else: print "ERROR: Format /CAL <calendar-name>" # comm /EVT <calendar-name> <event-name> <event-place> <event-start-hour> <event-end-hour> <event-description> # hour consists of 4 character e.g. 04pm, 05am # no space character for description elif(param[0].strip() == '/EVT'): if (param.__len__() == 7): calName = param[1].strip() if u.hasCalendar(calName): EvtName = param[2] EvtPlace = param[3] EvtStart = param[4] EvtEnd = param[5] EvtDesc = param[6] ev = Event(EvtName,EvtPlace,EvtStart,EvtEnd,EvtDesc) x = calName + 'X' channel.exchange_declare(exchange=x,type='fanout') message = ev.toString() # print "message:",message channel.basic_publish(exchange=x,routing_key='',body=message) print "INFO: Event sent to calendar",calName else: print "INFO: You are not in this calendar" else: print "ERROR: Parameter Error" elif(param[0].strip()=='/ALL'): u.showAllEvents()
def findOrthologsBySelfGlobalAlignment(strain, coverageTracker, sibling): print('Performing self-global alignment on strain: %s' % (strain.name)) if strain.name == 'NC_015634': print('BREAK') lossEvents = [] duplicationEvents = [] fragments = strain.genomeFragments for i in range(0, len(coverageTracker)): if coverageTracker[i] == False: #Operon has not been marked bestScore = 1000 #Make the best score some large numer bestEvent = None #Initialize the event minDistance = 1000 #Used to track the minimum distance from singleton to operon that has an identical gene filteredList = iter( filter( lambda x: x.fragmentIndex == i, fragments)) #Get the fragment we need based on the index unmarkedFragment = next(filteredList, None) if len(unmarkedFragment.sequence) > 1: #We're processing an operon for j in range(0, len(coverageTracker)): filteredList = iter( filter(lambda x: x.fragmentIndex == j, fragments) ) #Get the fragment we need based on the index currFragment = next(filteredList, None) if i != j and coverageTracker[j] == True and len( currFragment.sequence) > 1: op1 = unmarkedFragment.sequence op2 = currFragment.sequence event = Event(0) event.setFragmentDetails1(unmarkedFragment) event.setFragmentDetails2(currFragment) event.setGenome1Name(strain.name) event.setGenome2Name(strain.name) event.setTechnique('Self Global Alignment (Operon)') event.setAncestralOperonGeneSequence( copy.deepcopy( op1)) #Set the ancestral operon sequence score, event = performGlobalAlignment( op1, op2, event) #Perform the global alignment event.setScore(score) #Compute whether this comparison is interesting threshold = max(len(op1), len(op2)) threshold = threshold // 3 numOperonDifferences = computeOperonDifferences( op1, op2) if numOperonDifferences <= threshold and score < bestScore: bestScore = score bestEvent = event #Make sure an origin or a terminus doesn't get mapped with a singleton gene elif len( unmarkedFragment.sequence ) == 1 and unmarkedFragment.description != 'Origin' and unmarkedFragment.description != 'Terminus': for j in range(0, len(coverageTracker)): if i != j and coverageTracker[j] == True: filteredList = iter( filter(lambda x: x.fragmentIndex == j, fragments) ) #Get the fragment we need based on the index currFragment = next(filteredList, None) op1 = unmarkedFragment.sequence op2 = currFragment.sequence event = Event(0) event.setFragmentDetails1(unmarkedFragment) event.setFragmentDetails2(currFragment) event.setGenome1Name(strain.name) event.setGenome2Name(strain.name) event.setTechnique('Self Global Alignment (Singleton)') event.setAncestralOperonGeneSequence( copy.deepcopy( op1)) #Set the ancestral operon sequence if op1[0] in op2 and abs( i - j ) < minDistance: #Checks if the singleton gene is located in the operon and if the distance is smaller minDistance = abs(i - j) event.setScore(0) bestEvent = event if bestEvent != None: #A match was found meaning the operon is a duplicate therefor do not add it into the ancestor globals.trackingId += 1 bestEvent.trackingEventId = globals.trackingId coverageTracker[i] = True duplicationEvents.append(bestEvent) duplicationDetails = '' position = bestEvent.fragmentDetails1.startPositionInGenome op = copy.deepcopy(bestEvent.fragmentDetails1.sequence) if bestEvent.fragmentDetails1.isNegativeOrientation == True: #Reverses the genes if the operon was originally negative to ensure the correct position is computed op.reverse() for gene in op: duplicationDetails += gene + ' ' + str(position) + ', ' position += 1 duplicationDetails = duplicationDetails[0:( len(duplicationDetails) - 2)] duplicationDetails += ';' #Increment the duplicate counter with size of operon since the operon is a duplication strain = addDuplicationEventsToStrain( strain, [len(bestEvent.fragmentDetails1.sequence)], duplicationDetails) print('\n&&&&&& Self Global Alignment &&&&&') print(bestEvent.toString()) print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n') else: #No match was found therefore it must have been lost in the sibling therefore we include it in the ancestor coverageTracker[i] = True globals.trackingId += 1 event = Event(globals.trackingId) event.setScore(-1) event.setFragmentDetails1(unmarkedFragment) event.setFragmentDetails2(unmarkedFragment) event.setGenome1Name(strain.name) event.setGenome2Name(strain.name) event.setTechnique('Self Global Alignment (No match!)') event.setAncestralOperonGeneSequence( copy.deepcopy(unmarkedFragment.sequence)) lossEvents.append(event) deletionDetails = '' position = event.fragmentDetails1.startPositionInGenome op = copy.deepcopy(event.fragmentDetails1.sequence) if event.fragmentDetails1.isNegativeOrientation == True: #Reverses the genes if the operon was originally negative to ensure the correct position is computed op.reverse() for gene in op: deletionDetails += gene + ' ' + str(position) + ', ' position += 1 deletionDetails = deletionDetails[0:(len(deletionDetails) - 2)] deletionDetails += ';' #Increment the loss counter with the size of the operon since the operon is a loss sibling = addDeletionEventsToStrain( sibling, [len(event.fragmentDetails1.sequence)], deletionDetails) print('\n&&&&&& Self Global Alignment &&&&&') print(event.toString()) print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n') return duplicationEvents, lossEvents, coverageTracker, strain, sibling
def findOrthologsByLocalAlignment(coverageTracker1, coverageTracker2, strain1, strain2): events = [] localAlignmentCounter = 0 minValue = min(len(coverageTracker1), len( coverageTracker2)) #Used for computing all of the values in the matrix #Scan the matrix x times to find optimal local alignments everytime an entire matrix is computed for x in range(0, minValue): highestScore = -1 distance = 50 #An arbitrary large number for i in range(0, len(coverageTracker1)): filteredList = iter( filter(lambda x: x.fragmentIndex == i, strain1.genomeFragments) ) #Get the fragment we need based on the index fragment1 = next(filteredList, None) if coverageTracker1[i] == False and len( fragment1.sequence ) > 1: #Make sure the operon is not marked and not a singleton for j in range(0, len(coverageTracker2)): filteredList = iter( filter(lambda x: x.fragmentIndex == j, strain2.genomeFragments) ) #Get the fragment we need based on the index fragment2 = next(filteredList, None) if coverageTracker2[j] == False and len( fragment2.sequence ) > 1: #Make sure the operon is not marked and not a singleton #Initialize the event event = Event(0) event.setFragmentDetails1(fragment1) event.setFragmentDetails2(fragment2) event.setGenome1Name(strain1.name) event.setGenome2Name(strain2.name) event.setTechnique('Local Alignment') score, startPosition, endPosition, event = localAlignment( fragment1, fragment2, event) if (score > highestScore) or (score == highestScore and (abs(i - j)) < distance): highestScore = score rowIndex = i colIndex = j distance = abs(i - j) chosenOpEvent = event #After scanning the whole matrix if we found a best score, then store it if highestScore > -1: print('\n******** Local Alignment ***********') print('**************************************\n') event = chosenOpEvent globals.trackingId += 1 localAlignmentCounter += 1 coverageTracker1[rowIndex] = True coverageTracker2[colIndex] = True event.trackingEventId = globals.trackingId event, strain1, strain2 = reconstructOperonSequence( event, strain1, strain2) #Codon mismatches if event.numCodonMismatches > 0: codonMismatchDescription1 = constructStatement( event.codonMismatchIndexesStrain1, event.codonMismatchGenesStrain1, event.fragmentDetails1) codonMismatchDescription2 = constructStatement( event.codonMismatchIndexesStrain2, event.codonMismatchGenesStrain2, event.fragmentDetails2) strain1.addCodonMismatchDetails(codonMismatchDescription1) strain2.addCodonMismatchDetails(codonMismatchDescription2) #Substitutions if event.numSubstitutions > 0: substitutionDescription1 = constructStatement( event.substitutionIndexesStrain1, event.substitutionGenesStrain1, event.fragmentDetails1) substitutionDescription2 = constructStatement( event.substitutionIndexesStrain2, event.substitutionGenesStrain2, event.fragmentDetails2) strain1.addSubstitutionDetails(substitutionDescription1) strain2.addSubstitutionDetails(substitutionDescription2) events.append(event) #Add the event to the tracking events list print(event.toString()) print('\n**************************************') print('**************************************\n\n') return events, coverageTracker1, coverageTracker2, localAlignmentCounter, strain1, strain2
def findOrthologsBySelfGlobalAlignment(strain, coverageTracker, sibling): if globals.printToConsole: print('Performing self-global alignment on strain: %s' % (strain.name)) lossEvents = [] duplicationEvents = [] fragments = strain.genomeFragments for i in range(0, len(coverageTracker)): if coverageTracker[i] == False: #Operon has not been marked bestScore = -1000 #Make the best score some large numer bestEvent = None #Initialize the event minDistance = 1000 #Used to track the minimum distance from singleton to operon that has an identical gene bestJ = -999 filteredList = iter( filter( lambda x: x.fragmentIndex == i, fragments)) #Get the fragment we need based on the index unmarkedFragment = next(filteredList, None) if len(unmarkedFragment.sequence) > 1: #We're processing an operon for j in range(0, len(coverageTracker)): filteredList = iter( filter(lambda x: x.fragmentIndex == j, fragments) ) #Get the fragment we need based on the index currFragment = next(filteredList, None) if i != j and currFragment.isDuplicate == False and len( currFragment.sequence) > 1: op1 = unmarkedFragment.sequence op2 = currFragment.sequence event = Event(0) event.setFragmentDetails1(unmarkedFragment) event.setFragmentDetails2(currFragment) event.setGenome1Name(strain.name) event.setGenome2Name(strain.name) event.setTechnique('Self Global Alignment (Operon)') event.setAncestralOperonGeneSequence( copy.deepcopy( op1)) #Set the ancestral operon sequence score, event = performGlobalAlignment( op1, op2, event) #Perform the global alignment event.setScore(score) #Compute whether this comparison is interesting #threshold = max(len(op1), len(op2)) #threshold = threshold//3 #numOperonDifferences = computeOperonDifferences(op1, op2) #if numOperonDifferences <= threshold and score < bestScore: if (score > 0 and score > bestScore) or ( score == bestScore and abs(i - j) < minDistance): bestScore = score bestEvent = event minDistance = abs(i - j) bestJ = j #Make sure an origin or a terminus doesn't get mapped with a singleton gene elif len( unmarkedFragment.sequence ) == 1 and unmarkedFragment.description != 'Origin' and unmarkedFragment.description != 'Terminus': for j in range(0, len(coverageTracker)): filteredList = iter( filter(lambda x: x.fragmentIndex == j, fragments) ) #Get the fragment we need based on the index currFragment = next(filteredList, None) if i != j and currFragment.isDuplicate == False: op1 = unmarkedFragment.sequence op2 = currFragment.sequence event = Event(0) event.setFragmentDetails1(unmarkedFragment) event.setFragmentDetails2(currFragment) event.setGenome1Name(strain.name) event.setGenome2Name(strain.name) event.setTechnique('Self Global Alignment (Singleton)') event.setAncestralOperonGeneSequence( copy.deepcopy( op1)) #Set the ancestral operon sequence if op1[0] in op2 and abs( i - j ) < minDistance: #Checks if the singleton gene is located in the operon and if the distance is smaller minDistance = abs(i - j) event.setScore(0) bestEvent = event bestJ = j if bestEvent != None: #A match was found meaning the operon is a duplicate therefor do not add it into the ancestor #Handle special case where two unmarked operons are selected as the best matches cycleDuplication = False if coverageTracker[i] == False and coverageTracker[ bestJ] == False: bestEvent.fragmentDetails2.isDuplicate = True coverageTracker[bestJ] = True cycleDuplication = True bestEvent.setScore(-1) bestEvent.setAncestralOperonGeneSequence( copy.deepcopy(bestEvent.fragmentDetails2.sequence) ) #insert source as ancestral operon bestEvent.setTechnique( 'Self Global Alignment (Cyclic Duplication!)') lossEvents.append(bestEvent) globals.trackingId += 1 coverageTracker[i] = True bestEvent.trackingEventId = globals.trackingId if len(bestEvent.fragmentDetails1.sequence) > 1 and len( bestEvent.fragmentDetails2.sequence) > 1: handleDuplicateDetails(bestEvent, strain, sibling, cycleDuplication) else: #Singleton was mapped to an operon if len(bestEvent.fragmentDetails1.sequence) == 1: gene = bestEvent.fragmentDetails1.sequence[0] position = bestEvent.fragmentDetails1.startPositionInGenome else: gene = bestEvent.fragmentDetails2.sequence[0] position = bestEvent.fragmentDetails2.startPositionInGenome tempString = gene + ' ' + str(position) + ';' strain = addDuplicationEventsToStrain( strain, [1], tempString) duplicationEvents.append(bestEvent) #This is now being handled with the function handleDuplicateDetails #duplicationDetails = '' #position = bestEvent.fragmentDetails1.startPositionInGenome #op = copy.deepcopy(bestEvent.fragmentDetails1.sequence) #if bestEvent.fragmentDetails1.isNegativeOrientation == True: #Reverses the genes if the operon was originally negative to ensure the correct position is computed #op.reverse() #for gene in op: #duplicationDetails += gene + ' ' + str(position) + ', ' #position += 1 #duplicationDetails = duplicationDetails[0:(len(duplicationDetails) - 2)] #duplicationDetails += ';' #Increment the duplicate counter with size of operon since the operon is a duplication #strain = addDuplicationEventsToStrain(strain, [len(bestEvent.fragmentDetails1.sequence)], duplicationDetails) if globals.printToConsole: print('\n&&&&&& Self Global Alignment &&&&&') print(bestEvent.toString()) print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n') else: #No match was found therefore it must have been lost in the sibling therefore we include it in the ancestor coverageTracker[i] = True globals.trackingId += 1 event = Event(globals.trackingId) event.setScore(-1) event.setFragmentDetails1(unmarkedFragment) event.setFragmentDetails2(unmarkedFragment) event.setGenome1Name(strain.name) event.setGenome2Name(strain.name) event.setTechnique('Self Global Alignment (No match!)') event.setAncestralOperonGeneSequence( copy.deepcopy(unmarkedFragment.sequence)) lossEvents.append(event) position = event.fragmentDetails1.startPositionInGenome op = copy.deepcopy(event.fragmentDetails1.sequence) tempString = '' for n in range(0, len(op)): gene = op[n] if event.fragmentDetails1.isNegativeOrientation == False: tempString += gene + ' ' + str(n + position) + ', ' else: tempString = gene + ' ' + str(position + len(op) - n - 1) + ', ' + tempString tempString = tempString[0:( len(tempString) - 2)] #Remove the last comma and space tempString += ';' #Increment the loss counter with the size of the operon since the operon is a loss sibling = addDeletionEventsToStrain( sibling, [len(event.fragmentDetails1.sequence)], tempString) if globals.printToConsole: print('\n&&&&&& Self Global Alignment &&&&&') print(event.toString()) print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n') return duplicationEvents, lossEvents, coverageTracker, strain, sibling