#!/usr/bin/env python

import sys

import argparse

import math

from collections import OrderedDict

import json

from random import choice

import random

import copy

import os

import cPickle as pickle

import re

from gzip import open as _gzip_open

import doctest

def enum(cls):

return [t for t in dir(cls) if (not t.startswith('__')) and (not t.endswith('__'))]

class Bset:

bt_cnv, bt_patient = range(2)

class Rset:

no, new, last = range(3)

parser = argparse.ArgumentParser(description='Description.')

parser.add_argument('in_gene_file', help="Arff body file of genes.")

parser.add_argument('iteration', type=int, help="Number of iterations to run.")

parser.add_argument('out_file', help="Randomized output arff file of genes.")

parser.add_argument('header_file', help="Arff header file.")

parser.add_argument('balance_test', choices=enum(Bset), help="bt_cnv for balanced, bt_patient for unbalanced.")

parser.add_argument('num_sets', type=int, help="Number of sets to split the data into [x-fold].")

parser.add_argument('add_remaining', choices=enum(Rset), \

help="no for do not use the leftover data for another set, new for creating another set for leftover data, last for adding the remaining data to the last set")

parser.add_argument('weighted_gene_duplication', choices=['sim', 'uniform'], \

help="sim for using the similarity scores to weigh the instances, uniform for uniform weighting")

parser.add_argument('--balance_genes', '-b', action='store_true', help="Set to balance the genes between benign and harmful.")

parser.add_argument('--debug', '-d', action='store_true', help="Set to output debugging infomation.")

args = parser.parse_args()

def expand_info_dict(info_dict):

return clone_dict

def query_info_dict(info_dict):

return counts

def test_one_phenotype_info_dict(info_dict):

print len(cnv_val)

# number of cnvs for a phenotype for benign/harmful

def num_per_phenotype(info_dict, phenotype_id, case_control_id):

return sum([len(v[case_control_id].values()) if case_control_id in v else 0 for k,v in info_dict[phenotype_id].iteritems()])

# number of cnvs for a phenotype for a patient for benign/harmful

def num_per_patient(info_dict, phenotype_id, patient_id, case_control_id):

if case_control_id in info_dict[phenotype_id][patient_id]:

return sum([len(v) for v in info_dict[phenotype_id][patient_id][case_control_id].values()])

return 0

# does a particualr patient have both a harmful and a benign cnv?

def single_patient_per_phenotype_w_at_least_1_benign_and_1_harmful(info_dict, phenotype_id, patient_id):

return (num_per_patient(info_dict, phenotype_id, patient_id, 'BENIGN') > 0) and \

(num_per_patient(info_dict, phenotype_id, patient_id, 'HARMFUL') > 0)

# return the number of patients with at least 1 benign and 1 harmful cnv

# def num_patient_per_phenotype_w_at_least_1_benign_and_1_harmful(info_dict, phenotype_id, at_least):

# return [single_patient_per_phenotype_w_at_least_1_benign_and_1_harmful(info_dict, phenotype_id, patient_id) \

# for patient_id in info_dict[phenotype_id].keys()].count(True) >= at_least

# return the patients with at least 1 benign and 1 harmful cnv

def ids_patient_per_phenotype_w_at_least_1_benign_and_1_harmful(info_dict, phenotype_id):

return [patient_id \

for patient_id in info_dict[phenotype_id].keys() \

if single_patient_per_phenotype_w_at_least_1_benign_and_1_harmful(info_dict, phenotype_id, patient_id)]

# add a patient to cnv_ret

def add_patient(cnv_ret, info_dict, phenotype_id, patient_id, train_test):

return cnv_ret, info_dict

# add a cnv to cnv_ret

def add_cnv(cnv_ret, info_dict, phenotype_id, case_control_id, total_set_id):

return cnv_ret, info_dict, total_set_id

# add remaining patients/cnvs to the test set

def add_remaining_fn(cnv_ret, info_dict, phenotype_id, remaining_set):

return cnv_ret, info_dict

def fill_out_set(num_sets, fill):

return dict([[sk, copy.deepcopy(fill)] for sk in range(num_sets)])

# generate train/test sets to output

def create_out_genes(cnv_ret, balance_genes, num_sets, balance_cnvs):

return out_genes

def is_cnv_ret_full(cnv_ret):

return ret

def random_info_dict(info_dict, balance_test, num_sets):

return None, {}, {}

print args.balance_test

def random_out(iteration, info_dict, num_sets):

sys.stdout.flush()

in_gene_file = open(args.in_gene_file, 'r')

info_dict = pickle.loads(in_gene_file.read())

in_gene_file.close()

for iteration in range(1, args.iteration + 1):

random_out(iteration, info_dict, args.num_sets)

doctest.testmod()