#!/usr/bin/env python

import sys

import csv

import cPickle as pickle

import networkx as nx

from sets import Set

import time

import operator

import argparse

from collections import OrderedDict

import copy

from operator import mul

import os

EXT_GZ = "gz"

SUFFIX_GZ = os.extsep + EXT_GZ

from contextlib import closing, contextmanager

from gzip import open as _gzip_open

def gzip_open(*args, **kwargs):

return _gzip_open(*args, **kwargs)

def maybe_gzip_open(filename, *args, **kwargs):

return open(filename, *args, **kwargs)

import gc

gc.disable()

parser = argparse.ArgumentParser(description='Formats the CNVs into an Arff. Anotates the CNVs/genes with go terms.')

parser.add_argument('gene_network_file', help="Gene-gene iteractions file.")

parser.add_argument('gene2go', help="Mapping between genes and go terms.")

parser.add_argument('case_control_gff', help="CNVs annotated with genes.")

parser.add_argument('weka_header_file', help="Output file. The weka header.")

parser.add_argument('go_slim_file', help="Mapping from go to go slim.")

parser.add_argument('evidence_code_filter_level', type=int, choices=[0,1,2,-1], \

help="0: no filter, n: tier filter, -1: modify weights")

parser.add_argument('filter_go_slim', choices=['y','n'], help="Toggle using go or go slim.")

parser.add_argument('take_top_x_neighbours', type=int, help=("Number of neighbours to use."))

parser.add_argument('neighbour_weight_function', help=\

"Function to modify the feature weights.")

parser.add_argument('go_and_ensg_to_hpo_file', help="Mapping between GO/genes/HPO.")

parser.add_argument('dijkstra_distance_cutoff', type=int, help="Max gene network distance.")

parser.add_argument('output_file', help="Output file. Weka body.")

parser.add_argument('--go_terms_for_sim', '-g', \

help="Output go terms for similarity processing.", action='store_true')

args = parser.parse_args()

totalstart = time.clock()

start = time.clock()

TIER_X_GO_FILTER = \

'IGC', 'RCA', 'IBA', 'IBD', 'IKR', 'IRD', 'TAS', 'IC', 'IEA'})])

RESERVED_FIELD_NUM = 7

if args.neighbour_weight_function == "0":

anwf = "1"

else:

anwf = args.neighbour_weight_function

fn_str = 'lambda x: %s' % anwf

print fn_str

NEIGHBOUR_WEIGHT_FUNCTION = eval(fn_str)

output_file = _gzip_open(args.output_file, 'w')

def timer(s):

sys.stdout.flush()

def load_gene_net():

return gene_net

def load_gene2go():

return gene2go

def load_go_slim_filter(RESERVED_FIELD_NUM):

return go_slim_filter, all_go_dict, attribute_num

def load_ensg_to_hpo_file(f_name):

return ensg_to_hpo_dict

def add_go_and_parents(go_slim_filter, go_names, go_name, evidence_code_weight):

return go_names

def inv_log(x):

return 1/float(10**x)

def set_go_names(gene2go, gene_name, go_slim_filter):

return go_names

def update_genes_and_go(gene_name, go_names, all_go_dict, attribute_num, current_genes, \

return current_genes, current_go_dict, all_go_dict, attribute_num

def add_gene(go_slim_filter, gene2go, gene_name, current_genes, current_go_dict, all_go_dict, \

return current_genes, current_go_dict, all_go_dict, attribute_num, current_gene_weights

def add_multiple(gene_name, gene_net, current_genes, gene2go, current_go_dict, all_go_dict, \

return current_genes, current_go_dict, all_go_dict, attribute_num

def set_printList(print_dict):

return printList

def set_annotation_hpo_set(current_gene_list, ensg_to_hpo_dict):

return annotation_hpo_set

def set_go_output_line(current_gene_list, gene2go):

return go_output_line

def output_line(print_dict, size, extras, col_dict, dup, phenotype_list, current_go_dict, \

print >> output_file, to_output_line

def update_phenotypes(phenotypes):

return phenotype_list, dup, phenotype

def update_hpo(phenotype_list, all_hpo_dict, attribute_num, print_dict):

return all_hpo_dict, attribute_num, print_dict

def update_info_lists(gene_id, original_gene, gene_list,

return info_lists_cnv, info_lists_original_gene, info_lists_each_gene

def update_weights(go_id, go_count, all_go_dict, each_gene_dict, \

return each_gene_dict, original_gene_dict, print_dict, go_count_s

def start_current_genes_loop(base_dict, total_genes):

original_gene_dict, total_genes, use_this_gene

def init_calc_weights(print_dict):

return base_dict, used_genes, total_genes, info_lists_cnv, num_go_cnv, sum_go_cnv

def exit_current_genes_loop(use_this_gene, num_go_gene, sum_go_gene, \

return used_genes, original_gene_dict

def current_genes_loop(original_gene_list, base_dict, use_this_gene, info_lists_cnv, \

num_go_cnv, num_go_gene, sum_go_cnv, sum_go_gene

def calc_weights(current_genes, print_dict, size, extras, col_dict, dup, phenotype_list, \

current_go_dict, ensg_to_hpo_dict, info_lists_original_gene, '#')

def process_cnv(col_dict, phenotype_set, current_go_dict, all_go_dict, current_genes, \

return attribute_num

def first_init():

return gff_header, phenotype_set, last_col_dict, all_hpo_dict

def initialize_vars():

return current_genes, current_go_dict, current_gene_weights

def print_weka_body(gene_net, gene2go, go_slim_filter, all_go_dict, attribute_num, \

return all_go_dict, phenotype_set, all_hpo_dict

def print_weka_header(all_go_dict, phenotype_set, all_hpo_dict):

header_file.close()

timer('Loading gene network')

gene_net = load_gene_net()

timer('Loading genes to GO')

gene2go = load_gene2go()

timer('Loading go slim filter')

go_slim_filter, all_go_dict, attribute_num = load_go_slim_filter(RESERVED_FIELD_NUM)

timer('Load ensg_to_hpo_dict')

ensg_to_hpo_dict = load_ensg_to_hpo_file(args.go_and_ensg_to_hpo_file)

timer('Print weka body')

all_go_dict, phenotype_set, all_hpo_dict = \

print_weka_body(gene_net, gene2go, go_slim_filter, all_go_dict, \

attribute_num, ensg_to_hpo_dict)

timer('Print weka header')

print_weka_header(all_go_dict, phenotype_set, all_hpo_dict)

timer('Done')