def main(args):
    with file('arena.json', 'rb') as json_f:
        config = json.load(json_f)
    svc_list = config['services']
    cns_list = config['consumers']
    sts_list = config['suites']
    if len(args) < 2:
        exit_errmsg(USAGE.format(progname=args[0],
			services=usage_format(svc_list),
            consumers=usage_format(cns_list),
            suites=usage_format(sts_list)))
    else:
        tst = Tester()
        if args[1] == 'test':
            svc_name, cns_name = args[2:4]
            tst.test_pair(resolve(svc_list, svc_name, 'service'),
                    resolve(cns_list, cns_name, 'consumer'))
        elif args[1] == 'clean':
            tst.clean(config[args[2] + 's'][args[3]])
        elif args[1] == 'measure':
            if len(args) < 3:
                suites = sts_list.itervalues()
            else:
                suites = [resolve(sts_list, args[2], 'suite')]
            if len(args) < 4:
                repeats = config['measurement']['repeats']
            else:
                repeats = [int(args[3])]
            if len(args) < 5:
                runs = config['measurement']['runs']
            else:
                runs = int(args[4])
            measure(suites, repeats, runs, svc_list, cns_list)
        else:
            exit_errmsg('Invalid command: "{0}"'.format(args[1]))

def main(config):
    prepare_dirs_and_logger(config)
    save_config(config)

    if config.is_train:
        from trainer import Trainer
        if config.dataset == 'line':
            from data_line import BatchManager
        elif config.dataset == 'ch':
            from data_ch import BatchManager
        elif config.dataset == 'kanji':
            from data_kanji import BatchManager
        elif config.dataset == 'baseball' or\
             config.dataset == 'cat':
            from data_qdraw import BatchManager

        batch_manager = BatchManager(config)
        trainer = Trainer(config, batch_manager)
        trainer.train()
    else:
        from tester import Tester
        if config.dataset == 'line':
            from data_line import BatchManager
        elif config.dataset == 'ch':
            from data_ch import BatchManager
        elif config.dataset == 'kanji':
            from data_kanji import BatchManager
        elif config.dataset == 'baseball' or\
             config.dataset == 'cat':
            from data_qdraw import BatchManager
        
        batch_manager = BatchManager(config)
        tester = Tester(config, batch_manager)
        tester.test()

def cmd_test(args, auth, cookies):
	if args.commonwords is not None:
		words = list()
		for word in args.commonwords:
			word = word.rstrip("\n")
			if word:
				words.append(word)
		args.commonwords.close()
	else:
		words = []

	sensitive_data, vectors = [], []
	for sensitive in args.sensitive:
		sensitive = sensitive.rstrip("\n")
		if sensitive:
			sensitive_data.append(sensitive)
	args.sensitive.close()

	for v in args.vectors:
		v = v.rstrip("\n")
		if v:
			vectors.append(v)
	args.vectors.close()

	crawler = Site(words, args.blacklist)
	crawler.crawl(args.url, auth, cookies)

	fuzzer = Tester(crawler, sensitive_data, vectors, args.slow, args.random)
	if args.random:
		fuzzer.run_random()
	else:
		fuzzer.run()

def test_two_A_responses():
    qname = "dualstack.mc-12555-1019789594.us-east-1.elb.amazonaws.com."
    T = Tester()
    T.newtest(testname="py.test")
    response = dbdns.query(T, qname, dns.rdatatype.A)
    count = 0
    for rrset in response.answer:
        for rr in rrset:
            if rr.rdtype == dns.rdatatype.A:
                print("IP address for {} is {}".format(qname, rr.address))
                count += 1
    assert count >= 2

def test_a_read():
    qname = "google-public-dns-a.google.com."
    T = Tester()
    T.newtest(testname="py.test")
    response = dbdns.query(T, qname, dns.rdatatype.A)
    count = 0
    for rrset in response.answer:
        for rr in rrset:
            if rr.rdtype == dns.rdatatype.A:
                print("IP addr for {} is {}".format(qname, rr.address))
                assert rr.address == "8.8.8.8"
                count += 1
    assert count > 0

def test_read_tlsa():
    """Verify that a TLSA record can be read"""
    qname = "_443._tcp.good.dane.verisignlabs.com"
    T = Tester()
    T.newtest(testname="py.test")
    response = dbdns.query(T, qname, dns.rdatatype.TLSA)
    count = 0
    for rrset in response.answer:
        for rr in rrset:
            if rr.rdtype == dns.rdatatype.TLSA:
                print("{}: {} {} {} {}".format(qname, rr.usage, rr.selector, rr.mtype, hexdump(rr.cert)))
                count += 1
    assert count > 0

def test_dnssec_response_notpresent():
    qname = "www.google.com"
    T = Tester()
    T.newtest(testname="py.test")
    response = dbdns.query(T, qname, dns.rdatatype.A)
    count = 0
    for rrset in response.answer:
        for rr in rrset:
            if rr.rdtype == dns.rdatatype.A:
                dnssec = response.flags & dns.flags.AD
                print("IP address for {} is {} DNSSEC: {}".format(qname, rr.address, dnssec))
                if dnssec:
                    count += 1
    assert count == 0

def test_cname_read():
    # This test makes use of the fact that a.nitroba.org is set as a cname to b.nitroba.org
    qname = "a.nitroba.org"
    T = Tester()
    T.newtest(testname="py.test")
    response = dbdns.query(T, qname, dns.rdatatype.CNAME)
    count = 0
    for rset in response.answer:
        for rr in rset:
            if rr.rdtype == dns.rdatatype.CNAME:
                print("cname for a.nitroba.org is {}".format(rr.target))
                assert str(rr.target) == "b.nitroba.org."
                count += 1
    assert count > 0  # no response?

 def __init__(self, vc, opts):
     self.vc = vc
     ret,im = vc.read()
     self.numGestures = opts.num
     self.imHeight,self.imWidth,self.channels = im.shape
     self.trainer = Trainer(numGestures=opts.num, numFramesPerGesture=opts.frames, minDescriptorsPerFrame=opts.desc, numWords=opts.words, descType=opts.type, kernel=opts.kernel, numIter=opts.iter, parent=self)
     self.tester = Tester(numGestures=opts.num, minDescriptorsPerFrame=opts.desc, numWords=opts.words, descType=opts.type, numPredictions=7, parent=self)

def train_and_test(image_loader, feature_extractor):
    """
    Simple implementation of train and test function
    :param image_loader:
    :param feature_extractor:
    """
    first_class_train_data, first_class_test_data = get_train_and_test_data(params.first_class_params)
    second_class_train_data, second_class_test_data = get_train_and_test_data(params.second_class_params)

    train_data = list(first_class_train_data) + list(second_class_train_data)
    random.shuffle(train_data)
    trainer = Trainer(image_loader, feature_extractor)
    solve_container = trainer.train(train_data, params.svm_params)

    test_data = list(first_class_test_data) + list(second_class_test_data)
    tester = Tester(image_loader, solve_container)
    return tester.test(test_data)

def measure(suites, repeats, runs, svc_list, cns_list):
    filebase = datetime.now().strftime(FILE_FORMAT)
    log = LogFile(filebase)
    csv = path.join(getcwd(), filebase + CSV_SUFFIX)
    with file(csv, 'w') as f:
        f.write('Service;Consumer;Repeats;Suite;Initialization;Invocation')
    for suite, repeat, (svc_name, service), (cns_name, consumer), num in product(
            suites, repeats, svc_list.iteritems(), cns_list.iteritems(), xrange(runs)):
        log.log('{0} using {1} -({2}x)-> {3}, try {4}'.format(
            suite['title'], cns_name, repeat, svc_name, num + 1))
        tst = Tester()
        env = dict(TIMES=str(repeat), CSV_FILE=csv, CSV_PREFIX=';'.join(
            (svc_name, cns_name, str(repeat), suite['title'])))
        for i in suite['env']:
            env[i] = '1'
        tst.extend_env(env)
        tst.test_pair(service, consumer)

def run_training(difficulty, algorithm, output_name):
	genotype, haplotype = get_training_file_paths(difficulty)
	if algorithm == 'greedy':
		g = Greedy(genotype)
		t = Tester(g, haplotype, genotype, output_name)
		t.run_analysis()
	elif algorithm == 'optimal':
		o = Optimal(genotype)
		t = Tester(o, haplotype, genotype, output_name)
		t.run_analysis()
	elif algorithm == 'exhaustive':
		e = Exhaustive(genotype)
		t = Tester(e, haplotype, genotype, output_name)
		t.run_analysis()

def run_test(difficulty, algorithm, output_name):
	genotype = get_test_data_path(difficulty)
	if algorithm == 'greedy':
		g = Greedy(genotype)
		t = Tester(g, None, genotype, output_name)
		t.run_analysis()
	elif algorithm == 'optimal':
		o = Optimal(genotype)
		t = Tester(o, None, genotype, output_name)
		t.run_analysis()
	elif algorithm == 'exhaustive':
		e = Exhaustive(genotype)
		t = Tester(e, None, genotype, output_name)
		t.run_analysis()

	def __init__(self, solution, case):
		self.solution = solution
		self.current_mattes = sum([int(x) for x in solution])
		self.case = case
		self.tester = Tester()
		self.valid_solution = False
		self.steps = 0
		self.METHODS = {
			'random_optimizer': self.random_optimizer,
			'matte_minimizer': self.matte_minimizer
		}

def periodic():
    from tester import Tester

    import argparse

    parser = argparse.ArgumentParser(description="database maintenance")
    parser.add_argument("--debug", action="store_true")
    parser.add_argument("--list", help="List all of the tasks", action="store_true")
    args = parser.parse_args()

    W = Tester()  # get a database connection
    c = W.conn.cursor()

    if args.list:
        c.execute("select workqueueid,testid,created,completed from workqueue")
        for line in c:
            print(line)
        exit(0)

    # Run the queue until there is nothing left to run
    while True:
        c.execute("select workqueueid,testid,task,args from workqueue where isnull(completed)")
        count = 0
        for (workqueueid, testid, task, task_args_str) in c.fetchall():
            count += 1
            T = Tester(testid=testid)
            task_args = json.loads(task_args_str)
            if args.debug or debug:
                print("task_args=", task_args)
                task_args["state"] = "WORKING"
            logging.info("testid={} task={} task_args={}".format(testid, task, task_args))
            if eval(task + "(T,task_args)"):
                c.execute("update workqueue set completed=now() where workqueueid=%s", (workqueueid,))
                W.commit()
        if count == 0:
            break

def main():
    f = open('try_3.txt','w')
    g = open('accs.txt', 'w')
    g.close()
    task = MarioTask("testbed", initMarioMode = 2)
    task.env.initMarioMode = 2
    task.env.levelDifficulty = 1

    results = [] 
    names = [] 

    
    iterations = 50
    rounds = 15
     
    agent = Supervise(IT,useKMM = False)
    exp = EpisodicExperiment(task, agent) 
    T = Tester(agent,exp)
    sl_data, sup_data, acc = T.test(rounds = rounds, iterations = iterations)

    np.save('./data/sup_data.npy', sup_data)
    np.save('./data/sl_data.npy', sl_data)
    np.save('./data/acc.npy', acc)    
    
    IPython.embed()

    analysis = Analysis()
    analysis.get_perf(sup_data, range(iterations))
    analysis.get_perf(sl_data, range(iterations))
    analysis.plot(names=['Supervisor', 'Supervised Learning'], label='Reward', filename='./results/return_plots.eps')#, ylims=[0, 1600])

    acc_a = Analysis()
    acc_a.get_perf(acc, range(iterations))
    acc_a.plot(names=['Supervised Learning Acc.'], label='Accuracy', filename='./results/acc_plots.eps')

    print "finished"

class Recognizer(object):
    def __init__(self, vc, opts):
        self.vc = vc
        ret,im = vc.read()
        self.numGestures = opts.num
        self.imHeight,self.imWidth,self.channels = im.shape
        self.trainer = Trainer(numGestures=opts.num, numFramesPerGesture=opts.frames, minDescriptorsPerFrame=opts.desc, numWords=opts.words, descType=opts.type, kernel=opts.kernel, numIter=opts.iter, parent=self)
        self.tester = Tester(numGestures=opts.num, minDescriptorsPerFrame=opts.desc, numWords=opts.words, descType=opts.type, numPredictions=7, parent=self)

    def train_from_video(self):
        self.trainer.extract_descriptors_from_video()
        variance = self.trainer.kmeans()
        self.trainer.bow()
        score = self.trainer.svm()
        return score

    def train_from_descriptors(self, desList, trainLabels):
        self.trainer.desList = desList
        self.trainer.trainLabels = trainLabels
        #numFramesPerGesture = trainLabels.count(1)
        #self.trainer.desList = desList[:numFramesPerGesture*self.numGestures]
        #self.trainer.trainLabels = trainLabels[:numFramesPerGesture*self.numGestures]

        variance = self.trainer.kmeans()
        self.trainer.bow()
        score = self.trainer.svm()
        return score

    def train_from_images(self, gestureDirList, parentDirPath, trainMask, maskParentDirPath):
        self.trainer.extract_descriptors_from_images(gestureDirList, parentDirPath, trainMask, maskParentDirPath)
        variance = self.trainer.kmeans()
        self.trainer.bow()
        score = self.trainer.svm()
        return score

    def test_on_video(self, clf):
        #print clf.coef_
        self.tester.initialize(clf)
        self.tester.test_on_video()
    
    def test_on_descriptors(self, clf, descList, trueLabels):
        #numFramesPerGesture = trueLabels.count(1)
        #descList = descList[:numFramesPerGesture*self.numGestures]
        #trueLabels = trueLabels[:numFramesPerGesture*self.numGestures]
        self.tester.initialize(clf)
        testLabels = self.tester.test_on_descriptors(descList)
        matchList = [i for i, j in zip(trueLabels, testLabels) if i == j]
        score = float(len(matchList))/len(trueLabels)
        return score

import subprocess
import sys
sys.path.insert(0, "../")
from tester import Tester
t = Tester()
##

# from task import parseLine

## write tests here --

# part 1

# part 2

## -- end of tests

def askYesNo(question):
	print(question + " [y/n]")
	yes = set(['yes','y', 'ye', ''])
	no = set(['no','n'])	
	while True:
		choice = raw_input().lower()
		if choice in yes:
			return True
		elif choice in no:
			return False
		else:
			print("Answer with 'y' (yes) or 'n' (no).")

ARGUMENTS = [ ]

def main():
    f = open('try_3.txt','w')
    g = open('accs.txt', 'w')
    g.close()
    task = MarioTask("testbed", initMarioMode = 2)
    task.env.initMarioMode = 2
    task.env.levelDifficulty = 1

    results = [] 
    names = [] 
    
    with open('type.txt', 'w') as f:
        f.write('dt')
    
    iterations = 20
    rounds = 30
    learning_samples = 33
    eval_samples = 10

    # iterations = 5
    # rounds = 2
    # learning_samples = 3
    # eval_samples = 2

    agent = Dagger(IT,useKMM = False)

    if args['linear']:
        agent.learner.linear = True
        prefix = 'svc-dagger-change-'
    else:
        agent.learner.linear = False
        prefix = 'dt-dagger-change-'

    exp = EpisodicExperiment(task, agent) 
    T = Tester(agent,exp)
    dagger_data, _, acc, loss, js, test_acc = T.test(rounds = rounds, iterations = iterations,
         learning_samples = learning_samples, eval_samples = eval_samples, prefix = prefix)

    np.save('./data/' + prefix + 'dagger_data.npy', dagger_data)
    np.save('./data/' + prefix + 'acc.npy', acc)    
    np.save('./data/' + prefix + 'loss.npy', loss)
    np.save('./data/' + prefix + 'js.npy', js)
    np.save('./data/' + prefix + 'test_acc.npy', test_acc)
    
    analysis = Analysis()
    analysis.get_perf(dagger_data, range(iterations))
    analysis.plot(names=['DAgger'], label='Reward', filename='./results/' + prefix + 'return_plots.eps')

    acc_a = Analysis()
    acc_a.get_perf(acc, range(iterations))
    acc_a.plot(names=['DAgger Acc.'], label='Accuracy', filename='./results/' + prefix + 'acc_plots.eps', ylims=[0,1])

    test_acc_a = Analysis()
    test_acc_a.get_perf(test_acc, range(iterations))
    test_acc_a.plot(names=['DAgger Acc.'], label='Test Accuracy', filename='./results/' + prefix + 'test_acc_plots.eps', ylims=[0, 1])

    loss_a = Analysis()
    loss_a.get_perf(loss, range(iterations))
    loss_a.plot(names=['DAgger Loss'], label='Loss', filename='./results/' + prefix + 'loss_plots.eps', ylims=[0, 1])

    js_a = Analysis()
    js_a.get_perf(js, range(iterations))
    js_a.plot(names=['DAgger'], label='J()', filename='./results/' + prefix + '-js_plots.eps')

    
    print "finished"

__author__ = 'semyon'

from connector import Connector
from tester import Tester

connector = Connector("pythonroot", "test", "localhost", "mlt", {"spam": "spam", "ham": "ham"})
#connector.put_data("asd", True)
tester = Tester(connector)
tester.test_message("Qwerty asd")