Allcomb.py

From OpenWetWare

Jump to: navigation, 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()
    ######################################################################################################################### 
Personal tools