hexsha stringlengths 40 40 | repo stringlengths 7 114 | path stringlengths 4 124 | license listlengths 1 9 | language stringclasses 1
value | identifier stringlengths 1 71 | return_type stringlengths 1 749 ⌀ | original_string stringlengths 76 22.7k | original_docstring stringlengths 16 7.61k | docstring stringlengths 16 2.47k | docstring_tokens listlengths 6 477 | code stringlengths 14 10.2k | code_tokens listlengths 6 996 | short_docstring stringlengths 2 644 | short_docstring_tokens listlengths 1 116 | comment listlengths 1 89 | parameters listlengths 0 64 | docstring_params dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
070f0aee3d21e264774ec5b12c3f104a6de7d7e9 | shambo001/peat | pKaTool/pKaIO.py | [
"MIT"
] | Python | write_pdb2pka_matrix | <not_specific> | def write_pdb2pka_matrix(self,filename,matrix):
"""Write an interaction energy matrix in pdb2pka format"""
"""At the moment, we just reformat and write a WHAT IF file"""
self.matrix={}
for group1 in matrix.keys():
self.matrix[group1.uniqueid]={}
for tit1 in matrix... | Write an interaction energy matrix in pdb2pka format | Write an interaction energy matrix in pdb2pka format | [
"Write",
"an",
"interaction",
"energy",
"matrix",
"in",
"pdb2pka",
"format"
] | def write_pdb2pka_matrix(self,filename,matrix):
self.matrix={}
for group1 in matrix.keys():
self.matrix[group1.uniqueid]={}
for tit1 in matrix[group1].keys():
for state1 in matrix[group1][tit1].keys():
sub_m=matrix[group1][tit1][state1]
... | [
"def",
"write_pdb2pka_matrix",
"(",
"self",
",",
"filename",
",",
"matrix",
")",
":",
"\"\"\"At the moment, we just reformat and write a WHAT IF file\"\"\"",
"self",
".",
"matrix",
"=",
"{",
"}",
"for",
"group1",
"in",
"matrix",
".",
"keys",
"(",
")",
":",
"self",... | Write an interaction energy matrix in pdb2pka format | [
"Write",
"an",
"interaction",
"energy",
"matrix",
"in",
"pdb2pka",
"format"
] | [
"\"\"\"Write an interaction energy matrix in pdb2pka format\"\"\"",
"\"\"\"At the moment, we just reformat and write a WHAT IF file\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "filename",
"type": null
},
{
"param": "matrix",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filename",
"type": null,
"docstring": null,
"docstring_tokens... |
070f0aee3d21e264774ec5b12c3f104a6de7d7e9 | shambo001/peat | pKaTool/pKaIO.py | [
"MIT"
] | Python | read_WIfile | <not_specific> | def read_WIfile(self,lines,dict,format):
"""
# Read a DESOLV file or a BACKGR file
"""
import string
x=1
done=None
Nterm=0
while not done:
x=x+1
#
# Read first line for this residue
#
term=None
... |
# Read a DESOLV file or a BACKGR file
| Read a DESOLV file or a BACKGR file | [
"Read",
"a",
"DESOLV",
"file",
"or",
"a",
"BACKGR",
"file"
] | def read_WIfile(self,lines,dict,format):
import string
x=1
done=None
Nterm=0
while not done:
x=x+1
Read first line for this residue
term=None
if lines[x].strip()=='TERMINAL GROUP:':
Nterm=abs(Nterm-1)
... | [
"def",
"read_WIfile",
"(",
"self",
",",
"lines",
",",
"dict",
",",
"format",
")",
":",
"import",
"string",
"x",
"=",
"1",
"done",
"=",
"None",
"Nterm",
"=",
"0",
"while",
"not",
"done",
":",
"x",
"=",
"x",
"+",
"1",
"term",
"=",
"None",
"if",
"... | Read a DESOLV file or a BACKGR file | [
"Read",
"a",
"DESOLV",
"file",
"or",
"a",
"BACKGR",
"file"
] | [
"\"\"\"\n # Read a DESOLV file or a BACKGR file\n \"\"\"",
"#",
"# Read first line for this residue",
"#",
"#",
"# Replace the residue name by the terminal name",
"#",
"#"
] | [
{
"param": "self",
"type": null
},
{
"param": "lines",
"type": null
},
{
"param": "dict",
"type": null
},
{
"param": "format",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "lines",
"type": null,
"docstring": null,
"docstring_tokens": ... |
070f0aee3d21e264774ec5b12c3f104a6de7d7e9 | shambo001/peat | pKaTool/pKaIO.py | [
"MIT"
] | Python | write_pKacoop_submission | <not_specific> | def write_pKacoop_submission(self,filename='submit.pkac',prediction_name='TEST',groups=[]):
"""Write a submission file for the pKa cooperative"""
if groups==[]:
return
groups.sort()
tcs=self.readtitcurv()
fd=open(filename,'w')
for group in groups:
... | Write a submission file for the pKa cooperative | Write a submission file for the pKa cooperative | [
"Write",
"a",
"submission",
"file",
"for",
"the",
"pKa",
"cooperative"
] | def write_pKacoop_submission(self,filename='submit.pkac',prediction_name='TEST',groups=[]):
if groups==[]:
return
groups.sort()
tcs=self.readtitcurv()
fd=open(filename,'w')
for group in groups:
fd.write('PREDICTION: %s\n' %prediction_name)
numb... | [
"def",
"write_pKacoop_submission",
"(",
"self",
",",
"filename",
"=",
"'submit.pkac'",
",",
"prediction_name",
"=",
"'TEST'",
",",
"groups",
"=",
"[",
"]",
")",
":",
"if",
"groups",
"==",
"[",
"]",
":",
"return",
"groups",
".",
"sort",
"(",
")",
"tcs",
... | Write a submission file for the pKa cooperative | [
"Write",
"a",
"submission",
"file",
"for",
"the",
"pKa",
"cooperative"
] | [
"\"\"\"Write a submission file for the pKa cooperative\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "filename",
"type": null
},
{
"param": "prediction_name",
"type": null
},
{
"param": "groups",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filename",
"type": null,
"docstring": null,
"docstring_tokens... |
070f0aee3d21e264774ec5b12c3f104a6de7d7e9 | shambo001/peat | pKaTool/pKaIO.py | [
"MIT"
] | Python | WI_res_text | <not_specific> | def WI_res_text(self,residue,format):
"""Constructs the WHAT IF residue ID line
f.ex. 1 LYS ( 1 ) from 0001LYS.
Function works with new names."""
if format=='WHAT IF':
if not self.newname:
# Old names
import string
terminal=... | Constructs the WHAT IF residue ID line
f.ex. 1 LYS ( 1 ) from 0001LYS.
Function works with new names. | Constructs the WHAT IF residue ID line
f.ex. | [
"Constructs",
"the",
"WHAT",
"IF",
"residue",
"ID",
"line",
"f",
".",
"ex",
"."
] | def WI_res_text(self,residue,format):
if format=='WHAT IF':
if not self.newname:
import string
terminal=None
if residue[0]=="T":
terminal=1
residue=residue[1:]
number=string.atoi(residue[:4])
... | [
"def",
"WI_res_text",
"(",
"self",
",",
"residue",
",",
"format",
")",
":",
"if",
"format",
"==",
"'WHAT IF'",
":",
"if",
"not",
"self",
".",
"newname",
":",
"import",
"string",
"terminal",
"=",
"None",
"if",
"residue",
"[",
"0",
"]",
"==",
"\"T\"",
... | Constructs the WHAT IF residue ID line
f.ex. | [
"Constructs",
"the",
"WHAT",
"IF",
"residue",
"ID",
"line",
"f",
".",
"ex",
"."
] | [
"\"\"\"Constructs the WHAT IF residue ID line\n f.ex. 1 LYS ( 1 ) from 0001LYS.\n Function works with new names.\"\"\"",
"# Old names",
"#",
"# New names",
"#",
"#",
"# PDB2PKA format",
"#",
"#",
"#",
"# For Design_pKa",
"#",
"#"
] | [
{
"param": "self",
"type": null
},
{
"param": "residue",
"type": null
},
{
"param": "format",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "residue",
"type": null,
"docstring": null,
"docstring_tokens"... |
2992f5738c56e283eb131387d23427da2f3817a8 | shambo001/peat | PEATDB/TableFormula.py | [
"MIT"
] | Python | isFormula | <not_specific> | def isFormula(cls, rec):
"""Evaluate the cell and return true if its a formula"""
isform = False
if type(rec) is DictType:
if rec.has_key('formula'):
isform = True
return isform | Evaluate the cell and return true if its a formula | Evaluate the cell and return true if its a formula | [
"Evaluate",
"the",
"cell",
"and",
"return",
"true",
"if",
"its",
"a",
"formula"
] | def isFormula(cls, rec):
isform = False
if type(rec) is DictType:
if rec.has_key('formula'):
isform = True
return isform | [
"def",
"isFormula",
"(",
"cls",
",",
"rec",
")",
":",
"isform",
"=",
"False",
"if",
"type",
"(",
"rec",
")",
"is",
"DictType",
":",
"if",
"rec",
".",
"has_key",
"(",
"'formula'",
")",
":",
"isform",
"=",
"True",
"return",
"isform"
] | Evaluate the cell and return true if its a formula | [
"Evaluate",
"the",
"cell",
"and",
"return",
"true",
"if",
"its",
"a",
"formula"
] | [
"\"\"\"Evaluate the cell and return true if its a formula\"\"\""
] | [
{
"param": "cls",
"type": null
},
{
"param": "rec",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "cls",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "rec",
"type": null,
"docstring": null,
"docstring_tokens": [],... |
2992f5738c56e283eb131387d23427da2f3817a8 | shambo001/peat | PEATDB/TableFormula.py | [
"MIT"
] | Python | readExpression | <not_specific> | def readExpression(cls, expr):
"""Get the operands and operators into lists from a string expression"""
ops = []
vals = []
p = re.compile('[()*/+-]')
x = p.split(expr)
ops = p.findall(expr)
#print expr, ops
for i in x:
if i ==... | Get the operands and operators into lists from a string expression | Get the operands and operators into lists from a string expression | [
"Get",
"the",
"operands",
"and",
"operators",
"into",
"lists",
"from",
"a",
"string",
"expression"
] | def readExpression(cls, expr):
ops = []
vals = []
p = re.compile('[()*/+-]')
x = p.split(expr)
ops = p.findall(expr)
for i in x:
if i == '':
vals.append(i)
else:
vals.append(eval(i))
... | [
"def",
"readExpression",
"(",
"cls",
",",
"expr",
")",
":",
"ops",
"=",
"[",
"]",
"vals",
"=",
"[",
"]",
"p",
"=",
"re",
".",
"compile",
"(",
"'[()*/+-]'",
")",
"x",
"=",
"p",
".",
"split",
"(",
"expr",
")",
"ops",
"=",
"p",
".",
"findall",
"... | Get the operands and operators into lists from a string expression | [
"Get",
"the",
"operands",
"and",
"operators",
"into",
"lists",
"from",
"a",
"string",
"expression"
] | [
"\"\"\"Get the operands and operators into lists from a string expression\"\"\"",
"#print expr, ops",
"#print ops, vals"
] | [
{
"param": "cls",
"type": null
},
{
"param": "expr",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "cls",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "expr",
"type": null,
"docstring": null,
"docstring_tokens": []... |
2992f5738c56e283eb131387d23427da2f3817a8 | shambo001/peat | PEATDB/TableFormula.py | [
"MIT"
] | Python | doExpression | <not_specific> | def doExpression(cls, vals, ops, getvalues=True):
"""Create an expression string from provided operands and operators"""
expr = ''
if getvalues == True:
for i in range(len(vals)):
if vals[i] != '':
vals[i] = float(vals[i])
if len(ops)>len(v... | Create an expression string from provided operands and operators | Create an expression string from provided operands and operators | [
"Create",
"an",
"expression",
"string",
"from",
"provided",
"operands",
"and",
"operators"
] | def doExpression(cls, vals, ops, getvalues=True):
expr = ''
if getvalues == True:
for i in range(len(vals)):
if vals[i] != '':
vals[i] = float(vals[i])
if len(ops)>len(vals):
while len(ops):
expr += ops.pop(... | [
"def",
"doExpression",
"(",
"cls",
",",
"vals",
",",
"ops",
",",
"getvalues",
"=",
"True",
")",
":",
"expr",
"=",
"''",
"if",
"getvalues",
"==",
"True",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"vals",
")",
")",
":",
"if",
"vals",
"[",
... | Create an expression string from provided operands and operators | [
"Create",
"an",
"expression",
"string",
"from",
"provided",
"operands",
"and",
"operators"
] | [
"\"\"\"Create an expression string from provided operands and operators\"\"\"",
"#use lists as queues",
"#use lists as queues"
] | [
{
"param": "cls",
"type": null
},
{
"param": "vals",
"type": null
},
{
"param": "ops",
"type": null
},
{
"param": "getvalues",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "cls",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "vals",
"type": null,
"docstring": null,
"docstring_tokens": []... |
2992f5738c56e283eb131387d23427da2f3817a8 | shambo001/peat | PEATDB/TableFormula.py | [
"MIT"
] | Python | doFormula | <not_specific> | def doFormula(cls, cellformula, data):
"""Evaluate the formula for a cell and return the result
takes a formula dict or just the string as input"""
if type(cellformula) is DictType:
cellformula = cellformula['formula']
vals = []
cells, ops = cls.re... | Evaluate the formula for a cell and return the result
takes a formula dict or just the string as input | Evaluate the formula for a cell and return the result
takes a formula dict or just the string as input | [
"Evaluate",
"the",
"formula",
"for",
"a",
"cell",
"and",
"return",
"the",
"result",
"takes",
"a",
"formula",
"dict",
"or",
"just",
"the",
"string",
"as",
"input"
] | def doFormula(cls, cellformula, data):
if type(cellformula) is DictType:
cellformula = cellformula['formula']
vals = []
cells, ops = cls.readExpression(cellformula)
for i in cells:
if type(i) is ListType:
recname, col= i
if ... | [
"def",
"doFormula",
"(",
"cls",
",",
"cellformula",
",",
"data",
")",
":",
"if",
"type",
"(",
"cellformula",
")",
"is",
"DictType",
":",
"cellformula",
"=",
"cellformula",
"[",
"'formula'",
"]",
"vals",
"=",
"[",
"]",
"cells",
",",
"ops",
"=",
"cls",
... | Evaluate the formula for a cell and return the result
takes a formula dict or just the string as input | [
"Evaluate",
"the",
"formula",
"for",
"a",
"cell",
"and",
"return",
"the",
"result",
"takes",
"a",
"formula",
"dict",
"or",
"just",
"the",
"string",
"as",
"input"
] | [
"\"\"\"Evaluate the formula for a cell and return the result\n takes a formula dict or just the string as input\"\"\"",
"#get cell records into their values",
"#recursive",
"#print vals, ops",
"#print 'expr', expr "
] | [
{
"param": "cls",
"type": null
},
{
"param": "cellformula",
"type": null
},
{
"param": "data",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "cls",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "cellformula",
"type": null,
"docstring": null,
"docstring_toke... |
9b43e12b92292c3151c7657a4a89d0860942d5b8 | shambo001/peat | sandbox/ProteinComplexTool_parallel.py | [
"MIT"
] | Python | DeltaStability | <not_specific> | def DeltaStability(self,inputFile, mutationList, configurationFile, workingDirectory, outputDirectory):
'''Calculates the stability difference between a protein and set of mutants
Parameters:
inputFile: A PDB file of the protein
mutationList... | Calculates the stability difference between a protein and set of mutants
Parameters:
inputFile: A PDB file of the protein
mutationList: A list of Data.MutationSet instances. Each represents a mutant of the protein.
configurationFile: The location ... | Calculates the stability difference between a protein and set of mutants | [
"Calculates",
"the",
"stability",
"difference",
"between",
"a",
"protein",
"and",
"set",
"of",
"mutants"
] | def DeltaStability(self,inputFile, mutationList, configurationFile, workingDirectory, outputDirectory):
tool = Core.ProteinDesignTool.ProteinDesignTool(configurationFile,
workingDirectory=workingDirectory,
pdbFile=inputFile,
... | [
"def",
"DeltaStability",
"(",
"self",
",",
"inputFile",
",",
"mutationList",
",",
"configurationFile",
",",
"workingDirectory",
",",
"outputDirectory",
")",
":",
"tool",
"=",
"Core",
".",
"ProteinDesignTool",
".",
"ProteinDesignTool",
"(",
"configurationFile",
",",
... | Calculates the stability difference between a protein and set of mutants | [
"Calculates",
"the",
"stability",
"difference",
"between",
"a",
"protein",
"and",
"set",
"of",
"mutants"
] | [
"'''Calculates the stability difference between a protein and set of mutants\n\n Parameters:\n inputFile: A PDB file of the protein\n mutationList: A list of Data.MutationSet instances. Each represents a mutant of the protein.\n configurationFile: ... | [
{
"param": "self",
"type": null
},
{
"param": "inputFile",
"type": null
},
{
"param": "mutationList",
"type": null
},
{
"param": "configurationFile",
"type": null
},
{
"param": "workingDirectory",
"type": null
},
{
"param": "outputDirectory",
"type... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "inputFile",
"type": null,
"docstring": "A PDB file of the protein",... |
d400015a960a22538cb79f5a1508361ea6936671 | shambo001/peat | pKaTool/multiple_calc_analysis.py | [
"MIT"
] | Python | save_sequences | <not_specific> | def save_sequences(self):
"""Save all sequences in a single PIR file for an alignment program"""
#
# Just do it
#
import tkFileDialog, os, pickle
savedir=os.getcwd()
filename=tkFileDialog.asksaveasfilename(defaultextension=".pir",
... | Save all sequences in a single PIR file for an alignment program | Save all sequences in a single PIR file for an alignment program | [
"Save",
"all",
"sequences",
"in",
"a",
"single",
"PIR",
"file",
"for",
"an",
"alignment",
"program"
] | def save_sequences(self):
Just do it
import tkFileDialog, os, pickle
savedir=os.getcwd()
filename=tkFileDialog.asksaveasfilename(defaultextension=".pir",
initialfile='sequences.pir',
initiald... | [
"def",
"save_sequences",
"(",
"self",
")",
":",
"import",
"tkFileDialog",
",",
"os",
",",
"pickle",
"savedir",
"=",
"os",
".",
"getcwd",
"(",
")",
"filename",
"=",
"tkFileDialog",
".",
"asksaveasfilename",
"(",
"defaultextension",
"=",
"\".pir\"",
",",
"init... | Save all sequences in a single PIR file for an alignment program | [
"Save",
"all",
"sequences",
"in",
"a",
"single",
"PIR",
"file",
"for",
"an",
"alignment",
"program"
] | [
"\"\"\"Save all sequences in a single PIR file for an alignment program\"\"\"",
"#",
"# Just do it",
"#"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
d400015a960a22538cb79f5a1508361ea6936671 | shambo001/peat | pKaTool/multiple_calc_analysis.py | [
"MIT"
] | Python | colour_dpKa | <not_specific> | def colour_dpKa(self,calc,resnum,restype):
"""Colour as a function of dpKa"""
resid=resnum+':'+restype
if calc['pkavals'].has_key(resid):
dpka=calc['pkavals'][resid]['pKa']
if dpka:
dpka=dpka-calc['pkavals'][resid]['modelpK']
else:
... | Colour as a function of dpKa | Colour as a function of dpKa | [
"Colour",
"as",
"a",
"function",
"of",
"dpKa"
] | def colour_dpKa(self,calc,resnum,restype):
resid=resnum+':'+restype
if calc['pkavals'].has_key(resid):
dpka=calc['pkavals'][resid]['pKa']
if dpka:
dpka=dpka-calc['pkavals'][resid]['modelpK']
else:
dpka=None
return dpka
... | [
"def",
"colour_dpKa",
"(",
"self",
",",
"calc",
",",
"resnum",
",",
"restype",
")",
":",
"resid",
"=",
"resnum",
"+",
"':'",
"+",
"restype",
"if",
"calc",
"[",
"'pkavals'",
"]",
".",
"has_key",
"(",
"resid",
")",
":",
"dpka",
"=",
"calc",
"[",
"'pk... | Colour as a function of dpKa | [
"Colour",
"as",
"a",
"function",
"of",
"dpKa"
] | [
"\"\"\"Colour as a function of dpKa\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "calc",
"type": null
},
{
"param": "resnum",
"type": null
},
{
"param": "restype",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "calc",
"type": null,
"docstring": null,
"docstring_tokens": [... |
d400015a960a22538cb79f5a1508361ea6936671 | shambo001/peat | pKaTool/multiple_calc_analysis.py | [
"MIT"
] | Python | display_sequence | <not_specific> | def display_sequence(self,calculation,calculation_name,seq_num,alignedseq=None):
"""Display a single sequence in the window"""
y_spacing=15
y=20+seq_num*y_spacing
x_start=100
spacing=9
count=0
display_count=0
aligncount=0
self.canv.create_text(0,y,... | Display a single sequence in the window | Display a single sequence in the window | [
"Display",
"a",
"single",
"sequence",
"in",
"the",
"window"
] | def display_sequence(self,calculation,calculation_name,seq_num,alignedseq=None):
y_spacing=15
y=20+seq_num*y_spacing
x_start=100
spacing=9
count=0
display_count=0
aligncount=0
self.canv.create_text(0,y,text=calculation_name,anchor='nw')
for aanum,r... | [
"def",
"display_sequence",
"(",
"self",
",",
"calculation",
",",
"calculation_name",
",",
"seq_num",
",",
"alignedseq",
"=",
"None",
")",
":",
"y_spacing",
"=",
"15",
"y",
"=",
"20",
"+",
"seq_num",
"*",
"y_spacing",
"x_start",
"=",
"100",
"spacing",
"=",
... | Display a single sequence in the window | [
"Display",
"a",
"single",
"sequence",
"in",
"the",
"window"
] | [
"\"\"\"Display a single sequence in the window\"\"\"",
"#",
"# If we have an alignment then skip forward until we have a residue",
"#",
"#print alignedseq[aligncount],aa1,count,aligncount",
"#print alignedseq[aligncount]",
"#print alignedseq",
"#print calculation['sequence']",
"#print 'scanning, ali... | [
{
"param": "self",
"type": null
},
{
"param": "calculation",
"type": null
},
{
"param": "calculation_name",
"type": null
},
{
"param": "seq_num",
"type": null
},
{
"param": "alignedseq",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "calculation",
"type": null,
"docstring": null,
"docstring_tok... |
9909a257de4d11e3ec03c2b56467b73e60beb08f | shambo001/peat | Ghost/make_figs_helper.py | [
"MIT"
] | Python | error_size | <not_specific> | def error_size(options):
"""Unused code for looking at the size of errorrs"""
#
# Split into large and small errors
#
sxs=[]
sys=[]
serr=[]
bxs=[]
bys=[]
berr=[]
calc_bigerr=[]
calc_small_err=[]
for count in range(len(xs)):
x=xs[count]
y=ys[count]
... | Unused code for looking at the size of errorrs | Unused code for looking at the size of errorrs | [
"Unused",
"code",
"for",
"looking",
"at",
"the",
"size",
"of",
"errorrs"
] | def error_size(options):
Split into large and small errors
sxs=[]
sys=[]
serr=[]
bxs=[]
bys=[]
berr=[]
calc_bigerr=[]
calc_small_err=[]
for count in range(len(xs)):
x=xs[count]
y=ys[count]
err=experrors[count]
c_err=calcerrors[count]
diff=... | [
"def",
"error_size",
"(",
"options",
")",
":",
"sxs",
"=",
"[",
"]",
"sys",
"=",
"[",
"]",
"serr",
"=",
"[",
"]",
"bxs",
"=",
"[",
"]",
"bys",
"=",
"[",
"]",
"berr",
"=",
"[",
"]",
"calc_bigerr",
"=",
"[",
"]",
"calc_small_err",
"=",
"[",
"]"... | Unused code for looking at the size of errorrs | [
"Unused",
"code",
"for",
"looking",
"at",
"the",
"size",
"of",
"errorrs"
] | [
"\"\"\"Unused code for looking at the size of errorrs\"\"\"",
"#",
"# Split into large and small errors",
"#",
"#",
"# Plot",
"#",
"#",
"# Reformat the residues info",
"#",
"#",
"# Find the worst predictions",
"#",
"#Y=Yasara.yasara_handler()",
"#obj=Y.load_mol('2LZT.pdb')",
"#Y.yasara... | [
{
"param": "options",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "options",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9909a257de4d11e3ec03c2b56467b73e60beb08f | shambo001/peat | Ghost/make_figs_helper.py | [
"MIT"
] | Python | score_ghosts | <not_specific> | def score_ghosts(self,calc_ghosts):
"""Score all the calculated ghosts given"""
big_satisfied={}
atom=options.atom
big_satisfied[atom]={}
xs=[]
ys=[]
experrors=[]
#
for tg in sorted(self.exp_ghosts.keys()):
big_satisfied[atom][tg]={}
... | Score all the calculated ghosts given | Score all the calculated ghosts given | [
"Score",
"all",
"the",
"calculated",
"ghosts",
"given"
] | def score_ghosts(self,calc_ghosts):
big_satisfied={}
atom=options.atom
big_satisfied[atom]={}
xs=[]
ys=[]
experrors=[]
for tg in sorted(self.exp_ghosts.keys()):
big_satisfied[atom][tg]={}
for residue in sorted(self.exp_ghosts[tg].keys()):
... | [
"def",
"score_ghosts",
"(",
"self",
",",
"calc_ghosts",
")",
":",
"big_satisfied",
"=",
"{",
"}",
"atom",
"=",
"options",
".",
"atom",
"big_satisfied",
"[",
"atom",
"]",
"=",
"{",
"}",
"xs",
"=",
"[",
"]",
"ys",
"=",
"[",
"]",
"experrors",
"=",
"["... | Score all the calculated ghosts given | [
"Score",
"all",
"the",
"calculated",
"ghosts",
"given"
] | [
"\"\"\"Score all the calculated ghosts given\"\"\"",
"#",
"#",
"# Exclude this residue for this tg?",
"#",
"#",
"# Get the experimental values and its error",
"#",
"#",
"# Get calculated value and score it",
"#",
"#",
"#"
] | [
{
"param": "self",
"type": null
},
{
"param": "calc_ghosts",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "calc_ghosts",
"type": null,
"docstring": null,
"docstring_tok... |
9909a257de4d11e3ec03c2b56467b73e60beb08f | shambo001/peat | Ghost/make_figs_helper.py | [
"MIT"
] | Python | cubescanplot | <not_specific> | def cubescanplot(options):
"""Read a cubescan output file and show the results"""
fd=open(options.cubescanfile)
import pickle
data=pickle.load(fd)
fd.close()
#
cubegrid=data[0]
scanresults=data[1]
#
# Instantiate scoring class
#
SC=score_class(options)
#
# Score t... | Read a cubescan output file and show the results | Read a cubescan output file and show the results | [
"Read",
"a",
"cubescan",
"output",
"file",
"and",
"show",
"the",
"results"
] | def cubescanplot(options):
fd=open(options.cubescanfile)
import pickle
data=pickle.load(fd)
fd.close()
cubegrid=data[0]
scanresults=data[1]
Instantiate scoring class
SC=score_class(options)
Score the ghosts from each cubescan
scores=[]
for cube in sorted(scanresults.keys())... | [
"def",
"cubescanplot",
"(",
"options",
")",
":",
"fd",
"=",
"open",
"(",
"options",
".",
"cubescanfile",
")",
"import",
"pickle",
"data",
"=",
"pickle",
".",
"load",
"(",
"fd",
")",
"fd",
".",
"close",
"(",
")",
"cubegrid",
"=",
"data",
"[",
"0",
"... | Read a cubescan output file and show the results | [
"Read",
"a",
"cubescan",
"output",
"file",
"and",
"show",
"the",
"results"
] | [
"\"\"\"Read a cubescan output file and show the results\"\"\"",
"#",
"#",
"# Instantiate scoring class",
"#",
"#",
"# Score the ghosts from each cubescan",
"#",
"#import pylab",
"#pylab.errorbar(xs,ys,xerr=experrors,fmt='ro')",
"#pylab.plot(xs,xs,'g-')",
"#pylab.xlabel('Experimental dCS')",
... | [
{
"param": "options",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "options",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9909a257de4d11e3ec03c2b56467b73e60beb08f | shambo001/peat | Ghost/make_figs_helper.py | [
"MIT"
] | Python | heatmap | <not_specific> | def heatmap():
"""|Make a heatmap - not sure what this function does..."""
data=getdata()
TGs=sorted(data.keys())
for titgroup in TGs:
thisN=[]
thisH=[]
for residue in sorted(data[titgroup].keys()):
Hval=0.0
Nval=0.0
for atom in ['H','N']:
... | |Make a heatmap - not sure what this function does... | |Make a heatmap - not sure what this function does | [
"|Make",
"a",
"heatmap",
"-",
"not",
"sure",
"what",
"this",
"function",
"does"
] | def heatmap():
data=getdata()
TGs=sorted(data.keys())
for titgroup in TGs:
thisN=[]
thisH=[]
for residue in sorted(data[titgroup].keys()):
Hval=0.0
Nval=0.0
for atom in ['H','N']:
if data[titgroup][residue].has_key(atom):
... | [
"def",
"heatmap",
"(",
")",
":",
"data",
"=",
"getdata",
"(",
")",
"TGs",
"=",
"sorted",
"(",
"data",
".",
"keys",
"(",
")",
")",
"for",
"titgroup",
"in",
"TGs",
":",
"thisN",
"=",
"[",
"]",
"thisH",
"=",
"[",
"]",
"for",
"residue",
"in",
"sort... | |Make a heatmap - not sure what this function does... | [
"|Make",
"a",
"heatmap",
"-",
"not",
"sure",
"what",
"this",
"function",
"does",
"..."
] | [
"\"\"\"|Make a heatmap - not sure what this function does...\"\"\"",
"#",
"# -----",
"#",
"#",
"#",
"#",
"#",
"#",
"#"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | ResidueCodeCompare | <not_specific> | def ResidueCodeCompare(residue1, residue2):
'''Compares two residue codes which have the form ChainID:ResidueNumber
Note: Actually can compare any code where the components are separated by colons
and the second element is the residue number
Also note this does not take into accound possible different chain ids... | Compares two residue codes which have the form ChainID:ResidueNumber
Note: Actually can compare any code where the components are separated by colons
and the second element is the residue number
Also note this does not take into accound possible different chain ids.
Returns an integer - Meaning is the same as ... | Compares two residue codes which have the form ChainID:ResidueNumber
Note: Actually can compare any code where the components are separated by colons
and the second element is the residue number
Also note this does not take into accound possible different chain ids.
Returns an integer - Meaning is the same as the inbu... | [
"Compares",
"two",
"residue",
"codes",
"which",
"have",
"the",
"form",
"ChainID",
":",
"ResidueNumber",
"Note",
":",
"Actually",
"can",
"compare",
"any",
"code",
"where",
"the",
"components",
"are",
"separated",
"by",
"colons",
"and",
"the",
"second",
"element... | def ResidueCodeCompare(residue1, residue2):
residue1 = int(residue1.split(':')[1])
residue2 = int(residue2.split(':')[1])
if residue1 > residue2:
return 1
elif residue1 < residue2:
return -1
else:
return 0 | [
"def",
"ResidueCodeCompare",
"(",
"residue1",
",",
"residue2",
")",
":",
"residue1",
"=",
"int",
"(",
"residue1",
".",
"split",
"(",
"':'",
")",
"[",
"1",
"]",
")",
"residue2",
"=",
"int",
"(",
"residue2",
".",
"split",
"(",
"':'",
")",
"[",
"1",
"... | Compares two residue codes which have the form ChainID:ResidueNumber
Note: Actually can compare any code where the components are separated by colons
and the second element is the residue number
Also note this does not take into accound possible different chain ids. | [
"Compares",
"two",
"residue",
"codes",
"which",
"have",
"the",
"form",
"ChainID",
":",
"ResidueNumber",
"Note",
":",
"Actually",
"can",
"compare",
"any",
"code",
"where",
"the",
"components",
"are",
"separated",
"by",
"colons",
"and",
"the",
"second",
"element... | [
"'''Compares two residue codes which have the form ChainID:ResidueNumber\n\t\n\tNote: Actually can compare any code where the components are separated by colons\n\tand the second element is the residue number\n\tAlso note this does not take into accound possible different chain ids.\n\t\t\n\tReturns an integer - Me... | [
{
"param": "residue1",
"type": null
},
{
"param": "residue2",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "residue1",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "residue2",
"type": null,
"docstring": null,
"docstring_to... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | scannerUsingStoredConfiguration | <not_specific> | def scannerUsingStoredConfiguration(filename):
'''Creates a new Scanner object using configuration information stored in a file
Parameters:
filename: The name of a file containing a scan options
Exceptions:
ConfigurationError: If the file isn't a valid configurationFile'''
configuration = Environment.... | Creates a new Scanner object using configuration information stored in a file
Parameters:
filename: The name of a file containing a scan options
Exceptions:
ConfigurationError: If the file isn't a valid configurationFile | Creates a new Scanner object using configuration information stored in a file | [
"Creates",
"a",
"new",
"Scanner",
"object",
"using",
"configuration",
"information",
"stored",
"in",
"a",
"file"
] | def scannerUsingStoredConfiguration(filename):
configuration = Environment.Configuration(filename)
return Scanner(configuration) | [
"def",
"scannerUsingStoredConfiguration",
"(",
"filename",
")",
":",
"configuration",
"=",
"Environment",
".",
"Configuration",
"(",
"filename",
")",
"return",
"Scanner",
"(",
"configuration",
")"
] | Creates a new Scanner object using configuration information stored in a file | [
"Creates",
"a",
"new",
"Scanner",
"object",
"using",
"configuration",
"information",
"stored",
"in",
"a",
"file"
] | [
"'''Creates a new Scanner object using configuration information stored in a file\n\t\n\tParameters: \n\t\tfilename: The name of a file containing a scan options\n\t\t\t\t\n\tExceptions:\n\t\tConfigurationError: If the file isn't a valid configurationFile'''"
] | [
{
"param": "filename",
"type": null
}
] | {
"returns": [],
"raises": [
{
"docstring": "If the file isn't a valid configurationFile",
"docstring_tokens": [
"If",
"the",
"file",
"isn",
"'",
"t",
"a",
"valid",
"configurationFile"
],
"type": "ConfigurationError"... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | run | null | def run(self, cleanPDB=True):
'''Runs the pKa calculation. This method does not return until the run is finished which may take some time.
Parameters:
cleanPDB - If True the all waters and ligands are removed from the pdbfile before the run.
Default is True.'''
#Import these here rather than at the ... | Runs the pKa calculation. This method does not return until the run is finished which may take some time.
Parameters:
cleanPDB - If True the all waters and ligands are removed from the pdbfile before the run.
Default is True. | Runs the pKa calculation. This method does not return until the run is finished which may take some time.
Parameters:
cleanPDB - If True the all waters and ligands are removed from the pdbfile before the run.
Default is True. | [
"Runs",
"the",
"pKa",
"calculation",
".",
"This",
"method",
"does",
"not",
"return",
"until",
"the",
"run",
"is",
"finished",
"which",
"may",
"take",
"some",
"time",
".",
"Parameters",
":",
"cleanPDB",
"-",
"If",
"True",
"the",
"all",
"waters",
"and",
"l... | def run(self, cleanPDB=True):
import pKarun.pKarun_base
standardOut = sys.stdout
scanLogFile = os.path.join(self.outputDirectory, '%s%d.log' % (os.path.split(self.pdbFile)[1], self.environment.rank()))
scanLogStream = open(scanLogFile, 'w', 1)
sys.stdout = scanLogStream
standardOut.write('[PKA CALC] Setting... | [
"def",
"run",
"(",
"self",
",",
"cleanPDB",
"=",
"True",
")",
":",
"import",
"pKarun",
".",
"pKarun_base",
"standardOut",
"=",
"sys",
".",
"stdout",
"scanLogFile",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"outputDirectory",
",",
"'%s%d.log'... | Runs the pKa calculation. | [
"Runs",
"the",
"pKa",
"calculation",
"."
] | [
"'''Runs the pKa calculation. This method does not return until the run is finished which may take some time.\n\t\t\n\t\tParameters:\n\t\t\tcleanPDB - If True the all waters and ligands are removed from the pdbfile before the run.\n\t\t\t\tDefault is True.'''",
"#Import these here rather than at the top of the mo... | [
{
"param": "self",
"type": null
},
{
"param": "cleanPDB",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "cleanPDB",
"type": null,
"docstring": null,
"docstring_tokens... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | pdbFile | <not_specific> | def pdbFile(self):
'''Returns the path to the currently set pdb.
Exceptions -
Raises an ArgumentError if the specified pdbfile doesn't exist. '''
return self.pdbFile | Returns the path to the currently set pdb.
Exceptions -
Raises an ArgumentError if the specified pdbfile doesn't exist. | Returns the path to the currently set pdb.
Exceptions
Raises an ArgumentError if the specified pdbfile doesn't exist. | [
"Returns",
"the",
"path",
"to",
"the",
"currently",
"set",
"pdb",
".",
"Exceptions",
"Raises",
"an",
"ArgumentError",
"if",
"the",
"specified",
"pdbfile",
"doesn",
"'",
"t",
"exist",
"."
] | def pdbFile(self):
return self.pdbFile | [
"def",
"pdbFile",
"(",
"self",
")",
":",
"return",
"self",
".",
"pdbFile"
] | Returns the path to the currently set pdb. | [
"Returns",
"the",
"path",
"to",
"the",
"currently",
"set",
"pdb",
"."
] | [
"'''Returns the path to the currently set pdb.\n\t\t\n\t\tExceptions -\n\t\t\tRaises an ArgumentError if the specified pdbfile doesn't exist. '''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | configuration | <not_specific> | def configuration(self):
'''Returns a copy of the configuration object the instance is using'''
return copy.deepcopy(self.configuration) | Returns a copy of the configuration object the instance is using | Returns a copy of the configuration object the instance is using | [
"Returns",
"a",
"copy",
"of",
"the",
"configuration",
"object",
"the",
"instance",
"is",
"using"
] | def configuration(self):
return copy.deepcopy(self.configuration) | [
"def",
"configuration",
"(",
"self",
")",
":",
"return",
"copy",
".",
"deepcopy",
"(",
"self",
".",
"configuration",
")"
] | Returns a copy of the configuration object the instance is using | [
"Returns",
"a",
"copy",
"of",
"the",
"configuration",
"object",
"the",
"instance",
"is",
"using"
] | [
"'''Returns a copy of the configuration object the instance is using'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | workingDirectory | <not_specific> | def workingDirectory(self):
'''Returns the working directory object the instance is using'''
return self.workingDirectory | Returns the working directory object the instance is using | Returns the working directory object the instance is using | [
"Returns",
"the",
"working",
"directory",
"object",
"the",
"instance",
"is",
"using"
] | def workingDirectory(self):
return self.workingDirectory | [
"def",
"workingDirectory",
"(",
"self",
")",
":",
"return",
"self",
".",
"workingDirectory"
] | Returns the working directory object the instance is using | [
"Returns",
"the",
"working",
"directory",
"object",
"the",
"instance",
"is",
"using"
] | [
"'''Returns the working directory object the instance is using'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | absoluteStability | null | def absoluteStability(self, pdbFiles=[], verbose=False):
'''Calculates the absolute stability of a number of structures
FIXME: Incomplete'''
#If there are no compare pdbs supplied raise an exception
if len(pdbFiles) == 0:
raise Exceptions.StabilityError, "Unable to perform stability calculation - N... | Calculates the absolute stability of a number of structures
FIXME: Incomplete | Calculates the absolute stability of a number of structures
FIXME: Incomplete | [
"Calculates",
"the",
"absolute",
"stability",
"of",
"a",
"number",
"of",
"structures",
"FIXME",
":",
"Incomplete"
] | def absoluteStability(self, pdbFiles=[], verbose=False):
if len(pdbFiles) == 0:
raise Exceptions.StabilityError, "Unable to perform stability calculation - No files supplied"
runFile = os.path.join(self.directoryPath, "run%d.txt" % self.environment.rank())
outputFile = os.path.join(self.directoryPath, "output%... | [
"def",
"absoluteStability",
"(",
"self",
",",
"pdbFiles",
"=",
"[",
"]",
",",
"verbose",
"=",
"False",
")",
":",
"if",
"len",
"(",
"pdbFiles",
")",
"==",
"0",
":",
"raise",
"Exceptions",
".",
"StabilityError",
",",
"\"Unable to perform stability calculation - ... | Calculates the absolute stability of a number of structures
FIXME: Incomplete | [
"Calculates",
"the",
"absolute",
"stability",
"of",
"a",
"number",
"of",
"structures",
"FIXME",
":",
"Incomplete"
] | [
"'''Calculates the absolute stability of a number of structures\n\t\t\n\t\tFIXME: Incomplete'''",
"#If there are no compare pdbs supplied raise an exception",
"#The run file name",
"#The executable",
"#Force output of last print line - required when using \",\"",
"#Variables for informing user of progress... | [
{
"param": "self",
"type": null
},
{
"param": "pdbFiles",
"type": null
},
{
"param": "verbose",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pdbFiles",
"type": null,
"docstring": null,
"docstring_tokens... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | _chopDeltaStabilityResultLine | <not_specific> | def _chopDeltaStabilityResultLine(self, resultLine):
'''Chops the result line from a delta stability run and returns the essential information
Note: Private method for internal use only
Returns:
A list containing the stability information
'''
#Chop up the result
components = resultLine.split(... | Chops the result line from a delta stability run and returns the essential information
Note: Private method for internal use only
Returns:
A list containing the stability information
| Chops the result line from a delta stability run and returns the essential information
Note: Private method for internal use only | [
"Chops",
"the",
"result",
"line",
"from",
"a",
"delta",
"stability",
"run",
"and",
"returns",
"the",
"essential",
"information",
"Note",
":",
"Private",
"method",
"for",
"internal",
"use",
"only"
] | def _chopDeltaStabilityResultLine(self, resultLine):
components = resultLine.split(" ")
components.pop(0)
components = [element.strip() for element in components]
components = [element for element in components if element != "|" and element != ""]
components = [float(element) for element in components]
comp... | [
"def",
"_chopDeltaStabilityResultLine",
"(",
"self",
",",
"resultLine",
")",
":",
"components",
"=",
"resultLine",
".",
"split",
"(",
"\" \"",
")",
"components",
".",
"pop",
"(",
"0",
")",
"components",
"=",
"[",
"element",
".",
"strip",
"(",
")",
"for",
... | Chops the result line from a delta stability run and returns the essential information
Note: Private method for internal use only | [
"Chops",
"the",
"result",
"line",
"from",
"a",
"delta",
"stability",
"run",
"and",
"returns",
"the",
"essential",
"information",
"Note",
":",
"Private",
"method",
"for",
"internal",
"use",
"only"
] | [
"'''Chops the result line from a delta stability run and returns the essential information\n\t\t\n\t\tNote: Private method for internal use only\n\t\t\n\t\tReturns:\n\t\t\tA list containing the stability information\n\t\t\t'''",
"#Chop up the result",
"#Get rid of the pdb name which is the first string",
"#Th... | [
{
"param": "self",
"type": null
},
{
"param": "resultLine",
"type": null
}
] | {
"returns": [
{
"docstring": "A list containing the stability information",
"docstring_tokens": [
"A",
"list",
"containing",
"the",
"stability",
"information"
],
"type": null
}
],
"raises": [],
"params": [
{
"identifier":... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | _writeDeltaStabilityRunFile | null | def _writeDeltaStabilityRunFile(self, pdbOne, pdbTwo, filename=None):
'''Writes a input file for Uffbaps for comparing the stability of two proteins
Note: Private method for internal use only'''
#Create the run file
run = "load %s %s\n" % (pdbOne, pdbOne)
run = run + "load %s %s\n" % (pdbTwo, pdbTw... | Writes a input file for Uffbaps for comparing the stability of two proteins
Note: Private method for internal use only | Writes a input file for Uffbaps for comparing the stability of two proteins
Note: Private method for internal use only | [
"Writes",
"a",
"input",
"file",
"for",
"Uffbaps",
"for",
"comparing",
"the",
"stability",
"of",
"two",
"proteins",
"Note",
":",
"Private",
"method",
"for",
"internal",
"use",
"only"
] | def _writeDeltaStabilityRunFile(self, pdbOne, pdbTwo, filename=None):
run = "load %s %s\n" % (pdbOne, pdbOne)
run = run + "load %s %s\n" % (pdbTwo, pdbTwo)
run = run + "task msc {%s}{%s}\n" % (pdbOne, pdbTwo)
runStream = open(filename, 'w')
runStream.write(run)
runStream.close() | [
"def",
"_writeDeltaStabilityRunFile",
"(",
"self",
",",
"pdbOne",
",",
"pdbTwo",
",",
"filename",
"=",
"None",
")",
":",
"run",
"=",
"\"load %s %s\\n\"",
"%",
"(",
"pdbOne",
",",
"pdbOne",
")",
"run",
"=",
"run",
"+",
"\"load %s %s\\n\"",
"%",
"(",
"pdbTwo... | Writes a input file for Uffbaps for comparing the stability of two proteins
Note: Private method for internal use only | [
"Writes",
"a",
"input",
"file",
"for",
"Uffbaps",
"for",
"comparing",
"the",
"stability",
"of",
"two",
"proteins",
"Note",
":",
"Private",
"method",
"for",
"internal",
"use",
"only"
] | [
"'''Writes a input file for Uffbaps for comparing the stability of two proteins\n\t\t\n\t\t Note: Private method for internal use only'''",
"#Create the run file "
] | [
{
"param": "self",
"type": null
},
{
"param": "pdbOne",
"type": null
},
{
"param": "pdbTwo",
"type": null
},
{
"param": "filename",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pdbOne",
"type": null,
"docstring": null,
"docstring_tokens":... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | deltaStability | null | def deltaStability(self, comparePDBs=[], verbose=False):
'''Calculate the difference in stability between the source pdb and the compare pbds
Parameters
comparePDBs - A list of paths to PDB files.
All the pdbs in this list will be compared to the sourcePDB.
The names of the compare pdbs are expected... | Calculate the difference in stability between the source pdb and the compare pbds
Parameters
comparePDBs - A list of paths to PDB files.
All the pdbs in this list will be compared to the sourcePDB.
The names of the compare pdbs are expected to conform to the following
.....
(FIXME: Possibly only... | Calculate the difference in stability between the source pdb and the compare pbds
Parameters
comparePDBs - A list of paths to PDB files.
All the pdbs in this list will be compared to the sourcePDB.
The names of the compare pdbs are expected to conform to the following
(FIXME: Possibly only have to be of a certain form... | [
"Calculate",
"the",
"difference",
"in",
"stability",
"between",
"the",
"source",
"pdb",
"and",
"the",
"compare",
"pbds",
"Parameters",
"comparePDBs",
"-",
"A",
"list",
"of",
"paths",
"to",
"PDB",
"files",
".",
"All",
"the",
"pdbs",
"in",
"this",
"list",
"w... | def deltaStability(self, comparePDBs=[], verbose=False):
if len(comparePDBs) == 0:
raise Exceptions.StabilityError, "Unable to perform stability calculation - No mutants supplied"
pdbName = os.path.split(self.sourcePDB)[1]
components = os.path.splitext(pdbName)
if components[1] != 'pdb':
pdbName = '%s.pdb... | [
"def",
"deltaStability",
"(",
"self",
",",
"comparePDBs",
"=",
"[",
"]",
",",
"verbose",
"=",
"False",
")",
":",
"if",
"len",
"(",
"comparePDBs",
")",
"==",
"0",
":",
"raise",
"Exceptions",
".",
"StabilityError",
",",
"\"Unable to perform stability calculation... | Calculate the difference in stability between the source pdb and the compare pbds
Parameters
comparePDBs - A list of paths to PDB files. | [
"Calculate",
"the",
"difference",
"in",
"stability",
"between",
"the",
"source",
"pdb",
"and",
"the",
"compare",
"pbds",
"Parameters",
"comparePDBs",
"-",
"A",
"list",
"of",
"paths",
"to",
"PDB",
"files",
"."
] | [
"'''Calculate the difference in stability between the source pdb and the compare pbds\n\t\t\n\t\tParameters\n\t\t\tcomparePDBs - A list of paths to PDB files.\n\t\t\t\tAll the pdbs in this list will be compared to the sourcePDB.\n\t\t\t\tThe names of the compare pdbs are expected to conform to the following\n\t\t\t... | [
{
"param": "self",
"type": null
},
{
"param": "comparePDBs",
"type": null
},
{
"param": "verbose",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "comparePDBs",
"type": null,
"docstring": null,
"docstring_tok... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | _chopLigandResultLine | <not_specific> | def _chopLigandResultLine(self, resultLine):
'''Chops the result line from a binding run and returns the essential information
Note: Private method for internal use only
Returns:
A list containing the binding information'''
#Chop up the result
components = resultLine.split(" ")
#Get rid of t... | Chops the result line from a binding run and returns the essential information
Note: Private method for internal use only
Returns:
A list containing the binding information | Chops the result line from a binding run and returns the essential information
Note: Private method for internal use only | [
"Chops",
"the",
"result",
"line",
"from",
"a",
"binding",
"run",
"and",
"returns",
"the",
"essential",
"information",
"Note",
":",
"Private",
"method",
"for",
"internal",
"use",
"only"
] | def _chopLigandResultLine(self, resultLine):
components = resultLine.split(" ")
components.pop(0)
components = [element.strip() for element in components]
components = [element for element in components if element != "|" and element != ""]
components = [float(element) for element in components]
components.p... | [
"def",
"_chopLigandResultLine",
"(",
"self",
",",
"resultLine",
")",
":",
"components",
"=",
"resultLine",
".",
"split",
"(",
"\" \"",
")",
"components",
".",
"pop",
"(",
"0",
")",
"components",
"=",
"[",
"element",
".",
"strip",
"(",
")",
"for",
"elemen... | Chops the result line from a binding run and returns the essential information
Note: Private method for internal use only | [
"Chops",
"the",
"result",
"line",
"from",
"a",
"binding",
"run",
"and",
"returns",
"the",
"essential",
"information",
"Note",
":",
"Private",
"method",
"for",
"internal",
"use",
"only"
] | [
"'''Chops the result line from a binding run and returns the essential information\n\t\t\n\t\tNote: Private method for internal use only\n\t\t\n\t\tReturns:\n\t\t\tA list containing the binding information'''",
"#Chop up the result",
"#Get rid of the pdb name which is the first string",
"#Then make floats fr... | [
{
"param": "self",
"type": null
},
{
"param": "resultLine",
"type": null
}
] | {
"returns": [
{
"docstring": "A list containing the binding information",
"docstring_tokens": [
"A",
"list",
"containing",
"the",
"binding",
"information"
],
"type": null
}
],
"raises": [],
"params": [
{
"identifier": "se... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | _writeBindingRunFile | null | def _writeBindingRunFile(self, pdbOne, pdbTwo, filename=None):
'''Writes a file that acts as input for Uffbaps fo comparing the stability of two proteins
Note: Private method for internal use only'''
#Create the run file
run = "load %s %s\n" % (pdbOne, pdbOne)
run = run + "load %s %s\n" % (pdbTwo, ... | Writes a file that acts as input for Uffbaps fo comparing the stability of two proteins
Note: Private method for internal use only | Writes a file that acts as input for Uffbaps fo comparing the stability of two proteins
Note: Private method for internal use only | [
"Writes",
"a",
"file",
"that",
"acts",
"as",
"input",
"for",
"Uffbaps",
"fo",
"comparing",
"the",
"stability",
"of",
"two",
"proteins",
"Note",
":",
"Private",
"method",
"for",
"internal",
"use",
"only"
] | def _writeBindingRunFile(self, pdbOne, pdbTwo, filename=None):
run = "load %s %s\n" % (pdbOne, pdbOne)
run = run + "load %s %s\n" % (pdbTwo, pdbTwo)
run = run + "task energy {%s}{%s}\n" % (pdbOne, pdbTwo)
runStream = open(filename, 'w')
runStream.write(run)
runStream.close() | [
"def",
"_writeBindingRunFile",
"(",
"self",
",",
"pdbOne",
",",
"pdbTwo",
",",
"filename",
"=",
"None",
")",
":",
"run",
"=",
"\"load %s %s\\n\"",
"%",
"(",
"pdbOne",
",",
"pdbOne",
")",
"run",
"=",
"run",
"+",
"\"load %s %s\\n\"",
"%",
"(",
"pdbTwo",
",... | Writes a file that acts as input for Uffbaps fo comparing the stability of two proteins
Note: Private method for internal use only | [
"Writes",
"a",
"file",
"that",
"acts",
"as",
"input",
"for",
"Uffbaps",
"fo",
"comparing",
"the",
"stability",
"of",
"two",
"proteins",
"Note",
":",
"Private",
"method",
"for",
"internal",
"use",
"only"
] | [
"'''Writes a file that acts as input for Uffbaps fo comparing the stability of two proteins\n\t\t\n\t\t Note: Private method for internal use only'''",
"#Create the run file "
] | [
{
"param": "self",
"type": null
},
{
"param": "pdbOne",
"type": null
},
{
"param": "pdbTwo",
"type": null
},
{
"param": "filename",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pdbOne",
"type": null,
"docstring": null,
"docstring_tokens":... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | _runBindingCalculation | <not_specific> | def _runBindingCalculation(self, pdbName, ligandName, executable, outputStream):
'''Runs a binding calculation for ligandName to pdbName
Note: This is a private method - runBindingCalculation() should be used by external callers
The method writes a Uffbaps run file for calcualting the binding energy of l... | Runs a binding calculation for ligandName to pdbName
Note: This is a private method - runBindingCalculation() should be used by external callers
The method writes a Uffbaps run file for calcualting the binding energy of ligandName to pdbName.
It then runs Uffbaps and waits for it to finish.
Finally it re... | Runs a binding calculation for ligandName to pdbName
Note: This is a private method - runBindingCalculation() should be used by external callers
The method writes a Uffbaps run file for calcualting the binding energy of ligandName to pdbName.
It then runs Uffbaps and waits for it to finish.
Finally it reads the last l... | [
"Runs",
"a",
"binding",
"calculation",
"for",
"ligandName",
"to",
"pdbName",
"Note",
":",
"This",
"is",
"a",
"private",
"method",
"-",
"runBindingCalculation",
"()",
"should",
"be",
"used",
"by",
"external",
"callers",
"The",
"method",
"writes",
"a",
"Uffbaps"... | def _runBindingCalculation(self, pdbName, ligandName, executable, outputStream):
runFile = os.path.join(self.directoryPath, "run%d.txt" % self.environment.rank())
self._writeBindingRunFile(pdbName, ligandName, runFile)
process = subprocess.Popen([executable, runFile], cwd=self.directoryPath, stdout=outputStream)... | [
"def",
"_runBindingCalculation",
"(",
"self",
",",
"pdbName",
",",
"ligandName",
",",
"executable",
",",
"outputStream",
")",
":",
"runFile",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"directoryPath",
",",
"\"run%d.txt\"",
"%",
"self",
".",
"e... | Runs a binding calculation for ligandName to pdbName
Note: This is a private method - runBindingCalculation() should be used by external callers | [
"Runs",
"a",
"binding",
"calculation",
"for",
"ligandName",
"to",
"pdbName",
"Note",
":",
"This",
"is",
"a",
"private",
"method",
"-",
"runBindingCalculation",
"()",
"should",
"be",
"used",
"by",
"external",
"callers"
] | [
"'''Runs a binding calculation for ligandName to pdbName \n\t\t\n\t\tNote: This is a private method - runBindingCalculation() should be used by external callers\n\t\t\n\t\tThe method writes a Uffbaps run file for calcualting the binding energy of ligandName to pdbName.\n\t\tIt then runs Uffbaps and waits for it to ... | [
{
"param": "self",
"type": null
},
{
"param": "pdbName",
"type": null
},
{
"param": "ligandName",
"type": null
},
{
"param": "executable",
"type": null
},
{
"param": "outputStream",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pdbName",
"type": null,
"docstring": null,
"docstring_tokens"... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | binding | null | def binding(self, comparePDBs=[], ligand=None, verbose=False):
'''Calculates the binding free-energy of a ligand to the source pdb and the compare pdbs.
Also calculates the change in binding free-energy for each to the source pdb
Parameters
comparePDBs - A list of paths to PDB files.
All the pdbs i... | Calculates the binding free-energy of a ligand to the source pdb and the compare pdbs.
Also calculates the change in binding free-energy for each to the source pdb
Parameters
comparePDBs - A list of paths to PDB files.
All the pdbs in this list will be compared to the sourcePDB.
The names of the co... | Calculates the binding free-energy of a ligand to the source pdb and the compare pdbs.
Also calculates the change in binding free-energy for each to the source pdb
Parameters
comparePDBs - A list of paths to PDB files.
All the pdbs in this list will be compared to the sourcePDB.
The names of the compare pdbs are expec... | [
"Calculates",
"the",
"binding",
"free",
"-",
"energy",
"of",
"a",
"ligand",
"to",
"the",
"source",
"pdb",
"and",
"the",
"compare",
"pdbs",
".",
"Also",
"calculates",
"the",
"change",
"in",
"binding",
"free",
"-",
"energy",
"for",
"each",
"to",
"the",
"so... | def binding(self, comparePDBs=[], ligand=None, verbose=False):
if len(comparePDBs) == 0:
raise Exceptions.StabilityError, "Unable to perform stability calculation - No mutants supplied"
pdbName = os.path.split(self.sourcePDB)[1]
ligandName = os.path.split(ligand)[1]
if self.environment.isRoot():
shutil.co... | [
"def",
"binding",
"(",
"self",
",",
"comparePDBs",
"=",
"[",
"]",
",",
"ligand",
"=",
"None",
",",
"verbose",
"=",
"False",
")",
":",
"if",
"len",
"(",
"comparePDBs",
")",
"==",
"0",
":",
"raise",
"Exceptions",
".",
"StabilityError",
",",
"\"Unable to ... | Calculates the binding free-energy of a ligand to the source pdb and the compare pdbs. | [
"Calculates",
"the",
"binding",
"free",
"-",
"energy",
"of",
"a",
"ligand",
"to",
"the",
"source",
"pdb",
"and",
"the",
"compare",
"pdbs",
"."
] | [
"'''Calculates the binding free-energy of a ligand to the source pdb and the compare pdbs.\n\t\t\n\t\tAlso calculates the change in binding free-energy for each to the source pdb\n\t\t\n\t\tParameters\n\t\t\tcomparePDBs - A list of paths to PDB files.\n\t\t\t\tAll the pdbs in this list will be compared to the sourc... | [
{
"param": "self",
"type": null
},
{
"param": "comparePDBs",
"type": null
},
{
"param": "ligand",
"type": null
},
{
"param": "verbose",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "comparePDBs",
"type": null,
"docstring": null,
"docstring_tok... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | deltaStabilityResults | <not_specific> | def deltaStabilityResults(self):
'''Returns the results of the last stability comparison run.
Return:
Returns None if no successful stability comparison run has been performed.'''
#Return the results of the last run
return copy.deepcopy(self.resultsMatrix) | Returns the results of the last stability comparison run.
Return:
Returns None if no successful stability comparison run has been performed. | Returns the results of the last stability comparison run.
Return:
Returns None if no successful stability comparison run has been performed. | [
"Returns",
"the",
"results",
"of",
"the",
"last",
"stability",
"comparison",
"run",
".",
"Return",
":",
"Returns",
"None",
"if",
"no",
"successful",
"stability",
"comparison",
"run",
"has",
"been",
"performed",
"."
] | def deltaStabilityResults(self):
return copy.deepcopy(self.resultsMatrix) | [
"def",
"deltaStabilityResults",
"(",
"self",
")",
":",
"return",
"copy",
".",
"deepcopy",
"(",
"self",
".",
"resultsMatrix",
")"
] | Returns the results of the last stability comparison run. | [
"Returns",
"the",
"results",
"of",
"the",
"last",
"stability",
"comparison",
"run",
"."
] | [
"'''Returns the results of the last stability comparison run.\n\t\t\n\t\tReturn:\n\t\t\tReturns None if no successful stability comparison run has been performed.'''",
"#Return the results of the last run"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | bindingResults | <not_specific> | def bindingResults(self):
'''Returns the results of the last binding run.
Return:
Returns None if no successful binding comparison run has been performed.'''
return copy.deepcopy(self.bindingMatrix) | Returns the results of the last binding run.
Return:
Returns None if no successful binding comparison run has been performed. | Returns the results of the last binding run.
Return:
Returns None if no successful binding comparison run has been performed. | [
"Returns",
"the",
"results",
"of",
"the",
"last",
"binding",
"run",
".",
"Return",
":",
"Returns",
"None",
"if",
"no",
"successful",
"binding",
"comparison",
"run",
"has",
"been",
"performed",
"."
] | def bindingResults(self):
return copy.deepcopy(self.bindingMatrix) | [
"def",
"bindingResults",
"(",
"self",
")",
":",
"return",
"copy",
".",
"deepcopy",
"(",
"self",
".",
"bindingMatrix",
")"
] | Returns the results of the last binding run. | [
"Returns",
"the",
"results",
"of",
"the",
"last",
"binding",
"run",
"."
] | [
"'''Returns the results of the last binding run.\n\t\t\n\t\tReturn:\n\t\t\tReturns None if no successful binding comparison run has been performed.'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | deltaBindingResults | <not_specific> | def deltaBindingResults(self):
'''Returns the delta binding results of the last binding run.
Return:
Returns None if no successful binding comparison run has been performed.'''
return copy.deepcopy(self.deltaBindingMatrix) | Returns the delta binding results of the last binding run.
Return:
Returns None if no successful binding comparison run has been performed. | Returns the delta binding results of the last binding run.
Return:
Returns None if no successful binding comparison run has been performed. | [
"Returns",
"the",
"delta",
"binding",
"results",
"of",
"the",
"last",
"binding",
"run",
".",
"Return",
":",
"Returns",
"None",
"if",
"no",
"successful",
"binding",
"comparison",
"run",
"has",
"been",
"performed",
"."
] | def deltaBindingResults(self):
return copy.deepcopy(self.deltaBindingMatrix) | [
"def",
"deltaBindingResults",
"(",
"self",
")",
":",
"return",
"copy",
".",
"deepcopy",
"(",
"self",
".",
"deltaBindingMatrix",
")"
] | Returns the delta binding results of the last binding run. | [
"Returns",
"the",
"delta",
"binding",
"results",
"of",
"the",
"last",
"binding",
"run",
"."
] | [
"'''Returns the delta binding results of the last binding run.\n\t\t\n\t\tReturn:\n\t\t\tReturns None if no successful binding comparison run has been performed.'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | _singleScan | <not_specific> | def _singleScan(self, mutationSet, defaults, mutantCollection):
'''Does a scan of the pdb defined by mutationSet
This is a private method. Do not call externally
Parameters
mutationSet is a Data.MutationSet instance
defaults are the parameters to pass to calc_dpKa
mutantCollection is the Data.Mut... | Does a scan of the pdb defined by mutationSet
This is a private method. Do not call externally
Parameters
mutationSet is a Data.MutationSet instance
defaults are the parameters to pass to calc_dpKa
mutantCollection is the Data.MutantCollection instance the mutationSet
is part of. | Does a scan of the pdb defined by mutationSet
This is a private method. Do not call externally
Parameters
mutationSet is a Data.MutationSet instance
defaults are the parameters to pass to calc_dpKa
mutantCollection is the Data.MutantCollection instance the mutationSet
is part of. | [
"Does",
"a",
"scan",
"of",
"the",
"pdb",
"defined",
"by",
"mutationSet",
"This",
"is",
"a",
"private",
"method",
".",
"Do",
"not",
"call",
"externally",
"Parameters",
"mutationSet",
"is",
"a",
"Data",
".",
"MutationSet",
"instance",
"defaults",
"are",
"the",... | def _singleScan(self, mutationSet, defaults, mutantCollection):
import pKa
defaults['mutations'][0] = mutationSet.codeString(self.pdb, reduced=False)
self.environment.output('Mutation %s' % defaults['mutations'][0], rootOnly=False)
params={}
for key in defaults.keys():
params[key]=defaults[key][0]
print ... | [
"def",
"_singleScan",
"(",
"self",
",",
"mutationSet",
",",
"defaults",
",",
"mutantCollection",
")",
":",
"import",
"pKa",
"defaults",
"[",
"'mutations'",
"]",
"[",
"0",
"]",
"=",
"mutationSet",
".",
"codeString",
"(",
"self",
".",
"pdb",
",",
"reduced",
... | Does a scan of the pdb defined by mutationSet
This is a private method. | [
"Does",
"a",
"scan",
"of",
"the",
"pdb",
"defined",
"by",
"mutationSet",
"This",
"is",
"a",
"private",
"method",
"."
] | [
"'''Does a scan of the pdb defined by mutationSet\n\t\t\n\t\tThis is a private method. Do not call externally\n\t\t\n\t\tParameters\n\t\t\tmutationSet is a Data.MutationSet instance\n\t\t\tdefaults are the parameters to pass to calc_dpKa\n\t\t\tmutantCollection is the Data.MutantCollection instance the mutationSet\... | [
{
"param": "self",
"type": null
},
{
"param": "mutationSet",
"type": null
},
{
"param": "defaults",
"type": null
},
{
"param": "mutantCollection",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "mutationSet",
"type": null,
"docstring": null,
"docstring_tok... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | _processTasks | <not_specific> | def _processTasks(self, taskArray, results, standardOut, scanLogStream, verbose, checkInterval, skewThreshold):
'''Process the tasks in taskArray and accumulates the answers in results.
Every checkInterval tasks this method checks if the loadSkew
(the balance of tasks across nodes) is greater than skewThresh... | Process the tasks in taskArray and accumulates the answers in results.
Every checkInterval tasks this method checks if the loadSkew
(the balance of tasks across nodes) is greater than skewThreshold.
If it is, this method exits, returning an array containing the uncompleted tasks | Process the tasks in taskArray and accumulates the answers in results.
Every checkInterval tasks this method checks if the loadSkew
(the balance of tasks across nodes) is greater than skewThreshold.
If it is, this method exits, returning an array containing the uncompleted tasks | [
"Process",
"the",
"tasks",
"in",
"taskArray",
"and",
"accumulates",
"the",
"answers",
"in",
"results",
".",
"Every",
"checkInterval",
"tasks",
"this",
"method",
"checks",
"if",
"the",
"loadSkew",
"(",
"the",
"balance",
"of",
"tasks",
"across",
"nodes",
")",
... | def _processTasks(self, taskArray, results, standardOut, scanLogStream, verbose, checkInterval, skewThreshold):
defaults = self.configuration.designPKAOptions()
defaults['pdb'][0] = self.pdbName
defaults['pKas'][0] = self.dummyPKAArg
numberMutations = len(taskArray)
ten = int(numberMutations/10)
if ten == 0... | [
"def",
"_processTasks",
"(",
"self",
",",
"taskArray",
",",
"results",
",",
"standardOut",
",",
"scanLogStream",
",",
"verbose",
",",
"checkInterval",
",",
"skewThreshold",
")",
":",
"defaults",
"=",
"self",
".",
"configuration",
".",
"designPKAOptions",
"(",
... | Process the tasks in taskArray and accumulates the answers in results. | [
"Process",
"the",
"tasks",
"in",
"taskArray",
"and",
"accumulates",
"the",
"answers",
"in",
"results",
"."
] | [
"'''Process the tasks in taskArray and accumulates the answers in results.\n\t\t\n\t\tEvery checkInterval tasks this method checks if the loadSkew\n\t\t(the balance of tasks across nodes) is greater than skewThreshold.\n\t\tIf it is, this method exits, returning an array containing the uncompleted tasks'''",
"#Ge... | [
{
"param": "self",
"type": null
},
{
"param": "taskArray",
"type": null
},
{
"param": "results",
"type": null
},
{
"param": "standardOut",
"type": null
},
{
"param": "scanLogStream",
"type": null
},
{
"param": "verbose",
"type": null
},
{
"... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "taskArray",
"type": null,
"docstring": null,
"docstring_token... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | scan | null | def scan(self, mutantCollection, verbose=False, printList=True):
'''Performs a scan for each mutation specified in data
Parameters:
mutantCollection - MutantCollection containing the mutants to be scanned
verbose - True if more verbose output is required. False by default.
printList - Outputs a list ... | Performs a scan for each mutation specified in data
Parameters:
mutantCollection - MutantCollection containing the mutants to be scanned
verbose - True if more verbose output is required. False by default.
printList - Outputs a list of all the mutations being scanned if True.
Returns:
Nothing.... | Performs a scan for each mutation specified in data
Parameters:
mutantCollection - MutantCollection containing the mutants to be scanned
verbose - True if more verbose output is required. False by default.
printList - Outputs a list of all the mutations being scanned if True.
Nothing.
To access the scan results use t... | [
"Performs",
"a",
"scan",
"for",
"each",
"mutation",
"specified",
"in",
"data",
"Parameters",
":",
"mutantCollection",
"-",
"MutantCollection",
"containing",
"the",
"mutants",
"to",
"be",
"scanned",
"verbose",
"-",
"True",
"if",
"more",
"verbose",
"output",
"is",... | def scan(self, mutantCollection, verbose=False, printList=True):
if len(mutantCollection.mutations()) == 0:
raise Exceptions.ArgumentError, "No mutations supplied"
self.environment.output('[SCAN] Ionisable residues - %s' % " ".join(self.ionisableResidues))
self.mutantCollection = mutantCollection
data = self... | [
"def",
"scan",
"(",
"self",
",",
"mutantCollection",
",",
"verbose",
"=",
"False",
",",
"printList",
"=",
"True",
")",
":",
"if",
"len",
"(",
"mutantCollection",
".",
"mutations",
"(",
")",
")",
"==",
"0",
":",
"raise",
"Exceptions",
".",
"ArgumentError"... | Performs a scan for each mutation specified in data
Parameters:
mutantCollection - MutantCollection containing the mutants to be scanned
verbose - True if more verbose output is required. | [
"Performs",
"a",
"scan",
"for",
"each",
"mutation",
"specified",
"in",
"data",
"Parameters",
":",
"mutantCollection",
"-",
"MutantCollection",
"containing",
"the",
"mutants",
"to",
"be",
"scanned",
"verbose",
"-",
"True",
"if",
"more",
"verbose",
"output",
"is",... | [
"'''Performs a scan for each mutation specified in data\n\t\t\n\t\tParameters: \n\t\t\tmutantCollection - MutantCollection containing the mutants to be scanned\n\t\t\tverbose - True if more verbose output is required. False by default.\n\t\t\tprintList - Outputs a list of all the mutations being scanned if True.\t\... | [
{
"param": "self",
"type": null
},
{
"param": "mutantCollection",
"type": null
},
{
"param": "verbose",
"type": null
},
{
"param": "printList",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "mutantCollection",
"type": null,
"docstring": null,
"docstrin... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | scanLogFile | <not_specific> | def scanLogFile(self):
'''Returns the path to the log file for the last scan'''
return self.scanLogFile | Returns the path to the log file for the last scan | Returns the path to the log file for the last scan | [
"Returns",
"the",
"path",
"to",
"the",
"log",
"file",
"for",
"the",
"last",
"scan"
] | def scanLogFile(self):
return self.scanLogFile | [
"def",
"scanLogFile",
"(",
"self",
")",
":",
"return",
"self",
".",
"scanLogFile"
] | Returns the path to the log file for the last scan | [
"Returns",
"the",
"path",
"to",
"the",
"log",
"file",
"for",
"the",
"last",
"scan"
] | [
"'''Returns the path to the log file for the last scan'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | scanResults | <not_specific> | def scanResults(self):
'''The results of the last scan performed.
Returns
A Matrix instance.
The first four columns are:
'Chain, Residue Code, Residue Number, Mutation'
There is one remaining colomn for each ionisable residue the scan was defined for.
Each entry in these columns gives the ch... | The results of the last scan performed.
Returns
A Matrix instance.
The first four columns are:
'Chain, Residue Code, Residue Number, Mutation'
There is one remaining colomn for each ionisable residue the scan was defined for.
Each entry in these columns gives the change in pKa due to the mutatio... | The results of the last scan performed.
Returns
A Matrix instance.
The first four columns are:
'Chain, Residue Code, Residue Number, Mutation'
There is one remaining colomn for each ionisable residue the scan was defined for.
Each entry in these columns gives the change in pKa due to the mutation defined
by the entrie... | [
"The",
"results",
"of",
"the",
"last",
"scan",
"performed",
".",
"Returns",
"A",
"Matrix",
"instance",
".",
"The",
"first",
"four",
"columns",
"are",
":",
"'",
"Chain",
"Residue",
"Code",
"Residue",
"Number",
"Mutation",
"'",
"There",
"is",
"one",
"remaini... | def scanResults(self):
return self.resultsMatrix | [
"def",
"scanResults",
"(",
"self",
")",
":",
"return",
"self",
".",
"resultsMatrix"
] | The results of the last scan performed. | [
"The",
"results",
"of",
"the",
"last",
"scan",
"performed",
"."
] | [
"'''The results of the last scan performed.\n\t\t\n\t\tReturns\n\t\t\tA Matrix instance.\n\t\t\tThe first four columns are:\n\t\t\t'Chain, Residue Code, Residue Number, Mutation'\n\t\t\t\n\t\t\tThere is one remaining colomn for each ionisable residue the scan was defined for.\n\t\t\tEach entry in these columns give... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | _getNewSID | <not_specific> | def _getNewSID(self, tag):
'''Returns a unique string for use as a Session ID'''
import time, md5, random
t1 = time.time()
t2 = t1 + random.random()
base = md5.new( tag + str(t1 +t2) )
sid = tag + '_' + base.hexdigest()
return sid | Returns a unique string for use as a Session ID | Returns a unique string for use as a Session ID | [
"Returns",
"a",
"unique",
"string",
"for",
"use",
"as",
"a",
"Session",
"ID"
] | def _getNewSID(self, tag):
import time, md5, random
t1 = time.time()
t2 = t1 + random.random()
base = md5.new( tag + str(t1 +t2) )
sid = tag + '_' + base.hexdigest()
return sid | [
"def",
"_getNewSID",
"(",
"self",
",",
"tag",
")",
":",
"import",
"time",
",",
"md5",
",",
"random",
"t1",
"=",
"time",
".",
"time",
"(",
")",
"t2",
"=",
"t1",
"+",
"random",
".",
"random",
"(",
")",
"base",
"=",
"md5",
".",
"new",
"(",
"tag",
... | Returns a unique string for use as a Session ID | [
"Returns",
"a",
"unique",
"string",
"for",
"use",
"as",
"a",
"Session",
"ID"
] | [
"'''Returns a unique string for use as a Session ID'''"
] | [
{
"param": "self",
"type": null
},
{
"param": "tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "tag",
"type": null,
"docstring": null,
"docstring_tokens": []... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | _convertProtonationData | <not_specific> | def _convertProtonationData(self, protonationStates):
'''Replaces PEAT type residue codes with pdb2pqr residue codes'''
#Convert protonation states
converted = {}
for residueCode in protonationStates.keys():
data = Utilities.ParseResidueCode()
pdb2pqrCode = '%s %s %d' % (data[2], data[0], data[1])
... | Replaces PEAT type residue codes with pdb2pqr residue codes | Replaces PEAT type residue codes with pdb2pqr residue codes | [
"Replaces",
"PEAT",
"type",
"residue",
"codes",
"with",
"pdb2pqr",
"residue",
"codes"
] | def _convertProtonationData(self, protonationStates):
converted = {}
for residueCode in protonationStates.keys():
data = Utilities.ParseResidueCode()
pdb2pqrCode = '%s %s %d' % (data[2], data[0], data[1])
converted[pdb2pqrCode] = protonationStates[residueCode]
return converted | [
"def",
"_convertProtonationData",
"(",
"self",
",",
"protonationStates",
")",
":",
"converted",
"=",
"{",
"}",
"for",
"residueCode",
"in",
"protonationStates",
".",
"keys",
"(",
")",
":",
"data",
"=",
"Utilities",
".",
"ParseResidueCode",
"(",
")",
"pdb2pqrCod... | Replaces PEAT type residue codes with pdb2pqr residue codes | [
"Replaces",
"PEAT",
"type",
"residue",
"codes",
"with",
"pdb2pqr",
"residue",
"codes"
] | [
"'''Replaces PEAT type residue codes with pdb2pqr residue codes'''",
"#Convert protonation states"
] | [
{
"param": "self",
"type": null
},
{
"param": "protonationStates",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "protonationStates",
"type": null,
"docstring": null,
"docstri... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | solvationEnergy | <not_specific> | def solvationEnergy(self, pdbFile, ligandFile, protonationStates={}, verbose=True):
'''Returns the electrostatic solvation energies for the protein ligand complex
Params:
ligandFile: A ligand in mol2 format
pdbFile: A pdb the ligand binds to
Returns:
A list of energies. The elements of the list a... | Returns the electrostatic solvation energies for the protein ligand complex
Params:
ligandFile: A ligand in mol2 format
pdbFile: A pdb the ligand binds to
Returns:
A list of energies. The elements of the list are
(Desolvation, Interaction, Protein Solvation, Water Solvation)
The Protein and Wat... | Returns the electrostatic solvation energies for the protein ligand complex | [
"Returns",
"the",
"electrostatic",
"solvation",
"energies",
"for",
"the",
"protein",
"ligand",
"complex"
] | def solvationEnergy(self, pdbFile, ligandFile, protonationStates={}, verbose=True):
try:
import pdb2pqr.pdb2pka.pka
except ImportError, data:
raise Exceptions.EnvironmentError, 'Unable to compute solvation energies - %s' % data
dir = self._getNewSID('PB')
dir = os.path.abspath(dir)
try:
os.mkdir(dir... | [
"def",
"solvationEnergy",
"(",
"self",
",",
"pdbFile",
",",
"ligandFile",
",",
"protonationStates",
"=",
"{",
"}",
",",
"verbose",
"=",
"True",
")",
":",
"try",
":",
"import",
"pdb2pqr",
".",
"pdb2pka",
".",
"pka",
"except",
"ImportError",
",",
"data",
"... | Returns the electrostatic solvation energies for the protein ligand complex | [
"Returns",
"the",
"electrostatic",
"solvation",
"energies",
"for",
"the",
"protein",
"ligand",
"complex"
] | [
"'''Returns the electrostatic solvation energies for the protein ligand complex\n\t\t\n\t\tParams:\n\t\t\tligandFile: A ligand in mol2 format\n\t\t\tpdbFile: A pdb the ligand binds to\n\t\t\n\t\tReturns:\n\t\t\tA list of energies. The elements of the list are\n\t\t\t(Desolvation, Interaction, Protein Solvation, Wat... | [
{
"param": "self",
"type": null
},
{
"param": "pdbFile",
"type": null
},
{
"param": "ligandFile",
"type": null
},
{
"param": "protonationStates",
"type": null
},
{
"param": "verbose",
"type": null
}
] | {
"returns": [
{
"docstring": "A list of energies. The elements of the list are\n(Desolvation, Interaction, Protein Solvation, Water Solvation)\nThe Protein and Water solvation energies have been scaled by 0.5 ala Born",
"docstring_tokens": [
"A",
"list",
"of",
"energie... |
6bb026965f285d6f172aae88e9f33aac6ec58cd6 | shambo001/peat | PEATSA/Core/Programs.py | [
"MIT"
] | Python | mutantSolvationEnergies | <not_specific> | def mutantSolvationEnergies(self, mutantCollection, ligandFile, protonationStates={}):
'''Calculates electrostatic solvation energies for all the mutant/ligand complexes
Params:
ligandFile: A ligand in mol2 format
mutantCollection: A Core.Data.MutantCollection instance
Returns:
A matrix of result... | Calculates electrostatic solvation energies for all the mutant/ligand complexes
Params:
ligandFile: A ligand in mol2 format
mutantCollection: A Core.Data.MutantCollection instance
Returns:
A matrix of results. The matrix columns are
(MutationCode, Desolvation, Interaction, Protein Solvation, Water... | Calculates electrostatic solvation energies for all the mutant/ligand complexes | [
"Calculates",
"electrostatic",
"solvation",
"energies",
"for",
"all",
"the",
"mutant",
"/",
"ligand",
"complexes"
] | def mutantSolvationEnergies(self, mutantCollection, ligandFile, protonationStates={}):
rows = []
mutations = mutantCollection.mutations()
mutations = self.environment.splitArray(mutations)
for set in mutations:
mutant = mutantCollection.fileForMutationSet(set)
result = self.solvationEnergy(mutant, ligand... | [
"def",
"mutantSolvationEnergies",
"(",
"self",
",",
"mutantCollection",
",",
"ligandFile",
",",
"protonationStates",
"=",
"{",
"}",
")",
":",
"rows",
"=",
"[",
"]",
"mutations",
"=",
"mutantCollection",
".",
"mutations",
"(",
")",
"mutations",
"=",
"self",
"... | Calculates electrostatic solvation energies for all the mutant/ligand complexes | [
"Calculates",
"electrostatic",
"solvation",
"energies",
"for",
"all",
"the",
"mutant",
"/",
"ligand",
"complexes"
] | [
"'''Calculates electrostatic solvation energies for all the mutant/ligand complexes\n\t\t\n\t\tParams:\n\t\t\tligandFile: A ligand in mol2 format\n\t\t\tmutantCollection: A Core.Data.MutantCollection instance\n\t\t\n\t\tReturns:\n\t\t\tA matrix of results. The matrix columns are\n\t\t\t(MutationCode, Desolvation, I... | [
{
"param": "self",
"type": null
},
{
"param": "mutantCollection",
"type": null
},
{
"param": "ligandFile",
"type": null
},
{
"param": "protonationStates",
"type": null
}
] | {
"returns": [
{
"docstring": "A matrix of results. The matrix columns are\n(MutationCode, Desolvation, Interaction, Protein Solvation, Water Solvation)",
"docstring_tokens": [
"A",
"matrix",
"of",
"results",
".",
"The",
"matrix",
"column... |
8c03ecb41dfd382c0e938aa5647240be9d4c0bd5 | shambo001/peat | pKarun/pKarun_base.py | [
"MIT"
] | Python | autonomy | <not_specific> | def autonomy (self):
"""
# Calculate titration curves for the autonomy analysis
"""
import os, string
os.chdir(self.topdir)
#
# Right now we need a full pKa calculation to do the autonomy calcs
#
command=self.startcom+'\n pka \n autpka \n'
... |
# Calculate titration curves for the autonomy analysis
| Calculate titration curves for the autonomy analysis | [
"Calculate",
"titration",
"curves",
"for",
"the",
"autonomy",
"analysis"
] | def autonomy (self):
import os, string
os.chdir(self.topdir)
Right now we need a full pKa calculation to do the autonomy calcs
command=self.startcom+'\n pka \n autpka \n'
command=command+'y \n'
command=command+self.desolvfile+' \n'+self.backgrfile+' \n '+self.matrixfile+... | [
"def",
"autonomy",
"(",
"self",
")",
":",
"import",
"os",
",",
"string",
"os",
".",
"chdir",
"(",
"self",
".",
"topdir",
")",
"command",
"=",
"self",
".",
"startcom",
"+",
"'\\n pka \\n autpka \\n'",
"command",
"=",
"command",
"+",
"'y \\n'",
"command",
... | Calculate titration curves for the autonomy analysis | [
"Calculate",
"titration",
"curves",
"for",
"the",
"autonomy",
"analysis"
] | [
"\"\"\"\n # Calculate titration curves for the autonomy analysis\n \"\"\"",
"#",
"# Right now we need a full pKa calculation to do the autonomy calcs",
"#",
"#",
"# If we calculate only for specific groups then put them in",
"# command file",
"#"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
8c19597c1a3ad981e37150fce2c25298e2f53d67 | shambo001/peat | PEATDB/Actions.py | [
"MIT"
] | Python | AAList2String | <not_specific> | def AAList2String(self, aalist):
"""Convert the amino acid sequence as stored in aaseq to a string"""
s = ''
for a in aalist:
s+=self.three_to_one[a[1]]
return s | Convert the amino acid sequence as stored in aaseq to a string | Convert the amino acid sequence as stored in aaseq to a string | [
"Convert",
"the",
"amino",
"acid",
"sequence",
"as",
"stored",
"in",
"aaseq",
"to",
"a",
"string"
] | def AAList2String(self, aalist):
s = ''
for a in aalist:
s+=self.three_to_one[a[1]]
return s | [
"def",
"AAList2String",
"(",
"self",
",",
"aalist",
")",
":",
"s",
"=",
"''",
"for",
"a",
"in",
"aalist",
":",
"s",
"+=",
"self",
".",
"three_to_one",
"[",
"a",
"[",
"1",
"]",
"]",
"return",
"s"
] | Convert the amino acid sequence as stored in aaseq to a string | [
"Convert",
"the",
"amino",
"acid",
"sequence",
"as",
"stored",
"in",
"aaseq",
"to",
"a",
"string"
] | [
"\"\"\"Convert the amino acid sequence as stored in aaseq to a string\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "aalist",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "aalist",
"type": null,
"docstring": null,
"docstring_tokens":... |
8c19597c1a3ad981e37150fce2c25298e2f53d67 | shambo001/peat | PEATDB/Actions.py | [
"MIT"
] | Python | string2AAseq | <not_specific> | def string2AAseq(self, seq, chain='A'):
"""Convert string to amino acid aaseq as stored in PEAT"""
from PEATSA.Core import Utilities
codemap = Utilities.InvertedCodeDictionary()
codes = [codemap[el] for el in list(seq)]
indexes = [Utilities.CreateResidueCode(chain=chain, number=... | Convert string to amino acid aaseq as stored in PEAT | Convert string to amino acid aaseq as stored in PEAT | [
"Convert",
"string",
"to",
"amino",
"acid",
"aaseq",
"as",
"stored",
"in",
"PEAT"
] | def string2AAseq(self, seq, chain='A'):
from PEATSA.Core import Utilities
codemap = Utilities.InvertedCodeDictionary()
codes = [codemap[el] for el in list(seq)]
indexes = [Utilities.CreateResidueCode(chain=chain, number=index) for index in range(1, len(seq) + 1)]
return ... | [
"def",
"string2AAseq",
"(",
"self",
",",
"seq",
",",
"chain",
"=",
"'A'",
")",
":",
"from",
"PEATSA",
".",
"Core",
"import",
"Utilities",
"codemap",
"=",
"Utilities",
".",
"InvertedCodeDictionary",
"(",
")",
"codes",
"=",
"[",
"codemap",
"[",
"el",
"]",
... | Convert string to amino acid aaseq as stored in PEAT | [
"Convert",
"string",
"to",
"amino",
"acid",
"aaseq",
"as",
"stored",
"in",
"PEAT"
] | [
"\"\"\"Convert string to amino acid aaseq as stored in PEAT\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "seq",
"type": null
},
{
"param": "chain",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "seq",
"type": null,
"docstring": null,
"docstring_tokens": []... |
8c19597c1a3ad981e37150fce2c25298e2f53d67 | shambo001/peat | PEATDB/Actions.py | [
"MIT"
] | Python | checkMutation | <not_specific> | def checkMutation(self, DB, name, ref=None, X=None):
"""Check mutations based on ref sequence and current mutant
sequence, should be triggered whenever ref protein is altered so
that the mutation codes are updated."""
prot = DB.get(name)
if prot.aaseq == None:
... | Check mutations based on ref sequence and current mutant
sequence, should be triggered whenever ref protein is altered so
that the mutation codes are updated. | Check mutations based on ref sequence and current mutant
sequence, should be triggered whenever ref protein is altered so
that the mutation codes are updated. | [
"Check",
"mutations",
"based",
"on",
"ref",
"sequence",
"and",
"current",
"mutant",
"sequence",
"should",
"be",
"triggered",
"whenever",
"ref",
"protein",
"is",
"altered",
"so",
"that",
"the",
"mutation",
"codes",
"are",
"updated",
"."
] | def checkMutation(self, DB, name, ref=None, X=None):
prot = DB.get(name)
if prot.aaseq == None:
return
if ref == None:
ref = self.DB.meta.refprotein
refseq = self.AAList2String(DB.get(ref).aaseq)
if prot.aaseq == None:
retur... | [
"def",
"checkMutation",
"(",
"self",
",",
"DB",
",",
"name",
",",
"ref",
"=",
"None",
",",
"X",
"=",
"None",
")",
":",
"prot",
"=",
"DB",
".",
"get",
"(",
"name",
")",
"if",
"prot",
".",
"aaseq",
"==",
"None",
":",
"return",
"if",
"ref",
"==",
... | Check mutations based on ref sequence and current mutant
sequence, should be triggered whenever ref protein is altered so
that the mutation codes are updated. | [
"Check",
"mutations",
"based",
"on",
"ref",
"sequence",
"and",
"current",
"mutant",
"sequence",
"should",
"be",
"triggered",
"whenever",
"ref",
"protein",
"is",
"altered",
"so",
"that",
"the",
"mutation",
"codes",
"are",
"updated",
"."
] | [
"\"\"\"Check mutations based on ref sequence and current mutant\n sequence, should be triggered whenever ref protein is altered so \n that the mutation codes are updated.\"\"\"",
"#get mutations from sequence",
"#get alignment for pdb seq and AA from DNA seq ",
"#we need to also provide... | [
{
"param": "self",
"type": null
},
{
"param": "DB",
"type": null
},
{
"param": "name",
"type": null
},
{
"param": "ref",
"type": null
},
{
"param": "X",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "DB",
"type": null,
"docstring": null,
"docstring_tokens": [],... |
8c19597c1a3ad981e37150fce2c25298e2f53d67 | shambo001/peat | PEATDB/Actions.py | [
"MIT"
] | Python | addPDBFile | <not_specific> | def addPDBFile(self, DB=None, name=None, pdbfile=None,
pdbdata=None, pdbname=None, gui=True):
"""Add a PDB file to the record given as argument"""
import os, tkMessageBox
if pdbdata == None and pdbfile == None:
savedir=os.getcwd()
global PDB_code
... | Add a PDB file to the record given as argument | Add a PDB file to the record given as argument | [
"Add",
"a",
"PDB",
"file",
"to",
"the",
"record",
"given",
"as",
"argument"
] | def addPDBFile(self, DB=None, name=None, pdbfile=None,
pdbdata=None, pdbname=None, gui=True):
import os, tkMessageBox
if pdbdata == None and pdbfile == None:
savedir=os.getcwd()
global PDB_code
pdbfile=tkFileDialog.askopenfilename(defaultextensi... | [
"def",
"addPDBFile",
"(",
"self",
",",
"DB",
"=",
"None",
",",
"name",
"=",
"None",
",",
"pdbfile",
"=",
"None",
",",
"pdbdata",
"=",
"None",
",",
"pdbname",
"=",
"None",
",",
"gui",
"=",
"True",
")",
":",
"import",
"os",
",",
"tkMessageBox",
"if",... | Add a PDB file to the record given as argument | [
"Add",
"a",
"PDB",
"file",
"to",
"the",
"record",
"given",
"as",
"argument"
] | [
"\"\"\"Add a PDB file to the record given as argument\"\"\"",
"# Extracting PDB_code from pdbfile",
"# Try to read it using Protool ",
"#store it ",
"#if this is the reference protein remodel mutations and rewrite mut codes ",
"#get new mutation codes",
"#self.checkModels(DB)",
"#add the origi... | [
{
"param": "self",
"type": null
},
{
"param": "DB",
"type": null
},
{
"param": "name",
"type": null
},
{
"param": "pdbfile",
"type": null
},
{
"param": "pdbdata",
"type": null
},
{
"param": "pdbname",
"type": null
},
{
"param": "gui",
"... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "DB",
"type": null,
"docstring": null,
"docstring_tokens": [],... |
8c19597c1a3ad981e37150fce2c25298e2f53d67 | shambo001/peat | PEATDB/Actions.py | [
"MIT"
] | Python | checkPDBSequence | <not_specific> | def checkPDBSequence(self, name):
"""Check the PDB sequence against a newly added structure, optional.
Adds the amino acid seq of the PDB file, overwriting the old one"""
# Extract the sequence
import sequence_alignment
pdb_1,ignored_res1=sequence_alignment.Protool2pir(self.X.... | Check the PDB sequence against a newly added structure, optional.
Adds the amino acid seq of the PDB file, overwriting the old one | Check the PDB sequence against a newly added structure, optional.
Adds the amino acid seq of the PDB file, overwriting the old one | [
"Check",
"the",
"PDB",
"sequence",
"against",
"a",
"newly",
"added",
"structure",
"optional",
".",
"Adds",
"the",
"amino",
"acid",
"seq",
"of",
"the",
"PDB",
"file",
"overwriting",
"the",
"old",
"one"
] | def checkPDBSequence(self, name):
import sequence_alignment
pdb_1,ignored_res1=sequence_alignment.Protool2pir(self.X.sequence)
print 'IGNORED',ignored_res1
if ignored_res1!={}:
igroups=ignored_res1.keys()
igroups.sort()
import tkMessageBox
... | [
"def",
"checkPDBSequence",
"(",
"self",
",",
"name",
")",
":",
"import",
"sequence_alignment",
"pdb_1",
",",
"ignored_res1",
"=",
"sequence_alignment",
".",
"Protool2pir",
"(",
"self",
".",
"X",
".",
"sequence",
")",
"print",
"'IGNORED'",
",",
"ignored_res1",
... | Check the PDB sequence against a newly added structure, optional. | [
"Check",
"the",
"PDB",
"sequence",
"against",
"a",
"newly",
"added",
"structure",
"optional",
"."
] | [
"\"\"\"Check the PDB sequence against a newly added structure, optional.\n Adds the amino acid seq of the PDB file, overwriting the old one\"\"\"",
"# Extract the sequence",
"# Get the entry sequence",
"# If we do not have an amino acid sequence for the record, then",
"# we simply use the one from... | [
{
"param": "self",
"type": null
},
{
"param": "name",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "name",
"type": null,
"docstring": null,
"docstring_tokens": [... |
8c19597c1a3ad981e37150fce2c25298e2f53d67 | shambo001/peat | PEATDB/Actions.py | [
"MIT"
] | Python | checkModels | <not_specific> | def checkModels(self, DB=None, callback=None, selected=None, usemutationcodes=False):
"""Check that we have modelled a structure for everything we can"""
if DB == None:
return
proteins = DB.getRecs()
refprot = DB.meta.refprotein
refseq = DB[refprot].aaseq
refa... | Check that we have modelled a structure for everything we can | Check that we have modelled a structure for everything we can | [
"Check",
"that",
"we",
"have",
"modelled",
"a",
"structure",
"for",
"everything",
"we",
"can"
] | def checkModels(self, DB=None, callback=None, selected=None, usemutationcodes=False):
if DB == None:
return
proteins = DB.getRecs()
refprot = DB.meta.refprotein
refseq = DB[refprot].aaseq
refaa = self.AAList2String(refseq)
refpdb = DB[refprot].Structure
... | [
"def",
"checkModels",
"(",
"self",
",",
"DB",
"=",
"None",
",",
"callback",
"=",
"None",
",",
"selected",
"=",
"None",
",",
"usemutationcodes",
"=",
"False",
")",
":",
"if",
"DB",
"==",
"None",
":",
"return",
"proteins",
"=",
"DB",
".",
"getRecs",
"(... | Check that we have modelled a structure for everything we can | [
"Check",
"that",
"we",
"have",
"modelled",
"a",
"structure",
"for",
"everything",
"we",
"can"
] | [
"\"\"\"Check that we have modelled a structure for everything we can\"\"\"",
"# Check that Protool is loaded",
"#Create protool oinstance for ref pdb",
"# Find all potential parents",
"# Loop over selected or all ",
"#if no sequence try create one from mutation code",
"#print refaa",
"# We can only... | [
{
"param": "self",
"type": null
},
{
"param": "DB",
"type": null
},
{
"param": "callback",
"type": null
},
{
"param": "selected",
"type": null
},
{
"param": "usemutationcodes",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "DB",
"type": null,
"docstring": null,
"docstring_tokens": [],... |
8c19597c1a3ad981e37150fce2c25298e2f53d67 | shambo001/peat | PEATDB/Actions.py | [
"MIT"
] | Python | sendDB2Labbook | <not_specific> | def sendDB2Labbook(self, DB, recs=None, cols=None, name='main'):
"""Send copy of selected DB cols to a labbook table
convenience method to allow quick duplication of main DB data"""
from PEATDB.TableModels import TableModel
if cols == None:
cols = DB.meta.userfields.keys()
... | Send copy of selected DB cols to a labbook table
convenience method to allow quick duplication of main DB data | Send copy of selected DB cols to a labbook table
convenience method to allow quick duplication of main DB data | [
"Send",
"copy",
"of",
"selected",
"DB",
"cols",
"to",
"a",
"labbook",
"table",
"convenience",
"method",
"to",
"allow",
"quick",
"duplication",
"of",
"main",
"DB",
"data"
] | def sendDB2Labbook(self, DB, recs=None, cols=None, name='main'):
from PEATDB.TableModels import TableModel
if cols == None:
cols = DB.meta.userfields.keys()
if recs == None:
recs = DB.getRecs()
cols.append('name')
M = TableModel()
for rec in re... | [
"def",
"sendDB2Labbook",
"(",
"self",
",",
"DB",
",",
"recs",
"=",
"None",
",",
"cols",
"=",
"None",
",",
"name",
"=",
"'main'",
")",
":",
"from",
"PEATDB",
".",
"TableModels",
"import",
"TableModel",
"if",
"cols",
"==",
"None",
":",
"cols",
"=",
"DB... | Send copy of selected DB cols to a labbook table
convenience method to allow quick duplication of main DB data | [
"Send",
"copy",
"of",
"selected",
"DB",
"cols",
"to",
"a",
"labbook",
"table",
"convenience",
"method",
"to",
"allow",
"quick",
"duplication",
"of",
"main",
"DB",
"data"
] | [
"\"\"\"Send copy of selected DB cols to a labbook table\n convenience method to allow quick duplication of main DB data\"\"\"",
"#M.addColumn('name') "
] | [
{
"param": "self",
"type": null
},
{
"param": "DB",
"type": null
},
{
"param": "recs",
"type": null
},
{
"param": "cols",
"type": null
},
{
"param": "name",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "DB",
"type": null,
"docstring": null,
"docstring_tokens": [],... |
0c5e939cb16a473d24f43c5d3d4c6619675a546f | shambo001/peat | PEATDB/DNAtool/evaluate_primer.py | [
"MIT"
] | Python | save_primer_from_edit | <not_specific> | def save_primer_from_edit(self, parent_window=None):
"""Save the primer in the DB when doing a primer Edit"""
if not parent_window:
parent_window = self.eval_win
# Check if the primer name has been changed first, and ask for confirmation of rename
if self.primername_var.get... | Save the primer in the DB when doing a primer Edit | Save the primer in the DB when doing a primer Edit | [
"Save",
"the",
"primer",
"in",
"the",
"DB",
"when",
"doing",
"a",
"primer",
"Edit"
] | def save_primer_from_edit(self, parent_window=None):
if not parent_window:
parent_window = self.eval_win
if self.primername_var.get() != self.edit_primer_name or not self.edit_primer_name:
import tkMessageBox
ok = tkMessageBox.askyesno('Primer Name altered',
... | [
"def",
"save_primer_from_edit",
"(",
"self",
",",
"parent_window",
"=",
"None",
")",
":",
"if",
"not",
"parent_window",
":",
"parent_window",
"=",
"self",
".",
"eval_win",
"if",
"self",
".",
"primername_var",
".",
"get",
"(",
")",
"!=",
"self",
".",
"edit_... | Save the primer in the DB when doing a primer Edit | [
"Save",
"the",
"primer",
"in",
"the",
"DB",
"when",
"doing",
"a",
"primer",
"Edit"
] | [
"\"\"\"Save the primer in the DB when doing a primer Edit\"\"\"",
"# Check if the primer name has been changed first, and ask for confirmation of rename",
"#rename primer based on value in entry widget",
"#only rename if there isn't already a primer with the same name",
"#otherwise don't allow rename",
"#... | [
{
"param": "self",
"type": null
},
{
"param": "parent_window",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "parent_window",
"type": null,
"docstring": null,
"docstring_t... |
f81741d0ebeccd185df09ddca636b6ae3eff47ea | shambo001/peat | pKaTool/pKa_system_data_manipulation.py | [
"MIT"
] | Python | pack_all_data | <not_specific> | def pack_all_data(self):
"""Pack all data in a dictionary"""
#
# Dictionary for storing everything
#
pKaTool_data = {}
#
# Store groups
#
pKaTool_data['groups'] = {}
no_groups = len(self.groups)
pKaTool_data['no_groups'] = no_groups... | Pack all data in a dictionary | Pack all data in a dictionary | [
"Pack",
"all",
"data",
"in",
"a",
"dictionary"
] | def pack_all_data(self):
Dictionary for storing everything
pKaTool_data = {}
Store groups
pKaTool_data['groups'] = {}
no_groups = len(self.groups)
pKaTool_data['no_groups'] = no_groups
for i in range(no_groups):
pKaTool_data['groups'][i] = {}
... | [
"def",
"pack_all_data",
"(",
"self",
")",
":",
"pKaTool_data",
"=",
"{",
"}",
"pKaTool_data",
"[",
"'groups'",
"]",
"=",
"{",
"}",
"no_groups",
"=",
"len",
"(",
"self",
".",
"groups",
")",
"pKaTool_data",
"[",
"'no_groups'",
"]",
"=",
"no_groups",
"for",... | Pack all data in a dictionary | [
"Pack",
"all",
"data",
"in",
"a",
"dictionary"
] | [
"\"\"\"Pack all data in a dictionary\"\"\"",
"#",
"# Dictionary for storing everything",
"#",
"#",
"# Store groups",
"#",
"#",
"# Store experimental data",
"#",
"#",
"# store pH-activity profile",
"#",
"#",
"# store FTIR data",
"#"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f81741d0ebeccd185df09ddca636b6ae3eff47ea | shambo001/peat | pKaTool/pKa_system_data_manipulation.py | [
"MIT"
] | Python | send_system_to_EAT | <not_specific> | def send_system_to_EAT(self):
"""Get all data and send it to EAT"""
#
# Do we have an EAT instance?
#
EAT_instance=None
if self.parent_application:
if self.parent_application.ID=='EAT':
EAT_instance=self.parent_application
elif self... | Get all data and send it to EAT | Get all data and send it to EAT | [
"Get",
"all",
"data",
"and",
"send",
"it",
"to",
"EAT"
] | def send_system_to_EAT(self):
Do we have an EAT instance?
EAT_instance=None
if self.parent_application:
if self.parent_application.ID=='EAT':
EAT_instance=self.parent_application
elif self.parent_application.ID=='Ekin':
if self.parent_appl... | [
"def",
"send_system_to_EAT",
"(",
"self",
")",
":",
"EAT_instance",
"=",
"None",
"if",
"self",
".",
"parent_application",
":",
"if",
"self",
".",
"parent_application",
".",
"ID",
"==",
"'EAT'",
":",
"EAT_instance",
"=",
"self",
".",
"parent_application",
"elif... | Get all data and send it to EAT | [
"Get",
"all",
"data",
"and",
"send",
"it",
"to",
"EAT"
] | [
"\"\"\"Get all data and send it to EAT\"\"\"",
"#",
"# Do we have an EAT instance?",
"#",
"#",
"# Get the data for the system",
"#",
"#",
"# Add info for EAT if we have it",
"#",
"#",
"# Send the whole thing to EAT",
"#",
"#",
"# Destroy window",
"#",
"#",
"# We have to manually lo... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9b67cac376e4d17ff120bf019f1276364aba99d2 | shambo001/peat | PEATDB/Extfile.py | [
"MIT"
] | Python | displayFile | <not_specific> | def displayFile(self, filerec):
"""Uses a new method of file storage with blobs"""
#now we just get the blob from the filerecord object...
from PILView import PILViewer
from PEATDB.Record import FileRecord
#check class
if not type(filerec) is FileRecord: ... | Uses a new method of file storage with blobs | Uses a new method of file storage with blobs | [
"Uses",
"a",
"new",
"method",
"of",
"file",
"storage",
"with",
"blobs"
] | def displayFile(self, filerec):
from PILView import PILViewer
from PEATDB.Record import FileRecord
if not type(filerec) is FileRecord:
return False
myblob = filerec.blob
ext = filerec.ext
mtype = filerec.mimetype
print 'mimetype is', mtype
... | [
"def",
"displayFile",
"(",
"self",
",",
"filerec",
")",
":",
"from",
"PILView",
"import",
"PILViewer",
"from",
"PEATDB",
".",
"Record",
"import",
"FileRecord",
"if",
"not",
"type",
"(",
"filerec",
")",
"is",
"FileRecord",
":",
"return",
"False",
"myblob",
... | Uses a new method of file storage with blobs | [
"Uses",
"a",
"new",
"method",
"of",
"file",
"storage",
"with",
"blobs"
] | [
"\"\"\"Uses a new method of file storage with blobs\"\"\"",
"#now we just get the blob from the filerecord object...",
"#check class ",
"#try using mailcaps on linux system",
"#os.remove(tempname)"
] | [
{
"param": "self",
"type": null
},
{
"param": "filerec",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filerec",
"type": null,
"docstring": null,
"docstring_tokens"... |
9b67cac376e4d17ff120bf019f1276364aba99d2 | shambo001/peat | PEATDB/Extfile.py | [
"MIT"
] | Python | addFileDialog | <not_specific> | def addFileDialog(self, filerec=None):
"""Do the front-end stuff for adding files to peat"""
import tkFileDialog
filename=tkFileDialog.askopenfilename(defaultextension='.*',
initialdir=os.getcwd(),
filety... | Do the front-end stuff for adding files to peat | Do the front-end stuff for adding files to peat | [
"Do",
"the",
"front",
"-",
"end",
"stuff",
"for",
"adding",
"files",
"to",
"peat"
] | def addFileDialog(self, filerec=None):
import tkFileDialog
filename=tkFileDialog.askopenfilename(defaultextension='.*',
initialdir=os.getcwd(),
filetypes=[("All files","*.*")])
self.newfile = filename
... | [
"def",
"addFileDialog",
"(",
"self",
",",
"filerec",
"=",
"None",
")",
":",
"import",
"tkFileDialog",
"filename",
"=",
"tkFileDialog",
".",
"askopenfilename",
"(",
"defaultextension",
"=",
"'.*'",
",",
"initialdir",
"=",
"os",
".",
"getcwd",
"(",
")",
",",
... | Do the front-end stuff for adding files to peat | [
"Do",
"the",
"front",
"-",
"end",
"stuff",
"for",
"adding",
"files",
"to",
"peat"
] | [
"\"\"\"Do the front-end stuff for adding files to peat\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "filerec",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filerec",
"type": null,
"docstring": null,
"docstring_tokens"... |
9b67cac376e4d17ff120bf019f1276364aba99d2 | shambo001/peat | PEATDB/Extfile.py | [
"MIT"
] | Python | importFileset | <not_specific> | def importFileset(self, DB, parentframe=None, callback=None):
"""Import a series of external files in a folder to peat"""
def getdir():
import tkFileDialog, os
d=tkFileDialog.askdirectory(initialdir=importdir.get(),title='Select directory files',
... | Import a series of external files in a folder to peat | Import a series of external files in a folder to peat | [
"Import",
"a",
"series",
"of",
"external",
"files",
"in",
"a",
"folder",
"to",
"peat"
] | def importFileset(self, DB, parentframe=None, callback=None):
def getdir():
import tkFileDialog, os
d=tkFileDialog.askdirectory(initialdir=importdir.get(),title='Select directory files',
mustexist=1,parent=self.parent.master)
if... | [
"def",
"importFileset",
"(",
"self",
",",
"DB",
",",
"parentframe",
"=",
"None",
",",
"callback",
"=",
"None",
")",
":",
"def",
"getdir",
"(",
")",
":",
"import",
"tkFileDialog",
",",
"os",
"d",
"=",
"tkFileDialog",
".",
"askdirectory",
"(",
"initialdir"... | Import a series of external files in a folder to peat | [
"Import",
"a",
"series",
"of",
"external",
"files",
"in",
"a",
"folder",
"to",
"peat"
] | [
"\"\"\"Import a series of external files in a folder to peat\"\"\"",
"#iterate over filenames in folder and add one rec to DB for each file"
] | [
{
"param": "self",
"type": null
},
{
"param": "DB",
"type": null
},
{
"param": "parentframe",
"type": null
},
{
"param": "callback",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "DB",
"type": null,
"docstring": null,
"docstring_tokens": [],... |
9b67cac376e4d17ff120bf019f1276364aba99d2 | shambo001/peat | PEATDB/Extfile.py | [
"MIT"
] | Python | exportExtFiles | <not_specific> | def exportExtFiles(self, DB):
"""Get all stored ext files in DB and save to folder"""
import tkFileDialog, os, shutil
expdir=tkFileDialog.askdirectory(initialdir=os.getcwd(),title='Select a directory',
mustexist=1,parent=self.parent.master)
if no... | Get all stored ext files in DB and save to folder | Get all stored ext files in DB and save to folder | [
"Get",
"all",
"stored",
"ext",
"files",
"in",
"DB",
"and",
"save",
"to",
"folder"
] | def exportExtFiles(self, DB):
import tkFileDialog, os, shutil
expdir=tkFileDialog.askdirectory(initialdir=os.getcwd(),title='Select a directory',
mustexist=1,parent=self.parent.master)
if not expdir:
return
path = os.path.join(expdir,... | [
"def",
"exportExtFiles",
"(",
"self",
",",
"DB",
")",
":",
"import",
"tkFileDialog",
",",
"os",
",",
"shutil",
"expdir",
"=",
"tkFileDialog",
".",
"askdirectory",
"(",
"initialdir",
"=",
"os",
".",
"getcwd",
"(",
")",
",",
"title",
"=",
"'Select a director... | Get all stored ext files in DB and save to folder | [
"Get",
"all",
"stored",
"ext",
"files",
"in",
"DB",
"and",
"save",
"to",
"folder"
] | [
"\"\"\"Get all stored ext files in DB and save to folder\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "DB",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "DB",
"type": null,
"docstring": null,
"docstring_tokens": [],... |
9b67cac376e4d17ff120bf019f1276364aba99d2 | shambo001/peat | PEATDB/Extfile.py | [
"MIT"
] | Python | displayExtFiles | <not_specific> | def displayExtFiles(self, DB):
"""Display blobs in DB as web page links"""
files = DB.getExtFilenames()
print files
if len(files) == 0:
return
items=[]
for f in files:
print f, files[f]
items.append('<a href=%s>%s</a>' %(files[f],f)
... | Display blobs in DB as web page links | Display blobs in DB as web page links | [
"Display",
"blobs",
"in",
"DB",
"as",
"web",
"page",
"links"
] | def displayExtFiles(self, DB):
files = DB.getExtFilenames()
print files
if len(files) == 0:
return
items=[]
for f in files:
print f, files[f]
items.append('<a href=%s>%s</a>' %(files[f],f)
)
import markup
... | [
"def",
"displayExtFiles",
"(",
"self",
",",
"DB",
")",
":",
"files",
"=",
"DB",
".",
"getExtFilenames",
"(",
")",
"print",
"files",
"if",
"len",
"(",
"files",
")",
"==",
"0",
":",
"return",
"items",
"=",
"[",
"]",
"for",
"f",
"in",
"files",
":",
... | Display blobs in DB as web page links | [
"Display",
"blobs",
"in",
"DB",
"as",
"web",
"page",
"links"
] | [
"\"\"\"Display blobs in DB as web page links\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "DB",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "DB",
"type": null,
"docstring": null,
"docstring_tokens": [],... |
e936adce12944a8236663838afcb666c65c4f445 | shambo001/peat | pKa/prepare_for_pKa_design.py | [
"MIT"
] | Python | send_email | <not_specific> | def send_email(address,message):
"""Send an email to the address saying that prepration for the dir is done"""
import smtplib
from email.MIMEText import MIMEText
from email.MIMEMultipart import MIMEMultipart
from email.MIMENonMultipart import MIMENonMultipart
from email.MIMEBase import MIMEBase
... | Send an email to the address saying that prepration for the dir is done | Send an email to the address saying that prepration for the dir is done | [
"Send",
"an",
"email",
"to",
"the",
"address",
"saying",
"that",
"prepration",
"for",
"the",
"dir",
"is",
"done"
] | def send_email(address,message):
import smtplib
from email.MIMEText import MIMEText
from email.MIMEMultipart import MIMEMultipart
from email.MIMENonMultipart import MIMENonMultipart
from email.MIMEBase import MIMEBase
from email import Encoders
import mimetypes
Prepare the message
t... | [
"def",
"send_email",
"(",
"address",
",",
"message",
")",
":",
"import",
"smtplib",
"from",
"email",
".",
"MIMEText",
"import",
"MIMEText",
"from",
"email",
".",
"MIMEMultipart",
"import",
"MIMEMultipart",
"from",
"email",
".",
"MIMENonMultipart",
"import",
"MIM... | Send an email to the address saying that prepration for the dir is done | [
"Send",
"an",
"email",
"to",
"the",
"address",
"saying",
"that",
"prepration",
"for",
"the",
"dir",
"is",
"done"
] | [
"\"\"\"Send an email to the address saying that prepration for the dir is done\"\"\"",
"#",
"# Prepare the message",
"#",
"#",
"# Send the email",
"#",
"#sys.stdout=X",
"#mail.ucd.ie"
] | [
{
"param": "address",
"type": null
},
{
"param": "message",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "address",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "message",
"type": null,
"docstring": null,
"docstring_toke... |
e936adce12944a8236663838afcb666c65c4f445 | shambo001/peat | pKa/prepare_for_pKa_design.py | [
"MIT"
] | Python | do_pKa_calc | <not_specific> | def do_pKa_calc(pdbfile):
"""Perform a pKa calculation on the PDB file"""
#
# Get the name of the PDB file
#
import os
pdb_name=os.path.split(pdbfile)[1]
pdb_dir=os.path.split(pdbfile)[0]
topdir=os.getcwd()
#
# Prepare the PDB file
#
import pKarun.WI_tools
logfile,fil... | Perform a pKa calculation on the PDB file | Perform a pKa calculation on the PDB file | [
"Perform",
"a",
"pKa",
"calculation",
"on",
"the",
"PDB",
"file"
] | def do_pKa_calc(pdbfile):
Get the name of the PDB file
import os
pdb_name=os.path.split(pdbfile)[1]
pdb_dir=os.path.split(pdbfile)[0]
topdir=os.getcwd()
Prepare the PDB file
import pKarun.WI_tools
logfile,files=pKarun.WI_tools.dellig_delhyd_corall(pdbfile=pdbfile,readall=None,setcha=No... | [
"def",
"do_pKa_calc",
"(",
"pdbfile",
")",
":",
"import",
"os",
"pdb_name",
"=",
"os",
".",
"path",
".",
"split",
"(",
"pdbfile",
")",
"[",
"1",
"]",
"pdb_dir",
"=",
"os",
".",
"path",
".",
"split",
"(",
"pdbfile",
")",
"[",
"0",
"]",
"topdir",
"... | Perform a pKa calculation on the PDB file | [
"Perform",
"a",
"pKa",
"calculation",
"on",
"the",
"PDB",
"file"
] | [
"\"\"\"Perform a pKa calculation on the PDB file\"\"\"",
"#",
"# Get the name of the PDB file",
"#",
"#",
"# Prepare the PDB file",
"#",
"#",
"# Overwrite the file",
"#",
"#",
"# Write failed file",
"#",
"#",
"# copy the PDB file and the parameter files",
"#",
"#",
"# Start pKa cal... | [
{
"param": "pdbfile",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "pdbfile",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
b7165a8df9eea1bd90027aa0cd5d4c9878040b6c | shambo001/peat | Protool/Yasara_handler.py | [
"MIT"
] | Python | col_res | <not_specific> | def col_res(self,obj,residues,color):
"""Color a number of residues a color"""
if type(residues) is type([]):
for res in residues:
self.yasara.ColorRes("%d Obj %d" %(res,obj),color)
else:
for res in residues.keys():
#print "%d Obj %d" %(res... | Color a number of residues a color | Color a number of residues a color | [
"Color",
"a",
"number",
"of",
"residues",
"a",
"color"
] | def col_res(self,obj,residues,color):
if type(residues) is type([]):
for res in residues:
self.yasara.ColorRes("%d Obj %d" %(res,obj),color)
else:
for res in residues.keys():
self.yasara.ColorRes("%d Obj %d" %(res,obj),int(120*residues[res]))
... | [
"def",
"col_res",
"(",
"self",
",",
"obj",
",",
"residues",
",",
"color",
")",
":",
"if",
"type",
"(",
"residues",
")",
"is",
"type",
"(",
"[",
"]",
")",
":",
"for",
"res",
"in",
"residues",
":",
"self",
".",
"yasara",
".",
"ColorRes",
"(",
"\"%d... | Color a number of residues a color | [
"Color",
"a",
"number",
"of",
"residues",
"a",
"color"
] | [
"\"\"\"Color a number of residues a color\"\"\"",
"#print \"%d Obj %d\" %(res,obj),int(180*residues[res])"
] | [
{
"param": "self",
"type": null
},
{
"param": "obj",
"type": null
},
{
"param": "residues",
"type": null
},
{
"param": "color",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "obj",
"type": null,
"docstring": null,
"docstring_tokens": []... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | WeightChangeForMutation | <not_specific> | def WeightChangeForMutation(mutationCode):
'''Calculates the change in Molecular Weight due to a mutation
Params:
mutationCode - must be in extended format (contain the wild-type residue code)
Returns
The difference in mw between new and old residues i.e. (New - Old)
'''
if IsReducedCode(mutationCode)... | Calculates the change in Molecular Weight due to a mutation
Params:
mutationCode - must be in extended format (contain the wild-type residue code)
Returns
The difference in mw between new and old residues i.e. (New - Old)
| Calculates the change in Molecular Weight due to a mutation
Params:
mutationCode - must be in extended format (contain the wild-type residue code)
Returns
The difference in mw between new and old residues i.e. (New - Old) | [
"Calculates",
"the",
"change",
"in",
"Molecular",
"Weight",
"due",
"to",
"a",
"mutation",
"Params",
":",
"mutationCode",
"-",
"must",
"be",
"in",
"extended",
"format",
"(",
"contain",
"the",
"wild",
"-",
"type",
"residue",
"code",
")",
"Returns",
"The",
"d... | def WeightChangeForMutation(mutationCode):
if IsReducedCode(mutationCode):
mutationCode = ConvertMutationCodeFromReducedFormat(mutationCode, extended=True)
components = ParseMutationCode(mutationCode)
if(len(components) != 4):
raise ValueError, 'Mutation code must be extended to determine weight change'
return ... | [
"def",
"WeightChangeForMutation",
"(",
"mutationCode",
")",
":",
"if",
"IsReducedCode",
"(",
"mutationCode",
")",
":",
"mutationCode",
"=",
"ConvertMutationCodeFromReducedFormat",
"(",
"mutationCode",
",",
"extended",
"=",
"True",
")",
"components",
"=",
"ParseMutatio... | Calculates the change in Molecular Weight due to a mutation
Params:
mutationCode - must be in extended format (contain the wild-type residue code) | [
"Calculates",
"the",
"change",
"in",
"Molecular",
"Weight",
"due",
"to",
"a",
"mutation",
"Params",
":",
"mutationCode",
"-",
"must",
"be",
"in",
"extended",
"format",
"(",
"contain",
"the",
"wild",
"-",
"type",
"residue",
"code",
")"
] | [
"'''Calculates the change in Molecular Weight due to a mutation\n\t\n\tParams:\n\t\tmutationCode - must be in extended format (contain the wild-type residue code)\n\t\t\n\tReturns\n\t\tThe difference in mw between new and old residues i.e. (New - Old)\t\n\t'''"
] | [
{
"param": "mutationCode",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "mutationCode",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | VolumeChangeForMutation | <not_specific> | def VolumeChangeForMutation(mutationCode):
'''Calculates the change in Molecular Weight due to a mutation
Params:
mutationCode - must be in extended format (contain the wild-type residue code)
Returns
The difference in mw between new and old residues i.e. (New - Old)
'''
if IsReducedCode(mutationCode)... | Calculates the change in Molecular Weight due to a mutation
Params:
mutationCode - must be in extended format (contain the wild-type residue code)
Returns
The difference in mw between new and old residues i.e. (New - Old)
| Calculates the change in Molecular Weight due to a mutation
Params:
mutationCode - must be in extended format (contain the wild-type residue code)
Returns
The difference in mw between new and old residues i.e. (New - Old) | [
"Calculates",
"the",
"change",
"in",
"Molecular",
"Weight",
"due",
"to",
"a",
"mutation",
"Params",
":",
"mutationCode",
"-",
"must",
"be",
"in",
"extended",
"format",
"(",
"contain",
"the",
"wild",
"-",
"type",
"residue",
"code",
")",
"Returns",
"The",
"d... | def VolumeChangeForMutation(mutationCode):
if IsReducedCode(mutationCode):
mutationCode = ConvertMutationCodeFromReducedFormat(mutationCode, extended=True)
components = ParseMutationCode(mutationCode)
if(len(components) != 4):
raise ValueError, 'Mutation code must be extended to determine weight change'
return ... | [
"def",
"VolumeChangeForMutation",
"(",
"mutationCode",
")",
":",
"if",
"IsReducedCode",
"(",
"mutationCode",
")",
":",
"mutationCode",
"=",
"ConvertMutationCodeFromReducedFormat",
"(",
"mutationCode",
",",
"extended",
"=",
"True",
")",
"components",
"=",
"ParseMutatio... | Calculates the change in Molecular Weight due to a mutation
Params:
mutationCode - must be in extended format (contain the wild-type residue code) | [
"Calculates",
"the",
"change",
"in",
"Molecular",
"Weight",
"due",
"to",
"a",
"mutation",
"Params",
":",
"mutationCode",
"-",
"must",
"be",
"in",
"extended",
"format",
"(",
"contain",
"the",
"wild",
"-",
"type",
"residue",
"code",
")"
] | [
"'''Calculates the change in Molecular Weight due to a mutation\n\t\n\tParams:\n\t\tmutationCode - must be in extended format (contain the wild-type residue code)\n\t\t\n\tReturns\n\t\tThe difference in mw between new and old residues i.e. (New - Old)\t\n\t'''"
] | [
{
"param": "mutationCode",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "mutationCode",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | CreateBarChartData | <not_specific> | def CreateBarChartData(matrix, column, **options):
'''Returns a binary string representing a bar chart image with the given options'''
print options
options["matrix"] = matrix
options["column"] = column
options["outputFile"] = 'picture.png'
options["xaxis"] = None
CreateBarChart(**options)
print 'Reading char... | Returns a binary string representing a bar chart image with the given options | Returns a binary string representing a bar chart image with the given options | [
"Returns",
"a",
"binary",
"string",
"representing",
"a",
"bar",
"chart",
"image",
"with",
"the",
"given",
"options"
] | def CreateBarChartData(matrix, column, **options):
print options
options["matrix"] = matrix
options["column"] = column
options["outputFile"] = 'picture.png'
options["xaxis"] = None
CreateBarChart(**options)
print 'Reading chart'
stream = open('picture.png')
data = stream.read()
stream.close()
os.remove('pict... | [
"def",
"CreateBarChartData",
"(",
"matrix",
",",
"column",
",",
"**",
"options",
")",
":",
"print",
"options",
"options",
"[",
"\"matrix\"",
"]",
"=",
"matrix",
"options",
"[",
"\"column\"",
"]",
"=",
"column",
"options",
"[",
"\"outputFile\"",
"]",
"=",
"... | Returns a binary string representing a bar chart image with the given options | [
"Returns",
"a",
"binary",
"string",
"representing",
"a",
"bar",
"chart",
"image",
"with",
"the",
"given",
"options"
] | [
"'''Returns a binary string representing a bar chart image with the given options'''"
] | [
{
"param": "matrix",
"type": null
},
{
"param": "column",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "matrix",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "column",
"type": null,
"docstring": null,
"docstring_tokens... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | CreateBarChart | <not_specific> | def CreateBarChart(matrix, column, outputFile, xaxis=None, **options):
'''Creates a bar chart out of the specified data
Parameters:
Matrix: A Matrix.Matrix instance containing the data to create the chart from
column: The name of the column containing the value (yAxis) data
outputFile: The file to write the ... | Creates a bar chart out of the specified data
Parameters:
Matrix: A Matrix.Matrix instance containing the data to create the chart from
column: The name of the column containing the value (yAxis) data
outputFile: The file to write the chart to
xaxis: The name of the column containing the xaxis values.
If ... | Creates a bar chart out of the specified data | [
"Creates",
"a",
"bar",
"chart",
"out",
"of",
"the",
"specified",
"data"
] | def CreateBarChart(matrix, column, outputFile, xaxis=None, **options):
string = '''set datafile separator ','
set xlabel '%s'
#set xtics nomirror %d
set ylabel '%s'
set term png size 1280,800
set output '%s'
set boxwidth 0.5 relative
set style fill solid 0.8
plot '%s' u %d:%d with boxes t '%s' '''
stream = open('.mat... | [
"def",
"CreateBarChart",
"(",
"matrix",
",",
"column",
",",
"outputFile",
",",
"xaxis",
"=",
"None",
",",
"**",
"options",
")",
":",
"string",
"=",
"'''set datafile separator ','\nset xlabel '%s'\n#set xtics nomirror %d\nset ylabel '%s'\nset term png size 1280,800\nset output '... | Creates a bar chart out of the specified data | [
"Creates",
"a",
"bar",
"chart",
"out",
"of",
"the",
"specified",
"data"
] | [
"'''Creates a bar chart out of the specified data\n\t\n\tParameters:\n\t\tMatrix: A Matrix.Matrix instance containing the data to create the chart from\n\t\tcolumn: The name of the column containing the value (yAxis) data\n\t\toutputFile: The file to write the chart to\n\t\txaxis: The name of the column containing ... | [
{
"param": "matrix",
"type": null
},
{
"param": "column",
"type": null
},
{
"param": "outputFile",
"type": null
},
{
"param": "xaxis",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "matrix",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "column",
"type": null,
"docstring": "The name of the column conta... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | GetTraceback | <not_specific> | def GetTraceback():
'''Returns the current stack traceback as a string'''
#Get the traceback as a string = convoluted ....
trace = traceback.format_list(traceback.extract_tb(sys.exc_info()[2]))
trace = reduce(lambda x, y: x + y, trace)
#Need to remove single quotes from the traceback
trace = trace.replace("'"... | Returns the current stack traceback as a string | Returns the current stack traceback as a string | [
"Returns",
"the",
"current",
"stack",
"traceback",
"as",
"a",
"string"
] | def GetTraceback():
trace = traceback.format_list(traceback.extract_tb(sys.exc_info()[2]))
trace = reduce(lambda x, y: x + y, trace)
trace = trace.replace("'", " ")
return trace | [
"def",
"GetTraceback",
"(",
")",
":",
"trace",
"=",
"traceback",
".",
"format_list",
"(",
"traceback",
".",
"extract_tb",
"(",
"sys",
".",
"exc_info",
"(",
")",
"[",
"2",
"]",
")",
")",
"trace",
"=",
"reduce",
"(",
"lambda",
"x",
",",
"y",
":",
"x"... | Returns the current stack traceback as a string | [
"Returns",
"the",
"current",
"stack",
"traceback",
"as",
"a",
"string"
] | [
"'''Returns the current stack traceback as a string'''",
"#Get the traceback as a string = convoluted ....",
"#Need to remove single quotes from the traceback\t"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | IsExtendedMutationFormat | <not_specific> | def IsExtendedMutationFormat(code):
'''Returns True if code is in extended format.
That is, it contains both the residue and the mutation name
Parameters:
code: A mutation code - can be normal or reduced'''
isExtended = True
if IsReducedCode(code):
#Check if the second last element is a string or a nu... | Returns True if code is in extended format.
That is, it contains both the residue and the mutation name
Parameters:
code: A mutation code - can be normal or reduced | Returns True if code is in extended format.
That is, it contains both the residue and the mutation name | [
"Returns",
"True",
"if",
"code",
"is",
"in",
"extended",
"format",
".",
"That",
"is",
"it",
"contains",
"both",
"the",
"residue",
"and",
"the",
"mutation",
"name"
] | def IsExtendedMutationFormat(code):
isExtended = True
if IsReducedCode(code):
try:
element = code[-2]
int(element)
isExtended = False
except ValueError:
pass
except IndexError:
raise Exceptions.MutationCodeFormatError, 'Code %s does not have enough elements' % code
else:
components = code.s... | [
"def",
"IsExtendedMutationFormat",
"(",
"code",
")",
":",
"isExtended",
"=",
"True",
"if",
"IsReducedCode",
"(",
"code",
")",
":",
"try",
":",
"element",
"=",
"code",
"[",
"-",
"2",
"]",
"int",
"(",
"element",
")",
"isExtended",
"=",
"False",
"except",
... | Returns True if code is in extended format. | [
"Returns",
"True",
"if",
"code",
"is",
"in",
"extended",
"format",
"."
] | [
"'''Returns True if code is in extended format.\n\t\n\tThat is, it contains both the residue and the mutation name\n\t\n\tParameters:\n\t\tcode: A mutation code - can be normal or reduced'''",
"#Check if the second last element is a string or a number",
"#Check if there are four components separated by colons"
... | [
{
"param": "code",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "code",
"type": null,
"docstring": "A mutation code - can be normal or reduced",
"docstring_tokens": [
"A",
"mutation",
"code",
"-",
"can",
"be",
"normal",
"or",
... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | IsExtendedResidueFormat | <not_specific> | def IsExtendedResidueFormat(code):
'''Returns True if code is in extended format.
That is, it contains both the residue number and the residue name
Parameters:
code: A residue code - can be normal or reduced'''
isExtended = True
if IsReducedCode(code):
#Check if the last element is a string or a numbe... | Returns True if code is in extended format.
That is, it contains both the residue number and the residue name
Parameters:
code: A residue code - can be normal or reduced | Returns True if code is in extended format.
That is, it contains both the residue number and the residue name | [
"Returns",
"True",
"if",
"code",
"is",
"in",
"extended",
"format",
".",
"That",
"is",
"it",
"contains",
"both",
"the",
"residue",
"number",
"and",
"the",
"residue",
"name"
] | def IsExtendedResidueFormat(code):
isExtended = True
if IsReducedCode(code):
element = code[-1]
try:
int(element)
isExtended = False
except ValueError:
pass
else:
components = code.split(':')
if len(components) == 2:
isExtended = False
return isExtended | [
"def",
"IsExtendedResidueFormat",
"(",
"code",
")",
":",
"isExtended",
"=",
"True",
"if",
"IsReducedCode",
"(",
"code",
")",
":",
"element",
"=",
"code",
"[",
"-",
"1",
"]",
"try",
":",
"int",
"(",
"element",
")",
"isExtended",
"=",
"False",
"except",
... | Returns True if code is in extended format. | [
"Returns",
"True",
"if",
"code",
"is",
"in",
"extended",
"format",
"."
] | [
"'''Returns True if code is in extended format.\n\t\n\tThat is, it contains both the residue number and the residue name\n\t\n\tParameters:\n\t\tcode: A residue code - can be normal or reduced'''",
"#Check if the last element is a string or a number",
"#Check if there are three components separated by colons"
] | [
{
"param": "code",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "code",
"type": null,
"docstring": "A residue code - can be normal or reduced",
"docstring_tokens": [
"A",
"residue",
"code",
"-",
"can",
"be",
"normal",
"or",
... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | IsReducedCode | <not_specific> | def IsReducedCode(code):
'''Returns True is code is in reduced format, false otherwise.
A code is in reduced format simply if it contains no colons'''
components = code.split(':')
if len(components) == 1:
return True
else:
return False | Returns True is code is in reduced format, false otherwise.
A code is in reduced format simply if it contains no colons | Returns True is code is in reduced format, false otherwise.
A code is in reduced format simply if it contains no colons | [
"Returns",
"True",
"is",
"code",
"is",
"in",
"reduced",
"format",
"false",
"otherwise",
".",
"A",
"code",
"is",
"in",
"reduced",
"format",
"simply",
"if",
"it",
"contains",
"no",
"colons"
] | def IsReducedCode(code):
components = code.split(':')
if len(components) == 1:
return True
else:
return False | [
"def",
"IsReducedCode",
"(",
"code",
")",
":",
"components",
"=",
"code",
".",
"split",
"(",
"':'",
")",
"if",
"len",
"(",
"components",
")",
"==",
"1",
":",
"return",
"True",
"else",
":",
"return",
"False"
] | Returns True is code is in reduced format, false otherwise. | [
"Returns",
"True",
"is",
"code",
"is",
"in",
"reduced",
"format",
"false",
"otherwise",
"."
] | [
"'''Returns True is code is in reduced format, false otherwise.\n\t\n\tA code is in reduced format simply if it contains no colons'''"
] | [
{
"param": "code",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "code",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | CreateResidueCode | <not_specific> | def CreateResidueCode(chain, number, name=None):
'''Creates a residue code from a chain id and residue number and optionally a name
A normal residue code has the form ChainID:ResidueIndex where the residue index is a
string of length 4 left padded with zeros.
For example passing A, 4 return A:0004.
If a name ... | Creates a residue code from a chain id and residue number and optionally a name
A normal residue code has the form ChainID:ResidueIndex where the residue index is a
string of length 4 left padded with zeros.
For example passing A, 4 return A:0004.
If a name is passed an extended residue code is returned. This h... | Creates a residue code from a chain id and residue number and optionally a name
A normal residue code has the form ChainID:ResidueIndex where the residue index is a
string of length 4 left padded with zeros.
For example passing A, 4 return A:0004.
If a name is passed an extended residue code is returned. | [
"Creates",
"a",
"residue",
"code",
"from",
"a",
"chain",
"id",
"and",
"residue",
"number",
"and",
"optionally",
"a",
"name",
"A",
"normal",
"residue",
"code",
"has",
"the",
"form",
"ChainID",
":",
"ResidueIndex",
"where",
"the",
"residue",
"index",
"is",
"... | def CreateResidueCode(chain, number, name=None):
if name is None:
return chain + ":" + "0"*(4 - len(str(number))) + str(number)
else:
return chain + ":" + "0"*(4 - len(str(number))) + str(number) + ":" + name | [
"def",
"CreateResidueCode",
"(",
"chain",
",",
"number",
",",
"name",
"=",
"None",
")",
":",
"if",
"name",
"is",
"None",
":",
"return",
"chain",
"+",
"\":\"",
"+",
"\"0\"",
"*",
"(",
"4",
"-",
"len",
"(",
"str",
"(",
"number",
")",
")",
")",
"+",... | Creates a residue code from a chain id and residue number and optionally a name
A normal residue code has the form ChainID:ResidueIndex where the residue index is a
string of length 4 left padded with zeros. | [
"Creates",
"a",
"residue",
"code",
"from",
"a",
"chain",
"id",
"and",
"residue",
"number",
"and",
"optionally",
"a",
"name",
"A",
"normal",
"residue",
"code",
"has",
"the",
"form",
"ChainID",
":",
"ResidueIndex",
"where",
"the",
"residue",
"index",
"is",
"... | [
"'''Creates a residue code from a chain id and residue number and optionally a name\n\t\n\tA normal residue code has the form ChainID:ResidueIndex where the residue index is a\n\tstring of length 4 left padded with zeros.\n\tFor example passing A, 4 return A:0004.\n\t\n\tIf a name is passed an extended residue code... | [
{
"param": "chain",
"type": null
},
{
"param": "number",
"type": null
},
{
"param": "name",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "chain",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "number",
"type": null,
"docstring": null,
"docstring_tokens"... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ParseStandardResidueCode | <not_specific> | def ParseStandardResidueCode(residueCode, extended=False):
'''Parses a residue code returning the chain and residueIndex (as an int).
Set extended to True if the code is in extended format,
See CreateResidueCode for information on the residue code format.
Raises an Exceptions.ResidueCodeError if the residue c... | Parses a residue code returning the chain and residueIndex (as an int).
Set extended to True if the code is in extended format,
See CreateResidueCode for information on the residue code format.
Raises an Exceptions.ResidueCodeError if the residue code is not in the correct format | Parses a residue code returning the chain and residueIndex (as an int).
Set extended to True if the code is in extended format,
See CreateResidueCode for information on the residue code format.
Raises an Exceptions.ResidueCodeError if the residue code is not in the correct format | [
"Parses",
"a",
"residue",
"code",
"returning",
"the",
"chain",
"and",
"residueIndex",
"(",
"as",
"an",
"int",
")",
".",
"Set",
"extended",
"to",
"True",
"if",
"the",
"code",
"is",
"in",
"extended",
"format",
"See",
"CreateResidueCode",
"for",
"information",
... | def ParseStandardResidueCode(residueCode, extended=False):
components = residueCode.split(':')
try:
if components[1] != '0000':
data = (components[0], int(components[1].lstrip('0'))) + tuple(components[2:])
else:
data = (components[0], int(components[1])) + tuple(components[2:])
except BaseException, dat... | [
"def",
"ParseStandardResidueCode",
"(",
"residueCode",
",",
"extended",
"=",
"False",
")",
":",
"components",
"=",
"residueCode",
".",
"split",
"(",
"':'",
")",
"try",
":",
"if",
"components",
"[",
"1",
"]",
"!=",
"'0000'",
":",
"data",
"=",
"(",
"compon... | Parses a residue code returning the chain and residueIndex (as an int). | [
"Parses",
"a",
"residue",
"code",
"returning",
"the",
"chain",
"and",
"residueIndex",
"(",
"as",
"an",
"int",
")",
"."
] | [
"'''Parses a residue code returning the chain and residueIndex (as an int).\n\t\n\tSet extended to True if the code is in extended format,\n\tSee CreateResidueCode for information on the residue code format.\n\t\n\tRaises an Exceptions.ResidueCodeError if the residue code is not in the correct format'''"
] | [
{
"param": "residueCode",
"type": null
},
{
"param": "extended",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "residueCode",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "extended",
"type": null,
"docstring": null,
"docstring... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ParseReducedResidueCode | <not_specific> | def ParseReducedResidueCode(code, extended=False):
'''Returns the chain, the residue index and the residue name'''
invertedMap = InvertedCodeDictionary()
noChain = False
if not code[0].isalpha():
noChain = True
chainId = ""
indexStart = 0
try:
if not noChain:
chainId = code[0]
indexStart = 1
... | Returns the chain, the residue index and the residue name | Returns the chain, the residue index and the residue name | [
"Returns",
"the",
"chain",
"the",
"residue",
"index",
"and",
"the",
"residue",
"name"
] | def ParseReducedResidueCode(code, extended=False):
invertedMap = InvertedCodeDictionary()
noChain = False
if not code[0].isalpha():
noChain = True
chainId = ""
indexStart = 0
try:
if not noChain:
chainId = code[0]
indexStart = 1
if extended is True:
index = code[indexStart:-1]
return chainId, ... | [
"def",
"ParseReducedResidueCode",
"(",
"code",
",",
"extended",
"=",
"False",
")",
":",
"invertedMap",
"=",
"InvertedCodeDictionary",
"(",
")",
"noChain",
"=",
"False",
"if",
"not",
"code",
"[",
"0",
"]",
".",
"isalpha",
"(",
")",
":",
"noChain",
"=",
"T... | Returns the chain, the residue index and the residue name | [
"Returns",
"the",
"chain",
"the",
"residue",
"index",
"and",
"the",
"residue",
"name"
] | [
"'''Returns the chain, the residue index and the residue name'''"
] | [
{
"param": "code",
"type": null
},
{
"param": "extended",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "code",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "extended",
"type": null,
"docstring": null,
"docstring_tokens... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ParseResidueCode | <not_specific> | def ParseResidueCode(code):
'''Parses residue code returning chain, residue index and the residue name if present
code can be in any format. However if the code has an error it may be misidentifed'''
extended = IsExtendedResidueFormat(code)
if IsReducedCode(code):
return ParseReducedResidueCo... | Parses residue code returning chain, residue index and the residue name if present
code can be in any format. However if the code has an error it may be misidentifed | Parses residue code returning chain, residue index and the residue name if present
code can be in any format. However if the code has an error it may be misidentifed | [
"Parses",
"residue",
"code",
"returning",
"chain",
"residue",
"index",
"and",
"the",
"residue",
"name",
"if",
"present",
"code",
"can",
"be",
"in",
"any",
"format",
".",
"However",
"if",
"the",
"code",
"has",
"an",
"error",
"it",
"may",
"be",
"misidentifed... | def ParseResidueCode(code):
extended = IsExtendedResidueFormat(code)
if IsReducedCode(code):
return ParseReducedResidueCode(code, extended=extended)
else:
return ParseStandardResidueCode(code, extended=extended) | [
"def",
"ParseResidueCode",
"(",
"code",
")",
":",
"extended",
"=",
"IsExtendedResidueFormat",
"(",
"code",
")",
"if",
"IsReducedCode",
"(",
"code",
")",
":",
"return",
"ParseReducedResidueCode",
"(",
"code",
",",
"extended",
"=",
"extended",
")",
"else",
":",
... | Parses residue code returning chain, residue index and the residue name if present
code can be in any format. | [
"Parses",
"residue",
"code",
"returning",
"chain",
"residue",
"index",
"and",
"the",
"residue",
"name",
"if",
"present",
"code",
"can",
"be",
"in",
"any",
"format",
"."
] | [
"'''Parses residue code returning chain, residue index and the residue name if present\n\t\n\tcode can be in any format. However if the code has an error it may be misidentifed'''"
] | [
{
"param": "code",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "code",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ParseStandardMutationCode | <not_specific> | def ParseStandardMutationCode(mutationCode, extended=False):
'''Parses an mutation code returning the chain, residueIndex (as an int) and mutationName (non-extended format)
If the mutationCode is in extended format this function additionally returns the residueName before the mutationName
See CreateExtendedResidu... | Parses an mutation code returning the chain, residueIndex (as an int) and mutationName (non-extended format)
If the mutationCode is in extended format this function additionally returns the residueName before the mutationName
See CreateExtendedResidueCode for information on the extended residue code format.
Rais... | Parses an mutation code returning the chain, residueIndex (as an int) and mutationName (non-extended format)
If the mutationCode is in extended format this function additionally returns the residueName before the mutationName
See CreateExtendedResidueCode for information on the extended residue code format.
Raises an ... | [
"Parses",
"an",
"mutation",
"code",
"returning",
"the",
"chain",
"residueIndex",
"(",
"as",
"an",
"int",
")",
"and",
"mutationName",
"(",
"non",
"-",
"extended",
"format",
")",
"If",
"the",
"mutationCode",
"is",
"in",
"extended",
"format",
"this",
"function"... | def ParseStandardMutationCode(mutationCode, extended=False):
mutationCode = mutationCode.strip(" ")
components = mutationCode.split(':')
try:
if components[1] != '0000':
data = (components[0], int(components[1].lstrip('0'))) + tuple(components[2:])
else:
data = (components[0], int(components[1])) + tuple(c... | [
"def",
"ParseStandardMutationCode",
"(",
"mutationCode",
",",
"extended",
"=",
"False",
")",
":",
"mutationCode",
"=",
"mutationCode",
".",
"strip",
"(",
"\" \"",
")",
"components",
"=",
"mutationCode",
".",
"split",
"(",
"':'",
")",
"try",
":",
"if",
"compo... | Parses an mutation code returning the chain, residueIndex (as an int) and mutationName (non-extended format)
If the mutationCode is in extended format this function additionally returns the residueName before the mutationName
See CreateExtendedResidueCode for information on the extended residue code format. | [
"Parses",
"an",
"mutation",
"code",
"returning",
"the",
"chain",
"residueIndex",
"(",
"as",
"an",
"int",
")",
"and",
"mutationName",
"(",
"non",
"-",
"extended",
"format",
")",
"If",
"the",
"mutationCode",
"is",
"in",
"extended",
"format",
"this",
"function"... | [
"'''Parses an mutation code returning the chain, residueIndex (as an int) and mutationName (non-extended format)\n\t\n\tIf the mutationCode is in extended format this function additionally returns the residueName before the mutationName\n\tSee CreateExtendedResidueCode for information on the extended residue code f... | [
{
"param": "mutationCode",
"type": null
},
{
"param": "extended",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "mutationCode",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "extended",
"type": null,
"docstring": null,
"docstrin... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ParseReducedMutationCode | <not_specific> | def ParseReducedMutationCode(code, extended=False):
'''Parse the reduced mutation code.
If the reduced code includes the original residue name set extendedFormat to be true.
If the code is not in extendedFormat this function returns the chain, the residue index and the mutation name
in that order.
Otherwise it... | Parse the reduced mutation code.
If the reduced code includes the original residue name set extendedFormat to be true.
If the code is not in extendedFormat this function returns the chain, the residue index and the mutation name
in that order.
Otherwise it returns he chain, the residue index, the residue name an... | Parse the reduced mutation code.
If the reduced code includes the original residue name set extendedFormat to be true.
If the code is not in extendedFormat this function returns the chain, the residue index and the mutation name
in that order.
Otherwise it returns he chain, the residue index, the residue name and the m... | [
"Parse",
"the",
"reduced",
"mutation",
"code",
".",
"If",
"the",
"reduced",
"code",
"includes",
"the",
"original",
"residue",
"name",
"set",
"extendedFormat",
"to",
"be",
"true",
".",
"If",
"the",
"code",
"is",
"not",
"in",
"extendedFormat",
"this",
"functio... | def ParseReducedMutationCode(code, extended=False):
try:
invertedMap = InvertedCodeDictionary()
mutation = invertedMap[code[-1]]
data = ParseReducedResidueCode(code[:-1], extended=extended)
return data + (mutation,)
except Exceptions.ResidueCodeFormatError, data:
raise Exceptions.MutationCodeFormatError, da... | [
"def",
"ParseReducedMutationCode",
"(",
"code",
",",
"extended",
"=",
"False",
")",
":",
"try",
":",
"invertedMap",
"=",
"InvertedCodeDictionary",
"(",
")",
"mutation",
"=",
"invertedMap",
"[",
"code",
"[",
"-",
"1",
"]",
"]",
"data",
"=",
"ParseReducedResid... | Parse the reduced mutation code. | [
"Parse",
"the",
"reduced",
"mutation",
"code",
"."
] | [
"'''Parse the reduced mutation code.\n\t\n\tIf the reduced code includes the original residue name set extendedFormat to be true.\n\tIf the code is not in extendedFormat this function returns the chain, the residue index and the mutation name\n\tin that order. \n\tOtherwise it returns he chain, the residue index, t... | [
{
"param": "code",
"type": null
},
{
"param": "extended",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "code",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "extended",
"type": null,
"docstring": null,
"docstring_tokens... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ParseMutationCode | <not_specific> | def ParseMutationCode(code):
'''Parses mutation code returning chain, residue index, residue name if present, and mutation code
code can be in any format'''
extended = IsExtendedMutationFormat(code)
if IsReducedCode(code):
return ParseReducedMutationCode(code, extended=extended)
else:
retu... | Parses mutation code returning chain, residue index, residue name if present, and mutation code
code can be in any format | Parses mutation code returning chain, residue index, residue name if present, and mutation code
code can be in any format | [
"Parses",
"mutation",
"code",
"returning",
"chain",
"residue",
"index",
"residue",
"name",
"if",
"present",
"and",
"mutation",
"code",
"code",
"can",
"be",
"in",
"any",
"format"
] | def ParseMutationCode(code):
extended = IsExtendedMutationFormat(code)
if IsReducedCode(code):
return ParseReducedMutationCode(code, extended=extended)
else:
return ParseStandardMutationCode(code, extended=extended) | [
"def",
"ParseMutationCode",
"(",
"code",
")",
":",
"extended",
"=",
"IsExtendedMutationFormat",
"(",
"code",
")",
"if",
"IsReducedCode",
"(",
"code",
")",
":",
"return",
"ParseReducedMutationCode",
"(",
"code",
",",
"extended",
"=",
"extended",
")",
"else",
":... | Parses mutation code returning chain, residue index, residue name if present, and mutation code
code can be in any format | [
"Parses",
"mutation",
"code",
"returning",
"chain",
"residue",
"index",
"residue",
"name",
"if",
"present",
"and",
"mutation",
"code",
"code",
"can",
"be",
"in",
"any",
"format"
] | [
"'''Parses mutation code returning chain, residue index, residue name if present, and mutation code\n\t\n\tcode can be in any format'''"
] | [
{
"param": "code",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "code",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ConvertMutationCodeToReducedFormat | <not_specific> | def ConvertMutationCodeToReducedFormat(mutationCode, extended=False):
'''Converts a mutation code to a reduced format
e.g. A:0025:ALA:GLY -> A25AG'''
if extended is True:
chain, residueIndex, residueName, mutation = ParseMutationCode(mutationCode)
code = chain + str(residueIndex) + aminoAcidCodes[residu... | Converts a mutation code to a reduced format
e.g. A:0025:ALA:GLY -> A25AG | Converts a mutation code to a reduced format
e.g. | [
"Converts",
"a",
"mutation",
"code",
"to",
"a",
"reduced",
"format",
"e",
".",
"g",
"."
] | def ConvertMutationCodeToReducedFormat(mutationCode, extended=False):
if extended is True:
chain, residueIndex, residueName, mutation = ParseMutationCode(mutationCode)
code = chain + str(residueIndex) + aminoAcidCodes[residueName] + aminoAcidCodes[mutation]
else:
chain, residueIndex, mutation = ParseMutationCo... | [
"def",
"ConvertMutationCodeToReducedFormat",
"(",
"mutationCode",
",",
"extended",
"=",
"False",
")",
":",
"if",
"extended",
"is",
"True",
":",
"chain",
",",
"residueIndex",
",",
"residueName",
",",
"mutation",
"=",
"ParseMutationCode",
"(",
"mutationCode",
")",
... | Converts a mutation code to a reduced format
e.g. | [
"Converts",
"a",
"mutation",
"code",
"to",
"a",
"reduced",
"format",
"e",
".",
"g",
"."
] | [
"'''Converts a mutation code to a reduced format\n\t\n\t e.g. A:0025:ALA:GLY -> A25AG'''"
] | [
{
"param": "mutationCode",
"type": null
},
{
"param": "extended",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "mutationCode",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "extended",
"type": null,
"docstring": null,
"docstrin... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ConvertMutationCodeFromReducedFormat | <not_specific> | def ConvertMutationCodeFromReducedFormat(mutationCode, extended=False):
'''Converts a mutation code from reduced format
e.g. A25AG -> A:0025:ALA:GLY'''
components = ParseReducedMutationCode(mutationCode, extended)
if len(components) == 3:
return CreateResidueCode(chain=components[0], number=components[1]) ... | Converts a mutation code from reduced format
e.g. A25AG -> A:0025:ALA:GLY | Converts a mutation code from reduced format
e.g. | [
"Converts",
"a",
"mutation",
"code",
"from",
"reduced",
"format",
"e",
".",
"g",
"."
] | def ConvertMutationCodeFromReducedFormat(mutationCode, extended=False):
components = ParseReducedMutationCode(mutationCode, extended)
if len(components) == 3:
return CreateResidueCode(chain=components[0], number=components[1]) + ":" + components[2]
else:
return CreateResidueCode(chain=components[0], number=compo... | [
"def",
"ConvertMutationCodeFromReducedFormat",
"(",
"mutationCode",
",",
"extended",
"=",
"False",
")",
":",
"components",
"=",
"ParseReducedMutationCode",
"(",
"mutationCode",
",",
"extended",
")",
"if",
"len",
"(",
"components",
")",
"==",
"3",
":",
"return",
... | Converts a mutation code from reduced format
e.g. | [
"Converts",
"a",
"mutation",
"code",
"from",
"reduced",
"format",
"e",
".",
"g",
"."
] | [
"'''Converts a mutation code from reduced format\n\t\n\t e.g. A25AG -> A:0025:ALA:GLY'''"
] | [
{
"param": "mutationCode",
"type": null
},
{
"param": "extended",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "mutationCode",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "extended",
"type": null,
"docstring": null,
"docstrin... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ConvertResidueCodeToReducedFormat | <not_specific> | def ConvertResidueCodeToReducedFormat(residueCode, extended=False):
'''Converts an residue code to a reduced format
e.g. A:0025 -> A25 or A:0025:ALA -> A25A'''
if extended is True:
chain, residueIndex, residueName = ParseResidueCode(residueCode)
code = chain + str(residueIndex) + aminoAcidCodes[residueName... | Converts an residue code to a reduced format
e.g. A:0025 -> A25 or A:0025:ALA -> A25A | Converts an residue code to a reduced format
e.g. | [
"Converts",
"an",
"residue",
"code",
"to",
"a",
"reduced",
"format",
"e",
".",
"g",
"."
] | def ConvertResidueCodeToReducedFormat(residueCode, extended=False):
if extended is True:
chain, residueIndex, residueName = ParseResidueCode(residueCode)
code = chain + str(residueIndex) + aminoAcidCodes[residueName]
else:
chain, residueIndex = ParseResidueCode(residueCode)
code = chain + str(residueIndex)
... | [
"def",
"ConvertResidueCodeToReducedFormat",
"(",
"residueCode",
",",
"extended",
"=",
"False",
")",
":",
"if",
"extended",
"is",
"True",
":",
"chain",
",",
"residueIndex",
",",
"residueName",
"=",
"ParseResidueCode",
"(",
"residueCode",
")",
"code",
"=",
"chain"... | Converts an residue code to a reduced format
e.g. | [
"Converts",
"an",
"residue",
"code",
"to",
"a",
"reduced",
"format",
"e",
".",
"g",
"."
] | [
"'''Converts an residue code to a reduced format\n\t\n\t e.g. A:0025 -> A25 or A:0025:ALA -> A25A'''"
] | [
{
"param": "residueCode",
"type": null
},
{
"param": "extended",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "residueCode",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "extended",
"type": null,
"docstring": null,
"docstring... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | CheckFile | <not_specific> | def CheckFile(path):
'''Checks if path refers to an existing file.
Parameters:
path - A path to a file - Can be absolute or not.
Returns:
The absolute path to the file.
Exceptions:
Raises an IOError if the file does not exist or if its not a file'''
#Make the filename absolute
if not os.path.is... | Checks if path refers to an existing file.
Parameters:
path - A path to a file - Can be absolute or not.
Returns:
The absolute path to the file.
Exceptions:
Raises an IOError if the file does not exist or if its not a file | Checks if path refers to an existing file.
Parameters:
path - A path to a file - Can be absolute or not.
The absolute path to the file.
Raises an IOError if the file does not exist or if its not a file | [
"Checks",
"if",
"path",
"refers",
"to",
"an",
"existing",
"file",
".",
"Parameters",
":",
"path",
"-",
"A",
"path",
"to",
"a",
"file",
"-",
"Can",
"be",
"absolute",
"or",
"not",
".",
"The",
"absolute",
"path",
"to",
"the",
"file",
".",
"Raises",
"an"... | def CheckFile(path):
if not os.path.isabs(path):
path = os.path.abspath(path)
if not os.path.exists(path):
raise IOError, 'File %s does not exist' % path
if not os.path.isfile(path):
raise IOError, 'Object at %s is not a file' % path
return path | [
"def",
"CheckFile",
"(",
"path",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"isabs",
"(",
"path",
")",
":",
"path",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"path",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
... | Checks if path refers to an existing file. | [
"Checks",
"if",
"path",
"refers",
"to",
"an",
"existing",
"file",
"."
] | [
"'''Checks if path refers to an existing file.\n\t\n\tParameters:\n\t\tpath - A path to a file - Can be absolute or not.\n\t\t\n\tReturns:\n\t\tThe absolute path to the file.\n\t\t\n\tExceptions:\n\t\tRaises an IOError if the file does not exist or if its not a file'''",
"#Make the filename absolute",
"#Check t... | [
{
"param": "path",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "path",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | WhatIfCommandBoilerPlate | <not_specific> | def WhatIfCommandBoilerPlate(inputFile, renumber=False):
'''Returns the following string
getmol PDBName
Y
1
set
%renum
tot
1
The last three lines are omitted by default.
PDBName is the last path component of inputFile'''
command='getmol '+os.path.split(inputFile)[1]+' \n Y \n 1\n set \n'
if renumber... | Returns the following string
getmol PDBName
Y
1
set
%renum
tot
1
The last three lines are omitted by default.
PDBName is the last path component of inputFile | Returns the following string
getmol PDBName
Y
1
set
%renum
tot
1
The last three lines are omitted by default.
PDBName is the last path component of inputFile | [
"Returns",
"the",
"following",
"string",
"getmol",
"PDBName",
"Y",
"1",
"set",
"%renum",
"tot",
"1",
"The",
"last",
"three",
"lines",
"are",
"omitted",
"by",
"default",
".",
"PDBName",
"is",
"the",
"last",
"path",
"component",
"of",
"inputFile"
] | def WhatIfCommandBoilerPlate(inputFile, renumber=False):
command='getmol '+os.path.split(inputFile)[1]+' \n Y \n 1\n set \n'
if renumber:
command=command+' %renumb \n tot \n 1 \n '
return command | [
"def",
"WhatIfCommandBoilerPlate",
"(",
"inputFile",
",",
"renumber",
"=",
"False",
")",
":",
"command",
"=",
"'getmol '",
"+",
"os",
".",
"path",
".",
"split",
"(",
"inputFile",
")",
"[",
"1",
"]",
"+",
"' \\n Y \\n 1\\n set \\n'",
"if",
"renumber",
":",
... | Returns the following string
getmol PDBName
Y
1
set
%renum
tot
1 | [
"Returns",
"the",
"following",
"string",
"getmol",
"PDBName",
"Y",
"1",
"set",
"%renum",
"tot",
"1"
] | [
"'''Returns the following string\n\t\n\tgetmol PDBName\n\tY\n\t1\n\tset\n\t%renum\n\ttot\n\t1\n\t\n\tThe last three lines are omitted by default.\n\tPDBName is the last path component of inputFile'''"
] | [
{
"param": "inputFile",
"type": null
},
{
"param": "renumber",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "inputFile",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "renumber",
"type": null,
"docstring": null,
"docstring_t... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | CleanPDB2PQR | null | def CleanPDB2PQR(inputFile, outputFile, forceField="amber", removeWater=True, removeLigand=True, removeAltLoc=True, addHydrogens=True, correct=True):
'''Cleans a PDB by using PDB2PQR
See CleanPDB for argument details
Note: With pdb2pqr you cannot remove-water or ligands.
Errors:
Raises an exception if the... | Cleans a PDB by using PDB2PQR
See CleanPDB for argument details
Note: With pdb2pqr you cannot remove-water or ligands.
Errors:
Raises an exception if the inputFile is not a valid PDB file. | Cleans a PDB by using PDB2PQR
See CleanPDB for argument details
With pdb2pqr you cannot remove-water or ligands.
Raises an exception if the inputFile is not a valid PDB file. | [
"Cleans",
"a",
"PDB",
"by",
"using",
"PDB2PQR",
"See",
"CleanPDB",
"for",
"argument",
"details",
"With",
"pdb2pqr",
"you",
"cannot",
"remove",
"-",
"water",
"or",
"ligands",
".",
"Raises",
"an",
"exception",
"if",
"the",
"inputFile",
"is",
"not",
"a",
"val... | def CleanPDB2PQR(inputFile, outputFile, forceField="amber", removeWater=True, removeLigand=True, removeAltLoc=True, addHydrogens=True, correct=True):
import Protool
try:
command = 'pdb2pqr --chain --ff=%s' % (forceField)
if removeWater == True:
print >>sys.stderr, 'Warn: Currently PDB2PQR does not remove water... | [
"def",
"CleanPDB2PQR",
"(",
"inputFile",
",",
"outputFile",
",",
"forceField",
"=",
"\"amber\"",
",",
"removeWater",
"=",
"True",
",",
"removeLigand",
"=",
"True",
",",
"removeAltLoc",
"=",
"True",
",",
"addHydrogens",
"=",
"True",
",",
"correct",
"=",
"True... | Cleans a PDB by using PDB2PQR
See CleanPDB for argument details | [
"Cleans",
"a",
"PDB",
"by",
"using",
"PDB2PQR",
"See",
"CleanPDB",
"for",
"argument",
"details"
] | [
"'''Cleans a PDB by using PDB2PQR\n\t\n\tSee CleanPDB for argument details\n\n\tNote: With pdb2pqr you cannot remove-water or ligands.\n\t\t\n\tErrors: \n\t\tRaises an exception if the inputFile is not a valid PDB file.'''",
"#Protool ignores altlocs so we can use it to remove them ",
"#Do this first as Protool... | [
{
"param": "inputFile",
"type": null
},
{
"param": "outputFile",
"type": null
},
{
"param": "forceField",
"type": null
},
{
"param": "removeWater",
"type": null
},
{
"param": "removeLigand",
"type": null
},
{
"param": "removeAltLoc",
"type": null
... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "inputFile",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "outputFile",
"type": null,
"docstring": null,
"docstring... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | CleanWHATIF | null | def CleanWHATIF(inputFile, outputFile, removeWater=True, removeLigand=True, removeAltLoc=True, addHydrogens=True, correct=True):
'''Cleans a PDB using WHAT-IF
Errors:
Raises an exception if the inputFile is not a valid PDB file.'''
import pKarun.WI_tools, Protool
#First try to load the pdb using protool.
... | Cleans a PDB using WHAT-IF
Errors:
Raises an exception if the inputFile is not a valid PDB file. | Cleans a PDB using WHAT-IF
Errors:
Raises an exception if the inputFile is not a valid PDB file. | [
"Cleans",
"a",
"PDB",
"using",
"WHAT",
"-",
"IF",
"Errors",
":",
"Raises",
"an",
"exception",
"if",
"the",
"inputFile",
"is",
"not",
"a",
"valid",
"PDB",
"file",
"."
] | def CleanWHATIF(inputFile, outputFile, removeWater=True, removeLigand=True, removeAltLoc=True, addHydrogens=True, correct=True):
import pKarun.WI_tools, Protool
try:
pdb = Protool.structureIO()
pdb.readpdb(inputFile)
except Exception, data:
raise Exceptions.FileFormatError, 'Format of specified PDB file %s no... | [
"def",
"CleanWHATIF",
"(",
"inputFile",
",",
"outputFile",
",",
"removeWater",
"=",
"True",
",",
"removeLigand",
"=",
"True",
",",
"removeAltLoc",
"=",
"True",
",",
"addHydrogens",
"=",
"True",
",",
"correct",
"=",
"True",
")",
":",
"import",
"pKarun",
"."... | Cleans a PDB using WHAT-IF
Errors:
Raises an exception if the inputFile is not a valid PDB file. | [
"Cleans",
"a",
"PDB",
"using",
"WHAT",
"-",
"IF",
"Errors",
":",
"Raises",
"an",
"exception",
"if",
"the",
"inputFile",
"is",
"not",
"a",
"valid",
"PDB",
"file",
"."
] | [
"'''Cleans a PDB using WHAT-IF\t\t\n\n\tErrors: \n\t\tRaises an exception if the inputFile is not a valid PDB file.'''",
"#First try to load the pdb using protool.",
"#If its not valid ",
"#Create the WHATIF command script",
"#RunWhatIF - Different command needed if hydrogens are to be added",
"#logfile i... | [
{
"param": "inputFile",
"type": null
},
{
"param": "outputFile",
"type": null
},
{
"param": "removeWater",
"type": null
},
{
"param": "removeLigand",
"type": null
},
{
"param": "removeAltLoc",
"type": null
},
{
"param": "addHydrogens",
"type": null... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "inputFile",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "outputFile",
"type": null,
"docstring": null,
"docstring... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | CleanPDB | null | def CleanPDB(inputFile, outputFile, removeWater=True, removeLigand=True, removeAltLoc=True, addHydrogens=True, correct=True):
'''Cleans a PDB by adding hydrogens, remove waters, ligands and altlocs and correct bad rotamers (default)
The specific cleaning tasks done can be set using the function keywords arguments
... | Cleans a PDB by adding hydrogens, remove waters, ligands and altlocs and correct bad rotamers (default)
The specific cleaning tasks done can be set using the function keywords arguments
Parameters:
inputFile - The location of the pdb to clean
outputFile - The location where the cleaned pdb should be written.
... | Cleans a PDB by adding hydrogens, remove waters, ligands and altlocs and correct bad rotamers (default)
The specific cleaning tasks done can be set using the function keywords arguments
The location of the pdb to clean
outputFile - The location where the cleaned pdb should be written.
Raises an exception if the input... | [
"Cleans",
"a",
"PDB",
"by",
"adding",
"hydrogens",
"remove",
"waters",
"ligands",
"and",
"altlocs",
"and",
"correct",
"bad",
"rotamers",
"(",
"default",
")",
"The",
"specific",
"cleaning",
"tasks",
"done",
"can",
"be",
"set",
"using",
"the",
"function",
"key... | def CleanPDB(inputFile, outputFile, removeWater=True, removeLigand=True, removeAltLoc=True, addHydrogens=True, correct=True):
cleanProgram = Environment.appConfiguration.pdbCleanProgram()
if cleanProgram == "WHATIF":
CleanWHATIF(inputFile, outputFile,
removeWater=removeWater,
removeLigand=removeLigand,
... | [
"def",
"CleanPDB",
"(",
"inputFile",
",",
"outputFile",
",",
"removeWater",
"=",
"True",
",",
"removeLigand",
"=",
"True",
",",
"removeAltLoc",
"=",
"True",
",",
"addHydrogens",
"=",
"True",
",",
"correct",
"=",
"True",
")",
":",
"cleanProgram",
"=",
"Envi... | Cleans a PDB by adding hydrogens, remove waters, ligands and altlocs and correct bad rotamers (default)
The specific cleaning tasks done can be set using the function keywords arguments | [
"Cleans",
"a",
"PDB",
"by",
"adding",
"hydrogens",
"remove",
"waters",
"ligands",
"and",
"altlocs",
"and",
"correct",
"bad",
"rotamers",
"(",
"default",
")",
"The",
"specific",
"cleaning",
"tasks",
"done",
"can",
"be",
"set",
"using",
"the",
"function",
"key... | [
"'''Cleans a PDB by adding hydrogens, remove waters, ligands and altlocs and correct bad rotamers (default)\n\t\n\tThe specific cleaning tasks done can be set using the function keywords arguments\n\t\n\tParameters:\n\t\tinputFile - The location of the pdb to clean\n\t\toutputFile - The location where the cleaned p... | [
{
"param": "inputFile",
"type": null
},
{
"param": "outputFile",
"type": null
},
{
"param": "removeWater",
"type": null
},
{
"param": "removeLigand",
"type": null
},
{
"param": "removeAltLoc",
"type": null
},
{
"param": "addHydrogens",
"type": null... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "inputFile",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "outputFile",
"type": null,
"docstring": null,
"docstring... |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | parseCommandLine | null | def parseCommandLine(self):
'''Parses the command line
Execeptions:
Raises Exceptions.ArgumentError if there was a problem with the arguments supplied'''
try:
#getopt does not want the "-" or "--" when being called
self.opt = getopt.getopt(sys.argv[1:],
"vw:p:o:hn:",
["pKa", "scan", "de... | Parses the command line
Execeptions:
Raises Exceptions.ArgumentError if there was a problem with the arguments supplied | Parses the command line
Execeptions:
Raises Exceptions.ArgumentError if there was a problem with the arguments supplied | [
"Parses",
"the",
"command",
"line",
"Execeptions",
":",
"Raises",
"Exceptions",
".",
"ArgumentError",
"if",
"there",
"was",
"a",
"problem",
"with",
"the",
"arguments",
"supplied"
] | def parseCommandLine(self):
try:
self.opt = getopt.getopt(sys.argv[1:],
"vw:p:o:hn:",
["pKa", "scan", "delta-pKa", "path", "modes", "stability",
"mutationList=", "mutation=", "mutants=", "ligand=", "mutationQuality="
"ionisableGroups=", "configurationFile=", "create-configuration", "keepHete... | [
"def",
"parseCommandLine",
"(",
"self",
")",
":",
"try",
":",
"self",
".",
"opt",
"=",
"getopt",
".",
"getopt",
"(",
"sys",
".",
"argv",
"[",
"1",
":",
"]",
",",
"\"vw:p:o:hn:\"",
",",
"[",
"\"pKa\"",
",",
"\"scan\"",
",",
"\"delta-pKa\"",
",",
"\"pa... | Parses the command line
Execeptions:
Raises Exceptions.ArgumentError if there was a problem with the arguments supplied | [
"Parses",
"the",
"command",
"line",
"Execeptions",
":",
"Raises",
"Exceptions",
".",
"ArgumentError",
"if",
"there",
"was",
"a",
"problem",
"with",
"the",
"arguments",
"supplied"
] | [
"'''Parses the command line\n\t\t\n\t\tExeceptions:\n\t\t\tRaises Exceptions.ArgumentError if there was a problem with the arguments supplied'''",
"#getopt does not want the \"-\" or \"--\" when being called",
"#Check if any of the optional flags were specified\t\t",
"#Add the options arguments",
"#Add the ... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | helpRequested | <not_specific> | def helpRequested(self):
'''Returns True if help was requested'''
if self.opt.has_key("-h"):
return True
return False | Returns True if help was requested | Returns True if help was requested | [
"Returns",
"True",
"if",
"help",
"was",
"requested"
] | def helpRequested(self):
if self.opt.has_key("-h"):
return True
return False | [
"def",
"helpRequested",
"(",
"self",
")",
":",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"\"-h\"",
")",
":",
"return",
"True",
"return",
"False"
] | Returns True if help was requested | [
"Returns",
"True",
"if",
"help",
"was",
"requested"
] | [
"'''Returns True if help was requested'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | createConfigurationRequested | <not_specific> | def createConfigurationRequested(self):
'''Returns True is the user asked for a configuration file to be made'''
#Check if create-configuration was specfied
if self.opt.has_key("--create-configuration"):
return True
return False | Returns True is the user asked for a configuration file to be made | Returns True is the user asked for a configuration file to be made | [
"Returns",
"True",
"is",
"the",
"user",
"asked",
"for",
"a",
"configuration",
"file",
"to",
"be",
"made"
] | def createConfigurationRequested(self):
if self.opt.has_key("--create-configuration"):
return True
return False | [
"def",
"createConfigurationRequested",
"(",
"self",
")",
":",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"\"--create-configuration\"",
")",
":",
"return",
"True",
"return",
"False"
] | Returns True is the user asked for a configuration file to be made | [
"Returns",
"True",
"is",
"the",
"user",
"asked",
"for",
"a",
"configuration",
"file",
"to",
"be",
"made"
] | [
"'''Returns True is the user asked for a configuration file to be made'''",
"#Check if create-configuration was specfied"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | outputDirectory | <not_specific> | def outputDirectory(self):
'''Returns the output directory to be used
If none was specified returns the directory the program was started from.
If the command line hasn't been parsed returns None'''
if self.opt.has_key('-o'):
return self.opt['-o']
else:
return None | Returns the output directory to be used
If none was specified returns the directory the program was started from.
If the command line hasn't been parsed returns None | Returns the output directory to be used
If none was specified returns the directory the program was started from.
If the command line hasn't been parsed returns None | [
"Returns",
"the",
"output",
"directory",
"to",
"be",
"used",
"If",
"none",
"was",
"specified",
"returns",
"the",
"directory",
"the",
"program",
"was",
"started",
"from",
".",
"If",
"the",
"command",
"line",
"hasn",
"'",
"t",
"been",
"parsed",
"returns",
"N... | def outputDirectory(self):
if self.opt.has_key('-o'):
return self.opt['-o']
else:
return None | [
"def",
"outputDirectory",
"(",
"self",
")",
":",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'-o'",
")",
":",
"return",
"self",
".",
"opt",
"[",
"'-o'",
"]",
"else",
":",
"return",
"None"
] | Returns the output directory to be used
If none was specified returns the directory the program was started from. | [
"Returns",
"the",
"output",
"directory",
"to",
"be",
"used",
"If",
"none",
"was",
"specified",
"returns",
"the",
"directory",
"the",
"program",
"was",
"started",
"from",
"."
] | [
"'''Returns the output directory to be used\n\t\t\n\t\tIf none was specified returns the directory the program was started from.\n\t\tIf the command line hasn't been parsed returns None'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | workingDirectory | <not_specific> | def workingDirectory(self):
'''Returns the working directory to be used'''
return self.opt["-w"] | Returns the working directory to be used | Returns the working directory to be used | [
"Returns",
"the",
"working",
"directory",
"to",
"be",
"used"
] | def workingDirectory(self):
return self.opt["-w"] | [
"def",
"workingDirectory",
"(",
"self",
")",
":",
"return",
"self",
".",
"opt",
"[",
"\"-w\"",
"]"
] | Returns the working directory to be used | [
"Returns",
"the",
"working",
"directory",
"to",
"be",
"used"
] | [
"'''Returns the working directory to be used'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | scan | <not_specific> | def scan(self):
'''Returns True if an scan was requested'''
if self.opt.has_key('--scan') or self.opt.has_key('--delta-pKa'):
return True
return False | Returns True if an scan was requested | Returns True if an scan was requested | [
"Returns",
"True",
"if",
"an",
"scan",
"was",
"requested"
] | def scan(self):
if self.opt.has_key('--scan') or self.opt.has_key('--delta-pKa'):
return True
return False | [
"def",
"scan",
"(",
"self",
")",
":",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'--scan'",
")",
"or",
"self",
".",
"opt",
".",
"has_key",
"(",
"'--delta-pKa'",
")",
":",
"return",
"True",
"return",
"False"
] | Returns True if an scan was requested | [
"Returns",
"True",
"if",
"an",
"scan",
"was",
"requested"
] | [
"'''Returns True if an scan was requested'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | scanMutation | <not_specific> | def scanMutation(self):
'''Returns the value of the mutation argument is supplied.
If not this always defaults to ALA.'''
mutation = None
if self.opt.has_key('--mutation'):
mutation = self.opt['--mutation']
else:
mutation = 'ALA'
return mutation | Returns the value of the mutation argument is supplied.
If not this always defaults to ALA. | Returns the value of the mutation argument is supplied.
If not this always defaults to ALA. | [
"Returns",
"the",
"value",
"of",
"the",
"mutation",
"argument",
"is",
"supplied",
".",
"If",
"not",
"this",
"always",
"defaults",
"to",
"ALA",
"."
] | def scanMutation(self):
mutation = None
if self.opt.has_key('--mutation'):
mutation = self.opt['--mutation']
else:
mutation = 'ALA'
return mutation | [
"def",
"scanMutation",
"(",
"self",
")",
":",
"mutation",
"=",
"None",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'--mutation'",
")",
":",
"mutation",
"=",
"self",
".",
"opt",
"[",
"'--mutation'",
"]",
"else",
":",
"mutation",
"=",
"'ALA'",
"retur... | Returns the value of the mutation argument is supplied. | [
"Returns",
"the",
"value",
"of",
"the",
"mutation",
"argument",
"is",
"supplied",
"."
] | [
"'''Returns the value of the mutation argument is supplied.\n\t\tIf not this always defaults to ALA.'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | stability | <not_specific> | def stability(self):
'''Returns True is a stability calculation was requested'''
if self.opt.has_key('--stability'):
return True
return False | Returns True is a stability calculation was requested | Returns True is a stability calculation was requested | [
"Returns",
"True",
"is",
"a",
"stability",
"calculation",
"was",
"requested"
] | def stability(self):
if self.opt.has_key('--stability'):
return True
return False | [
"def",
"stability",
"(",
"self",
")",
":",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'--stability'",
")",
":",
"return",
"True",
"return",
"False"
] | Returns True is a stability calculation was requested | [
"Returns",
"True",
"is",
"a",
"stability",
"calculation",
"was",
"requested"
] | [
"'''Returns True is a stability calculation was requested'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | binding | <not_specific> | def binding(self):
'''Returns True is a binding calculation was requested'''
if self.opt.has_key('--ligand'):
return True
return False | Returns True is a binding calculation was requested | Returns True is a binding calculation was requested | [
"Returns",
"True",
"is",
"a",
"binding",
"calculation",
"was",
"requested"
] | def binding(self):
if self.opt.has_key('--ligand'):
return True
return False | [
"def",
"binding",
"(",
"self",
")",
":",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'--ligand'",
")",
":",
"return",
"True",
"return",
"False"
] | Returns True is a binding calculation was requested | [
"Returns",
"True",
"is",
"a",
"binding",
"calculation",
"was",
"requested"
] | [
"'''Returns True is a binding calculation was requested'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | verbose | <not_specific> | def verbose(self):
'''Returns True if verbose output was requested'''
if self.opt.has_key('-v'):
return True
return False | Returns True if verbose output was requested | Returns True if verbose output was requested | [
"Returns",
"True",
"if",
"verbose",
"output",
"was",
"requested"
] | def verbose(self):
if self.opt.has_key('-v'):
return True
return False | [
"def",
"verbose",
"(",
"self",
")",
":",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'-v'",
")",
":",
"return",
"True",
"return",
"False"
] | Returns True if verbose output was requested | [
"Returns",
"True",
"if",
"verbose",
"output",
"was",
"requested"
] | [
"'''Returns True if verbose output was requested'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | configurationFile | <not_specific> | def configurationFile(self):
'''Returns the path to the specified configuration file or None if none was given'''
#See was a specifc configuration file specified
try:
configurationFile = self.opt['--configurationFile']
except KeyError:
configurationFile = None
return configurationFile | Returns the path to the specified configuration file or None if none was given | Returns the path to the specified configuration file or None if none was given | [
"Returns",
"the",
"path",
"to",
"the",
"specified",
"configuration",
"file",
"or",
"None",
"if",
"none",
"was",
"given"
] | def configurationFile(self):
try:
configurationFile = self.opt['--configurationFile']
except KeyError:
configurationFile = None
return configurationFile | [
"def",
"configurationFile",
"(",
"self",
")",
":",
"try",
":",
"configurationFile",
"=",
"self",
".",
"opt",
"[",
"'--configurationFile'",
"]",
"except",
"KeyError",
":",
"configurationFile",
"=",
"None",
"return",
"configurationFile"
] | Returns the path to the specified configuration file or None if none was given | [
"Returns",
"the",
"path",
"to",
"the",
"specified",
"configuration",
"file",
"or",
"None",
"if",
"none",
"was",
"given"
] | [
"'''Returns the path to the specified configuration file or None if none was given'''",
"#See was a specifc configuration file specified"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | pdbFile | <not_specific> | def pdbFile(self):
'''Returns the pdb file the program is to be run on
Raises a KeyError if not specified'''
return self.opt["-p"] | Returns the pdb file the program is to be run on
Raises a KeyError if not specified | Returns the pdb file the program is to be run on
Raises a KeyError if not specified | [
"Returns",
"the",
"pdb",
"file",
"the",
"program",
"is",
"to",
"be",
"run",
"on",
"Raises",
"a",
"KeyError",
"if",
"not",
"specified"
] | def pdbFile(self):
return self.opt["-p"] | [
"def",
"pdbFile",
"(",
"self",
")",
":",
"return",
"self",
".",
"opt",
"[",
"\"-p\"",
"]"
] | Returns the pdb file the program is to be run on
Raises a KeyError if not specified | [
"Returns",
"the",
"pdb",
"file",
"the",
"program",
"is",
"to",
"be",
"run",
"on",
"Raises",
"a",
"KeyError",
"if",
"not",
"specified"
] | [
"'''Returns the pdb file the program is to be run on\n\t\t\n\t\tRaises a KeyError if not specified'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | mutationListFile | <not_specific> | def mutationListFile(self):
'''Returns the file containing the mutation list'''
file = None
if self.opt.has_key('--mutationList'):
file = self.opt['--mutationList']
return file | Returns the file containing the mutation list | Returns the file containing the mutation list | [
"Returns",
"the",
"file",
"containing",
"the",
"mutation",
"list"
] | def mutationListFile(self):
file = None
if self.opt.has_key('--mutationList'):
file = self.opt['--mutationList']
return file | [
"def",
"mutationListFile",
"(",
"self",
")",
":",
"file",
"=",
"None",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'--mutationList'",
")",
":",
"file",
"=",
"self",
".",
"opt",
"[",
"'--mutationList'",
"]",
"return",
"file"
] | Returns the file containing the mutation list | [
"Returns",
"the",
"file",
"containing",
"the",
"mutation",
"list"
] | [
"'''Returns the file containing the mutation list'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | mutants | <not_specific> | def mutants(self):
'''Returns a mutant collection instance initialised with the contents of the mutants argument'''
mutantCollection = None
if self.opt.has_key('--mutants'):
mutantDir = self.opt['--mutants']
#remove the trailing slash if present so split will work
if mutantDir[-1:] == os.sep:
mut... | Returns a mutant collection instance initialised with the contents of the mutants argument | Returns a mutant collection instance initialised with the contents of the mutants argument | [
"Returns",
"a",
"mutant",
"collection",
"instance",
"initialised",
"with",
"the",
"contents",
"of",
"the",
"mutants",
"argument"
] | def mutants(self):
mutantCollection = None
if self.opt.has_key('--mutants'):
mutantDir = self.opt['--mutants']
if mutantDir[-1:] == os.sep:
mutantDir = mutantDir[:-1]
pathComponents = os.path.split(mutantDir)
mutantCollection = Data.MutantCollection(name=pathComponents[1], location=pathComponents[0]... | [
"def",
"mutants",
"(",
"self",
")",
":",
"mutantCollection",
"=",
"None",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'--mutants'",
")",
":",
"mutantDir",
"=",
"self",
".",
"opt",
"[",
"'--mutants'",
"]",
"if",
"mutantDir",
"[",
"-",
"1",
":",
"]... | Returns a mutant collection instance initialised with the contents of the mutants argument | [
"Returns",
"a",
"mutant",
"collection",
"instance",
"initialised",
"with",
"the",
"contents",
"of",
"the",
"mutants",
"argument"
] | [
"'''Returns a mutant collection instance initialised with the contents of the mutants argument'''",
"#remove the trailing slash if present so split will work"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | ligandFile | <not_specific> | def ligandFile(self):
'''Returns the value of the ligand command line argument if it exists.'''
if self.opt.has_key('--ligand'):
return self.opt['--ligand']
return None | Returns the value of the ligand command line argument if it exists. | Returns the value of the ligand command line argument if it exists. | [
"Returns",
"the",
"value",
"of",
"the",
"ligand",
"command",
"line",
"argument",
"if",
"it",
"exists",
"."
] | def ligandFile(self):
if self.opt.has_key('--ligand'):
return self.opt['--ligand']
return None | [
"def",
"ligandFile",
"(",
"self",
")",
":",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'--ligand'",
")",
":",
"return",
"self",
".",
"opt",
"[",
"'--ligand'",
"]",
"return",
"None"
] | Returns the value of the ligand command line argument if it exists. | [
"Returns",
"the",
"value",
"of",
"the",
"ligand",
"command",
"line",
"argument",
"if",
"it",
"exists",
"."
] | [
"'''Returns the value of the ligand command line argument if it exists.'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
43ef7777bcc0b06cae4bb221196eb1c364b3bb4d | shambo001/peat | PEATSA/Core/Utilities.py | [
"MIT"
] | Python | removeHeterogens | <not_specific> | def removeHeterogens(self):
'''If keepHeterogens command line argument was specified this returns False.
Otherwise it returns True'''
if self.opt.has_key('--keepHeterogens'):
return False
return True | If keepHeterogens command line argument was specified this returns False.
Otherwise it returns True | If keepHeterogens command line argument was specified this returns False.
Otherwise it returns True | [
"If",
"keepHeterogens",
"command",
"line",
"argument",
"was",
"specified",
"this",
"returns",
"False",
".",
"Otherwise",
"it",
"returns",
"True"
] | def removeHeterogens(self):
if self.opt.has_key('--keepHeterogens'):
return False
return True | [
"def",
"removeHeterogens",
"(",
"self",
")",
":",
"if",
"self",
".",
"opt",
".",
"has_key",
"(",
"'--keepHeterogens'",
")",
":",
"return",
"False",
"return",
"True"
] | If keepHeterogens command line argument was specified this returns False. | [
"If",
"keepHeterogens",
"command",
"line",
"argument",
"was",
"specified",
"this",
"returns",
"False",
"."
] | [
"'''If keepHeterogens command line argument was specified this returns False.\n\t\t\n\t\tOtherwise it returns True'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.