1670

pending completion

Build # 1670

Build Type

Pull #603

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/griffithlab/pVACtools/commit/<a class=hub.com/griffithlab/pVACtools/commit/704b631ee27c483daa7818d7ef86116df09ea46b">704b631ee<a href="https://github.com/griffithlab/pVACtools/commit/704b631ee27c483daa7818d7ef86116df09ea46b">">Merge </a><a class="double-link" href="https://github.com/griffithlab/pVACtools/commit/<a class="double-link" href="https://github.com/griffithlab/pVACtools/commit/e272ade57a37bcef1f9fd8f466b48064e6cc504a">e272ade57</a>">e272ade57</a><a href="https://github.com/griffithlab/pVACtools/commit/704b631ee27c483daa7818d7ef86116df09ea46b"> into 1b3fa5fef">1b3fa5fef</a>

Pull Request Pull Request #603: Centralize the index creation

Run Details

29 of 29 new or added lines in 7 files covered. (100.0%)

4239 of 5129 relevant lines covered (82.65%)

2.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.36

/tools/pvacfuse/generate_protein_fasta.py

import sys
from pathlib import Path # if you haven't already done so
root = str(Path(__file__).resolve().parents[1])
sys.path.append(root)
import argparse
import tempfile
import os
import yaml
import csv
from collections import OrderedDict
from Bio import SeqIO
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio.Alphabet import IUPAC
from lib.fasta_generator import *
from lib.input_file_converter import *
from lib.calculate_manufacturability import *

def define_parser():
    parser = argparse.ArgumentParser("pvacfuse generate_protein_fasta", formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument(
        "input_file",
        help="An INTEGRATE-Neo annotated bedpe file with fusions or a AGfusion output directory."
    )
    parser.add_argument(
        "flanking_sequence_length", type=int,
        help="Number of amino acids to add on each side of the mutation when creating the FASTA.",
    )
    parser.add_argument(
        "output_file",
        help="The output fasta file."
    )
    parser.add_argument(
        "--input-tsv",
        help = "A pVACfuse all_epitopes or filtered TSV file with epitopes to use for subsetting the input file to peptides of interest. Only the peptide sequences for the epitopes in the TSV will be used when creating the FASTA."
    )
    parser.add_argument(
        "-d", "--downstream-sequence-length",
        default="1000",
        help="Cap to limit the downstream sequence length for frameshift fusion when creating the fasta file. "
            + "Use 'full' to include the full downstream sequence."
    )
    return parser

def convert_fusion_input(input_file, temp_dir):
    print("Converting Fusion file to TSV")
    tsv_file = os.path.join(temp_dir, 'tmp.tsv')
    convert_params = {
        'input_file' : input_file,
        'output_file': tsv_file,
    }
    converter = FusionInputConverter(**convert_params)
    converter.execute()
    print("Completed")

def generate_fasta(flanking_sequence_length, downstream_sequence_length, temp_dir):
    print("Generating Variant Peptide FASTA and Key File")
    tsv_file = os.path.join(temp_dir, 'tmp.tsv')
    fasta_file = os.path.join(temp_dir, 'tmp.fasta')
    fasta_key_file = os.path.join(temp_dir, 'tmp.fasta.key')
    generate_fasta_params = {
        'input_file'                : tsv_file,
        'flanking_sequence_length'  : flanking_sequence_length,
        'epitope_length'            : 0,
        'output_file'               : fasta_file,
        'output_key_file'           : fasta_key_file,
        'downstream_sequence_length': downstream_sequence_length
    }
    fasta_generator = FusionFastaGenerator(**generate_fasta_params)
    fasta_generator.execute()
    print("Completed")

def parse_input_tsv(input_tsv):
    if input_tsv is None:
        return None
    indexes = []
    with open(input_tsv, 'r') as fh:
        reader = csv.DictReader(fh, delimiter = "\t")
        for line in reader:
            indexes.append(line['index'])
    return indexes

def parse_files(output_file, temp_dir, input_tsv):
    print("Parsing the Variant Peptide FASTA and Key File")
    fasta_file_path = os.path.join(temp_dir, 'tmp.fasta')
    fasta_key_file_path = os.path.join(temp_dir, 'tmp.fasta.key')

    with open(fasta_key_file_path, 'r') as fasta_key_file:
        keys = yaml.load(fasta_key_file, Loader=yaml.FullLoader)

    tsv_indexes = parse_input_tsv(input_tsv)

    dataframe = OrderedDict()
    output_records = []
    for record in SeqIO.parse(fasta_file_path, "fasta"):
        ids = keys[int(record.id)]
        for record_id in ids:
            if tsv_indexes is not None:
                if record_id not in tsv_indexes:
                    continue
            new_record = SeqRecord(record.seq, id=record_id, description=record_id)
            output_records.append(new_record)

    SeqIO.write(output_records, output_file, "fasta")
    print("Completed")

def main(args_input = sys.argv[1:]):
    parser = define_parser()
    args = parser.parse_args(args_input)

    if args.downstream_sequence_length == 'full':
        downstream_sequence_length = None
    elif args.downstream_sequence_length.isdigit():
        downstream_sequence_length = int(args.downstream_sequence_length)
    else:
        sys.exit("The downstream sequence length needs to be a positive integer or 'full'")

    temp_dir = tempfile.mkdtemp()
    convert_fusion_input(args.input_file, temp_dir)
    generate_fasta(args.flanking_sequence_length, downstream_sequence_length, temp_dir)
    parse_files(args.output_file, temp_dir, args.input_tsv)
    manufacturability_file = "{}.manufacturability.tsv".format(args.output_file)
    print("Calculating Manufacturability Metrics")
    CalculateManufacturability(args.output_file, manufacturability_file, 'fasta').execute()
    print("Completed")

if __name__ == '__main__':
    main()

1	import sys	3✔
2	from pathlib import Path # if you haven't already done so	3✔
3	root = str(Path(__file__).resolve().parents[1])	3✔
4	sys.path.append(root)	3✔
5	import argparse	3✔
6	import tempfile	3✔
7	import os	3✔
8	import yaml	3✔
9	import csv	3✔
10	from collections import OrderedDict	3✔
11	from Bio import SeqIO	3✔
12	from Bio.Seq import Seq	3✔
13	from Bio.SeqRecord import SeqRecord	3✔
14	from Bio.Alphabet import IUPAC	3✔
15	from lib.fasta_generator import *	3✔
16	from lib.input_file_converter import *	3✔
17	from lib.calculate_manufacturability import *	3✔
18
19	def define_parser():	3✔
20	parser = argparse.ArgumentParser("pvacfuse generate_protein_fasta", formatter_class=argparse.ArgumentDefaultsHelpFormatter)	3✔
21
22	parser.add_argument(	3✔
23	"input_file",
24	help="An INTEGRATE-Neo annotated bedpe file with fusions or a AGfusion output directory."
25	)
26	parser.add_argument(	3✔
27	"flanking_sequence_length", type=int,
28	help="Number of amino acids to add on each side of the mutation when creating the FASTA.",
29	)
30	parser.add_argument(	3✔
31	"output_file",
32	help="The output fasta file."
33	)
34	parser.add_argument(	3✔
35	"--input-tsv",
36	help = "A pVACfuse all_epitopes or filtered TSV file with epitopes to use for subsetting the input file to peptides of interest. Only the peptide sequences for the epitopes in the TSV will be used when creating the FASTA."
37	)
38	parser.add_argument(	3✔
39	"-d", "--downstream-sequence-length",
40	default="1000",
41	help="Cap to limit the downstream sequence length for frameshift fusion when creating the fasta file. "
42	+ "Use 'full' to include the full downstream sequence."
43	)
44	return parser	3✔
45
46	def convert_fusion_input(input_file, temp_dir):	3✔
47	print("Converting Fusion file to TSV")	3✔
48	tsv_file = os.path.join(temp_dir, 'tmp.tsv')	3✔
49	convert_params = {	3✔
50	'input_file' : input_file,
51	'output_file': tsv_file,
52	}
53	converter = FusionInputConverter(**convert_params)	3✔
54	converter.execute()	3✔
55	print("Completed")	3✔
56
57	def generate_fasta(flanking_sequence_length, downstream_sequence_length, temp_dir):	3✔
58	print("Generating Variant Peptide FASTA and Key File")	3✔
59	tsv_file = os.path.join(temp_dir, 'tmp.tsv')	3✔
60	fasta_file = os.path.join(temp_dir, 'tmp.fasta')	3✔
61	fasta_key_file = os.path.join(temp_dir, 'tmp.fasta.key')	3✔
62	generate_fasta_params = {	3✔
63	'input_file' : tsv_file,
64	'flanking_sequence_length' : flanking_sequence_length,
65	'epitope_length' : 0,
66	'output_file' : fasta_file,
67	'output_key_file' : fasta_key_file,
68	'downstream_sequence_length': downstream_sequence_length
69	}
70	fasta_generator = FusionFastaGenerator(**generate_fasta_params)	3✔
71	fasta_generator.execute()	3✔
72	print("Completed")	3✔
73
74	def parse_input_tsv(input_tsv):	3✔
75	if input_tsv is None:	3✔
76	return None	3✔
77	indexes = []	×
78	with open(input_tsv, 'r') as fh:	×
79	reader = csv.DictReader(fh, delimiter = "\t")	×
80	for line in reader:	×
81	indexes.append(line['index'])	×
82	return indexes	×
83
84	def parse_files(output_file, temp_dir, input_tsv):	3✔
85	print("Parsing the Variant Peptide FASTA and Key File")	3✔
86	fasta_file_path = os.path.join(temp_dir, 'tmp.fasta')	3✔
87	fasta_key_file_path = os.path.join(temp_dir, 'tmp.fasta.key')	3✔
88
89	with open(fasta_key_file_path, 'r') as fasta_key_file:	3✔
90	keys = yaml.load(fasta_key_file, Loader=yaml.FullLoader)	3✔
91
92	tsv_indexes = parse_input_tsv(input_tsv)	3✔
93
94	dataframe = OrderedDict()	3✔
95	output_records = []	3✔
96	for record in SeqIO.parse(fasta_file_path, "fasta"):	3✔
97	ids = keys[int(record.id)]	3✔
98	for record_id in ids:	3✔
99	if tsv_indexes is not None:	3✔
100	if record_id not in tsv_indexes:	×
101	continue	×
102	new_record = SeqRecord(record.seq, id=record_id, description=record_id)	3✔
103	output_records.append(new_record)	3✔
104
105	SeqIO.write(output_records, output_file, "fasta")	3✔
106	print("Completed")	3✔
107
108	def main(args_input = sys.argv[1:]):	3✔
109	parser = define_parser()	3✔
110	args = parser.parse_args(args_input)	3✔
111
112	if args.downstream_sequence_length == 'full':	3✔
113	downstream_sequence_length = None	×
114	elif args.downstream_sequence_length.isdigit():	3✔
115	downstream_sequence_length = int(args.downstream_sequence_length)	3✔
116	else:
117	sys.exit("The downstream sequence length needs to be a positive integer or 'full'")	×
118
119	temp_dir = tempfile.mkdtemp()	3✔
120	convert_fusion_input(args.input_file, temp_dir)	3✔
121	generate_fasta(args.flanking_sequence_length, downstream_sequence_length, temp_dir)	3✔
122	parse_files(args.output_file, temp_dir, args.input_tsv)	3✔
123	manufacturability_file = "{}.manufacturability.tsv".format(args.output_file)	3✔
124	print("Calculating Manufacturability Metrics")	3✔
125	CalculateManufacturability(args.output_file, manufacturability_file, 'fasta').execute()	3✔
126	print("Completed")	3✔
127
128	if __name__ == '__main__':	3✔
129	main()	×

griffithlab / pVACtools / 1670

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous