Allcomb.py
From OpenWetWare
Jump to navigationJump to search
Copy and past the following into a text editor and save it as allcomb.py to use the script.
#!/usr/bin/env python
#############################################################################################################################
#allcomb [options] <quality file path> <Reference> #
#Example: python allcomb.py -n 20 ../myFile.txt #
#Version: 1.1 Last Modified: 2/25/2010 Author: Zachary S. L. Foster #
#############################################################################################################################
####################################################################################################
# allcomb [options] <file path to text> #
#--------------------------------------------------------------------------------------------------#
# Example: python allcomb.py -i 2 -g 2 ../myFile.txt #
#--------------------------------------------------------------------------------------------------#
# Version: 1.2 Last Modified: 2/25/2010 Author: Zachary S. L. Foster #
# Intended uses: #
# 1)Find all possible combinations of elements (or group of elements) for every line of a #
# tab-delimitated text file and output every combination, on its own line, in a .txt file. #
#--------------------------------------------------------------------------------------------------#
# Modifiers: #
# -d : Save debug log to current working directory. #
# -g : Specify the number of elements in to treat as a group when combining. #
# -i : Specify the number of columns in front to ignore when making combinations. #
# (Data in ignored columns is preserved in the first columns of the output file) #
####################################################################################################
###Imports / Variable Initilization##########################################################################################
import os, string, sys, time
defArgList = ['allcomb.py','-g','1','-i','1','C:/Python26/allcombdef.txt'] #argument list used during script testing the with Python GUI IDLE
argList = sys.argv #argument list supplied by user
argNum = len(argList) #the number of arguments supplied
minArgNum = 1 #the smallest amount of arguments with which it is possible to run the script
saveDebug = False #is True if the debug is to be saved
warning = False #is set to 'True' if the program encounters any minor errors during the analysis; recorded in debug log
printOut = False #is True when no the -p modifier is supplied; #The results will be printed to the standard output (usually the screen)
helpOnly = False #is 'True' when no arguments are given; only help menu is printed
savePath = './' #the directory in which the output will be saved
defSavePath = 'C:/Python26/' #save path used during script testing with the python GUI IDLE
modifiers = [] #eventually contains a list of all modifiers and their arguments supplied by the user
allMods = 'dpig' #all the modifiers recognized by the script
activeMods = '' #a string containing all modifiers specified by the user
modArgs = [] #arguments supplied for the modifiers; assumed in the same order as the modifiers
outData = [] #eventually holds the data that will be saved in the output file
debugLog = ['***********DEBUG LOG***********\n'] #where all errors/anomalies are recorded; saved if the -d modifier is supplied
groupSize = 1
ignoreSize = 1 #number of coumbs to preserve in the start of each line
#############################################################################################################################
#Error handling function#####################################################################################################
#>Is called when the script encounters a fatal error #
#>Prints the debug log to standard out (usually the screen) #
def errorExit():
print 'The program was forced to exit prematurely, printing debug log...\n'
for line in debugLog:
print line
sys.exit()
#############################################################################################################################
def printHelp():
print '/--------------------------------------------------------------------------------------------------\\'
print '| allcomb [options] <file path to text> |'
print '|--------------------------------------------------------------------------------------------------|'
print '| Example: python allcomb.py -i 2 -g 2 ../myFile.txt |'
print '|--------------------------------------------------------------------------------------------------|'
print '| Version: 1.2 Last Modified: 2/25/2010 Author: Zachary S. L. Foster |'
print '| Intended uses: |'
print '| 1)Find all possible combinations of elements (or group of elements) for every line of a |'
print '| tab-delimitated text file and output every combination, on its own line, in a .txt file. |'
print '|--------------------------------------------------------------------------------------------------|'
print '| Modifiers: |'
print '| -d : Save debug log to current working directory. |'
print '| -g : Specify the number of elements in to treat as a group when combining. |'
print '| -i : Specify the number of columns in front to ignore when making combinations. |'
print '| Data in ignored columns is preserved in the first columns of the output file. |'
print '\\--------------------------------------------------------------------------------------------------/'
###Argument Interprtation####################################################################################################
#>Parses the arguments supplied by the user, or the default values if the script is being run on IDLE #
#>If no arguments are given, the help menu is printed #
#>Modifiers and their arguments are isolated from the raw input for later processing (in Modifier Interpretation) #
if __name__ == '__main__': #If the program is being called independent of the Python GUI, IDLE...
if argNum > minArgNum: #If at least the minimum number of arguments necessary is supplied...
if os.path.exists(argList[-1]) == 0: #if the path dose not exist
debugLog.append('Error: Invalid file path to input data')
errorExit() #end the program
elif argNum == 1: #If no arguments are supplied...
helpOnly = True
printHelp() #prints help menu
else:
debugLog.append('Error: Too few arguments supplied\n')
errorExit()
else: #If the script is being imported on to IDLE
argList = defArgList #use default arguments
argNum = len(defArgList)
if argNum == 1: #If no arguments are supplied...
helpOnly = True
printHelp() #prints help menu
savePath = defSavePath #sets the save path to the default, specified in the variable initialization section
debugLog.append('Alert: default debugging input arguments are being used\n')
if helpOnly == False: #if arguments were supplied...
inPath = argList[-1] #the path to the qual file containing the input data
if argNum > minArgNum + 1: #if modifiers are present (i.e. more the minimum number of arguments)
modifiers = argList[1:-minArgNum] #everything before the required arguments are modifiers and their arguments
#############################################################################################################################
if helpOnly == False:
###Modifier Interpretation###############################################################################################
#>Parses any modifiers and modifier arguments determined by the previous section of code, "Argument Interpretation" #
#>Given arguments are compared against a list of known arguments #
#>Matches found change the appropriate variable for the desired effect of the modifier the script #
if len(modifiers) > 0: #if modifiers are supplied
for mod in modifiers: #loops through the list of modifiers and modifier arguments
if mod[0] == '-' and len(mod) == 2: #list entry considered modifier if it starts with - and is only two characters
activeMods += mod[1:] #sorts the modifiers into activeMods...
else:
modArgs.append(mod) #assumes everything else to be a modifier argument
for letter in activeMods: #checks if the modifiers are recognized
if string.find(allMods,letter) == -1: #checks if the modifier is recognized by this script
debugLog.append('Warning: Unexpected modifier: ' + letter + '\n')
warning = True #if the input modifier is not found
else:
if letter == 'd': #if -d is supplied...
saveDebug = True #The debug log will be saved to the current working directory
elif letter == 'p': #if -p is supplied...
printOut = True #The results will be printed to the standard output (usually the screen)
elif letter == 'g': #if -g is supplied...
if len(modArgs) > 0: #if there is at least one non-processed modifier argument
groupSize = int(modArgs[0])
del modArgs[0] #the original argument is deleted from the list
else: #if the list of modifier arguments is empty...
print 'Error: Modifier argument not supplied\n'
sys.exit() #exit the script
elif letter == 'i': #if -i is supplied...
if len(modArgs) > 0: #if there is at least one non-processed modifier argument
ignoreSize = int(modArgs[0])
del modArgs[0] #the original argument is deleted from the list
else: #if the list of modifier arguments is empty...
print 'Error: Modifier argument not supplied\n'
sys.exit() #exit the script
#########################################################################################################################
###Input File Parsing and File procedures################################################################################
inData = []
inHandle = open(inPath, 'r') #opens the file containing the quality values
inRaw = inHandle.readlines() #saves all of the file into qualRaw
inHandle.close() #closes the file object
for line in inRaw:
lineParts = string.split(line)
ignored = lineParts[0]
for index in range(1,groupSize):
ignored += '\t' + lineParts[index]
del lineParts[:groupSize]
if len(lineParts) % groupSize != 0:
debugLog.append('Error: Invalid input data: odd number of arguments')
errorExit()
grouped = []
while len(lineParts) > 0:
group = lineParts[0]
for index in range(1,groupSize):
group += '\t' + lineParts[index]
grouped.append(group)
del lineParts[:groupSize]
parsedLine = [ignored,grouped]
inData.append(parsedLine)
#########################################################################################################################
###Output data generation################################################################################################
outData = []
for line in inData:
for refIndex in range(0,len(line[1])):
for compIndex in range(refIndex + 1,len(line[1])):
if len(line[0]) > 0:
outData.append(line[0] + '\t')
outData.append(line[1][refIndex] + '\t' + line[1][compIndex] + '\n')
#########################################################################################################################
###Out file writing and saveing procedures###############################################################################
fileSavePath = savePath + os.path.basename(inPath) + '_all_combinations.txt' #the path to where the output is saved
outHandle = open(fileSavePath, 'w') #opens the file object for saving the output
for line in outData:
outHandle.write(line)
outHandle.close() #closes file object
#########################################################################################################################
###Debug Saving procedures###############################################################################################
if saveDebug: #if the -d modifier is supplied...
debugHandle = open(savePath + os.path.basename(inPath) + '_debug.txt', 'w')
for line in debugLog:
debugHandle.write(line)
debugHandle.close()
#########################################################################################################################
