def run(seed): ans = sol_fn(seed, inp, log) process(inp, ans, seed, sc_fn, args.testcase, ignore=args.ignore, force=args.force)
def run(seed): ans = get_ans(seed) process(inp, ans, seed, sc_fn, args.testcase, ignore=args.ignore, force=args.force)
def get_discography(self, artist, song_name): """ Return the list of albums and their track names. Invalid albums (as decided by `is_value_invalid()`) are not included. Song names are preprocessed using `process()`. The result is a dictionary indexed by album name and sorted by release date. """ query = self.sp.search(f'artist:{artist} track:{song_name}', type='track') artist_id = query['tracks']['items'][0]['artists'][0]['id'] query = self.sp.artist_albums(artist_id, album_type='album') artist_albums = {} while query: for album in query['items']: name = process(album['name'], key='album') name = name.lower() if is_value_invalid(name, key='album'): continue _set_release_date(album) elem = dict(id=album['id'], release_date=album['release_date']) artist_albums[name] = elem query = self.sp.next(query) sort = sorted(artist_albums.items(), key=lambda x: x[1]['release_date']) artist_albums = dict(sort) album_ids = [album['id'] for album in artist_albums.values()] for albums, ids in chunks(artist_albums.values(), album_ids, 20): query = self.sp.albums(ids) for album, response in zip(albums, query['albums']): tracks = [] while response: if 'tracks' in response: response = response['tracks'] tracks.extend( process(t['name'], key='name').lower() for t in response['items']) response = self.sp.next(response) tracks = dict.fromkeys(tracks) tracks.pop('Unknown', None) album['tracks'] = list(tracks) return { k: v for k, v in artist_albums.items() if v.get('tracks', None) }
def _addrow(self, row, tablename): c = self.conn.cursor() (transcript_si, transcript, decode_si, decode, conf, decode_time, callsrepath, acoustic_model, date, time, milliseconds, grammarlevel, firstname, lastname, oration_id, chain, store) = process(row) # There might a better way. Breaking out of a function if the transcript column is empty. # This files without transcription are skipped if transcript in ['', '""', ' ', None, 'NULL', '(NULL)']: print 'No transcription for %s' print callsrepath return False # Insert row into database # Check if row exists. If yes don't add. If not add datarow_exist_status = self._check_if_row_exists( time, milliseconds, firstname, lastname, grammarlevel, tablename) if datarow_exist_status: print 'The data row you are trying to add might already exist' else: print 'Adding data row to database' sql_statement = '''INSERT INTO %s VALUES ("%s", "%s", "%s", "%s", %d, %d, "%s", "%s", %s, %s, %s, "%s", "%s", "%s", "%s", "%s", "%s", "%s")''' % ( tablename, transcript_si, transcript, decode_si, decode, int(conf), int( decode_time), callsrepath, acoustic_model, date, time, milliseconds, grammarlevel, firstname, lastname, oration_id, chain, store, row) try: c.execute(sql_statement) except: print 'Could not enter row to database'
def test_1(): from util import read_file_to_list from util import process data = read_file_to_list("testinput.txt") terminate, acc = process(data) assert terminate == False assert acc == 5
def capture(self, image_name): currentDir = os.getcwd() img_path = "%s/%s.jpg" % (currentDir, image_name) print('image path:' + img_path) self.camera.capture(img_path, use_video_port=True) image = util.process(img_path, assemble.get_height_each()) self.session_images.append(image)
def capture(self, image_name): currentDir = os.getcwd() img_path = "%s/%s.jpg" % (currentDir, image_name) print("image path:" + img_path) self.camera.capture(img_path, use_video_port=True) image = util.process(img_path, assemble.get_height_each()) self.session_images.append(image)
def generate_victim_offender(): victims = [] offenders = [] final = [] file_path = util.find_all("people.json") count = 0 with open(file_path, "r") as people_json: people = json.load(people_json) for person in people: if person['Victim']: victims.append(person['SSN']) else: offenders.append(person['SSN']) count += 1 util.process(count) # now lets make the connection between the two arrays. print(f"length of victims: {len(victims)}") print(f"length of offenders: {len(offenders)}") # length of victims is always larger than offenders (percentages) # therefore, we have a temp_offenders array that stores all deleted offenders # in case we run out of offenders to pair with victimes, hence the if stmt temp_offenders = [] for victim in victims: length = len(offenders) - 1 if length < 0: l = len(temp_offenders) - 1 num = random.randint(0, l) offender = temp_offenders[num] temp_offenders.remove(temp_offenders[num]) temp = [victim, offender] final.append(temp) else: num = random.randint(0, length) offender = offenders[num] temp_offenders.append(offenders[num]) offenders.remove(offenders[num]) temp = [victim, offender] final.append(temp) util.output_SQL("VICTIM_OFFENDER", final, "/mysql/insertVictimOffender.sql") util.output_json(final, "victim_offender.json")
def test_2(): from util import read_file_to_list from util import process from util import fix_command data = read_file_to_list("testinput.txt") data1 = fix_command(data, 7) terminate, acc = process(data1) assert terminate == True assert acc == 8
def __iter__(self): tokenizer = nltk.data.load('tokenizers/punkt/english.pickle') tknzr = TweetTokenizer(preserve_case=False); stop_words = set(stopwords.words("english")) for paragraph in self.paragraph_iterator(): raw_sentences = tokenizer.tokenize(paragraph.decode('utf8').strip()) for raw_sentence in raw_sentences: # process the sentence sentence = util.process(raw_sentence, tknzr, self.process_option, stop_words) yield sentence
def readCorpus(self,corpusName): print "Loading corpus" with open(corpusName,'r') as f: for tweet in f.readlines(): tweet = tweet.strip() #print tweet self.corpus.append(tweet) #print process(tweet) self.bagOfWords.append(process(tweet)) return self.bagOfWords
def generate_weapons(): file_name = util.find_all("weapons.csv") with open(file_name) as csv_file: csv_reader = csv.reader(csv_file, delimiter=',') line_count = 0 weapons = [] for row in csv_reader: if line_count == 0: # some glitch (weird UTF-8 symbol) weapon = row[0][1:] else: weapon = row[0] fatalities = row[1] temp = {weapon: fatalities} weapons.append(temp) line_count += 1 util.process(line_count) return weapons
def __iter__(self): tokenizer = nltk.data.load('tokenizers/punkt/english.pickle') tknzr = TweetTokenizer(preserve_case=False) stop_words = set(stopwords.words("english")) for paragraph in self.paragraph_iterator(): raw_sentences = tokenizer.tokenize( paragraph.decode('utf8').strip()) for raw_sentence in raw_sentences: # process the sentence sentence = util.process(raw_sentence, tknzr, self.process_option, stop_words) yield sentence
def fetch_album(self, song): """ Get the name of the album for a song from spotify. """ artist, title = song.artist, song.title self.fetch_discography(song) if not self.discography_cache.get(artist, ''): return 'Unknown' title = process(title, key='name') for album_name, info in self.discography_cache[artist].items(): if title.lower() in map(str.lower, info['tracks']): return album_name return 'Unknown'
def run(): camera.warmup(width, height) images = [] for i in range(takes): pic_paths = camera.take(1, width, height) start = time.time() image1 = util.process(pic_paths[0], assemble.get_height_each()) end = time.time() diff = end - start images.append(image1) print "took in: " + str(diff) + "ms" if(diff < PAUSE_MAX and i < takes - 1): sleep_time = PAUSE_MAX - diff print "sleeping for another: " + str(sleep_time) + "ms" time.sleep(diff) assemble.assemble(images)
def run(): camera.warmup(width, height) images = [] for i in range(takes): pic_paths = camera.take(1, width, height) start = time.time() image1 = util.process(pic_paths[0], assemble.get_height_each()) end = time.time() diff = end - start images.append(image1) print "took in: " + str(diff) + "ms" if (diff < PAUSE_MAX and i < takes - 1): sleep_time = PAUSE_MAX - diff print "sleeping for another: " + str(sleep_time) + "ms" time.sleep(diff) assemble.assemble(images)
def get_album_tracks(self, song): """ Get the list of tracks of the album this song belongs to. """ if song.album and song.album != 'Unknown': song.album = process(song.album, key='album', invalid=False) self.fetch_discography(song) else: logger.debug('song has no embedded album. searching') song.album = self.fetch_album(song) logger.debug('got this album: %s', song.album) try: if not song.album or song.album == 'Unknown': raise KeyError('Album not found') return self.discography_cache[song.artist][song.album]['tracks'] except KeyError: msg = 'Spotify could not find the list of tracks for %s' logging.info(msg, song) return []
if shuffle == 1: shuffled_pairs = util.random_shuffle(training_pairs) save_root = save_p + '/set%02d_%s' % (set_no, PHASE) if HNM == 1: save_root = save_root + '_hnm' print 'saved to: ' + save_root if os.path.exists(save_root): shutil.rmtree(save_root) os.makedirs(save_root) X = np.zeros((2000, 6, 160, 80), dtype=np.float32) map_size = X.nbytes * 1000 env = lmdb.open(save_root, map_size=map_size) util.process(shuffled_pairs, M, N, transformer, env) PHASE = 'test' training_pairs = [] for setname in dataset_list: if dataset_info_dict[setname]['Used'] == 1: filename_part = dataset_info_dict[setname]['PartitionTest'] if not setname == 'MARKET': main_dict = dataset_info_dict[setname]['Util'].collect_data( dataset_info_dict[setname]['DatasetPath']) this_list = dataset_info_dict[setname][ 'Util'].partition_file_to_list(filename_part) sub_dict = util.get_sub_dict(main_dict, this_list) else: main_dict = dataset_info_dict[setname]['Util'].collect_data( dataset_info_dict[setname]['DatasetPath'] +
sp.load_data() sp.train_df['X_train'] = list(sp.X_train) sp.train_df['y_train'] = list(sp.y_train) train_df = sp.train_df n_fold = 4 train_df.sort_values('coverage_class', inplace=True) train_df['fold'] = (list(range(n_fold)) * train_df.shape[0])[:train_df.shape[0]] subsets = [train_df[train_df['fold'] == i] for i in range(n_fold)] for fold_idx in range(n_fold): # get the train/val split X_tr, X_val, y_tr, y_val = get_train_val(subsets, fold_idx) # add depth information or triple the gray channel X_tr, y_tr = process(X_tr, y_tr, use_depth=use_depth) X_val, y_val = process(X_val, y_val, use_depth=use_depth) y_tr = np.squeeze(y_tr) y_val = np.squeeze(y_val) # prepare PyTorch dataset and dataloader train_ds = SaltDataset(X_tr, y_tr) val_ds = SaltDataset(X_val, y_val, transform=None) train_loader = torch.utils.data.DataLoader(train_ds, batch_size=32, shuffle=True) val_loader = torch.utils.data.DataLoader(val_ds, batch_size=32, shuffle=True) net = UNetResNet(34)
def run(solve_args): solve_args_orig = dict(solve_args) ans = get_ans(solve_args) process(inp, ans, solve_args_orig, sc_fn)
def __iter__(self): for document in self.field_iterator(setting.csv_option.review_name): yield util.process(document)
def test_process(): from util import process assert 73 == process('XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X', 11)
def test_process(): from util import process assert 0 == process([0, 3, 6], 10) assert 1 == process([1, 3, 2], 2020)
def summarize(self): for graph_id in self.dags.keys(): latency.process('%s/data/%s/dag' % (self._local_log_dir, graph_id), graph_id, '%s/summary' % (self._local_log_dir)) util.process('%s/util' % (self._local_log_dir), '%s/summary' % (self._local_log_dir))
def test_process(name, expect): assert process(name, key='name') == expect
def run(solve_args): solve_args_orig = dict(solve_args) ans = get_ans(solve_args) # run the solver function and get the answer process(inp, ans, solve_args_orig, sc_fn) # add to best submission or not