def main(process_id):
lims = Lims(config.BASEURI, config.USERNAME, config.PASSWORD)
process = Process(lims, id=process_id)
outputs = process.all_outputs(unique=True)
data = [["Sample", "Container", "Well", "Index"]]
for o in sorted((o for o in outputs if o.type == "Analyte"),
key=lambda x: (x.location[0].name, x.location[1][::-1])):
data.append([
o.name, o.location[0].name, o.location[1],
next(iter(o.reagent_labels))
])
printtable.print_table("Indexes for project " + o.samples[0].project.name,
data)
def note(arguments):
task = tasks[arguments['<id>']]
if task:
task.notes = task.notes or []
if arguments['<note>']:
#actualnotes = task.notes or []
task.update_record(notes=task.notes + [arguments['<note>']])
db.commit()
if arguments['--rm']:
try:
del task.notes[int(arguments['--rm'])]
task.update_record(notes=task.notes)
except:
print REDBOLD("Note not found")
else:
db.commit()
lenmax = max([len(note) for note in task.notes ]) if task.notes else 20
out = "+----" + "-" * lenmax + "-----+"
headers = [HEAD(s) for s in ['ID','Name','Tag','Status','Reminder','Created']]
fields = [ID(str(task.id)),
NAME(str(task.name)),
TAG(str(task.tag)),
STATUS(str(task.status)),
str(task.reminder),
str(task.created_on.strftime("%d/%m-%H:%M"))]
print_table([headers, fields])
if task.notes:
print HEAD("NOTES:")
print out
cprint("\n".join( [ ID(str(i)) + " " + NOTE(note, i) for i, note in enumerate(task.notes)] ), 'blue', attrs=['bold'])
out += FOOTER("\n%s notes" % len(task.notes))
return out
else:
return ""
else:
return FOOTER("Task not found")
def ls(arguments):
# --all
#tag=None, search=None, date=None,
#month=None, day=None, year=None
query = tasks.deleted != True
query &= tasks.status != 'done' if not arguments['--all'] and not arguments['--status'] else tasks.id > 0
if arguments['--tag']:
query &= tasks.tag == arguments['--tag']
if arguments['--status']:
query &= tasks.status == arguments['--status']
if arguments['--search']:
query &= tasks.name.like('%%%s%%' % arguments['--search'].lower())
rows = db(query).select()
headers = [HEAD(s) for s in ['ID','Name','Tag','Status','Reminder','Notes','Created']]
#if arguments['--n']:
#headers.append('Notes')
table = [headers]
for row in rows:
fields = [ID(str(row.id)),
NAME(str(row.name)),
TAG(str(row.tag)),
STATUS(str(row.status)),
str(row.reminder),
str(len(row.notes) if row.notes else 0),
str(row.created_on.strftime("%d/%m-%H:%M"))]
#if arguments['--n']:
#fields.append(str( '\n'.join(row.notes) ))
table.append(fields)
#pprint_table(sys.stdout, table)
print_table(table)
return FOOTER("TOTAL:%s tasks" % len(rows) if rows else "NO TASKS FOUND\nUse --help to see the usage tips")
def test_strats(self):
'''Tests all of the strats against each other
'''
NUMBER_OF_TRIALS = 100000
results = {}
old_strat_combos = [x for x in itertools.product(VALID_STRATEGIES,repeat=2)]
strat_combos = []
for combo in old_strat_combos:
if combo[::-1] not in strat_combos:
strat_combos.append(combo)
for strat1,strat2 in strat_combos:
self.p1 = ComputerPlayer(name='Computer1',strat=strat1)
self.p2 = ComputerPlayer(name='Computer2',strat=strat2)
results[(strat1,strat2)] = {'number of trials':NUMBER_OF_TRIALS,'p1 results':[],'p2 results':[],'number of best outcomes':0,'number of p1 worst outcomes':0,'number of p2 worst outcomes':0,'number of average outcomes':0,'number of bad outcomes':0}
#Get results
for i in range(NUMBER_OF_TRIALS):
key = (strat1,strat2)
p1_sentence,p2_sentence = self.play(do_cls=False)
results[key]['p1 results'].append((p1_sentence))
results[key]['p2 results'].append((p2_sentence))
if p1_sentence == P and p2_sentence == P: #both players stay silent
results[key]['number of best outcomes'] += 1
if p1_sentence == R and p2_sentence == R: #both players defected
results[key]['number of average outcomes'] += 1
if p1_sentence == T:
results[key]['number of p1 worst outcomes'] += 1
results[key]['number of bad outcomes'] += 1
if p2_sentence == T:
results[key]['number of p2 worst outcomes'] += 1
results[key]['number of bad outcomes'] += 1
#Process Results
for s1,s2 in results.keys():
key = (s1,s2)
#get average p1 sentence
results[key]['p1 average sentence'] = sum(results[key]['p1 results'])/float(len(results[key]['p1 results']))
#get average p2 sentence
results[key]['p2 average sentence'] = sum(results[key]['p2 results'])/float(len(results[key]['p2 results']))
#Get the sentence lengths for each strat
sentences_for_strat = {} #{strat:[your_total_sentence_for_using_strat,number_of_trials,other_players_total_sentence_for_competing_against_strat}
for strat in VALID_STRATEGIES:
your_total_sentence = 0
trials = 0
other_total_sentence = 0
for s1,s2 in results.keys():
key = (s1,s2)
if s1 != s2:
if s1 == strat:
your_total_sentence += sum(results[key]['p1 results'])
other_total_sentence += sum(results[key]['p2 results'])
trials += results[key]['number of trials']
elif s2 == strat:
your_total_sentence += sum(results[key]['p2 results'])
other_total_sentence += sum(results[key]['p1 results'])
trials += results[key]['number of trials']
both_same = (sum(results[(strat,strat)]['p1 results'])+sum(results[(strat,strat)]['p2 results']))/2 #take the average of p1 and p2 results, since both are using the same strat
your_total_sentence += both_same
other_total_sentence += both_same
trials += results[(strat,strat)]['number of trials']
sentences_for_strat[strat] = [your_total_sentence,trials,other_total_sentence]
#Print Results (using print_table)
print 'Results of different strategy combinations'
trials = NUMBER_OF_TRIALS
headers = ['Strat1','Strat2','P1 Avg','P2 Avg','Best/Trials','Avg/Trials','Bad/Trials','P1 Bad/Trials','P2 Bad/Trials']
rows = [[strat1,strat2,results[strat1,strat2]['p1 average sentence'],results[strat1,strat2]['p2 average sentence'],'{}/{}'.format(results[strat1,strat2]['number of best outcomes'],trials),'{}/{}'.format(results[strat1,strat2]['number of average outcomes'],trials),'{}/{}'.format(results[strat1,strat2]['number of bad outcomes'],trials),'{}/{}'.format(results[strat1,strat2]['number of p1 worst outcomes'],trials),'{}/{}'.format(results[strat1,strat2]['number of p2 worst outcomes'],trials)] for strat1,strat2 in results.keys()]
## #Sort by strat 1
## print 'Sorted by P1's Strategy:'
## rows = sorted(rows,key=lambda x: x[0])
##
## #Sort by strat 2
## print 'Sorted by P2's Strategy:'
## rows = sorted(rows,key=lambda x: x[1])
##
## #Sort by p1 avg
## print 'Sorted by P1 Average Sentence:'
## rows = sorted(rows,key=lambda x: x[2],reverse=True)
##
## #Sort by p2 avg
## print 'Sorted by P2 Average Sentence:'
## rows = sorted(rows,key=lambda x: x[3],reverse=True)
##
## #Sort by best
print 'Sorted by Number of Best Outcomes:'
rows = sorted(rows,key=lambda x: int(x[4][:x[4].index('/')]),reverse=True)
##
## #Sort by avg
## print 'Sorted by Number of Average Outcomes'
## rows = sorted(rows,key=lambda x: int(x[5][:x[5].index('/')]),reverse=True)
##
## #Sort by bad
## print 'Sorted by Number of Bad Outcomes'
## rows = sorted(rows,key=lambda x: int(x[6][:x[6].index('/')]),reverse=True)
##
## #Sort by p1 bad
## print 'Sorted by Number of Bad Outcomes for P1'
## rows = sorted(rows,key=lambda x: int(x[7][:x[7].index('/')]),reverse=True)
##
## #Sort by p2 bad
## print 'Sorted by Number of Bad Outcomes for P2'
## rows = sorted(rows,key=lambda x: int(x[8][:x[8].index('/')]),reverse=True)
print_table(headers,rows)
print '\n\n'
print 'Sentence lengths for playing with and against certain strategies'
## headers = ['Strat','Average for Using','Total Sent/Trials','Average for Against','Total Sent/Trials','Total Average']
headers = ['Strat','Average for Using','Average for Against','Total Average','Cum Average']
## rows = [[strat,float(sentences_for_strat[strat][0])/sentences_for_strat[strat][1],'{}/{}'.format(sentences_for_strat[strat][0],sentences_for_strat[strat][1]),float(sentences_for_strat[strat][2])/sentences_for_strat[strat][1],'{}/{}'.format(sentences_for_strat[strat][2],sentences_for_strat[strat][1]),(sentences_for_strat[strat][0]+sentences_for_strat[strat][2])/(sentences_for_strat[strat][1] * 2.)] for strat in sentences_for_strat.keys()]
rows = [[strat,float(sentences_for_strat[strat][0])/sentences_for_strat[strat][1],float(sentences_for_strat[strat][2])/sentences_for_strat[strat][1],(sentences_for_strat[strat][0]+sentences_for_strat[strat][2])/(sentences_for_strat[strat][1] * 2.),float(sentences_for_strat[strat][0]+sentences_for_strat[strat][2])/sentences_for_strat[strat][1]] for strat in sentences_for_strat.keys()]
## #Sort by average for using
## print 'Sorted by average for using'
## rows = sorted(rows,key=lambda x: x[1],reverse=False)
##
## #Sort by average for against
## print 'Sorted by average for against'
## rows = sorted(rows,key=lambda x: x[2],reverse=False)
##
## #Sort by total average
print 'Sorted by total average'
rows = sorted(rows,key=lambda x: x[3],reverse=False)
##
## #Sort by cum average
## print 'Sorted by cum average'
## rows = sorted(rows,key=lambda x: x[4],reverse=False)
print_table(headers,rows)
return results
