def parseToReport( self, fileName, keyTag, header = None, unique = True):
'''
@var fileName: name of flat (delimited) in text format to be parsed
@type fileName: String
@var keyTag: ID of column to be used for report key row
@type keyTag: String
@summary:
Primary Function
Parses flat file returns report object.
'''
if header != None:
self.setHeader(header)
result = Report()
self.startFile(fileName)
d = self.getTagedLine()
while d != None:
if d != "":
keyName = d[keyTag]
del d[keyTag]
for valueTag in d.keys():
v = d[valueTag]
result.addElement(keyName,valueTag,v)
d = self.getTagedLine()
self.closeFile()
return result
def analyseRecombindationResults(self,oligoReport,featureList,outputFile="oligo_recomb_analysis.txt"):
result = Report()
result.extend(oligoReport)
rowNames = oligoReport.returnRowNames()
recordAlignment = SeqRecord(Seq(""))
recordAlignment.features = featureList
for rName in rowNames:
output.write(rName + "\n")
start = float(oligoReport["genomic_start"][rName])
end = float(oligoReport["genomic_end"][rName])
oligo = oligoReport["best"][rName]
keyString = "\n(%s,%s) %s\n\n" % (start,end,oligo)
output.write(keyString)
subFeatures = self._selectFeatures(featureList,start,end)
index = 0
for feature in subFeatures:
matchName = "match_" + str(index)
id = feature.id
qValue = feature.qualifiers["query"]
sValue = feature.qualifiers["subject"]
matchString = feature.qualifiers["alignment"]
output.write(id + "\n")
output.write(matchString + "\n\n")
result.add(rName,matchName,qValue)
index += 1
output.close()
return result
def controlMapReport(self,controlMap):
'''
convert control map to report object
'''
report = Report()
for (key,coeffMap) in controlMap.items():
colName = str(key)
report.addColumnHash(colName, coeffMap)
return report
def writeSensitivityLibraryReport(self, senseLibrary, fileName, report=None):
if report == None:
report = Report()
for (libraryName,lib) in senseLibrary.items():
report.addColumnHash(libraryName, lib)
writer = ReportWriter()
writer.setFile(fileName)
code = writer.write(report)
writer.closeFile()
return code
def geneControlReport(self,model,controlMap,outputName):
report = Report()
geneMap = model.controlMap
for (target,controls) in geneMap.keys():
for control in controls:
report.add(target,control,"control")
writer = ReportWriter()
writer.setFile(outputName)
writer.write(report)
writer.closeFile()
return None
def parseGenericReport(self, fileName, keyTag=None, header = None, unique = True):
'''
@var fileName: name of flat (delimited) in text format to be parsed
@type fileName: String
@var keyTag: ID of column to be used for report key row
@type keyTag: String
@summary:
Primary Function
Parses flat file returns report object.
'''
result = Report()
kIndex = None
lines = open( fileName, 'r' )
index = 0
for line in lines:
if self.isComment( line ):
pass
elif self.endLine < index < self.startLine:
index += 1
continue
elif index == self.headerLine:
header = self.parseHeader( line, unique )
if keyTag in header:
kIndex = header.index(keyTag)
elif self.endLine > index > self.startLine:
line = line.replace('\n','')
sLine =self._safeSplit(line)
if kIndex != None:
rName = sLine[kIndex]
else:
rName = str(index)
for i in range(len(sLine)):
if i != kIndex:
cName = header[i]
value = sLine[i]
result.add(rName,cName,value)
index += 1
lines.close()
return result
def getReport(self):
report = Report()
fluxModel = self
reactionNames = fluxModel.network.getOrderedReactionNames()
reactionMap = fluxModel.network.getReactionMap()
for reactionName in reactionNames:
reaction = reactionMap[reactionName]
equation = reaction.getEquation()
pathway = reaction.getAnnotation("Subsystem")
name = reaction.getName()#Currently sensitivity values can be too large for control factors.
report.addElement(reactionName,"name",name)
report.addElement(reactionName,"equation", equation)
report.addElement(reactionName,"Subsystem", pathway)
return report
def enzymeBoundaryControl(model,targets,bounds,objectiveName,productionName,searchSize):
targets = bounds.keys()
controlNames = model.getControlsForNames(targets)
eControlMap = model.getEnzymeControlMap()
controlSubSets = combinations(controlNames,searchSize)
xcontrolSubSets = set(controlSubSets)
result = Report()
iter = 0
for icontrolNames in xcontrolSubSets:
ibounds = {}
controlTag = ''
ienzymeNames = model.annotateGeneList(list(icontrolNames))
ienzymeNames.sort()
for ieName in ienzymeNames:
controlTag += "(%s)" % (ieName)
for icontrolName in icontrolNames:
itargets = eControlMap[icontrolName]
for itarget in itargets:
if itarget in bounds.keys():
ibound = bounds[itarget]
ibounds[itarget] = ibound
#print ("control %s => [%s]") % (icontrolName,ibounds)
pass
if len(ibounds) == 0:
continue
(fluxMap,oflux,pflux) = findBoundaryProduction(model, ibounds, None, objectiveName, productionName)
print "[%s] objective %s => production %s" % (controlTag, oflux, pflux)
iter += 1
#iEnzymeNames = model.annotateGeneList(icontrolNames)
#for icontrolName in iEnzymeNames:
# result.add(iter, icontrolName, "active")
result.add(controlTag,"natural",oflux)
result.add(controlTag,"production",pflux)
return result
def main_function():
parser = OptionParser()
parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="set verbose mode")
parser.add_option("-c","--config", dest="config", default="redirector.config", help="master configuration file", metavar="FILE")
parser.add_option("--model_config", dest="modelConfig", default="model.config", help="configuration file", metavar="FILE")
parser.add_option("-n","--configNames", type = "string", dest = "configNames", default = "Default", help = "comma separated list of configuration settings to include", metavar="FILE")
parser.add_option("-m","--modelname", type = "string", dest="modelName", default="", help="name of model from configuration file", metavar="String")
parser.add_option("-b","--bioObjective", type = "string", dest="bioObj", default = 'Biomass', help="name of biological objective reaction", metavar="String")
parser.add_option("-s","--synthObjective", type = "string", dest="synthObj", default='', help="name of synthetic objective reaction", metavar="String")
parser.add_option("--sn", "--searchNeighborhood", dest = "searchNeighborhood", default = 1, type = int, help = "size of search neighborhood", metavar = "int")
parser.add_option("--iter", "--searchIterations", dest = "iterations", default = 1, type = int, help = "maximum number of iterations, if blank no max", metavar = "int")
parser.add_option("--report", action = "store_true", dest = "isReport", default = False, help = "Write report", metavar = "boolean")
parser.add_option("--pl","--preload", dest = "preload", default = 0, type = int, help = "indicate size of pre-made library to load for faster start", metavar="int")
parser.add_option("--ps", "--preStart", dest = "preStart", default = 0, type = int, help = "start from previous iteration state", metavar = "int")
parser.add_option("--gm", "--GeneMap", action="store_true", dest = "useGeneMap", default = False, help = "Use Gene Map")
parser.add_option("--control", dest="control", default = "flat", help = "control library type, flat,binary,sense", metavar="String")
parser.add_option("--simocontrol", dest="simoControl", default = 1.0, help = "number of simultaneously active controls", metavar="int")
parser.add_option("--section", dest="subSections", default = '', help = "Comma separated list of sections of the model files to use", metavar="String")
parser.add_option("-o", dest="resultDirectory", default = './Result', help = "Directory to store analysis results", metavar="String")
# Parse options
(options,args) = parser.parse_args()
config = ReflectionConfig()
config.readfp(open("Redirector.config"))
'''
0. configure analysis
'''
configNames = options.configNames.split(",")
configNames.insert(0,"Redirector Model")
for name in configNames:
config.merge(name,"Redirector",append=True)
#----------------------------------------
# reflect options from configuration
#----------------------------------------
config.reflect("Redirector",options)
config.load("Redirector", options.__dict__,override=False)
#-----------------------------------------
# Check and Build Storage Directories
#-----------------------------------------
dataDirectory = config.getValue("Redirector","dataDirectory",classType=''.__class__)
libraryDirectory = config.getValue("Redirector","libraryDirectory",classType=''.__class__)
resultsDirectory = config.getValue("Redirector","resultDirectory",classType=''.__class__)
analysisDirectory = config.getValue("Redirector","analysisDirectory",classType=''.__class__)
if not os.path.exists(dataDirectory):
raise IOError("unable to find required data directory" % dataDirectory)
if not os.path.exists(resultsDirectory):
os.makedirs(resultsDirectory)
if not os.path.exists(libraryDirectory):
os.makedirs(libraryDirectory)
if not os.path.exists(analysisDirectory):
os.makedirs(analysisDirectory)
#----------------------------
# Parse Inputs
#----------------------------
verbose = config.get("Redirector","verbose")
modelName = config.get("Redirector","modelName")
objectiveName = config.get("Redirector","bioObj")
syntheticObjectiveName = config.get("Redirector","synthObj")
searchSize = config.get("Redirector","searchNeighborhood")
searchIter = config.get("Redirector","iterations")
objectiveMinPercent = float(config.get("Redirector","bioTarget"))
usePrimeBounds = config.get("Redirector","primeBounds") == "True"
#----------------------------------------------------
# Initialize and set values for tools and factories
#----------------------------------------------------
naturalObjective = {objectiveName:-1.0}
syntheticObjective = {syntheticObjectiveName:-1.0}
protectedTargets = set(naturalObjective.keys()).union(syntheticObjective.keys())
if verbose: print "Redirector Version 1.0"
if verbose: print "Model names: [%s]" % (modelName)
if verbose: print "Synthetic objective: [%s]" % (syntheticObjectiveName)
if verbose: print "Parsing data files for [%s]" % (modelName)
if verbose: print "Search Size [%s] Iterations [%s]" % (searchSize,searchIter)
'''
I. Parse data files and configuration settings
'''
if verbose: print "----------------Loading Metabolic Models---------------"
modelNames = modelName.split(",")
modelFactory = ModelFactory()
config.reflect("Redirector",modelFactory)
modelFactory.protectedTargets = protectedTargets
(fluxModel,modelMatrix) = modelFactory.loadModel(modelNames)
if verbose: print "Removing objectives from target set"
targets = modelMatrix.targets
targets = set(targets).difference(protectedTargets)
if verbose: print "Targets List Size [%s]" % len(targets)
simControl = options.simoControl
if verbose: print "Simultaneous Control %s" % simControl
#-------------------------------------------------------------------
# Pre-discovery of flux bound current not used due to instability
#-------------------------------------------------------------------
primeFluxBoundaries = {}
boundarySearchSize = 1
boundaryTargets = targets
boundaryReportFileName = "rd_flux_boundary_M_%s_t_%s_p_%s_s_%s_analysis.csv" % (modelName,len(targets),objectiveMinPercent,boundarySearchSize)
fluxBoundariesFile = "ControlLibraries/FluxBounds_M_%s_O_%s_T_%s_S_%s" % (modelName,objectiveName,objectiveMinPercent,syntheticObjectiveName)
naturalFluxBounds = None
if usePrimeBounds:
print "finding natural flux bounds [%s]" % (usePrimeBounds)
#return False
naturalFluxBounds = LinearModelVariableBoundarys(modelMatrix, objectiveName=objectiveName, targets=boundaryTargets, pickleFileName = fluxBoundariesFile, minObjectivePercent=objectiveMinPercent,searchSize=boundarySearchSize)
print "finding production flux bounds"
#syntheticFluxBounds = LinearModelVariableBoundarys(modelMatrix, objectiveName=syntheticObjectiveName, targets=boundaryTargets, pickleFileName = fluxBoundariesFile, minObjectivePercent=objectiveMinPercent,searchSize=boundarySearchSize)
if verbose: print "Prime flux boundaries found."
boundaryReport = Report()
boundaryReport.addColumnHash(objectiveName, naturalFluxBounds)
#boundaryReport.addColumnHash(syntheticObjectiveName, syntheticFluxBounds)
writer = ReportWriter()
writer.setFile(boundaryReportFileName)
writer.write(boundaryReport)
writer.closeFile()
'''
II. Generate Control Library(ies)
'''
if verbose: print "===============Setting up control libraries================="
processLibrary = OptimizationControlFactory()
config.reflect("Redirector",processLibrary)
processLibrary.geneMap = modelMatrix.controlMap
processLibrary.fluxBounds = primeFluxBoundaries
processLibrary.naturalObjectiveName = objectiveName
processLibrary.syntheticObjectiveName = syntheticObjectiveName
controlLibraries = []
controlMap = {}
controlTags = options.control.split(",")
if "sense" in controlTags:
print "====>Using sensitivity control library"
(icontrolLibraries, controlMap) = processLibrary.generateControl(modelMatrix,targets,targetsOnly = False)
icontrolLibraries = processLibrary._filterControl(icontrolLibraries, targets)
controlLibraries.extend(icontrolLibraries)
if "flat" in controlTags:
print "====>Using flat control library"
(icontrolLibraries) = processLibrary.seedTestLibrary(targets, randomize=False)
controlLibraries.extend(icontrolLibraries)
if "random" in controlTags:
print "====>Using random control library"
(icontrolLibraries) = processLibrary.seedTestLibrary(targets, randomize=True, factor = 2.0)
controlLibraries.extend(icontrolLibraries)
if "binary" in controlTags:
print "====>Using binary control library"
binaryRange =[-3,-2,-1,0]
icontrolLibraries = processLibrary.generateBinaryControl(targets,binaryRange)
controlLibraries.extend(icontrolLibraries)
controlReportName = "ControlLibraries/ControlReport_%s_%s_%s_%s.csv" % (options.configNames,objectiveName,syntheticObjectiveName,len(targets))
processLibrary.controlReport(modelMatrix, controlLibraries, controlMap, targets, controlReportName)
print "============Control Constructed============="
#--------------------------------------------------
#configure Redirector model construction object
#--------------------------------------------------
if verbose: print "==Formulating Framework=="
con = ConstructRegulationOptimization()
config.reflect("Redirector",con)
con.controlMax = options.searchNeighborhood
con.newObjective = syntheticObjectiveName
#----------------------------------------
# Initialize redirector analysis object
#----------------------------------------
if verbose: print "==Running Optimization=="
redirector = OptimizationControlRedirector()
config.reflect("Redirector",redirector)
redirector.modelFactory = modelFactory
redirector.con = con
redirector.controlFactory = processLibrary
redirector.controlLibraries = controlLibraries
redirector.primeBounds = naturalFluxBounds
#redirector.targets = targets
redirector.rGeneMap = modelMatrix.controlMap
#redirector.modelName = modelName
redirector.naturalObjectiveName = objectiveName
redirector.syntheticObjectiveName = syntheticObjectiveName
#--------------------------------------------------------
# Debugging option which tests addition / removal of
# reactions from the objective
#--------------------------------------------------------
if "toggle0" in options.control.split(","):
if verbose: print "-----------control test toggle 0-------------------"
redirector.testDesignOptimization(modelMatrix)
if "toggle" in options.control.split(","):
if verbose: print "-----------control test toggle all-------------------"
redirector.testDesignOptimization(modelMatrix,fullTest=True)
(ltReport,oPredVal,sPredVal,finalCheckValue,fObjective) = redirector.optimizeControl(modelMatrix)
finalPredictionValue = ltReport["flux"]
if verbose: print "Final Production: %s" % (finalPredictionValue[syntheticObjectiveName])
#-----------------------------
# Write Report
#----------------------------
if options.isReport:
try:
print "Writing Full Model Report in %s" % (options.resultDirectory)
redirector.writeReport(ltReport,fluxModel,oPredVal,sPredVal,searchSize,searchIter,fObjective,resultsDirectory)
except Exception, e:
print "Unable to write report: %s" % (e)
try:
targetReportName = "Target_Report_M_%s_N_%s_S_%s_K_%s_I_%s.txt" % (modelName,objectiveName,syntheticObjectiveName,options.searchNeighborhood,options.iterations)
print "Writing Optimization target Report %s" % (targetReportName)
iteration = options.preStart + options.iterations
redirector.writeAnnotatedTargets(fObjective, modelMatrix, annotationName = "bnumber", regex="[a-zA-Z0-9\(\)]+", iteration = iteration, oPrediction = oPredVal, nPrediction = finalPredictionValue)
except:
print "failed to write %s" % (targetReportName)
def controlReport(self,model,controlLibraries,controlMap,targets,outputName):
report = Report()
controlMapList = {}
if self.geneMap:
report.addColumnHash("geneticControl",model.controlMap)
for (name, prefix, coeffMap) in controlLibraries:
report.addColumnHash(name,coeffMap)
for (target,value) in coeffMap.items():
if target not in controlMapList.keys():
controlMapList[target] = {}
if value not in controlMapList[target].keys():
controlMapList[target][value] = []
controlMapList[target][value].append(name)
rControlMap = {}
tags = controlMap.keys()
tags.sort()
for tag in tags:
valueSetMap = controlMap[tag]
report.addColumnHash(tag,valueSetMap)
for (k,valueSet) in valueSetMap.items():
if k not in rControlMap.keys():
rControlMap[k] = {}
rValueMap = rControlMap[k]
for v in valueSet:
if v not in rValueMap.keys():
rValueMap[v] = []
rValueMap[v].append(tag)
rControlMap[k] = rValueMap
iControlMapList = {}
for (key,data) in controlMapList.items():
if data != None:
list = data.keys()
l = reduceVector(list)
iControlMapList[key] = l
targetNameMap = {}
for target in targets:
targetNameMap[target] = "Target"
report.addColumnHash("control target", targetNameMap)
report.addColumnHash("complete list of control Library", controlMapList)
report.addColumnHash("control Reduced", iControlMapList)
report.addColumnHash("complete control discovered", rControlMap)
writer = ReportWriter()
writer.setFile(outputName)
writer.write(report)
writer.closeFile()
return None
def modelReport(self,dir=1,prediction=None):
report = Report()
delta = 1e-6
for rowName in self.getRowNames():
rLimit = self.floatLimit(self.getRowLimit(rowName))
rValues =self.getRowValueMap(rowName)
rString = self._reportRow(rValues,rLimit,prediction)
report.addElement(rowName,"Type","row")
report.addElement(rowName,"Equation",rString)
rLimitS = "(%s,%s)" % (rLimit[0],rLimit[1])
report.addElement(rowName,"Limit",rLimitS)
if prediction != None:
rValue = self._vectorValue(rValues, prediction)
rValue = round(rValue,6)
rValid = rLimit[0]-delta < rValue < rLimit[1] + delta
report.addElement(rowName,"Value",rValue)
report.addElement(rowName,"Valid",rValid)
for colName in self.getColumnNames():
cLimit = self.floatLimit(self.getColumnLimit(colName))
cValues =self.getColumnValueMap(colName)
cString = self._reportRow(cValues,cLimit,prediction)
report.addElement(colName,"Type","column")
report.addElement(colName,"Equation",cString)
if prediction != None:
if colName in prediction.keys():
cValue = prediction[colName]
cValid = cLimit[0]-delta < cValue < cLimit[1] + delta
report.addElement(colName,"Value",cValue)
report.addElement(colName,"Valid",cValid)
return report
def parseAlignments(self,records,featureLocations):
result = Report()
index = 0
logFile = open("oligoLog.txt","w")
targetMap = {}
for r in records:
id = r.id
features = featureLocations[index]
hits = len(features)
genomicStart = features[0].location.start.position
genomicEnd = features[0].location.end.position
genomicStrand = features[0].strand
laggingComplementStrand = self.strandChooser(features[0])
if "alignment" in features[0].qualifiers.keys():
aMatch = features[0].qualifiers["alignment"]
else:
aMatch = ''
targetMap[id] = (genomicStart + genomicEnd)/2
logFile.write(id+"\n")
logFile.write(aMatch+"\n")
#if self.verbose: print aMatch
s = str(r.seq)
originalString = s
result.add(id,"original", originalString)
result.add(id,"hits", hits)
result.add(id,"genomic_start", genomicStart)
result.add(id,"genomic_end", genomicEnd)
result.add(id,"genomic_strand", genomicStrand)
result.add(id,"match", aMatch)
return result
def getControlReport(self,genes,targetRecord,sequence,boundary=0,range=1000):
'''
Create report of control regions for listed genes
'''
result = Report()
seqProp = RecombinationOligoFactory()
sdata = str(sequence).lower()
promoters = {}
locations = {}
arrow= ["<-","-","->"]
if self.verbose: print "finding local features"
localFeatures = self.localFeatures(genes,targetRecord,range=range)
if self.verbose: print "features found, creating report"
for feature in genes:
name = feature.qualifiers["gene"][0]
locTag = feature.qualifiers["locus_tag"][0]
start = feature.location.start.position
end = feature.location.end.position
strand = feature.strand
result.add(name,"locus_tag",locTag)
result.add(name,"gene_start",start)
result.add(name,"gene_end",end)
result.add(name,"gene_strand",strand)
if strand == 1:
loc = start
if strand == -1:
loc = end
rbsSeq = self.getSequenceRegion(sdata, loc, 3, boundary, strand)
oligoStrandRbs = seqProp.strandChooser(feature)
result.add(name,"rbs_start",loc)
result.add(name,"rbs_region",rbsSeq)
result.add(name,"rbs_Oligo_Strand",str(oligoStrandRbs))
iLocalFeatures = localFeatures[name]
count = 0
for tFeature in iLocalFeatures:
count = count + 1
tName = tFeature.qualifiers["gene"][0]
tStart = tFeature.location.start.position
tEnd = tFeature.location.end.position
tStrand = tFeature.strand
oligoStrand = seqProp.strandChooser(tFeature)
iArrow = arrow[tStrand + 1]
if tStrand == strand:
tSize = -1*tStrand
pSeq = self.getSequenceRegion(sdata, tStart, tSize, boundary, strand)
tag = "%s:[%s %s %s] t[%s] = %s" % (tName,tStart,iArrow,tEnd,oligoStrand,pSeq)
colName = "promoter_%s" % (count)
result.add(name,colName,tag)
return result
def findPrimers(self,seq,targetMap,boundary,oligoSize,searchSize,targetTm):
'''
@input targetMap: a list of genomic locations with sequence names
find a list of sequencing primers for a list of target locations
usage:
set boundary and oligo size
read in report, list of locations
run find sequence primers.
write report of result
'''
result = Report()
for k in targetMap.keys():
targetLocation = targetMap[k]
upLocation = targetLocation - boundary
upStart = targetLocation - boundary - searchSize - oligoSize
upEnd = targetLocation - boundary + searchSize
upSeq = seq[upStart:upEnd]
downLocation = targetLocation + boundary
downStart = targetLocation + boundary - searchSize
downEnd = targetLocation + boundary + searchSize + oligoSize
downSeq = seq[downStart:downEnd]
downSeq = downSeq.reverse_complement()
start = searchSize
(uTm,uAdjust,oUpSeq) = self.scanOligoTm(upSeq,start,oligoSize,searchSize,targetTm)
(dTm,dAdjust,oDownSeq) = self.scanOligoTm(downSeq,start,oligoSize,searchSize,targetTm)
dAdjust = -dAdjust
ucLocation = upLocation + uAdjust
dcLocation = downLocation + dAdjust
result.add(k,"sequencing location",targetLocation)
result.add(k,"foward primer",oUpSeq)
result.add(k,"foward adjust",uAdjust)
result.add(k,"foward location",ucLocation)
result.add(k,"foward TM",uTm)
result.add(k,"reverse primer",oDownSeq)
result.add(k,"reverse adjust",dAdjust)
result.add(k,"reverse location",dcLocation + dAdjust)
result.add(k,"reverse TM",dTm)
return result
def generateTargetingOligos(self, records, featureLocations, tagRE, boundary, searchSize, cutOff):
'''
Generate a list of oligos for recombination in target locations
and return report with the targets and sequencing oligos
All oligos printed 5' -> 3'
Control upstream will be to the left if strands are preserved and to the right
if strands are switched when matching lagging complement
oligos are selected discovered as an optimized subsection of the presented sequences
@records: sequences from which to select oligos
@featureLocations: a list of locations that place the features in a genome
@tagRE: regular expression for finding taged sequence with in feature sequences.
@bounary: oligo flanking region size
@searchSize: distance in base pairs to search for optimal oligo
@cutOff: limit of viable fold change energy for chose oligos.
'''
result = Report()
index = 0
logFile = open("oligoLog.txt","w")
targetMap = {}
sRegions = []
for r in records:
id = r.id
features = featureLocations[index]
hits = len(features)
genomicStart = features[0].location.start.position
genomicEnd = features[0].location.end.position
genomicStrand = features[0].strand
laggingComplementStrand = self.strandChooser(features[0])
if "alignment" in features[0].qualifiers.keys():
aMatch = features[0].qualifiers["alignment"]
else:
aMatch = ''
targetMap[id] = (genomicStart + genomicEnd)/2
logFile.write(id+"\n")
logFile.write(aMatch+"\n")
#if self.verbose: print aMatch
s = str(r.seq)
originalString = s
#Find larget section using special targeting tag
matchTag = re.search(tagRE,s)
if matchTag == None:
tagLoc = len(s)/2
else:
targetTag = matchTag.group(0)
tagLoc = s.index(targetTag) + len(targetTag)/2
if self.verbose: print "Target [%s] location [%s]" % (targetTag,tagLoc)
start = int(tagLoc - boundary)
end = int(tagLoc + boundary)
#!May need a little touch up
if start < 0:
start = 0
end = int(boundary*2)
if end > len(s):
end = len(s)
if self.verbose: print"region %s -> %s of %s" % (start,end,len(s))
lowSearchBound = start - searchSize - 5
highSearchBound = end + searchSize + 5
if lowSearchBound < 0:
lowSearchBound = 0
if highSearchBound > len(s):
highSearchBound = len(s)
if genomicStrand == laggingComplementStrand:
s = r.seq[lowSearchBound:highSearchBound]
sx = r.seq[start:end]
else:
s = r.seq[lowSearchBound:highSearchBound].reverse_complement()
sx = r.seq[start:end].reverse_complement()
searchEnd = (end-start+searchSize+5)
searchStart = searchSize + 5
try:
testSeqs = self.optimizeSecondaryStructure(s, searchStart, searchEnd, searchSize, cutOff, ratio = 2)
testSeqs.sort()
if len(testSeqs) == 0:
(score,adjust,foldScore,bestSeq) = ("na","na","na","na")
else:
(score,adjust,foldScore,bestSeq) = testSeqs.pop(0)
except:
testSeqs = []
(score,adjust,foldScore,bestSeq) = ("na","na","na",sx)
print "failed to exicute secondary structure test"
#print "[%s]" % (s)
#bestSeq = self.addStars(bestSeq,self.stars)
if len(bestSeq) < boundary*2:
print "Short Sequence"
if self.verbose: print "%s best %s S:%s [%s] (%s)" % (len(testSeqs), adjust, score, foldScore, len(bestSeq))
if self.verbose: print "[%s]" % (bestSeq)
result.add(id,"original", originalString)
result.add(id,"hits", hits)
result.add(id,"genomic_start", genomicStart)
result.add(id,"genomic_end", genomicEnd)
result.add(id,"genomic_strand", genomicStrand)
result.add(id,"lagging_complement_strand", laggingComplementStrand)
result.add(id,"best", bestSeq)
result.add(id,"fold score", foldScore)
result.add(id,"off center", adjust)
#append to list of sequence regions
sRegion = r
sRegion.seq = sx
sRegions.append(sRegion)
index = index + 1
logFile.close()
return (targetMap,result,sRegions)
self.headerNames = ["Row Names"]
def write(self, report):
headerNames = self.headerNames
headerNames.extend(report.returnColumnNames())
self.writeLineArray(headerNames)
rowNames = report.returnRowNames()
for rowName in rowNames:
nameArray = [rowName]
rowArray = report.returnRowArray(rowName)
nameArray.extend(rowArray)
self.writeLineArray(nameArray)
if __name__=='__main__':
hash = {"sad":"happy","mad":"calm"}
stuff = Report()
stuff.addReportColumnHash("nerd",hash)
hash2 = {"sad":"crabby","crazy":"cool",}
hash3 = {"bad":"foolish","great":"hysterical"}
stuff.addReportColumnHash("loop", hash2)
stuff.addReportColumnHash("please", hash3)
print stuff.returnColumnNames()
print stuff.returnRowNames()
print stuff.returnRowArray("mad")
print stuff.returnRowArray("sad")
morestuff = ReportWriter()
filename = 'testfile'
morestuff.setFile(filename)
morestuff.writer(stuff)
morestuff.closeFile()
