def setUp(self): self.x, self.y, self.word2Id, self.Id2word, self.dataId2word = read( 'D:\Emphasis_Selection\Github\Taher_Github\emphasis\input/test_case_train.txt' ) self.x_test = read( 'D:\Emphasis_Selection\Github\Taher_Github\emphasis\input/test_case_train.txt', word2Id=self.word2Id) self.one_hot_x = get_one_hot_matrix(self.x, len(self.word2Id))
def get_data(self, spreadsheetId): q = read(spreadsheetId, 'pergunta') a = read(spreadsheetId, 'resposta') for row in a: self.answers[int(row[0]) + self.offset] = row[1] for row in q: t = (preprocess(row[0], self.sub_dict), int(row[1]) + self.offset) self.faq += [t] self.offset += 1000
def setUp(self): self.X, self.y, self.word2Id, self.Id2word, self.dataId2word = read('D:\Emphasis_Selection\Github\Taher_Github\emphasis\input/test_case_models.txt') self.x_test = read('D:\Emphasis_Selection\Github\Taher_Github\emphasis\input/test_case_train.txt', word2Id= self.word2Id) self.one_hot_X = get_one_hot_matrix(self.X, len(self.word2Id)) self.one_hot_y = get_one_hot_matrix(self.y, len(self.word2Id)) model = WordConditionalModel() model.fit(np.array(self.one_hot_X), np.array(self.one_hot_y)) self.model = model.get_model() print(self.Id2word) self.predictions = model.predict(self.one_hot_X)
def main(argv): argc = len(argv) if argc < 2: print(get_help()) exit(0) if argv[1] == 't': net = ANN(Functions.SIGMOID, Functions.MSE) nb = NaiveBayes() bn = Bernoulli() selected_tweets = reader.read(argv[2]) rejected_tweets = reader.read(argv[3]) t1 = threading.Thread(target=train_net,\ args=(net, selected_tweets, rejected_tweets)) t2 = threading.Thread(target=train_nb,\ args=(nb, selected_tweets, rejected_tweets)) t3 = threading.Thread(target=train_bn,\ args=(bn, selected_tweets, rejected_tweets)) t1.start() t2.start() t3.start() t1.join() t2.join() t3.join() elif argv[1] == 'c': f_net = open(argv[2], 'rb') net = pickle.load(f_net) f_net.close() f_nb = open(argv[3], 'rb') nb = pickle.load(f_nb) f_nb.close() f_bn = open(argv[4], 'rb') bn = pickle.load(f_bn) f_bn.close() tweets = reader.read(argv[5]) t1 = threading.Thread(target=classify_using_net,\ args=(net, tweets)) t2 = threading.Thread(target=classify_using_nb,\ args=(nb, tweets)) t3 = threading.Thread(target=classify_using_bn,\ args=(bn, tweets)) t1.start() t2.start() t3.start() t1.join() t2.join() t3.join() else: print(get_help()) exit(0)
def date_registration(message): global commandlist global fromplace global toplace global dateregistration global loadsticerpack if message.text.lower() in commandlist: exec(commandlist[message.text.lower()]) elif message.text.lower() in commandlist_ru: exec(commandlist_ru[message.text.lower()]) elif '/' + message.text.lower() in commandlist: exec(commandlist['/' + message.text.lower()]) else: dateregistration = message.text.lower() print(fromplace) print(toplace) print(dateregistration) Sendler(fromInput=fromplace, fromOutput=toplace, date=dateregistration).send() bot.send_message(message.chat.id, 'Ищу билеты по выбранному направлению') bot.send_sticker(message.chat.id, random.choice(loadstickerpack)) bot.send_message( message.chat.id, 'Билеты по маршруту {0} - {1} на {2} '.format( fromplace, toplace, dateregistration) + "\n" + reader.read())
def elaborate(name, ocr=False, lang="eng", debug=False): global phase nameDoc = name app_folder = os.getcwd() fi = os.path.join(app_folder, "raw_data") fo = os.path.join(app_folder, "images") phase = 1 cropper.crop(fi, fo, debug) if ocr: fi, fo, focr, foPDF = fo, os.path.join( app_folder, "images"), os.path.join(app_folder, "hocr"), os.path.join( app_folder, "pdf_complete") phase = 2 reader.read(fi, fo, focr, foPDF, lang, debug, name) phase = 0
def GetRatio(self, request, context): print("send to client current status for:", request.baseCurCode) filter_fun = filter_factory(request.baseCurCode, request.wantedCurCodes) raw_ratio = filter(filter_fun, read(self.filename)) ratio = map(map_raw_ratio, raw_ratio) return CurrenciesRatio(ratio=list(ratio))
def run(method='read', expr=None, vars=None, time=None, fields=None, limit=1000, sort=None, fill=None): # Create an empty response object. response = geoweb.empty_response(); # Check the requested method. if method not in ['find', 'read']: response['error'] = "Unsupported data operation '%s'" % (method) return bson.json_util.dumps(response) # Decode the strings into Python objects. try: if expr is not None: expr = decode(expr, 'expr', response) if vars is not None: vars = decode(vars, 'vars', response) if time is not None: time = decode(time, 'time', response) if fields is not None: fields = decode(fields, 'f', response) if sort is not None: sort = decode(sort, 'sort', response) if fill is not None: fill = decode(fill, 'fill', response) else: fill = True except ValueError: return bson.json_util.dumps(response) # Cast the limit value to an int try: limit = int(limit) except ValueError: response['error'] = "Argument 'limit' ('%s') could not be converted to int." % (limit) return bson.json_util.dumps(response) # Perform the requested action. if method == 'find': # @todo This method should find the matching data on the server pass elif method == 'read': # Load reader module import reader try: it = reader.read(expr, vars, time) # Create a list of the results. if fill: results = [it] else: results = [] # Create an object to structure the results. retobj = {} retobj['count'] = 1 retobj['data'] = results # Pack the results into the response object, and return it. response['result'] = retobj except IOError as io: response['error'] = io.message else: raise RuntimeError("illegal method '%s' in module 'mongo'") # Return the response object. return bson.json_util.dumps(response)
def test_step6_reader_read_string(self): read = reader.read('(read-string "(1 2 (3 4) nil)")') self.assertTrue(isinstance(read, MalList)) arg = read.native()[1] self.assertTrue(isinstance(arg, MalString)) native_str = arg.native() self.assertEqual("(1 2 (3 4) nil)", native_str)
def move_abs_run_agg(direction, aggregate): """ Changes absorber position, runs direction with output to dataframe (as Direction class attribute), calculates aggregate of dataframe columns (sum, mean, etc) returns new dataframe with coords and columns aggregate """ cols = ["efficiency", *reader.columns.keys()] df = pd.DataFrame(columns=["abs_x", "abs_y", *cols]) for x in tqdm(abs_positions(centered_x)): for y in abs_positions(centered_y): move_absorber(direction.geometry_path, x, y) direction.df = export.df(direction) tr_df = reader.read(direction) df = df.append( { "abs_x": round(x, 3), "abs_y": round(y, 3), "efficiency": getattr(tr_df["efficiency"], aggregate)(), "potential_flux": getattr(tr_df["potential_flux"], aggregate)(), "absorbed_flux": getattr(tr_df["absorbed_flux"], aggregate)(), "cos_factor": getattr(tr_df["cos_factor"], aggregate)(), "shadow_losses": getattr(tr_df["shadow_losses"], aggregate)() }, ignore_index=True) move_absorber(direction.geometry_path, 0, 0) csvpath = direction.raw_file.split(".")[0] + f"-{aggregate}.csv" df.to_csv(csvpath, index=False)
def read_n_map(self): """ Read input. Lengths is the max distance for each document """ if not self.params['window']: lengths, sents, self.documents, self.entities, self.pairs = \ read(self.input, self.documents, self.entities, self.pairs) else: lengths, sents, self.documents, self.entities, self.pairs = \ read_subdocs(self.input, self.params['window'], self.documents, self.entities, self.pairs) self.find_max_length(lengths) # map types and positions and relation types for did, d in self.documents.items(): self.add_document(d) for did, e in self.entities.items(): for k, v in e.items(): self.add_type(v.type) for dist in np.arange(0, self.max_distance + 1): self.add_dist(dist) for did, p in self.pairs.items(): for k, v in p.items(): if v.type == 'not_include': continue self.add_relation(v.type) assert len(self.entities) == len(self.documents) == len(self.pairs)
def _parse_tweets(tweets_csv, f): ''' format of each tweet: { text: string, original text of tweet msg, unigrams: string[], relevant bits of tweet msg, tagged_unigrams: string[], relevant bits of tweet msg, POS-tagged, datetime: float, created date of tweet in Unix time, users: string[], user ids of relevant users, rt_count: int, no. of times retweeted, fav_count: int, no. of times favorited } ''' for json in reader.read(tweets_csv): tweet = {} # text tweet['text'] = json['text'] tweet['unigrams'], tweet['tagged_unigrams'] = _parse_text(json['text']) # datetime tweet['datetime'] = _parse_datetime(json['created_at']) # user ids tweet['users'] = [] _append_if_exists(json['user']['id_str'], tweet, 'users') _extend_if_exists(json['entities']['user_mentions'], 'id_str', tweet, 'users') _append_if_exists(json['in_reply_to_user_id_str'], tweet, 'users') # counts tweet['rt_count'] = json['retweet_count'] tweet['fav_count'] = json['favorite_count'] f(tweet)
def start(): for c in code: expr = read(c) if read_only: print(repr(expr)) else: print(expr.eval(global_env))
def testName(self): # read data data = reader.read("../data/log_1_fixed.txt", jstartline=15000, maxlines=5000) # preprocess data preprocess.preproc(data) # initialize model layers = [13, 8, 1] activf = [ activation.linear(), activation.tanh(), activation.sigmoid() ] # activation.tanh(1.75, 3./2.), net = ffnet.FFNet(layers, activf) net.initw(0.1) # create training options opts = trainsg.options() # write function f = open("../output/trainsg_test.txt", "w+") writefcn = lambda s: f.write(s) # training trainsg.train(data, opts, net, writefcn) # close file f.close()
def test_reader(self): got = reader.read('data.in') self.assertIsNotNone(got) self.assertIsInstance(got['entries'], list) self.assertIsInstance(got['errors'], list) self.assertTrue(len(got['entries']) > 0) self.assertTrue(len(got['errors']) > 0)
def main(): """The main function of this program. """ structure = None print("Welcome to {0}.".format(basename(__file__))) print("=" * 76) print_help() while True: in_str = input("your command>>>\n").lower().strip() if in_str.startswith("quit"): print("Bye, bye.") return elif in_str.startswith("help"): print_help() elif in_str.startswith("open"): filenm, nstrips = in_str.replace("open ", "").split(" into ") structure = read(filenm, int(nstrips)) structure.print_strip_statistics() elif in_str.startswith("p") or in_str.startswith( "c") or in_str.startswith("r"): if structure is None: print("No points read yet, open a file first!") else: print_statistics(structure.query(parse(in_str)))
def solve(problems): files = {'a': 'a_example.txt', 'b': 'b_read_on.txt', 'c': 'c_incunabula.txt', 'd': 'd_tough_choices.txt', 'e': 'e_so_many_books.txt', 'f': 'f_libraries_of_the_world.txt'} pool = Pool() for f in problems: run_file = files[f] days_left, remaining_libs = reader.read('./inputs/' + run_file) outputs = [] while days_left > 0 and len(remaining_libs) > 0: # Tuning: # For b, c, f: 50 is better than 0 # For e: 0 is better than 50 scores = pool.map(lambda x: x.get_score(days_left), remaining_libs) next_lib = remaining_libs[np.argmax(scores)] _ = pool.map(lambda x: x.scan_copy(), next_lib.books.values()) remaining_libs.remove(next_lib) next_lib.books = next_lib.avail_books(days_left) if not next_lib.books: continue _ = pool.map(lambda x: x.remove_dupes(next_lib.books.keys()), remaining_libs) days_left = days_left - next_lib.signup outputs.append(next_lib) writer.write('./outputs/' + run_file, outputs) return scorer.score(run_file)
def testName(self): # read data data = reader.read("../data/log_1_fixed.txt", jstartline=15000, maxlines=5000) # preprocess data preprocess.preproc(data) # initialize model layers = [13, 8, 1] activf = [activation.linear(), activation.tanh(), activation.sigmoid()] # , activation.tanh(1.75, 3./2.), net = ffnet.FFNet(layers, activf) net.initw(0.1) # create training options opts = trainb.options() # write function f = open("../output/trainb_test.txt", "w+") writefcn = lambda s: f.write(s) # training trainb.train(data, opts, net, writefcn) # close file f.close()
def loader(parent_dir, override_db_name=False): parent = pathlib.Path(parent_dir) db_name = override_db_name or DB_FILENAME if parent.exists() is False: raise RuntimeError( f"Provided {parent=!r} but this dir couldn't be found") if parent.is_dir() is False: raise RuntimeError(f"Provided {parent=!r} is not a directory") print(f"Creating DB") create_schema(db_name) print("Connecting to DB") conn = sqlite3.connect(db_name) cursor = conn.cursor() print("Storing parent path") cursor.execute("INSERT INTO ParentDir(path) VALUES(?)", [str(parent)]) conn.commit() cursor.execute("SELECT id FROM ParentDir WHERE path=?", [str(parent)]) parent_id = cursor.fetchone()[0] print(f"Processing {parent=!r}") for index, song in enumerate(walker(parent)): if song.name.endswith(( ".mp3", ".ogg", )): # print(f"Found {index}: {song.name=}") tags = read(song) columns = "title,track,artist_id,album_id,filesize,duration,filename,rel_path,parent_dir" rel_path = str(song).replace(str(parent), "") data = [ tags.title, tags.track, Artist.Get(conn, tags.albumartist), Album.Get(conn, Artist.Get(conn, tags.albumartist), tags.album), tags.filesize, tags.duration, tags.filename, rel_path, parent_id ] try: cursor.execute( f"INSERT INTO Song({columns}) VALUES(?,?,?,?,?,?,?,?,?)", data) except sqlite3.IntegrityError: print(f"Sus duplicate: {song=}, {tags.title=}, {parent_id=}") else: print(f"WARNING - {song.name}") conn.commit() conn.close()
def addDatasets(self, platTrack, fileList, nameList, bands): # appends a list of 2D or 3D datsets to the geometry group. Can be lat.rdr, lon.rdr, z.rdr, los.rdr, a mask file, etc import reader if fileList is not None: self.h5file = h5py.File(self.output, 'a') numDataSets = len(fileList) for i in range(numDataSets): print('adding ', fileList[i]) if bands is None: data = reader.read(fileList[i]) else: data = reader.read(fileList[i], bands=[bands[i]]) self.h5file['/' + platTrack + '/geometry'].create_dataset( nameList[i], data=data, shape=data.shape, dtype=data.dtype) self.h5file.close()
def readImage(reader): imageList = [] for i in range(28): imageRowList = [] for j in range(28): imageRowList.append(reader.read()) imageList.append(imageRowList) return imageList
def readImageLinear(reader): imageList = [] for i in range(28): imageRowList = [] for j in range(28): imageRowList.append(transGrayToBinary(reader.read())) imageList.append(imageRowList) return imageList
def load(): global __user_list # Read the stored data from the file. data = reader.read(DATA_FILE) # Deserialize the data from string. __user_list = json.loads(data) return __user_list
def addDatasets(self, platTrack, fileList, nameList, bands): # appends a list of 2D or 3D datsets to the geometry group. Can be lat.rdr, lon.rdr, z.rdr, los.rdr, a mask file, etc import reader if fileList is not None: self.h5file = h5py.File(self.output, 'a') numDataSets = len(fileList) for i in range(numDataSets): print('adding ', fileList[i]) if bands is None: data = reader.read(fileList[i]) else: data = reader.read(fileList[i], bands=[bands[i]]) dsg = self.h5file['/'+platTrack+'/geometry'].create_dataset( nameList[i], data=data, shape=data.shape, dtype=data.dtype) self.h5file.close()
def read(self, family): self.get_metadata(family) bands_key = self.processor + '-' + family if bands_key in bandsDict.keys(): bands = bandsDict[bands_key] else: bands = None data = reader.read(self.file, self.processor, bands=bands) return data, self.metadata
def main(): option = input("What do you want to do?" "\t1 for the Hazanot-O-mat" "\t2 for a CSV of all data\n") write = {'1': hazanotomat.write, '2': csvfy.write}.get(option) or exit(0) write(reader.read()) report_uuid_errors() print("Done")
def set_layout(): global df df = read() return html.Div([ dcc.Location(id='url', refresh=False, href='/bedas'), navbar(), dbc.Container(id="content", style={"padding": "20px"}, children=[home(df)]) ])
def load(dataset="training", data_size=10000): # Lamda functins for preprocessing imgs = lambda dset : \ np.array([data[1] for data in dset], dtype='f') labels = lambda dset: np.array([data[0] for data in dset]) dset = list(reader.read(dataset=dataset, data_size=data_size)) return (imgs(dset), labels(dset))
def load_variables(): variables = dict() tabs = ['colegiado', 'formacao_complementar', 'bot'] for tab in tabs: data = read(VARIABLES_SHEET, tab) for row in data: k = row[0] value = row[1] variables['var_' + k] = value return variables
def main(): """The main function of this program. """ structure = None shape = None points = [] print("Welcome to {0}.".format(basename(__file__))) print("=" * 76) print_help() while True: try: in_str = input("your command>>>\n").lower().strip() if in_str.startswith("quit"): print("Bye, bye.") return elif in_str.startswith("help"): print_help() elif in_str.startswith("open"): filenm, nstrips = in_str.replace("open ", "").split(" into ") structure = read(filenm, int(nstrips)) structure.print_strip_statistics() elif in_str.startswith("p") or in_str.startswith( "c") or in_str.startswith("r"): if structure is None: print("No points read yet, open a file first!") else: shape = parse(in_str) points = structure.query(shape) print_statistics(points) # custom dump for testing elif in_str.startswith("dump") and shape and structure: with open('strips.wkt', "w") as fh: fh.write(structure.dumps_strips()) with open('points.wkt', "w") as fh: fh.write(structure.dumps_points()) with open('shape.wkt', "w") as fh: fh.write('shape;\n%s;' % shape) with open('result.wkt', "w") as fh: fh.write('points;\n') for p in points: fh.write('%s;\n' % p) else: print("Input not understood (use 'help')") except AssertionError: print('Invalid input value!')
def test_read(self): records = [] for record in reader.read("test/resources/test_file.json"): records.append(record) self.assertEqual(len(records), 1) record = records[0] fields = [key for key in record.keys()] fields.sort() expected = ["latitude", "longitude", "user_id", "name"] expected.sort() self.assertListEqual(fields, expected)
def main(): #situation sit = reader.read(dirname(abspath(__file__))+'/../tools/data/bb.csv') #load data file for historical situation #requirement dam = BhumibolDam() #simple bhumibol dam requirement sim = Simulation(dam,sit,simple_alg) #make simulation with dam requirement, situation, and your chosen algorithm result = sim.run(True) #use sim.run() or sim.run(False) to abort when there is an error #it also returns the array or struct of bookkeeping result #try printing the result[0] to see what each element contain fig,ax = sim.plot(sit) ax.set_xlim(xmin=datetime.date(2009,01,01)) plt.show()
def check_locale(path=""): global INVALIDS path = os.path.normpath(path) if ((not path == ".") and path.startswith(".")) or path.startswith("_"): return print(" " * (len(os.path.split(path)) - 1), "Folder:", path, sep="") folders = [] for item in os.listdir(path): npath = os.path.normpath(os.path.join(path, item)) if item.endswith(".locale"): beautiful_path = " " * len(os.path.split(npath)) + npath try: reader.read(npath) except Exception as e: print(beautiful_path, "FAIL(%s)" % e) INVALIDS += 1 else: print(beautiful_path, "is valid") elif os.path.isdir(npath): folders.append(npath) for folder in folders: check_locale(folder)
def read_and_display(): csv_data = hreader.read('list.csv') header_count = csv_data[0] content = csv_data[1] elements_printed = 0 dclr.foreground_paint('Yellow', '') for element in content: dclr.foreground_paint('Yellow', element) elements_printed += 1 if elements_printed % header_count == 0: dclr.foreground_paint('Blue', '----')
def main(): corpus = reader.read('hamlet.txt') unigrams = generate_ngrams(corpus, 1) bigrams = generate_ngrams(corpus, 2) trigrams = generate_ngrams(corpus, 3) unigram_frequencies = get_corpus_frequencies(unigrams) bigram_frequencies = get_corpus_frequencies(bigrams) trigram_frequencies = get_corpus_frequencies(trigrams) print_most_frequent("unigram", unigram_frequencies, 10) # 10 most frequent print_most_frequent("bigram", bigram_frequencies, 10) print_most_frequent("trigram", trigram_frequencies, 10)
def main(): # load training data data = reader.read("../data/log_1_fixed.txt") # preprocess preprocess.preproc(data) # shuffle data perm = range(len(data)) random.shuffle(perm) # train a network ntrain = 100000 dtrain = la.idxview(data, perm[:ntrain]) net = train(0, dtrain) # evaluate on training data evaluate(dtrain, net) # evaluate on test data devaluate = la.idxview(data, perm[ntrain:2*ntrain]) evaluate(devaluate, net)
except ImportError: pass # but not everyone has it import sys from reader import read from expr import global_env # program start if __name__ == '__main__': """Run a read-eval-print loop. `python3 repl.py` to start an interactive REPL. `python3 repl.py --read` to interactively read expressions and print their Python representations. """ read_only = len(sys.argv) == 2 and sys.argv[1] == '--read' while True: try: # `input` prints the prompt, waits, and returns the user's input. user_input = input('> ') expr = read(user_input) if expr is not None: if read_only: print(repr(expr)) else: print(expr.eval(global_env)) except (SyntaxError, NameError, TypeError) as err: print(type(err).__name__ + ':', err) except (KeyboardInterrupt, EOFError): # Ctrl-C, Ctrl-D print() # blank line break # exit while loop (and end program)
features.append(f3) f = border_definition(image, outline_mask) features.append(f) f = radial_gradient_index(image, outline_mask) features.append(f) f = tangential_gradient_index(image, outline_mask) features.append(f) # f = line_enhancement_index(image, outline_mask) # features.append(f) return features if __name__=='__main__':# A test main function, never used import sys outline_mask = get_outline_mask('(252, 399),(252, 399),(250, 399),(249, 399),(248, 399),(247, 399),(246, 399),(244, 399),(243, 399),(241, 399),(234, 402),(233, 403),(231, 406),(228, 408),(226, 413),(224, 414),(224, 415),(222, 417),(222, 418),(222, 421),(222, 424),(222, 425),(222, 427),(222, 429),(222, 432),(222, 435),(224, 437),(225, 438),(227, 440),(228, 441),(229, 443),(230, 443),(230, 444),(231, 445),(232, 445),(233, 445),(234, 445),(236, 446),(238, 446),(239, 446),(240, 446),(241, 445),(243, 444),(245, 443),(246, 442),(247, 441),(249, 441),(252, 439),(256, 435),(257, 435),(257, 434),(258, 432),(262, 428),(263, 428),(264, 427),(266, 426),(266, 425),(266, 423),(268, 418),(268, 417),(268, 415),(268, 413),(268, 412),(269, 411),(269, 409),(269, 408),(270, 407),(271, 403),(271, 402),(271, 401),(271, 400),(271, 399),(271, 398),(271, 397),(270, 396),(269, 395),(269, 394),(268, 393),(267, 393),(266, 393),(264, 393),(263, 393),(262, 393),(261, 393),(260, 393),(259, 394),(258, 394),(257, 394),(256, 394),(255, 394),(254, 394),(253, 394)', 560, 560) #print np.array_equal(img.astype(np.uint8), rasterize(img)) #val = degree_of_circularity(rasterize(img)) #val = degree_of_ellipticity(img) #print val #fm, rmsv, doi = marginal_irregularity(img) #print border_definition(img, img) dcm = reader.read("000001.dcm") print dcm.shape f = tangential_gradient_index(dcm, outline_mask) print f f = line_enhancement_index(dcm, outline_mask) print f
def ToneBurst(): global points,lastcanvas,lastcanvas2,values data=[] for i in range(4): t1=Record() t2=Play() t2.start() t1.start() while t1.isAlive() or t2.isAlive(): continue data.append(reader.read(RECORDING_FILENAME,AMBIENT_FILENAME)) t = arange(len(data[2]))*1.0/RATE f=Figure(figsize=(6,4),dpi=100) a=f.add_subplot(111) a.plot(t,data[2]) a.set_title('Amplitude Waveform') a.set_xlabel('Time') a.set_ylabel('Amplitude') canvas=FigureCanvasTkAgg(f,master=root) canvas.show() if lastcanvas!=None: lastcanvas.pack_forget() lastcanvas=canvas.get_tk_widget() lastcanvas.pack(side=Tk.LEFT, fill=Tk.BOTH, expand=1) canvas._tkcanvas.pack(side=Tk.LEFT, fill=Tk.BOTH, expand=1) c80=reader.c80(data[2],RATE,TIME) c80_string="Clarity(C80) value is "+str(c80)+" dB" c80_label.config(text=c80_string) snd_energy=reader.soundEnergy(data[2],RATE,TIME) SS_string="Strength of sound received is "+str(snd_energy) SS_label.config(text=SS_string) data2=[] m=10000000 for dat in data: data2.append(reader.dB(dat,RATE)) if(len(data2[-1])<m): m=len(data2[-1]) print m, "lalal" for i in range(4): data2[i]=data2[i][:m] mdat=[] for j in range(m): mdat.append(median([data2[0][j],data2[1][j],data2[2][j],data2[3][j]])) t2=arange(m)*1.0/RATE f2=Figure(figsize=(6,4),dpi=100) a2=f2.add_subplot(111) a2.plot(t2,mdat,color='r') a2.plot(t2, data2[0],color='g') a2.plot(t2, data2[1],color='b') a2.plot(t2, data2[2],color='y') a2.plot(t2, data2[3],color='k') a2.set_title('Sound Pressue Levels') a2.set_xlabel('Time') a2.set_ylabel('dBu(RMS)') #try: r_time,t_beg,t_end=reader.RT(mdat,RATE,TIME,False) RT_string="Reverberation Time (RT20) is "+str(r_time*1000)+" milliseconds. \n(Note:The red interval shows 20dB decay, which is extrapolated over 60dB to get RT)" RT_label.config(text=RT_string) a2.axvline(TIME/1000., color='k') a2.axvline(t_beg, color='r') a2.axvline(t_end, color='r') ## except: ## RT_string="Reverberation Time could not be measured. Try increasing the volume, or try a Frequency between 250 Hz and 2000 Hz" ## RT_label.config(text=RT_string) canvas2=FigureCanvasTkAgg(f2,master=root) canvas2.show() if lastcanvas2!=None: lastcanvas2.pack_forget() lastcanvas2=canvas2.get_tk_widget() lastcanvas2.pack(side=Tk.RIGHT, fill=Tk.BOTH, expand=1) canvas2._tkcanvas.pack(side=Tk.RIGHT, fill=Tk.BOTH, expand=1) values=(r_time,c80,snd_energy) label.config(text="Please check if all values have been recorded. Measure again?") y_button.config(text="Yes") n_button.config(command=Prepare,state=Tk.NORMAL)
import csv from os.path import dirname from matplotlib import pyplot as plt from math import sin,pi import sys sys.path.append(dirname(__file__)+'../../natee/') import reader import util fname = 'bb.csv' data = reader.read(dirname(__file__)+'../data/'+fname) data = [(x.date,x.water_lvl,x.water_in*50) for x in data] date,lvl,influx = zip(*data) period = 365 ur = [sin(2*pi*x/365)*262+13379 for x in range(len(lvl))]#luckily the shift is 0 for bb dam lr = [(sin(2*pi*x/365)*2.5+237.5)*13462./260. for x in range(len(lvl))] fig = plt.figure() ax = fig.add_subplot(111) ax.plot(range(len(influx)),influx,label = 'incoming water per day scaled up by 50',alpha=0.7,color ='green') ax.plot(range(len(lvl)),lvl,label = 'water level',lw=2,alpha=0.7,color='red') ax.plot(range(len(ur)),ur,color='blue',label="upper/lower rule") ax.plot(range(len(lr)),lr,color='blue') xticks = range(0,7500,365) ax.set_xticks(xticks) xticklabels = [ util.date2td(date[i]) if i < len(date) else '' for i in xticks ] ax.set_xticklabels(xticklabels,rotation = 45) locs = ax.get_xticks() ax.set_title('Water Level in Bhumibol Dam') ax.set_ylabel('million m^3')
import sys sys.path.insert(0, '/home/zack/Desktop') import reader path = "/home/zack/Desktop/data/pm15.csv" data = reader.read(path) for i in range(len(data)): print data[i]
import random import proceduralRandom from reader import read_file as read import os.path #The text directory TEXT_DIR = 'data/' if not os.path.isfile(TEXT_DIR+'senSubjects'): TEXT_DIR = '../'+TEXT_DIR subjects = read(TEXT_DIR + 'senSubjects').split(',') verbs = read(TEXT_DIR + 'senVerbs').split(',') verbsH = read(TEXT_DIR + 'senVerbsH').split(',') nouns = read(TEXT_DIR + 'senNouns').split(',') adjectives = read(TEXT_DIR + 'senAdjectives').split(',') adverbs = read(TEXT_DIR + 'senAdverbs').split(',') articles = ['the','a'] vowels = ['a','e','i','o','u','y'] def oneOf(theList,minRange = 1): return theList[random.randint(minRange - 1,len(theList)-1)] def adjs(): repTimes = proceduralRandom.proceduralRandom()
with open(path, 'r') as f: for line in f: yield line.split('\t') HIERARCHY = dict([(a[1], [a[0]]) for a in db('hierarchy.txt')]) def ancestors(child): if child not in HIERARCHY: return [] parents = HIERARCHY[child] grand_parents = ancestors(parents[-1]) if grand_parents == []: return parents parents = parents + grand_parents return parents def reverse_ancestor(child): a = ancestors(child) a.reverse() return a if __name__ == '__main__': from reader import read for doc in read('allCountries.txt'): a = ancestors(doc['geonameid']) if a != []: print doc['name'], a
from reader import read from preprocessor import preprocess from naivebayes import NaiveBayesClassifier from knn import KNNClassifier from metrics import calculate_metrics import sys if __name__ == '__main__': if len(sys.argv) != 2: print("Wrong number of arguments. Please specify a classifier. Choose from [naivebayes, knn]") else: if sys.argv[1] == 'naivebayes' or sys.argv[1] == 'knn': annotated_texts = read('blog-gender-dataset.xlsx') training_set_len = 0.7 * len(annotated_texts) training_set = [] test_set = [] for (text,gender) in annotated_texts: if 'M' in gender: gender = 'M' else: gender = 'F' if len(training_set) < training_set_len: training_set.append((preprocess(text), gender)) else: test_set.append((preprocess(text), gender))
def read(args): import reader output = reader.read(args[0]) outfile = os.path.splitext(args[0])[0] + '.json' reader.write(output, outfile) print 'Completed rolodex file: %s' % outfile
nodes = sys.argv[2:] else: nodes = '127.0.0.1' print("nodes", nodes) es = Elasticsearch(nodes) if es.indices.exists('geoname'): es.indices.delete('geoname') print es.indices.create(index='geoname', body={ 'mappings': mappings, 'settings': settings} ) bulk(es, indexer(read(src))) es.indices.refresh('geoname') # 36m31.860s for 8600414 documents print es.indices.stats('geoname') #res = es.search(index="geoname", body={"query": {"match_all": {}}}) #es.search('geoname', { #'query': { #'filtered': { #'filter': { #'term': {'cc': 'FR'} #}, #'query': { #'query_string': {'query': 'Gre%'} #}
parser.error('invalid --wrap-output value: must be an integer or "no"') config.defines = {} if options.defines != None: for define in options.defines: d = define.split('=') if len(d) == 1: config.defines[d[0]] = '' else: config.defines[d[0]] = '='.join(d[1:]) import reader, writer try: read_ok = reader.read(args[0]) finally: if xmlparser.cache != None: xmlparser.cache.close() xmlparser.cache = None if not read_ok: sys.exit(1) if options.dump: import mk_dump mk_dump.dumpMakefile() else: if not writer.write(): sys.exit(1)