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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
936f5d385510f58d67f5d9798af4c311b9dc86cd | shambo001/peat | PEATSA/WebApp/JobSubmission.py | [
"MIT"
] | Python | isMutationList | <not_specific> | def isMutationList(self):
'''Returns True if the formData contains a mutationList file'''
mutationList = False
mutationChoice = self.formData.getlist("mutation")
if mutationChoice.count('mutationFile') != 0:
mutationList=True
return mutationList | Returns True if the formData contains a mutationList file | Returns True if the formData contains a mutationList file | [
"Returns",
"True",
"if",
"the",
"formData",
"contains",
"a",
"mutationList",
"file"
] | def isMutationList(self):
mutationList = False
mutationChoice = self.formData.getlist("mutation")
if mutationChoice.count('mutationFile') != 0:
mutationList=True
return mutationList | [
"def",
"isMutationList",
"(",
"self",
")",
":",
"mutationList",
"=",
"False",
"mutationChoice",
"=",
"self",
".",
"formData",
".",
"getlist",
"(",
"\"mutation\"",
")",
"if",
"mutationChoice",
".",
"count",
"(",
"'mutationFile'",
")",
"!=",
"0",
":",
"mutatio... | Returns True if the formData contains a mutationList file | [
"Returns",
"True",
"if",
"the",
"formData",
"contains",
"a",
"mutationList",
"file"
] | [
"'''Returns True if the formData contains a mutationList file'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
936f5d385510f58d67f5d9798af4c311b9dc86cd | shambo001/peat | PEATSA/WebApp/JobSubmission.py | [
"MIT"
] | Python | calculations | <not_specific> | def calculations(self):
'''Returns a list containing the names of the calculations requested'''
return self.formData.getlist("calculation") | Returns a list containing the names of the calculations requested | Returns a list containing the names of the calculations requested | [
"Returns",
"a",
"list",
"containing",
"the",
"names",
"of",
"the",
"calculations",
"requested"
] | def calculations(self):
return self.formData.getlist("calculation") | [
"def",
"calculations",
"(",
"self",
")",
":",
"return",
"self",
".",
"formData",
".",
"getlist",
"(",
"\"calculation\"",
")"
] | Returns a list containing the names of the calculations requested | [
"Returns",
"a",
"list",
"containing",
"the",
"names",
"of",
"the",
"calculations",
"requested"
] | [
"'''Returns a list containing the names of the calculations requested'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
936f5d385510f58d67f5d9798af4c311b9dc86cd | shambo001/peat | PEATSA/WebApp/JobSubmission.py | [
"MIT"
] | Python | pdbFilename | <not_specific> | def pdbFilename(self):
'''Returns the filename of the pdb - note this does not include a path'''
return self.standardizedPDBFilename | Returns the filename of the pdb - note this does not include a path | Returns the filename of the pdb - note this does not include a path | [
"Returns",
"the",
"filename",
"of",
"the",
"pdb",
"-",
"note",
"this",
"does",
"not",
"include",
"a",
"path"
] | def pdbFilename(self):
return self.standardizedPDBFilename | [
"def",
"pdbFilename",
"(",
"self",
")",
":",
"return",
"self",
".",
"standardizedPDBFilename"
] | Returns the filename of the pdb - note this does not include a path | [
"Returns",
"the",
"filename",
"of",
"the",
"pdb",
"-",
"note",
"this",
"does",
"not",
"include",
"a",
"path"
] | [
"'''Returns the filename of the pdb - note this does not include a path'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
936f5d385510f58d67f5d9798af4c311b9dc86cd | shambo001/peat | PEATSA/WebApp/JobSubmission.py | [
"MIT"
] | Python | pdbFileStream | <not_specific> | def pdbFileStream(self):
'''Returns an opened stream to the pdbFile'''
self.pdbStream.seek(0)
return self.pdbStream | Returns an opened stream to the pdbFile | Returns an opened stream to the pdbFile | [
"Returns",
"an",
"opened",
"stream",
"to",
"the",
"pdbFile"
] | def pdbFileStream(self):
self.pdbStream.seek(0)
return self.pdbStream | [
"def",
"pdbFileStream",
"(",
"self",
")",
":",
"self",
".",
"pdbStream",
".",
"seek",
"(",
"0",
")",
"return",
"self",
".",
"pdbStream"
] | Returns an opened stream to the pdbFile | [
"Returns",
"an",
"opened",
"stream",
"to",
"the",
"pdbFile"
] | [
"'''Returns an opened stream to the pdbFile'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
936f5d385510f58d67f5d9798af4c311b9dc86cd | shambo001/peat | PEATSA/WebApp/JobSubmission.py | [
"MIT"
] | Python | ligandFileStream | <not_specific> | def ligandFileStream(self):
'''Returns an opened stream to the ligand file'''
stream = self.formData["ligandFile"].file
stream.seek(0)
return stream | Returns an opened stream to the ligand file | Returns an opened stream to the ligand file | [
"Returns",
"an",
"opened",
"stream",
"to",
"the",
"ligand",
"file"
] | def ligandFileStream(self):
stream = self.formData["ligandFile"].file
stream.seek(0)
return stream | [
"def",
"ligandFileStream",
"(",
"self",
")",
":",
"stream",
"=",
"self",
".",
"formData",
"[",
"\"ligandFile\"",
"]",
".",
"file",
"stream",
".",
"seek",
"(",
"0",
")",
"return",
"stream"
] | Returns an opened stream to the ligand file | [
"Returns",
"an",
"opened",
"stream",
"to",
"the",
"ligand",
"file"
] | [
"'''Returns an opened stream to the ligand file'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
936f5d385510f58d67f5d9798af4c311b9dc86cd | shambo001/peat | PEATSA/WebApp/JobSubmission.py | [
"MIT"
] | Python | mutationListFileStream | <not_specific> | def mutationListFileStream(self):
'''Returns an opened stream to the mutationList file'''
if self.mutationData['Type'] == 'mutationList':
stream = self.mutationData["Data"]
stream.seek(0)
return stream | Returns an opened stream to the mutationList file | Returns an opened stream to the mutationList file | [
"Returns",
"an",
"opened",
"stream",
"to",
"the",
"mutationList",
"file"
] | def mutationListFileStream(self):
if self.mutationData['Type'] == 'mutationList':
stream = self.mutationData["Data"]
stream.seek(0)
return stream | [
"def",
"mutationListFileStream",
"(",
"self",
")",
":",
"if",
"self",
".",
"mutationData",
"[",
"'Type'",
"]",
"==",
"'mutationList'",
":",
"stream",
"=",
"self",
".",
"mutationData",
"[",
"\"Data\"",
"]",
"stream",
".",
"seek",
"(",
"0",
")",
"return",
... | Returns an opened stream to the mutationList file | [
"Returns",
"an",
"opened",
"stream",
"to",
"the",
"mutationList",
"file"
] | [
"'''Returns an opened stream to the mutationList file'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
936f5d385510f58d67f5d9798af4c311b9dc86cd | shambo001/peat | PEATSA/WebApp/JobSubmission.py | [
"MIT"
] | Python | pKaCode | <not_specific> | def pKaCode(self):
'''Returns the pKa code.
If none is present returns None.
A pKa code is deemed present if the code field is filled
and a delta-pKa calculation is requested'''
retval = None
if self.isPKACodePresent():
retval = self.formData.getvalue("pdbCode")
return retval | Returns the pKa code.
If none is present returns None.
A pKa code is deemed present if the code field is filled
and a delta-pKa calculation is requested | Returns the pKa code.
If none is present returns None.
A pKa code is deemed present if the code field is filled
and a delta-pKa calculation is requested | [
"Returns",
"the",
"pKa",
"code",
".",
"If",
"none",
"is",
"present",
"returns",
"None",
".",
"A",
"pKa",
"code",
"is",
"deemed",
"present",
"if",
"the",
"code",
"field",
"is",
"filled",
"and",
"a",
"delta",
"-",
"pKa",
"calculation",
"is",
"requested"
] | def pKaCode(self):
retval = None
if self.isPKACodePresent():
retval = self.formData.getvalue("pdbCode")
return retval | [
"def",
"pKaCode",
"(",
"self",
")",
":",
"retval",
"=",
"None",
"if",
"self",
".",
"isPKACodePresent",
"(",
")",
":",
"retval",
"=",
"self",
".",
"formData",
".",
"getvalue",
"(",
"\"pdbCode\"",
")",
"return",
"retval"
] | Returns the pKa code. | [
"Returns",
"the",
"pKa",
"code",
"."
] | [
"'''Returns the pKa code.\n\t\t\n\t\tIf none is present returns None.\n\t\tA pKa code is deemed present if the code field is filled\n\t\tand a delta-pKa calculation is requested'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
936f5d385510f58d67f5d9798af4c311b9dc86cd | shambo001/peat | PEATSA/WebApp/JobSubmission.py | [
"MIT"
] | Python | email | <not_specific> | def email(self):
'''Returns the email address if their is one'''
retval = self.formData.getvalue("email")
if retval == "":
retval = "Unknown"
return retval | Returns the email address if their is one | Returns the email address if their is one | [
"Returns",
"the",
"email",
"address",
"if",
"their",
"is",
"one"
] | def email(self):
retval = self.formData.getvalue("email")
if retval == "":
retval = "Unknown"
return retval | [
"def",
"email",
"(",
"self",
")",
":",
"retval",
"=",
"self",
".",
"formData",
".",
"getvalue",
"(",
"\"email\"",
")",
"if",
"retval",
"==",
"\"\"",
":",
"retval",
"=",
"\"Unknown\"",
"return",
"retval"
] | Returns the email address if their is one | [
"Returns",
"the",
"email",
"address",
"if",
"their",
"is",
"one"
] | [
"'''Returns the email address if their is one'''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
ad1513f16c63116e1f32e985dddf5fcf90bac9b0 | shambo001/peat | pKaTool/titration_class.py | [
"MIT"
] | Python | sub_scaled | <not_specific> | def sub_scaled(self,other):
"""scaled difference btw two titration curves"""
diff=0.0
for group in self.curves.keys():
if not other.curves.has_key(group):
continue
raise 'incompatible titration curves'
for ph in self.curves[group].keys():
... | scaled difference btw two titration curves | scaled difference btw two titration curves | [
"scaled",
"difference",
"btw",
"two",
"titration",
"curves"
] | def sub_scaled(self,other):
diff=0.0
for group in self.curves.keys():
if not other.curves.has_key(group):
continue
raise 'incompatible titration curves'
for ph in self.curves[group].keys():
if other.curves[group].has_key(ph):
... | [
"def",
"sub_scaled",
"(",
"self",
",",
"other",
")",
":",
"diff",
"=",
"0.0",
"for",
"group",
"in",
"self",
".",
"curves",
".",
"keys",
"(",
")",
":",
"if",
"not",
"other",
".",
"curves",
".",
"has_key",
"(",
"group",
")",
":",
"continue",
"raise",... | scaled difference btw two titration curves | [
"scaled",
"difference",
"btw",
"two",
"titration",
"curves"
] | [
"\"\"\"scaled difference btw two titration curves\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "other",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "other",
"type": null,
"docstring": null,
"docstring_tokens": ... |
ad1513f16c63116e1f32e985dddf5fcf90bac9b0 | shambo001/peat | pKaTool/titration_class.py | [
"MIT"
] | Python | experimental_uncertainty | <not_specific> | def experimental_uncertainty(self, pH_uncertainty=0.1):
"""estimates the experimental uncertainty of titration curves"""
res=0.0
count = 0
for group in self.curves.keys():
#print 'Now estimating for ',group
pHs = self.curves[group].keys()
#make sure th... | estimates the experimental uncertainty of titration curves | estimates the experimental uncertainty of titration curves | [
"estimates",
"the",
"experimental",
"uncertainty",
"of",
"titration",
"curves"
] | def experimental_uncertainty(self, pH_uncertainty=0.1):
res=0.0
count = 0
for group in self.curves.keys():
pHs = self.curves[group].keys()
pHs.sort()
for i in range(len(pHs)):
bw_diff = 0
fw_diff = 0
try:
... | [
"def",
"experimental_uncertainty",
"(",
"self",
",",
"pH_uncertainty",
"=",
"0.1",
")",
":",
"res",
"=",
"0.0",
"count",
"=",
"0",
"for",
"group",
"in",
"self",
".",
"curves",
".",
"keys",
"(",
")",
":",
"pHs",
"=",
"self",
".",
"curves",
"[",
"group... | estimates the experimental uncertainty of titration curves | [
"estimates",
"the",
"experimental",
"uncertainty",
"of",
"titration",
"curves"
] | [
"\"\"\"estimates the experimental uncertainty of titration curves\"\"\"",
"#print 'Now estimating for ',group",
"#make sure that ph values are sorted",
"##### abs()?"
] | [
{
"param": "self",
"type": null
},
{
"param": "pH_uncertainty",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pH_uncertainty",
"type": null,
"docstring": null,
"docstring_... |
ad1513f16c63116e1f32e985dddf5fcf90bac9b0 | shambo001/peat | pKaTool/titration_class.py | [
"MIT"
] | Python | sub_HHd_scaled | <not_specific> | def sub_HHd_scaled(self, exp_data, pkas):
"""Calculates error with scaling based on deviation of exp data from the Henderson-Hasselbalch eq"""
diff=0.0
scales = exp_data.deviation_from_henderson_hasselbalch(pkas)
for group in self.curves.keys():
if not exp_data.curves.has_key... | Calculates error with scaling based on deviation of exp data from the Henderson-Hasselbalch eq | Calculates error with scaling based on deviation of exp data from the Henderson-Hasselbalch eq | [
"Calculates",
"error",
"with",
"scaling",
"based",
"on",
"deviation",
"of",
"exp",
"data",
"from",
"the",
"Henderson",
"-",
"Hasselbalch",
"eq"
] | def sub_HHd_scaled(self, exp_data, pkas):
diff=0.0
scales = exp_data.deviation_from_henderson_hasselbalch(pkas)
for group in self.curves.keys():
if not exp_data.curves.has_key(group):
continue
for ph in self.curves[group].keys():
if exp_dat... | [
"def",
"sub_HHd_scaled",
"(",
"self",
",",
"exp_data",
",",
"pkas",
")",
":",
"diff",
"=",
"0.0",
"scales",
"=",
"exp_data",
".",
"deviation_from_henderson_hasselbalch",
"(",
"pkas",
")",
"for",
"group",
"in",
"self",
".",
"curves",
".",
"keys",
"(",
")",
... | Calculates error with scaling based on deviation of exp data from the Henderson-Hasselbalch eq | [
"Calculates",
"error",
"with",
"scaling",
"based",
"on",
"deviation",
"of",
"exp",
"data",
"from",
"the",
"Henderson",
"-",
"Hasselbalch",
"eq"
] | [
"\"\"\"Calculates error with scaling based on deviation of exp data from the Henderson-Hasselbalch eq\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "exp_data",
"type": null
},
{
"param": "pkas",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "exp_data",
"type": null,
"docstring": null,
"docstring_tokens... |
ad1513f16c63116e1f32e985dddf5fcf90bac9b0 | shambo001/peat | pKaTool/titration_class.py | [
"MIT"
] | Python | deviation_from_henderson_hasselbalch | <not_specific> | def deviation_from_henderson_hasselbalch(self, pKas):
"""Calculates the deviation from the Henderson-Hasselbalch equation for all points given pKa values"""
HH_deviation = {}
deviation = lambda ph,pka,exp: abs(1/(1+pow(10,ph-pka))-1-exp)
for group in self.curves.keys():
if pK... | Calculates the deviation from the Henderson-Hasselbalch equation for all points given pKa values | Calculates the deviation from the Henderson-Hasselbalch equation for all points given pKa values | [
"Calculates",
"the",
"deviation",
"from",
"the",
"Henderson",
"-",
"Hasselbalch",
"equation",
"for",
"all",
"points",
"given",
"pKa",
"values"
] | def deviation_from_henderson_hasselbalch(self, pKas):
HH_deviation = {}
deviation = lambda ph,pka,exp: abs(1/(1+pow(10,ph-pka))-1-exp)
for group in self.curves.keys():
if pKas.has_key(group):
pka = pKas[group]
HH_deviation[group] = {}
f... | [
"def",
"deviation_from_henderson_hasselbalch",
"(",
"self",
",",
"pKas",
")",
":",
"HH_deviation",
"=",
"{",
"}",
"deviation",
"=",
"lambda",
"ph",
",",
"pka",
",",
"exp",
":",
"abs",
"(",
"1",
"/",
"(",
"1",
"+",
"pow",
"(",
"10",
",",
"ph",
"-",
... | Calculates the deviation from the Henderson-Hasselbalch equation for all points given pKa values | [
"Calculates",
"the",
"deviation",
"from",
"the",
"Henderson",
"-",
"Hasselbalch",
"equation",
"for",
"all",
"points",
"given",
"pKa",
"values"
] | [
"\"\"\"Calculates the deviation from the Henderson-Hasselbalch equation for all points given pKa values\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "pKas",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pKas",
"type": null,
"docstring": null,
"docstring_tokens": [... |
b43a405e8e8ff5437e864cbcdfe0294e602e325d | shambo001/peat | PEATSA/Tools/ExampleFunction.py | [
"MIT"
] | Python | DeltaStability | <not_specific> | def DeltaStability(inputFile, mutationList, configurationFile=None, workingDirectory=os.getcwd(), outputDirectory=os.getcwd()):
'''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 r... | 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 of a proteinDesignTool.conf file - defaults to home directory.
... | Calculates the stability difference between a protein and set of mutants | [
"Calculates",
"the",
"stability",
"difference",
"between",
"a",
"protein",
"and",
"set",
"of",
"mutants"
] | def DeltaStability(inputFile, mutationList, configurationFile=None, workingDirectory=os.getcwd(), outputDirectory=os.getcwd()):
tool = Core.ProteinDesignTool.ProteinDesignTool(configurationFile,
workingDirectory=workingDirectory,
pdbFile=inputFile,
outputDirectory=outputDirectory)
inputFile = tool.pdbFile
... | [
"def",
"DeltaStability",
"(",
"inputFile",
",",
"mutationList",
",",
"configurationFile",
"=",
"None",
",",
"workingDirectory",
"=",
"os",
".",
"getcwd",
"(",
")",
",",
"outputDirectory",
"=",
"os",
".",
"getcwd",
"(",
")",
")",
":",
"tool",
"=",
"Core",
... | 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\t\n\tParameters:\n\t\tinputFile: A PDB file of the protein\n\t\tmutationList: A list of Data.MutationSet instances. Each represents a mutant of the protein.\n\t\tconfigurationFile: The location of a proteinDesignTool.conf file - defaults... | [
{
"param": "inputFile",
"type": null
},
{
"param": "mutationList",
"type": null
},
{
"param": "configurationFile",
"type": null
},
{
"param": "workingDirectory",
"type": null
},
{
"param": "outputDirectory",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "inputFile",
"type": null,
"docstring": "A PDB file of the protein",
"docstring_tokens": [
"A",
"PDB",
"file",
"of",
"the",
"protein"
],
"default": null,
"is_opt... |
4593b50299fad2aa64c2de524e5b78120f218a06 | shambo001/peat | PEATSA/Tools/PCA.py | [
"MIT"
] | Python | pca | <not_specific> | def pca(m):
'''Performs pca on the Core.Matrix.Matrix instance m.
Returns:
eigenvalues - A numpy 1-D array.
eigenvectors - A numpy 2-D array
transformedData - A numpy 2-D array'''
print >>sys.stderr, 'Calculating mean vector'
data = numpy.array(m.matrix)
average = numpy.zeros(m.numberOfColumns())
for ro... | Performs pca on the Core.Matrix.Matrix instance m.
Returns:
eigenvalues - A numpy 1-D array.
eigenvectors - A numpy 2-D array
transformedData - A numpy 2-D array | Performs pca on the Core.Matrix.Matrix instance m. | [
"Performs",
"pca",
"on",
"the",
"Core",
".",
"Matrix",
".",
"Matrix",
"instance",
"m",
"."
] | def pca(m):
print >>sys.stderr, 'Calculating mean vector'
data = numpy.array(m.matrix)
average = numpy.zeros(m.numberOfColumns())
for row in data:
average = average + row
average /= m.numberOfRows()
temp = zip(m.columnHeaders(), average)
print >>sys.stderr, 'Result: '
for el in temp:
print >>sys.stderr, '\t... | [
"def",
"pca",
"(",
"m",
")",
":",
"print",
">>",
"sys",
".",
"stderr",
",",
"'Calculating mean vector'",
"data",
"=",
"numpy",
".",
"array",
"(",
"m",
".",
"matrix",
")",
"average",
"=",
"numpy",
".",
"zeros",
"(",
"m",
".",
"numberOfColumns",
"(",
"... | Performs pca on the Core.Matrix.Matrix instance m. | [
"Performs",
"pca",
"on",
"the",
"Core",
".",
"Matrix",
".",
"Matrix",
"instance",
"m",
"."
] | [
"'''Performs pca on the Core.Matrix.Matrix instance m.\n\n\tReturns: \n\t\teigenvalues - A numpy 1-D array.\n\t\teigenvectors - A numpy 2-D array\n\t\ttransformedData - A numpy 2-D array'''"
] | [
{
"param": "m",
"type": null
}
] | {
"returns": [
{
"docstring": "A numpy 1-D array.\neigenvectors - A numpy 2-D array\ntransformedData - A numpy 2-D array",
"docstring_tokens": [
"A",
"numpy",
"1",
"-",
"D",
"array",
".",
"eigenvectors",
"-",
"A",
... |
24e1fad48201c38399d82abedd0e89b9cd0b208e | shambo001/peat | pKaTool/CCPS_stab_opt.py | [
"MIT"
] | Python | optimise_system | <not_specific> | def optimise_system(self):
"""Optimise the system according to the values given by the user"""
#
# Did the bozo choose the CCPS?
#
self.find_chosen_CCPS()
if self.get_CCPSs()==[]:
import tkMessageBox
tkMessageBox.showwarning('No CCPS selected',
... | Optimise the system according to the values given by the user | Optimise the system according to the values given by the user | [
"Optimise",
"the",
"system",
"according",
"to",
"the",
"values",
"given",
"by",
"the",
"user"
] | def optimise_system(self):
Did the bozo choose the CCPS?
self.find_chosen_CCPS()
if self.get_CCPSs()==[]:
import tkMessageBox
tkMessageBox.showwarning('No CCPS selected',
'You have to chose the CCPS from the microscopic states',
... | [
"def",
"optimise_system",
"(",
"self",
")",
":",
"self",
".",
"find_chosen_CCPS",
"(",
")",
"if",
"self",
".",
"get_CCPSs",
"(",
")",
"==",
"[",
"]",
":",
"import",
"tkMessageBox",
"tkMessageBox",
".",
"showwarning",
"(",
"'No CCPS selected'",
",",
"'You hav... | Optimise the system according to the values given by the user | [
"Optimise",
"the",
"system",
"according",
"to",
"the",
"values",
"given",
"by",
"the",
"user"
] | [
"\"\"\"Optimise the system according to the values given by the user\"\"\"",
"#",
"# Did the bozo choose the CCPS?",
"#",
"#",
"# Find the properties we will use",
"#",
"#",
"#",
"# Get the variables",
"#",
"#",
"# Perform all variations within the limits",
"#",
"#",
"# Make copies of ... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
24e1fad48201c38399d82abedd0e89b9cd0b208e | shambo001/peat | pKaTool/CCPS_stab_opt.py | [
"MIT"
] | Python | _CCPS_population_base | <not_specific> | def _CCPS_population_base(self,variable,primary,spec):
"""Function that will give a score for how well one of the CCPS population meets the targets"""
#
# Loaded profile or entered values
#
if spec['profile']['var'].get()==0:
#
# Entered values
... | Function that will give a score for how well one of the CCPS population meets the targets | Function that will give a score for how well one of the CCPS population meets the targets | [
"Function",
"that",
"will",
"give",
"a",
"score",
"for",
"how",
"well",
"one",
"of",
"the",
"CCPS",
"population",
"meets",
"the",
"targets"
] | def _CCPS_population_base(self,variable,primary,spec):
Loaded profile or entered values
if spec['profile']['var'].get()==0:
Entered values
Get the pH values where we want to impose the criterium
if not self.CCPS_pH_vals:
self.CCPS_pH_vals=self.get_p... | [
"def",
"_CCPS_population_base",
"(",
"self",
",",
"variable",
",",
"primary",
",",
"spec",
")",
":",
"if",
"spec",
"[",
"'profile'",
"]",
"[",
"'var'",
"]",
".",
"get",
"(",
")",
"==",
"0",
":",
"if",
"not",
"self",
".",
"CCPS_pH_vals",
":",
"self",
... | Function that will give a score for how well one of the CCPS population meets the targets | [
"Function",
"that",
"will",
"give",
"a",
"score",
"for",
"how",
"well",
"one",
"of",
"the",
"CCPS",
"population",
"meets",
"the",
"targets"
] | [
"\"\"\"Function that will give a score for how well one of the CCPS population meets the targets\"\"\"",
"#",
"# Loaded profile or entered values",
"#",
"#",
"# Entered values",
"#",
"# Get the pH values where we want to impose the criterium",
"#",
"#",
"# pH values have already been identified"... | [
{
"param": "self",
"type": null
},
{
"param": "variable",
"type": null
},
{
"param": "primary",
"type": null
},
{
"param": "spec",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "variable",
"type": null,
"docstring": null,
"docstring_tokens... |
24e1fad48201c38399d82abedd0e89b9cd0b208e | shambo001/peat | pKaTool/CCPS_stab_opt.py | [
"MIT"
] | Python | _CCPS_maxrange | <not_specific> | def _CCPS_maxrange(self,spec):
"""Score for having the maximum of the CCPS in a range"""
#
# Get the pH values where we want to impose the criterium
#
if not self.CCPSmax_pH_vals:
self.CCPSmax_pH_vals=self.get_pH_range(spec['pH']['var'].get())
print 'Monit... | Score for having the maximum of the CCPS in a range | Score for having the maximum of the CCPS in a range | [
"Score",
"for",
"having",
"the",
"maximum",
"of",
"the",
"CCPS",
"in",
"a",
"range"
] | def _CCPS_maxrange(self,spec):
Get the pH values where we want to impose the criterium
if not self.CCPSmax_pH_vals:
self.CCPSmax_pH_vals=self.get_pH_range(spec['pH']['var'].get())
print 'Monitoring activity at these pH values',self.CCPSmax_pH_vals
pH values have already... | [
"def",
"_CCPS_maxrange",
"(",
"self",
",",
"spec",
")",
":",
"if",
"not",
"self",
".",
"CCPSmax_pH_vals",
":",
"self",
".",
"CCPSmax_pH_vals",
"=",
"self",
".",
"get_pH_range",
"(",
"spec",
"[",
"'pH'",
"]",
"[",
"'var'",
"]",
".",
"get",
"(",
")",
"... | Score for having the maximum of the CCPS in a range | [
"Score",
"for",
"having",
"the",
"maximum",
"of",
"the",
"CCPS",
"in",
"a",
"range"
] | [
"\"\"\"Score for having the maximum of the CCPS in a range\"\"\"",
"#",
"# Get the pH values where we want to impose the criterium",
"#",
"#",
"# pH values have already been identified",
"#",
"#",
"# Find the maximum activity",
"#",
"#",
"# Report the fraction of points that are within 10%",
... | [
{
"param": "self",
"type": null
},
{
"param": "spec",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "spec",
"type": null,
"docstring": null,
"docstring_tokens": [... |
24e1fad48201c38399d82abedd0e89b9cd0b208e | shambo001/peat | pKaTool/CCPS_stab_opt.py | [
"MIT"
] | Python | _Stability | <not_specific> | def _Stability(self,spec):
"""Score the stability of the system"""
if not self.Stability_pH_vals:
self.Stability_pH_vals=self.get_pH_range(spec['pH']['var'].get())
#
# Score the stability
#
opttype=spec['opttype']['var'].get()
cutoff=spec['cutoff']['va... | Score the stability of the system | Score the stability of the system | [
"Score",
"the",
"stability",
"of",
"the",
"system"
] | def _Stability(self,spec):
if not self.Stability_pH_vals:
self.Stability_pH_vals=self.get_pH_range(spec['pH']['var'].get())
Score the stability
opttype=spec['opttype']['var'].get()
cutoff=spec['cutoff']['var'].get()
if opttype=='maximise':
Maximising sta... | [
"def",
"_Stability",
"(",
"self",
",",
"spec",
")",
":",
"if",
"not",
"self",
".",
"Stability_pH_vals",
":",
"self",
".",
"Stability_pH_vals",
"=",
"self",
".",
"get_pH_range",
"(",
"spec",
"[",
"'pH'",
"]",
"[",
"'var'",
"]",
".",
"get",
"(",
")",
"... | Score the stability of the system | [
"Score",
"the",
"stability",
"of",
"the",
"system"
] | [
"\"\"\"Score the stability of the system\"\"\"",
"#",
"# Score the stability",
"#",
"# Maximising stability means minimising the dG of folding",
"#print 'Stability',math.exp(sum_stab)"
] | [
{
"param": "self",
"type": null
},
{
"param": "spec",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "spec",
"type": null,
"docstring": null,
"docstring_tokens": [... |
24e1fad48201c38399d82abedd0e89b9cd0b208e | shambo001/peat | pKaTool/CCPS_stab_opt.py | [
"MIT"
] | Python | _individual_intene | <not_specific> | def _individual_intene(self,spec):
return 0.0
"""Keep all interaction energies below a certain kT limit"""
import math
opttype=spec['opttype']['var'].get()
cutoff=spec['cutoff']['var'].get()
if opttype=='keep below':
score=0.0
for group in self.gro... | Keep all interaction energies below a certain kT limit | Keep all interaction energies below a certain kT limit | [
"Keep",
"all",
"interaction",
"energies",
"below",
"a",
"certain",
"kT",
"limit"
] | def _individual_intene(self,spec):
return 0.0
import math
opttype=spec['opttype']['var'].get()
cutoff=spec['cutoff']['var'].get()
if opttype=='keep below':
score=0.0
for group in self.groups:
for num in self.groups[group].intenes:
... | [
"def",
"_individual_intene",
"(",
"self",
",",
"spec",
")",
":",
"return",
"0.0",
"import",
"math",
"opttype",
"=",
"spec",
"[",
"'opttype'",
"]",
"[",
"'var'",
"]",
".",
"get",
"(",
")",
"cutoff",
"=",
"spec",
"[",
"'cutoff'",
"]",
"[",
"'var'",
"]"... | Keep all interaction energies below a certain kT limit | [
"Keep",
"all",
"interaction",
"energies",
"below",
"a",
"certain",
"kT",
"limit"
] | [
"\"\"\"Keep all interaction energies below a certain kT limit\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "spec",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "spec",
"type": null,
"docstring": null,
"docstring_tokens": [... |
62556c0cd8766bb8994769d48de9f3966df04b6f | shambo001/peat | PEATSA/WebApp/UtilityFunctions.py | [
"MIT"
] | Python | ResourceDirectory | <not_specific> | def ResourceDirectory():
'''Returns the path to the resource directory for the Backend'''
#Assign the location of the module to a variable
moduleLocation = os.path.dirname(__file__)
moduleLocation = os.path.abspath(moduleLocation)
#Create the resource path
resources = os.path.join(moduleLocation, 'Resources')
... | Returns the path to the resource directory for the Backend | Returns the path to the resource directory for the Backend | [
"Returns",
"the",
"path",
"to",
"the",
"resource",
"directory",
"for",
"the",
"Backend"
] | def ResourceDirectory():
moduleLocation = os.path.dirname(__file__)
moduleLocation = os.path.abspath(moduleLocation)
resources = os.path.join(moduleLocation, 'Resources')
return resources | [
"def",
"ResourceDirectory",
"(",
")",
":",
"moduleLocation",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"__file__",
")",
"moduleLocation",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"moduleLocation",
")",
"resources",
"=",
"os",
".",
"path",
".",
"jo... | Returns the path to the resource directory for the Backend | [
"Returns",
"the",
"path",
"to",
"the",
"resource",
"directory",
"for",
"the",
"Backend"
] | [
"'''Returns the path to the resource directory for the Backend'''",
"#Assign the location of the module to a variable",
"#Create the resource path"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
62556c0cd8766bb8994769d48de9f3966df04b6f | shambo001/peat | PEATSA/WebApp/UtilityFunctions.py | [
"MIT"
] | Python | ExecutablePath | <not_specific> | def ExecutablePath():
'''Returns the absolute path to PDTWebScript.py.
This is the backend executable for the WebApp which actually runs the job'''
moduleLocation = os.path.dirname(__file__)
moduleLocation = os.path.abspath(moduleLocation)
executablePath = os.path.join(moduleLocation, 'WebScript.py')
re... | Returns the absolute path to PDTWebScript.py.
This is the backend executable for the WebApp which actually runs the job | Returns the absolute path to PDTWebScript.py.
This is the backend executable for the WebApp which actually runs the job | [
"Returns",
"the",
"absolute",
"path",
"to",
"PDTWebScript",
".",
"py",
".",
"This",
"is",
"the",
"backend",
"executable",
"for",
"the",
"WebApp",
"which",
"actually",
"runs",
"the",
"job"
] | def ExecutablePath():
moduleLocation = os.path.dirname(__file__)
moduleLocation = os.path.abspath(moduleLocation)
executablePath = os.path.join(moduleLocation, 'WebScript.py')
return executablePath | [
"def",
"ExecutablePath",
"(",
")",
":",
"moduleLocation",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"__file__",
")",
"moduleLocation",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"moduleLocation",
")",
"executablePath",
"=",
"os",
".",
"path",
".",
"... | Returns the absolute path to PDTWebScript.py. | [
"Returns",
"the",
"absolute",
"path",
"to",
"PDTWebScript",
".",
"py",
"."
] | [
"'''Returns the absolute path to PDTWebScript.py.\n\t\n\tThis is the backend executable for the WebApp which actually runs the job'''"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
62556c0cd8766bb8994769d48de9f3966df04b6f | shambo001/peat | PEATSA/WebApp/UtilityFunctions.py | [
"MIT"
] | Python | CreateDateString | <not_specific> | def CreateDateString():
'''Creates a date string in the format yyyy-mm-dd hh:mm:ss
This format is acceptable for insertion as a DATETIME value in SQL'''
date = datetime.datetime.today()
string = "%s-%s-%s %s:%s:%s" % (date.year, date.month, date.day, date.hour, date.minute, date.second)
return string | Creates a date string in the format yyyy-mm-dd hh:mm:ss
This format is acceptable for insertion as a DATETIME value in SQL | Creates a date string in the format yyyy-mm-dd hh:mm:ss
This format is acceptable for insertion as a DATETIME value in SQL | [
"Creates",
"a",
"date",
"string",
"in",
"the",
"format",
"yyyy",
"-",
"mm",
"-",
"dd",
"hh",
":",
"mm",
":",
"ss",
"This",
"format",
"is",
"acceptable",
"for",
"insertion",
"as",
"a",
"DATETIME",
"value",
"in",
"SQL"
] | def CreateDateString():
date = datetime.datetime.today()
string = "%s-%s-%s %s:%s:%s" % (date.year, date.month, date.day, date.hour, date.minute, date.second)
return string | [
"def",
"CreateDateString",
"(",
")",
":",
"date",
"=",
"datetime",
".",
"datetime",
".",
"today",
"(",
")",
"string",
"=",
"\"%s-%s-%s %s:%s:%s\"",
"%",
"(",
"date",
".",
"year",
",",
"date",
".",
"month",
",",
"date",
".",
"day",
",",
"date",
".",
"... | Creates a date string in the format yyyy-mm-dd hh:mm:ss
This format is acceptable for insertion as a DATETIME value in SQL | [
"Creates",
"a",
"date",
"string",
"in",
"the",
"format",
"yyyy",
"-",
"mm",
"-",
"dd",
"hh",
":",
"mm",
":",
"ss",
"This",
"format",
"is",
"acceptable",
"for",
"insertion",
"as",
"a",
"DATETIME",
"value",
"in",
"SQL"
] | [
"'''Creates a date string in the format yyyy-mm-dd hh:mm:ss\n\t\n\tThis format is acceptable for insertion as a DATETIME value in SQL'''"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
62556c0cd8766bb8994769d48de9f3966df04b6f | shambo001/peat | PEATSA/WebApp/UtilityFunctions.py | [
"MIT"
] | Python | GetNewSID | <not_specific> | def GetNewSID(tag):
'''Returns a unique string for use as a Session ID'''
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(tag):
t1 = time.time()
t2 = t1 + random.random()
base = md5.new( tag + str(t1 +t2) )
sid = tag + '_' + base.hexdigest()
return sid | [
"def",
"GetNewSID",
"(",
"tag",
")",
":",
"t1",
"=",
"time",
".",
"time",
"(",
")",
"t2",
"=",
"t1",
"+",
"random",
".",
"random",
"(",
")",
"base",
"=",
"md5",
".",
"new",
"(",
"tag",
"+",
"str",
"(",
"t1",
"+",
"t2",
")",
")",
"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'''"
] | [
{
"param": "tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "tag",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
62556c0cd8766bb8994769d48de9f3966df04b6f | shambo001/peat | PEATSA/WebApp/UtilityFunctions.py | [
"MIT"
] | Python | ConnectionFromConfiguration | <not_specific> | def ConnectionFromConfiguration(configuration):
'''Creates and returns a connection based on the information in the configuration object.
The configuration object should be an instance of the Core.Environment.Configuration class.
The underlying configuration file should contain a section 'DATABASE' with the value... | Creates and returns a connection based on the information in the configuration object.
The configuration object should be an instance of the Core.Environment.Configuration class.
The underlying configuration file should contain a section 'DATABASE' with the value
host, user, password and database | Creates and returns a connection based on the information in the configuration object.
The configuration object should be an instance of the Core.Environment.Configuration class.
The underlying configuration file should contain a section 'DATABASE' with the value
host, user, password and database | [
"Creates",
"and",
"returns",
"a",
"connection",
"based",
"on",
"the",
"information",
"in",
"the",
"configuration",
"object",
".",
"The",
"configuration",
"object",
"should",
"be",
"an",
"instance",
"of",
"the",
"Core",
".",
"Environment",
".",
"Configuration",
... | def ConnectionFromConfiguration(configuration):
connection = MySQLdb.connect(host=configuration.get("DATABASE", "host"),
user=configuration.get("DATABASE","user"),
passwd=configuration.get("DATABASE", "password"),
db=configuration.get("DATABASE", "database"))
return connection | [
"def",
"ConnectionFromConfiguration",
"(",
"configuration",
")",
":",
"connection",
"=",
"MySQLdb",
".",
"connect",
"(",
"host",
"=",
"configuration",
".",
"get",
"(",
"\"DATABASE\"",
",",
"\"host\"",
")",
",",
"user",
"=",
"configuration",
".",
"get",
"(",
... | Creates and returns a connection based on the information in the configuration object. | [
"Creates",
"and",
"returns",
"a",
"connection",
"based",
"on",
"the",
"information",
"in",
"the",
"configuration",
"object",
"."
] | [
"'''Creates and returns a connection based on the information in the configuration object.\n\t\n\tThe configuration object should be an instance of the Core.Environment.Configuration class.\n\tThe underlying configuration file should contain a section 'DATABASE' with the value\n\thost, user, password and database''... | [
{
"param": "configuration",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "configuration",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
62556c0cd8766bb8994769d48de9f3966df04b6f | shambo001/peat | PEATSA/WebApp/UtilityFunctions.py | [
"MIT"
] | Python | ConnectionFromDefaultConfiguration | <not_specific> | def ConnectionFromDefaultConfiguration():
'''Create and returns a connection based on the information in the default webapp configuration file.
This is located in Backend/Resources/webApplication.conf'''
return ConnectionFromConfiguration(DefaultWebAppConfiguration()) | Create and returns a connection based on the information in the default webapp configuration file.
This is located in Backend/Resources/webApplication.conf | Create and returns a connection based on the information in the default webapp configuration file.
This is located in Backend/Resources/webApplication.conf | [
"Create",
"and",
"returns",
"a",
"connection",
"based",
"on",
"the",
"information",
"in",
"the",
"default",
"webapp",
"configuration",
"file",
".",
"This",
"is",
"located",
"in",
"Backend",
"/",
"Resources",
"/",
"webApplication",
".",
"conf"
] | def ConnectionFromDefaultConfiguration():
return ConnectionFromConfiguration(DefaultWebAppConfiguration()) | [
"def",
"ConnectionFromDefaultConfiguration",
"(",
")",
":",
"return",
"ConnectionFromConfiguration",
"(",
"DefaultWebAppConfiguration",
"(",
")",
")"
] | Create and returns a connection based on the information in the default webapp configuration file. | [
"Create",
"and",
"returns",
"a",
"connection",
"based",
"on",
"the",
"information",
"in",
"the",
"default",
"webapp",
"configuration",
"file",
"."
] | [
"'''Create and returns a connection based on the information in the default webapp configuration file.\n\t\n\tThis is located in Backend/Resources/webApplication.conf'''"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
62556c0cd8766bb8994769d48de9f3966df04b6f | shambo001/peat | PEATSA/WebApp/UtilityFunctions.py | [
"MIT"
] | Python | DefaultWebAppConfiguration | <not_specific> | def DefaultWebAppConfiguration():
'''Returns the default configuration object based on the default configuration file.
This is located in Backend/Resources/webApplication.conf'''
configurationFile = os.path.join(ResourceDirectory(), 'webApplication.conf')
return Core.Environment.Configuration(filename=confi... | Returns the default configuration object based on the default configuration file.
This is located in Backend/Resources/webApplication.conf | Returns the default configuration object based on the default configuration file.
This is located in Backend/Resources/webApplication.conf | [
"Returns",
"the",
"default",
"configuration",
"object",
"based",
"on",
"the",
"default",
"configuration",
"file",
".",
"This",
"is",
"located",
"in",
"Backend",
"/",
"Resources",
"/",
"webApplication",
".",
"conf"
] | def DefaultWebAppConfiguration():
configurationFile = os.path.join(ResourceDirectory(), 'webApplication.conf')
return Core.Environment.Configuration(filename=configurationFile) | [
"def",
"DefaultWebAppConfiguration",
"(",
")",
":",
"configurationFile",
"=",
"os",
".",
"path",
".",
"join",
"(",
"ResourceDirectory",
"(",
")",
",",
"'webApplication.conf'",
")",
"return",
"Core",
".",
"Environment",
".",
"Configuration",
"(",
"filename",
"=",... | Returns the default configuration object based on the default configuration file. | [
"Returns",
"the",
"default",
"configuration",
"object",
"based",
"on",
"the",
"default",
"configuration",
"file",
"."
] | [
"'''Returns the default configuration object based on the default configuration file.\t\n\t\n\tThis is located in Backend/Resources/webApplication.conf'''"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
62556c0cd8766bb8994769d48de9f3966df04b6f | shambo001/peat | PEATSA/WebApp/UtilityFunctions.py | [
"MIT"
] | Python | SendNotificationEmail | <not_specific> | def SendNotificationEmail(job):
'''Sends an email to the address associated with job is done
Note: A mail is only sent if no previous mail has been sent.
Parameters:
job - A WebApp.Data.Job instance representing a PEATSA job
'''
if job.isEmailSent():
return
import smtplib
from email.MIMEText import MIME... | Sends an email to the address associated with job is done
Note: A mail is only sent if no previous mail has been sent.
Parameters:
job - A WebApp.Data.Job instance representing a PEATSA job
| Sends an email to the address associated with job is done
Note: A mail is only sent if no previous mail has been sent.
A WebApp.Data.Job instance representing a PEATSA job | [
"Sends",
"an",
"email",
"to",
"the",
"address",
"associated",
"with",
"job",
"is",
"done",
"Note",
":",
"A",
"mail",
"is",
"only",
"sent",
"if",
"no",
"previous",
"mail",
"has",
"been",
"sent",
".",
"A",
"WebApp",
".",
"Data",
".",
"Job",
"instance",
... | def SendNotificationEmail(job):
if job.isEmailSent():
return
import smtplib
from email.MIMEText import MIMEText
from email.MIMEMultipart import MIMEMultipart
message = MIMEMultipart()
message['From'] = 'peatadmin@ucd.ie'
message['Reply-To'] = 'peatadmin@ucd.ie'
message['To'] = job.email()
if job.error() is N... | [
"def",
"SendNotificationEmail",
"(",
"job",
")",
":",
"if",
"job",
".",
"isEmailSent",
"(",
")",
":",
"return",
"import",
"smtplib",
"from",
"email",
".",
"MIMEText",
"import",
"MIMEText",
"from",
"email",
".",
"MIMEMultipart",
"import",
"MIMEMultipart",
"mess... | Sends an email to the address associated with job is done
Note: A mail is only sent if no previous mail has been sent. | [
"Sends",
"an",
"email",
"to",
"the",
"address",
"associated",
"with",
"job",
"is",
"done",
"Note",
":",
"A",
"mail",
"is",
"only",
"sent",
"if",
"no",
"previous",
"mail",
"has",
"been",
"sent",
"."
] | [
"'''Sends an email to the address associated with job is done\n\n\tNote: A mail is only sent if no previous mail has been sent.\n\n\tParameters:\n\tjob - A WebApp.Data.Job instance representing a PEATSA job\n\n\t'''",
"# Send the email"
] | [
{
"param": "job",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "job",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
5490c591ad838da8ffe82aac651d80e91d000557 | shambo001/peat | PEATDB/sequence_alignment.py | [
"MIT"
] | Python | Protool2pir | <not_specific> | def Protool2pir(sequence):
""" Reformats a protool style sequence to a regular one-letter sequence"""
import Protool
X=Protool.structureIO()
seq=''
#
# Get rid of final stop codon
#
if sequence[-1][1]=='***':
sequence=sequence[:-1]
ignored={}
for aa in sequence:
i... | Reformats a protool style sequence to a regular one-letter sequence | Reformats a protool style sequence to a regular one-letter sequence | [
"Reformats",
"a",
"protool",
"style",
"sequence",
"to",
"a",
"regular",
"one",
"-",
"letter",
"sequence"
] | def Protool2pir(sequence):
import Protool
X=Protool.structureIO()
seq=''
Get rid of final stop codon
if sequence[-1][1]=='***':
sequence=sequence[:-1]
ignored={}
for aa in sequence:
if aa[1]:
Ignore water
if not X.three_to_one.has_key(aa[1]):
... | [
"def",
"Protool2pir",
"(",
"sequence",
")",
":",
"import",
"Protool",
"X",
"=",
"Protool",
".",
"structureIO",
"(",
")",
"seq",
"=",
"''",
"if",
"sequence",
"[",
"-",
"1",
"]",
"[",
"1",
"]",
"==",
"'***'",
":",
"sequence",
"=",
"sequence",
"[",
":... | Reformats a protool style sequence to a regular one-letter sequence | [
"Reformats",
"a",
"protool",
"style",
"sequence",
"to",
"a",
"regular",
"one",
"-",
"letter",
"sequence"
] | [
"\"\"\" Reformats a protool style sequence to a regular one-letter sequence\"\"\"",
"#",
"# Get rid of final stop codon",
"#",
"#",
"# Ignore water",
"#"
] | [
{
"param": "sequence",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "sequence",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
5490c591ad838da8ffe82aac651d80e91d000557 | shambo001/peat | PEATDB/sequence_alignment.py | [
"MIT"
] | Python | read_clustal_aln_file | <not_specific> | def read_clustal_aln_file(filename):
"""Read a clustalW/X aln file"""
import os
seqs={}
if os.path.isfile(filename):
fd=open(filename)
lines=fd.readlines()
fd.close()
#
# Read the lines
#
import string
for line in lines:
if len(... | Read a clustalW/X aln file | Read a clustalW/X aln file | [
"Read",
"a",
"clustalW",
"/",
"X",
"aln",
"file"
] | def read_clustal_aln_file(filename):
import os
seqs={}
if os.path.isfile(filename):
fd=open(filename)
lines=fd.readlines()
fd.close()
Read the lines
import string
for line in lines:
if len(line.strip())==0:
continue
eli... | [
"def",
"read_clustal_aln_file",
"(",
"filename",
")",
":",
"import",
"os",
"seqs",
"=",
"{",
"}",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"filename",
")",
":",
"fd",
"=",
"open",
"(",
"filename",
")",
"lines",
"=",
"fd",
".",
"readlines",
"(",
... | Read a clustalW/X aln file | [
"Read",
"a",
"clustalW",
"/",
"X",
"aln",
"file"
] | [
"\"\"\"Read a clustalW/X aln file\"\"\"",
"#",
"# Read the lines",
"#"
] | [
{
"param": "filename",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "filename",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
5490c591ad838da8ffe82aac651d80e91d000557 | shambo001/peat | PEATDB/sequence_alignment.py | [
"MIT"
] | Python | calculate_sequence_identity_matrix | <not_specific> | def calculate_sequence_identity_matrix(seqs):
"""Given a dictionary of aligned sequences, this function will calculate the % sequence identity matrix"""
matrix={}
names=sorted(seqs.keys())
for name1 in names:
matrix[name1]={}
for name2 in names:
print name1,name2
... | Given a dictionary of aligned sequences, this function will calculate the % sequence identity matrix | Given a dictionary of aligned sequences, this function will calculate the % sequence identity matrix | [
"Given",
"a",
"dictionary",
"of",
"aligned",
"sequences",
"this",
"function",
"will",
"calculate",
"the",
"%",
"sequence",
"identity",
"matrix"
] | def calculate_sequence_identity_matrix(seqs):
matrix={}
names=sorted(seqs.keys())
for name1 in names:
matrix[name1]={}
for name2 in names:
print name1,name2
matrix[name1][name2]=calc_identity(seqs[name1],seqs[name2])
s1=seqs[name1].replace('-','')
prin... | [
"def",
"calculate_sequence_identity_matrix",
"(",
"seqs",
")",
":",
"matrix",
"=",
"{",
"}",
"names",
"=",
"sorted",
"(",
"seqs",
".",
"keys",
"(",
")",
")",
"for",
"name1",
"in",
"names",
":",
"matrix",
"[",
"name1",
"]",
"=",
"{",
"}",
"for",
"name... | Given a dictionary of aligned sequences, this function will calculate the % sequence identity matrix | [
"Given",
"a",
"dictionary",
"of",
"aligned",
"sequences",
"this",
"function",
"will",
"calculate",
"the",
"%",
"sequence",
"identity",
"matrix"
] | [
"\"\"\"Given a dictionary of aligned sequences, this function will calculate the % sequence identity matrix\"\"\"",
"#"
] | [
{
"param": "seqs",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "seqs",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
5490c591ad838da8ffe82aac651d80e91d000557 | shambo001/peat | PEATDB/sequence_alignment.py | [
"MIT"
] | Python | calc_identity | <not_specific> | def calc_identity(seq1,seq2):
"""Calculate the sequence identity for these two aligned sequences"""
id=0
if len(seq1)!=len(seq2):
print 'Sequences have different length! %d %d' %(len(seq1),len(seq2))
raise Exception('Incorrect alignment')
#
for pos in range(len(seq1)):
if seq... | Calculate the sequence identity for these two aligned sequences | Calculate the sequence identity for these two aligned sequences | [
"Calculate",
"the",
"sequence",
"identity",
"for",
"these",
"two",
"aligned",
"sequences"
] | def calc_identity(seq1,seq2):
id=0
if len(seq1)!=len(seq2):
print 'Sequences have different length! %d %d' %(len(seq1),len(seq2))
raise Exception('Incorrect alignment')
for pos in range(len(seq1)):
if seq1[pos]==seq2[pos] and seq1[pos]!='-':
id=id+1
print 'ID',id
... | [
"def",
"calc_identity",
"(",
"seq1",
",",
"seq2",
")",
":",
"id",
"=",
"0",
"if",
"len",
"(",
"seq1",
")",
"!=",
"len",
"(",
"seq2",
")",
":",
"print",
"'Sequences have different length! %d %d'",
"%",
"(",
"len",
"(",
"seq1",
")",
",",
"len",
"(",
"s... | Calculate the sequence identity for these two aligned sequences | [
"Calculate",
"the",
"sequence",
"identity",
"for",
"these",
"two",
"aligned",
"sequences"
] | [
"\"\"\"Calculate the sequence identity for these two aligned sequences\"\"\"",
"#"
] | [
{
"param": "seq1",
"type": null
},
{
"param": "seq2",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "seq1",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "seq2",
"type": null,
"docstring": null,
"docstring_tokens": [... |
ca0c164a87162f74ba1d32f318545e72a587bc92 | shambo001/peat | pKaTool/explore/explore_pKa_system.py | [
"MIT"
] | Python | construct_permutations | <not_specific> | def construct_permutations(self):
"""Construct the specification for all possible permutations specified in __init__"""
#
# Make pickled files for each configuration
#
import large_dataset_manager, os
self.options.dir=os.path.join(os.getcwd(),options.dir)
if not o... | Construct the specification for all possible permutations specified in __init__ | Construct the specification for all possible permutations specified in __init | [
"Construct",
"the",
"specification",
"for",
"all",
"possible",
"permutations",
"specified",
"in",
"__init"
] | def construct_permutations(self):
Make pickled files for each configuration
import large_dataset_manager, os
self.options.dir=os.path.join(os.getcwd(),options.dir)
if not os.path.isdir(self.options.dir):
os.mkdir(options.dir)
self.Data=large_dataset_manager.data_mana... | [
"def",
"construct_permutations",
"(",
"self",
")",
":",
"import",
"large_dataset_manager",
",",
"os",
"self",
".",
"options",
".",
"dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"getcwd",
"(",
")",
",",
"options",
".",
"dir",
")",
"if",
... | Construct the specification for all possible permutations specified in __init__ | [
"Construct",
"the",
"specification",
"for",
"all",
"possible",
"permutations",
"specified",
"in",
"__init__"
] | [
"\"\"\"Construct the specification for all possible permutations specified in __init__\"\"\"",
"#",
"# Make pickled files for each configuration",
"#",
"#",
"# Init the counters",
"#",
"#",
"# Start the loop",
"#",
"#",
"# Get the specification",
"#",
"#print spec",
"#",
"# Get the tim... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
ca0c164a87162f74ba1d32f318545e72a587bc92 | shambo001/peat | pKaTool/explore/explore_pKa_system.py | [
"MIT"
] | Python | calculate_system | <not_specific> | def calculate_system(self):
"""Calculate titration curves for all permutations of the system"""
print 'Solving system'
count=0
import time
start=time.time()
for perm in self.Data.index.keys():
count=count+1
perc=float(count)/float(self.tot_perms)*1... | Calculate titration curves for all permutations of the system | Calculate titration curves for all permutations of the system | [
"Calculate",
"titration",
"curves",
"for",
"all",
"permutations",
"of",
"the",
"system"
] | def calculate_system(self):
print 'Solving system'
count=0
import time
start=time.time()
for perm in self.Data.index.keys():
count=count+1
perc=float(count)/float(self.tot_perms)*100.0
now=time.time()
time_passed=now-start
... | [
"def",
"calculate_system",
"(",
"self",
")",
":",
"print",
"'Solving system'",
"count",
"=",
"0",
"import",
"time",
"start",
"=",
"time",
".",
"time",
"(",
")",
"for",
"perm",
"in",
"self",
".",
"Data",
".",
"index",
".",
"keys",
"(",
")",
":",
"coun... | Calculate titration curves for all permutations of the system | [
"Calculate",
"titration",
"curves",
"for",
"all",
"permutations",
"of",
"the",
"system"
] | [
"\"\"\"Calculate titration curves for all permutations of the system\"\"\"",
"#",
"#"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
129b83bc3aef4d1ce6f0faa102e71cfe5ed38fbf | shambo001/peat | pKaTool/explore/make_2grp_system_permutations.py | [
"MIT"
] | Python | do_pKa_calc | <not_specific> | def do_pKa_calc(self,pka_diff,int_ene):
"""Do the pKa calculation for this system"""
import pKaTool.pKa_calc, math
self.PK=pKaTool.pKa_calc.Boltzmann()
groups={':0001:GLU':{'backgr':0.0,':0002:GLU':int_ene},':0002:GLU':{'backgr':pka_diff*math.log(10),':0001:GLU':int_ene}}
self.s... | Do the pKa calculation for this system | Do the pKa calculation for this system | [
"Do",
"the",
"pKa",
"calculation",
"for",
"this",
"system"
] | def do_pKa_calc(self,pka_diff,int_ene):
import pKaTool.pKa_calc, math
self.PK=pKaTool.pKa_calc.Boltzmann()
groups={':0001:GLU':{'backgr':0.0,':0002:GLU':int_ene},':0002:GLU':{'backgr':pka_diff*math.log(10),':0001:GLU':int_ene}}
self.setup_system(groups)
pKa_values,prot_states=se... | [
"def",
"do_pKa_calc",
"(",
"self",
",",
"pka_diff",
",",
"int_ene",
")",
":",
"import",
"pKaTool",
".",
"pKa_calc",
",",
"math",
"self",
".",
"PK",
"=",
"pKaTool",
".",
"pKa_calc",
".",
"Boltzmann",
"(",
")",
"groups",
"=",
"{",
"':0001:GLU'",
":",
"{"... | Do the pKa calculation for this system | [
"Do",
"the",
"pKa",
"calculation",
"for",
"this",
"system"
] | [
"\"\"\"Do the pKa calculation for this system\"\"\"",
"#"
] | [
{
"param": "self",
"type": null
},
{
"param": "pka_diff",
"type": null
},
{
"param": "int_ene",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pka_diff",
"type": null,
"docstring": null,
"docstring_tokens... |
02e4ce5111137b19520cca6597985964a8e05c57 | shambo001/peat | PEATDB/Filtering.py | [
"MIT"
] | Python | doFiltering | <not_specific> | def doFiltering(self, searchfunc, filters=None):
"""Filter recs by several filters using user provided search function.
Provides a list of tuples with filter values"""
F=[]
for f in self.filters:
F.append(f.getFilter())
#print F
sets = []
for f in F:
... | Filter recs by several filters using user provided search function.
Provides a list of tuples with filter values | Filter recs by several filters using user provided search function.
Provides a list of tuples with filter values | [
"Filter",
"recs",
"by",
"several",
"filters",
"using",
"user",
"provided",
"search",
"function",
".",
"Provides",
"a",
"list",
"of",
"tuples",
"with",
"filter",
"values"
] | def doFiltering(self, searchfunc, filters=None):
F=[]
for f in self.filters:
F.append(f.getFilter())
sets = []
for f in F:
col, val, op, boolean = f
names = searchfunc(col, val, op)
sets.append((set(names), boolean))
names = sets[0]... | [
"def",
"doFiltering",
"(",
"self",
",",
"searchfunc",
",",
"filters",
"=",
"None",
")",
":",
"F",
"=",
"[",
"]",
"for",
"f",
"in",
"self",
".",
"filters",
":",
"F",
".",
"append",
"(",
"f",
".",
"getFilter",
"(",
")",
")",
"sets",
"=",
"[",
"]"... | Filter recs by several filters using user provided search function. | [
"Filter",
"recs",
"by",
"several",
"filters",
"using",
"user",
"provided",
"search",
"function",
"."
] | [
"\"\"\"Filter recs by several filters using user provided search function.\n Provides a list of tuples with filter values\"\"\"",
"#print F"
] | [
{
"param": "self",
"type": null
},
{
"param": "searchfunc",
"type": null
},
{
"param": "filters",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "searchfunc",
"type": null,
"docstring": null,
"docstring_toke... |
3979061d739e80364d96e4c6ad79af976bad805a | shambo001/peat | pKaTool/Ghosts/utilities_CSP.py | [
"MIT"
] | Python | parseResName | <not_specific> | def parseResName(line):
'''
Parse residue name of the line
'''
return line[17:20].strip() |
Parse residue name of the line
| Parse residue name of the line | [
"Parse",
"residue",
"name",
"of",
"the",
"line"
] | def parseResName(line):
return line[17:20].strip() | [
"def",
"parseResName",
"(",
"line",
")",
":",
"return",
"line",
"[",
"17",
":",
"20",
"]",
".",
"strip",
"(",
")"
] | Parse residue name of the line | [
"Parse",
"residue",
"name",
"of",
"the",
"line"
] | [
"'''\n\tParse residue name of the line\n\t'''"
] | [
{
"param": "line",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "line",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
3979061d739e80364d96e4c6ad79af976bad805a | shambo001/peat | pKaTool/Ghosts/utilities_CSP.py | [
"MIT"
] | Python | parseAtomName | <not_specific> | def parseAtomName(line):
'''
Parse atom name of the line
'''
return line[12:16].strip() |
Parse atom name of the line
| Parse atom name of the line | [
"Parse",
"atom",
"name",
"of",
"the",
"line"
] | def parseAtomName(line):
return line[12:16].strip() | [
"def",
"parseAtomName",
"(",
"line",
")",
":",
"return",
"line",
"[",
"12",
":",
"16",
"]",
".",
"strip",
"(",
")"
] | Parse atom name of the line | [
"Parse",
"atom",
"name",
"of",
"the",
"line"
] | [
"'''\n\tParse atom name of the line\n\t'''"
] | [
{
"param": "line",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "line",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
3979061d739e80364d96e4c6ad79af976bad805a | shambo001/peat | pKaTool/Ghosts/utilities_CSP.py | [
"MIT"
] | Python | parseResNum | <not_specific> | def parseResNum(line):
'''
Parse residue number from the line
'''
return int(line[22:26].strip()) |
Parse residue number from the line
| Parse residue number from the line | [
"Parse",
"residue",
"number",
"from",
"the",
"line"
] | def parseResNum(line):
return int(line[22:26].strip()) | [
"def",
"parseResNum",
"(",
"line",
")",
":",
"return",
"int",
"(",
"line",
"[",
"22",
":",
"26",
"]",
".",
"strip",
"(",
")",
")"
] | Parse residue number from the line | [
"Parse",
"residue",
"number",
"from",
"the",
"line"
] | [
"'''\n\tParse residue number from the line\n\t'''"
] | [
{
"param": "line",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "line",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
3979061d739e80364d96e4c6ad79af976bad805a | shambo001/peat | pKaTool/Ghosts/utilities_CSP.py | [
"MIT"
] | Python | parseChainID | <not_specific> | def parseChainID(line):
'''
Parse residue number from the line
'''
return line[21] |
Parse residue number from the line
| Parse residue number from the line | [
"Parse",
"residue",
"number",
"from",
"the",
"line"
] | def parseChainID(line):
return line[21] | [
"def",
"parseChainID",
"(",
"line",
")",
":",
"return",
"line",
"[",
"21",
"]"
] | Parse residue number from the line | [
"Parse",
"residue",
"number",
"from",
"the",
"line"
] | [
"'''\n\tParse residue number from the line\n\t'''"
] | [
{
"param": "line",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "line",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
3979061d739e80364d96e4c6ad79af976bad805a | shambo001/peat | pKaTool/Ghosts/utilities_CSP.py | [
"MIT"
] | Python | fieldCoulomb | <not_specific> | def fieldCoulomb(distCharge, cosAngle, charge):
'''
Calculate electric field using Coulombs law
'''
import math
E = 1.0/(4*math.pi*e0)*qe/(distCharge*1E-10)**2 *charge*cosAngle / au_field
return E |
Calculate electric field using Coulombs law
| Calculate electric field using Coulombs law | [
"Calculate",
"electric",
"field",
"using",
"Coulombs",
"law"
] | def fieldCoulomb(distCharge, cosAngle, charge):
import math
E = 1.0/(4*math.pi*e0)*qe/(distCharge*1E-10)**2 *charge*cosAngle / au_field
return E | [
"def",
"fieldCoulomb",
"(",
"distCharge",
",",
"cosAngle",
",",
"charge",
")",
":",
"import",
"math",
"E",
"=",
"1.0",
"/",
"(",
"4",
"*",
"math",
".",
"pi",
"*",
"e0",
")",
"*",
"qe",
"/",
"(",
"distCharge",
"*",
"1E-10",
")",
"**",
"2",
"*",
... | Calculate electric field using Coulombs law | [
"Calculate",
"electric",
"field",
"using",
"Coulombs",
"law"
] | [
"'''\n\tCalculate electric field using Coulombs law\n\t'''"
] | [
{
"param": "distCharge",
"type": null
},
{
"param": "cosAngle",
"type": null
},
{
"param": "charge",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "distCharge",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "cosAngle",
"type": null,
"docstring": null,
"docstring_... |
9b11091d413d9a348fb46782618e9ac142ea38c9 | shambo001/peat | PEATDB/Ekin/sparky.py | [
"MIT"
] | Python | find_cols | <not_specific> | def find_cols(filename):
"""Get no. of assignment cols in peak file"""
fd=open(filename)
lines=fd.readlines()
fd.close()
cols=None
import string
for line in lines:
line=string.strip(line)
if len(line)>0 and 'Assignment' in line:
split=line.split()
... | Get no. of assignment cols in peak file | Get no. of assignment cols in peak file | [
"Get",
"no",
".",
"of",
"assignment",
"cols",
"in",
"peak",
"file"
] | def find_cols(filename):
fd=open(filename)
lines=fd.readlines()
fd.close()
cols=None
import string
for line in lines:
line=string.strip(line)
if len(line)>0 and 'Assignment' in line:
split=line.split()
print split
cols = len(split)-1
r... | [
"def",
"find_cols",
"(",
"filename",
")",
":",
"fd",
"=",
"open",
"(",
"filename",
")",
"lines",
"=",
"fd",
".",
"readlines",
"(",
")",
"fd",
".",
"close",
"(",
")",
"cols",
"=",
"None",
"import",
"string",
"for",
"line",
"in",
"lines",
":",
"line"... | Get no. | [
"Get",
"no",
"."
] | [
"\"\"\"Get no. of assignment cols in peak file\"\"\""
] | [
{
"param": "filename",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "filename",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9b11091d413d9a348fb46782618e9ac142ea38c9 | shambo001/peat | PEATDB/Ekin/sparky.py | [
"MIT"
] | Python | read_all | <not_specific> | def read_all(parentwin,dir,pattern):
"""Read all Sparky peak files in dir that match pattern"""
import os, re
files=os.listdir(dir)
okfiles=[]
files.sort()
for file in files:
if file.find(pattern)!=-1 and file[0]!='.':
okfiles.append(os.path.join(dir,file))
print 'files t... | Read all Sparky peak files in dir that match pattern | Read all Sparky peak files in dir that match pattern | [
"Read",
"all",
"Sparky",
"peak",
"files",
"in",
"dir",
"that",
"match",
"pattern"
] | def read_all(parentwin,dir,pattern):
import os, re
files=os.listdir(dir)
okfiles=[]
files.sort()
for file in files:
if file.find(pattern)!=-1 and file[0]!='.':
okfiles.append(os.path.join(dir,file))
print 'files to be used:',okfiles
columns=None
dict={}
regex = "... | [
"def",
"read_all",
"(",
"parentwin",
",",
"dir",
",",
"pattern",
")",
":",
"import",
"os",
",",
"re",
"files",
"=",
"os",
".",
"listdir",
"(",
"dir",
")",
"okfiles",
"=",
"[",
"]",
"files",
".",
"sort",
"(",
")",
"for",
"file",
"in",
"files",
":"... | Read all Sparky peak files in dir that match pattern | [
"Read",
"all",
"Sparky",
"peak",
"files",
"in",
"dir",
"that",
"match",
"pattern"
] | [
"\"\"\"Read all Sparky peak files in dir that match pattern\"\"\"",
"# Loop over all files and get peaks ",
"# Get the pH from the filename ",
"'Could not extract the pH from filename'",
"#Read the file and get the peaks "
] | [
{
"param": "parentwin",
"type": null
},
{
"param": "dir",
"type": null
},
{
"param": "pattern",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "parentwin",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dir",
"type": null,
"docstring": null,
"docstring_tokens... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | mouse_wheel | <not_specific> | def mouse_wheel(self, event):
"""Handle mouse wheel scroll for windows"""
if event.num == 5 or event.delta == -120:
event.widget.yview_scroll(1, UNITS)
self.tablerowheader.yview_scroll(1, UNITS)
if event.num == 4 or event.delta == 120:
event.widget.yview_scrol... | Handle mouse wheel scroll for windows | Handle mouse wheel scroll for windows | [
"Handle",
"mouse",
"wheel",
"scroll",
"for",
"windows"
] | def mouse_wheel(self, event):
if event.num == 5 or event.delta == -120:
event.widget.yview_scroll(1, UNITS)
self.tablerowheader.yview_scroll(1, UNITS)
if event.num == 4 or event.delta == 120:
event.widget.yview_scroll(-1, UNITS)
self.tablerowheader.yview_s... | [
"def",
"mouse_wheel",
"(",
"self",
",",
"event",
")",
":",
"if",
"event",
".",
"num",
"==",
"5",
"or",
"event",
".",
"delta",
"==",
"-",
"120",
":",
"event",
".",
"widget",
".",
"yview_scroll",
"(",
"1",
",",
"UNITS",
")",
"self",
".",
"tablerowhea... | Handle mouse wheel scroll for windows | [
"Handle",
"mouse",
"wheel",
"scroll",
"for",
"windows"
] | [
"\"\"\"Handle mouse wheel scroll for windows\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | do_bindings | <not_specific> | def do_bindings(self):
"""Bind keys and mouse clicks, this can be overriden"""
self.bind("<Button-1>",self.handle_left_click)
self.bind("<Double-Button-1>",self.handle_double_click)
self.bind("<Control-Button-1>", self.handle_left_ctrl_click)
self.bind("<Shift-Button-1>", self.ha... | Bind keys and mouse clicks, this can be overriden | Bind keys and mouse clicks, this can be overriden | [
"Bind",
"keys",
"and",
"mouse",
"clicks",
"this",
"can",
"be",
"overriden"
] | def do_bindings(self):
self.bind("<Button-1>",self.handle_left_click)
self.bind("<Double-Button-1>",self.handle_double_click)
self.bind("<Control-Button-1>", self.handle_left_ctrl_click)
self.bind("<Shift-Button-1>", self.handle_left_shift_click)
self.bind("<ButtonRelease-1>", se... | [
"def",
"do_bindings",
"(",
"self",
")",
":",
"self",
".",
"bind",
"(",
"\"<Button-1>\"",
",",
"self",
".",
"handle_left_click",
")",
"self",
".",
"bind",
"(",
"\"<Double-Button-1>\"",
",",
"self",
".",
"handle_double_click",
")",
"self",
".",
"bind",
"(",
... | Bind keys and mouse clicks, this can be overriden | [
"Bind",
"keys",
"and",
"mouse",
"clicks",
"this",
"can",
"be",
"overriden"
] | [
"\"\"\"Bind keys and mouse clicks, this can be overriden\"\"\"",
"#For mac we bind Shift, left-click to right click",
"#if not hasattr(self,'parentapp'):",
"# self.parentapp = self.parentframe"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | createTableFrame | <not_specific> | def createTableFrame(self, callback=None):
"""Adds column header and scrollbars and combines them with
the current table adding all to the master frame provided in constructor.
Table is then redrawn."""
#Add the table and header to the frame
self.Yscrollbar = AutoScrollbar... | Adds column header and scrollbars and combines them with
the current table adding all to the master frame provided in constructor.
Table is then redrawn. | Adds column header and scrollbars and combines them with
the current table adding all to the master frame provided in constructor.
Table is then redrawn. | [
"Adds",
"column",
"header",
"and",
"scrollbars",
"and",
"combines",
"them",
"with",
"the",
"current",
"table",
"adding",
"all",
"to",
"the",
"master",
"frame",
"provided",
"in",
"constructor",
".",
"Table",
"is",
"then",
"redrawn",
"."
] | def createTableFrame(self, callback=None):
self.Yscrollbar = AutoScrollbar(self.parentframe,orient=VERTICAL,command=self.set_yviews)
self.Yscrollbar.grid(row=1,column=2,rowspan=1,sticky='news',pady=0,ipady=0)
self.Xscrollbar = AutoScrollbar(self.parentframe,orient=HORIZONTAL,command=self.set_xvi... | [
"def",
"createTableFrame",
"(",
"self",
",",
"callback",
"=",
"None",
")",
":",
"self",
".",
"Yscrollbar",
"=",
"AutoScrollbar",
"(",
"self",
".",
"parentframe",
",",
"orient",
"=",
"VERTICAL",
",",
"command",
"=",
"self",
".",
"set_yviews",
")",
"self",
... | Adds column header and scrollbars and combines them with
the current table adding all to the master frame provided in constructor. | [
"Adds",
"column",
"header",
"and",
"scrollbars",
"and",
"combines",
"them",
"with",
"the",
"current",
"table",
"adding",
"all",
"to",
"the",
"master",
"frame",
"provided",
"in",
"constructor",
"."
] | [
"\"\"\"Adds column header and scrollbars and combines them with\n the current table adding all to the master frame provided in constructor.\n Table is then redrawn.\"\"\"",
"#Add the table and header to the frame",
"#self.table.yview(\"moveto\", 0)"
] | [
{
"param": "self",
"type": null
},
{
"param": "callback",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "callback",
"type": null,
"docstring": null,
"docstring_tokens... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | redrawTable | <not_specific> | def redrawTable(self, event=None, callback=None):
"""Draw the table from scratch based on it's model data"""
import time
model = self.model
self.rows=self.model.getRowCount()
self.cols=self.model.getColumnCount()
self.tablewidth=(self.cellwidth)*self.cols
self.con... | Draw the table from scratch based on it's model data | Draw the table from scratch based on it's model data | [
"Draw",
"the",
"table",
"from",
"scratch",
"based",
"on",
"it",
"'",
"s",
"model",
"data"
] | def redrawTable(self, event=None, callback=None):
import time
model = self.model
self.rows=self.model.getRowCount()
self.cols=self.model.getColumnCount()
self.tablewidth=(self.cellwidth)*self.cols
self.configure(bg=self.cellbackgr)
self.set_colPositions()
... | [
"def",
"redrawTable",
"(",
"self",
",",
"event",
"=",
"None",
",",
"callback",
"=",
"None",
")",
":",
"import",
"time",
"model",
"=",
"self",
".",
"model",
"self",
".",
"rows",
"=",
"self",
".",
"model",
".",
"getRowCount",
"(",
")",
"self",
".",
"... | Draw the table from scratch based on it's model data | [
"Draw",
"the",
"table",
"from",
"scratch",
"based",
"on",
"it",
"'",
"s",
"model",
"data"
] | [
"\"\"\"Draw the table from scratch based on it's model data\"\"\"",
"#determine col positions for first time",
"#are we drawing a filtered subset of the recs?",
"#check if large no. of records and switch to paging view",
"#if using paging, we only want to display the current page..",
"#determine current r... | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
},
{
"param": "callback",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | resizeTable | <not_specific> | def resizeTable(self, event):
"""Respond to a resize event - redraws table"""
if self.autoresizecols == 1 and event != None:
self.cellwidth = (event.width - self.x_start - 24) / self.cols
#print 'cellwidth', self.cellwidth
self.redrawTable()
return | Respond to a resize event - redraws table | Respond to a resize event - redraws table | [
"Respond",
"to",
"a",
"resize",
"event",
"-",
"redraws",
"table"
] | def resizeTable(self, event):
if self.autoresizecols == 1 and event != None:
self.cellwidth = (event.width - self.x_start - 24) / self.cols
self.redrawTable()
return | [
"def",
"resizeTable",
"(",
"self",
",",
"event",
")",
":",
"if",
"self",
".",
"autoresizecols",
"==",
"1",
"and",
"event",
"!=",
"None",
":",
"self",
".",
"cellwidth",
"=",
"(",
"event",
".",
"width",
"-",
"self",
".",
"x_start",
"-",
"24",
")",
"/... | Respond to a resize event - redraws table | [
"Respond",
"to",
"a",
"resize",
"event",
"-",
"redraws",
"table"
] | [
"\"\"\"Respond to a resize event - redraws table\"\"\"",
"#print 'cellwidth', self.cellwidth"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | adjust_colWidths | <not_specific> | def adjust_colWidths(self):
"""Optimally adjust col widths at start to accomodate the longest entry"""
try:
fontsize=self.celltextsizevar.get()
except:
fontsize=11
scale = 8.5 # +fontsize/10
for col in range(self.cols):
width = self.model.getl... | Optimally adjust col widths at start to accomodate the longest entry | Optimally adjust col widths at start to accomodate the longest entry | [
"Optimally",
"adjust",
"col",
"widths",
"at",
"start",
"to",
"accomodate",
"the",
"longest",
"entry"
] | def adjust_colWidths(self):
try:
fontsize=self.celltextsizevar.get()
except:
fontsize=11
scale = 8.5
for col in range(self.cols):
width = self.model.getlongestEntry(col) * scale
if width >= self.maxcellwidth:
width = self.m... | [
"def",
"adjust_colWidths",
"(",
"self",
")",
":",
"try",
":",
"fontsize",
"=",
"self",
".",
"celltextsizevar",
".",
"get",
"(",
")",
"except",
":",
"fontsize",
"=",
"11",
"scale",
"=",
"8.5",
"for",
"col",
"in",
"range",
"(",
"self",
".",
"cols",
")"... | Optimally adjust col widths at start to accomodate the longest entry | [
"Optimally",
"adjust",
"col",
"widths",
"at",
"start",
"to",
"accomodate",
"the",
"longest",
"entry"
] | [
"\"\"\"Optimally adjust col widths at start to accomodate the longest entry\"\"\"",
"# +fontsize/10",
"#print 'comparing', width, self.maxcellwidth"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | sortTable | <not_specific> | def sortTable(self, sortcol=None, reverse=0):
"""Set up sort order dict based on currently selected field"""
#self.sortcol = self.currentcol
self.model.setSortOrder(self.currentcol, self.reverseorder)
self.reverseorder = reverse
self.redrawTable()
return | Set up sort order dict based on currently selected field | Set up sort order dict based on currently selected field | [
"Set",
"up",
"sort",
"order",
"dict",
"based",
"on",
"currently",
"selected",
"field"
] | def sortTable(self, sortcol=None, reverse=0):
self.model.setSortOrder(self.currentcol, self.reverseorder)
self.reverseorder = reverse
self.redrawTable()
return | [
"def",
"sortTable",
"(",
"self",
",",
"sortcol",
"=",
"None",
",",
"reverse",
"=",
"0",
")",
":",
"self",
".",
"model",
".",
"setSortOrder",
"(",
"self",
".",
"currentcol",
",",
"self",
".",
"reverseorder",
")",
"self",
".",
"reverseorder",
"=",
"rever... | Set up sort order dict based on currently selected field | [
"Set",
"up",
"sort",
"order",
"dict",
"based",
"on",
"currently",
"selected",
"field"
] | [
"\"\"\"Set up sort order dict based on currently selected field\"\"\"",
"#self.sortcol = self.currentcol"
] | [
{
"param": "self",
"type": null
},
{
"param": "sortcol",
"type": null
},
{
"param": "reverse",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "sortcol",
"type": null,
"docstring": null,
"docstring_tokens"... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | drawNavFrame | <not_specific> | def drawNavFrame(self):
"""Draw the frame for selecting pages when paging is on"""
#print 'adding page frame'
import Table_images
self.navFrame = Frame(self.parentframe)
self.navFrame.grid(row=4,column=0,columnspan=2,sticky='news',padx=1,pady=1,ipady=1)
pagingbuttons = { ... | Draw the frame for selecting pages when paging is on | Draw the frame for selecting pages when paging is on | [
"Draw",
"the",
"frame",
"for",
"selecting",
"pages",
"when",
"paging",
"is",
"on"
] | def drawNavFrame(self):
import Table_images
self.navFrame = Frame(self.parentframe)
self.navFrame.grid(row=4,column=0,columnspan=2,sticky='news',padx=1,pady=1,ipady=1)
pagingbuttons = { 'start' : self.first_Page, 'prev' : self.prev_Page,
'next' : self.next_Page,... | [
"def",
"drawNavFrame",
"(",
"self",
")",
":",
"import",
"Table_images",
"self",
".",
"navFrame",
"=",
"Frame",
"(",
"self",
".",
"parentframe",
")",
"self",
".",
"navFrame",
".",
"grid",
"(",
"row",
"=",
"4",
",",
"column",
"=",
"0",
",",
"columnspan",... | Draw the frame for selecting pages when paging is on | [
"Draw",
"the",
"frame",
"for",
"selecting",
"pages",
"when",
"paging",
"is",
"on"
] | [
"\"\"\"Draw the frame for selecting pages when paging is on\"\"\"",
"#print 'adding page frame'",
"#Label(self.navFrame,text='Goto Record:').pack(side=LEFT,padx=3)",
"#self.gotorecordvar = StringVar()",
"#Entry(self.navFrame,textvariable=self.gotorecordvar,",
"# width=8,bg='white').pack(side=LEFT... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | check_PageView | <not_specific> | def check_PageView(self, row):
"""Check if row clickable for page view"""
if self.paging == 1:
absrow = self.get_AbsoluteRow(row)
if absrow >= self.rows or row > self.rowsperpage:
return 1
return 0 | Check if row clickable for page view | Check if row clickable for page view | [
"Check",
"if",
"row",
"clickable",
"for",
"page",
"view"
] | def check_PageView(self, row):
if self.paging == 1:
absrow = self.get_AbsoluteRow(row)
if absrow >= self.rows or row > self.rowsperpage:
return 1
return 0 | [
"def",
"check_PageView",
"(",
"self",
",",
"row",
")",
":",
"if",
"self",
".",
"paging",
"==",
"1",
":",
"absrow",
"=",
"self",
".",
"get_AbsoluteRow",
"(",
"row",
")",
"if",
"absrow",
">=",
"self",
".",
"rows",
"or",
"row",
">",
"self",
".",
"rows... | Check if row clickable for page view | [
"Check",
"if",
"row",
"clickable",
"for",
"page",
"view"
] | [
"\"\"\"Check if row clickable for page view\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "row",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "row",
"type": null,
"docstring": null,
"docstring_tokens": []... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | autoAdd_Rows | <not_specific> | def autoAdd_Rows(self, numrows=None):
"""Automatically add x number of records"""
import string
if numrows == None:
numrows = tkSimpleDialog.askinteger("Auto add rows.",
"How many empty rows?",
... | Automatically add x number of records | Automatically add x number of records | [
"Automatically",
"add",
"x",
"number",
"of",
"records"
] | def autoAdd_Rows(self, numrows=None):
import string
if numrows == None:
numrows = tkSimpleDialog.askinteger("Auto add rows.",
"How many empty rows?",
parent=self.parentframe)
self.model.au... | [
"def",
"autoAdd_Rows",
"(",
"self",
",",
"numrows",
"=",
"None",
")",
":",
"import",
"string",
"if",
"numrows",
"==",
"None",
":",
"numrows",
"=",
"tkSimpleDialog",
".",
"askinteger",
"(",
"\"Auto add rows.\"",
",",
"\"How many empty rows?\"",
",",
"parent",
"... | Automatically add x number of records | [
"Automatically",
"add",
"x",
"number",
"of",
"records"
] | [
"\"\"\"Automatically add x number of records\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "numrows",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "numrows",
"type": null,
"docstring": null,
"docstring_tokens"... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | autoAdd_Columns | <not_specific> | def autoAdd_Columns(self, numcols=None):
"""Automatically add x number of cols"""
if numcols == None:
numcols = tkSimpleDialog.askinteger("Auto add rows.",
"How many empty columns?",
parent=self.p... | Automatically add x number of cols | Automatically add x number of cols | [
"Automatically",
"add",
"x",
"number",
"of",
"cols"
] | def autoAdd_Columns(self, numcols=None):
if numcols == None:
numcols = tkSimpleDialog.askinteger("Auto add rows.",
"How many empty columns?",
parent=self.parentframe)
self.model.auto_AddColumns(nu... | [
"def",
"autoAdd_Columns",
"(",
"self",
",",
"numcols",
"=",
"None",
")",
":",
"if",
"numcols",
"==",
"None",
":",
"numcols",
"=",
"tkSimpleDialog",
".",
"askinteger",
"(",
"\"Auto add rows.\"",
",",
"\"How many empty columns?\"",
",",
"parent",
"=",
"self",
".... | Automatically add x number of cols | [
"Automatically",
"add",
"x",
"number",
"of",
"cols"
] | [
"\"\"\"Automatically add x number of cols\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "numcols",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "numcols",
"type": null,
"docstring": null,
"docstring_tokens"... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | findValue | <not_specific> | def findValue(self, searchstring=None, findagain=None):
"""Return the row/col for the input value"""
if searchstring == None:
searchstring = tkSimpleDialog.askstring("Search table.",
"Enter search value",
... | Return the row/col for the input value | Return the row/col for the input value | [
"Return",
"the",
"row",
"/",
"col",
"for",
"the",
"input",
"value"
] | def findValue(self, searchstring=None, findagain=None):
if searchstring == None:
searchstring = tkSimpleDialog.askstring("Search table.",
"Enter search value",
parent=self.parentframe)
found=0
... | [
"def",
"findValue",
"(",
"self",
",",
"searchstring",
"=",
"None",
",",
"findagain",
"=",
"None",
")",
":",
"if",
"searchstring",
"==",
"None",
":",
"searchstring",
"=",
"tkSimpleDialog",
".",
"askstring",
"(",
"\"Search table.\"",
",",
"\"Enter search value\"",... | Return the row/col for the input value | [
"Return",
"the",
"row",
"/",
"col",
"for",
"the",
"input",
"value"
] | [
"\"\"\"Return the row/col for the input value\"\"\"",
"#highlight cell",
"#add row/col to foundlist",
"#need to scroll to centre the cell here.."
] | [
{
"param": "self",
"type": null
},
{
"param": "searchstring",
"type": null
},
{
"param": "findagain",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "searchstring",
"type": null,
"docstring": null,
"docstring_to... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | doFilter | <not_specific> | def doFilter(self, event=None):
"""Filter the table display by some column values.
We simply pass the model search function to the the filtering
class and that handles everything else.
See filtering frame class for how searching is done.
"""
if self.model==None:
... | Filter the table display by some column values.
We simply pass the model search function to the the filtering
class and that handles everything else.
See filtering frame class for how searching is done.
| Filter the table display by some column values.
We simply pass the model search function to the the filtering
class and that handles everything else.
See filtering frame class for how searching is done. | [
"Filter",
"the",
"table",
"display",
"by",
"some",
"column",
"values",
".",
"We",
"simply",
"pass",
"the",
"model",
"search",
"function",
"to",
"the",
"the",
"filtering",
"class",
"and",
"that",
"handles",
"everything",
"else",
".",
"See",
"filtering",
"fram... | def doFilter(self, event=None):
if self.model==None:
return
from Filtering import FilterFrame
names = self.filterframe.doFiltering(searchfunc=self.model.filterBy)
self.model.filteredrecs = names
self.filtered = True
if self.paging == 1:
self.cu... | [
"def",
"doFilter",
"(",
"self",
",",
"event",
"=",
"None",
")",
":",
"if",
"self",
".",
"model",
"==",
"None",
":",
"return",
"from",
"Filtering",
"import",
"FilterFrame",
"names",
"=",
"self",
".",
"filterframe",
".",
"doFiltering",
"(",
"searchfunc",
"... | Filter the table display by some column values. | [
"Filter",
"the",
"table",
"display",
"by",
"some",
"column",
"values",
"."
] | [
"\"\"\"Filter the table display by some column values.\n We simply pass the model search function to the the filtering \n class and that handles everything else.\n See filtering frame class for how searching is done.\n \"\"\"",
"#create a list of filtered recs"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | gotoprevRow | <not_specific> | def gotoprevRow(self):
"""Programmatically set previous row - eg. for button events"""
self.clearSelected()
current = self.getSelectedRow()
self.setSelectedRow(current-1)
self.startrow = current-1
self.endrow = current-1
#reset multiple selection list
self... | Programmatically set previous row - eg. for button events | Programmatically set previous row - eg. for button events | [
"Programmatically",
"set",
"previous",
"row",
"-",
"eg",
".",
"for",
"button",
"events"
] | def gotoprevRow(self):
self.clearSelected()
current = self.getSelectedRow()
self.setSelectedRow(current-1)
self.startrow = current-1
self.endrow = current-1
self.multiplerowlist=[]
self.multiplerowlist.append(self.currentrow)
self.draw_selected_rect(self.c... | [
"def",
"gotoprevRow",
"(",
"self",
")",
":",
"self",
".",
"clearSelected",
"(",
")",
"current",
"=",
"self",
".",
"getSelectedRow",
"(",
")",
"self",
".",
"setSelectedRow",
"(",
"current",
"-",
"1",
")",
"self",
".",
"startrow",
"=",
"current",
"-",
"1... | Programmatically set previous row - eg. | [
"Programmatically",
"set",
"previous",
"row",
"-",
"eg",
"."
] | [
"\"\"\"Programmatically set previous row - eg. for button events\"\"\"",
"#reset multiple selection list"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | gotonextRow | <not_specific> | def gotonextRow(self):
"""Programmatically set next row - eg. for button events"""
self.clearSelected()
current = self.getSelectedRow()
self.setSelectedRow(current+1)
self.startrow = current+1
self.endrow = current+1
#reset multiple selection list
self.mul... | Programmatically set next row - eg. for button events | Programmatically set next row - eg. for button events | [
"Programmatically",
"set",
"next",
"row",
"-",
"eg",
".",
"for",
"button",
"events"
] | def gotonextRow(self):
self.clearSelected()
current = self.getSelectedRow()
self.setSelectedRow(current+1)
self.startrow = current+1
self.endrow = current+1
self.multiplerowlist=[]
self.multiplerowlist.append(self.currentrow)
self.draw_selected_rect(self.c... | [
"def",
"gotonextRow",
"(",
"self",
")",
":",
"self",
".",
"clearSelected",
"(",
")",
"current",
"=",
"self",
".",
"getSelectedRow",
"(",
")",
"self",
".",
"setSelectedRow",
"(",
"current",
"+",
"1",
")",
"self",
".",
"startrow",
"=",
"current",
"+",
"1... | Programmatically set next row - eg. | [
"Programmatically",
"set",
"next",
"row",
"-",
"eg",
"."
] | [
"\"\"\"Programmatically set next row - eg. for button events\"\"\"",
"#reset multiple selection list"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | handle_mouse_drag | <not_specific> | def handle_mouse_drag(self, event):
"""Handle mouse moved with button held down, multiple selections"""
if hasattr(self, 'cellentry'):
self.cellentry.destroy()
rowover = self.get_row_clicked(event)
colover = self.get_col_clicked(event)
if colover == None or rowover ==... | Handle mouse moved with button held down, multiple selections | Handle mouse moved with button held down, multiple selections | [
"Handle",
"mouse",
"moved",
"with",
"button",
"held",
"down",
"multiple",
"selections"
] | def handle_mouse_drag(self, event):
if hasattr(self, 'cellentry'):
self.cellentry.destroy()
rowover = self.get_row_clicked(event)
colover = self.get_col_clicked(event)
if colover == None or rowover == None:
return
if self.check_PageView(rowover) == 1:
... | [
"def",
"handle_mouse_drag",
"(",
"self",
",",
"event",
")",
":",
"if",
"hasattr",
"(",
"self",
",",
"'cellentry'",
")",
":",
"self",
".",
"cellentry",
".",
"destroy",
"(",
")",
"rowover",
"=",
"self",
".",
"get_row_clicked",
"(",
"event",
")",
"colover",... | Handle mouse moved with button held down, multiple selections | [
"Handle",
"mouse",
"moved",
"with",
"button",
"held",
"down",
"multiple",
"selections"
] | [
"\"\"\"Handle mouse moved with button held down, multiple selections\"\"\"",
"#print rowover",
"#do columns",
"#print self.multiplecollist",
"#draw the selected rows",
"#draw selected cells outline using row and col lists",
"#print self.multiplerowlist",
"#print self.multiplerowlist"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | handle_double_click | <not_specific> | def handle_double_click(self, event):
"""Do double click stuff. Selected row/cols will already have
been set with single click binding"""
#print 'double click'
row = self.get_row_clicked(event)
col = self.get_col_clicked(event)
absrow = self.get_AbsoluteRow(row)
... | Do double click stuff. Selected row/cols will already have
been set with single click binding | Do double click stuff. Selected row/cols will already have
been set with single click binding | [
"Do",
"double",
"click",
"stuff",
".",
"Selected",
"row",
"/",
"cols",
"will",
"already",
"have",
"been",
"set",
"with",
"single",
"click",
"binding"
] | def handle_double_click(self, event):
row = self.get_row_clicked(event)
col = self.get_col_clicked(event)
absrow = self.get_AbsoluteRow(row)
model=self.getModel()
cellvalue = model.getCellRecord(absrow, col)
if Formula.isFormula(cellvalue):
self.formula_Dialog... | [
"def",
"handle_double_click",
"(",
"self",
",",
"event",
")",
":",
"row",
"=",
"self",
".",
"get_row_clicked",
"(",
"event",
")",
"col",
"=",
"self",
".",
"get_col_clicked",
"(",
"event",
")",
"absrow",
"=",
"self",
".",
"get_AbsoluteRow",
"(",
"row",
")... | Do double click stuff. | [
"Do",
"double",
"click",
"stuff",
"."
] | [
"\"\"\"Do double click stuff. Selected row/cols will already have\n been set with single click binding\"\"\"",
"#print 'double click'",
"#self.enterFormula(rowclicked, colclicked)",
"#self.draw_cellentry(self.currentrow, self.currentcol)"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | gotonextCell | <not_specific> | def gotonextCell(self, event):
"""Move highlighted cell to next cell in row or a new col"""
#print 'next'
if hasattr(self, 'cellentry'):
self.cellentry.destroy()
self.currentcol=self.currentcol+1
if self.currentcol >= self.cols-1:
self.currentrow = self.c... | Move highlighted cell to next cell in row or a new col | Move highlighted cell to next cell in row or a new col | [
"Move",
"highlighted",
"cell",
"to",
"next",
"cell",
"in",
"row",
"or",
"a",
"new",
"col"
] | def gotonextCell(self, event):
if hasattr(self, 'cellentry'):
self.cellentry.destroy()
self.currentcol=self.currentcol+1
if self.currentcol >= self.cols-1:
self.currentrow = self.currentrow +1
self.currentcol = self.currentcol+1
self.draw_selected_rec... | [
"def",
"gotonextCell",
"(",
"self",
",",
"event",
")",
":",
"if",
"hasattr",
"(",
"self",
",",
"'cellentry'",
")",
":",
"self",
".",
"cellentry",
".",
"destroy",
"(",
")",
"self",
".",
"currentcol",
"=",
"self",
".",
"currentcol",
"+",
"1",
"if",
"se... | Move highlighted cell to next cell in row or a new col | [
"Move",
"highlighted",
"cell",
"to",
"next",
"cell",
"in",
"row",
"or",
"a",
"new",
"col"
] | [
"\"\"\"Move highlighted cell to next cell in row or a new col\"\"\"",
"#print 'next'"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | movetoSelectedRow | <not_specific> | def movetoSelectedRow(self, row=None, recname=None):
"""Move to selected row, updating table"""
row=self.model.getRecordIndex(recname)
self.setSelectedRow(row)
self.drawSelectedRow()
x,y = self.getCanvasPos(row, 0)
self.yview('moveto', y-0.0... | Move to selected row, updating table | Move to selected row, updating table | [
"Move",
"to",
"selected",
"row",
"updating",
"table"
] | def movetoSelectedRow(self, row=None, recname=None):
row=self.model.getRecordIndex(recname)
self.setSelectedRow(row)
self.drawSelectedRow()
x,y = self.getCanvasPos(row, 0)
self.yview('moveto', y-0.01)
self.tablecolheader.yview('moveto', y) ... | [
"def",
"movetoSelectedRow",
"(",
"self",
",",
"row",
"=",
"None",
",",
"recname",
"=",
"None",
")",
":",
"row",
"=",
"self",
".",
"model",
".",
"getRecordIndex",
"(",
"recname",
")",
"self",
".",
"setSelectedRow",
"(",
"row",
")",
"self",
".",
"drawSel... | Move to selected row, updating table | [
"Move",
"to",
"selected",
"row",
"updating",
"table"
] | [
"\"\"\"Move to selected row, updating table\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "row",
"type": null
},
{
"param": "recname",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "row",
"type": null,
"docstring": null,
"docstring_tokens": []... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | handleFormulaClick | <not_specific> | def handleFormulaClick(self, row, col):
"""Do a dialog for cell formula entry"""
model = self.getModel()
cell = list(model.getRecColNames(row, col))
absrow = self.get_AbsoluteRow(row)
self.formulaText.insert(END, str(cell))
self.formulaText.focus_set()
self.d... | Do a dialog for cell formula entry | Do a dialog for cell formula entry | [
"Do",
"a",
"dialog",
"for",
"cell",
"formula",
"entry"
] | def handleFormulaClick(self, row, col):
model = self.getModel()
cell = list(model.getRecColNames(row, col))
absrow = self.get_AbsoluteRow(row)
self.formulaText.insert(END, str(cell))
self.formulaText.focus_set()
self.draw_selected_rect(row, col, color='red')
retur... | [
"def",
"handleFormulaClick",
"(",
"self",
",",
"row",
",",
"col",
")",
":",
"model",
"=",
"self",
".",
"getModel",
"(",
")",
"cell",
"=",
"list",
"(",
"model",
".",
"getRecColNames",
"(",
"row",
",",
"col",
")",
")",
"absrow",
"=",
"self",
".",
"ge... | Do a dialog for cell formula entry | [
"Do",
"a",
"dialog",
"for",
"cell",
"formula",
"entry"
] | [
"\"\"\"Do a dialog for cell formula entry\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "row",
"type": null
},
{
"param": "col",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "row",
"type": null,
"docstring": null,
"docstring_tokens": []... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | convertFormulae | <not_specific> | def convertFormulae(self, rows, cols=None):
"""Convert the formulas in the cells to their result values"""
if len(self.multiplerowlist) == 0 or len(self.multiplecollist) == 0:
return None
print rows, cols
if cols == None:
cols = range(self.cols)
for... | Convert the formulas in the cells to their result values | Convert the formulas in the cells to their result values | [
"Convert",
"the",
"formulas",
"in",
"the",
"cells",
"to",
"their",
"result",
"values"
] | def convertFormulae(self, rows, cols=None):
if len(self.multiplerowlist) == 0 or len(self.multiplecollist) == 0:
return None
print rows, cols
if cols == None:
cols = range(self.cols)
for r in rows:
absr=self.get_AbsoluteRow(r)
for c in cols... | [
"def",
"convertFormulae",
"(",
"self",
",",
"rows",
",",
"cols",
"=",
"None",
")",
":",
"if",
"len",
"(",
"self",
".",
"multiplerowlist",
")",
"==",
"0",
"or",
"len",
"(",
"self",
".",
"multiplecollist",
")",
"==",
"0",
":",
"return",
"None",
"print"... | Convert the formulas in the cells to their result values | [
"Convert",
"the",
"formulas",
"in",
"the",
"cells",
"to",
"their",
"result",
"values"
] | [
"\"\"\"Convert the formulas in the cells to their result values\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "rows",
"type": null
},
{
"param": "cols",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "rows",
"type": null,
"docstring": null,
"docstring_tokens": [... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | copyCell | <not_specific> | def copyCell(self, rows, cols=None):
"""Copy cell contents to a temp internal clipboard"""
row = rows[0]; col = cols[0]
absrow = self.get_AbsoluteRow(row)
import copy
self.clipboard = copy.deepcopy(self.model.getCellRecord(absrow, col))
return | Copy cell contents to a temp internal clipboard | Copy cell contents to a temp internal clipboard | [
"Copy",
"cell",
"contents",
"to",
"a",
"temp",
"internal",
"clipboard"
] | def copyCell(self, rows, cols=None):
row = rows[0]; col = cols[0]
absrow = self.get_AbsoluteRow(row)
import copy
self.clipboard = copy.deepcopy(self.model.getCellRecord(absrow, col))
return | [
"def",
"copyCell",
"(",
"self",
",",
"rows",
",",
"cols",
"=",
"None",
")",
":",
"row",
"=",
"rows",
"[",
"0",
"]",
";",
"col",
"=",
"cols",
"[",
"0",
"]",
"absrow",
"=",
"self",
".",
"get_AbsoluteRow",
"(",
"row",
")",
"import",
"copy",
"self",
... | Copy cell contents to a temp internal clipboard | [
"Copy",
"cell",
"contents",
"to",
"a",
"temp",
"internal",
"clipboard"
] | [
"\"\"\"Copy cell contents to a temp internal clipboard\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "rows",
"type": null
},
{
"param": "cols",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "rows",
"type": null,
"docstring": null,
"docstring_tokens": [... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | pasteColumns | <not_specific> | def pasteColumns(self, coldata):
"""Paste new cols, overwrites existing names"""
M = self.model
for name in coldata:
if name not in M.columnNames:
M.addColumn(name)
for r in range(len(coldata[name])):
val = c... | Paste new cols, overwrites existing names | Paste new cols, overwrites existing names | [
"Paste",
"new",
"cols",
"overwrites",
"existing",
"names"
] | def pasteColumns(self, coldata):
M = self.model
for name in coldata:
if name not in M.columnNames:
M.addColumn(name)
for r in range(len(coldata[name])):
val = coldata[name][r]
col = M.columnNames.inde... | [
"def",
"pasteColumns",
"(",
"self",
",",
"coldata",
")",
":",
"M",
"=",
"self",
".",
"model",
"for",
"name",
"in",
"coldata",
":",
"if",
"name",
"not",
"in",
"M",
".",
"columnNames",
":",
"M",
".",
"addColumn",
"(",
"name",
")",
"for",
"r",
"in",
... | Paste new cols, overwrites existing names | [
"Paste",
"new",
"cols",
"overwrites",
"existing",
"names"
] | [
"\"\"\"Paste new cols, overwrites existing names\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "coldata",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "coldata",
"type": null,
"docstring": null,
"docstring_tokens"... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | popupMenu | <not_specific> | def popupMenu(self, event, rows=None, cols=None, outside=None):
"""Add left and right click behaviour for canvas, should not have to override
this function, it will take its values from defined dicts in constructor"""
if outside == None:
row = self.get_row_clicked(event)
... | Add left and right click behaviour for canvas, should not have to override
this function, it will take its values from defined dicts in constructor | Add left and right click behaviour for canvas, should not have to override
this function, it will take its values from defined dicts in constructor | [
"Add",
"left",
"and",
"right",
"click",
"behaviour",
"for",
"canvas",
"should",
"not",
"have",
"to",
"override",
"this",
"function",
"it",
"will",
"take",
"its",
"values",
"from",
"defined",
"dicts",
"in",
"constructor"
] | def popupMenu(self, event, rows=None, cols=None, outside=None):
if outside == None:
row = self.get_row_clicked(event)
col = self.get_col_clicked(event)
coltype = self.model.getColumnType(col)
popupmenu = Menu(self, tearoff = 0)
def popupFocusOut(event):
... | [
"def",
"popupMenu",
"(",
"self",
",",
"event",
",",
"rows",
"=",
"None",
",",
"cols",
"=",
"None",
",",
"outside",
"=",
"None",
")",
":",
"if",
"outside",
"==",
"None",
":",
"row",
"=",
"self",
".",
"get_row_clicked",
"(",
"event",
")",
"col",
"=",... | Add left and right click behaviour for canvas, should not have to override
this function, it will take its values from defined dicts in constructor | [
"Add",
"left",
"and",
"right",
"click",
"behaviour",
"for",
"canvas",
"should",
"not",
"have",
"to",
"override",
"this",
"function",
"it",
"will",
"take",
"its",
"values",
"from",
"defined",
"dicts",
"in",
"constructor"
] | [
"\"\"\"Add left and right click behaviour for canvas, should not have to override\n this function, it will take its values from defined dicts in constructor\"\"\"",
"#if outside table, just show general items ",
"\"\"\"Add commands to popup menu for col type\"\"\"",
"#add column actions ... | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
},
{
"param": "rows",
"type": null
},
{
"param": "cols",
"type": null
},
{
"param": "outside",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | add_commands | <not_specific> | def add_commands(fieldtype):
"""Add commands to popup menu for col type"""
#add column actions for this table type defined in self.columnactions
functions = self.columnactions[fieldtype]
for f in functions.keys():
func = getattr(self, f... | Add commands to popup menu for col type | Add commands to popup menu for col type | [
"Add",
"commands",
"to",
"popup",
"menu",
"for",
"col",
"type"
] | def add_commands(fieldtype):
functions = self.columnactions[fieldtype]
for f in functions.keys():
func = getattr(self, functions[f])
popupmenu.add_command(label=f, command= lambda : func(row,col))
return | [
"def",
"add_commands",
"(",
"fieldtype",
")",
":",
"functions",
"=",
"self",
".",
"columnactions",
"[",
"fieldtype",
"]",
"for",
"f",
"in",
"functions",
".",
"keys",
"(",
")",
":",
"func",
"=",
"getattr",
"(",
"self",
",",
"functions",
"[",
"f",
"]",
... | Add commands to popup menu for col type | [
"Add",
"commands",
"to",
"popup",
"menu",
"for",
"col",
"type"
] | [
"\"\"\"Add commands to popup menu for col type\"\"\"",
"#add column actions for this table type defined in self.columnactions"
] | [
{
"param": "fieldtype",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "fieldtype",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | add_defaultcommands | <not_specific> | def add_defaultcommands():
"""now add general actions for all cells"""
main = ["Set Fill Color","Set Text Color","Copy", "Paste", "Fill Down","Fill Right", "Clear Data",
"Delete Row", "Select All", "Plot Selected","Plot Options",
"Show Pr... | now add general actions for all cells | now add general actions for all cells | [
"now",
"add",
"general",
"actions",
"for",
"all",
"cells"
] | def add_defaultcommands():
main = ["Set Fill Color","Set Text Color","Copy", "Paste", "Fill Down","Fill Right", "Clear Data",
"Delete Row", "Select All", "Plot Selected","Plot Options",
"Show Prefs"]
utils = ["View Record", "Formulae->Val... | [
"def",
"add_defaultcommands",
"(",
")",
":",
"main",
"=",
"[",
"\"Set Fill Color\"",
",",
"\"Set Text Color\"",
",",
"\"Copy\"",
",",
"\"Paste\"",
",",
"\"Fill Down\"",
",",
"\"Fill Right\"",
",",
"\"Clear Data\"",
",",
"\"Delete Row\"",
",",
"\"Select All\"",
",",
... | now add general actions for all cells | [
"now",
"add",
"general",
"actions",
"for",
"all",
"cells"
] | [
"\"\"\"now add general actions for all cells\"\"\""
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | fill_down | <not_specific> | def fill_down(self, rowlist, collist):
"""Fill down a column, or multiple columns"""
model = self.model
absrow = self.get_AbsoluteRow(rowlist[0])
#remove first element as we don't want to overwrite it
rowlist.remove(rowlist[0])
#if this is a formula, we have to treat it... | Fill down a column, or multiple columns | Fill down a column, or multiple columns | [
"Fill",
"down",
"a",
"column",
"or",
"multiple",
"columns"
] | def fill_down(self, rowlist, collist):
model = self.model
absrow = self.get_AbsoluteRow(rowlist[0])
rowlist.remove(rowlist[0])
for col in collist:
val = self.model.getCellRecord(absrow, col)
f=val
i=1
for r in rowlist:
abs... | [
"def",
"fill_down",
"(",
"self",
",",
"rowlist",
",",
"collist",
")",
":",
"model",
"=",
"self",
".",
"model",
"absrow",
"=",
"self",
".",
"get_AbsoluteRow",
"(",
"rowlist",
"[",
"0",
"]",
")",
"rowlist",
".",
"remove",
"(",
"rowlist",
"[",
"0",
"]",... | Fill down a column, or multiple columns | [
"Fill",
"down",
"a",
"column",
"or",
"multiple",
"columns"
] | [
"\"\"\"Fill down a column, or multiple columns\"\"\"",
"#remove first element as we don't want to overwrite it",
"#if this is a formula, we have to treat it specially",
"#formula to copy",
"#print 'setting', val, 'at row', r"
] | [
{
"param": "self",
"type": null
},
{
"param": "rowlist",
"type": null
},
{
"param": "collist",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "rowlist",
"type": null,
"docstring": null,
"docstring_tokens"... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | fill_across | <not_specific> | def fill_across(self, collist, rowlist):
"""Fill across a row, or multiple rows"""
model = self.model
#row = self.currentrow
#absrow = self.get_AbsoluteRow(collist[0])
frstcol = collist[0]
collist.remove(frstcol)
for row in rowlist:
absr = self.get_A... | Fill across a row, or multiple rows | Fill across a row, or multiple rows | [
"Fill",
"across",
"a",
"row",
"or",
"multiple",
"rows"
] | def fill_across(self, collist, rowlist):
model = self.model
frstcol = collist[0]
collist.remove(frstcol)
for row in rowlist:
absr = self.get_AbsoluteRow(row)
val = self.model.getCellRecord(absr, frstcol)
f=val
i=1
for c in ... | [
"def",
"fill_across",
"(",
"self",
",",
"collist",
",",
"rowlist",
")",
":",
"model",
"=",
"self",
".",
"model",
"frstcol",
"=",
"collist",
"[",
"0",
"]",
"collist",
".",
"remove",
"(",
"frstcol",
")",
"for",
"row",
"in",
"rowlist",
":",
"absr",
"=",... | Fill across a row, or multiple rows | [
"Fill",
"across",
"a",
"row",
"or",
"multiple",
"rows"
] | [
"\"\"\"Fill across a row, or multiple rows\"\"\"",
"#row = self.currentrow",
"#absrow = self.get_AbsoluteRow(collist[0])",
"#formula to copy"
] | [
{
"param": "self",
"type": null
},
{
"param": "collist",
"type": null
},
{
"param": "rowlist",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "collist",
"type": null,
"docstring": null,
"docstring_tokens"... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | plot_Selected | <not_specific> | def plot_Selected(self):
"""Plot the selected data using pylab - if possible"""
from PylabPlot import pylabPlotter
if not hasattr(self, 'pyplot'):
self.pyplot = pylabPlotter()
plotdata = []
for p in self.getSelectionValues():
x = []
for d in p:... | Plot the selected data using pylab - if possible | Plot the selected data using pylab - if possible | [
"Plot",
"the",
"selected",
"data",
"using",
"pylab",
"-",
"if",
"possible"
] | def plot_Selected(self):
from PylabPlot import pylabPlotter
if not hasattr(self, 'pyplot'):
self.pyplot = pylabPlotter()
plotdata = []
for p in self.getSelectionValues():
x = []
for d in p:
try:
x.append(float(d))
... | [
"def",
"plot_Selected",
"(",
"self",
")",
":",
"from",
"PylabPlot",
"import",
"pylabPlotter",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'pyplot'",
")",
":",
"self",
".",
"pyplot",
"=",
"pylabPlotter",
"(",
")",
"plotdata",
"=",
"[",
"]",
"for",
"p",
"... | Plot the selected data using pylab - if possible | [
"Plot",
"the",
"selected",
"data",
"using",
"pylab",
"-",
"if",
"possible"
] | [
"\"\"\"Plot the selected data using pylab - if possible\"\"\"",
"#print pltlabels, plotdata"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | plotSetup | <not_specific> | def plotSetup(self):
"""Call pylab plot dialog setup, send data if we haven't already
plotted"""
from PylabPlot import pylabPlotter
if not hasattr(self, 'pyplot'):
self.pyplot = pylabPlotter()
plotdata = self.getSelectionValues()
if not self.pyplot.hasDat... | Call pylab plot dialog setup, send data if we haven't already
plotted | Call pylab plot dialog setup, send data if we haven't already
plotted | [
"Call",
"pylab",
"plot",
"dialog",
"setup",
"send",
"data",
"if",
"we",
"haven",
"'",
"t",
"already",
"plotted"
] | def plotSetup(self):
from PylabPlot import pylabPlotter
if not hasattr(self, 'pyplot'):
self.pyplot = pylabPlotter()
plotdata = self.getSelectionValues()
if not self.pyplot.hasData() and plotdata != None:
print 'has data'
plotdata = self.getSelectionVa... | [
"def",
"plotSetup",
"(",
"self",
")",
":",
"from",
"PylabPlot",
"import",
"pylabPlotter",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'pyplot'",
")",
":",
"self",
".",
"pyplot",
"=",
"pylabPlotter",
"(",
")",
"plotdata",
"=",
"self",
".",
"getSelectionValue... | Call pylab plot dialog setup, send data if we haven't already
plotted | [
"Call",
"pylab",
"plot",
"dialog",
"setup",
"send",
"data",
"if",
"we",
"haven",
"'",
"t",
"already",
"plotted"
] | [
"\"\"\"Call pylab plot dialog setup, send data if we haven't already\n plotted\"\"\""
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | draw_new_row | <not_specific> | def draw_new_row(self):
"""For performance reasons, we can just draw new rows at the end of
the table, without doing a redraw."""
return | For performance reasons, we can just draw new rows at the end of
the table, without doing a redraw. | For performance reasons, we can just draw new rows at the end of
the table, without doing a redraw. | [
"For",
"performance",
"reasons",
"we",
"can",
"just",
"draw",
"new",
"rows",
"at",
"the",
"end",
"of",
"the",
"table",
"without",
"doing",
"a",
"redraw",
"."
] | def draw_new_row(self):
return | [
"def",
"draw_new_row",
"(",
"self",
")",
":",
"return"
] | For performance reasons, we can just draw new rows at the end of
the table, without doing a redraw. | [
"For",
"performance",
"reasons",
"we",
"can",
"just",
"draw",
"new",
"rows",
"at",
"the",
"end",
"of",
"the",
"table",
"without",
"doing",
"a",
"redraw",
"."
] | [
"\"\"\"For performance reasons, we can just draw new rows at the end of\n the table, without doing a redraw.\"\"\""
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | draw_selected_rect | <not_specific> | def draw_selected_rect(self, row, col, color=None):
"""User has clicked to select a cell"""
if col >= self.cols:
return
self.delete('currentrect')
bg=self.selectedcolor
if color == None:
color = 'gray25'
w=3
x1,y1,x2,y2 = self.getCellCoords... | User has clicked to select a cell | User has clicked to select a cell | [
"User",
"has",
"clicked",
"to",
"select",
"a",
"cell"
] | def draw_selected_rect(self, row, col, color=None):
if col >= self.cols:
return
self.delete('currentrect')
bg=self.selectedcolor
if color == None:
color = 'gray25'
w=3
x1,y1,x2,y2 = self.getCellCoords(row,col)
rect = self.create_rectangle(x... | [
"def",
"draw_selected_rect",
"(",
"self",
",",
"row",
",",
"col",
",",
"color",
"=",
"None",
")",
":",
"if",
"col",
">=",
"self",
".",
"cols",
":",
"return",
"self",
".",
"delete",
"(",
"'currentrect'",
")",
"bg",
"=",
"self",
".",
"selectedcolor",
"... | User has clicked to select a cell | [
"User",
"has",
"clicked",
"to",
"select",
"a",
"cell"
] | [
"\"\"\"User has clicked to select a cell\"\"\"",
"#self.lower('currentrect')",
"#raise text above all"
] | [
{
"param": "self",
"type": null
},
{
"param": "row",
"type": null
},
{
"param": "col",
"type": null
},
{
"param": "color",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "row",
"type": null,
"docstring": null,
"docstring_tokens": []... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | draw_cellentry | <not_specific> | def draw_cellentry(self, row, col, text=None):
"""When the user single/double clicks on a text/number cell, bring up entry window"""
if self.editable == False:
return
absrow = self.get_AbsoluteRow(row)
h=self.rowheight
model=self.getModel()
cellvalue = self.m... | When the user single/double clicks on a text/number cell, bring up entry window | When the user single/double clicks on a text/number cell, bring up entry window | [
"When",
"the",
"user",
"single",
"/",
"double",
"clicks",
"on",
"a",
"text",
"/",
"number",
"cell",
"bring",
"up",
"entry",
"window"
] | def draw_cellentry(self, row, col, text=None):
if self.editable == False:
return
absrow = self.get_AbsoluteRow(row)
h=self.rowheight
model=self.getModel()
cellvalue = self.model.getCellRecord(absrow, col)
if Formula.isFormula(cellvalue):
return
... | [
"def",
"draw_cellentry",
"(",
"self",
",",
"row",
",",
"col",
",",
"text",
"=",
"None",
")",
":",
"if",
"self",
".",
"editable",
"==",
"False",
":",
"return",
"absrow",
"=",
"self",
".",
"get_AbsoluteRow",
"(",
"row",
")",
"h",
"=",
"self",
".",
"r... | When the user single/double clicks on a text/number cell, bring up entry window | [
"When",
"the",
"user",
"single",
"/",
"double",
"clicks",
"on",
"a",
"text",
"/",
"number",
"cell",
"bring",
"up",
"entry",
"window"
] | [
"\"\"\"When the user single/double clicks on a text/number cell, bring up entry window\"\"\"",
"#Draw an entry window",
"#do a dialog that gets the formula into a text area",
"#then they can click on the cells they want",
"#when done the user presses ok and its entered into the cell",
"#its all done here.... | [
{
"param": "self",
"type": null
},
{
"param": "row",
"type": null
},
{
"param": "col",
"type": null
},
{
"param": "text",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "row",
"type": null,
"docstring": null,
"docstring_tokens": []... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | check_data_entry | <not_specific> | def check_data_entry(self,event=None):
"""do validation checks on data entry in a widget"""
#if user enters commas, change to points
import re
value=event.widget.get()
if value!='':
try:
value=re.sub(',','.', value)
value=float(value)
... | do validation checks on data entry in a widget | do validation checks on data entry in a widget | [
"do",
"validation",
"checks",
"on",
"data",
"entry",
"in",
"a",
"widget"
] | def check_data_entry(self,event=None):
import re
value=event.widget.get()
if value!='':
try:
value=re.sub(',','.', value)
value=float(value)
except ValueError:
event.widget.configure(bg='red')
return 0
... | [
"def",
"check_data_entry",
"(",
"self",
",",
"event",
"=",
"None",
")",
":",
"import",
"re",
"value",
"=",
"event",
".",
"widget",
".",
"get",
"(",
")",
"if",
"value",
"!=",
"''",
":",
"try",
":",
"value",
"=",
"re",
".",
"sub",
"(",
"','",
",",
... | do validation checks on data entry in a widget | [
"do",
"validation",
"checks",
"on",
"data",
"entry",
"in",
"a",
"widget"
] | [
"\"\"\"do validation checks on data entry in a widget\"\"\"",
"#if user enters commas, change to points"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | draw_Text | <not_specific> | def draw_Text(self, row, col, celltxt, fgcolor=None, align=None):
"""Draw the text inside a cell area"""
self.delete('celltext'+str(col)+'_'+str(row))
h=self.rowheight
x1,y1,x2,y2 = self.getCellCoords(row,col)
w=x2-x1
wrap = False
# If celltxt is a number then we ... | Draw the text inside a cell area | Draw the text inside a cell area | [
"Draw",
"the",
"text",
"inside",
"a",
"cell",
"area"
] | def draw_Text(self, row, col, celltxt, fgcolor=None, align=None):
self.delete('celltext'+str(col)+'_'+str(row))
h=self.rowheight
x1,y1,x2,y2 = self.getCellCoords(row,col)
w=x2-x1
wrap = False
import types
if type(celltxt) is types.FloatType or type(celltxt) is typ... | [
"def",
"draw_Text",
"(",
"self",
",",
"row",
",",
"col",
",",
"celltxt",
",",
"fgcolor",
"=",
"None",
",",
"align",
"=",
"None",
")",
":",
"self",
".",
"delete",
"(",
"'celltext'",
"+",
"str",
"(",
"col",
")",
"+",
"'_'",
"+",
"str",
"(",
"row",
... | Draw the text inside a cell area | [
"Draw",
"the",
"text",
"inside",
"a",
"cell",
"area"
] | [
"\"\"\"Draw the text inside a cell area\"\"\"",
"# If celltxt is a number then we make it a string",
"#if cell width is less than x, print nothing",
"#if celltxt is dict then we are drawing a hyperlink ",
"#f,s = self.thefont.split(' ')",
"#just normal text "
] | [
{
"param": "self",
"type": null
},
{
"param": "row",
"type": null
},
{
"param": "col",
"type": null
},
{
"param": "celltxt",
"type": null
},
{
"param": "fgcolor",
"type": null
},
{
"param": "align",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "row",
"type": null,
"docstring": null,
"docstring_tokens": []... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | isLink | <not_specific> | def isLink(self, cell):
"""Checks if cell is a hyperlink, without using isinstance"""
try:
if cell.has_key('link'):
return True
except:
return False | Checks if cell is a hyperlink, without using isinstance | Checks if cell is a hyperlink, without using isinstance | [
"Checks",
"if",
"cell",
"is",
"a",
"hyperlink",
"without",
"using",
"isinstance"
] | def isLink(self, cell):
try:
if cell.has_key('link'):
return True
except:
return False | [
"def",
"isLink",
"(",
"self",
",",
"cell",
")",
":",
"try",
":",
"if",
"cell",
".",
"has_key",
"(",
"'link'",
")",
":",
"return",
"True",
"except",
":",
"return",
"False"
] | Checks if cell is a hyperlink, without using isinstance | [
"Checks",
"if",
"cell",
"is",
"a",
"hyperlink",
"without",
"using",
"isinstance"
] | [
"\"\"\"Checks if cell is a hyperlink, without using isinstance\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "cell",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "cell",
"type": null,
"docstring": null,
"docstring_tokens": [... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | drawSelectedRow | <not_specific> | def drawSelectedRow(self):
"""Draw the highlight rect for the currently selected row"""
self.delete('rowrect')
row=self.currentrow
x1,y1,x2,y2 = self.getCellCoords(row,0)
x2=self.tablewidth
rect = self.create_rectangle(x1,y1,x2,y2,
fill=s... | Draw the highlight rect for the currently selected row | Draw the highlight rect for the currently selected row | [
"Draw",
"the",
"highlight",
"rect",
"for",
"the",
"currently",
"selected",
"row"
] | def drawSelectedRow(self):
self.delete('rowrect')
row=self.currentrow
x1,y1,x2,y2 = self.getCellCoords(row,0)
x2=self.tablewidth
rect = self.create_rectangle(x1,y1,x2,y2,
fill=self.rowselectedcolor,
outline=self.... | [
"def",
"drawSelectedRow",
"(",
"self",
")",
":",
"self",
".",
"delete",
"(",
"'rowrect'",
")",
"row",
"=",
"self",
".",
"currentrow",
"x1",
",",
"y1",
",",
"x2",
",",
"y2",
"=",
"self",
".",
"getCellCoords",
"(",
"row",
",",
"0",
")",
"x2",
"=",
... | Draw the highlight rect for the currently selected row | [
"Draw",
"the",
"highlight",
"rect",
"for",
"the",
"currently",
"selected",
"row"
] | [
"\"\"\"Draw the highlight rect for the currently selected row\"\"\""
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | drawMultipleRows | <not_specific> | def drawMultipleRows(self, rowlist):
"""Draw more than one row selection"""
self.delete('multiplesel')
for r in rowlist:
if r > self.rows-1:
continue
x1,y1,x2,y2 = self.getCellCoords(r,0)
x2=self.tablewidth
rect = self.create_rectan... | Draw more than one row selection | Draw more than one row selection | [
"Draw",
"more",
"than",
"one",
"row",
"selection"
] | def drawMultipleRows(self, rowlist):
self.delete('multiplesel')
for r in rowlist:
if r > self.rows-1:
continue
x1,y1,x2,y2 = self.getCellCoords(r,0)
x2=self.tablewidth
rect = self.create_rectangle(x1,y1,x2,y2,
... | [
"def",
"drawMultipleRows",
"(",
"self",
",",
"rowlist",
")",
":",
"self",
".",
"delete",
"(",
"'multiplesel'",
")",
"for",
"r",
"in",
"rowlist",
":",
"if",
"r",
">",
"self",
".",
"rows",
"-",
"1",
":",
"continue",
"x1",
",",
"y1",
",",
"x2",
",",
... | Draw more than one row selection | [
"Draw",
"more",
"than",
"one",
"row",
"selection"
] | [
"\"\"\"Draw more than one row selection\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "rowlist",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "rowlist",
"type": null,
"docstring": null,
"docstring_tokens"... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | draw_tooltip | <not_specific> | def draw_tooltip(self, row, col):
"""Draw a tooltip showing contents of cell"""
absrow = self.get_AbsoluteRow(row)
x1,y1,x2,y2 = self.getCellCoords(row,col)
w=x2-x1
text = self.model.getValueAt(absrow,col)
if isinstance(text, dict):
if text.has_key('link'):
... | Draw a tooltip showing contents of cell | Draw a tooltip showing contents of cell | [
"Draw",
"a",
"tooltip",
"showing",
"contents",
"of",
"cell"
] | def draw_tooltip(self, row, col):
absrow = self.get_AbsoluteRow(row)
x1,y1,x2,y2 = self.getCellCoords(row,col)
w=x2-x1
text = self.model.getValueAt(absrow,col)
if isinstance(text, dict):
if text.has_key('link'):
text = text['link']
import types... | [
"def",
"draw_tooltip",
"(",
"self",
",",
"row",
",",
"col",
")",
":",
"absrow",
"=",
"self",
".",
"get_AbsoluteRow",
"(",
"row",
")",
"x1",
",",
"y1",
",",
"x2",
",",
"y2",
"=",
"self",
".",
"getCellCoords",
"(",
"row",
",",
"col",
")",
"w",
"=",... | Draw a tooltip showing contents of cell | [
"Draw",
"a",
"tooltip",
"showing",
"contents",
"of",
"cell"
] | [
"\"\"\"Draw a tooltip showing contents of cell\"\"\"",
"# If text is a number we make it a string"
] | [
{
"param": "self",
"type": null
},
{
"param": "row",
"type": null
},
{
"param": "col",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "row",
"type": null,
"docstring": null,
"docstring_tokens": []... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | loadPrefs | <not_specific> | def loadPrefs(self, prefs=None):
"""Load table specific prefs from the prefs instance used
if they are not present, create them."""
if prefs==None:
prefs=Preferences('Table',{'check_for_update':1})
self.prefs = prefs
defaultprefs = {'horizlines':self.horizlines, '... | Load table specific prefs from the prefs instance used
if they are not present, create them. | Load table specific prefs from the prefs instance used
if they are not present, create them. | [
"Load",
"table",
"specific",
"prefs",
"from",
"the",
"prefs",
"instance",
"used",
"if",
"they",
"are",
"not",
"present",
"create",
"them",
"."
] | def loadPrefs(self, prefs=None):
if prefs==None:
prefs=Preferences('Table',{'check_for_update':1})
self.prefs = prefs
defaultprefs = {'horizlines':self.horizlines, 'vertlines':self.vertlines,
'alternaterows':self.alternaterows,
'rowheig... | [
"def",
"loadPrefs",
"(",
"self",
",",
"prefs",
"=",
"None",
")",
":",
"if",
"prefs",
"==",
"None",
":",
"prefs",
"=",
"Preferences",
"(",
"'Table'",
",",
"{",
"'check_for_update'",
":",
"1",
"}",
")",
"self",
".",
"prefs",
"=",
"prefs",
"defaultprefs",... | Load table specific prefs from the prefs instance used
if they are not present, create them. | [
"Load",
"table",
"specific",
"prefs",
"from",
"the",
"prefs",
"instance",
"used",
"if",
"they",
"are",
"not",
"present",
"create",
"them",
"."
] | [
"\"\"\"Load table specific prefs from the prefs instance used\n if they are not present, create them.\"\"\"",
"#Create tkvars for dialog"
] | [
{
"param": "self",
"type": null
},
{
"param": "prefs",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "prefs",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | check_hyperlink | <not_specific> | def check_hyperlink(self,event=None):
"""Check if a hyperlink was clicked"""
row = self.get_row_clicked(event)
col = self.get_col_clicked(event)
absrow = self.get_AbsoluteRow(row)
recdata = self.model.getValueAt(absrow, col)
try:
link = recdata['link']
... | Check if a hyperlink was clicked | Check if a hyperlink was clicked | [
"Check",
"if",
"a",
"hyperlink",
"was",
"clicked"
] | def check_hyperlink(self,event=None):
row = self.get_row_clicked(event)
col = self.get_col_clicked(event)
absrow = self.get_AbsoluteRow(row)
recdata = self.model.getValueAt(absrow, col)
try:
link = recdata['link']
import webbrowser
webbrowser.o... | [
"def",
"check_hyperlink",
"(",
"self",
",",
"event",
"=",
"None",
")",
":",
"row",
"=",
"self",
".",
"get_row_clicked",
"(",
"event",
")",
"col",
"=",
"self",
".",
"get_col_clicked",
"(",
"event",
")",
"absrow",
"=",
"self",
".",
"get_AbsoluteRow",
"(",
... | Check if a hyperlink was clicked | [
"Check",
"if",
"a",
"hyperlink",
"was",
"clicked"
] | [
"\"\"\"Check if a hyperlink was clicked\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | exportTable | <not_specific> | def exportTable(self, filename=None):
"""Do a simple export of the cell contents to csv"""
from Tables_IO import TableExporter
exporter = TableExporter()
exporter.ExportTableData(self)
return | Do a simple export of the cell contents to csv | Do a simple export of the cell contents to csv | [
"Do",
"a",
"simple",
"export",
"of",
"the",
"cell",
"contents",
"to",
"csv"
] | def exportTable(self, filename=None):
from Tables_IO import TableExporter
exporter = TableExporter()
exporter.ExportTableData(self)
return | [
"def",
"exportTable",
"(",
"self",
",",
"filename",
"=",
"None",
")",
":",
"from",
"Tables_IO",
"import",
"TableExporter",
"exporter",
"=",
"TableExporter",
"(",
")",
"exporter",
".",
"ExportTableData",
"(",
"self",
")",
"return"
] | Do a simple export of the cell contents to csv | [
"Do",
"a",
"simple",
"export",
"of",
"the",
"cell",
"contents",
"to",
"csv"
] | [
"\"\"\"Do a simple export of the cell contents to csv\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "filename",
"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... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | checkOSType | <not_specific> | def checkOSType(cls):
"""Check the OS we are in"""
import os, string
ostyp=''
var_s=['OSTYPE','OS']
for var in var_s:
if os.environ.has_key(var):
ostyp=string.lower(os.environ[var])
ostyp=ostyp.lower()
if ostyp.find('windows')!=-1:
... | Check the OS we are in | Check the OS we are in | [
"Check",
"the",
"OS",
"we",
"are",
"in"
] | def checkOSType(cls):
import os, string
ostyp=''
var_s=['OSTYPE','OS']
for var in var_s:
if os.environ.has_key(var):
ostyp=string.lower(os.environ[var])
ostyp=ostyp.lower()
if ostyp.find('windows')!=-1:
ostyp='windows'
elif ... | [
"def",
"checkOSType",
"(",
"cls",
")",
":",
"import",
"os",
",",
"string",
"ostyp",
"=",
"''",
"var_s",
"=",
"[",
"'OSTYPE'",
",",
"'OS'",
"]",
"for",
"var",
"in",
"var_s",
":",
"if",
"os",
".",
"environ",
".",
"has_key",
"(",
"var",
")",
":",
"o... | Check the OS we are in | [
"Check",
"the",
"OS",
"we",
"are",
"in"
] | [
"\"\"\"Check the OS we are in\"\"\""
] | [
{
"param": "cls",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "cls",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | handle_left_click | <not_specific> | def handle_left_click(self,event):
"""Does cell selection when mouse is clicked on canvas"""
self.delete('rect')
self.table.delete('entry')
self.table.delete('multicellrect')
colclicked = self.table.get_col_clicked(event)
#set all rows selected
self.table.allrows ... | Does cell selection when mouse is clicked on canvas | Does cell selection when mouse is clicked on canvas | [
"Does",
"cell",
"selection",
"when",
"mouse",
"is",
"clicked",
"on",
"canvas"
] | def handle_left_click(self,event):
self.delete('rect')
self.table.delete('entry')
self.table.delete('multicellrect')
colclicked = self.table.get_col_clicked(event)
self.table.allrows = True
self.table.setSelectedCol(colclicked)
if self.atdivider == 1:
... | [
"def",
"handle_left_click",
"(",
"self",
",",
"event",
")",
":",
"self",
".",
"delete",
"(",
"'rect'",
")",
"self",
".",
"table",
".",
"delete",
"(",
"'entry'",
")",
"self",
".",
"table",
".",
"delete",
"(",
"'multicellrect'",
")",
"colclicked",
"=",
"... | Does cell selection when mouse is clicked on canvas | [
"Does",
"cell",
"selection",
"when",
"mouse",
"is",
"clicked",
"on",
"canvas"
] | [
"\"\"\"Does cell selection when mouse is clicked on canvas\"\"\"",
"#set all rows selected",
"#also draw a copy of the rect to be dragged",
"#finally, draw the selected col on the table"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | handle_left_release | <not_specific> | def handle_left_release(self,event):
"""When mouse released implement resize or col move"""
self.delete('dragrect')
if self.atdivider == 1:
#col = self.table.get_col_clicked(event)
x=int(self.canvasx(event.x))
col = self.table.currentcol
x1,y1,x2,y... | When mouse released implement resize or col move | When mouse released implement resize or col move | [
"When",
"mouse",
"released",
"implement",
"resize",
"or",
"col",
"move"
] | def handle_left_release(self,event):
self.delete('dragrect')
if self.atdivider == 1:
x=int(self.canvasx(event.x))
col = self.table.currentcol
x1,y1,x2,y2 = self.table.getCellCoords(0,col)
newwidth=x - x1
if newwidth < 5:
newwidt... | [
"def",
"handle_left_release",
"(",
"self",
",",
"event",
")",
":",
"self",
".",
"delete",
"(",
"'dragrect'",
")",
"if",
"self",
".",
"atdivider",
"==",
"1",
":",
"x",
"=",
"int",
"(",
"self",
".",
"canvasx",
"(",
"event",
".",
"x",
")",
")",
"col",... | When mouse released implement resize or col move | [
"When",
"mouse",
"released",
"implement",
"resize",
"or",
"col",
"move"
] | [
"\"\"\"When mouse released implement resize or col move\"\"\"",
"#col = self.table.get_col_clicked(event)",
"#move column"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | handle_left_shift_click | <not_specific> | def handle_left_shift_click(self, event):
"""Handle shift click, for selecting multiple cols"""
self.table.delete('colrect')
self.delete('rect')
currcol = self.table.currentcol
colclicked = self.table.get_col_clicked(event)
if colclicked > currcol:
self.table.... | Handle shift click, for selecting multiple cols | Handle shift click, for selecting multiple cols | [
"Handle",
"shift",
"click",
"for",
"selecting",
"multiple",
"cols"
] | def handle_left_shift_click(self, event):
self.table.delete('colrect')
self.delete('rect')
currcol = self.table.currentcol
colclicked = self.table.get_col_clicked(event)
if colclicked > currcol:
self.table.multiplecollist = range(currcol, colclicked+1)
elif co... | [
"def",
"handle_left_shift_click",
"(",
"self",
",",
"event",
")",
":",
"self",
".",
"table",
".",
"delete",
"(",
"'colrect'",
")",
"self",
".",
"delete",
"(",
"'rect'",
")",
"currcol",
"=",
"self",
".",
"table",
".",
"currentcol",
"colclicked",
"=",
"sel... | Handle shift click, for selecting multiple cols | [
"Handle",
"shift",
"click",
"for",
"selecting",
"multiple",
"cols"
] | [
"\"\"\"Handle shift click, for selecting multiple cols\"\"\"",
"#print self.table.multiplecollist"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | popupMenu | <not_specific> | def popupMenu(self, event):
"""Add left and right click behaviour for column header"""
colname = self.model.columnNames[self.table.currentcol]
collabel = self.model.columnlabels[colname]
popupmenu = Menu(self, tearoff = 0)
def popupFocusOut(event):
popupmenu.unpost()
... | Add left and right click behaviour for column header | Add left and right click behaviour for column header | [
"Add",
"left",
"and",
"right",
"click",
"behaviour",
"for",
"column",
"header"
] | def popupMenu(self, event):
colname = self.model.columnNames[self.table.currentcol]
collabel = self.model.columnlabels[colname]
popupmenu = Menu(self, tearoff = 0)
def popupFocusOut(event):
popupmenu.unpost()
popupmenu.add_command(label="Rename Column", command=self.r... | [
"def",
"popupMenu",
"(",
"self",
",",
"event",
")",
":",
"colname",
"=",
"self",
".",
"model",
".",
"columnNames",
"[",
"self",
".",
"table",
".",
"currentcol",
"]",
"collabel",
"=",
"self",
".",
"model",
".",
"columnlabels",
"[",
"colname",
"]",
"popu... | Add left and right click behaviour for column header | [
"Add",
"left",
"and",
"right",
"click",
"behaviour",
"for",
"column",
"header"
] | [
"\"\"\"Add left and right click behaviour for column header\"\"\"",
"#self.bind(\"<Button-3>\", popupFocusOut)"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | draw_rect | <not_specific> | def draw_rect(self,col, tag=None, color=None, outline=None, delete=1):
"""User has clicked to select a col"""
if tag==None:
tag='rect'
if color==None:
color='#0099CC'
if outline==None:
outline='gray25'
if delete == 1:
self.delete(ta... | User has clicked to select a col | User has clicked to select a col | [
"User",
"has",
"clicked",
"to",
"select",
"a",
"col"
] | def draw_rect(self,col, tag=None, color=None, outline=None, delete=1):
if tag==None:
tag='rect'
if color==None:
color='#0099CC'
if outline==None:
outline='gray25'
if delete == 1:
self.delete(tag)
w=2
x1,y1,x2,y2 = self.table... | [
"def",
"draw_rect",
"(",
"self",
",",
"col",
",",
"tag",
"=",
"None",
",",
"color",
"=",
"None",
",",
"outline",
"=",
"None",
",",
"delete",
"=",
"1",
")",
":",
"if",
"tag",
"==",
"None",
":",
"tag",
"=",
"'rect'",
"if",
"color",
"==",
"None",
... | User has clicked to select a col | [
"User",
"has",
"clicked",
"to",
"select",
"a",
"col"
] | [
"\"\"\"User has clicked to select a col\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "col",
"type": null
},
{
"param": "tag",
"type": null
},
{
"param": "color",
"type": null
},
{
"param": "outline",
"type": null
},
{
"param": "delete",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "col",
"type": null,
"docstring": null,
"docstring_tokens": []... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | handle_mouse_drag | <not_specific> | def handle_mouse_drag(self, event):
"""Handle mouse drag for mult row selection"""
rowover = self.table.get_row_clicked(event)
colover = self.table.get_col_clicked(event)
if colover == None or rowover == None:
return
if self.table.check_PageView(rowover) == 1:
... | Handle mouse drag for mult row selection | Handle mouse drag for mult row selection | [
"Handle",
"mouse",
"drag",
"for",
"mult",
"row",
"selection"
] | def handle_mouse_drag(self, event):
rowover = self.table.get_row_clicked(event)
colover = self.table.get_col_clicked(event)
if colover == None or rowover == None:
return
if self.table.check_PageView(rowover) == 1:
return | [
"def",
"handle_mouse_drag",
"(",
"self",
",",
"event",
")",
":",
"rowover",
"=",
"self",
".",
"table",
".",
"get_row_clicked",
"(",
"event",
")",
"colover",
"=",
"self",
".",
"table",
".",
"get_col_clicked",
"(",
"event",
")",
"if",
"colover",
"==",
"Non... | Handle mouse drag for mult row selection | [
"Handle",
"mouse",
"drag",
"for",
"mult",
"row",
"selection"
] | [
"\"\"\"Handle mouse drag for mult row selection\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | handle_mouse_drag | <not_specific> | def handle_mouse_drag(self, event):
"""Handle mouse moved with button held down, multiple selections"""
if hasattr(self, 'cellentry'):
self.cellentry.destroy()
rowover = self.table.get_row_clicked(event)
colover = self.table.get_col_clicked(event)
if rowover == None o... | Handle mouse moved with button held down, multiple selections | Handle mouse moved with button held down, multiple selections | [
"Handle",
"mouse",
"moved",
"with",
"button",
"held",
"down",
"multiple",
"selections"
] | def handle_mouse_drag(self, event):
if hasattr(self, 'cellentry'):
self.cellentry.destroy()
rowover = self.table.get_row_clicked(event)
colover = self.table.get_col_clicked(event)
if rowover == None or self.table.check_PageView(rowover) == 1:
return
if row... | [
"def",
"handle_mouse_drag",
"(",
"self",
",",
"event",
")",
":",
"if",
"hasattr",
"(",
"self",
",",
"'cellentry'",
")",
":",
"self",
".",
"cellentry",
".",
"destroy",
"(",
")",
"rowover",
"=",
"self",
".",
"table",
".",
"get_row_clicked",
"(",
"event",
... | Handle mouse moved with button held down, multiple selections | [
"Handle",
"mouse",
"moved",
"with",
"button",
"held",
"down",
"multiple",
"selections"
] | [
"\"\"\"Handle mouse moved with button held down, multiple selections\"\"\"",
"#draw the selected rows"
] | [
{
"param": "self",
"type": null
},
{
"param": "event",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "event",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | drawSelectedRows | <not_specific> | def drawSelectedRows(self, rows=None):
"""Draw selected rows, accepts a list or integer"""
self.delete('rect')
if type(rows) is not ListType:
rowlist=[]
rowlist.append(rows)
else:
rowlist = rows
for r in rowlist:
#print r
... | Draw selected rows, accepts a list or integer | Draw selected rows, accepts a list or integer | [
"Draw",
"selected",
"rows",
"accepts",
"a",
"list",
"or",
"integer"
] | def drawSelectedRows(self, rows=None):
self.delete('rect')
if type(rows) is not ListType:
rowlist=[]
rowlist.append(rows)
else:
rowlist = rows
for r in rowlist:
self.draw_rect(r, delete=0)
return | [
"def",
"drawSelectedRows",
"(",
"self",
",",
"rows",
"=",
"None",
")",
":",
"self",
".",
"delete",
"(",
"'rect'",
")",
"if",
"type",
"(",
"rows",
")",
"is",
"not",
"ListType",
":",
"rowlist",
"=",
"[",
"]",
"rowlist",
".",
"append",
"(",
"rows",
")... | Draw selected rows, accepts a list or integer | [
"Draw",
"selected",
"rows",
"accepts",
"a",
"list",
"or",
"integer"
] | [
"\"\"\"Draw selected rows, accepts a list or integer\"\"\"",
"#print r"
] | [
{
"param": "self",
"type": null
},
{
"param": "rows",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "rows",
"type": null,
"docstring": null,
"docstring_tokens": [... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | draw_rect | <not_specific> | def draw_rect(self, row=None, tag=None, color=None, outline=None, delete=1):
"""Draw a rect representing row selection"""
if tag==None:
tag='rect'
if color==None:
color='#0099CC'
if outline==None:
outline='gray25'
if delete == 1:
se... | Draw a rect representing row selection | Draw a rect representing row selection | [
"Draw",
"a",
"rect",
"representing",
"row",
"selection"
] | def draw_rect(self, row=None, tag=None, color=None, outline=None, delete=1):
if tag==None:
tag='rect'
if color==None:
color='#0099CC'
if outline==None:
outline='gray25'
if delete == 1:
self.delete(tag)
w=0
i = self.inset
... | [
"def",
"draw_rect",
"(",
"self",
",",
"row",
"=",
"None",
",",
"tag",
"=",
"None",
",",
"color",
"=",
"None",
",",
"outline",
"=",
"None",
",",
"delete",
"=",
"1",
")",
":",
"if",
"tag",
"==",
"None",
":",
"tag",
"=",
"'rect'",
"if",
"color",
"... | Draw a rect representing row selection | [
"Draw",
"a",
"rect",
"representing",
"row",
"selection"
] | [
"\"\"\"Draw a rect representing row selection\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "row",
"type": null
},
{
"param": "tag",
"type": null
},
{
"param": "color",
"type": null
},
{
"param": "outline",
"type": null
},
{
"param": "delete",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "row",
"type": null,
"docstring": null,
"docstring_tokens": []... |
9ae7aec184fde145b547d8a050083eb98c00afa1 | shambo001/peat | PEATDB/Tables.py | [
"MIT"
] | Python | body | <not_specific> | def body(self, master):
"""Show all record fields in entry fields or labels"""
model = self.model
cols = self.recdata.keys()
self.editable = []
self.fieldnames = {}
self.fieldvars = {}
self.fieldvars['Name'] = StringVar()
self.fieldvars['Name'].set... | Show all record fields in entry fields or labels | Show all record fields in entry fields or labels | [
"Show",
"all",
"record",
"fields",
"in",
"entry",
"fields",
"or",
"labels"
] | def body(self, master):
model = self.model
cols = self.recdata.keys()
self.editable = []
self.fieldnames = {}
self.fieldvars = {}
self.fieldvars['Name'] = StringVar()
self.fieldvars['Name'].set(self.recname)
Label(master, text='Rec Name:').grid(row... | [
"def",
"body",
"(",
"self",
",",
"master",
")",
":",
"model",
"=",
"self",
".",
"model",
"cols",
"=",
"self",
".",
"recdata",
".",
"keys",
"(",
")",
"self",
".",
"editable",
"=",
"[",
"]",
"self",
".",
"fieldnames",
"=",
"{",
"}",
"self",
".",
... | Show all record fields in entry fields or labels | [
"Show",
"all",
"record",
"fields",
"in",
"entry",
"fields",
"or",
"labels"
] | [
"\"\"\"Show all record fields in entry fields or labels\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "master",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "master",
"type": null,
"docstring": null,
"docstring_tokens":... |
011c5737cdb45b9106477a737995e2fd48e7a76d | shambo001/peat | Ghost/epsmap2.py | [
"MIT"
] | Python | fill_actsite | <not_specific> | def fill_actsite(self,depth,eps,mask):
"""Fill the active site to a specific depth with a dielectric value.
Change only epsvalues that are different than mask"""
bottom='A:0058:CD1'
top=['A:0112:NH1','A:0062:CH2','A:0047:OG1'] # midpoint is max dist from bottom
crds=[]
fo... | Fill the active site to a specific depth with a dielectric value.
Change only epsvalues that are different than mask | Fill the active site to a specific depth with a dielectric value.
Change only epsvalues that are different than mask | [
"Fill",
"the",
"active",
"site",
"to",
"a",
"specific",
"depth",
"with",
"a",
"dielectric",
"value",
".",
"Change",
"only",
"epsvalues",
"that",
"are",
"different",
"than",
"mask"
] | def fill_actsite(self,depth,eps,mask):
bottom='A:0058:CD1'
top=['A:0112:NH1','A:0062:CH2','A:0047:OG1']
crds=[]
for c in top:
crds.append(P.getcoords(c))
midpoint=sum(crds)/len(crds)
print 'Midpoint',midpoint
maxdist=midpoint-P.getcoords(bottom)
... | [
"def",
"fill_actsite",
"(",
"self",
",",
"depth",
",",
"eps",
",",
"mask",
")",
":",
"bottom",
"=",
"'A:0058:CD1'",
"top",
"=",
"[",
"'A:0112:NH1'",
",",
"'A:0062:CH2'",
",",
"'A:0047:OG1'",
"]",
"crds",
"=",
"[",
"]",
"for",
"c",
"in",
"top",
":",
"... | Fill the active site to a specific depth with a dielectric value. | [
"Fill",
"the",
"active",
"site",
"to",
"a",
"specific",
"depth",
"with",
"a",
"dielectric",
"value",
"."
] | [
"\"\"\"Fill the active site to a specific depth with a dielectric value.\n Change only epsvalues that are different than mask\"\"\"",
"# midpoint is max dist from bottom",
"#",
"# Loop over all cubes and see which are in between bottom and midpoint",
"#"
] | [
{
"param": "self",
"type": null
},
{
"param": "depth",
"type": null
},
{
"param": "eps",
"type": null
},
{
"param": "mask",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "depth",
"type": null,
"docstring": null,
"docstring_tokens": ... |
9ddc0f1dcb7b4aec9ce850807c4e5fa71dea695c | shambo001/peat | PEATDB/Ekin/LM_Fitter.py | [
"MIT"
] | Python | printResult | <not_specific> | def printResult(self):
"""Return the fit results for printing"""
res=self.getResult()
for v in res.keys():
result+= v +':'+ "%E" %fd[v] +' '
return result | Return the fit results for printing | Return the fit results for printing | [
"Return",
"the",
"fit",
"results",
"for",
"printing"
] | def printResult(self):
res=self.getResult()
for v in res.keys():
result+= v +':'+ "%E" %fd[v] +' '
return result | [
"def",
"printResult",
"(",
"self",
")",
":",
"res",
"=",
"self",
".",
"getResult",
"(",
")",
"for",
"v",
"in",
"res",
".",
"keys",
"(",
")",
":",
"result",
"+=",
"v",
"+",
"':'",
"+",
"\"%E\"",
"%",
"fd",
"[",
"v",
"]",
"+",
"' '",
"return",
... | Return the fit results for printing | [
"Return",
"the",
"fit",
"results",
"for",
"printing"
] | [
"\"\"\"Return the fit results for printing\"\"\""
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ddc0f1dcb7b4aec9ce850807c4e5fa71dea695c | shambo001/peat | PEATDB/Ekin/LM_Fitter.py | [
"MIT"
] | Python | AIC | <not_specific> | def AIC(self):
"""Computes the Akaike Information Criterion.
see http://adorio-research.org/wordpress/?p=1932
RSS-residual sum of squares of the fitting errors.
k - number of fitted parameters.
n - number of observations.
"""
RSS = self.g... | Computes the Akaike Information Criterion.
see http://adorio-research.org/wordpress/?p=1932
RSS-residual sum of squares of the fitting errors.
k - number of fitted parameters.
n - number of observations.
| Computes the Akaike Information Criterion.
RSS-residual sum of squares of the fitting errors.
k - number of fitted parameters.
n - number of observations. | [
"Computes",
"the",
"Akaike",
"Information",
"Criterion",
".",
"RSS",
"-",
"residual",
"sum",
"of",
"squares",
"of",
"the",
"fitting",
"errors",
".",
"k",
"-",
"number",
"of",
"fitted",
"parameters",
".",
"n",
"-",
"number",
"of",
"observations",
"."
] | def AIC(self):
RSS = self.getRMSE()
k = len(self.variables)
n = len(self.exp_data)
AIC = 2 * k + n * (log(2 * pi * RSS/n) + 1)
return AIC | [
"def",
"AIC",
"(",
"self",
")",
":",
"RSS",
"=",
"self",
".",
"getRMSE",
"(",
")",
"k",
"=",
"len",
"(",
"self",
".",
"variables",
")",
"n",
"=",
"len",
"(",
"self",
".",
"exp_data",
")",
"AIC",
"=",
"2",
"*",
"k",
"+",
"n",
"*",
"(",
"log"... | Computes the Akaike Information Criterion. | [
"Computes",
"the",
"Akaike",
"Information",
"Criterion",
"."
] | [
"\"\"\"Computes the Akaike Information Criterion.\n see http://adorio-research.org/wordpress/?p=1932\n \n RSS-residual sum of squares of the fitting errors.\n k - number of fitted parameters.\n n - number of observations.\n \"\"\""
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ddc0f1dcb7b4aec9ce850807c4e5fa71dea695c | shambo001/peat | PEATDB/Ekin/LM_Fitter.py | [
"MIT"
] | Python | fit | <not_specific> | def fit(self, rounds=500, error_crit=0.00005, gradient_crit = 1e-6, step=1E-8,
LM_damper = 0.00001, damper_adjustment_factor = 2.0, silent=False):
"""Do 500 rounds of fitting, or until converged"""
if silent == False:
print 'Fitting..'
print 'start vars:', self.va... | Do 500 rounds of fitting, or until converged | Do 500 rounds of fitting, or until converged | [
"Do",
"500",
"rounds",
"of",
"fitting",
"or",
"until",
"converged"
] | def fit(self, rounds=500, error_crit=0.00005, gradient_crit = 1e-6, step=1E-8,
LM_damper = 0.00001, damper_adjustment_factor = 2.0, silent=False):
if silent == False:
print 'Fitting..'
print 'start vars:', self.variables
self.step=step
self.LM_damper = LM_... | [
"def",
"fit",
"(",
"self",
",",
"rounds",
"=",
"500",
",",
"error_crit",
"=",
"0.00005",
",",
"gradient_crit",
"=",
"1e-6",
",",
"step",
"=",
"1E-8",
",",
"LM_damper",
"=",
"0.00001",
",",
"damper_adjustment_factor",
"=",
"2.0",
",",
"silent",
"=",
"Fals... | Do 500 rounds of fitting, or until converged | [
"Do",
"500",
"rounds",
"of",
"fitting",
"or",
"until",
"converged"
] | [
"\"\"\"Do 500 rounds of fitting, or until converged\"\"\"",
"# Set damper",
"# Try to set error_crit using exp_data range",
"#get y vals",
"# Start iterating",
"#print 'Step Diff LM_damper'",
"# check for singluar matrix",
"# Check convergence",
"#print '%5d %6.4f %6.4e' %(x, now_diff, self.L... | [
{
"param": "self",
"type": null
},
{
"param": "rounds",
"type": null
},
{
"param": "error_crit",
"type": null
},
{
"param": "gradient_crit",
"type": null
},
{
"param": "step",
"type": null
},
{
"param": "LM_damper",
"type": null
},
{
"param... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "rounds",
"type": null,
"docstring": null,
"docstring_tokens":... |
37d101d22d8d7711d7cfecd17a1971b5b46cccb5 | shambo001/peat | PEATSA/WebApp/RemoteLaunch.py | [
"MIT"
] | Python | main | null | def main(parser, options, job):
'''Launches the job on a remote cluster'''
#Get information for running the job remotely
identityFile = options.get('CLUSTER', 'identityFile')
user = options.get('CLUSTER', 'user')
host = options.get('CLUSTER', 'host')
webServerDirectory = options.get('WEB APPLICATION', 'webSer... | Launches the job on a remote cluster | Launches the job on a remote cluster | [
"Launches",
"the",
"job",
"on",
"a",
"remote",
"cluster"
] | def main(parser, options, job):
identityFile = options.get('CLUSTER', 'identityFile')
user = options.get('CLUSTER', 'user')
host = options.get('CLUSTER', 'host')
webServerDirectory = options.get('WEB APPLICATION', 'webServerDirectory')
outputDirectory = parser.outputDirectory()
pbsScript = PEATSAParallel.PBSScr... | [
"def",
"main",
"(",
"parser",
",",
"options",
",",
"job",
")",
":",
"identityFile",
"=",
"options",
".",
"get",
"(",
"'CLUSTER'",
",",
"'identityFile'",
")",
"user",
"=",
"options",
".",
"get",
"(",
"'CLUSTER'",
",",
"'user'",
")",
"host",
"=",
"option... | Launches the job on a remote cluster | [
"Launches",
"the",
"job",
"on",
"a",
"remote",
"cluster"
] | [
"'''Launches the job on a remote cluster'''",
"#Get information for running the job remotely",
"#Create PBS file",
"#Write the PBS file to the web server directory for the job\t",
"#Create the output directory for the job on the remote machine",
"#Copy the PBS script to the run dir",
"#Copy the pdb file... | [
{
"param": "parser",
"type": null
},
{
"param": "options",
"type": null
},
{
"param": "job",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "parser",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "options",
"type": null,
"docstring": null,
"docstring_token... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.