1136043958

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/griffithlab/pVACtools/commit/<a class=hub.com/griffithlab/pVACtools/commit/<a class="double-link" href="https://git"><a class=hub.com/griffithlab/pVACtools/commit/<a class="double-link" href="https://git"><a class=hub.com/griffithlab/pVACtools/commit/<a class="double-link" href="https://git"><a class=hub.com/griffithlab/pVACtools/commit/124d1194ca12fbf07e5ff0aa93e895543fc2658e">124d1194c">&lt;a href=&quot;https://github.com/griffithlab/pVACtools/commit/</a><a class="double-link" href="https://github.com/griffithlab/pVACtools/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/griffithlab/pVACtools/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/griffithlab/pVACtools/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/griffithlab/pVACtools/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/griffithlab/pVACtools/commit/124d1194ca12fbf07e5ff0aa93e895543fc2658e">124d1194c</a><a href="https://github.com/griffithlab/pVACtools/commit/124d1194ca12fbf07e5ff0aa93e895543fc2658e">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/griffithlab/pVACtools/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/griffithlab/pVACtools/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/griffithlab/pVACtools/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/griffithlab/pVACtools/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/griffithlab/pVACtools/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/griffithlab/pVACtools/commit/124d1194ca12fbf07e5ff0aa93e895543fc2658e&quot;&gt;124d1194c&lt;/a&gt;&lt;a href=&quot;https://github.com/griffithlab/pVACtools/commit/124d1194ca12fbf07e5ff0aa93e895543fc2658e&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/griffithlab/pVACtools/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp... (continued)

Pull Request Pull Request #690: Implement pVACview and various improvements to the aggregate report

Run Details

794 of 794 new or added lines in 42 files covered. (100.0%)

4539 of 5564 relevant lines covered (81.58%)

2.45 hits per line

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

88.15

/tools/pvacfuse/run.py

import sys
import argparse
import os
import shutil
from lib.prediction_class import *
from lib.pipeline import *
from lib.run_argument_parser import *
from lib.post_processor import *
from lib.run_utils import *
import tools.pvacfuse.generate_protein_fasta
import lib.call_iedb

def define_parser():
    return PvacfuseRunArgumentParser().parser

def create_combined_reports(files, all_epitopes_output_file, filtered_report_file, run_manufacturability_metrics, args):
    for file_name in files:
        if not os.path.exists(file_name):
            print("File {} doesn't exist. Aborting.".format(file_name))
            return

    combine_reports(files, all_epitopes_output_file)

    post_processing_params = vars(args).copy()
    post_processing_params['input_file'] = all_epitopes_output_file
    post_processing_params['filtered_report_file'] = filtered_report_file
    post_processing_params['minimum_fold_change'] = None
    post_processing_params['run_coverage_filter'] = False
    post_processing_params['run_transcript_support_level_filter'] = False
    post_processing_params['run_net_chop'] = False
    post_processing_params['run_netmhc_stab'] = False
    post_processing_params['run_manufacturability_metrics'] = run_manufacturability_metrics
    post_processing_params['run_reference_proteome_similarity'] = False
    post_processing_params['file_type'] = 'pVACfuse'

    PostProcessor(**post_processing_params).execute()

def generate_fasta(args, output_dir, epitope_length):
    per_epitope_output_dir = os.path.join(output_dir, str(epitope_length))
    os.makedirs(per_epitope_output_dir, exist_ok=True)
    output_file = os.path.join(per_epitope_output_dir, "{}.fa".format(args.sample_name))
    params = [
        args.input_file,
        str(epitope_length - 1),
        output_file,
    ]
    if args.downstream_sequence_length is not None:
        params.extend(["-d", str(args.downstream_sequence_length)])
    else:
        params.extend(["-d", 'full'])
    tools.pvacfuse.generate_protein_fasta.main(params, save_tsv_file=True)
    os.unlink("{}.manufacturability.tsv".format(output_file))
    return (output_file, per_epitope_output_dir)

def append_columns(intermediate_output_file, tsv_file, output_file):
    tsv_entries = {}
    with open(tsv_file, 'r') as input_fh:
        reader = csv.DictReader(input_fh, delimiter="\t")
        for line in reader:
            tsv_entries[line['index']] = line

    with open(intermediate_output_file, 'r') as input_fh, open(output_file, 'w') as output_fh:
        reader = csv.DictReader(input_fh, delimiter="\t")
        fieldnames = ['Chromosome', 'Start', 'Stop', 'Transcript', 'Gene Name', 'Variant Type'] + reader.fieldnames
        writer = csv.DictWriter(output_fh, delimiter="\t", fieldnames=fieldnames)
        writer.writeheader()
        for line in reader:
            matching_line = tsv_entries[line['Mutation']]
            line['Chromosome'] = matching_line['chromosome_name']
            line['Start'] = matching_line['start']
            line['Stop'] = matching_line['stop']
            line['Transcript'] = matching_line['transcript_name']
            line['Gene Name'] = matching_line['gene_name']
            line['Variant Type'] = matching_line['variant_type']
            writer.writerow(line)

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

    if args.fasta_size%2 != 0:
        sys.exit("The fasta size needs to be an even number")

    if args.iedb_retries > 100:
        sys.exit("The number of IEDB retries must be less than or equal to 100")

    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'")


    base_output_dir = os.path.abspath(args.output_dir)

    (class_i_prediction_algorithms, class_ii_prediction_algorithms) = split_algorithms(args.prediction_algorithms)
    (class_i_alleles, class_ii_alleles, species) = split_alleles(args.allele)

    shared_arguments = {
        'input_file_type'           : 'fasta',
        'sample_name'               : args.sample_name,
        'top_score_metric'          : args.top_score_metric,
        'binding_threshold'         : args.binding_threshold,
        'percentile_threshold'      : args.percentile_threshold,
        'allele_specific_cutoffs'   : args.allele_specific_binding_thresholds,
        'net_chop_method'           : args.net_chop_method,
        'net_chop_threshold'        : args.net_chop_threshold,
        'additional_report_columns' : args.additional_report_columns,
        'fasta_size'                : args.fasta_size,
        'iedb_retries'              : args.iedb_retries,
        'downstream_sequence_length': downstream_sequence_length,
        'keep_tmp_files'            : args.keep_tmp_files,
        'n_threads'                 : args.n_threads,
        'species'                   : species,
        'run_reference_proteome_similarity': args.run_reference_proteome_similarity,
        'blastp_path'               : args.blastp_path,
        'blastp_db'                 : args.blastp_db,
        'run_post_processor'        : False
    }

    if args.iedb_install_directory:
        iedb_mhc_i_executable = os.path.join(args.iedb_install_directory, 'mhc_i', 'src', 'predict_binding.py')
        if not os.path.exists(iedb_mhc_i_executable):
            sys.exit("IEDB MHC I executable path doesn't exist %s" % iedb_mhc_i_executable)
        iedb_mhc_ii_executable = os.path.join(args.iedb_install_directory, 'mhc_ii', 'mhc_II_binding.py')
        if not os.path.exists(iedb_mhc_ii_executable):
            sys.exit("IEDB MHC II executable path doesn't exist %s" % iedb_mhc_ii_executable)
    else:
        iedb_mhc_i_executable = None
        iedb_mhc_ii_executable = None

    all_params = {
        'I': {
            'iedb_executable': iedb_mhc_i_executable,
            'prediction_algorithms': class_i_prediction_algorithms,
            'alleles': class_i_alleles,
            'epitope_lengths': args.class_i_epitope_length,
            'netmhc_stab': args.netmhc_stab
        },
        'II': {
            'iedb_executable': iedb_mhc_ii_executable,
            'prediction_algorithms': class_ii_prediction_algorithms,
            'alleles': class_ii_alleles,
            'epitope_lengths': args.class_ii_epitope_length,
            'netmhc_stab': False
        }
    }

    for (mhc_class, params) in all_params.items():
        prediction_algorithms = params['prediction_algorithms']
        alleles = params['alleles']
        epitope_lengths = params['epitope_lengths']

        if len(prediction_algorithms) > 0 and len(alleles) > 0:
            print("Executing MHC Class {} predictions".format(mhc_class))

            output_dir = os.path.join(base_output_dir, 'MHC_Class_{}'.format(mhc_class))
            os.makedirs(output_dir, exist_ok=True)

            output_files = []
            for epitope_length in epitope_lengths:
                (input_file, per_epitope_output_dir) = generate_fasta(args, output_dir, epitope_length)

                class_i_arguments = shared_arguments.copy()
                class_i_arguments['input_file']              = input_file
                class_i_arguments['alleles']                 = alleles
                class_i_arguments['iedb_executable']         = iedb_mhc_i_executable
                class_i_arguments['epitope_lengths']         = [epitope_length]
                class_i_arguments['prediction_algorithms']   = prediction_algorithms
                class_i_arguments['output_dir']              = per_epitope_output_dir
                class_i_arguments['netmhc_stab']             = params['netmhc_stab']
                pipeline = PvacbindPipeline(**class_i_arguments)
                pipeline.execute()
                intermediate_output_file = os.path.join(per_epitope_output_dir, "{}.all_epitopes.tsv".format(args.sample_name))
                output_file = os.path.join(per_epitope_output_dir, "{}.all_epitopes.final.tsv".format(args.sample_name))
                append_columns(intermediate_output_file, "{}.tsv".format(input_file), output_file)
                output_files.append(output_file)
                if epitope_length == max(epitope_lengths):
                    fasta_file = os.path.join(output_dir, "{}.fasta".format(args.sample_name))
                    shutil.copy(input_file, fasta_file)
            all_epitopes_file = os.path.join(output_dir, "{}.all_epitopes.tsv".format(args.sample_name))
            filtered_file = os.path.join(output_dir, "{}.filtered.tsv".format(args.sample_name))
            create_combined_reports(output_files, all_epitopes_file, filtered_file, True, args)
        elif len(prediction_algorithms) == 0:
            print("No MHC class {} prediction algorithms chosen. Skipping MHC class I predictions.".format(mhc_class))
        elif len(alleles) == 0:
            print("No MHC class{} alleles chosen. Skipping MHC class I predictions.".format(mhc_class))

    if len(class_i_prediction_algorithms) > 0 and len(class_i_alleles) > 0 and len(class_ii_prediction_algorithms) > 0 and len(class_ii_alleles) > 0:
        print("Creating combined reports")
        output_dir = os.path.join(base_output_dir, 'combined')
        os.makedirs(output_dir, exist_ok=True)
        file1 = os.path.join(base_output_dir, 'MHC_Class_I', "{}.all_epitopes.tsv".format(args.sample_name))
        file2 = os.path.join(base_output_dir, 'MHC_Class_II', "{}.all_epitopes.tsv".format(args.sample_name))
        combined_output_file = os.path.join(output_dir, "{}.all_epitopes.tsv".format(args.sample_name))
        filtered_report_file = os.path.join(output_dir, "{}.filtered.tsv".format(args.sample_name))
        create_combined_reports([file1, file2], combined_output_file, filtered_report_file, False, args)

    change_permissions_recursive(base_output_dir, 0o755, 0o644)

if __name__ == '__main__':
    main()

1	import sys	3✔
2	import argparse	3✔
3	import os	3✔
4	import shutil	3✔
5	from lib.prediction_class import *	3✔
6	from lib.pipeline import *	3✔
7	from lib.run_argument_parser import *	3✔
8	from lib.post_processor import *	3✔
9	from lib.run_utils import *	3✔
10	import tools.pvacfuse.generate_protein_fasta	3✔
11	import lib.call_iedb	3✔
12
13	def define_parser():	3✔
14	return PvacfuseRunArgumentParser().parser	3✔
15
16	def create_combined_reports(files, all_epitopes_output_file, filtered_report_file, run_manufacturability_metrics, args):	3✔
17	for file_name in files:	3✔
18	if not os.path.exists(file_name):	3✔
19	print("File {} doesn't exist. Aborting.".format(file_name))	×
20	return	×
21
22	combine_reports(files, all_epitopes_output_file)	3✔
23
24	post_processing_params = vars(args).copy()	3✔
25	post_processing_params['input_file'] = all_epitopes_output_file	3✔
26	post_processing_params['filtered_report_file'] = filtered_report_file	3✔
27	post_processing_params['minimum_fold_change'] = None	3✔
28	post_processing_params['run_coverage_filter'] = False	3✔
29	post_processing_params['run_transcript_support_level_filter'] = False	3✔
30	post_processing_params['run_net_chop'] = False	3✔
31	post_processing_params['run_netmhc_stab'] = False	3✔
32	post_processing_params['run_manufacturability_metrics'] = run_manufacturability_metrics	3✔
33	post_processing_params['run_reference_proteome_similarity'] = False	3✔
34	post_processing_params['file_type'] = 'pVACfuse'	3✔
35
36	PostProcessor(**post_processing_params).execute()	3✔
37
38	def generate_fasta(args, output_dir, epitope_length):	3✔
39	per_epitope_output_dir = os.path.join(output_dir, str(epitope_length))	3✔
40	os.makedirs(per_epitope_output_dir, exist_ok=True)	3✔
41	output_file = os.path.join(per_epitope_output_dir, "{}.fa".format(args.sample_name))	3✔
42	params = [	3✔
43	args.input_file,
44	str(epitope_length - 1),
45	output_file,
46	]
47	if args.downstream_sequence_length is not None:	3✔
48	params.extend(["-d", str(args.downstream_sequence_length)])	3✔
49	else:
50	params.extend(["-d", 'full'])	×
51	tools.pvacfuse.generate_protein_fasta.main(params, save_tsv_file=True)	3✔
52	os.unlink("{}.manufacturability.tsv".format(output_file))	3✔
53	return (output_file, per_epitope_output_dir)	3✔
54
55	def append_columns(intermediate_output_file, tsv_file, output_file):	3✔
56	tsv_entries = {}	3✔
57	with open(tsv_file, 'r') as input_fh:	3✔
58	reader = csv.DictReader(input_fh, delimiter="\t")	3✔
59	for line in reader:	3✔
60	tsv_entries[line['index']] = line	3✔
61
62	with open(intermediate_output_file, 'r') as input_fh, open(output_file, 'w') as output_fh:	3✔
63	reader = csv.DictReader(input_fh, delimiter="\t")	3✔
64	fieldnames = ['Chromosome', 'Start', 'Stop', 'Transcript', 'Gene Name', 'Variant Type'] + reader.fieldnames	3✔
65	writer = csv.DictWriter(output_fh, delimiter="\t", fieldnames=fieldnames)	3✔
66	writer.writeheader()	3✔
67	for line in reader:	3✔
68	matching_line = tsv_entries[line['Mutation']]	3✔
69	line['Chromosome'] = matching_line['chromosome_name']	3✔
70	line['Start'] = matching_line['start']	3✔
71	line['Stop'] = matching_line['stop']	3✔
72	line['Transcript'] = matching_line['transcript_name']	3✔
73	line['Gene Name'] = matching_line['gene_name']	3✔
74	line['Variant Type'] = matching_line['variant_type']	3✔
75	writer.writerow(line)	3✔
76
77	def main(args_input = sys.argv[1:]):	3✔
78	parser = define_parser()	3✔
79	args = parser.parse_args(args_input)	3✔
80
81	if args.fasta_size%2 != 0:	3✔
82	sys.exit("The fasta size needs to be an even number")	×
83
84	if args.iedb_retries > 100:	3✔
85	sys.exit("The number of IEDB retries must be less than or equal to 100")	×
86
87	if args.downstream_sequence_length == 'full':	3✔
88	downstream_sequence_length = None	×
89	elif args.downstream_sequence_length.isdigit():	3✔
90	downstream_sequence_length = int(args.downstream_sequence_length)	3✔
91	else:
92	sys.exit("The downstream sequence length needs to be a positive integer or 'full'")	×
93
94
95	base_output_dir = os.path.abspath(args.output_dir)	3✔
96
97	(class_i_prediction_algorithms, class_ii_prediction_algorithms) = split_algorithms(args.prediction_algorithms)	3✔
98	(class_i_alleles, class_ii_alleles, species) = split_alleles(args.allele)	3✔
99
100	shared_arguments = {	3✔
101	'input_file_type' : 'fasta',
102	'sample_name' : args.sample_name,
103	'top_score_metric' : args.top_score_metric,
104	'binding_threshold' : args.binding_threshold,
105	'percentile_threshold' : args.percentile_threshold,
106	'allele_specific_cutoffs' : args.allele_specific_binding_thresholds,
107	'net_chop_method' : args.net_chop_method,
108	'net_chop_threshold' : args.net_chop_threshold,
109	'additional_report_columns' : args.additional_report_columns,
110	'fasta_size' : args.fasta_size,
111	'iedb_retries' : args.iedb_retries,
112	'downstream_sequence_length': downstream_sequence_length,
113	'keep_tmp_files' : args.keep_tmp_files,
114	'n_threads' : args.n_threads,
115	'species' : species,
116	'run_reference_proteome_similarity': args.run_reference_proteome_similarity,
117	'blastp_path' : args.blastp_path,
118	'blastp_db' : args.blastp_db,
119	'run_post_processor' : False
120	}
121
122	if args.iedb_install_directory:	3✔
123	iedb_mhc_i_executable = os.path.join(args.iedb_install_directory, 'mhc_i', 'src', 'predict_binding.py')	×
124	if not os.path.exists(iedb_mhc_i_executable):	×
125	sys.exit("IEDB MHC I executable path doesn't exist %s" % iedb_mhc_i_executable)	×
126	iedb_mhc_ii_executable = os.path.join(args.iedb_install_directory, 'mhc_ii', 'mhc_II_binding.py')	×
127	if not os.path.exists(iedb_mhc_ii_executable):	×
128	sys.exit("IEDB MHC II executable path doesn't exist %s" % iedb_mhc_ii_executable)	×
129	else:
130	iedb_mhc_i_executable = None	3✔
131	iedb_mhc_ii_executable = None	3✔
132
133	all_params = {	3✔
134	'I': {
135	'iedb_executable': iedb_mhc_i_executable,
136	'prediction_algorithms': class_i_prediction_algorithms,
137	'alleles': class_i_alleles,
138	'epitope_lengths': args.class_i_epitope_length,
139	'netmhc_stab': args.netmhc_stab
140	},
141	'II': {
142	'iedb_executable': iedb_mhc_ii_executable,
143	'prediction_algorithms': class_ii_prediction_algorithms,
144	'alleles': class_ii_alleles,
145	'epitope_lengths': args.class_ii_epitope_length,
146	'netmhc_stab': False
147	}
148	}
149
150	for (mhc_class, params) in all_params.items():	3✔
151	prediction_algorithms = params['prediction_algorithms']	3✔
152	alleles = params['alleles']	3✔
153	epitope_lengths = params['epitope_lengths']	3✔
154
155	if len(prediction_algorithms) > 0 and len(alleles) > 0:	3✔
156	print("Executing MHC Class {} predictions".format(mhc_class))	3✔
157
158	output_dir = os.path.join(base_output_dir, 'MHC_Class_{}'.format(mhc_class))	3✔
159	os.makedirs(output_dir, exist_ok=True)	3✔
160
161	output_files = []	3✔
162	for epitope_length in epitope_lengths:	3✔
163	(input_file, per_epitope_output_dir) = generate_fasta(args, output_dir, epitope_length)	3✔
164
165	class_i_arguments = shared_arguments.copy()	3✔
166	class_i_arguments['input_file'] = input_file	3✔
167	class_i_arguments['alleles'] = alleles	3✔
168	class_i_arguments['iedb_executable'] = iedb_mhc_i_executable	3✔
169	class_i_arguments['epitope_lengths'] = [epitope_length]	3✔
170	class_i_arguments['prediction_algorithms'] = prediction_algorithms	3✔
171	class_i_arguments['output_dir'] = per_epitope_output_dir	3✔
172	class_i_arguments['netmhc_stab'] = params['netmhc_stab']	3✔
173	pipeline = PvacbindPipeline(**class_i_arguments)	3✔
174	pipeline.execute()	3✔
175	intermediate_output_file = os.path.join(per_epitope_output_dir, "{}.all_epitopes.tsv".format(args.sample_name))	3✔
176	output_file = os.path.join(per_epitope_output_dir, "{}.all_epitopes.final.tsv".format(args.sample_name))	3✔
177	append_columns(intermediate_output_file, "{}.tsv".format(input_file), output_file)	3✔
178	output_files.append(output_file)	3✔
179	if epitope_length == max(epitope_lengths):	3✔
180	fasta_file = os.path.join(output_dir, "{}.fasta".format(args.sample_name))	3✔
181	shutil.copy(input_file, fasta_file)	3✔
182	all_epitopes_file = os.path.join(output_dir, "{}.all_epitopes.tsv".format(args.sample_name))	3✔
183	filtered_file = os.path.join(output_dir, "{}.filtered.tsv".format(args.sample_name))	3✔
184	create_combined_reports(output_files, all_epitopes_file, filtered_file, True, args)	3✔
185	elif len(prediction_algorithms) == 0:	3✔
186	print("No MHC class {} prediction algorithms chosen. Skipping MHC class I predictions.".format(mhc_class))	3✔
187	elif len(alleles) == 0:	×
188	print("No MHC class{} alleles chosen. Skipping MHC class I predictions.".format(mhc_class))	×
189
190	if len(class_i_prediction_algorithms) > 0 and len(class_i_alleles) > 0 and len(class_ii_prediction_algorithms) > 0 and len(class_ii_alleles) > 0:	3✔
191	print("Creating combined reports")	3✔
192	output_dir = os.path.join(base_output_dir, 'combined')	3✔
193	os.makedirs(output_dir, exist_ok=True)	3✔
194	file1 = os.path.join(base_output_dir, 'MHC_Class_I', "{}.all_epitopes.tsv".format(args.sample_name))	3✔
195	file2 = os.path.join(base_output_dir, 'MHC_Class_II', "{}.all_epitopes.tsv".format(args.sample_name))	3✔
196	combined_output_file = os.path.join(output_dir, "{}.all_epitopes.tsv".format(args.sample_name))	3✔
197	filtered_report_file = os.path.join(output_dir, "{}.filtered.tsv".format(args.sample_name))	3✔
198	create_combined_reports([file1, file2], combined_output_file, filtered_report_file, False, args)	3✔
199
200	change_permissions_recursive(base_output_dir, 0o755, 0o644)	3✔
201
202	if __name__ == '__main__':	3✔
203	main()	×

griffithlab / pVACtools / 1136043958

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