Allcomb.py

Copy and past the following into a text editor and save it as allcomb.py to use the script.


 * 1) !/usr/bin/env python
 * 1) allcomb [options]                                                                          #
 * 2) Example: python allcomb.py -n 20 ../myFile.txt                                                                            #
 * 3) Version: 1.1  Last Modified: 2/25/2010     Author: Zachary S. L. Foster                                                   #
 * 1) Version: 1.1  Last Modified: 2/25/2010     Author: Zachary S. L. Foster                                                   #


 * 1) allcomb [options]                                                            #
 * 2) Example: python allcomb.py -i 2 -g 2 ../myFile.txt                                               #
 * 3) Version: 1.2   Last Modified: 2/25/2010     Author: Zachary S. L. Foster                         #
 * 4) Intended uses:                                                                                   #
 * 5)  1)Find all possible combinations of elements (or group of elements) for every line of a         #
 * 6)    tab-delimitated text file and output every combination, on its own line, in a .txt file.      #
 * 7) Modifiers:                                                                                       #
 * 8)  -d  : Save debug log to current working directory.                                              #
 * 9)  -g  : Specify the number of elements in to treat as a group when combining.                     #
 * 10)  -i  : Specify the number of columns in front to ignore when making combinations.                #
 * 11)        (Data in ignored columns is preserved in the first columns of the output file)            #
 * 1)  -d  : Save debug log to current working directory.                                              #
 * 2)  -g  : Specify the number of elements in to treat as a group when combining.                     #
 * 3)  -i  : Specify the number of columns in front to ignore when making combinations.                #
 * 4)        (Data in ignored columns is preserved in the first columns of the output file)            #

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
 * 1) Imports / Variable Initilization##########################################################################################

def errorExit: print 'The program was forced to exit prematurely, printing debug log...\n' for line in debugLog: print line sys.exit
 * 1) Error handling function#####################################################################################################
 * 2) >Is called when the script encounters a fatal error                                                                       #
 * 3) >Prints the debug log to standard out (usually the screen)                                                                #

def printHelp: print '/--\\' print '| allcomb [options]                                                           |' 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 '\\--/'

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
 * 1) Argument Interprtation####################################################################################################
 * 2) >Parses the arguments supplied by the user, or the default values if the script is being run on IDLE                      #
 * 3) >If no arguments are given, the help menu is printed                                                                      #
 * 4) >Modifiers and their arguments are isolated from the raw input for later processing (in Modifier Interpretation)          #

#########################################################################################################################

###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 #########################################################################################################################