Esempio n. 1
0
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))
Esempio n. 2
0
    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)
Esempio n. 3
0
    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)
Esempio n. 5
0
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)
Esempio n. 6
0
 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, [])
Esempio n. 7
0
 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))
Esempio n. 8
0
def main(args):
    """ select appropriate response """

    if args.status == True:
        status.status()

    elif args.write == True:
        write.write()

    else:
        parser.print_help()
Esempio n. 9
0
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)
Esempio n. 10
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()
Esempio n. 11
0
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,
Esempio n. 12
0
 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
Esempio n. 13
0
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))
Esempio n. 14
0
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"
Esempio n. 15
0
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()
Esempio n. 16
0
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)
Esempio n. 17
0
	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)
Esempio n. 18
0
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)
Esempio n. 20
0
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
Esempio n. 22
0
    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
Esempio n. 23
0
    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()))
Esempio n. 24
0
 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)
Esempio n. 25
0
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))
Esempio n. 26
0
    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)
Esempio n. 27
0
    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
Esempio n. 28
0
 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)
Esempio n. 29
0
def set(channel, ONorOFF):
    # AWGoutput.set		- set desired channel to ON or OFF
    Command = ":OUTP" + str(channel) + " " + str(ONorOFF)
    return write.write(AWGadd, Command)
Esempio n. 30
0
 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))
Esempio n. 31
0
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()
Esempio n. 32
0
    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)
Esempio n. 33
0
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)

Esempio n. 34
0
def set(frequency):
    # AWGrefClock.set		- set frequency of reference clock
    Command = ":ROSC:FREQ " + str(frequency)
    return write.write(AWGadd, Command)
Esempio n. 35
0
 def save(self, path="setup.cfg"):
     """save to `setup.cfg` file"""
     value = self.string()
     write.write(path, value)
     return self
Esempio n. 36
0
def set(channel, voltage):
    # AWGvoltage.set		- set voltage of channel
    Command = "VOLT" + str(channel) + " " + str(voltage)
    return write.write(AWGadd, Command)
Esempio n. 37
0
 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])
Esempio n. 38
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()

Esempio n. 39
0
    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
Esempio n. 40
0
    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)
Esempio n. 41
0
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
Esempio n. 42
0
import read
import write

print "before write"
read.read()

write.write()

print "\nafter write"
read.read()
Esempio n. 43
0
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)
Esempio n. 44
0
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)
Esempio n. 45
0
 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])