def get_test_predictions(self, test_filename, save_filename): test_dataset = DialogueDataset( test_filename, self.config.sentence_len, self.vocab, False) test_data_loader = torch.utils.data.DataLoader( test_dataset, self.config.val_batch_size, shuffle=True) with open(test_filename, 'r') as f: data = json.load(f) start = time.clock() phase_metrics = dict() epoch_loss = list() epoch_metrics = list() results = {"accuracy": list(), "precision": list(), "recall": list(), "F1": list()} average_epoch_loss = None for i, batch in enumerate(tqdm(test_data_loader, mininterval=2, desc='test', leave=False)): # prepare data src_seq, src_pos, src_seg, tgt = map( lambda x: x.to(self.device), batch[:4]) ids = batch[4] start_end_idx = batch[5] # forward pred = self.model(src_seq, src_pos, src_seg, tgt) loss = F.cross_entropy(self.prepare_pred(pred).view(-1, 2), tgt.view(-1)) average_loss = float(loss) epoch_loss.append(average_loss) average_epoch_loss = np.mean(epoch_loss) output = torch.argmax(self.prepare_pred(pred), 3) record_predictions(output, data, ids, start_end_idx) get_results(tgt.view(-1).cpu(), output.view(-1).cpu(), results) phase_metrics["avg_results"] = {key: np.mean(value) for key, value in results.items()} phase_metrics["loss"] = average_epoch_loss phase_metrics["time_taken"] = time.clock() - start string = ' {} loss: {:.3f} '.format('test', average_epoch_loss) print(string, end='\n') data["results"] = phase_metrics with open(save_filename, 'w') as f: json.dump(data, f) return phase_metrics
def execute_phase(self, epoch, phase): if phase == "train": self.model.train() dataloader = self.data_loader_train batch_size = self.config.train_batch_size train = True else: self.model.eval() dataloader = self.data_loader_val batch_size = self.config.val_batch_size train = False start = time.clock() phase_metrics = dict() epoch_loss = list() epoch_metrics = list() results = {"accuracy": list(), "precision": list(), "recall": list(), "F1": list()} average_epoch_loss = None for i, batch in enumerate(tqdm(dataloader, mininterval=2, desc=phase, leave=False)): # prepare data src_seq, src_pos, src_seg, tgt= map( lambda x: x.to(self.device), batch[:4]) ids = batch[4] start_end_idx = batch[5] # forward if train: self.optimizer.zero_grad() pred = self.model(src_seq, src_pos, src_seg, tgt) loss = F.cross_entropy(self.prepare_pred(pred).view(-1, 2), tgt.view(-1)) average_loss = float(loss) epoch_loss.append(average_loss) average_epoch_loss = np.mean(epoch_loss) if train: self.writer.add_scalar("train_loss", average_loss, global_step=i + epoch * self.config.train_batch_size) # backward loss.backward() # update parameters self.optimizer.step_and_update_lr() output = torch.argmax(self.prepare_pred(pred), 3) get_results(tgt.view(-1).cpu(), output.view(-1).cpu(), results) phase_metrics["avg_results"] = {key: np.mean(value) for key, value in results.items()} phase_metrics["loss"] = average_epoch_loss phase_metrics["time_taken"] = time.clock() - start string = ' {} loss: {:.3f} '.format(phase, average_epoch_loss) print(string, end='\n') return phase_metrics
def addTracks(artist, tracks, artistNet): for track in tracks: # get list of users who have favorited this user's track favoriters = get_results(client, '/tracks/' + str(track.id) + '/favoriters') for user in favoriters: addAction('favorites', user, artist, addWeight('favorites', user, artist, artistNet, 'fav_weight')) # get list of users who have commented on this user's track commenters = get_results(client, '/tracks/' + str(track.id) + '/comments') for comment in commenters: addAction('comments', comment, artist, addWeight('favorites', comment, artist, artistNet, 'com_weight'))
def addTracks(profile, tracks): #, profileGraph): for track in tracks: # get list of users who have favorited this user's track favoriters = get_results(client, '/tracks/' + str(track.id) + '/favoriters') for favoriter in favoriters: addFav(favoriter.user, profile, track.id) # addAction('favorites', user, artist, addWeight('favorites', user, artist, profileGraph, 'fav_weight')) # get list of users who have commented on this user's track commenters = get_results(client, '/tracks/' + str(track.id) + '/comments') for commenter in commenters: addComment(commenter.user, profile, commenter.id)
def ga(conf, sample, start, end, step, typ, relations, basefile, metric): """ Genetic algorithm for black box optimization :param conf: list of parameters to tune :param sample: a sample configuration :param start: the lower limit for values of each parameter (a dictionary) :param end: the upper limit for values of each parameter (a dictonary) :param step: the step size for values of each parameter (a dictionary) :param typ: type of the parameter (int,boolean etc) (Not being used currently) :param relations: defines the relationship that should be maintained between parameters that are being tuned and other parameters to maintain correctness of configuration :param basefile: basefile that contains a sample of a full topology configuration :param metric: comma separated metrics """ # Initializations p = [] total_runs = 50 m = 12 #initial sample size mu_rate = 0.1 # Mutation rate rand_select = 0.1 # Random parent selection rate top = 0.2 #Percentage of top parents selected design_space = list() metric_values = list() numbers = list() result = dict(sample) # Generate the first n samples using LHS design_space = utils.generate_LHS(result, start, end, step, typ, relations, p, conf, m) # Get results and get the best configuration metric_values, numbers = utils.get_results(0, m, design_space, basefile, metric) while (len(design_space) <= total_runs): # Get two parents parents = get_parents(design_space, top, rand_select, metric) # Do a cross over between parents children = do_crossover(parents) # Perform mutations with a probability of 0.1 mu_children = do_mutations(children, mu_rate, design_space, start, end, step, typ, relations, conf) # If the child has been evaluated before skip it if mu_children in design_space: continue n = len(design_space) design_space.extend(mu_children) # Get the results from running the application and based on the utility function metric_values, numbers = utils.get_results(n, n + len(mu_children), design_space, basefile, metric)
def get_chosen_price_results(): user_query = request.form.get('user_query') price = request.form.get('median_price') higher_lower = request.form.get('price_choice') if higher_lower == 'higher': results = get_results(es_connection, user_query, min_price=price) else: results = get_results(es_connection, user_query, max_price=price) if results: brand_results = get_top_k_brands(results, top_k=5) return jsonify(status="OK", products=results, brands=brand_results) else: return jsonify(status="FAILED", error=404, message="No results found.")
def addTracks(profile, tracks): #, profileGraph): for track in tracks: # get list of users who have favorited this user's track try: favoriters = get_results(client, '/tracks/' + str(track.id) + '/favoriters') for favoriter in favoriters: addTrackFav(favoriter, profile) #, track.id) # addAction('favorites', user, artist, addWeight('favorites', user, artist, profileGraph, 'fav_weight')) # get list of users who have commented on this user's track commenters = get_results(client, '/tracks/' + str(track.id) + '/comments') for commenter in commenters: addTrackComm(commenter, profile) #, commenter.id) # addAction('comments', user, artist, addWeight('comments', comment, artist, profileGraph, 'com_weight')) except HTTPError: print "Track not processed due to HTTP error."
def job(query: str): message = None if not query.startswith('test'): job_id = utils.get_job_from_string(query) else: job_id = query job = utils.get_job(job_id) if not job: message = f'There isn`t job for word: "{query}"' else: if job.get_error_path(): message = f'Error for job for word: "{query}"' if message: flash(message, 'errors') return redirect(url_for('main')) try: job_results = utils.apply_window(utils.get_results(job)) except FileNotFoundError: return render_template("job.html", meta=job.get_meta(), inprogress=True, data=[], labels=[]) return render_template("job.html", meta=job.get_meta(), data=job_results.data, labels=list(map(str, job_results.labels)))
def update_graph(*args): data = data_source() filter_ids, date_col, feature = get_filters(data)[4:-1] type_converter = lambda filter: "'" if type(list(data[filter])[0]) == str else " " for f in range(len(filter_ids)): filter = filter_ids[f] conv = type_converter(filter) query_str = "" if args[f] != 'ALL': is_started = " " if query_str == "" else " and " query_str += is_started + " " + filter + " == " + conv + str(args[f]) + conv result_data = get_results(date_col) dff = result_data if query_str == "" else result_data.query(query_str) if len(dff) == 0: return {"data": [], "layout": go.Layout(height=600, title="Time Line Of " + feature)} else: trace = [go.Scatter(x=dff[date_col], y=dff['predict'], mode='markers+lines', customdata=dff[date_col], name='prediction'), go.Bar(x=dff[date_col], y=dff['predicted_label'])] return {"data": trace, "layout": go.Layout(height=600, title="Anomaly Detection and Prediction " + feature)}
def main(): cat_fn = "/scratch/ksf293/kavli/anomaly/data/hsc_catalogs/pdr2_wide_icmod_20.0-20.5_clean_more.csv" #cat_fn = "../data/hsc_catalogs/pdr2_wide_icmod_20.0-20.5.csv" cat = pd.read_csv(cat_fn) tag = 'gri_100k' results_dir = '/scratch/ksf293/kavli/anomaly/results' results_fn = f'{results_dir}/results_{tag}.h5' imarr_fn = f'/scratch/ksf293/kavli/anomaly/data/images_h5/images_{tag}.h5' #savetag = '_log' savetag = '' sigma = 0 reals, recons, gen_scores, disc_scores, scores, idxs, object_ids = utils.get_results( results_fn, imarr_fn, sigma=sigma) flag = 'cmodel_ellipse_radius' plot_vs_scores(idxs, scores, flag, cat, tag, savetag, band='i') flags = [ 'pixelflags_interpolated', 'pixelflags_saturated', 'pixelflags_clipped', 'pixelflags_rejected', 'pixelflags_inexact_psf', 'pixelflags_cr', 'pixelflags_clippedcenter', 'pixelflags_rejectedcenter', 'pixelflags_inexact_psfcenter' ]
def run_fourier_sarsa_experiments(transfer_episodes, transfer_epsilon, params): statistics = {"errors": [], "stopping_points": [], "utilities": []} filename = RESULTS_DIRECTORY + "fourier-sarsa-transfer-[{}]-[{}]-[{}].json".format( params["alpha"], params["epsilon"], params["order"]) print("Training on {} with [increment = {}]".format( PROBLEM_DIRECTORY + PROBLEM_FILES[0][0], PROBLEM_FILES[0][1])) metareasoning_env = env.Environment( PROBLEM_DIRECTORY + PROBLEM_FILES[0][0], ALPHA, BETA, PROBLEM_FILES[0][1]) prakhar = fourier_agent.Agent(metareasoning_env, params) prakhar.run_sarsa(statistics) for problem_file in PROBLEM_FILES[1:]: problem_file_path = PROBLEM_DIRECTORY + problem_file[0] increment = problem_file[1] params["episodes"] = transfer_episodes params["epsilon"] = transfer_epsilon print("Shifting to {} with [increment = {}]".format( problem_file_path, increment)) metareasoning_env = env.Environment(problem_file_path, ALPHA, BETA, increment) prakhar = fourier_agent.Agent( metareasoning_env, params, prakhar.function_approximator.weights, prakhar.function_approximator.action_value_function) prakhar.run_sarsa(statistics) utils.save(filename, statistics) return utils.get_results(statistics["errors"], WINDOW_SIZE, PLOT_WINDOW_SIZE)
def predict(bot, update): chat_id = update.message.chat_id msg = '' user_rephrase_times[chat_id][0] = 0 if update.message.text.lower() not in non_fin_words and is_finance( clf, vect, update.message.text): user_contexts[chat_id] += " " + clean_text(update.message.text) results = get_results(clf, vect, user_contexts[chat_id]) user_themes[chat_id] = [i[0] for i in results] if results[0][1] / results[1][1] > 3: msg += "Вас интересует тема \"" + labels[int( results[0][0])] + "\". Да?" custom_keyboard = [["Да"], ["Нет"]] mode = "SINGLE" else: msg += "Пожалуйста, уточните, какая тема вас интересует(Введите номер или выбирите в списке)" custom_keyboard = [[ str(i + 1) + '. ' + labels[int(results[i][0])] ] for i in range(4)] custom_keyboard.append(["0. Никакая из этих тем не подходит"]) mode = "MULTIPLE" user_check_times[chat_id] = [time.time(), False, mode] user_states[chat_id] = 'CHECK' reply_markup = telegram.ReplyKeyboardMarkup(custom_keyboard) bot.sendMessage(chat_id=chat_id, text=msg, reply_markup=reply_markup) else: msg += "Не похоже не финансовый текст" msg += cake bot.sendMessage(chat_id=update.message.chat_id, text=msg)
def run_experiment(self): if self.onEuler: self.run_euler_experiment(self.nethz_username) if self.nethz_username == 'xxx': self.processs_euler_experiment() return self.re_init_data() files = sorted([ os.path.join(CNF_FOLDER, f) for f in os.listdir(CNF_FOLDER) if os.path.isfile(os.path.join(CNF_FOLDER, f)) and f.endswith('.cnf') ]) for s in EXECUTABLES: exe = os.path.join(parent_parent, "./{}_main".format(s)) delete_files_in_folder(CNF_FOLDER, 'time') self.data[s] = {} for f in files: print('main: {} file: {}'.format(s, f)) self.data[s][f] = {} self.data[s][f]['info'] = get_info(f).__dict__ command = 'gtimeout {} mpirun -np 4 {} {}'.format( TIMEOUT, exe, f) run_n_times(command, REPETITIONS) timing_file = f[:-3] + 'time' times = get_results(timing_file) self.data[s][f]['time'] = times
def post_restart_phase(values, fx_new, x_new, fx0, x0, length, design_space, basefile, metric, metric_values, numbers, total_runs): if fx_new < numpy.percentile(values, 80): if fx_new < fx0: print "Potential best result" design_space.append(x_new) value, number = utils.get_results(length, length + 1, design_space, basefile, metric) metric_values.extend(value) numbers.extend(number) f_temp = min(list(value)) #f_temp = min(metric_values) #x_temp = design_space[numbers[metric_values.index(f_temp)]] x_temp = dict(x_new) length = len(design_space) if f_temp < fx0: if fx_new < f_temp: x0 = dict(x_temp) fx0 = f_temp else: x0 = dict(x_new) fx0 = fx_new print "Best result: " + str(fx0) if len(values) >= total_runs: return "terminate", design_space, metric_values, numbers, fx0, x0, length else: local_search = True return "localsearch", design_space, metric_values, numbers, fx0, x0, length else: if len(values) >= total_runs: return "terminate", design_space, metric_values, numbers, fx0, x0, length else: local_search = False return "restart", design_space, metric_values, numbers, fx0, x0, length
def restart_phase(design_space, result, start, end, step, typ, relations, p, conf, l, length, basefile, metric): design_space.extend( generate_LHS(result, start, end, step, typ, relations, p, conf, l)) # Get results and get the best configuration metric_values, numbers = utils.get_results(length, length + l, design_space, basefile, metric) return design_space, metric_values, numbers
def addTracks(artist, tracks, artistNet): for track in tracks: # get list of users who have favorited this user's track favoriters = get_results(client, '/tracks/' + str(track.id) + '/favoriters') for user in favoriters: addAction( 'favorites', user, artist, addWeight('favorites', user, artist, artistNet, 'fav_weight')) # get list of users who have commented on this user's track commenters = get_results(client, '/tracks/' + str(track.id) + '/comments') for comment in commenters: addAction( 'comments', comment, artist, addWeight('favorites', comment, artist, artistNet, 'com_weight'))
def test_api_query(self): new_tag = Tag.objects.create(name='new-tag') Post.objects.create(title='Post with another tag', published=True).tags.set([new_tag]) client = APIClient() response = client.get(reverse('post-list') + '?tag=tag2') self.assertEqual(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 1) self.assertEqual(data[0].get('id'), 1)
def test_api_tag_list(self): client = APIClient() response = client.get(reverse('tag-list')) self.assertEqual(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 3) self.assertEqual(data[0], {'id': 1, 'name': 'tag1', 'count': 1}) self.assertEqual(data[1], {'id': 2, 'name': 'tag2', 'count': 1}) self.assertEqual(data[2], {'id': 3, 'name': 'tag3', 'count': 0})
def test_posts_list_user_unpublished(self): client = APIClient() client.login(username='******', password='******') response = client.get(self.list_url) self.assertEqual(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 4) self.assertEqual(data[3]['id'], 4) self.assertEqual(data[3]['published'], False) self.assertEqual(data[3]['author']['id'], 2)
def gen_search_json(): start_time = time.time() query = request.args.get("q", '') query = utils.process_term(query) results = utils.get_results(query.strip()) resp = jsonify(results=results[:10]) # top 10 results resp.headers['Access-Control-Allow-Origin'] = '*' end_time = time.time() #print("Response time : " + str(end_time - start_time)) return resp
def get_initial_query_results(): user_query = request.form.get('user_query') results = get_results(es_connection, user_query) if results: median_price = get_price_info(results) return jsonify(status="OK", products=results, median_price=median_price) else: return jsonify(status="FAILED", error=404, message="No results found.")
def test_api_category_list(self): client = APIClient() response = client.get(reverse('category-list')) self.assertEqual(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 5) self.assertEqual(data[0], {'id': 1, 'name': 'root1', 'count': 0, 'parent': None}) self.assertEqual(data[1], {'id': 2, 'name': 'root2', 'count': 0, 'parent': None}) self.assertEqual(data[2], {'id': 3, 'name': 'root1-node1', 'count': 0, 'parent': 1}) self.assertEqual(data[3], {'id': 4, 'name': 'root1-node2', 'count': 1, 'parent': 1}) self.assertEqual(data[4], {'id': 5, 'name': 'root1-node2-node1', 'count': 0, 'parent': 4})
def results(): # get query query = request.args['query'] # get results response = get_results(query) recordings = response['recordings'] recordings = sorted(recordings, key=lambda rec: rec['q']) # render response return render_template('results.html.j2', recordings=recordings, query=query)
def get_query_results_for_sweater(): # TODO: fill in - Siem. # If user indeed wants to search for sweaters, give sweater results. results = get_results(es_connection, query="jacket", filter_category="Jackets & Coats") if results: return jsonify(status="OK", products=results) else: return jsonify(status="FAILED", error=404, message="No results found.")
def new_potentialbest(fx0, x0, design_space, length, basefile, metric, metric_values, numbers, neighborhood_size, alpha_passed, conf, n_start, n_end, step, typ, relations): x_new = get_pbest(design_space, numbers, conf, metric_values, n_start, n_end, step, typ, relations) design_space.append(x_new) val, num = utils.get_results(length, length + 1, design_space, basefile, metric) metric_values.extend(val) numbers.extend(num) fx_new = val length = len(design_space) if fx_new < fx0: print "Potential best result" design_space.append(x_new) value, number = utils.get_results(length, length + 1, design_space, basefile, metric) metric_values.extend(value) numbers.extend(number) f_temp = min(list(value)) x_temp = dict(x_new) #f_temp = min(metric_values) #x_temp = design_space[numbers[metric_values.index(f_temp)]] length = len(design_space) if f_temp < fx0: print "New Best configuration found" if fx_new < f_temp: x0 = dict(x_temp) fx0 = f_temp else: x0 = dict(x_new) fx0 = fx_new alpha_passed = 1 neighborhood_size *= alpha_passed print "Best result: " + str(fx0) return True, x0, fx0, alpha_passed, neighborhood_size, length return False, x0, fx0, alpha_passed, neighborhood_size, length
def test_posts_list_anonymous_user(self): client = APIClient() response = client.get(self.list_url) self.assertIs(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 2) self.assertEqual(data[0]['id'], 1) self.assertEqual(data[1]['id'], 2) self.assertEqual(data[0]['title'], "Post #1") # now post-list does not return content # self.assertEqual(data[0]['content'], "Post #1 content") self.assertEqual(data[0]['published'], True) self.assertIsNotNone(data[1]['publish_time'])
def run_fourier_q_learning_experiments(params): statistics = {"errors": [], "stopping_points": [], "utilities": []} filename = RESULTS_DIRECTORY + "fourier-q-[{}]-[{}]-[{}]-{}".format( params["alpha"], params["epsilon"], params["order"], PROBLEM_FILE) metareasoning_env = env.Environment(PROBLEM_FILE_PATH, ALPHA, BETA, INCREMENT) prakhar = fourier_agent.Agent(params, metareasoning_env) prakhar.run_q_learning(statistics) utils.save(filename, statistics) return utils.get_results(statistics["errors"], WINDOW_SIZE, PLOT_WINDOW_SIZE)
def test_post_filter(self): client = APIClient() response = client.get(self.list_url + '?title=Post%20#1') self.assertEqual(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 1) self.assertEqual(data[0].get('id'), 1) response = client.get(self.list_url + '?content_contains=#2') self.assertEqual(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 1) self.assertEqual(data[0].get('id'), 2) response = client.get(self.list_url + '?author=user1') self.assertEqual(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 2) self.assertEqual(data[0].get('id'), 1) self.assertEqual(data[1].get('id'), 2) response = client.get(self.list_url + f'?publish_time_gte={self.time_now.date().isoformat()}') self.assertEqual(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 1) self.assertEqual(data[0].get('id'), 2) response = client.get(self.list_url + '?view_count_lte=5') self.assertEqual(response.status_code, 200) data = get_results(response.data) self.assertEqual(len(data), 1) self.assertEqual(data[0].get('id'), 1) # accepts pagination params response = client.get(self.list_url + '?limit=5&offset=1') self.assertEqual(response.status_code, 200)
def get_query_results_for_brand(): """ :return: new results based on query with user_query and brand_name filter as well as price choice from previous prompt. """ user_query = request.form.get('user_query') brand = request.form.get('brand_choice') price = request.form.get('median_price') higher_lower = request.form.get('price_choice') if higher_lower == 'higher': results = get_results(es_connection, user_query, min_price=price, filter_brand=brand) else: results = get_results(es_connection, user_query, max_price=price, filter_brand=brand) lat = request.form.get('latitude') lon = request.form.get('longitude') if results: temperature = get_weather_for_latlon(lat, lon) return jsonify(status="OK", products=results, temperature=temperature) else: return jsonify(status="FAILED", error=404, message="No results found.")
def test_api_post(self): client = APIClient() client.login(username='******', password='******') response = client.post(reverse('post-list'), format='json', data={'title': 'New Post', 'content': 'To test adding tags and categories for contents.', 'tags': ['tag2', 'new_tag'], 'category': 'root1-node2-node1'}) self.assertEqual(response.status_code, 201) data = get_results(response.data) self.assertTrue(Tag.objects.filter(name='new_tag').exists()) self.assertEqual(data['category'], 'root1-node2-node1') self.assertEqual(data['tags'][0], {'id': 2, 'name': 'tag2', 'count': 2}) self.assertEqual(data['tags'][1], {'id': 4, 'name': 'new_tag', 'count': 1})
def gen_search_json(): start_time = time.time() query = request.args.get("q", '') query = utils.process_term(query) results = utils.get_results(query.strip()) resp = jsonify(results=results[:]) # top 10 results print("########################################") print("IF HERE IS MORE THEN ZERO BYTE THEN SERVER IS SENDING RESULT TO FRONTEND") print(resp) print("########################################") resp.headers['Access-Control-Allow-Origin'] = '*' # end_time = time.time() # print("Response time : " + str(end_time - start_time)) return resp
def processs_euler_experiment(self): self.re_init_data() files = sorted([ os.path.join(CNF_FOLDER, f) for f in os.listdir(CNF_FOLDER) if os.path.isfile(os.path.join(CNF_FOLDER, f)) and f.endswith('.cnf') ]) for s in EXECUTABLES: self.data[s] = {} for f in files: time_file = f.replace('.cnf', '_{}.time'.format(s)) print('main: {} file: {}'.format(s, time_file)) self.data[s][f] = {} self.data[s][f]['info'] = get_info(f).__dict__ times = get_results(time_file) self.data[s][f]['time'] = times
def build_per_batch_size(snmp_version): results = {} base_options = { 'round': 10, 'session': 10, 'snmp_version': snmp_version, } for i in [5, 10, 15, 20, 50, 100]: kwargs = base_options.copy() kwargs.update({ 'oid_batch_size': i, }) print("Run for params: {}".format(kwargs)) results[i] = get_results(**kwargs) create_all_graphs(results, per_value='batch_size', desc="params: {}".format(base_options))
import soundcloud from utils import get_results # create a client object with your app credentials client = soundcloud.Client(client_id='454aeaee30d3533d6d8f448556b50f23') i = 0 for track in get_results(client, '/tracks'): print i, track.title i += 1 if i == 100: break i = 0 for user in get_results(client, '/users'): print i, user.first_name, user.last_name, user.id i+= 1 if i == 100: break
def get_queryset(self): results = get_results(self.request.GET.get('query')) return results
def getTracks(profile): tracks = get_results(client, '/users/{0:s}/tracks/'.format(str(profile))) return tracks
def getComments(profile): comments = get_results(client, '/users/{0:s}/comments/'.format(str(profile))) return comments
def getRelationships(profile, client, url): return get_results(client, url) @handle_http_errors
def getFollowings(profile): # get list of users who the artist is following. followings = get_results(client, '/users/{0:s}/followings/'.format(str(profile))) return followings
def getFollowers(profile): followers = get_results(client, '/users/{0:s}/followers/'.format(str(profile))) return followers
def getFavorites(profile): favorites = get_results(client, '/users/{0:s}/favorites/'.format(str(profile))) return favorites