def kmeans(task):
start = time.time()
output = []
buildings, antennas, reward = read(path + task)
X = np.array([[int(building.x), (building.y)] for building in buildings])
kmeans = KMeans(n_clusters=len(antennas), max_iter=1)
kmeans.fit(X)
centroids_x = [int(value[0]) for value in kmeans.cluster_centers_]
centroids_y = [int(value[1]) for value in kmeans.cluster_centers_]
antennas.sort(key=lambda antenna: antenna.speed, reverse=True)
for i in range(len(centroids_x)):
antennas[i].x = centroids_x[i]
antennas[i].y = centroids_y[i]
output.append(antennas[i])
write('output/' + str(task.split('.')[0]) + '.txt', output)
print(task, str(time.time() - start))
def print_board(self, k):
'''print board function'''
if self.player.level == 1:
print_background(self)
print_player(self)
draw_brick(self, self.bricks)
print_enemy(self)
print_bullet(self, self.bullets)
print_bullet(self, self.ebul)
if self.alivev == 1:
print_villain(self, self.vil.posx, self.vil.posy)
if self.alivev == 0:
win(self)
# time.sleep(3)
temp = ""
string = '\033[93m' + "Life=" + str(
self.player.life) + " Score=" + str(
self.player.score) + " Coins=" + str(
self.player.coins) + "\n" + '\033[0m'
if k >= 550 and self.alivev == 1:
string += '\033[93m' + "Boss Life=" + \
str(self.vil.life) + "\n" + '\033[0m'
temp += string
for i in range(40):
for j in range(k, k + 150, 1):
temp += self.level1[i][j]
print(temp)
else:
print_background(self)
print_player(self)
draw_brick(self, self.bricks2)
draw_coin(self, self.coins)
if time.time() - self.time >= 0.3:
write(self)
self.time = time.time()
temp = ""
string = '\033[93m' + "Life=" + str(
self.player.life) + " Score=" + str(
self.player.score) + " Coins=" + str(
self.player.coins) + "\n" + '\033[0m'
temp += string
for i in range(40):
for j in range(k, k + 150, 1):
temp += self.level1[i][j]
print(temp)
def new(self, params):
os.makedirs(params.out_dir, exist_ok=True)
self.params = params
w.write(params.out_dir + "/params.json",
w.pretty_json(params.to_json()))
self.sample = Sample().new(params)
sample_file = params.out_dir + "/sample.fasta"
w.write(sample_file, w.fasta(self.sample))
art_prefix = params.out_dir + "/art"
art = os.environ['ART_ILLUMINA']
subprocess.run([
art, "--in", sample_file, "--out", art_prefix, "--rndSeed",
str(params.seed)
] + params.art_flags,
stdout=subprocess.DEVNULL)
self.art_output = r.read(art_prefix + ".aln", r.aln(params.take_ref))
self.instance = Instance().new(params, self.art_output)
w.write(params.out_dir + "/instance.json",
w.json(self.instance.to_json()))
w.write(params.out_dir + "/instance.txt",
w.text(self.instance.to_text()))
w.write(params.out_dir + "/instance.stats.json",
w.json(self.instance.stats()))
return self
def displayStats(self):
if self.tests_failed:
bg_colour = "#ff0000"
fg_colour = "#ffffff"
else:
bg_colour = "#00ff00"
fg_colour = "#000000"
tests_passed = self.tests_completed - self.tests_failed
if sys.platform in ['mozilla', 'ie6', 'opera', 'oldmoz', 'safari']:
output = "<table cellpadding=4 width=100%><tr><td bgcolor='" + bg_colour + "'><font face='arial' size=4 color='" + fg_colour + "'><b>"
else:
output = ""
output += self.getNameFmt(
) + "Passed %d " % tests_passed + "/ %d" % self.tests_completed + " tests"
if self.tests_failed:
output += " (%d failed)" % self.tests_failed
if sys.platform in ['mozilla', 'ie6', 'opera', 'oldmoz', 'safari']:
output += "</b></font></td></tr></table>"
else:
output += "\n"
write(output)
def subopen(args, stdin=None, shell=False, cwd=None, env=None):
temp = None
pid = None
close_fds = True
rstrip = True
try:
if stdin is not None and isstring(stdin):
temp = tempfile()
write(temp, stdin)
stdin = open(temp)
args = tolist(args)
for i, arg in enumerate(args):
if not isinstance(arg, int):
if PY3:
args[i] = str(arg) # python3
else:
args[i] = __builtin__.unicode(arg) # python2
if not env:
env = os.environ.copy()
process = subprocess.Popen(args,
stdin=stdin,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
close_fds=close_fds,
shell=shell,
cwd=cwd,
env=env,
universal_newlines=False # ,
# startupinfo=startupinfo#,
# creationflags=creationflags
)
pid = process.pid
stdoutdata, stderrdata = process.communicate()
if PY3:
# python3. process.communicate returns bytes
stdoutdata = str(stdoutdata, "utf-8") # stdoutdata
stderrdata = str(stderrdata, "utf-8") # stderrdata
# rstrip
if rstrip and stdoutdata:
stdoutdata = stdoutdata.rstrip()
if rstrip and stderrdata:
stderrdata = stderrdata.rstrip()
returncode = process.returncode
return (returncode, stdoutdata, stderrdata)
# raise CalledProcessError(returncode,args,err)
# if returncode!=0:
# raise CalledProcessError(returncode,args,stderrdata)
# return stdoutdata
finally:
try:
if pid:
os.killpg(pid, signal.SIGTERM)
except Exception:
pass
# print(format_exc())
rm(temp)
def testConflictedMerge(self):
config.journalPath = self.localDir
write.time = datetime.datetime.strftime(datetime.datetime.strptime("11:00:00", "%H:%M:%S"), config.timeFormat)
write.write(name="1800-01-01", tags=self.remoteContent[0], content=self.localContent[1], quiet=True)
merge = sync.Sync(self.remoteDir, self.localDir)
sync.raw_input = lambda _: "2"
merge.merge()
self.assertEqual(filecmp.dircmp(self.remoteDir, self.localDir).left_only, [])
self.assertEqual(filecmp.dircmp(self.remoteDir, self.localDir).right_only, [])
self.assertEqual(filecmp.dircmp(self.remoteDir, self.localDir).diff_files, [])
def testMultiPageSearch(self):
tag = self.tagList[5]
content = self.contentList[0]
write.write("test-1", tags=tag, content=content, quiet=True)
write.write("test-99", tags=tag, content=content, quiet=True)
expected = [["# test-1\n", "{0} {1} \n".format(write.time, tag)
+ write.prepareContent(content)],
["# test-99\n", "{0} {1} \n".format(write.time, tag)
+ write.prepareContent(content)]]
self.assertEquals(expected, search.search(tag))
def main(args):
""" select appropriate response """
if args.status == True:
status.status()
elif args.write == True:
write.write()
else:
parser.print_help()
def makerandom(target):
global quality
ind = []
for i in range(config.IND_SIZE):
ind.append(random.random())
config.listToConfig(ind)
config.init()
melody.generate()
write.write([melody.melody], [melody.rhythm])
# print sum(melody.rhythm)
rewrite("output.mid", target, 0)
def sentence():
if tk.token.code == CodeTable['IDENTIFIER']:
assipro.assipro()
elif tk.token.code == CodeTable['IF']:
ifsent.ifsent()
elif tk.token.code == CodeTable['WHILE']:
whilsent.whilsent()
elif tk.token.code == CodeTable['READ']:
read.read()
elif tk.token.code == CodeTable['WRITE']:
write.write()
elif tk.token.code == CodeTable['BEGIN']:
compsent.compsent()
def evaluate(individual):
global tim
config.listToConfig(individual)
config.init()
x = 0
for i in range(config.evaluationToAverage):
tim += time.process_time()
melody.generate()
write.write([melody.melody], [melody.rhythm])
write.save()
track = miditotxt.rewrite('output.mid')
tim -= time.process_time()
x += discriminator.evaluate(track)
return x/config.evaluationToAverage,
def run(self):
try:
for copied in write.write(self.source, self.destination):
self.value += copied
if self.stop: return
except Exception as ex:
self.ex = ex
def solver(task):
start = time.time()
output = []
buildings, antennas, reward = read(path + task)
for i in range(min(len(buildings), len(antennas))):
antennas[i].x = buildings[i].x
antennas[i].y = buildings[i].y
output.append(antennas[i])
write('output/' + str(task.split('.')[0]) + '.txt', output)
print(task, str(time.time() - start))
def tracker(name):
if exist(name):
app = increment(name)
image = write(app["count_visited"])
try:
response = make_response(
send_file(BytesIO(image),
attachment_filename="logo.jpg",
mimetype="image/jpg"))
# Disable caching
response.headers["Pragma-Directive"] = "no-cache"
response.headers["Cache-Directive"] = "no-cache"
response.headers[
"Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Pragma"] = "no-cache"
response.headers["Expires"] = "0"
return response
except:
pass
else:
return "Not found"
def main():
status()
dump_data()
# Updates everything
insts = get_insts()
update(insts)
for inst in insts:
r = do_thing(inst, Settings.INTERVAL)
r.to_csv('{}/{}.csv'.format(Settings.PATH_RESULTS, inst), index=False)
for inst in insts:
write(inst, '{}/{}.csv'.format(Settings.PATH_RESULTS, inst))
status()
def normalize(in_path, out_path):
print 'Reading concept data'
concepts = list(read_ontology())
concept_ids, concept_names, concept_map, concept_vectors, tfidf_vectorizer = build_tfidf(concepts)
reverse_concept_map = {concept_ids[i]:concept_names[i] for i in range(len(concept_names))}
print 'Making predictions'
devel_data = read(in_path)
devel_tuples = []
for entity_id, data in devel_data.items():
entity_span = data[0]
for ann in data[1:]:
devel_tuples.append((entity_id, entity_span, ann))
devel_entity_ids = [d[0] for d in devel_tuples]
devel_spans = [d[1] for d in devel_tuples]
# Acronym expansion
if settings.ENTITY_TYPE == 'Bacteria':
from collections import defaultdict
doc_entities = defaultdict(list)
for i, entity_span in enumerate(devel_spans):
if len(entity_span) >= 5 and not entity_span.isupper():
doc_entities[devel_entity_ids[i].split('___')[0]].append(entity_span)
for i, entity_span in enumerate(devel_spans):
if len(entity_span) < 5 or entity_span.isupper():
#print 'Too small entity: %s' % entity_span
entity_vect = tfidf_vectorizer.transform([entity_span])
prev_entities = doc_entities[devel_entity_ids[i].split('___')[0]]
if len(prev_entities) > 0:
prev_entity_acronyms = [''.join([l[0] for l in e.split()]) for e in prev_entities]
doc_vects = tfidf_vectorizer.transform(prev_entity_acronyms)
best_hit = numpy.argmax(cosine_similarity(entity_vect, doc_vects), axis=1)[0]
new_span = doc_entities[devel_entity_ids[i].split('___')[0]][best_hit]
#print 'Entity: %s, expansion: %s' % (entity_span, new_span)
devel_spans[i] = new_span
devel_vectors = tfidf_vectorizer.transform(devel_spans)
sims = cosine_similarity(devel_vectors, concept_vectors)
devel_hits = numpy.argmax(sims, axis=1)
predicted_labels = [concept_ids[i] for i in devel_hits]
write(list(zip(devel_entity_ids, predicted_labels)), out_path)
def displayStats(self):
if self.tests_failed:
bg_colour="#ff0000"
fg_colour="#ffffff"
else:
bg_colour="#00ff00"
fg_colour="#000000"
tests_passed=self.tests_completed - self.tests_failed
output="<table cellpadding=4 width=100%><tr><td bgcolor='" + bg_colour + "'><font face='arial' size=4 color='" + fg_colour + "'><b>"
output+=self.getNameFmt() + "Passed " + tests_passed + "/" + self.tests_completed + " tests"
if self.tests_failed:
output+=" (" + self.tests_failed + " failed)"
output+="</b></font></td></tr></table>"
write(output)
def solver(task):
start = time.time()
output = []
buildings, antennas, reward = read(path + task)
antennas.sort(key=lambda x: x.speed, reverse=True)
buildings.sort(key=lambda x: x.speed_weight, reverse=True)
for i in range(min(len(buildings), len(antennas))):
antennas[i].x = buildings[i].x
antennas[i].y = buildings[i].y
output.append(antennas[i])
write('output/' + str(task.split('.')[0]) + '.txt', output)
print(task, str(time.time() - start))
def displayStats(self):
if self.tests_failed:
bg_colour = "#ff0000"
fg_colour = "#ffffff"
else:
bg_colour = "#00ff00"
fg_colour = "#000000"
tests_passed = self.tests_completed - self.tests_failed
output = "<table cellpadding=4 width=100%><tr><td bgcolor='" + bg_colour + "'><font face='arial' size=4 color='" + fg_colour + "'><b>"
output += self.getNameFmt(
) + "Passed " + tests_passed + "/" + self.tests_completed + " tests"
if self.tests_failed:
output += " (" + self.tests_failed + " failed)"
output += "</b></font></td></tr></table>"
write(output)
def osascript(applescript, flags=None):
"""osascript applescript code or file
"""
args = ["osascript"]
if applescript and isinstance(applescript, list):
applescript = "\n".join(applescript)
temp = programfile = None
if applescript and os.path.exists(applescript):
programfile = applescript
else:
temp = programfile = tempfile()
write(temp, applescript)
try:
if flags:
args += ["-s", flags]
if programfile:
args.append(programfile)
returncode, stdout, stderr = subopen(args)
return (returncode, stdout, stderr)
finally:
rm(temp)
def fail(self, msg=None):
self.startTest()
self.tests_failed += 1
if not msg:
msg = "assertion failed"
else:
msg = str(msg)
octothorp = msg.find("#")
has_bugreport = octothorp >= 0 and msg[octothorp + 1].isdigit()
if has_bugreport:
name_fmt = "Known issue"
bg_colour = "#ffc000"
fg_colour = "#000000"
else:
bg_colour = "#ff8080"
fg_colour = "#000000"
name_fmt = "Test failed"
output = "<table style='padding-left:20px;padding-right:20px;' cellpadding=2 width=100%><tr><td bgcolor='" + bg_colour + "'><font color='" + fg_colour + "'>"
write(output)
title = "<b>" + self.getNameFmt(name_fmt) + "</b>"
write(title + msg)
output = "</font></td></tr></table>"
output += "\n"
write(output)
if sys.platform in ['mozilla', 'ie6', 'opera', 'oldmoz', 'safari']:
from __pyjamas__ import JS
JS("""if (typeof @{{!console}} != 'undefined') {
if (typeof @{{!console}}.error == 'function') @{{!console}}.error(@{{msg}});
if (typeof @{{!console}}.trace == 'function') @{{!console}}.trace();
}""")
return False
def fail(self, msg=None):
self.startTest()
self.tests_failed+=1
if not msg:
msg="assertion failed"
else:
msg = str(msg)
octothorp = msg.find("#")
has_bugreport = octothorp >= 0 and msg[octothorp+1].isdigit()
if has_bugreport:
name_fmt = "Known issue"
bg_colour="#ffc000"
fg_colour="#000000"
else:
bg_colour="#ff8080"
fg_colour="#000000"
name_fmt = "Test failed"
output="<table style='padding-left:20px;padding-right:20px;' cellpadding=2 width=100%><tr><td bgcolor='" + bg_colour + "'><font color='" + fg_colour + "'>"
write(output)
title="<b>" + self.getNameFmt(name_fmt) + "</b>"
write(title + msg)
output="</font></td></tr></table>"
output+= "\n"
write(output)
if sys.platform in ['mozilla', 'ie6', 'opera', 'oldmoz', 'safari']:
from __pyjamas__ import JS
JS("""if (typeof @{{!console}} != 'undefined') {
if (typeof @{{!console}}.error == 'function') @{{!console}}.error(@{{msg}});
if (typeof @{{!console}}.trace == 'function') @{{!console}}.trace();
}""")
return False
def new(self, root_dir, strains, aligned, sample):
out_dir = root_dir + "/" + sample[0]
os.makedirs(out_dir, exist_ok=True)
# sample_json = out_dir + "/sample.json"
# w.write(sample_json, w.json(s.to_json(sample)))
sample_fasta = out_dir + "/sample.fasta"
w.write(sample_fasta, w.fasta(s.to_fasta(sample)))
art_prefix = out_dir + "/art"
art = os.environ['ART_ILLUMINA']
subprocess.run([
art, "--in", sample_fasta, "--out", art_prefix, "--seqSys", "HS20",
"--len", "100", "--fcov", "100"
],
stdout=subprocess.DEVNULL)
take_ref = False
art_output = r.read(art_prefix + ".aln", r.aln(take_ref))
instance = Instance().new(strains, aligned, art_output)
# w.write(out_dir + "/instance.json", w.json(instance.to_json()))
w.write(out_dir + "/instance.txt", w.text(instance.to_text()))
w.write(out_dir + "/instance.stats.json", w.json(instance.stats()))
def setUp(self):
self.tempPath = tempfile.mkdtemp(prefix="diariumSearchTest-")
config.journalPath = self.tempPath
self.numberOfFiles = 100
self.tagList = list()
self.contentList = list()
for j in range(10):
self.tagList.append(''.join(random.choice(string.ascii_letters) for k in range(10)))
self.contentList.append(''.join(random.choice(string.ascii_letters) for k in range(100)))
for i in range(self.numberOfFiles):
name = "test-{0}".format(i)
for j in range(10):
write.write(name, tags=str(j), content=str(i), quiet=True)
write.write("0001-01-01", content="Start of datesearch", quiet=True)
write.write("0015-01-01", content="Middle of datesearch", quiet=True)
write.write("0031-01-01", content="End of datesearch", quiet=True)
def solver(task):
start = time.time()
duration, n_intersec, n_streets, n_cars, bonus, streets, cars, intersections = read(
path + task + '.txt')
output = []
for intersec in intersections:
intersec_streets = intersec.streets_in
intersec_streets.sort(key=lambda x: x.cars, reverse=True)
schedule_pairs = [
SchedulePair(street_in, 1) for street_in in intersec_streets
]
output.append(Schedule(schedule_pairs, intersec))
write('./output/' + task + '.txt', output)
# score = judge(output)
print(task, str(time.time() - start))
def displayStats(self):
if self.tests_failed:
bg_colour="#ff0000"
fg_colour="#ffffff"
else:
bg_colour="#00ff00"
fg_colour="#000000"
tests_passed=self.tests_completed - self.tests_failed
if sys.platform in ['mozilla', 'ie6', 'opera', 'oldmoz', 'safari']:
output="<table cellpadding=4 width=100%><tr><td bgcolor='" + bg_colour + "'><font face='arial' size=4 color='" + fg_colour + "'><b>"
else:
output = ""
output+=self.getNameFmt() + "Passed %d " % tests_passed + "/ %d" % self.tests_completed + " tests"
if self.tests_failed:
output+=" (%d failed)" % self.tests_failed
if sys.platform in ['mozilla', 'ie6', 'opera', 'oldmoz', 'safari']:
output+="</b></font></td></tr></table>"
else:
output+= "\n"
write(output)
def fail(self, msg=None):
self.startTest()
self.tests_failed += 1
if not msg:
msg = "assertion failed"
else:
msg = str(msg)
has_bugreport = False
for issue in issue_re.findall(msg):
# TODO/XXX/HACK: The findall() method in pyjs is buggy and also returns
# the leading '#' character, so strip it as a workaround.
issue = issue.lstrip('#')
print issue, issues.get(issue)
if issue in issues and issues[issue] != 'Fixed':
has_bugreport = True
break
if has_bugreport:
name_fmt = "Known issue"
bg_colour = "#ffc000"
fg_colour = "#000000"
else:
bg_colour = "#ff8080"
fg_colour = "#000000"
name_fmt = "Test failed"
output = "<table style='padding-left:20px;padding-right:20px;' cellpadding=2 width=100%><tr><td bgcolor='" + bg_colour + "'><font color='" + fg_colour + "'>"
write(output)
title = "<b>" + self.getNameFmt(name_fmt) + "</b>"
write(title + msg)
output = "</font></td></tr></table>"
output += "\n"
write(output)
if sys.platform in ['mozilla', 'ie6', 'opera', 'oldmoz', 'safari']:
from __pyjamas__ import JS
JS("""if (typeof @{{!console}} != 'undefined') {
if (typeof @{{!console}}.error == 'function') @{{!console}}.error(@{{msg}});
if (typeof @{{!console}}.trace == 'function') @{{!console}}.trace();
}""")
return False
def setUp(self):
self.localDir = tempfile.mkdtemp(suffix="local")
self.remoteDir = tempfile.mkdtemp(suffix="remote")
config.journalPath = self.localDir
self.localContent = ["tag1, tag2, tag3", "LoremIpsum\nDolorSit amet\nLOCAL\nLOCAl"]
self.sharedContent = ["tag2, tag4", "Share the Lorem Ipsum\nShare IT!"]
self.remoteContent = ["tag4, tag5", "Remote\nStuff"]
write.time = datetime.datetime.strftime(datetime.datetime.strptime("00:00:00", "%H:%M:%S"), config.timeFormat)
write.write(name="1900-01-01", tags=self.localContent[0], content=self.localContent[1], quiet=True)
write.time = datetime.datetime.strftime(datetime.datetime.strptime("10:00:00", "%H:%M:%S"), config.timeFormat)
write.write(name="1841-01-01", tags=self.sharedContent[0], content=self.sharedContent[1], quiet=True)
config.journalPath = self.remoteDir
write.write(name="1841-01-01", tags=self.sharedContent[0], content=self.sharedContent[1], quiet=True)
write.time = datetime.datetime.strftime(datetime.datetime.strptime("11:00:00", "%H:%M:%S"), config.timeFormat)
write.write(name="1841-01-01", tags=self.remoteContent[0], content=self.remoteContent[1], quiet=True)
write.write(name="1800-01-01", tags=self.remoteContent[0], content=self.remoteContent[1], quiet=True)
write.write(name="1900-01-01", tags=self.remoteContent[0], content=self.remoteContent[1], quiet=True)
def set(channel, ONorOFF):
# AWGoutput.set - set desired channel to ON or OFF
Command = ":OUTP" + str(channel) + " " + str(ONorOFF)
return write.write(AWGadd, Command)
def annotate_dir(self, wypluwka_dir, output_dir, save_gzipped=True):
tmp_name = self._tmp_name(output_dir, save_gzipped)
out = self._output_for(tmp_name, save_gzipped)
write.write(out, self._annotations(wypluwka_dir))
out.close()
shutil.move(tmp_name, self._out_name(output_dir, save_gzipped))
count = {}
# Create an array of note sequences for each song
while i < 60:
if (i == 33) or (i == 34):
i += 1
else:
array.array(i, notes)
i += 1
# Map note transitions for all songs
while j < 60:
if (j == 32) or (j == 33) or (j == 34):
j += 1
else:
compare.compare(j, count, notes)
j += 1
# Generate probability matrix
while co < 12:
compare.probability(co, count)
co += 1
# Write 60 measures of song
while k < 60:
write.write(p, count)
k += 1
# Display song as musicXML
song.show()
if args.draw and args.filename:
logging.info(f"Drawing Inky {args.filename}")
image = prepare(inky_display, args.filename)
draw(inky_display, image)
if args.write:
logging.info(f"Writing Inky lines from stdin")
font = ImageFont.truetype(args.font, args.font_size)
# font = ImageFont.truetype(FredokaOne, args.font_size)
lines = fit_lines(
"\n".join(sys.stdin.readlines()).strip(),
font,
inky_display.WIDTH,
padding=args.font_padding * 2,
)
logging.info(f"First Line: {lines[0]}...")
image = draw_lines(
inky_display,
lines,
font,
origin=(args.font_padding, args.font_padding),
)
write(inky_display, image)
if args.weather:
logging.info("Plotting weather")
filename = args.filename or "/tmp/weather_forecast.png"
save_png(filename)
image = prepare(inky_display, filename)
draw(inky_display, image)
from read import read
from execute import execute
from write import write
from scipy.stats import random_correlation
if __name__ == "__main__":
### Read inputs ###
# Tasks:
# 1 - select your input folder
# 2 - select your input file name
inputFilePath = ''
inputFileName = ''
sheetName = 'Input'
read(inputFilePath, inputFileName, sheetName)
### Execute operations ###
execute()
### Write output ###
# Tasks:
# 1 - select your output folder
# 2 - select your output file name
outputFilePath = ''
outputFileName = ''
write(outputFilePath, outputFileName)
def set(frequency):
# AWGrefClock.set - set frequency of reference clock
Command = ":ROSC:FREQ " + str(frequency)
return write.write(AWGadd, Command)
def save(self, path="setup.cfg"):
"""save to `setup.cfg` file"""
value = self.string()
write.write(path, value)
return self
def set(channel, voltage):
# AWGvoltage.set - set voltage of channel
Command = "VOLT" + str(channel) + " " + str(voltage)
return write.write(AWGadd, Command)
def testSingleTagSearch(self):
tag = self.tagList[7]
content = self.contentList[1]
write.write("test-42", tags=tag, content=content, quiet=True)
self.assertEquals(["# test-42\n", "{0} {1} \n".format(write.time, tag) +
write.prepareContent(content)], search.search(tag)[0])
# Create an array of note sequences for each song while i < 60: if (i == 33) or (i == 34): i += 1 else: notearray.array(i, notes) i += 1 # Map note transitions for all songs while j < 60: if (j == 32) or (j == 33) or (j == 34): j += 1 else: compare.compare(j, count, notes) j += 1 # Generate probability matrix while co < 12: compare.probability(co,count) co += 1 # Write 60 measures of song while k < 60: write.write(p, count, song) k+=1 # Display song as musicXML song.show()
def __call__(self, x, previous_controller, previous_weights, prev_read):
with tf.variable_scope("concat", reuse=(self.step > 0)):
x = tf.layers.Flatten()(x)
NTM_Input = tf.concat([x, prev_read], axis=1)
with tf.variable_scope("controller", reuse=(self.step > 0)):
controller_output, controller_state = self.controller(
NTM_Input, previous_controller)
with tf.variable_scope("parameter_feedforward", reuse=(self.step > 0)):
parameter_weight = tf.get_variable(
'parameter_weight', [
controller_output.get_shape()[1], 5 + 3 *
(self.memory.get_shape()[1])
],
initializer=tf.contrib.layers.xavier_initializer())
#parameter weight is determined by controller outputs and the memory M dimension M is multiplied by three because
#of the key vector and the two add and erase vectors
parameter_bias = tf.get_variable(
'parameter_bias', [5 + 3 * (self.memory.get_shape()[1])],
initializer=tf.contrib.layers.xavier_initializer())
parameters = tf.nn.xw_plus_b(controller_output, parameter_weight,
parameter_bias)
#head_parameter = parameters
#erase_add = tf.split(parameters[self.memory.get_shape()[1]+1+1+3+1], 2, axis=1)
head_parameter = parameters[:self.memory.get_shape()[1] + 1 + 1 + 3 +
1 + 1]
erase_add = parameters[self.memory.get_shape()[1] + 1 + 1 + 3 + 1 + 1:]
#Form focus vectors
k = tf.tanh(head_parameter[0][0:self.memory.get_shape()[1]])
beta = tf.sigmoid(head_parameter[0][self.memory.get_shape()[1]]) * 10
g = tf.sigmoid(head_parameter[0][self.memory.get_shape()[1] + 1])
s = tf.nn.softmax(
head_parameter[0][self.memory.get_shape()[1] +
2:self.memory.get_shape()[1] + 2 + 3])
gamma = tf.log(tf.exp(head_parameter[0][-1]) + 1) + 1
with tf.variable_scope('addressing_head'):
print(k.get_shape())
print(self.memory.get_shape())
print(tf.reshape(self.memory, [80, 100]).get_shape())
#tf.gather_nd(self.memory_vector,[1,j])
#ad = addressing.addressing(k, beta, g, s,gamma, self.memory, previous_weights)
inter_memory = tf.reshape(self.memory, [80, 100])
print("...")
print(inter_memory.shape.as_list())
print("...")
ad = addressing.addressing(k, beta, g, s, gamma, inter_memory,
previous_weights, self.sess)
w = ad.address()
#Reading
with tf.variable_scope("read_vector"):
read_vector = read.reading_function(w, self.memory)
#Writing
erase_vector = tf.sigmoid(erase_add[0], axis=1)
add_vector = tf.tanh(erase_add[1], axis=1)
with tf.variable_scope("write_vector"):
comp_mem = write.write(w, erase_vector, add_vector, self.memory)
self.memory = comp_mem
#Going from controller to NTM
with tf.graph_argument.variable_scope("output_feedforward",
reuse=(self.step > 0)):
output_weight = tf.get_variable('output_weight',
[controller_output.shape()[1]])
output_bias = tf.get_variable('output_bias', [output_dim])
output = tf.nn.xw_plus_b(controller_output, output_weight,
output_bias)
self.step += 1
return output, controller_state, read_vector, w
exit()
while(1):
count = input("How many pictures do you have?\n")
try:
count = int(count)
break
except ValueError:
print("This value is not valid! Try again!")
time.sleep(2)
a = ask.ask(count)
picArray = []
for i in range(count):
if len(picArray)>0:
a.printHeader(i, True, picArray[-1].strTime)
path = a.askPath()
sumSecTime = sum(pic.secTime for pic in picArray)
#print(sumSecTime)
else:
a.printHeader(i, False, "")
path = a.askPath()
sumSecTime = 0
print()
strTime = a.askTime(sumSecTime)
picObject = pic(strTime, path, sumSecTime)
picArray.append(picObject)
write.write(picArray)
import os
import write
import check
import move
arr = []
for w in range(9):
w += 1
arr.append("%s" % w)
player1 = input("Nick 1: ")
char1 = ("X")
player2 = input("Nick 2: ")
char2 = ("0")
write.write(arr)
a = 0
while a in range(9):
move.next(arr, char1, player1)
write.write(arr)
if check.check(arr, char1, player1) == True:
break
move.next(arr, char2, player2)
write.write(arr)
if check.check(arr, char2, player2) == True:
break
if a == 8:
print("Remis!")
break
import read import write print "before write" read.read() write.write() print "\nafter write" read.read()
def simulate(filepath,
filedir,
fullfilename,
write=1,
analyze=1,
makefig=1,
diffuse=1,
antibunch=1,
pulsed=0,
numlines=10**7,
maxlines=10**8,
endtime=10**12,
temp=298,
concentration=2 * 10**-8,
dabsXsec=3.6 * 10**-10,
labsXsec=3.6 * 10**(-10),
k_demission=1000000,
k_sem=10000,
emwavelength=815,
r=10,
eta=8.9 * 10**(-13),
n=1.3,
k_tem=1,
k_fiss=1,
k_trans=200000,
reprate=1,
wavelength=532,
laserpwr=0.5,
pulselength=80,
foclen=310000,
NA=1.4,
darkcounts=1,
sensitivity=0.1,
nligands=1,
deadtime=70000,
afterpulse=0,
order=2,
mode="t2",
gnpwr=20,
numbins=4096,
pulsebins=99,
channels=3,
seq=0,
mL1=0,
picyzoom=100,
timestep=200):
suffix = ".txt"
if not os.path.isdir(filepath):
os.mkdir(filepath)
if not os.path.isdir(filepath + "RawData/"):
os.mkdir(filepath + "RawData/")
os.mkdir(filepath + "Figures/")
if not os.path.isdir(filepath + "RawData/" + filedir):
os.mkdir(filepath + "RawData/" + filedir)
os.mkdir(filepath + "Figures/" + filedir)
os.mkdir(filepath + "RawData/" + filedir + fullfilename)
os.mkdir(filepath + "Figures/" + filedir + fullfilename)
elif not os.path.isdir(filepath + "RawData/" + filedir + fullfilename):
os.mkdir(filepath + "RawData/" + filedir + fullfilename)
os.mkdir(filepath + "Figures/" + filedir + fullfilename)
os.chdir(filepath + "RawData/" + filedir + fullfilename)
print(os.getcwd())
if write == 1:
w.write(filepath, filedir, fullfilename, antibunch, diffuse, pulsed,
numlines, maxlines, endtime, temp, concentration, dabsXsec,
labsXsec, k_demission, k_fiss, k_trans, k_sem, k_tem,
emwavelength, r, eta, n, reprate, wavelength, laserpwr,
pulselength, foclen, NA, darkcounts, sensitivity, nligands,
deadtime, afterpulse, timestep, channels, seq, mL1)
if analyze == 1:
a.analyze(filepath, filedir, fullfilename, numlines, order, mode,
gnpwr, numbins, pulsebins, channels, makefig, m.makeafig,
pulsed, picyzoom, reprate)
elif makefig == 1: #only really used if it crashed part way through analysis
#nm.figs(filepath, file, filoutpath, savename, fontsize, color, sfactor, xzoom, yzoom, log, pulsed)
file = fullfilename
fileoutname = file + "gnpwr15"
c = isbf(fullfilename)
filename = "fig"
m.makeafig("g2",
filename, [-1, -1], [-1, -1],
0,
pulsed,
filepath=filepath,
filedir=filedir + file + "/",
fileoutdir=fileoutname + ".g2.run/",
color=c)
filename = "20mszoom"
m.makeafig("g2",
filename, [-20000000, 20000000], [-1, -1],
0,
pulsed,
filepath=filepath,
filedir=filedir + file + "/",
fileoutdir=fileoutname + ".g2.run/",
color=c)
filename = "200uszoom"
m.makeafig("g2",
filename, [-200000, 200000], [-1, -1],
0,
pulsed,
filepath=filepath,
filedir=filedir + file + "/",
fileoutdir=fileoutname + ".g2.run/",
color=c)
filename = "log"
m.makeafig("g2",
filename, [-1, -1], [-1, -1],
1,
pulsed,
filepath=filepath,
filedir=filedir + file + "/",
fileoutdir=fileoutname + ".g2.run/",
color=c)
str_style_fill.alignment = Alignment(horizontal='center', vertical='center')
str_style_fill.border = Border(left=Side(style='thin'),
right=Side(style='thin'),
top=Side(style='thin'),
bottom=Side(style='thin'))
str_style_fill.fill = PatternFill('solid', fgColor='E5E5E5')
wb.add_named_style(title_style)
wb.add_named_style(num_style)
wb.add_named_style(num_style_fill)
wb.add_named_style(str_style)
wb.add_named_style(str_style_fill)
rens = rens_list(cur, '前线')
write(wb, rens, '整体')
write(wb, rens, '车险')
write(wb, rens, '非车险')
write_zhong_zhi(wb, cur, rens, '分公司营业一部')
write_zhong_zhi(wb, cur, rens, '曲靖')
write_zhong_zhi(wb, cur, rens, '文山')
write_zhong_zhi(wb, cur, rens, '大理')
write_zhong_zhi(wb, cur, rens, '保山')
write_zhong_zhi(wb, cur, rens, '版纳')
write_zhong_zhi(wb, cur, rens, '怒江')
write_zhong_zhi(wb, cur, rens, '昭通')
rens = rens_list(cur, '后线')
write(wb, rens, '整体', '后线')
wb.move_sheet('后线人员整体保费排名', offset=-8)
def testMultiTagSearch(self):
tags = "{0}, {1}, {2}".format(self.tagList[1], self.tagList[9], self.tagList[2])
content = self.contentList[2]
write.write("test-13", tags=tags, content=content, quiet=True)
self.assertEquals(["# test-13\n", "{0} {1} \n".format(write.time, tags) +
write.prepareContent(content)], search.search(tags)[0])
