bseq_opdracht.py

# coding=utf-8
import os
import sys

def maak_fasta():
    fastabestand = open("blast_output_fasta.fa", "w")
    for lijn in open("blast_output.txt", "r"):
        split_lijn = lijn.split("\t")
        fastabestand.write(">" + split_lijn[0] + "\n" + split_lijn[1] + "\n")

    fastabestand.close()


class Commando:
    def __init__(self, commando, parameters):
        self.commando = commando
        self.parameters = parameters
        self.actieve_parameters = []

    def get_naam(self):
        return self.commando

    def get_parameters(self):
        return self.parameters

    def default(self, parameter, parameter_invoer):
        self.actieve_parameters.append([parameter, " " + parameter_invoer])

    def set_parameter(self, gekozen_categorie, parameter_nummer, parameter_invoer):
        parameter = self.parameters[gekozen_categorie].get_parameterlijst()[parameter_nummer][0]
        kopie = [par[0] for par in self.actieve_parameters]
        if parameter in kopie:
            self.actieve_parameters[kopie.index(parameter)] = [parameter, " " + parameter_invoer]
        else:
            self.actieve_parameters.append([parameter, " " + parameter_invoer])

    def bouw_commando(self):
        return "".join(self.commando + " " + str(self.actieve_parameters))


class Parameters:
    def __init__(self, categorie, parameterlijst):
        self.parameterlijst = parameterlijst
        self.categorie = categorie

    def get_parameterlijst(self):
        return self.parameterlijst

    def get_categorie(self):
        return self.categorie


def hoofdmenu(blast_parameters, clustal_parameters, blast_commando, clustal_commando):
    while True:
        print("=== Hoofdmenu ===")
        print("Huidige BLAST commando: " + blast_commando.bouw_commando())
        print("Huidige CLUSTAL commando: " + clustal_commando.bouw_commando())
        print("0. pas BLAST parameters aan")
        print("1. pas CLUSTAL parameters aan")
        print("5. GO!")
        print("\n99. stop")
        invoer = int(input(">>> "))

        if invoer == 0:
            wijzig_parameters(blast_parameters, blast_commando)
        elif invoer == 1:
            wijzig_parameters(clustal_parameters, clustal_commando)
        elif invoer == 5:
            os.system(blast_commando.bouw_commando())
            maak_fasta()

#            os.system(clustal_commando.get_commando())
        elif invoer == 99:
            sys.exit()


def printbare_parameter(parameter, commando_naam):
    if commando_naam == "clustalw":
        return parameter[0][:-1]
    else:
        return parameter[0][1:]


def print_parameters(commando_naam, categorie, parameter_lijst):
    print("=== " + categorie + " ===")
    print("Welke parameter(s) wil je aanpassen?\n")
    for parameter_nummer, parameter in enumerate(parameter_lijst):
        parameter_beschrijving = parameter[1]
        print(
            "%i.\t%s\n\t%s\n" % (
                parameter_nummer, printbare_parameter(parameter, commando_naam), parameter_beschrijving))

    print("99. Ga terug\n")


def print_categorien(alle_parameters):
    print("Welke categorie wil je aanpassen?")
    for parameter_nummer, parameter in enumerate(alle_parameters):
        print("%i. %s" % (parameter_nummer, parameter.get_categorie()))

    print("\n99. Ga terug\n")


def wijzig_parameters(parameters, commando):
    while True:
        print("Huidige commando: " + commando.bouw_commando())

        #Kies een categorie
        print_categorien(parameters)
        gekozen_categorie = int(input(">>> "))
        if gekozen_categorie == 99:
            return
        categorie = parameters[gekozen_categorie]

        #Kies parameters binnen de categorie om aan te passen
        print_parameters(commando.get_naam(), categorie.get_categorie(), categorie.get_parameterlijst())
        parameter_input = input(">>> ")
        if int(parameter_input) == 99:
            return

        gekozen_parameters = [int(parameter_nummer) for parameter_nummer in list(parameter_input)]

        parameterlijst = categorie.get_parameterlijst()
        for parameter_nummer in gekozen_parameters:
            parameter = parameterlijst[parameter_nummer]
            parameter_beschrijving = parameter[1]

            print("%s\n%s" % (printbare_parameter(parameter, commando.get_naam()), parameter_beschrijving))
            commando.set_parameter(gekozen_categorie, parameter_nummer, input(">>> "))


Blast_input_query = Parameters("Input query opties",
    [["-query", "The sequence to search with."
     ]])

Blast_general_search = Parameters("General search opties",
    [["-db",
      "The database to BLAST against."],

     ["-out",
      "The output file"
     ],

     ["-evalue",
      """Expectation value cutoff."""],

     ["-word_size",
      """Word size for wordfinder algorithm.
    Integer. Minimum 2."""],

     ["-gapopen",
      "Cost to open a gap (integer)."],

     ["-gapextend",
      "Cost to extend a gap (integer)."],

     ["-matrix",
      "Scoring matrix name (default BLOSUM62)."],

     ["-threshold",
      "Minimum word score such that the word is added to the "
      "BLAST lookup table (float)"]
    ])

Blast_restrict_search = Parameters("Restrict search opties",
    [["-db_soft_mask",
      """Filtering algorithm for soft masking (integer).
  Filtering algorithm ID to apply to the BLAST database as soft masking.
  Incompatible with: db_hard_mask, subject, subject_loc"""],

     ["-db_hard_mask",
      """Filtering algorithm for hard masking (integer).
  Filtering algorithm ID to apply to the BLAST database as hard masking.
  Incompatible with: db_soft_mask, subject, subject_loc"""]

    ])

Blast_extension = Parameters("Extension opties", [
    ["-xdrop_ungap",
     "X-dropoff value (in bits) for ungapped extensions. Float."],

    ["-xdrop_gap",
     "X-dropoff value (in bits) for preliminary gapped extensions. Float."],

    ["-xdrop_gap_final",
     "X-dropoff value (in bits) for final gapped alignment. Float."],

    ["-window_size",
     "Multiple hits window size, use 0 to specify 1-hit algorithm. Integer."],

    ["-ungapped",
     "Perform ungapped alignment only?"]

])

Blast_miscellaneous = Parameters("Miscellaneous opties", [
    ["-use_sw_tback",
     "Compute locally optimal Smith-Waterman alignments?"],

    ["-num_threads",
     """Number of threads to use in the BLAST search. Integer of at least one. Default is one."""]

])

Clustal_opties = Parameters("Clustal opties", [
    ["MATRIX=",
     "Protein weight matrix"],

    ["NEGATIVE=",
     "Protein alignment with negative values in matrix"],

    ["-SEQNOS=",
     "?"],

    ["-SEQNO_RANGE=",
     "?"],

    ["-STATS=",
     "Log some alignents statistics to file"],

    ["GAPOPEN=",
     """Gap opening penalty"""],

    ["GAPTEXT=",
     """Gap extension penalty"""],

    ["ENDGAPS=",
     """No end gap separation pen"""],

    ["GAPDIST=",
     """Gap separation pen"""],

    ["iteration=",
     """No end gap separation pen"""],

    ["numiter=",
     """No end gap separation pen"""],

    ["clustering=",
     """nj OR upgma"""]

])

#-QUICKTREE   :use FAST algorithm for the alignment guide tree
#
#
#-NEGATIVE    :protein alignment with negative values in matrix
#-OUTORDER=   :INPUT or ALIGNED
#-SEQNOS=     :OFF or ON (for Clustal output only)
#-SEQNO_RANGE=:OFF or ON (NEW: for all output formats)
#-STATS=      :Log some alignents statistics to file
#
#-RANGE=m,n   :sequence range to write starting m to m+n
#-MAXSEQLEN=n :maximum allowed input sequence length
#
#
#-INFILE=     :input sequences.
#-OUTFILE=    :sequence alignment file name


def main():
    #BLAST
    #os.system("formatdb -p T -i blast_database.fa")

    blast_parameters = [Blast_input_query, Blast_general_search, Blast_restrict_search,
                        Blast_extension,
                        Blast_miscellaneous]

    blast_commando = Commando("blastp", blast_parameters)

    clustal_parameters = [Clustal_opties]

    blast_commando.default(Blast_input_query.get_parameterlijst()[0][0], "~/PycharmProjects/Bseq/query.fa")
    General_parameterlijst = Blast_general_search.get_parameterlijst()
    blast_commando.default(General_parameterlijst[0][0], "~/PycharmProjects/Bseq/blast_database.fa")
    blast_commando.default(General_parameterlijst[1][0], "~/PycharmProjects/Bseq/blast_output.txt")

#    blast_commando.default('-outfmt "6 sseqid sseq" -num_threads 4')


    #CLUSTAL
    clustal_commando = Commando("clustalw", clustal_parameters)
#    clustal_commando.default("-INFILE=/home/jeroen/PycharmProjects/Bseq/blast_output_fasta.fa -OUTFILE=MSA.fa -TYPE=PROTEIN -QUIET")


    hoofdmenu(blast_parameters, clustal_parameters, blast_commando, clustal_commando)

main()

#blast_parameters = [Blast_input_query, Blast_general_search, Blast_restrict_search,
#                    Blast_extension,
#                    Blast_miscellaneous]
#blast_commando = Commando("blastp", blast_parameters)
#wijzig_parameters(blast_parameters, blast_commando)