max(f_scores):\\n logging.info('==== writing best model: %f ====', f_score)\\n model.save(cfg.ckpt_path)\\n check_point = CheckPoint(optimizer, model,\\n {'iter': iter_, 'loss': loss.data[0],\\n 'accuracy': accuracy, 'f-score': f_score})\\n check_point.save(cfg.ckpt_path)\\n logging.info('check point: %s', check_point)\\n best_iter = iter_\\n revert = 0\\n one_more_thing = True\\n accuracies.append(accuracy)\\n f_scores.append(f_score)\\n logging.info('---- iter: %dk, loss: %f, accuracy: %f, f-score: %f (max: %r) ----',\\n iter_ // 1000, losses[-1], accuracy, f_score, max(f_scores))\\n\\n if cfg.model_dir.exists():\\n sum_wrt.add_scalar('loss', losses[-1], iter_ // 1000)\\n sum_wrt.add_scalar('accuracy', accuracy, iter_ // 1000)\\n sum_wrt.add_scalar('f-score', f_score, iter_ // 1000)\\n print('{}\\\\t{}\\\\t{}\\\\t{}'.format(iter_ // 1000, losses[-1], accuracy,\\n f_score), file=logf)\\n logf.flush()\\n\\n # revert policy\\n if (iter_ - best_iter) > iter_to_rvt:\\n revert += 1\\n logging.info('==== revert to iter: %dk, revert count: %d ====',\\n best_iter // 1000, revert)\\n model_dump = CheckPoint.load(cfg.ckpt_path)\\n model.load_state_dict(model_dump['model'])\\n optimizer.load_state_dict(model_dump['optim'])\\n lrs = []\\n for param_group in optimizer.param_groups:\\n param_group['lr'] *= (0.9 if one_more_thing else 0.8) ** revert\\n lrs.append(param_group['lr'])\\n best_iter = iter_\\n logging.info('learning rates: %s', ', '.join([str(_) for _ in lrs]))\\n elif iter_ % 100 == 0:\\n print('.', end='', file=sys.stderr)\\n sys.stderr.flush()\\n\\n iter_ += 1\\n if revert > cfg.rvt_term and one_more_thing:\\n logging.info('==== one more thing, revert to iter: %dk ====', best_iter // 1000)\\n model_dump = CheckPoint.load(cfg.ckpt_path)\\n model.load_state_dict(model_dump['model'])\\n optimizer.load_state_dict(model_dump['optim'])\\n lrs = []\\n for param_group in optimizer.param_groups:\\n param_group['lr'] *= 10.0\\n lrs.append(param_group['lr'])\\n best_iter = iter_\\n revert = 0\\n one_more_thing = False\\n logging.info('learning rates: %s', ', '.join([str(_) for _ in lrs]))\",\n \"def main(args):\\n bad_words_file = codecs.open(args.language + \\\"/feature_files/bad_words\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n bad_words = read_known_words(bad_words_file)\\n \\n good_words_file = codecs.open(args.language + \\\"/feature_files/good_words\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n good_words = read_known_words(good_words_file)\\n\\n curse_words_file = codecs.open(args.language + \\\"/feature_files/curse_words\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n curse_words = read_known_words(curse_words_file)\\n\\n prepositions_file = codecs.open(args.language + \\\"/feature_files/prepositions\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n prepositions = read_known_words(prepositions_file)\\n\\n determiners_file = codecs.open(args.language + \\\"/feature_files/determiners\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n determiners = read_known_words(determiners_file)\\n\\n syllables_file = codecs.open(args.language + \\\"/feature_files/syllables\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n syllable_structure = read_syllables_file(syllables_file)\\n\\n other_feature_files = glob.glob(args.language + \\\"/feature_files/*.txt\\\")\\n other_features = set_features_from_files(other_feature_files)\\n \\n ermaObj = ConllToErma(args, bad_words, good_words, curse_words, prepositions, \\\\\\n determiners, syllable_structure, other_features)\\n\\n if not args.just_test:\\n # Input training file.\\n train_id = open(args.train, \\\"r\\\")\\n train = train_id.readlines()\\n train_id.close()\\n sys.stdout.write(\\\"Reading training file...\\\\n\\\")\\n (train_features, train_skip_chains) = ermaObj.read_conll_file(train)\\n sys.stdout.write(\\\"Building model...\\\\n\\\")\\n train_hash = ermaObj.make_nodes(train_features)\\n # Freeze the known features based on what's seen in the training data\\n ermaObj.cutoff_features()\\n else:\\n train_hash = {}\\n train_skip_chains = {}\\n # Input testing file.\\n test_id = open(args.test, \\\"r\\\")\\n test = test_id.readlines()\\n test_id.close()\\n sys.stdout.write(\\\"Reading test file...\\\\n\\\")\\n (test_features, test_skip_chains) = ermaObj.read_conll_file(test)\\n sys.stdout.write(\\\"Building model...\\\\n\\\")\\n test_hash = ermaObj.make_nodes(test_features, test=True)\\n ermaObj.write_out(train_hash, train_skip_chains, test_hash, test_skip_chains)\",\n \"def main_strategy_2():\\n en_text, de_text, train_iter, dev_iter, _ = clean_data_strategy_2()\\n embedding_en, embedding_de = get_GloVe_embedding(en_text, de_text)\\n model = Model(len(en_text.vocab), len(de_text.vocab), 300, embedding_en, embedding_de)\\n train(model, train_iter, dev_iter)\",\n \"def main():\\n X_train, Y_train, y_train = load_batch(\\\"data_batch_1\\\")\\n X_test, Y_test, y_test = load_batch(\\\"test_batch\\\")\\n X_val, Y_val, y_val = load_batch((\\\"data_batch_2\\\"))\\n\\n X_train, X_train_mean, X_train_std = normalize(X_train)\\n X_test = normalize_mean_std(X_test, X_train_mean, X_train_std)\\n X_val = normalize_mean_std(X_val, X_train_mean, X_train_std)\\n\\n data = {\\n \\\"X_train\\\": X_train,\\n \\\"Y_train\\\": Y_train,\\n \\\"y_train\\\": y_train,\\n \\\"X_test\\\": X_test,\\n \\\"Y_test\\\": Y_test,\\n \\\"y_test\\\": y_test,\\n \\\"X_val\\\": X_val,\\n \\\"Y_val\\\": Y_val,\\n \\\"y_val\\\": y_val,\\n }\\n\\n network = Network(data)\",\n \"def trainNet():\",\n \"def main(config):\\n\\n runModel(config)\\n while (config['looping']):\\n runModel(config)\",\n \"def __init__(self):\\n self.train(positivity_files, 0)\\n self.train(subjectivity_files, 1)\",\n \"def finetuning_single(phase,token2id_dict,id2embedding_dict,inference,dataloaders,model,optimizer,device,weighted_sampling,criterion,classification,auxiliary_loss=False,attn_loss=False,epoch_count=None,new_task_epochs=None,trial=None,goal='IC',save_path_dir=None): #b/c it is single, models_list contains one model only\\n running_loss = 0.0\\n \\n# outputs_list = []\\n# representations_list = []\\n# labels_list = []\\n# modality_list = []\\n# indices_list = []\\n# task_names_list = []\\n# attn_coefs_list = []\\n# sentence_lens_list = []\\n# class_labels_list = []\\n# class_predictions_list = []\\n \\n \\\"\\\"\\\" Initialize Dictionaries to Store Results \\\"\\\"\\\" \\n outputs_dict = dict()\\n representations_dict = dict()\\n attn_coefs_dict = dict()\\n labels_dict = dict()\\n sentence_lens_dict = dict()\\n class_labels_dict = dict()\\n class_predictions_dict = dict()\\n epoch_bleu = dict()\\n epoch_rouge = dict()\\n epoch_meteor = dict()\\n\\n for dest_lang in token2id_dict.keys():\\n outputs_dict[dest_lang] = list()\\n attn_coefs_dict[dest_lang] = list()\\n representations_dict[dest_lang] = list()\\n labels_dict[dest_lang] = list()\\n sentence_lens_dict[dest_lang] = list()\\n class_labels_dict[dest_lang] = list()\\n class_predictions_dict[dest_lang] = list()\\n epoch_bleu[dest_lang] = 0\\n epoch_rouge[dest_lang] = 0\\n epoch_meteor[dest_lang] = 0\\n\\n batch_num = 0\\n batch = 0\\n #class label is that in IC setting, but class label is answer in VQA setting\\n for inputs, text_indices, sentence_lens, class_labels, languages, document_level_text_indices, document_level_sentence_lens in tqdm(dataloaders[phase]):\\n \\\"\\\"\\\" Weaning Off of Teacher Forcing in a Linear Manner \\\"\\\"\\\"\\n #sampling_prob = (0.4/30000)*(batch+1)*(epoch_count+1)\\n #uniform_value = np.random.uniform(0,1)\\n #sampling = True if uniform_value < sampling_prob else False\\n sampling = False\\n batch += 1\\n \\\"\\\"\\\" Send Data to Device \\\"\\\"\\\"\\n inputs = inputs.to(device)\\n class_labels = class_labels.to(device)\\n #print(text_indices)\\n with torch.set_grad_enabled('train1' in phase):# and inference == False): #('train' in phase and inference == False)\\n \\\"\\\"\\\" Image Captioning Path \\\"\\\"\\\"\\n if goal == 'IC':\\n \\\"\\\"\\\" Perform Forward Pass i.e. Encoder and Decoder \\\"\\\"\\\"\\n current_labels_dict = dict() #text\\n# current_class_labels_dict = dict()\\n# current_class_predictions_dict = dict()\\n current_outputs_dict = dict()\\n# current_attn_coefs_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\\n outputs, representations = model(inputs,current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],dest_lang,phase,sampling,device) #outputs is B x S x Words\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n #current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n if phase == 'train1':\\n attn_coefs = 5\\n class_predictions = 6\\n loss = calculate_IC_loss(criterion,outputs,current_text_indices[:,1:],class_predictions,class_labels,attn_coefs,auxiliary_loss,attn_loss)\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n current_labels_dict[dest_lang] = current_text_indices[:,1:].cpu().detach().numpy()\\n# current_class_labels_dict[dest_lang] = class_labels\\n# current_class_predictions_dict[dest_lang] = class_predictions\\n current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\\n# current_attn_coefs_dict[dest_lang] = attn_coefs\\n# current_representations_dict[dest_lang] = representations\\n #\\\"\\\"\\\" Detach Outputs and Attn Coefs To Avoid Memory Leakage \\\"\\\"\\\"\\n #outputs = outputs.detach()\\n #attn_coefs = attn_coefs.detach()\\n current_text_indices.detach()\\n elif goal == 'VQA':\\n \\\"\\\"\\\" Perform Forward Pass and Get Answers \\\"\\\"\\\"\\n outputs, representations, attn_coefs, class_predictions = model(inputs,text_indices,sentence_lens,id2embedding_dict,phase,device)\\n \\\"\\\"\\\" Calculate MSE Loss \\\"\\\"\\\"\\n #criterion = nn.MSELoss()\\n #class_labels = class_labels.type(torch.float)\\n \\\"\\\"\\\" Calculate CrossEntropyLoss \\\"\\\"\\\"\\n criterion = nn.CrossEntropyLoss()\\n class_labels = class_labels.type(torch.long)\\n #print(outputs,outputs.shape)\\n loss = criterion(outputs,class_labels)\\n elif goal == 'Supervised': #encoder supervised pre-training\\n h, representations, class_predictions = model(inputs)#,text_indices,sentence_lens,id2embedding_dict,phase,device)\\n criterion = nn.CrossEntropyLoss()\\n class_labels = class_labels.type(torch.long)\\n loss = criterion(class_predictions,class_labels)\\n elif goal == 'Text_Supervised':\\n #h, class_predictions = model.supervised_forward(text_indices,sentence_lens,token2id_dict,id2embedding_dict,phase,device)\\n criterion = nn.CrossEntropyLoss()\\n class_labels = class_labels.type(torch.long)\\n current_class_labels_dict = dict()\\n current_class_predictions_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\\n class_predictions = model.supervised_forward(current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],phase,device)\\n loss = criterion(class_predictions,class_labels)\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n\\n current_class_labels_dict[dest_lang] = class_labels.cpu().detach().numpy()\\n current_class_predictions_dict[dest_lang] = class_predictions.cpu().detach().numpy()\\n# current_representations_dict[dest_lang] = h\\n #loss = criterion(class_predictions,class_labels)\\n #print(loss)\\n elif goal == 'Language_Change_Detection':\\n criterion = nn.BCEWithLogitsLoss()\\n class_labels = class_labels.type(torch.long)\\n current_class_labels_dict = dict()\\n current_class_predictions_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\\n \\\"\\\"\\\" Forward Pass \\\"\\\"\\\"\\n replacement_predictions, replacement_labels = model.language_change_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\\n #replacement_labels = replacement_labels.type(torch.float) #needed for BCELoss\\n \\\"\\\"\\\" Instance-Wise Loss Because Each Sentence is of a Different Length \\\"\\\"\\\"\\n loss = 0\\n for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\\n current_loss = criterion(replacement_prediction,replacement_label)\\n loss = loss + current_loss\\n if i == len(replacement_predictions)-1:\\n loss = loss / len(replacement_predictions)\\n #loss = torch.mean(torch.tensor([criterion(replacement_prediction,replacement_label) for replacement_prediction,replacement_label in zip(replacement_predictions,replacement_labels)]))\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\n \\\"\\\"\\\" Store Representations and Labels \\\"\\\"\\\"\\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\\n# current_representations_dict[dest_lang] = h \\n elif goal == 'Language_Detection':\\n criterion = nn.CrossEntropyLoss(ignore_index=0)\\n class_labels = class_labels.type(torch.long)\\n current_class_labels_dict = dict()\\n current_class_predictions_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\\n \\\"\\\"\\\" Forward Pass \\\"\\\"\\\"\\n replacement_predictions, replacement_labels = model.language_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\\n #replacement_labels = replacement_labels.type(torch.long) #needed for CrossEntropyLoss\\n \\\"\\\"\\\" Instance-Wise Loss Because Each Sentence is of a Different Length \\\"\\\"\\\"\\n# loss = 0\\n# for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\\n# replacement_label = replacement_label.type(torch.long)\\n# current_loss = criterion(replacement_prediction,replacement_label)\\n# loss = loss + current_loss\\n# if i == len(replacement_predictions)-1:\\n# loss = loss / len(replacement_predictions)\\n #print(replacement_predictions.shape,replacement_labels.shape)\\n loss = criterion(replacement_predictions.permute(0,2,1),replacement_labels)\\n #print(loss)\\n total_loss = total_loss + loss\\n #print(dest_lang,total_loss)\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\n \\\"\\\"\\\" Store Representations and Labels \\\"\\\"\\\"\\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\\n# current_representations_dict[dest_lang] = h\\n elif goal == 'MLM':\\n criterion = nn.CrossEntropyLoss(reduction='none')\\n# current_labels_dict = dict() #text\\n# current_outputs_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\\n outputs, replacement_predictions = model.MLM_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device) #outputs is B x S x Words\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n \\\"\\\"\\\" Obtain Applicable Loss Locations (i.e., Where Token Was Masked) \\\"\\\"\\\"\\n token_loss_mask = torch.where(replacement_predictions == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\\n #print(outputs.shape)\\n #if phase == 'train1':\\n \\\"\\\"\\\" Obtain Each Token's Loss \\\"\\\"\\\"\\n token_loss = criterion(outputs.permute(0,2,1),current_text_indices)\\n \\\"\\\"\\\" Retrieve Only Relevant Losses (Masked) \\\"\\\"\\\"\\n loss = torch.mean(token_loss.masked_select(token_loss_mask))\\n \\\"\\\"\\\" Aggregate Loss Across Languages \\\"\\\"\\\"\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\n del current_text_indices\\n del token_loss\\n del token_loss_mask\\n# \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n# current_labels_dict[dest_lang] = current_text_indices.cpu().detach().numpy()\\n# current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\\n elif goal == 'ELECTRA':\\n generator_criterion = nn.CrossEntropyLoss(reduction='none')\\n discriminator_criterion = nn.BCEWithLogitsLoss(reduction='none')\\n# current_labels_dict = dict() #text\\n# current_outputs_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Perform Forward Pass Through ELECTRA \\\"\\\"\\\"\\n generator_outputs, generator_labels, discriminator_outputs, discriminator_labels = model.ELECTRA_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,sampling,device) #outputs is B x S x Words\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n \\\"\\\"\\\" Generator Loss Mask (i.e., Only Consider Originally Masked Tokens ) \\\"\\\"\\\"\\n generator_token_loss_mask = torch.where(generator_labels == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\\n \\\"\\\"\\\" Discrimiantor Loss Mask (i.e., Do Not Consider Padded Regions ) \\\"\\\"\\\"\\n discriminator_labels = discriminator_labels.view_as(discriminator_outputs) \\n discriminator_token_loss_mask = torch.ones_like(discriminator_labels)\\n for i,sentence_len in zip(range(discriminator_token_loss_mask.shape[0]),current_sentence_lens):\\n discriminator_token_loss_mask[i,sentence_len:] = 0\\n \\n #if phase == 'train1':\\n \\\"\\\"\\\" Obtain Each Generator Token's Loss \\\"\\\"\\\"\\n generator_token_loss = generator_criterion(generator_outputs.permute(0,2,1),current_text_indices) # B x S\\n #print(generator_token_loss.shape,generator_token_loss_mask.shape)\\n \\\"\\\"\\\" Retrieve Only Relevant Loss (Masked) \\\"\\\"\\\"\\n generator_loss = torch.mean(generator_token_loss.masked_select(generator_token_loss_mask)) #scalar\\n \\n \\\"\\\"\\\" Obtain Each Discriminator Token's Loss \\\"\\\"\\\" \\n discriminator_token_loss = discriminator_criterion(discriminator_outputs,discriminator_labels) # B x S\\n #print(discriminator_token_loss.shape,discriminator_token_loss_mask.shape)\\n \\\"\\\"\\\" Retrieve Only Relevant Loss (Masked) \\\"\\\"\\\"\\n discriminator_loss = torch.mean(discriminator_token_loss.masked_select(discriminator_token_loss_mask.type(torch.bool))) #scalar\\n \\n #print(generator_loss,discriminator_loss)\\n \\\"\\\"\\\" Aggregate Loss Across Languages \\\"\\\"\\\"\\n total_loss = total_loss + generator_loss + discriminator_loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n# current_labels_dict[dest_lang] = discriminator_labels.cpu().detach().numpy()\\n# current_outputs_dict[dest_lang] = discriminator_outputs.cpu().detach().numpy() #text\\n elif goal == 'MARGE':\\n# current_labels_dict = dict() #text\\n# current_outputs_dict = dict()\\n #total_loss = 0\\n #for (dest_lang,current_text_indices),current_sentence_lens,current_languages in zip(text_indices.items(),sentence_lens.values(),languages.values()): #, sorted_indices, attn_coefs, class_predictions\\n \\\"\\\"\\\" Randomly Choose Target Lang for This Mini-Batch \\\"\\\"\\\"\\n #lang_list = list(text_indices.keys())\\n #target_lang = random.sample(lang_list,1).item()\\n #target_lang = 'de' #option to change based on dataset (MUST CHANGE IN PAD COLLATE)\\n outputs, target_lang = model(text_indices,sentence_lens,languages,document_level_text_indices,document_level_sentence_lens,token2id_dict,id2embedding_dict,phase,device)\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = text_indices[target_lang].to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n #if phase == 'train1':\\n \\\"\\\"\\\" Obtain Each Token's Loss \\\"\\\"\\\"\\n loss = criterion(outputs.permute(0,2,1),current_text_indices)\\n #print(loss)\\n #\\\"\\\"\\\" Aggregate Loss Across Languages \\\"\\\"\\\"\\n #total_loss = total_loss + loss\\n #\\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n #if dest_lang == list(text_indices.keys())[-1]:\\n # loss = total_loss / len(text_indices)\\n# print(loss)\\n# \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n# current_labels_dict[target_lang] = current_text_indices.cpu().detach().numpy()\\n# current_outputs_dict[target_lang] = outputs.cpu().detach().numpy() #text\\n \\n\\n \\\"\\\"\\\" Backpropagation and Update Step \\\"\\\"\\\"\\n if phase == 'train1': #only perform backprop for train1 phase \\n loss.backward()\\n \\n \\\"\\\"\\\" Network Parameters \\\"\\\"\\\"\\n if isinstance(optimizer,tuple):\\n optimizer[0].step()\\n \\\"\\\"\\\" Task-Instance Parameters \\\"\\\"\\\"\\n optimizer[1].step() \\n optimizer[0].zero_grad()\\n optimizer[1].zero_grad()\\n else:\\n optimizer.step()\\n optimizer.zero_grad()\\n \\n \\\"\\\"\\\" Calculate Metrics \\\"\\\"\\\"\\n if goal == 'IC':\\n if phase == 'train1':\\n running_loss += loss.item() * inputs.shape[0]\\n elif goal == 'VQA':\\n running_loss += loss.item() * inputs.shape[0] \\n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\\n running_loss += loss.item() * inputs.shape[0] \\n \\n# \\\"\\\"\\\" These Need to be Language Specific \\\"\\\"\\\"\\n \\n if goal in ['IC']:\\n batch_bleu = calculate_bleu_score(current_outputs_dict,current_labels_dict,token2id_dict)\\n batch_rouge = calculate_rouge_score(current_outputs_dict,current_labels_dict,token2id_dict)\\n batch_meteor = calculate_meteor_score(current_outputs_dict,current_labels_dict,token2id_dict) \\n \\n for dest_lang in batch_bleu.keys():\\n epoch_bleu[dest_lang] = epoch_bleu[dest_lang] + (1/batch)*(batch_bleu[dest_lang] - epoch_bleu[dest_lang])\\n epoch_rouge[dest_lang] = epoch_rouge[dest_lang] + (1/batch)*(batch_rouge[dest_lang] - epoch_rouge[dest_lang])\\n epoch_meteor[dest_lang] = epoch_meteor[dest_lang] + (1/batch)*(batch_meteor[dest_lang] - epoch_meteor[dest_lang])\\n \\n if phase in ['val']:\\n for dest_lang in text_indices.keys():\\n predicted_sentences = convert_predicted_ids_to_sentences(current_outputs_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\\n target_sentences = convert_target_ids_to_sentences(current_labels_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\\n outputs_dict[dest_lang].extend(predicted_sentences)\\n labels_dict[dest_lang].extend(target_sentences)\\n \\n elif goal in ['Language_Change_Detection','Language_Detection']:\\n for dest_lang in text_indices.keys():\\n if goal in ['Language_Change_Detection','Language_Detection']:\\n \\\"\\\"\\\" Store Batch Data in The Dictionaries \\\"\\\"\\\"\\n class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\\n class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\\n \\n# elif goal in ['Text_Supervised']:\\n## current_class_labels = current_class_labels_dict[dest_lang]\\n## current_class_predictions = current_class_predictions_dict[dest_lang]\\n## current_class_labels = current_class_labels.cpu().detach().numpy()\\n## current_class_predictions = current_class_predictions.cpu().detach().numpy()\\n# \\n# \\\"\\\"\\\" Store Batch Data in The Dictionaries \\\"\\\"\\\"\\n# #sentence_lens_dict[dest_lang].extend(current_sentence_lens)\\n# class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\\n# class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\\n#\\n# elif goal in ['MARGE']:\\n# labels_dict[target_lang].extend(current_labels_dict[target_lang]) #.cpu().detach().numpy())\\n# outputs_dict[target_lang].extend(current_outputs_dict[target_lang]) #.cpu().detach().numpy())\\n# break # because only one target language per minibatch \\n# if goal not in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\\n## if current_labels_dict[dest_lang].data.dtype != torch.long:\\n## current_labels_dict[dest_lang].data = current_labels_dict[dest_lang].data.type(torch.long)\\n# \\n## current_text_indices = current_labels_dict[dest_lang]\\n## current_outputs = current_outputs_dict[dest_lang]\\n## current_attn_coefs = current_attn_coefs_dict[dest_lang]\\n## current_representations = current_representations_dict[dest_lang]\\n# \\\"\\\"\\\" Store Batch Data in The Dictionaries \\\"\\\"\\\" \\n# labels_dict[dest_lang].extend(current_labels_dict[dest_lang]) #.cpu().detach().numpy())\\n# outputs_dict[dest_lang].extend(current_outputs_dict[dest_lang]) #.cpu().detach().numpy())\\n## attn_coefs_dict[dest_lang].extend(current_attn_coefs.cpu().detach().numpy())\\n## representations_dict[dest_lang].extend(current_representations.cpu().detach().numpy())\\n## elif goal in ['Text_Supervised']:\\n## current_representations = current_representations_dict[dest_lang]\\n## representations_dict[dest_lang].extend(current_representations.squeeze().cpu().detach().numpy()) \\n## else:\\n## current_representations = current_representations_dict[dest_lang]\\n## if goal in ['Language_Change_Detection','Language_Detection']:\\n## current_representations = [representations.cpu().detach().numpy() for representations in current_representations]\\n## else:\\n## current_representations = current_representations.cpu().detach().numpy()\\n## representations_dict[dest_lang].extend(current_representations) \\n# \\n## modality_list.append(modality)\\n## indices_list.append(indices)\\n## task_names_list.append(task_names)\\n \\n batch_num += 1\\n #if batch_num == 2:\\n # break\\n \\n #outputs_list, labels_list, modality_list, indices_list, task_names_list, pids_list = flatten_arrays(outputs_list,labels_list,modality_list,indices_list,task_names_list,pids_list)\\n if goal == 'IC':\\n if phase == 'train1':\\n epoch_loss = running_loss / len(dataloaders[phase].dataset)\\n else:\\n epoch_loss = 0 #filler\\n elif goal in ['VQA','Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\\n epoch_loss = running_loss / len(dataloaders[phase].dataset) \\n \\n \\\"\\\"\\\" Removed Recently \\\"\\\"\\\"\\n #representations_list = np.concatenate(representations_list)\\n \\n if goal == 'IC':\\n \\\"\\\"\\\" BLEU Score Evaluation \\\"\\\"\\\"\\n# epoch_bleu = calculate_bleu_score(outputs_dict,labels_dict,token2id_dict)\\n# epoch_rouge = calculate_rouge_score(outputs_dict,labels_dict,token2id_dict)\\n# epoch_meteor = calculate_meteor_score(outputs_dict,labels_dict,token2id_dict) \\n return epoch_loss, epoch_bleu, epoch_rouge, epoch_meteor, outputs_dict, labels_dict #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\\n elif goal == 'VQA':\\n \\\"\\\"\\\" Accuracy of Answers \\\"\\\"\\\"\\n epoch_acc = calculate_answer_accuracy(outputs_dict,class_labels_dict)\\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\\n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\\n if goal in ['Language_Change_Detection','Language_Detection']:\\n epoch_acc = calculate_language_detection_accuracy(class_predictions_dict,class_labels_dict,goal)\\n else:\\n \\\"\\\"\\\" Accuracy of Answers \\\"\\\"\\\"\\n epoch_acc = calculate_answer_accuracy(class_predictions_dict,class_labels_dict)\\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\\n elif goal in ['MLM','ELECTRA','MARGE']:\\n return epoch_loss#, outputs_dict, labels_dict #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\",\n \"def recog_ctconly(args):\\n\\n logging.warning(f'RECOGCTCONLY')\\n logging.warning(\\\"experimental API for custom LMs is selected by --api v2\\\")\\n if args.batchsize > 1:\\n raise NotImplementedError(\\\"multi-utt batch decoding is not implemented\\\")\\n if args.streaming_mode is not None:\\n raise NotImplementedError(\\\"streaming mode is not implemented\\\")\\n if args.word_rnnlm:\\n raise NotImplementedError(\\\"word LM is not implemented\\\")\\n\\n set_deterministic_pytorch(args)\\n model, train_args = load_trained_model(args.model)\\n\\n # add lang2ph to the model\\n if args.mask_phoneme:\\n logging.warning(f'mask phoneme and create lang2ph for model')\\n assert args.lang2ph is not None\\n with open(args.lang2ph, 'r') as f:\\n model.lang2ph = json.load(f)\\n\\n model.lang2phid = {}\\n for lang, phones in model.lang2ph.items(): \\n phoneset = set(phones + ['<blank>', '<unk>', '<space>', '<eos>'])\\n phoneset = phoneset.intersection(model.args.char_list)\\n model.lang2phid[lang] = list(map(model.args.char_list.index, phoneset))\\n # model.lang2phid[lang] = list(map(model.args.char_list.index, phones+['<blank>', '<unk>', '<space>', '<eos>']))\\n \\n model.ctc.lang2phid = model.lang2phid\\n logging.warning(f'model lang2phid {model.lang2phid}')\\n\\n assert isinstance(model, ASRInterface)\\n model.eval()\\n\\n load_inputs_and_targets = LoadInputsAndTargets(\\n mode=\\\"asr\\\",\\n load_output=False,\\n sort_in_input_length=False,\\n preprocess_conf=train_args.preprocess_conf\\n if args.preprocess_conf is None\\n else args.preprocess_conf,\\n preprocess_args={\\\"train\\\": False},\\n )\\n\\n if args.ngpu == 1:\\n device = \\\"cuda\\\"\\n else:\\n device = \\\"cpu\\\"\\n dtype = getattr(torch, args.dtype)\\n logging.info(f\\\"Decoding device={device}, dtype={dtype}\\\")\\n model.to(device=device, dtype=dtype).eval()\\n\\n # logging.warning(f'Recog deep [model.args] {model.args}')\\n\\n # with open(args.recog_json, \\\"rb\\\") as f:\\n # recog_json = json.load(f)[\\\"utts\\\"]\\n \\n recog_json = read_json_data(model.args, args.recog_json)\\n\\n if args.recog_size is not None and args.recog_size > 0:\\n random.seed(args.seed)\\n items = list(recog_json.items())\\n random.shuffle(items)\\n recog_json = OrderedDict(items[:args.recog_size])\\n logging.warning(f'data json len {len(recog_json)}')\\n\\n # if model.args.wav2vec_feature:\\n # modify_data_json(model.args, recog_json)\\n\\n use_sortagrad = model.args.sortagrad == -1 or model.args.sortagrad > 0\\n\\n converter = CustomConverter(subsampling_factor=model.subsample[0], dtype=dtype)\\n\\n # make minibatch list (variable length)\\n recog = make_batchset(\\n recog_json,\\n 16, # model.args.batch_size,\\n model.args.maxlen_in,\\n model.args.maxlen_out,\\n model.args.minibatches,\\n min_batch_size=model.args.ngpu if model.args.ngpu > 1 else 1,\\n shortest_first=use_sortagrad,\\n count=model.args.batch_count,\\n batch_bins=800000, #model.args.batch_bins,\\n batch_frames_in=model.args.batch_frames_in,\\n batch_frames_out=model.args.batch_frames_out,\\n batch_frames_inout=model.args.batch_frames_inout,\\n iaxis=0,\\n oaxis=0,\\n )\\n\\n \\n\\n load_rc = LoadInputsAndTargets(\\n mode=\\\"asr\\\",\\n load_output=True,\\n preprocess_conf=model.args.preprocess_conf,\\n preprocess_args={\\\"train\\\": False}, # Switch the mode of preprocessing\\n )\\n\\n recog_iter = ChainerDataLoader(\\n dataset=TransformDataset(\\n recog, lambda data: converter([load_rc(data)]), utt=True, lang_label=args.lang_label\\n ),\\n batch_size=1,\\n num_workers=model.args.n_iter_processes,\\n shuffle=not use_sortagrad,\\n collate_fn=lambda x: x[0],\\n )\\n\\n logging.info(f'Character list: {model.args.char_list}')\\n logging.warning(f'lang model and weight: {args.lang_model} {args.lang_model_weight}')\\n decoder = CTCBeamDecoder(\\n labels=model.args.char_list, beam_width=args.beam_size, log_probs_input=True,\\n model_path=args.lang_model, alpha=args.lang_model_weight\\n )\\n\\n # with open(args.recog_json, \\\"rb\\\") as f:\\n # js = json.load(f)[\\\"utts\\\"]\\n # if model.args.wav2vec_feature:\\n # modify_data_json(model.args, js)\\n js = read_json_data(model.args, args.recog_json)\\n\\n new_js = {}\\n with torch.no_grad():\\n for batch in recog_iter:\\n lang_labels = None\\n lang_labels_for_masking = None\\n if args.lang_label:\\n lang_labels, names, x = batch[0], batch[1], batch[2:]\\n if args.mask_phoneme:\\n lang_labels_for_masking = lang_labels # true lang labels\\n if args.fake_lang_label:\\n lang_labels = [args.fake_lang_label] * len(lang_labels)\\n \\n else:\\n names, x = batch[0], batch[1:]\\n \\n\\n logging.warning(f'{lang_labels}')\\n # if np.prod(list(x[0].size())) >= 350000:\\n # logging.warning(f'batch {x[0].size()} {np.prod(list(x[0].size())) } too large, skip')\\n # continue\\n # logging.warning(f\\\"Recog deep [names] {names}\\\")\\n x = _recursive_to(x, device)\\n \\n\\n xs_pad, ilens, ys_pad = x\\n\\n logprobs, seq_lens = model.encode_with_length(\\n xs_pad, ilens, lang_labels=lang_labels, \\n mask_phoneme=args.mask_phoneme, \\n lang_labels_for_masking=lang_labels_for_masking\\n )\\n\\n ## just for check\\n # with open('check.pk', 'wb') as f:\\n # o = model.args.char_list, logprobs, seq_lens, ys_pad, lang_labels\\n # pickle.dump(o, f)\\n # raise\\n\\n # logging.warning(f'Recog Deep [logprobs] {logprobs.size()}')\\n out, scores, offsets, seq_lens = decoder.decode(logprobs, seq_lens, )\\n for hyp, trn, length, name, score in zip(out, ys_pad, seq_lens, names, scores): # iterate batch\\n # logging.warning(f'{score}')\\n best_hyp = hyp[0,:length[0]]\\n\\n new_js[name] = add_results_to_json(\\n js[name], [{\\\"yseq\\\": best_hyp, \\\"score\\\": float(score[0])}], model.args.char_list\\n )\\n\\n\\n # logging.warning(f'Recog deep [new_js] {new_js}')\\n # break\\n\\n # raise\\n with open(args.result_label, \\\"wb\\\") as f:\\n f.write(\\n json.dumps(\\n {\\\"utts\\\": new_js}, indent=4, ensure_ascii=False, sort_keys=True\\n ).encode(\\\"utf_8\\\")\\n )\",\n \"def __call__(self, ens_x_input, vgg_x_input, inc_x_input, tcd_x_input):\\n reuse = True if self.built else None\\n logits = None\\n aux_logits = None\\n weights = [[0.7, 0.1], [0.2, 0.1]]\\n all_inputs = [[ens_x_input, tcd_x_input], [inc_x_input, tcd_x_input]]\\n scopes = [inception_resnet_v2.inception_resnet_v2_arg_scope(), inception.inception_v3_arg_scope()]\\n reuse_flags = [reuse, True]\\n for model_idx, model in enumerate([inception_resnet_v2.inception_resnet_v2, inception.inception_v3]):\\n with slim.arg_scope(scopes[model_idx]):\\n for idx, inputs in enumerate(all_inputs[model_idx]):\\n result = model(inputs, num_classes=self.num_classes, is_training=False, reuse=reuse_flags[idx])\\n weight = weights[model_idx][idx]\\n # :1 is for slicing out the background class\\n if logits == None:\\n logits = result[0][:, 1:] * weight\\n aux_logits = result[1]['AuxLogits'][:, 1:] * weight\\n else:\\n logits += result[0][:, 1:] * weight\\n aux_logits += result[1]['AuxLogits'][:, 1:] * weight\\n\\n with slim.arg_scope(vgg.vgg_arg_scope()):\\n weight = 0.1\\n result = vgg.vgg_16(vgg_x_input, num_classes=1000, is_training=False)\\n logits += result[0] * weight\\n\\n with slim.arg_scope(resnet_utils.resnet_arg_scope()):\\n weight = 0.05\\n result = resnet_v2.resnet_v2_152(vgg_x_input, num_classes=self.num_classes, reuse=reuse)\\n logits += tf.squeeze(result[0])[:, 1:] * weight\\n\\n self.built = True\\n aux_weight = 0.8\\n logits += aux_logits * aux_weight\\n\\n predictions = layers_lib.softmax(logits)\\n return predictions\",\n \"def run_tests():\\n source1 = TextModel('CS111 Syllabus')\\n source1.add_file('CS111_Syllabus.txt')\\n\\n source2 = TextModel('AR Syllabus')\\n source2.add_file('AR_Syllabus.txt')\\n\\n new1 = TextModel('WR120 Syllabus')\\n new1.add_file('WR120_Syllabus.txt')\\n new1.classify(source1, source2)\\n \\n new2 = TextModel('CS131 Syllabus')\\n new2.add_file('CS131_Syllabus.txt')\\n new2.classify(source1, source2)\\n \\n new3 = TextModel('My Paper 2 for WR120')\\n new3.add_file('WR_Paper_2.txt')\\n new3.classify(source1, source2)\\n \\n new4 = TextModel('CS111 PS9PR0')\\n new4.add_file('ps9pr0.txt')\\n new4.classify(source1, source2)\",\n \"def main():\\n\\n ############################ variable settings #################################\\n parser = argparse.ArgumentParser(description='Run Subtask C of GermEval 2017 Using Pre-Trained Language Model.')\\n parser.add_argument('--seed', type=int, default=42, help='Random seed.')\\n parser.add_argument('--lang_model', type=str, default='bert-base-german-dbmdz-uncased', help='The pre-trained language model.')\\n parser.add_argument('--epochs', type=int, default=4, help='Number of epochs for training.')\\n parser.add_argument('--lr', type=float, default=5e-5, help='The learning rate.')\\n parser.add_argument('--max_len', type=int, default=256, help='The maximum sequence length of the input text.')\\n parser.add_argument('--batch_size', type=int, default=32, help='Your train set batch size.')\\n parser.add_argument('--df_path', type=str, default='./data/', help='The data directory.') \\n parser.add_argument('--train_data', type=str, default='train_df_cat.tsv', help='The filename of the input train data.')\\n parser.add_argument('--dev_data', type=str, default='dev_df_cat.tsv', help='The filename of the input development data.')\\n parser.add_argument('--test_data1', type=str, default='test_syn_df_cat.tsv', help='The filename of the first input test data (synchronic).')\\n parser.add_argument('--test_data2', type=str, default='test_dia_df_cat.tsv', help='The filename of the second input test data (diachronic).')\\n parser.add_argument('--output_path', type=str, default='./output/subtaskC/', help='The output directory of the model and predictions.')\\n parser.add_argument(\\\"--train\\\", default=True, action=\\\"store_true\\\", help=\\\"Flag for training.\\\")\\n parser.add_argument(\\\"--save_prediction\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for saving predictions.\\\")\\n parser.add_argument(\\\"--save_cr\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for saving confusion matrix.\\\")\\n parser.add_argument(\\\"--exclude_general\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for excluding category Allgemein.\\\")\\n parser.add_argument(\\\"--exclude_neutral\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for excluding neutral polarity.\\\")\\n parser.add_argument(\\\"--exclude_general_neutral\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for excluding category Allgemein:neutral.\\\")\\n args = parser.parse_args()\\n ################################################################################\\n set_all_seeds(args.seed)\\n device, n_gpu = initialize_device_settings(use_cuda=True)\\n \\n # Load data\\n train_df = pd.read_csv(args.df_path + args.train_data, delimiter = '\\\\t')\\n dev_df = pd.read_csv(args.df_path + args.dev_data, delimiter = '\\\\t')\\n test_syn_df = pd.read_csv(args.df_path + args.test_data1, delimiter = '\\\\t')\\n test_dia_df = pd.read_csv(args.df_path + args.test_data2, delimiter = '\\\\t')\\n \\n # Create a tokenizer\\n lower_case = False\\n if args.lang_model[-7:] == \\\"uncased\\\":\\n lower_case = True\\n\\n if args.lang_model[:4] == \\\"bert\\\":\\n model_class = \\\"BERT\\\"\\n tokenizer = BertTokenizer.from_pretrained(args.lang_model, do_lower_case=lower_case, max_length=args.max_len)\\n \\n if args.lang_model[:10] == \\\"distilbert\\\":\\n model_class = \\\"DistilBERT\\\"\\n tokenizer = DistilBertTokenizer.from_pretrained(args.lang_model, do_lower_case=lower_case, max_length=args.max_len)\\n \\n\\n # get training features\\n cats = train_df.columns[5:]\\n end = \\\"full\\\"\\n # exclude categories if required\\n if (args.exclude_general):\\n cats = [i for i in list(cats) if \\\"Allgemein\\\" not in i]\\n end = \\\"excl_gen\\\"\\n if (args.exclude_neutral):\\n cats = [i for i in list(cats) if \\\"neutral\\\" not in i]\\n end = \\\"excl_neu\\\"\\n if (args.exclude_general_neutral):\\n cats = [i for i in list(cats) if \\\"Allgemein:neutral\\\" not in i]\\n end = \\\"excl_genneu\\\"\\n \\n num_labels = len(list(cats))\\n\\n # create one hot labels\\n train_df['one_hot_labels'] = list(train_df[list(cats)].values)\\n dev_df['one_hot_labels'] = list(dev_df[list(cats)].values)\\n test_syn_df['one_hot_labels'] = list(test_syn_df[list(cats)].values)\\n test_dia_df['one_hot_labels'] = list(test_dia_df[list(cats)].values)\\n\\n # retrieve sentences and labels\\n df = pd.concat([train_df, dev_df])\\n sentences = df.text.values\\n labels = list(df.one_hot_labels.values) \\n\\n sentences_syn = test_syn_df.text.values\\n labels_syn = list(test_syn_df.one_hot_labels.values)\\n\\n sentences_dia = test_dia_df.text.values\\n labels_dia = list(test_dia_df.one_hot_labels.values)\\n \\n print(\\\"number of categories:\\\", len(list(cats)))\\n\\n # Tokenize all of the sentences and map the tokens to their word IDs. \\n input_ids = [tokenizer.encode(sent, add_special_tokens=True, truncation=True, \\n max_length=args.max_len) for sent in sentences]\\n input_ids = pad_sequences(input_ids, maxlen=args.max_len, dtype=\\\"long\\\", \\n value=0.0, truncating=\\\"post\\\", padding=\\\"post\\\")\\n # Create attention masks\\n attention_masks = [[int(token_id > 0) for token_id in sent] for sent in input_ids]\\n \\n # synchronic test data\\n input_ids_syn = [tokenizer.encode(sent, add_special_tokens=True, truncation=True) for sent in sentences_syn]\\n input_ids_syn = pad_sequences(input_ids_syn, maxlen=args.max_len, dtype=\\\"long\\\", \\n value=0.0, truncating=\\\"post\\\", padding=\\\"post\\\")\\n attention_masks_syn = [[int(token_id > 0) for token_id in sent] for sent in input_ids_syn]\\n \\n # diachronic test data\\n input_ids_dia = [tokenizer.encode(sent, add_special_tokens=True, truncation=True) for sent in sentences_dia]\\n input_ids_dia = pad_sequences(input_ids_dia, maxlen=args.max_len, dtype=\\\"long\\\", \\n value=0.0, truncating=\\\"post\\\", padding=\\\"post\\\")\\n attention_masks_dia = [[int(token_id > 0) for token_id in sent] for sent in input_ids_dia]\\n\\n # split train, dev\\n train_inputs, train_labels, dev_inputs, dev_labels, train_masks, dev_masks = split_train_dev(\\n train_df, dev_df, attention_masks, input_ids, labels)\\n \\n # transform to torch tensor\\n train_inputs = torch.tensor(train_inputs)\\n dev_inputs = torch.tensor(dev_inputs)\\n\\n train_labels = torch.tensor(train_labels)\\n dev_labels = torch.tensor(dev_labels)\\n\\n train_masks = torch.tensor(train_masks)\\n dev_masks = torch.tensor(dev_masks)\\n\\n test_syn_inputs = torch.tensor(input_ids_syn)\\n test_syn_masks = torch.tensor(attention_masks_syn)\\n test_syn_labels = torch.tensor(labels_syn)\\n\\n test_dia_inputs = torch.tensor(input_ids_dia)\\n test_dia_masks = torch.tensor(attention_masks_dia)\\n test_dia_labels = torch.tensor(labels_dia)\\n\\n # Create the DataLoader\\n train_dataloader = create_dataloader(train_inputs, train_masks, \\n train_labels, args.batch_size, train = True)\\n\\n dev_dataloader = create_dataloader(dev_inputs, dev_masks, \\n dev_labels, args.batch_size, train = False)\\n\\n test_syn_dataloader = create_dataloader(test_syn_inputs, test_syn_masks, \\n test_syn_labels, args.batch_size, \\n train = False)\\n\\n test_dia_dataloader = create_dataloader(test_dia_inputs, test_dia_masks, \\n test_dia_labels, args.batch_size, \\n train = False)\\n\\n # Create model\\n if args.train:\\n if model_class == \\\"BERT\\\":\\n config = BertConfig.from_pretrained(args.lang_model, num_labels=num_labels) \\n config.hidden_dropout_prob = 0.1 \\n model = BertForSequenceClassification.from_pretrained(\\n args.lang_model,\\n num_labels = num_labels,\\n output_attentions = False,\\n output_hidden_states = False\\n )\\n\\n if model_class == \\\"DistilBERT\\\":\\n config = DistilBertConfig.from_pretrained(args.lang_model, num_labels=num_labels) \\n config.hidden_dropout_prob = 0.1 \\n model = DistilBertForSequenceClassification.from_pretrained(\\n args.lang_model,\\n num_labels = num_labels,\\n output_attentions = False,\\n output_hidden_states = False\\n )\\n model.cuda()\\n\\n\\n # Create an optimizer\\n param_optimizer = list(model.named_parameters())\\n no_decay = ['bias', 'LayerNorm.weight']\\n optimizer_grouped_parameters = [\\n {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],\\n 'weight_decay_rate': 0.01},\\n {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)],\\n 'weight_decay_rate': 0.0}\\n ]\\n optimizer = AdamW(\\n optimizer_grouped_parameters,\\n lr=args.lr,\\n eps = 1e-8\\n )\\n # Total number of training steps = number of batches * number of epochs\\n total_steps = len(train_dataloader) * args.epochs\\n # Create the learning rate scheduler\\n scheduler = get_linear_schedule_with_warmup(\\n optimizer,\\n num_warmup_steps=0,\\n num_training_steps=total_steps\\n )\\n \\n # train model\\n # Main Loop\\n print(\\\"=================== Train ================\\\")\\n print(\\\"##### Language Model:\\\", args.lang_model, \\\",\\\", \\\"learning rate:\\\", args.lr)\\n print()\\n\\n track_time = time.time()\\n # trange is a tqdm wrapper around the normal python range\\n for epoch in trange(args.epochs, desc=\\\"Epoch\\\"):\\n print(\\\"Epoch: %4i\\\"%epoch, dt.datetime.now())\\n\\n model, optimizer, scheduler, tr_loss = train_multilabel(\\n train_dataloader=train_dataloader, \\n model=model, \\n device=device, \\n optimizer=optimizer, \\n scheduler=scheduler, \\n num_labels=num_labels\\n )\\n # EVALUATION: TRAIN SET\\n pred_bools_train, true_bools_train, f1_train = eval_multilabel(\\n train_dataloader, model=model, device=device)\\n print(\\\"TRAIN: micro F1 %.3f\\\"%(f1_train))\\n \\n # EVALUATION: DEV SET\\n pred_bools_dev, true_bools_dev, f1_dev = eval_multilabel(\\n dev_dataloader, model=model, device=device)\\n print(\\\"EVAL: micro F1 %.3f\\\"%(f1_dev))\\n \\n\\n print(\\\" Training and validation took in total: {:}\\\".format(format_time(time.time()-track_time)))\\n\\n # EVALUATION: TEST SYN SET\\n pred_bools_syn, true_bools_syn, f1_test_syn = eval_multilabel(\\n test_syn_dataloader, model=model, device=device)\\n print(\\\"TEST SYN: micro F1 %.4f\\\"%(f1_test_syn))\\n\\n # classification report\\n clf_report_syn = classification_report(true_bools_syn, pred_bools_syn, target_names=cats, digits=3)\\n print(clf_report_syn)\\n\\n\\n # EVALUATION: TEST DIA SET\\n pred_bools_dia, true_bools_dia, f1_test_dia = eval_multilabel(\\n test_dia_dataloader, model=model, device=device\\n )\\n print(\\\"TEST DIA: micro F1 %.4f\\\"%(f1_test_dia))\\n\\n # classification report\\n clf_report_dia = classification_report(true_bools_dia, pred_bools_dia, target_names=cats, digits=3)\\n print(clf_report_dia)\\n \\n if args.save_cr:\\n pickle.dump(clf_report_syn, open(args.output_path+'clf_report_'+args.lang_model+'_test_syn_'+str(num_labels)+end+'.txt','wb'))\\n pickle.dump(clf_report_dia, open(args.output_path+'clf_report_'+args.lang_model+'_test_dia_'+str(num_labels)+end+'.txt','wb'))\\n\\n\\n if args.save_prediction:\\n test_syn_df[\\\"category_pred\\\"] = pred_bools_syn\\n test_dia_df[\\\"category_pred\\\"] = pred_bools_dia\\n test_syn_df.category_pred.to_csv(args.output_path+args.lang_model+'_test_syn_'+str(num_labels)+end+\\\".tsv\\\", \\n sep=\\\"\\\\t\\\", index = False, header = True, encoding = \\\"utf-8-sig\\\")\\n test_dia_df.category_pred.to_csv(args.output_path+args.lang_model+'_test_dia_'+str(num_labels)+end+\\\".tsv\\\", \\n sep=\\\"\\\\t\\\", index = False, header = True, encoding = \\\"utf-8-sig\\\")\",\n \"def main():\\n setup_keras()\\n\\n args = parse()\\n\\n train_settings = common.load_settings(args.settings_path, default_conf_name='train.yml')\\n train_settings['store'] = args.store\\n\\n feature_settings = common.load_settings(args.settings_path, default_conf_name='feature.yml')\\n model_settings = common.load_settings(args.settings_path, default_conf_name=train_settings['model_conf'])\\n\\n train_df, val_df = load_training_data(dict(train_settings, **feature_settings))\\n assert train_df.shape[0] > val_df.shape[0] * 4.5, f'training data {train_df.shape[0]} should be much larger than validation {val_df.shape[0]}'\\n\\n sample_featurizer = AudioFeature(feature_settings)\\n\\n if args.load_name:\\n model_name = args.load_name\\n print('Loading existing model', model_name)\\n m = keras.models.load_model(model_name)\\n else:\\n t = datetime.datetime.now().strftime('%Y%m%d-%H%M')\\n model_name = f\\\"model-{model_settings['model']}_hop{feature_settings['hop_length']}_{t}\\\"\\n m = models.build(dict(model_settings, **feature_settings))\\n m.summary()\\n\\n output_dir = os.path.join(args.model_store, model_name)\\n\\n print(f\\\"Training model: '{model_name}'\\\", json.dumps(train_settings, indent=1))\\n\\n combined_settings = dict(train_settings, **model_settings, **feature_settings)\\n\\n h = train_model(output_dir, train_df, val_df,\\n model=m,\\n sample_featurizer=sample_featurizer,\\n settings=combined_settings)\",\n \"def main():\\r\\n # assert tf.__version__[0] == \\\"2\\\"\\r\\n\\r\\n \\\"\\\"\\\" Load Config \\\"\\\"\\\"\\r\\n with open('./config/config_origin.json', 'r') as f:\\r\\n CONFIG = json.load(f)\\r\\n BATCH_SIZE = CONFIG[\\\"BATCH_SIZE\\\"]\\r\\n ROOT_PATH = CONFIG[\\\"ROOT_PATH\\\"]\\r\\n TRAIN_DATA_DIR = CONFIG[\\\"TRAIN_DATA_DIR\\\"]\\r\\n TEST_DATA_DIR = CONFIG[\\\"TEST_DATA_DIR\\\"]\\r\\n TRAIN_DATA_DIR = os.path.join(ROOT_PATH, TRAIN_DATA_DIR)\\r\\n TEST_DATA_DIR = os.path.join(ROOT_PATH, TEST_DATA_DIR)\\r\\n MODEL_CKPT = CONFIG[\\\"MODEL_CKPT\\\"]\\r\\n\\r\\n \\\"\\\"\\\" Prepare Model \\\"\\\"\\\"\\r\\n n = 6 # order of ResNetv2\\r\\n version = 2\\r\\n depth = model_depth(n, version)\\r\\n MODEL_TYPE = 'ResNet%dv%d' % (depth, version)\\r\\n SAVES_DIR = \\\"models-%s/\\\" % MODEL_TYPE\\r\\n SAVES_DIR = os.path.join(ROOT_PATH, SAVES_DIR)\\r\\n MODEL_CKPT = os.path.join(SAVES_DIR, MODEL_CKPT)\\r\\n\\r\\n # Features directory\\r\\n FEATURE_DIR = os.path.join(ROOT_PATH, \\\"features\\\")\\r\\n FEATURE_DIR = os.path.join(FEATURE_DIR, \\\"models-%s/\\\" % MODEL_TYPE)\\r\\n if not os.path.exists(FEATURE_DIR):\\r\\n os.mkdir(FEATURE_DIR)\\r\\n\\r\\n if not os.path.exists(SAVES_DIR):\\r\\n os.mkdir(SAVES_DIR)\\r\\n model = resnet_v2(input_shape=INPUT_SHAPE, depth=depth, num_classes=2)\\r\\n model.compile(loss='categorical_crossentropy',\\r\\n optimizer=Adam(learning_rate=lr_schedule(TRAINING_EPOCHS)),\\r\\n metrics=METRICS)\\r\\n # model.summary()\\r\\n print(MODEL_TYPE)\\r\\n\\r\\n \\\"\\\"\\\" Load Weights \\\"\\\"\\\"\\r\\n model_ckpt_file = os.path.join(SAVES_DIR, MODEL_CKPT)\\r\\n if os.path.exists(model_ckpt_file):\\r\\n print(\\\"Model ckpt found! Loading...:%s\\\" % model_ckpt_file)\\r\\n model.load_weights(model_ckpt_file)\\r\\n\\r\\n \\\"\\\"\\\" Extract Testing Data \\\"\\\"\\\"\\r\\n _train_filenames = os.listdir(os.path.join(TRAIN_DATA_DIR, \\\"bad_1\\\"))\\r\\n train_bad_df = pd.DataFrame({\\r\\n 'filename': _train_filenames\\r\\n })\\r\\n n_bad_samples = train_bad_df.shape[0]\\r\\n train_bad_df.to_csv(os.path.join(\\r\\n FEATURE_DIR, \\\"bad_samples_list.csv\\\"), index=False)\\r\\n\\r\\n \\\"\\\"\\\" Extract good samples \\\"\\\"\\\"\\r\\n _train_filenames = os.listdir(os.path.join(TRAIN_DATA_DIR, \\\"good_0\\\"))\\r\\n train_good_df = pd.DataFrame({\\r\\n 'filename': _train_filenames\\r\\n })\\r\\n n_good_samples = train_good_df.shape[0]\\r\\n train_good_df.to_csv(os.path.join(\\r\\n FEATURE_DIR, \\\"good_samples_list.csv\\\"), index=False)\\r\\n\\r\\n \\\"\\\"\\\" Create bad sample validation generator \\\"\\\"\\\"\\r\\n train_bad_datagen = ImageDataGenerator(rescale=1./255)\\r\\n train_bad_generator = train_bad_datagen.flow_from_dataframe(\\r\\n train_bad_df,\\r\\n os.path.join(TRAIN_DATA_DIR, \\\"bad_1\\\"),\\r\\n x_col='filename',\\r\\n y_col=None,\\r\\n class_mode=None,\\r\\n target_size=IMAGE_SIZE,\\r\\n color_mode=\\\"grayscale\\\",\\r\\n batch_size=BATCH_SIZE,\\r\\n shuffle=False\\r\\n )\\r\\n\\r\\n \\\"\\\"\\\" Create bad sample validation generator \\\"\\\"\\\"\\r\\n train_good_datagen = ImageDataGenerator(rescale=1./255)\\r\\n train_good_generator = train_good_datagen.flow_from_dataframe(\\r\\n train_good_df,\\r\\n os.path.join(TRAIN_DATA_DIR, \\\"good_0\\\"),\\r\\n x_col='filename',\\r\\n y_col=None,\\r\\n class_mode=None,\\r\\n target_size=IMAGE_SIZE,\\r\\n color_mode=\\\"grayscale\\\",\\r\\n batch_size=BATCH_SIZE,\\r\\n shuffle=False\\r\\n )\\r\\n\\r\\n \\\"\\\"\\\" Extractor \\\"\\\"\\\"\\r\\n extractor = Model(\\r\\n model.inputs, model.layers[-2].output) # flatten_2 (Flatten) (None, 12544)\\r\\n # features = extractor.predict(data)\\r\\n\\r\\n \\\"\\\"\\\" Extract train set 的特征 \\\"\\\"\\\"\\r\\n import time\\r\\n # bad samples\\r\\n start = time.perf_counter()\\r\\n print(\\\"Start extracting bad samples...\\\")\\r\\n features = extractor.predict_generator(\\r\\n train_bad_generator, steps=np.ceil(n_bad_samples / BATCH_SIZE),\\r\\n workers=4, verbose=1)\\r\\n print(\\\"features.shape:\\\", features.shape) # (16/32/etc, 12544)\\r\\n np.save(os.path.join(FEATURE_DIR, \\\"features_train_bad.npy\\\"), features)\\r\\n\\r\\n elapsed = (time.perf_counter() - start)\\r\\n print(\\\"Prediction time used:\\\", elapsed)\\r\\n # TODO 用 pandas 存储\\r\\n # good samples\\r\\n start = time.perf_counter()\\r\\n print(\\\"Start extracting good samples...\\\")\\r\\n features = extractor.predict_generator(\\r\\n train_good_generator, steps=np.ceil(n_good_samples / BATCH_SIZE),\\r\\n workers=4, verbose=1)\\r\\n print(\\\"features.shape:\\\", features.shape) # (16/32/etc, 12544)\\r\\n np.save(os.path.join(FEATURE_DIR, \\\"features_train_good.npy\\\"), features)\\r\\n\\r\\n elapsed = (time.perf_counter() - start)\\r\\n print(\\\"Prediction time used:\\\", elapsed)\",\n \"def run(self):\\n n_lines = 100\\n input_helpers = self.load_input_data(\\\"acas\\\")\\n\\n # Precompute the lines we use.\\n theta_lines = self.vary_theta_lines(n_lines // 4)\\n theta_lines = input_helpers[\\\"process\\\"](theta_lines)\\n distance_lines = self.vary_distance_lines(n_lines)\\n distance_lines = input_helpers[\\\"process\\\"](distance_lines)\\n\\n n_models = input(\\\"Number of models (# or * for all): \\\")\\n n_models = -1 if n_models == \\\"*\\\" else int(n_models)\\n models_run_for = 0\\n for i in range(1, 6):\\n for j in range(1, 10):\\n network_name = \\\"acas_%d_%d\\\" % (i, j)\\n print(\\\"Running Experiment for Network:\\\", network_name)\\n # Now we run the experiment for this layer.\\n self.run_for_network(network_name, theta_lines, distance_lines)\\n models_run_for += 1\\n if models_run_for == n_models:\\n return\",\n \"def run():\\n\\n df = read_input() # the parameters\\n df = add_time_period(df) # a feature\\n df = is_holiday(df) # a feature\\n df = scale_continous(df) # continous feature transformation\\n df = encode_dummy(df) # categorical feature transformation\\n df = order_columns(df) # ordering model inputs\\n model = load_model() # the multiple linear regression model\\n prediction = int(model.predict(df)) # form a prediction\\n return prediction # return the prediction\",\n \"def train():\\n # YOUR TRAINING CODE GOES HERE\",\n \"def main(IMAGES_PATH, action='model2'):\\n if action == 'yolo':\\n # Run yolo model on images in the given folder\\n run_yolo_model(IMAGES_PATH)\\n \\n elif action == 'mask':\\n # Run mask model on images in the given folder\\n run_mask_model(IMAGES_PATH)\\n \\n elif action == 'model1':\\n # Run yolo model on images in the given folder\\n run_yolo_model(IMAGES_PATH)\\n \\n # Run mask model on images in the given folder\\n run_mask_model(IMAGES_PATH)\\n \\n # Aggregate output of yolo and output of mask\\n #yolo_coco.py\\n\\n elif action == 'model2':\\n # For sake of time saving, we will run model2 on a previously saved table instead of the output of model1. \\n \\n #data_df = load_coco_json_into_table('yolo_mask_to_coco/Predictions_group3.json')\\n #data_df = add_date_time(data_df)\\n \\n data_df = pd.read_pickle('inputs/table_labels_new.pkl')\\n \\n data_df.reset_index(drop=True, inplace=True)\\n \\n complete_concreting_df = get_concreting_periods(data_df)\\n \\n final_concreting_df = get_concreting_zone_and_workers_infos(complete_concreting_df)\\n \\n df_efficiency = efficiency_of_site(final_concreting_df)\\n \\n return df_efficiency\",\n \"def main():\\n\\n args = define_and_process_args()\\n print('\\\\n', 'ARGUMENTS', '\\\\n\\\\n', args, '\\\\n')\\n\\n log_dir = get_log_dir(args)\\n print('\\\\n', 'LOG DIRECTORY', '\\\\n\\\\n', log_dir, '\\\\n')\\n\\n standardized_data_path = os.path.join(args.data_dir, args.data_filename)\\n if not os.path.exists(standardized_data_path):\\n message = '%s does not exist.' % standardized_data_path\\n raise ValueError(message)\\n\\n dataset = data.Dataset(standardized_data_path)\\n train_raw_seqs, test_raw_seqs = dataset.get_splits(args.test_users)\\n train_triplets = [data.prepare_raw_seq(seq) for seq in train_raw_seqs]\\n test_triplets = [data.prepare_raw_seq(seq) for seq in test_raw_seqs]\\n\\n train_input_seqs, train_reset_seqs, train_label_seqs = zip(*train_triplets)\\n test_input_seqs, test_reset_seqs, test_label_seqs = zip(*test_triplets)\\n\\n Model = eval('models.' + args.model_type + 'Model')\\n input_size = dataset.input_size\\n target_size = dataset.num_classes\\n\\n # This is just to satisfy a low-CPU requirement on our cluster\\n # when using GPUs.\\n if 'CUDA_VISIBLE_DEVICES' in os.environ:\\n config = tf.ConfigProto(intra_op_parallelism_threads=2,\\n inter_op_parallelism_threads=2)\\n else:\\n config = None\\n\\n with tf.Session(config=config) as sess:\\n model = Model(input_size, target_size, args.num_layers,\\n args.hidden_layer_size, args.init_scale,\\n args.dropout_keep_prob)\\n optimizer = optimizers.Optimizer(\\n model.loss, args.num_train_sweeps, args.initial_learning_rate,\\n args.num_initial_sweeps, args.num_sweeps_per_decay,\\n args.decay_factor, args.max_global_grad_norm)\\n train(sess, model, optimizer, log_dir, args.batch_size,\\n args.num_sweeps_per_summary, args.num_sweeps_per_save,\\n train_input_seqs, train_reset_seqs, train_label_seqs,\\n test_input_seqs, test_reset_seqs, test_label_seqs)\",\n \"def __init__(self, **kwargs):\\n\\n # Identify the mode to start the model in\\n if \\\"x\\\" in kwargs and \\\"y\\\" in kwargs:\\n x = kwargs.get(\\\"x\\\")\\n y = kwargs.get(\\\"y\\\")\\n if \\\"model_name\\\" not in kwargs:\\n self.__mode = \\\"train\\\"\\n else:\\n self.__mode = \\\"retrain\\\"\\n elif \\\"model_name\\\" in kwargs:\\n self.__mode = \\\"test\\\"\\n else:\\n raise NameError(\\\"Cannot infer mode from arguments.\\\")\\n\\n print(\\\"Initializing model in %s mode.\\\" % self.__mode)\\n\\n if self.mode == \\\"train\\\":\\n # Infer input type from type(x)\\n if type(x[0]) == np.bytes_:\\n print(\\\"Input type is 'binary mols'.\\\")\\n self.__input_type = \\\"mols\\\" # binary RDKit mols\\n else:\\n print(\\\"Input type is 'molecular descriptors'.\\\")\\n self.__input_type = \\\"descriptors\\\" # other molecular descriptors\\n\\n # If scaling is required\\n if kwargs.get(\\\"scaling\\\", False) is True:\\n # Normalize the input\\n print(\\\"Applying scaling on input.\\\")\\n self.__scaler = StandardScaler()\\n x = self.__scaler.fit_transform(x)\\n else:\\n self.__scaler = None\\n\\n # If PCA is required\\n if kwargs.get(\\\"pca\\\", False) is True:\\n print(\\\"Applying PCA on input.\\\")\\n self.__pca = PCA(\\n n_components=x.shape[1]\\n ) # n_components=n_features for now\\n x = self.__pca.fit_transform(x)\\n else:\\n self.__pca = None\\n\\n self.__maxlen = (\\n kwargs.get(\\\"dataset_info\\\")[\\\"maxlen\\\"] + 10\\n ) # Extend maxlen to avoid breaks in training\\n self.__charset = kwargs.get(\\\"dataset_info\\\")[\\\"charset\\\"]\\n self.__dataset_name = kwargs.get(\\\"dataset_info\\\")[\\\"name\\\"]\\n self.__lstm_dim = kwargs.get(\\\"lstm_dim\\\", 256)\\n self.__h_activation = kwargs.get(\\\"h_activation\\\", \\\"relu\\\")\\n self.__bn = kwargs.get(\\\"bn\\\", True)\\n self.__bn_momentum = kwargs.get(\\\"bn_momentum\\\", 0.9)\\n self.__noise_std = kwargs.get(\\\"noise_std\\\", 0.01)\\n self.__td_dense_dim = kwargs.get(\\n \\\"td_dense_dim\\\", 0\\n ) # >0 squeezes RNN connections with Dense sandwiches\\n self.__batch_size = kwargs.get(\\\"batch_size\\\", 256)\\n self.__dec_layers = kwargs.get(\\\"dec_layers\\\", 2)\\n\\n if self.input_type == \\\"descriptors\\\":\\n self.__codelayer_dim = x.shape[1] # features\\n if \\\"codelayer_dim\\\" in kwargs:\\n print(\\n \\\"Ignoring requested codelayer_dim because it is inferred from the cardinality of the descriptors.\\\"\\n )\\n else:\\n self.__codelayer_dim = kwargs.get(\\\"codelayer_dim\\\", 128)\\n \\n # Create the left/right-padding vectorizers\\n self.__smilesvec1 = SmilesVectorizer(\\n canonical=False,\\n augment=True,\\n maxlength=self.maxlen,\\n charset=self.charset,\\n binary=True,\\n )\\n\\n self.__smilesvec2 = SmilesVectorizer(\\n canonical=False,\\n augment=True,\\n maxlength=self.maxlen,\\n charset=self.charset,\\n binary=True,\\n leftpad=False,\\n )\\n\\n # self.train_gen.next() #This line is needed to set train_gen.dims (to be fixed in HetSmilesGenerator)\\n self.__input_shape = self.smilesvec1.dims\\n self.__dec_dims = list(self.smilesvec1.dims)\\n self.__dec_dims[0] = self.dec_dims[0] - 1\\n self.__dec_input_shape = self.dec_dims\\n self.__output_len = self.smilesvec1.dims[0] - 1\\n self.__output_dims = self.smilesvec1.dims[-1]\\n\\n # Build all sub-models as untrained models\\n if self.input_type == \\\"mols\\\":\\n self.__build_mol_to_latent_model()\\n else:\\n self.__mol_to_latent_model = None\\n\\n self.__build_latent_to_states_model()\\n self.__build_batch_model()\\n\\n # Build data generators\\n self.__build_generators(x, y)\\n\\n # Retrain or Test mode\\n else:\\n self.__model_name = kwargs.get(\\\"model_name\\\")\\n\\n # Load the model\\n self.__load(self.model_name)\\n \\n if self.mode == \\\"retrain\\\":\\n # If scaling is required\\n if self.scaler is not None:\\n print(\\\"Applying scaling on input.\\\")\\n x = self.scaler.transform(x)\\n\\n # If PCA is required\\n if self.pca is not None:\\n print(\\\"Applying PCA on input.\\\")\\n x = self.pca.transform(x)\\n \\n # Build data generators\\n self.__build_generators(x, y)\\n\\n # Build full model out of the sub-models\\n self.__build_model()\\n\\n # Show the resulting full model\\n print(self.model.summary())\",\n \"def run(self):\\n self.set_pipeline()\\n self.pipeline.fit(self.X, self.y)\",\n \"def evaluate(args):\\n dataset_param_filepath = os.path.join(args.model, 'dataset.params')\\n dataset_params = putils.load_params(dataset_param_filepath)\\n source_vocab_filepath = os.path.join(args.model, 'source.vocab')\\n source_vocab = Vocab(vocab_filepath=source_vocab_filepath)\\n target_vocab_filepath = os.path.join(args.model, 'target.vocab')\\n target_vocab = Vocab(vocab_filepath=target_vocab_filepath)\\n model_params_filepath = os.path.join(args.model, 'model.params')\\n model_params = putils.load_params(model_params_filepath)\\n checkpoint_filepath = os.path.join(args.model, 'checkpoint.tar')\\n if not torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location=const.DEVICE)\\n elif torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n elif torch.cuda.is_available() and not model_params['cuda']:\\n logger.info('Loading a CPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location='cuda:0')\\n else:\\n logger.info('Loading a CPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n encoder = Encoder(model_type=checkpoint['encoder']['model_type'],\\n input_size=checkpoint['encoder']['input_size'],\\n hidden_size=checkpoint['encoder']['hidden_size'],\\n num_layers=checkpoint['encoder']['num_layers'],\\n nonlinearity=checkpoint['encoder']['nonlinearity'],\\n bias=checkpoint['encoder']['bias'],\\n dropout=checkpoint['encoder']['dropout'],\\n bidirectional=checkpoint['encoder']['bidirectional'])\\n if checkpoint['with_attention']:\\n decoder = Attention(model_type=checkpoint['decoder']['model_type'],\\n hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n max_seq_len=dataset_params['max_seq_len'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'],\\n bidirectional=checkpoint['decoder']['bidirectional'])\\n else:\\n decoder = Decoder(model_type=checkpoint['decoder']['model_type'],\\n hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'],\\n bidirectional=checkpoint['decoder']['bidirectional'])\\n encoder.load_state_dict(checkpoint['encoder_state_dict'])\\n decoder.load_state_dict(checkpoint['decoder_state_dict'])\\n if torch.cuda.is_available():\\n encoder.to(const.DEVICE)\\n decoder.to(const.DEVICE)\\n encoder.eval()\\n decoder.eval()\\n indexes = putils.index_dataset(\\n args.data, source_vocab.item2idx, target_vocab.item2idx,\\n dataset_params['is_character_based'], dataset_params['max_seq_len'],\\n dataset_params['is_reversed'])\\n if args.random > 0:\\n random.shuffle(indexes)\\n for seq_num in range(args.random):\\n seq = indexes[seq_num]\\n print('-'*80)\\n print('>', ' '.join([source_vocab.idx2item[idx]\\n for idx in seq[0]]))\\n print('=', ' '.join([target_vocab.idx2item[idx]\\n for idx in seq[1]]))\\n # TODO: add support for OOV\\n predicted_idx, _ = _decode(seq[0], encoder, decoder,\\n checkpoint['with_attention'],\\n dataset_params['max_seq_len'])\\n print('<', ' '.join([target_vocab.idx2item[idx]\\n for idx in predicted_idx]))\\n else:\\n _evaluate(indexes, encoder, decoder, target_vocab, checkpoint,\\n dataset_params)\",\n \"def quick_run(self, *args):\\n self.inputs(*args)\\n self.run()\",\n \"def run(args):\\n ####################\\n # Data Processing #\\n ####################\\n\\n words, counts = load_input(args.train_path)\\n trie = marisa_trie.Trie(counts.keys())\\n indices = load_indices('word', words, counts)\\n args.nb_classes = len(indices.keys())\\n print(len(indices.keys()))\\n timeseries = make_embedding(args.train_path, words, indices)\\n\\n ###################\\n # Construct model #\\n ###################\\n\\n if os.path.exists(name+'.h5'):\\n model = keras_load_model(name+'.h5')#', custom_objects={'perplexity': perplexity})\\n model.summary()\\n else:\\n model = densenet.DenseNet(args.nb_classes,\\n args.img_dim,\\n args.depth,\\n args.nb_dense_block,\\n args.growth_rate,\\n args.nb_filter,\\n dropout_rate=args.dropout_rate,\\n weight_decay=args.weight_decay)\\n # Model output\\n model.summary()\\n\\n # Build optimizer\\n opt = Nadam(lr=args.learning_rate)\\n\\n model.compile(loss='categorical_crossentropy',\\n optimizer=opt,\\n metrics=['mae', 'accuracy'])\\n\\n ####################\\n # Network training #\\n ####################\\n\\n train(model, timeseries, indices, words, args)\\n\\n #words, counts = load_input(args.test_path)\\n #timeseries = make_embedding(args.test_path, words, indices)\\n #trie = load_trie(counts)\\n #charinds = load_indices('char')\\n #char_to_bpc(model, timeseries, indices, charinds, words, args, trie) #cel\\n #word_to_perplexity(model, timeseries, indices, words, args) #nll\",\n \"def main():\\n\\n args = get_arguments()\\n\\n w, h = map(int, args.input_size.split(','))\\n\\n config_path = os.path.join(os.path.dirname(args.restore_from),'opts.yaml')\\n with open(config_path, 'r') as stream:\\n config = yaml.load(stream)\\n\\n args.model = config['model']\\n print('ModelType:%s'%args.model)\\n print('NormType:%s'%config['norm_style'])\\n gpu0 = args.gpu\\n batchsize = args.batchsize\\n\\n model_name = os.path.basename( os.path.dirname(args.restore_from) )\\n #args.save += model_name\\n\\n if not os.path.exists(args.save):\\n os.makedirs(args.save)\\n confidence_path = os.path.join(args.save, 'submit/confidence')\\n label_path = os.path.join(args.save, 'submit/labelTrainIds')\\n label_invalid_path = os.path.join(args.save, 'submit/labelTrainIds_invalid')\\n for path in [confidence_path, label_path, label_invalid_path]:\\n if not os.path.exists(path):\\n os.makedirs(path)\\n\\n if args.model == 'DeepLab':\\n model = DeeplabMulti(num_classes=args.num_classes, use_se = config['use_se'], train_bn = False, norm_style = config['norm_style'])\\n elif args.model == 'Oracle':\\n model = Res_Deeplab(num_classes=args.num_classes)\\n if args.restore_from == RESTORE_FROM:\\n args.restore_from = RESTORE_FROM_ORC\\n elif args.model == 'DeeplabVGG':\\n model = DeeplabVGG(num_classes=args.num_classes)\\n if args.restore_from == RESTORE_FROM:\\n args.restore_from = RESTORE_FROM_VGG\\n\\n if args.restore_from[:4] == 'http' :\\n saved_state_dict = model_zoo.load_url(args.restore_from)\\n else:\\n saved_state_dict = torch.load(args.restore_from)\\n\\n try:\\n model.load_state_dict(saved_state_dict)\\n except:\\n model = torch.nn.DataParallel(model)\\n model.load_state_dict(saved_state_dict)\\n model.eval()\\n model.cuda(gpu0)\\n\\n testloader = data.DataLoader(DarkZurichDataSet(args.data_dir, args.data_list, crop_size=(h, w), resize_size=(w, h), mean=IMG_MEAN, scale=False, mirror=False, set=args.set),\\n batch_size=batchsize, shuffle=False, pin_memory=True, num_workers=4)\\n\\n scale = 1.25\\n testloader2 = data.DataLoader(DarkZurichDataSet(args.data_dir, args.data_list, crop_size=(round(h*scale), round(w*scale) ), resize_size=( round(w*scale), round(h*scale)), mean=IMG_MEAN, scale=False, mirror=False, set=args.set),\\n batch_size=batchsize, shuffle=False, pin_memory=True, num_workers=4)\\n\\n\\n if version.parse(torch.__version__) >= version.parse('0.4.0'):\\n interp = nn.Upsample(size=(1080, 1920), mode='bilinear', align_corners=True)\\n else:\\n interp = nn.Upsample(size=(1080, 1920), mode='bilinear')\\n\\n sm = torch.nn.Softmax(dim = 1)\\n log_sm = torch.nn.LogSoftmax(dim = 1)\\n kl_distance = nn.KLDivLoss( reduction = 'none')\\n prior = np.load('./utils/prior_all.npy').transpose((2,0,1))[np.newaxis, :, :, :]\\n prior = torch.from_numpy(prior)\\n for index, img_data in enumerate(zip(testloader, testloader2) ):\\n batch, batch2 = img_data\\n image, _, name = batch\\n image2, _, name2 = batch2\\n\\n inputs = image.cuda()\\n inputs2 = image2.cuda()\\n print('\\\\r>>>>Extracting feature...%04d/%04d'%(index*batchsize, args.batchsize*len(testloader)), end='')\\n if args.model == 'DeepLab':\\n with torch.no_grad():\\n output1, output2 = model(inputs)\\n output_batch = interp(sm(0.5* output1 + output2))\\n\\n heatmap_batch = torch.sum(kl_distance(log_sm(output1), sm(output2)), dim=1)\\n\\n output1, output2 = model(fliplr(inputs))\\n output1, output2 = fliplr(output1), fliplr(output2)\\n output_batch += interp(sm(0.5 * output1 + output2))\\n del output1, output2, inputs\\n\\n output1, output2 = model(inputs2)\\n output_batch += interp(sm(0.5* output1 + output2))\\n output1, output2 = model(fliplr(inputs2))\\n output1, output2 = fliplr(output1), fliplr(output2)\\n output_batch += interp(sm(0.5 * output1 + output2))\\n del output1, output2, inputs2\\n ratio = 0.95\\n output_batch = output_batch.cpu() / 4\\n # output_batch = output_batch *(ratio + (1 - ratio) * prior)\\n output_batch = output_batch.data.numpy()\\n heatmap_batch = heatmap_batch.cpu().data.numpy()\\n elif args.model == 'DeeplabVGG' or args.model == 'Oracle':\\n output_batch = model(Variable(image).cuda())\\n output_batch = interp(output_batch).cpu().data.numpy()\\n\\n output_batch = output_batch.transpose(0,2,3,1)\\n score_batch = np.max(output_batch, axis=3)\\n output_batch = np.asarray(np.argmax(output_batch, axis=3), dtype=np.uint8)\\n\\n threshold = 0.3274\\n for i in range(output_batch.shape[0]):\\n output_single = output_batch[i,:,:]\\n output_col = colorize_mask(output_single)\\n output = Image.fromarray(output_single)\\n\\n name_tmp = name[i].split('/')[-1]\\n dir_name = name[i].split('/')[-2]\\n save_path = args.save + '/' + dir_name\\n if not os.path.isdir(save_path):\\n os.mkdir(save_path)\\n output.save('%s/%s' % (save_path, name_tmp))\\n print('%s/%s' % (save_path, name_tmp))\\n output_col.save('%s/%s_color.png' % (save_path, name_tmp.split('.')[0]))\\n\\n # heatmap_tmp = heatmap_batch[i,:,:]/np.max(heatmap_batch[i,:,:])\\n # fig = plt.figure()\\n # plt.axis('off')\\n # heatmap = plt.imshow(heatmap_tmp, cmap='viridis')\\n # fig.colorbar(heatmap)\\n # fig.savefig('%s/%s_heatmap.png' % (save_path, name_tmp.split('.')[0]))\\n\\n if args.set == 'test' or args.set == 'val':\\n # label\\n output.save('%s/%s' % (label_path, name_tmp))\\n # label invalid\\n output_single[score_batch[i, :, :] < threshold] = 255\\n output = Image.fromarray(output_single)\\n output.save('%s/%s' % (label_invalid_path, name_tmp))\\n # conficence\\n\\n confidence = score_batch[i, :, :] * 65535\\n confidence = np.asarray(confidence, dtype=np.uint16)\\n print(confidence.min(), confidence.max())\\n iio.imwrite('%s/%s' % (confidence_path, name_tmp), confidence)\\n\\n return args.save\",\n \"def compile(self):\\n self.model = compile_model(self.model_filename, include_paths = self.include_paths)\\n self.simulation = compile_model(self.sim_filename, include_paths = self.include_paths)\",\n \"def main():\\n\\tmodel = load_model(args.model)\\n\\tif not args.retrain:\\n\\t\\twhile True:\\n\\t\\t\\tvideos = glob.glob(args.input + '/*.mov')\\n\\t\\t\\tif len(videos) > 0:\\n\\t\\t\\t\\tlabel(videos, model)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tsleep(10)\\n\\telif args.retrain:\\n\\t\\t\\tpath, file = os.path.split(args.model)\\n\\t\\t\\tmodel.save(path + '/old_' + file)\\n\\n\\t\\t\\tX, Y = process_train_data(args.train)\\n\\t\\t\\tX_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state = 24)\\n\\n\\t\\t\\tes_cb = EarlyStopping(monitor='val_loss', patience=2, mode='auto', restore_best_weights=True)\\n\\t\\t\\thistory = model.fit(X_train, y_train, batch_size=32, epochs=50, callbacks=[es_cb], validation_data=(X_test, y_test), verbose=int(args.debug))\\n\\t\\t\\tmodel.save(args.model)\\n\\n\\t\\t\\tmaintain(args.train, 600)\",\n \"def run(self, **inputs):\\n if self.cached_model is None:\\n self.cache_model(**inputs)\\n for name, data in inputs.items():\\n self.shared_vars[name].set_value(data)\\n if self.mb and self.variational:\\n self.minibatches = zip(self._mb_generator(inputs['gwas_gen']),\\n self._mb_generator(inputs['gwas_phen']))\\n self.trace = self._inference()\\n return self.trace\",\n \"def run_model (arguments):\\n if arguments.train is not None:\\n # Train a new model, optionally with a certain number of epochs\\n predictor = None\\n if len(arguments.train) > 0:\\n predictor = train(n_epochs=arguments.train[0])\\n else:\\n predictor = train()\\n # Afterwards save it\\n now = datetime.now(timezone.utc)\\n predictor.to_disk(fname=f\\\"model_parameters_{now.strftime('%Y%m%d%H%M%S')}\\\")\\n elif arguments.export_embeddings:\\n # Load the saved predictor ...\\n predictor = Predictor.from_file()\\n # ... and then dump the models to disk.\\n predictor.subj.export_embeddings(\\\"subject\\\")\\n predictor.obj.export_embeddings(\\\"object\\\")\\n print(\\\"Models are saved to output directory for loading with http://projector.tensorflow.org/.\\\")\\n elif arguments.console:\\n # Opens a console for prediction without training\\n predictor = Predictor.from_file()\\n tinker(predictor)\",\n \"def main():\\n\\n gpu_id = 1\\n d_batch = 64\\n d_embed = 256\\n d_hidden = 256\\n d_image_size = 256\\n device = torch.device(f'cuda:{gpu_id}' if torch.cuda.is_available() else 'cpu')\\n dataset, train_loader = get_default_flickr30k_loader(d_batch=d_batch, d_image_size=d_image_size)\\n model = Img2Txt(dataset.d_vocab, d_embed, d_hidden, dataset.start_token, dataset.end_token).to(device)\\n\\n train(model, dataset, train_loader, device)\",\n \"def main(_):\\n if not FLAGS.model_output_dir:\\n raise ValueError(\\n \\\"Undefined model output directory. Perhaps you forgot to set the --model_output_dir flag?\\\")\\n \\n if FLAGS.predict_input_file:\\n decode()\\n else:\\n train()\",\n \"def TrainOneStep(self):\\n pass\",\n \"def main(tetrode_number=TETRODE_NUMBER,num_hidden_units=500,num_hidden_units_2=300,num_hidden_units_3=200,num_code_units=50):\\n \\n print(\\\"Making the model...\\\")\\n network = model((None,200),200,num_hidden_units,num_hidden_units_2,num_hidden_units_3,num_code_units)\\n print(\\\"Done!\\\")\\n\\n\\n for tetrode_number in [10]:\\n\\n print(\\\"Loading the model parameters from {}\\\".format(MODEL_FILENAME+str(tetrode_number)))\\n f = open(MODEL_FILENAME+str(tetrode_number),'r')\\n all_param_values = pickle.load(f)\\n f.close()\\n # print(all_param_values)\\n lasagne.layers.set_all_param_values(network, all_param_values)\\n\\n print(\\\"Loading the data...\\\")\\n dataset = load_data(tetrode_number)\\n print(\\\"Done!\\\")\\n\\n print(dataset['data'].shape)\\n\\n print(\\\"Setting up the training functions...\\\")\\n training = funcs(dataset,network)\\n print(\\\"Done!\\\")\\n\\n for i in range(NUM_EPOCHS):\\n costs = []\\n\\n for start, end in zip(range(0, dataset['data'].shape[0], BATCH_SIZE), range(BATCH_SIZE, dataset['data'].shape[0], BATCH_SIZE)):\\n cost = training['train'](dataset['data'][start:end],dataset['data'][start:end])\\n costs.append(cost)\\n\\n meanTrainCost = np.mean(np.asarray(costs,dtype=np.float32))\\n # accuracy = training['accuracy'](dataset['X_test'],dataset['y_test'])\\n\\n print(\\\"Epoch: {}, Training cost: {}\\\".format(i+1,meanTrainCost))\\n # NUM_POINTS = 5000\\n codes = training['code'](dataset['data'][0:NUM_POINTS])\\n\\n \\n\\n # y = set(list(d.predict(dataset['data'][0:NUM_POINTS])))\\n\\n # print(y)\\n\\n # activations_1 = training['activations_1'](dataset['data'][0:NUM_POINTS])\\n # activations_2 = training['activations_2'](dataset['data'][0:NUM_POINTS])\\n # codes = training['code'](dataset['data'][0:NUM_POINTS])\\n # # print(codes.shape)\\n # # codes_2d = bh_sne(codes)\\n\\n # for k in range(3):\\n # print(k)\\n\\n # codes_2d = bh_sne(np.asarray(codes[:(k+1)*12000],dtype=np.float64))\\n\\n # # d = DPGMM(n_components=10, covariance_type='full')\\n # d = DPGMM(n_components=15,n_iter=100)\\n\\n # d.fit(codes_2d[:(k+1)*12000])\\n\\n # hdp = d.predict_proba(codes_2d[:(k+1)*12000])\\n\\n # hdp_1d = [np.argmax(z) for z in hdp]\\n\\n # print(set(list(hdp_1d)))\\n\\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\\n # plt.savefig('dbscan_labels/deep/sparse/hdp_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\\n # plt.close()\\n\\n # # m = TSNE(n_components=2, random_state=0)\\n \\n # # codes_2d = m.fit_transform(codes[:NUM_POINTS])\\n # # activations_1_2d = bh_sne(activations_1)\\n # # activations_2_2d = bh_sne(activations_2)\\n\\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS][:(k+1)*12000],alpha=0.8,lw=0)\\n # plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\\n # plt.close()\\n\\n # # This is where the code for the video will go\\n # ##############################################################################\\n # # Compute DBSCAN\\n # db = None\\n # core_samples_mask = None\\n # labels = None\\n\\n # num_labels = 0\\n # eps=1.0\\n # while(num_labels < 10):\\n # db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\\n # core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\\n # core_samples_mask[db.core_sample_indices_] = True\\n # labels = db.labels_\\n # num_labels = np.amax(labels)\\n # eps -= 0.1\\n\\n # print(\\\"Num learned labels: {}\\\".format(num_labels))\\n\\n # plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS][:(k+1)*12000],lw=0)\\n # plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\\n # plt.close()\\n\\n # # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\\n # # pickle.dump(labels, f)\\n # # f.close()\\n\\n codes_2d = bh_sne(np.asarray(codes,dtype=np.float64),theta=0.4)\\n\\n # d = DPGMM(n_components=10, covariance_type='full')\\n d = DPGMM(n_components=15,n_iter=1000)\\n\\n d.fit(codes_2d)\\n\\n hdp = d.predict_proba(codes_2d)\\n\\n hdp_1d = [np.argmax(z) for z in hdp]\\n\\n print(set(list(hdp_1d)))\\n\\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\\n plt.savefig('dbscan_labels/deep/sparse/hdp_{}.png'.format(tetrode_number), bbox_inches='tight')\\n plt.close()\\n\\n # m = TSNE(n_components=2, random_state=0)\\n \\n # codes_2d = m.fit_transform(codes[:NUM_POINTS])\\n # activations_1_2d = bh_sne(activations_1)\\n # activations_2_2d = bh_sne(activations_2)\\n\\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS],alpha=0.8,lw=0)\\n plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\\n plt.close()\\n\\n # This is where the code for the video will go\\n ##############################################################################\\n # Compute DBSCAN\\n db = None\\n core_samples_mask = None\\n labels = None\\n\\n num_labels = 0\\n eps=1.0\\n while(num_labels < 10):\\n db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\\n core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\\n core_samples_mask[db.core_sample_indices_] = True\\n labels = db.labels_\\n num_labels = np.amax(labels)\\n eps -= 0.1\\n\\n print(\\\"Num learned labels: {}\\\".format(num_labels))\\n\\n plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS],lw=0)\\n plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\\n plt.close()\\n\\n # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\\n # pickle.dump(labels, f)\\n # f.close()\",\n \"def main():\\n\\n parser = argparse.ArgumentParser(description='Duolingo shared task baseline model')\\n parser.add_argument('--train', help='Training file name', required=True)\\n parser.add_argument('--test', help='Test file name, to make predictions on', required=True)\\n parser.add_argument('--pred', help='Output file name for predictions, defaults to test_name.pred')\\n args = parser.parse_args()\\n\\n if not args.pred:\\n args.pred = args.test + '.pred'\\n\\n assert os.path.isfile(args.train)\\n assert os.path.isfile(args.test)\\n\\n # Assert that the train course matches the test course\\n assert os.path.basename(args.train)[:5] == os.path.basename(args.test)[:5]\\n\\n training_data, training_labels = load_data(args.train)\\n test_data = load_data(args.test)\\n\\n ####################################################################################\\n # Here is the delineation between loading the data and running the baseline model. #\\n # Replace the code between this and the next comment block with your own. #\\n ####################################################################################\\n\\n\\n vectorizer = DictVectorizer()\\n X_train = [instance_data.to_features() for instance_data in training_data]\\n Y_train = [training_labels[instance_data.instance_id] for instance_data in training_data]\\n ids_train = [instance_data.instance_id for instance_data in training_data]\\n\\n X_test = [instance_data.to_features() for instance_data in test_data]\\n ids_test = [instance_data.instance_id for instance_data in test_data]\\n\\n\\n X_train = vectorizer.fit_transform(X_train)\\n clf = LogisticRegression()\\n clf.fit(X_train,Y_train)\\n\\n X_test = vectorizer.transform(X_test)\\n preds_scores = [x[0] for x in clf.predict_proba(X_test)]\\n predictions = dict([(instance_id,pred_score) for instance_id,pred_score in zip(ids_test,preds_scores)])\\n\\n ####################################################################################\\n # This ends the baseline model code; now we just write predictions. #\\n ####################################################################################\\n\\n with open(args.pred, 'wt') as f:\\n for instance_id, prediction in iteritems(predictions):\\n f.write(instance_id + ' ' + str(prediction) + '\\\\n')\",\n \"def main(Args):\\n norm = [1.9844158727667542, 413.83759806375525,\\n 51.2789974336363, 1038.4760551905683]\\n input_pull = False\\n input_model_mapping = False\\n max_number = 2\\n count = 40000\\n catalog_name = os.path.join(DATA_PATH, 'OneDegSq.fits')\\n # Define parameters for mrcnn model with btk here\\n resid_model = btk_utils.Resid_btk_model(\\n Args.model_name, Args.model_path, MODEL_DIR, training=True,\\n images_per_gpu=4, validation_for_training=True)\\n # Load parameters for dataset and load model\\n resid_model.config.WEIGHT_DECAY = 0.001\\n resid_model.config.STEPS_PER_EPOCH = 1000\\n resid_model.config.VALIDATION_STEPS = 20\\n sampling_function = None\\n layers = 'all'\\n if Args.model_name == 'model1':\\n resid_model.config.BACKBONE = 'resnet41'\\n elif Args.model_name == 'model2':\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n elif Args.model_name == 'model3':\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n elif Args.model_name == 'model4':\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n elif Args.model_name == 'model5':\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet35'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n elif Args.model_name == 'model4_large':\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = '4+' # '3+'\\n elif Args.model_name == 'model6':\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0, 1, 51.2789974336363, 1038.4760551905683]\\n input_pull = True\\n elif Args.model_name == 'model7':\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model8': # stretch = 0.1, Q = 3\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model9': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1., 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10_again': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10_again2': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10_again3': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10_2': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0., 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model11': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1., 0., 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model11_2': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1., 0., 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model12': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n max_number = 6\\n elif Args.model_name == 'model12_again': # stretch = 2000, Q = 0.5 # larger learning rate\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n max_number = 10 # changed from 6 to 10 for run 4\\n elif Args.model_name == 'model12_again2': # stretch = 2000, Q = 0.5 # larger learning rate val set reduced to 10\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n max_number = 6\\n resid_model.config.VALIDATION_STEPS = 10\\n else:\\n raise AttributeError(\\\"model not found\\\", Args.model_name)\\n print(\\\"Train in model:\\\", Args.model_name)\\n resid_model.config.display()\\n resid_model.make_resid_model(catalog_name, count=count,\\n max_number=max_number, augmentation=True,\\n norm_val=norm, input_pull=input_pull,\\n sampling_function=sampling_function,\\n input_model_mapping=input_model_mapping)\\n learning_rate = resid_model.config.LEARNING_RATE/10.\\n np.random.seed(Args.epochs)\\n history = resid_model.model.train(resid_model.dataset,\\n resid_model.dataset_val,\\n learning_rate=learning_rate,\\n epochs=Args.epochs,\\n layers=layers)\\n name = Args.model_name + '_run2'\\n with open(name + \\\".dill\\\", 'wb') as handle:\\n dill.dump(history.history, handle)\\n learning_rate = resid_model.config.LEARNING_RATE/10.\\n np.random.seed(Args.epochs + 10)\\n history = resid_model.model.train(resid_model.dataset,\\n resid_model.dataset_val,\\n learning_rate=learning_rate,\\n epochs=Args.epochs+10,\\n layers=layers)\\n name = Args.model_name + '_run3'\\n with open(name + \\\".dill\\\", 'wb') as handle:\\n dill.dump(history.history, handle)\",\n \"def run_tests():\\n source1 = TextModel(\\\"Barack Obama\\\")\\n source1.add_file('project/source_texts/barackobama_source_text.txt')\\n\\n source2 = TextModel('Donald Trump')\\n source2.add_file('project/source_texts/donaldtrump_source_text.txt')\\n\\n new1 = TextModel('More Obama')\\n new1.add_file('project/source_texts/moreobama_source_text.txt')\\n new1.classify(source1, source2)\\n\\n new2 = TextModel('More Trump')\\n new2.add_file('project/source_texts/moretrump_source_text.txt')\\n new2.classify(source1, source2)\\n\\n new1 = TextModel('Gucci Gang by Lil Pump')\\n new1.add_file('project/source_texts/guccigang_source_text.txt')\\n new1.classify(source1, source2)\\n\\n new1 = TextModel(\\\"Spongebob Transcripts\\\")\\n new1.add_file('project/source_texts/spongebobeps_source_text.txt')\\n new1.classify(source1, source2)\",\n \"def use_args(args):\\n global DATA_PATH\\n global IMAGES_FILE\\n global WORKING_DIR\\n global OUTPUT_DIR\\n global OUTPUT_FILE_NAME\\n global OUTPUT_FILE\\n global LOAD_INDEXES\\n global INDEXES_DIR\\n global MODEL\\n global JOIN_MODELS\\n global MODEL1\\n global MODEL2\\n global ALL_TOGETHER\\n global TRAINED_MODELS\\n global TRAINED_MODELS_DIR\\n global TRAINED_MODELS_DIR2\\n global TRAINED_MODELS_DIRS\\n global CROSS_VALIDATION\\n global TRAIN_EPOCHS\\n global FEATURES\\n \\n if args.data_path:\\n # Change the default path of the images\\n DATA_PATH = args.data_path\\n IMAGES_FILE = os.path.join(DATA_PATH, IMAGES_FILE_NAME)\\n \\n if args.working_dir:\\n # Change the default path of the working directory\\n WORKING_DIR = args.working_dir\\n OUTPUT_DIR = WORKING_DIR\\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\\n \\n if args.output_dir:\\n # Change the default path of the output directory\\n OUTPUT_DIR = os.path.join(WORKING_DIR, args.output_dir)\\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\\n \\n if args.output:\\n # Change the default name of the output file\\n OUTPUT_FILE_NAME = args.output\\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\\n \\n if args.indexes_dir:\\n # Load random and train indexes from file\\n LOAD_INDEXES = True\\n INDEXES_DIR = args.indexes_dir\\n \\n if args.model:\\n # Select model\\n MODEL = args.model\\n \\n if args.models:\\n \\n if not args.trained_models_dirs:\\n raise Exception(\\\"Arg. `-M --models` requires arg. \\\"\\n + \\\"`-T --trained_models_dirs`\\\")\\n \\n # Models to combine\\n JOIN_MODELS = True\\n MODEL1 = args.models[0]\\n MODEL2 = args.models[1]\\n \\n if args.trained_models_dir:\\n # Load trained models from file\\n TRAINED_MODELS = True\\n TRAINED_MODELS_DIR = args.trained_models_dir\\n \\n if args.trained_models_dirs:\\n # Load trained models from file\\n TRAINED_MODELS = True\\n TRAINED_MODELS_DIR = args.trained_models_dirs[0]\\n TRAINED_MODELS_DIR2 = args.trained_models_dirs[1]\\n \\n if args.all_together:\\n # The four models together\\n ALL_TOGETHER = True\\n TRAINED_MODELS_DIRS = args.all_together\\n \\n if args.cross_validation:\\n # Activate cross_validation\\n CROSS_VALIDATION = True\\n \\n if args.train_epochs:\\n # Change the default number of train epochs\\n TRAIN_EPOCHS = args.train_epochs\\n \\n if args.features:\\n # Nuber of best features to use\\n FEATURES = args.features\",\n \"def main_modeling_pipeline():\\n\\n\\n data_df = pd.read_csv('gs://aiplatformfilipegracio2020/head_train_data.csv')\\n data_df = data_df[[LABEL, 'price', 'days_on_site']]\\n\\n class_weights = calculate_class_weights(data_df[LABEL])\\n print('class weights', class_weights)\\n logging.info('Data loaded and processed')\\n train_ds, val_ds, test_ds = make_tf_datasets(data_df, LABEL)\\n logging.info('Tensorflow datasets created')\\n\\n with strategy.scope():\\n logging.info('Inside strategy')\\n simple_feature_layer = make_simple_feature_layer(data_df)\\n logging.info('Going to make model')\\n simple_model = make_simple_model(simple_feature_layer)\\n\\n logging.info('Going fit model')\\n simple_model_results, simple_model = model_fit_and_evaluate(model=simple_model,\\n train_ds=train_ds,\\n val_ds=val_ds,\\n test_ds=test_ds,\\n class_weights=class_weights,\\n epochs=TRAINING_EPOCHS,\\n job_name='simple_model')\\n\\n simple_model.save('gs://aiplatformfilipegracio2020/')\",\n \"def run(self, config, year):\\r\\n raw_input(\\\"Press any key to continue for year - %d\\\"%year)\\r\\n #return\\r\\n tm_config = config['travel_model_configuration']\\r\\n openamos_convergence_file = tm_config.get(\\\"openamos_convergence_file\\\",\\r\\n os.path.join(\\r\\n os.path.split(tm_config[\\\"openamos_path\\\"])[0], \\r\\n 'openamos_convergence.txt')\\r\\n )\\r\\n malta_convergence_file = tm_config.get(\\\"malta_convergence_file\\\",\\r\\n os.path.join(\\r\\n os.path.split(tm_config[\\\"malta_path\\\"])[0], \\r\\n 'malta_convergence.txt')\\r\\n )\\r\\n #tm_config['openamos_configuration'] = tm_config['openamos_configuration_first_iteration']\\r\\n #config['travel_model_configuration'] = tm_config\\r\\n\\r\\n openamosBeforeConfig = copy.deepcopy(tm_config['openamos_configuration'])\\r\\n openamosAfterConfig = copy.deepcopy(tm_config['openamos_configuration_after_iterations'])\\r\\n\\r\\n\\r\\n iteration = 1\\r\\n max_iterations = tm_config['max_iterations']\\r\\n print 'type', type(max_iterations), 'value',max_iterations\\r\\n\\r\\n print 'Starting iteration count - ', iteration\\r\\n\\r\\n while (not (self._is_converged(openamos_convergence_file) and self._is_converged(malta_convergence_file)) ) and iteration <= max_iterations:\\r\\n print 'Travel model iteration -', iteration\\r\\n\\r\\n #if iteration == 1: # switch configuration file for openamos for second and later iterations, \\r\\n # # only need to do it once\\r\\n\\r\\n # Run the models for building activity-travle skeletons\\r\\n tm_config['openamos_configuration'] = openamosBeforeConfig\\r\\n config['travel_model_configuration'] = tm_config\\r\\n setupCache = 1\\r\\n backupResults = 0\\r\\n RunOpenamos().run(config, year, iteration, setupCache, backupResults)\\r\\n raw_input(\\\"Check before malta for year %d ... \\\"%year)\\r\\n RunMalta().run(config, year, iteration)\\r\\n raw_input(\\\"Check after malta is completed for year %d ... \\\"%year)\\r\\n\\r\\n # Run the models for post processing the outputs ... \\r\\n tm_config['openamos_configuration'] = openamosAfterConfig\\r\\n config['travel_model_configuration'] = tm_config\\r\\n setupCache = 0\\r\\n backupResults = 1\\r\\n RunOpenamos().run(config, year, iteration, setupCache, backupResults)\\r\\n raw_input(\\\"Check after results are post-processed for year %d ... \\\"%year)\\r\\n # Copy the malta generated files including link travel times file, dynustudio files, distance files\\r\\n maltaFiles = [\\\"output_linkTrvTime.dat\\\", \\\"tmp_output_arrVeh.txt\\\", \\r\\n \\\"OutAccuVol.dat\\\", \\\"OutLinkSpeedAll.dat\\\", \\\"VehTrajectory.dat\\\",\\r\\n \\\"output_vmtVHT_%d.dat\\\"%(iteration+1)]\\r\\n\\r\\n for file in maltaFiles:\\r\\n loc = os.path.split(tm_config[\\\"malta_path\\\"])[0]\\r\\n fileLoc = os.path.join(loc, file)\\r\\n projectLoc = tm_config.get(\\\"project_path\\\")\\r\\n copyToLoc = os.path.join(projectLoc, \\\"year_%d\\\" %(year), \\\"iteration_%d\\\" %(iteration), file)\\r\\n shutil.copyfile(fileLoc, copyToLoc)\\r\\n iteration += 1\",\n \"def main():\\n parser = argparse.ArgumentParser(description='Behavioral Cloning Training Program')\\n parser.add_argument('-d', help='data directory', dest='data_dir', type=str, default='data')\\n parser.add_argument('-t', help='test size fraction', dest='test_size', type=float, default=0.2)\\n parser.add_argument('-k', help='drop out probability', dest='keep_prob', type=float, default=0.5)\\n parser.add_argument('-n', help='number of epochs', dest='nb_epoch', type=int, default=5)\\n parser.add_argument('-c', help='steering correction', dest='correction', type=float, default=0.2)\\n parser.add_argument('-b', help='batch size', dest='batch_size', type=int, default=32)\\n parser.add_argument('-o', help='save best models only', dest='save_best_only', type=s2b, default='true')\\n parser.add_argument('-l', help='learning rate', dest='learning_rate', type=float, default=1.0e-3)\\n args = parser.parse_args()\\n\\n print('-' * 30)\\n print('Parameters')\\n print('-' * 30)\\n for key, value in vars(args).items():\\n print('{:<20} := {}'.format(key, value))\\n print('-' * 30)\\n\\n data = load_data(args)\\n model = build_model(args)\\n train_model(model, args, *data)\",\n \"def evaluate(args):\\n dataset_param_filepath = os.path.join(args.model, 'dataset.params')\\n dataset_params = putils.load_params(dataset_param_filepath)\\n left_vocab_filepath = os.path.join(args.model, 'left.vocab')\\n left_vocab = Vocab(vocab_filepath=left_vocab_filepath)\\n right_vocab_filepath = os.path.join(args.model, 'right.vocab')\\n right_vocab = Vocab(vocab_filepath=right_vocab_filepath)\\n model_params_filepath = os.path.join(args.model, 'model.params')\\n model_params = putils.load_params(model_params_filepath)\\n checkpoint_filepath = os.path.join(args.model, 'checkpoint.tar')\\n if not torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location=const.DEVICE)\\n elif torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n elif torch.cuda.is_available() and not model_params['cuda']:\\n logger.info('Loading a CPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location='cuda:0')\\n else:\\n logger.info('Loading a CPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n if checkpoint['encoder']['model_type'] == 'transformer':\\n encoder = TEncoder(input_size=checkpoint['encoder']['input_size'],\\n hidden_size=checkpoint['encoder']['hidden_size'],\\n num_layers=checkpoint['encoder']['num_layers'],\\n dropout=checkpoint['encoder']['dropout'],\\n num_attention_heads=checkpoint['encoder']['num_attention_heads'])\\n else:\\n encoder = Encoder(model_type=checkpoint['encoder']['model_type'],\\n input_size=checkpoint['encoder']['input_size'],\\n hidden_size=checkpoint['encoder']['hidden_size'],\\n num_layers=checkpoint['encoder']['num_layers'],\\n nonlinearity=checkpoint['encoder']['nonlinearity'],\\n bias=checkpoint['encoder']['bias'],\\n dropout=checkpoint['encoder']['dropout'],\\n bidirectional=checkpoint['encoder']['bidirectional'])\\n if checkpoint['decoder']['model_type'] == 'transformer':\\n decoder = TDecoder(hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n dropout=checkpoint['decoder']['dropout'],\\n num_attention_heads=checkpoint['decoder']['num_attention_heads'])\\n elif checkpoint['decoder']['with_attention']:\\n decoder = Attention(hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n max_seq_len=dataset_params['max_seq_len'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'])\\n else:\\n decoder = Decoder(model_type=checkpoint['decoder']['model_type'],\\n hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'])\\n encoder.load_state_dict(checkpoint['encoder_state_dict'])\\n decoder.load_state_dict(checkpoint['decoder_state_dict'])\\n if torch.cuda.is_available():\\n encoder.to(const.DEVICE)\\n decoder.to(const.DEVICE)\\n encoder.eval()\\n decoder.eval()\\n pairs = putils.convert_to_seq_pairs(args.data)\\n indexed_pairs = putils.index_pairs(pairs, left_vocab.char2idx,\\n right_vocab.char2idx)\\n if dataset_params['reverse']:\\n indexed_pairs = [(y, x) for x, y in indexed_pairs]\\n source_vocab = right_vocab\\n target_vocab = left_vocab\\n else:\\n source_vocab = left_vocab\\n target_vocab = right_vocab\\n if args.random > 0:\\n random.shuffle(indexed_pairs)\\n for seq_num in range(args.random):\\n seq = indexed_pairs[seq_num]\\n print('-'*80)\\n input_str = ' '.join(\\n ''.join([source_vocab.idx2char[idx] for idx in seq[0] if idx\\n not in [const.SOS_IDX, const.EOS_IDX]])\\n .split(const.SEP))\\n gold_str = ' '.join(\\n ''.join([target_vocab.idx2char[idx] for idx in seq[1] if idx\\n not in [const.SOS_IDX, const.EOS_IDX]])\\n .split(const.SEP))\\n predicted_idxx = decode(seq[0], args.itemize, encoder, decoder,\\n dataset_params['max_seq_len'])\\n pred_str = ' '.join(\\n ''.join([target_vocab.idx2char[idx] for idx in predicted_idxx\\n if idx not in [const.SOS_IDX, const.EOS_IDX]])\\n .split(const.SEP))\\n print('>', input_str)\\n print('=', gold_str)\\n print('<', pred_str)\\n else:\\n _evaluate(indexed_pairs, args.itemize, encoder, decoder,\\n target_vocab.idx2char, dataset_params['max_seq_len'])\",\n \"def main(args):\\n\\n print(now(), \\\"test_model.py main() running.\\\")\\n\\n test_log = \\\"clean_test_log.txt\\\"\\n to_log_file(args, args.output, test_log)\\n\\n # Set device\\n device = \\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\"\\n\\n ####################################################\\n # Dataset\\n if args.dataset.lower() == \\\"cifar10\\\":\\n transform_train = get_transform(args.normalize, args.train_augment)\\n transform_test = get_transform(args.normalize, False)\\n trainset = torchvision.datasets.CIFAR10(\\n root=\\\"./data\\\", train=True, download=True, transform=transform_train\\n )\\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=128)\\n testset = torchvision.datasets.CIFAR10(\\n root=\\\"./data\\\", train=False, download=True, transform=transform_test\\n )\\n testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False)\\n elif args.dataset.lower() == \\\"cifar100\\\":\\n transform_train = get_transform(args.normalize, args.train_augment)\\n transform_test = get_transform(args.normalize, False)\\n trainset = torchvision.datasets.CIFAR100(\\n root=\\\"./data\\\", train=True, download=True, transform=transform_train\\n )\\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=128)\\n testset = torchvision.datasets.CIFAR100(\\n root=\\\"./data\\\", train=False, download=True, transform=transform_test\\n )\\n testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False)\\n\\n elif args.dataset.lower() == \\\"tinyimagenet_first\\\":\\n transform_train = get_transform(\\n args.normalize, args.train_augment, dataset=args.dataset\\n )\\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\\n trainset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"train\\\",\\n transform=transform_train,\\n classes=\\\"firsthalf\\\",\\n )\\n trainloader = torch.utils.data.DataLoader(\\n trainset, batch_size=64, num_workers=1, shuffle=True\\n )\\n testset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"val\\\",\\n transform=transform_test,\\n classes=\\\"firsthalf\\\",\\n )\\n testloader = torch.utils.data.DataLoader(\\n testset, batch_size=64, num_workers=1, shuffle=False\\n )\\n\\n elif args.dataset.lower() == \\\"tinyimagenet_last\\\":\\n transform_train = get_transform(\\n args.normalize, args.train_augment, dataset=args.dataset\\n )\\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\\n trainset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"train\\\",\\n transform=transform_train,\\n classes=\\\"lasthalf\\\",\\n )\\n trainloader = torch.utils.data.DataLoader(\\n trainset, batch_size=64, num_workers=1, shuffle=True\\n )\\n testset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"val\\\",\\n transform=transform_test,\\n classes=\\\"lasthalf\\\",\\n )\\n testloader = torch.utils.data.DataLoader(\\n testset, batch_size=64, num_workers=1, shuffle=False\\n )\\n\\n elif args.dataset.lower() == \\\"tinyimagenet_all\\\":\\n transform_train = get_transform(\\n args.normalize, args.train_augment, dataset=args.dataset\\n )\\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\\n trainset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"train\\\",\\n transform=transform_train,\\n classes=\\\"all\\\",\\n )\\n trainloader = torch.utils.data.DataLoader(\\n trainset, batch_size=64, num_workers=1, shuffle=True\\n )\\n testset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"val\\\",\\n transform=transform_test,\\n classes=\\\"all\\\",\\n )\\n testloader = torch.utils.data.DataLoader(\\n testset, batch_size=64, num_workers=1, shuffle=False\\n )\\n\\n else:\\n print(\\\"Dataset not yet implemented. Exiting from test_model.py.\\\")\\n sys.exit()\\n\\n ####################################################\\n\\n ####################################################\\n # Network and Optimizer\\n net = get_model(args.model, args.dataset)\\n\\n # load model from path if a path is provided\\n if args.model_path is not None:\\n net = load_model_from_checkpoint(args.model, args.model_path, args.dataset)\\n else:\\n print(\\\"No model path provided, continuing test with untrained network.\\\")\\n net = net.to(device)\\n ####################################################\\n\\n ####################################################\\n # Test Model\\n training_acc = test(net, trainloader, device)\\n natural_acc = test(net, testloader, device)\\n print(now(), \\\" Training accuracy: \\\", training_acc)\\n print(now(), \\\" Natural accuracy: \\\", natural_acc)\\n stats = OrderedDict(\\n [\\n (\\\"model path\\\", args.model_path),\\n (\\\"model\\\", args.model),\\n (\\\"normalize\\\", args.normalize),\\n (\\\"augment\\\", args.train_augment),\\n (\\\"training_acc\\\", training_acc),\\n (\\\"natural_acc\\\", natural_acc),\\n ]\\n )\\n to_results_table(stats, args.output, \\\"clean_performance.csv\\\")\\n ####################################################\\n\\n return\",\n \"def train(self)->None:\",\n \"def main():\\r\\n preprocessor = DATA_PREPROCESSOR('shakespeare-corpus.txt')\\r\\n corpus = preprocessor.preprocess_data()\\r\\n plot(corpus)\\r\\n data, unique_vocab, word_to_idx = create_context(corpus)\\r\\n\\r\\n #train model- changed global variable if needed\\r\\n model=CBOW(len(unique_vocab), EMBEDDING_DIM, CONTEXT_SIZE)\\r\\n if USE_ADAM:\\r\\n print('Using adam as optimizer')\\r\\n optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\\r\\n else:\\r\\n print('Using SGD as optimizer')\\r\\n optimizer = torch.optim.SGD(model.parameters(), lr=0.001)\\r\\n\\r\\n checkpoint_file ='checkpoint.pth'\\r\\n checkpoint_available= os.path.exists(checkpoint_file)\\r\\n if checkpoint_available:\\r\\n model, optimizer, current_epoch = reset_model_to_checkpoint(model, optimizer, checkpoint_file)\\r\\n else:\\r\\n print('no checkpoint found. initializing new model..\\\\n')\\r\\n current_epoch=0 \\r\\n\\r\\n executor = MODEL_EXECUTOR(model)\\r\\n if RESUME_TRAINING or not checkpoint_available:\\r\\n print('resuming training...\\\\n')\\r\\n import time\\r\\n start_time = time.time()\\r\\n cbow = executor.train(optimizer, data, unique_vocab, word_to_idx, current_epoch, checkpoint_file)\\r\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\r\\n else:\\r\\n print('pre-trained model loaded. no further training...\\\\n')\\r\\n\\r\\n # get two words similarity\\r\\n executor.test(unique_vocab,word_to_idx)\\r\\n\\r\\n show_closest_words(cbow, word_to_idx,unique_vocab)\",\n \"def main():\\n # get config and processing of clauses\\n config = Config(load=False)\\n\\n # Generators\\n dev = Dataset(config.filename_dev)\\n test = Dataset(config.filename_test)\\n train = Dataset(config.filename_train)\\n\\n # Build tags vocab\\n vocab_tags = get_tag_vocab([train, dev, test])\\n vocab_tags.add(UNK)\\n\\n # Save vocab\\n write_vocab(vocab_tags, config.filename_tags)\\n\\n\\n # Build and save char vocab\\n train = Dataset(config.filename_train)\\n vocab_chars = get_char_vocab(train)\\n write_vocab(vocab_chars, config.filename_chars)\",\n \"def run_models(\\n self,\\n normal=True,\\n interrupt=True,\\n run_start=None,\\n state_builder=\\\"acis\\\",\\n hrc=False,\\n ):\\n if hrc:\\n loads = hrc_loads\\n else:\\n loads = test_loads\\n if normal and \\\"normal\\\" in loads:\\n for load in loads[\\\"normal\\\"]:\\n self.run_model(\\n load_week=load,\\n run_start=run_start,\\n state_builder=state_builder,\\n )\\n if interrupt and \\\"interrupt\\\" in loads:\\n for load in loads[\\\"interrupt\\\"]:\\n self.run_model(\\n load_week=load,\\n interrupt=True,\\n run_start=run_start,\\n state_builder=state_builder,\\n )\",\n \"def main():\\r\\n tr_loader, va_loader, te_loader, semantic_labels = get_train_val_test_loaders(\\r\\n task=\\\"source\\\", batch_size=config(\\\"source.batch_size\\\")\\r\\n )\\r\\n\\r\\n model = Source()\\r\\n print(\\\"Loading source...\\\")\\r\\n model, epoch, stats = restore_checkpoint(model, config(\\\"source.checkpoint\\\"))\\r\\n\\r\\n sem_labels = \\\"0 - Samoyed\\\\n1 - Miniature Poodle\\\\n2 - Saint Bernard\\\\n3 - Great Dane\\\\n4 - Dalmatian\\\\n5 - Chihuahua\\\\n6 - Siberian Husky\\\\n7 - Yorkshire Terrier\\\"\\r\\n\\r\\n # Evaluate model\\r\\n plot_conf(va_loader, model, sem_labels, \\\"conf_matrix.png\\\")\",\n \"def main():\\n config = handle_args()\\n print(config)\\n\\n if config['mode'] == 'train':\\n logger.info('Train mode')\\n trainer = Trainer(config, shared_theano_params=None, **config)\\n trainer.train(**config)\\n logger.warn('Exiting train mode')\\n else:\\n logger.info('Test mode')\\n translator = Translator(**config)\\n translator.load_from_disk(config['models'], config['configs'],\\n config['src_dicts'], config['trg_dict'])\\n translator.translate_and_save(**config)\",\n \"def main():\\n # Read data for train set\\n print('loading training data')\\n train = read_datafile('../data/tsd_train.csv')\\n\\n # Read trial data for validation set\\n validation = read_datafile('../data/tsd_trial.csv')\\n\\n # Read data for test set\\n print('loading test data')\\n test = read_datafile('../data/tsd_test.csv')\\n\\n # Convert training data to Spacy Entities\\n nlp = spacy.load(\\\"en_core_web_sm\\\")\\n print('preparing training data')\\n training_data = []\\n for n, (spans, text) in enumerate(train):\\n doc = nlp(text)\\n ents = spans_to_ents(doc, set(spans), 'TOXIC')\\n training_data.append((doc.text, {'entities': ents}))\\n\\n toxic_tagging = spacy.blank('en')\\n toxic_tagging.vocab.strings.add('TOXIC')\\n ner = nlp.create_pipe(\\\"ner\\\")\\n toxic_tagging.add_pipe(ner, last=True)\\n ner.add_label('TOXIC')\\n\\n pipe_exceptions = [\\\"ner\\\", \\\"trf_wordpiecer\\\", \\\"trf_tok2vec\\\"]\\n unaffected_pipes = [\\n pipe for pipe in toxic_tagging.pipe_names\\n if pipe not in pipe_exceptions]\\n\\n\\n print('Training!')\\n with toxic_tagging.disable_pipes(*unaffected_pipes):\\n \\n toxic_tagging.begin_training()\\n for iteration in range(30):\\n random.shuffle(training_data)\\n losses = {}\\n batches = spacy.util.minibatch(\\n training_data, size=spacy.util.compounding(\\n 4.0, 32.0, 1.001))\\n for batch in batches:\\n texts, annotations = zip(*batch)\\n toxic_tagging.update(texts, annotations, drop=0.5, losses=losses)\\n print(\\\"Losses\\\", losses)\\n\\n\\n # Define helper function for evaluating datasets\\n def evaluate(dateset):\\n precision_recall_f1_scores = []\\n for spans, text in dateset:\\n pred_spans = []\\n doc = toxic_tagging(text)\\n for ent in doc.ents:\\n pred_spans.extend(range(ent.start_char, ent.start_char + len(ent.text)))\\n \\n # score = semeval2021.f1(pred_spans, spans)\\n precision_recall_f1_scores.append(per_post_precision_recall_f1(pred_spans, spans))\\n\\n # compute average precision, recall and f1 score of all posts\\n return np.array(precision_recall_f1_scores).mean(axis=0)\\n\\n # Evaluate on dev and test sets\\n print('Evaluation:')\\n eval_precision, eval_recall, eval_f1 = evaluate(validation)\\n test_precision, test_recall, test_f1 = evaluate(test)\\n \\n print(f'Dev set: Precision = {eval_precision}, Recall = {eval_recall}, F1 = {eval_f1}')\\n print(f'Test set: Precision = {test_precision}, Recall = {test_recall}, F1 = {test_f1}')\",\n \"def train(self, ):\\n raise NotImplementedError\",\n \"def train(self, model, args):\\n if model == self.WORD_DET_RFC:\\n return self.train_rfc(args)\\n elif model == self.REGRESSION_PARAMS:\\n return self.train_bb_reg(args)\\n else:\\n raise Exception('No model %s exists to train' % model)\",\n \"def run(self, X, Y, model):\\n\\n p0 = X.iloc[0] # read in the input info\\n params = lmfit.Parameters() # empty parameter class\\n success = True # check for success\\n\\n if model == 'Medlyn':\\n min, max = self.param_space('g1')\\n params.add('g1', p0.g1, min=min, max=max)\\n min, max = self.param_space('sref')\\n params.add('sref', p0.sref, min=min, max=max)\\n\\n if model == 'Eller':\\n min, max = self.param_space('kmax')\\n params.add('kmaxS1', p0.kmaxS1, min=min, max=max)\\n\\n if (model == 'ProfitMax') or (model == 'ProfitMax2'):\\n min, max = self.param_space('kmax')\\n params.add('kmax', p0.kmax, min=min, max=max)\\n\\n # the following models all require the Sperry kmax as an input!\\n if model == 'Tuzet':\\n min, max = self.param_space('g1')\\n params.add('g1T', p0.g1T, min=min, max=max)\\n\\n if 'Tleaf' in X.columns: # vary g1 and kmax\\n min, max = self.param_space('kmax')\\n params.add('kmaxT', p0.kmax, min=min, max=max)\\n\\n else: # vary g1 and Pref, sref fixed\\n min, max = self.param_space('PrefT', P50=p0.P50, P88=p0.P88)\\n\\n if any(X['Ps_pd'] > p0.PrefT):\\n params.add('PrefT', p0.PrefT, min=min, max=max)\\n\\n else:\\n params.add('PrefT', -p0.P88, min=min, max=max)\\n\\n if model == 'WUE-LWP':\\n min, max = self.param_space('Lambda')\\n params.add('Lambda', p0.Lambda, min=min, max=max)\\n\\n if model == 'CGain':\\n min, max = self.param_space('Kappa')\\n params.add('Kappa', p0.Kappa, min=min, max=max)\\n\\n if model == 'CMax':\\n min, max = self.param_space('Alpha')\\n params.add('Alpha', p0.Alpha, min=min, max=max)\\n min, max = self.param_space('Beta')\\n params.add('Beta', p0.Beta, min=min, max=max)\\n\\n if model == 'SOX-OPT':\\n min, max = self.param_space('kmax')\\n params.add('kmaxS2', p0.kmaxS2, min=min, max=max)\\n\\n if model == 'LeastCost':\\n min, max = self.param_space('kmax')\\n params.add('kmaxLC', p0.kmaxLC, min=min, max=max)\\n min, max = self.param_space('Eta')\\n params.add('Eta', p0.Eta, min=min, max=max)\\n\\n if model == 'CAP':\\n min, max = self.param_space('krl')\\n params.add('krlC', p0.krlC, min=min, max=max)\\n min, max = self.param_space('Pcrit', P50=p0.P50, P88=p0.P88)\\n\\n if any(X['Ps_pd'] > p0.PcritC):\\n params.add('PcritC', p0.PcritC, min=min, max=max)\\n\\n else:\\n params.add('PcritC', -p0.P88, min=min, max=max)\\n\\n if model == 'MES':\\n min, max = self.param_space('krl')\\n params.add('krlM', p0.krlM, min=min, max=max)\\n min, max = self.param_space('Pcrit', P50=p0.P50, P88=p0.P88)\\n\\n if any(X['Ps_pd'] > p0.PcritM):\\n params.add('PcritM', p0.PcritM, min=min, max=max)\\n\\n else:\\n params.add('PcritM', -p0.P88, min=min, max=max)\\n\\n if not os.path.isdir(self.opath): # create output dir\\n os.makedirs(self.opath)\\n\\n # run the minimizer\\n if self.method == 'emcee':\\n out = lmfit.minimize(fres, params, args=(model, X, Y,\\n self.inf_gb,),\\n method=self.method, steps=self.steps,\\n nwalkers=self.nchains, burn=self.burn,\\n thin=self.thin, is_weighted=False,\\n progress=False, nan_policy='omit')\\n\\n else:\\n out = lmfit.minimize(fres, params, args=(model, X, Y,\\n self.inf_gb,),\\n method=self.method, nan_policy='omit')\\n\\n for param in out.params.values():\\n\\n if np.isclose(param.value, param.init_value):\\n params[param.name] = lmfit.Parameter(name=param.name,\\n value=1.5 *\\n param.init_value)\\n out = lmfit.minimize(fres, params,\\n args=(model, X, Y, self.inf_gb,),\\n method=self.method,\\n nan_policy='omit')\\n\\n if not os.path.isfile(os.path.join(self.opath, '%s.txt' % (model))):\\n txt = open(os.path.join(self.opath, '%s.txt' % (model)), 'w+')\\n\\n else: # append to existing file\\n txt = open(os.path.join(self.opath, '%s.txt' % (model)), 'a+')\\n\\n txt.write('\\\\n')\\n txt.write(lmfit.fit_report(out))\\n\\n if not success:\\n txt.write('\\\\n## Warning: had to fix first parameter value')\\n\\n txt.write('\\\\n')\\n txt.close() # close text file\\n\\n return out.params.valuesdict()\",\n \"def run(self, task):\\n params = self.params\\n\\n # task parameters\\n self.task = task\\n params.out_features = N_CLASSES[task]\\n self.is_classif = task != 'STS-B'\\n\\n # load data\\n self.data = self.load_data(task)\\n if not self.data['dico'] == self._embedder.dico:\\n raise Exception((\\\"Dictionary in evaluation data (%i words) seems different than the one \\\" +\\n \\\"in the pretrained model (%i words). Please verify you used the same dictionary, \\\" +\\n \\\"and the same values for max_vocab and min_count.\\\") % (len(self.data['dico']), len(self._embedder.dico)))\\n\\n # embedder\\n self.embedder = copy.deepcopy(self._embedder)\\n self.embedder.npu()\\n\\n # projection layer\\n self.proj = nn.Sequential(*[\\n nn.Dropout(params.dropout),\\n nn.Linear(self.embedder.out_dim, params.out_features)\\n ]).npu()\\n\\n # optimizers\\n self.optimizer_e = get_optimizer(list(self.embedder.get_parameters(params.finetune_layers)), params.optimizer_e)\\n self.optimizer_p = get_optimizer(self.proj.parameters(), params.optimizer_p)\\n\\n # train and evaluate the model\\n for epoch in range(params.n_epochs):\\n\\n # update epoch\\n self.epoch = epoch\\n\\n # training\\n logger.info(\\\"GLUE - %s - Training epoch %i ...\\\" % (task, epoch))\\n self.train()\\n\\n # evaluation\\n logger.info(\\\"GLUE - %s - Evaluating epoch %i ...\\\" % (task, epoch))\\n with torch.no_grad():\\n scores = self.eval('valid')\\n self.scores.update(scores)\\n self.eval('test')\",\n \"def run(self):\\n self.membershipFunction()\\n self.interpretingMF()\\n self.rules()\\n self.standardComposition_Min()\\n self.standardComposition_Max()\\n self.defuzzification()\",\n \"def run_models(request):\\n job_form_data = request.session['job_form_data']\\n job_wrapper = JobWrapper(job_form_data)\\n job_wrapper.create_data_file()\\n print job_wrapper.job_form_data\\n # Must run emits to generate emis_co2.dat - this step is requried to\\n # run the models and it's a lot simpler to have it run form here than\\n # from a job manager script\\n cmd = \\\"/var/opt/IMOGEN/EMITS/emits\\\"\\n subprocess.call(cmd, shell=True)\\n print \\\"Ran {0} program\\\".format(cmd)\\n # Now submit the models via the job manager\\n jr = DRMAAJobRunner()\\n return jr.queue_job(job_wrapper)\",\n \"def train(self) -> Any:\\n pass\",\n \"def train(self):\\n\\t\\traise NotImplementedError\",\n \"def eval(self):\\n self.train(mode=False)\",\n \"def train(\\n # fmt: off\\n lang: (\\\"Model language\\\", \\\"positional\\\", None, str),\\n output_path: (\\\"Output directory to store model in\\\", \\\"positional\\\", None, Path),\\n train_path: (\\\"Location of JSON-formatted training data\\\", \\\"positional\\\", None, Path),\\n dev_path: (\\\"Location of JSON-formatted development data\\\", \\\"positional\\\", None, Path),\\n raw_text: (\\\"Path to jsonl file with unlabelled text documents.\\\", \\\"option\\\", \\\"rt\\\", Path) = None,\\n base_model: (\\\"Name of model to update (optional)\\\", \\\"option\\\", \\\"b\\\", str) = None,\\n pipeline: (\\\"Comma-separated names of pipeline components\\\", \\\"option\\\", \\\"p\\\", str) = \\\"tagger,parser,ner\\\",\\n vectors: (\\\"Model to load vectors from\\\", \\\"option\\\", \\\"v\\\", str) = None,\\n replace_components: (\\\"Replace components from base model\\\", \\\"flag\\\", \\\"R\\\", bool) = False,\\n n_iter: (\\\"Number of iterations\\\", \\\"option\\\", \\\"n\\\", int) = 30,\\n n_early_stopping: (\\\"Maximum number of training epochs without dev accuracy improvement\\\", \\\"option\\\", \\\"ne\\\", int) = None,\\n n_examples: (\\\"Number of examples\\\", \\\"option\\\", \\\"ns\\\", int) = 0,\\n use_gpu: (\\\"Use GPU\\\", \\\"option\\\", \\\"g\\\", int) = -1,\\n version: (\\\"Model version\\\", \\\"option\\\", \\\"V\\\", str) = \\\"0.0.0\\\",\\n meta_path: (\\\"Optional path to meta.json to use as base.\\\", \\\"option\\\", \\\"m\\\", Path) = None,\\n init_tok2vec: (\\\"Path to pretrained weights for the token-to-vector parts of the models. See 'spacy pretrain'. Experimental.\\\", \\\"option\\\", \\\"t2v\\\", Path) = None,\\n parser_multitasks: (\\\"Side objectives for parser CNN, e.g. 'dep' or 'dep,tag'\\\", \\\"option\\\", \\\"pt\\\", str) = \\\"\\\",\\n entity_multitasks: (\\\"Side objectives for NER CNN, e.g. 'dep' or 'dep,tag'\\\", \\\"option\\\", \\\"et\\\", str) = \\\"\\\",\\n noise_level: (\\\"Amount of corruption for data augmentation\\\", \\\"option\\\", \\\"nl\\\", float) = 0.0,\\n orth_variant_level: (\\\"Amount of orthography variation for data augmentation\\\", \\\"option\\\", \\\"ovl\\\", float) = 0.0,\\n eval_beam_widths: (\\\"Beam widths to evaluate, e.g. 4,8\\\", \\\"option\\\", \\\"bw\\\", str) = \\\"\\\",\\n gold_preproc: (\\\"Use gold preprocessing\\\", \\\"flag\\\", \\\"G\\\", bool) = False,\\n learn_tokens: (\\\"Make parser learn gold-standard tokenization\\\", \\\"flag\\\", \\\"T\\\", bool) = False,\\n textcat_multilabel: (\\\"Textcat classes aren't mutually exclusive (multilabel)\\\", \\\"flag\\\", \\\"TML\\\", bool) = False,\\n textcat_arch: (\\\"Textcat model architecture\\\", \\\"option\\\", \\\"ta\\\", str) = \\\"bow\\\",\\n textcat_positive_label: (\\\"Textcat positive label for binary classes with two labels\\\", \\\"option\\\", \\\"tpl\\\", str) = None,\\n tag_map_path: (\\\"Location of JSON-formatted tag map\\\", \\\"option\\\", \\\"tm\\\", Path) = None,\\n verbose: (\\\"Display more information for debug\\\", \\\"flag\\\", \\\"VV\\\", bool) = False,\\n debug: (\\\"Run data diagnostics before training\\\", \\\"flag\\\", \\\"D\\\", bool) = False,\\n # fmt: on\\n):\\n util.fix_random_seed()\\n util.set_env_log(verbose)\\n\\n # Make sure all files and paths exists if they are needed\\n train_path = util.ensure_path(train_path)\\n dev_path = util.ensure_path(dev_path)\\n meta_path = util.ensure_path(meta_path)\\n output_path = util.ensure_path(output_path)\\n if raw_text is not None:\\n raw_text = list(srsly.read_jsonl(raw_text))\\n if not train_path or not train_path.exists():\\n msg.fail(\\\"Training data not found\\\", train_path, exits=1)\\n if not dev_path or not dev_path.exists():\\n msg.fail(\\\"Development data not found\\\", dev_path, exits=1)\\n if meta_path is not None and not meta_path.exists():\\n msg.fail(\\\"Can't find model meta.json\\\", meta_path, exits=1)\\n meta = srsly.read_json(meta_path) if meta_path else {}\\n if output_path.exists() and [p for p in output_path.iterdir() if p.is_dir()]:\\n msg.warn(\\n \\\"Output directory is not empty\\\",\\n \\\"This can lead to unintended side effects when saving the model. \\\"\\n \\\"Please use an empty directory or a different path instead. If \\\"\\n \\\"the specified output path doesn't exist, the directory will be \\\"\\n \\\"created for you.\\\",\\n )\\n if not output_path.exists():\\n output_path.mkdir()\\n msg.good(f\\\"Created output directory: {output_path}\\\")\\n\\n tag_map = {}\\n if tag_map_path is not None:\\n tag_map = srsly.read_json(tag_map_path)\\n # Take dropout and batch size as generators of values -- dropout\\n # starts high and decays sharply, to force the optimizer to explore.\\n # Batch size starts at 1 and grows, so that we make updates quickly\\n # at the beginning of training.\\n dropout_rates = util.decaying(\\n util.env_opt(\\\"dropout_from\\\", 0.2),\\n util.env_opt(\\\"dropout_to\\\", 0.2),\\n util.env_opt(\\\"dropout_decay\\\", 0.0),\\n )\\n batch_sizes = util.compounding(\\n util.env_opt(\\\"batch_from\\\", 100.0),\\n util.env_opt(\\\"batch_to\\\", 1000.0),\\n util.env_opt(\\\"batch_compound\\\", 1.001),\\n )\\n\\n if not eval_beam_widths:\\n eval_beam_widths = [1]\\n else:\\n eval_beam_widths = [int(bw) for bw in eval_beam_widths.split(\\\",\\\")]\\n if 1 not in eval_beam_widths:\\n eval_beam_widths.append(1)\\n eval_beam_widths.sort()\\n has_beam_widths = eval_beam_widths != [1]\\n\\n default_dir = Path(__file__).parent.parent / \\\"ml\\\" / \\\"models\\\" / \\\"defaults\\\"\\n\\n # Set up the base model and pipeline. If a base model is specified, load\\n # the model and make sure the pipeline matches the pipeline setting. If\\n # training starts from a blank model, intitalize the language class.\\n pipeline = [p.strip() for p in pipeline.split(\\\",\\\")]\\n msg.text(f\\\"Training pipeline: {pipeline}\\\")\\n disabled_pipes = None\\n pipes_added = False\\n if use_gpu >= 0:\\n activated_gpu = None\\n try:\\n activated_gpu = set_gpu(use_gpu)\\n except Exception as e:\\n msg.warn(f\\\"Exception: {e}\\\")\\n if activated_gpu is not None:\\n msg.text(f\\\"Using GPU: {use_gpu}\\\")\\n else:\\n msg.warn(f\\\"Unable to activate GPU: {use_gpu}\\\")\\n msg.text(\\\"Using CPU only\\\")\\n use_gpu = -1\\n if base_model:\\n msg.text(f\\\"Starting with base model '{base_model}'\\\")\\n nlp = util.load_model(base_model)\\n if nlp.lang != lang:\\n msg.fail(\\n f\\\"Model language ('{nlp.lang}') doesn't match language \\\"\\n f\\\"specified as `lang` argument ('{lang}') \\\",\\n exits=1,\\n )\\n if vectors:\\n msg.text(f\\\"Loading vectors from model '{vectors}'\\\")\\n _load_vectors(nlp, vectors)\\n\\n nlp.select_pipes(disable=[p for p in nlp.pipe_names if p not in pipeline])\\n for pipe in pipeline:\\n # first, create the model.\\n # Bit of a hack after the refactor to get the vectors into a default config\\n # use train-from-config instead :-)\\n if pipe == \\\"parser\\\":\\n config_loc = default_dir / \\\"parser_defaults.cfg\\\"\\n elif pipe == \\\"tagger\\\":\\n config_loc = default_dir / \\\"tagger_defaults.cfg\\\"\\n elif pipe == \\\"ner\\\":\\n config_loc = default_dir / \\\"ner_defaults.cfg\\\"\\n elif pipe == \\\"textcat\\\":\\n config_loc = default_dir / \\\"textcat_defaults.cfg\\\"\\n elif pipe == \\\"senter\\\":\\n config_loc = default_dir / \\\"senter_defaults.cfg\\\"\\n else:\\n raise ValueError(f\\\"Component {pipe} currently not supported.\\\")\\n pipe_cfg = util.load_config(config_loc, create_objects=False)\\n if vectors:\\n pretrained_config = {\\n \\\"@architectures\\\": \\\"spacy.VocabVectors.v1\\\",\\n \\\"name\\\": vectors,\\n }\\n pipe_cfg[\\\"model\\\"][\\\"tok2vec\\\"][\\\"pretrained_vectors\\\"] = pretrained_config\\n\\n if pipe == \\\"parser\\\":\\n pipe_cfg[\\\"learn_tokens\\\"] = learn_tokens\\n elif pipe == \\\"textcat\\\":\\n pipe_cfg[\\\"exclusive_classes\\\"] = not textcat_multilabel\\n pipe_cfg[\\\"architecture\\\"] = textcat_arch\\n pipe_cfg[\\\"positive_label\\\"] = textcat_positive_label\\n\\n if pipe not in nlp.pipe_names:\\n msg.text(f\\\"Adding component to base model '{pipe}'\\\")\\n nlp.add_pipe(nlp.create_pipe(pipe, config=pipe_cfg))\\n pipes_added = True\\n elif replace_components:\\n msg.text(f\\\"Replacing component from base model '{pipe}'\\\")\\n nlp.replace_pipe(pipe, nlp.create_pipe(pipe, config=pipe_cfg))\\n pipes_added = True\\n else:\\n if pipe == \\\"textcat\\\":\\n textcat_cfg = nlp.get_pipe(\\\"textcat\\\").cfg\\n base_cfg = {\\n \\\"exclusive_classes\\\": textcat_cfg[\\\"exclusive_classes\\\"],\\n \\\"architecture\\\": textcat_cfg[\\\"architecture\\\"],\\n \\\"positive_label\\\": textcat_cfg[\\\"positive_label\\\"],\\n }\\n if base_cfg != pipe_cfg:\\n msg.fail(\\n f\\\"The base textcat model configuration does\\\"\\n f\\\"not match the provided training options. \\\"\\n f\\\"Existing cfg: {base_cfg}, provided cfg: {pipe_cfg}\\\",\\n exits=1,\\n )\\n msg.text(f\\\"Extending component from base model '{pipe}'\\\")\\n disabled_pipes = nlp.select_pipes(\\n disable=[p for p in nlp.pipe_names if p not in pipeline]\\n )\\n else:\\n msg.text(f\\\"Starting with blank model '{lang}'\\\")\\n lang_cls = util.get_lang_class(lang)\\n nlp = lang_cls()\\n\\n if vectors:\\n msg.text(f\\\"Loading vectors from model '{vectors}'\\\")\\n _load_vectors(nlp, vectors)\\n\\n for pipe in pipeline:\\n # first, create the model.\\n # Bit of a hack after the refactor to get the vectors into a default config\\n # use train-from-config instead :-)\\n if pipe == \\\"parser\\\":\\n config_loc = default_dir / \\\"parser_defaults.cfg\\\"\\n elif pipe == \\\"tagger\\\":\\n config_loc = default_dir / \\\"tagger_defaults.cfg\\\"\\n elif pipe == \\\"morphologizer\\\":\\n config_loc = default_dir / \\\"morphologizer_defaults.cfg\\\"\\n elif pipe == \\\"ner\\\":\\n config_loc = default_dir / \\\"ner_defaults.cfg\\\"\\n elif pipe == \\\"textcat\\\":\\n config_loc = default_dir / \\\"textcat_defaults.cfg\\\"\\n elif pipe == \\\"senter\\\":\\n config_loc = default_dir / \\\"senter_defaults.cfg\\\"\\n else:\\n raise ValueError(f\\\"Component {pipe} currently not supported.\\\")\\n pipe_cfg = util.load_config(config_loc, create_objects=False)\\n if vectors:\\n pretrained_config = {\\n \\\"@architectures\\\": \\\"spacy.VocabVectors.v1\\\",\\n \\\"name\\\": vectors,\\n }\\n pipe_cfg[\\\"model\\\"][\\\"tok2vec\\\"][\\\"pretrained_vectors\\\"] = pretrained_config\\n\\n if pipe == \\\"parser\\\":\\n pipe_cfg[\\\"learn_tokens\\\"] = learn_tokens\\n elif pipe == \\\"textcat\\\":\\n pipe_cfg[\\\"exclusive_classes\\\"] = not textcat_multilabel\\n pipe_cfg[\\\"architecture\\\"] = textcat_arch\\n pipe_cfg[\\\"positive_label\\\"] = textcat_positive_label\\n\\n pipe = nlp.create_pipe(pipe, config=pipe_cfg)\\n nlp.add_pipe(pipe)\\n\\n # Update tag map with provided mapping\\n nlp.vocab.morphology.tag_map.update(tag_map)\\n\\n # Multitask objectives\\n multitask_options = [(\\\"parser\\\", parser_multitasks), (\\\"ner\\\", entity_multitasks)]\\n for pipe_name, multitasks in multitask_options:\\n if multitasks:\\n if pipe_name not in pipeline:\\n msg.fail(\\n f\\\"Can't use multitask objective without '{pipe_name}' in \\\"\\n f\\\"the pipeline\\\"\\n )\\n pipe = nlp.get_pipe(pipe_name)\\n for objective in multitasks.split(\\\",\\\"):\\n pipe.add_multitask_objective(objective)\\n\\n # Prepare training corpus\\n msg.text(f\\\"Counting training words (limit={n_examples})\\\")\\n corpus = GoldCorpus(train_path, dev_path, limit=n_examples)\\n n_train_words = corpus.count_train()\\n\\n if base_model and not pipes_added:\\n # Start with an existing model, use default optimizer\\n optimizer = create_default_optimizer()\\n else:\\n # Start with a blank model, call begin_training\\n cfg = {\\\"device\\\": use_gpu}\\n optimizer = nlp.begin_training(lambda: corpus.train_examples, **cfg)\\n nlp._optimizer = None\\n\\n # Load in pretrained weights (TODO: this may be broken in the config rewrite)\\n if init_tok2vec is not None:\\n components = _load_pretrained_tok2vec(nlp, init_tok2vec)\\n msg.text(f\\\"Loaded pretrained tok2vec for: {components}\\\")\\n\\n # Verify textcat config\\n if \\\"textcat\\\" in pipeline:\\n textcat_labels = nlp.get_pipe(\\\"textcat\\\").cfg.get(\\\"labels\\\", [])\\n if textcat_positive_label and textcat_positive_label not in textcat_labels:\\n msg.fail(\\n f\\\"The textcat_positive_label (tpl) '{textcat_positive_label}' \\\"\\n f\\\"does not match any label in the training data.\\\",\\n exits=1,\\n )\\n if textcat_positive_label and len(textcat_labels) != 2:\\n msg.fail(\\n \\\"A textcat_positive_label (tpl) '{textcat_positive_label}' was \\\"\\n \\\"provided for training data that does not appear to be a \\\"\\n \\\"binary classification problem with two labels.\\\",\\n exits=1,\\n )\\n train_data = corpus.train_data(\\n nlp,\\n noise_level=noise_level,\\n gold_preproc=gold_preproc,\\n max_length=0,\\n ignore_misaligned=True,\\n )\\n train_labels = set()\\n if textcat_multilabel:\\n multilabel_found = False\\n for ex in train_data:\\n train_labels.update(ex.gold.cats.keys())\\n if list(ex.gold.cats.values()).count(1.0) != 1:\\n multilabel_found = True\\n if not multilabel_found and not base_model:\\n msg.warn(\\n \\\"The textcat training instances look like they have \\\"\\n \\\"mutually-exclusive classes. Remove the flag \\\"\\n \\\"'--textcat-multilabel' to train a classifier with \\\"\\n \\\"mutually-exclusive classes.\\\"\\n )\\n if not textcat_multilabel:\\n for ex in train_data:\\n train_labels.update(ex.gold.cats.keys())\\n if list(ex.gold.cats.values()).count(1.0) != 1 and not base_model:\\n msg.warn(\\n \\\"Some textcat training instances do not have exactly \\\"\\n \\\"one positive label. Modifying training options to \\\"\\n \\\"include the flag '--textcat-multilabel' for classes \\\"\\n \\\"that are not mutually exclusive.\\\"\\n )\\n nlp.get_pipe(\\\"textcat\\\").cfg[\\\"exclusive_classes\\\"] = False\\n textcat_multilabel = True\\n break\\n if base_model and set(textcat_labels) != train_labels:\\n msg.fail(\\n f\\\"Cannot extend textcat model using data with different \\\"\\n f\\\"labels. Base model labels: {textcat_labels}, training data \\\"\\n f\\\"labels: {list(train_labels)}\\\",\\n exits=1,\\n )\\n if textcat_multilabel:\\n msg.text(\\n f\\\"Textcat evaluation score: ROC AUC score macro-averaged across \\\"\\n f\\\"the labels '{', '.join(textcat_labels)}'\\\"\\n )\\n elif textcat_positive_label and len(textcat_labels) == 2:\\n msg.text(\\n f\\\"Textcat evaluation score: F1-score for the \\\"\\n f\\\"label '{textcat_positive_label}'\\\"\\n )\\n elif len(textcat_labels) > 1:\\n if len(textcat_labels) == 2:\\n msg.warn(\\n \\\"If the textcat component is a binary classifier with \\\"\\n \\\"exclusive classes, provide '--textcat_positive_label' for \\\"\\n \\\"an evaluation on the positive class.\\\"\\n )\\n msg.text(\\n f\\\"Textcat evaluation score: F1-score macro-averaged across \\\"\\n f\\\"the labels '{', '.join(textcat_labels)}'\\\"\\n )\\n else:\\n msg.fail(\\n \\\"Unsupported textcat configuration. Use `spacy debug-data` \\\"\\n \\\"for more information.\\\"\\n )\\n\\n # fmt: off\\n row_head, output_stats = _configure_training_output(pipeline, use_gpu, has_beam_widths)\\n row_widths = [len(w) for w in row_head]\\n row_settings = {\\\"widths\\\": row_widths, \\\"aligns\\\": tuple([\\\"r\\\" for i in row_head]), \\\"spacing\\\": 2}\\n # fmt: on\\n print(\\\"\\\")\\n msg.row(row_head, **row_settings)\\n msg.row([\\\"-\\\" * width for width in row_settings[\\\"widths\\\"]], **row_settings)\\n try:\\n iter_since_best = 0\\n best_score = 0.0\\n for i in range(n_iter):\\n train_data = corpus.train_dataset(\\n nlp,\\n noise_level=noise_level,\\n orth_variant_level=orth_variant_level,\\n gold_preproc=gold_preproc,\\n max_length=0,\\n ignore_misaligned=True,\\n )\\n if raw_text:\\n random.shuffle(raw_text)\\n raw_batches = util.minibatch(\\n (nlp.make_doc(rt[\\\"text\\\"]) for rt in raw_text), size=8\\n )\\n words_seen = 0\\n with tqdm.tqdm(total=n_train_words, leave=False) as pbar:\\n losses = {}\\n for batch in util.minibatch_by_words(train_data, size=batch_sizes):\\n if not batch:\\n continue\\n try:\\n nlp.update(\\n batch,\\n sgd=optimizer,\\n drop=next(dropout_rates),\\n losses=losses,\\n )\\n except ValueError as e:\\n err = \\\"Error during training\\\"\\n if init_tok2vec:\\n err += \\\" Did you provide the same parameters during 'train' as during 'pretrain'?\\\"\\n msg.fail(err, f\\\"Original error message: {e}\\\", exits=1)\\n if raw_text:\\n # If raw text is available, perform 'rehearsal' updates,\\n # which use unlabelled data to reduce overfitting.\\n raw_batch = list(next(raw_batches))\\n nlp.rehearse(raw_batch, sgd=optimizer, losses=losses)\\n docs = [ex.doc for ex in batch]\\n if not int(os.environ.get(\\\"LOG_FRIENDLY\\\", 0)):\\n pbar.update(sum(len(doc) for doc in docs))\\n words_seen += sum(len(doc) for doc in docs)\\n with nlp.use_params(optimizer.averages):\\n util.set_env_log(False)\\n epoch_model_path = output_path / f\\\"model{i}\\\"\\n nlp.to_disk(epoch_model_path)\\n nlp_loaded = util.load_model_from_path(epoch_model_path)\\n for beam_width in eval_beam_widths:\\n for name, component in nlp_loaded.pipeline:\\n if hasattr(component, \\\"cfg\\\"):\\n component.cfg[\\\"beam_width\\\"] = beam_width\\n dev_dataset = list(\\n corpus.dev_dataset(\\n nlp_loaded,\\n gold_preproc=gold_preproc,\\n ignore_misaligned=True,\\n )\\n )\\n nwords = sum(len(ex.doc) for ex in dev_dataset)\\n start_time = timer()\\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\\n end_time = timer()\\n if use_gpu < 0:\\n gpu_wps = None\\n cpu_wps = nwords / (end_time - start_time)\\n else:\\n gpu_wps = nwords / (end_time - start_time)\\n with use_ops(\\\"numpy\\\"):\\n nlp_loaded = util.load_model_from_path(epoch_model_path)\\n for name, component in nlp_loaded.pipeline:\\n if hasattr(component, \\\"cfg\\\"):\\n component.cfg[\\\"beam_width\\\"] = beam_width\\n dev_dataset = list(\\n corpus.dev_dataset(\\n nlp_loaded,\\n gold_preproc=gold_preproc,\\n ignore_misaligned=True,\\n )\\n )\\n start_time = timer()\\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\\n end_time = timer()\\n cpu_wps = nwords / (end_time - start_time)\\n acc_loc = output_path / f\\\"model{i}\\\" / \\\"accuracy.json\\\"\\n srsly.write_json(acc_loc, scorer.scores)\\n\\n # Update model meta.json\\n meta[\\\"lang\\\"] = nlp.lang\\n meta[\\\"pipeline\\\"] = nlp.pipe_names\\n meta[\\\"spacy_version\\\"] = f\\\">={about.__version__}\\\"\\n if beam_width == 1:\\n meta[\\\"speed\\\"] = {\\n \\\"nwords\\\": nwords,\\n \\\"cpu\\\": cpu_wps,\\n \\\"gpu\\\": gpu_wps,\\n }\\n meta.setdefault(\\\"accuracy\\\", {})\\n for component in nlp.pipe_names:\\n for metric in _get_metrics(component):\\n meta[\\\"accuracy\\\"][metric] = scorer.scores[metric]\\n else:\\n meta.setdefault(\\\"beam_accuracy\\\", {})\\n meta.setdefault(\\\"beam_speed\\\", {})\\n for component in nlp.pipe_names:\\n for metric in _get_metrics(component):\\n meta[\\\"beam_accuracy\\\"][metric] = scorer.scores[metric]\\n meta[\\\"beam_speed\\\"][beam_width] = {\\n \\\"nwords\\\": nwords,\\n \\\"cpu\\\": cpu_wps,\\n \\\"gpu\\\": gpu_wps,\\n }\\n meta[\\\"vectors\\\"] = {\\n \\\"width\\\": nlp.vocab.vectors_length,\\n \\\"vectors\\\": len(nlp.vocab.vectors),\\n \\\"keys\\\": nlp.vocab.vectors.n_keys,\\n \\\"name\\\": nlp.vocab.vectors.name,\\n }\\n meta.setdefault(\\\"name\\\", f\\\"model{i}\\\")\\n meta.setdefault(\\\"version\\\", version)\\n meta[\\\"labels\\\"] = nlp.meta[\\\"labels\\\"]\\n meta_loc = output_path / f\\\"model{i}\\\" / \\\"meta.json\\\"\\n srsly.write_json(meta_loc, meta)\\n util.set_env_log(verbose)\\n\\n progress = _get_progress(\\n i,\\n losses,\\n scorer.scores,\\n output_stats,\\n beam_width=beam_width if has_beam_widths else None,\\n cpu_wps=cpu_wps,\\n gpu_wps=gpu_wps,\\n )\\n if i == 0 and \\\"textcat\\\" in pipeline:\\n textcats_per_cat = scorer.scores.get(\\\"textcats_per_cat\\\", {})\\n for cat, cat_score in textcats_per_cat.items():\\n if cat_score.get(\\\"roc_auc_score\\\", 0) < 0:\\n msg.warn(\\n f\\\"Textcat ROC AUC score is undefined due to \\\"\\n f\\\"only one value in label '{cat}'.\\\"\\n )\\n msg.row(progress, **row_settings)\\n # Early stopping\\n if n_early_stopping is not None:\\n current_score = _score_for_model(meta)\\n if current_score < best_score:\\n iter_since_best += 1\\n else:\\n iter_since_best = 0\\n best_score = current_score\\n if iter_since_best >= n_early_stopping:\\n msg.text(\\n f\\\"Early stopping, best iteration is: {i - iter_since_best}\\\"\\n )\\n msg.text(\\n f\\\"Best score = {best_score}; Final iteration score = {current_score}\\\"\\n )\\n break\\n except Exception as e:\\n msg.warn(f\\\"Aborting and saving final best model. Encountered exception: {e}\\\")\\n finally:\\n best_pipes = nlp.pipe_names\\n if disabled_pipes:\\n disabled_pipes.restore()\\n with nlp.use_params(optimizer.averages):\\n final_model_path = output_path / \\\"model-final\\\"\\n nlp.to_disk(final_model_path)\\n meta_loc = output_path / \\\"model-final\\\" / \\\"meta.json\\\"\\n final_meta = srsly.read_json(meta_loc)\\n final_meta.setdefault(\\\"accuracy\\\", {})\\n final_meta[\\\"accuracy\\\"].update(meta.get(\\\"accuracy\\\", {}))\\n final_meta.setdefault(\\\"speed\\\", {})\\n final_meta[\\\"speed\\\"].setdefault(\\\"cpu\\\", None)\\n final_meta[\\\"speed\\\"].setdefault(\\\"gpu\\\", None)\\n meta.setdefault(\\\"speed\\\", {})\\n meta[\\\"speed\\\"].setdefault(\\\"cpu\\\", None)\\n meta[\\\"speed\\\"].setdefault(\\\"gpu\\\", None)\\n # combine cpu and gpu speeds with the base model speeds\\n if final_meta[\\\"speed\\\"][\\\"cpu\\\"] and meta[\\\"speed\\\"][\\\"cpu\\\"]:\\n speed = _get_total_speed(\\n [final_meta[\\\"speed\\\"][\\\"cpu\\\"], meta[\\\"speed\\\"][\\\"cpu\\\"]]\\n )\\n final_meta[\\\"speed\\\"][\\\"cpu\\\"] = speed\\n if final_meta[\\\"speed\\\"][\\\"gpu\\\"] and meta[\\\"speed\\\"][\\\"gpu\\\"]:\\n speed = _get_total_speed(\\n [final_meta[\\\"speed\\\"][\\\"gpu\\\"], meta[\\\"speed\\\"][\\\"gpu\\\"]]\\n )\\n final_meta[\\\"speed\\\"][\\\"gpu\\\"] = speed\\n # if there were no speeds to update, overwrite with meta\\n if (\\n final_meta[\\\"speed\\\"][\\\"cpu\\\"] is None\\n and final_meta[\\\"speed\\\"][\\\"gpu\\\"] is None\\n ):\\n final_meta[\\\"speed\\\"].update(meta[\\\"speed\\\"])\\n # note: beam speeds are not combined with the base model\\n if has_beam_widths:\\n final_meta.setdefault(\\\"beam_accuracy\\\", {})\\n final_meta[\\\"beam_accuracy\\\"].update(meta.get(\\\"beam_accuracy\\\", {}))\\n final_meta.setdefault(\\\"beam_speed\\\", {})\\n final_meta[\\\"beam_speed\\\"].update(meta.get(\\\"beam_speed\\\", {}))\\n srsly.write_json(meta_loc, final_meta)\\n msg.good(\\\"Saved model to output directory\\\", final_model_path)\\n with msg.loading(\\\"Creating best model...\\\"):\\n best_model_path = _collate_best_model(final_meta, output_path, best_pipes)\\n msg.good(\\\"Created best model\\\", best_model_path)\",\n \"def main(unused_argv):\\n\\n # Create tokenizer based on the training files.\\n logging.info(\\\"Step 1: Loading tokenizer\\\")\\n train_en = FLAGS.data_dir+'/EN_TRAIN_CORPUS_NAME'\\n val_en = FLAGS.data_dir+'/EN_VAL_CORPUS_NAME'\\n\\n VOCAB_FILE = \\\"VOCAB_NAME\\\" \\n vocab_file = os.path.join(FLAGS.data_dir, VOCAB_FILE)\\n subtokenizer = tokenizer.Subtokenizer.init_from_files(\\n vocab_file, [train_en], _TARGET_VOCAB_SIZE, _TARGET_THRESHOLD,\\n min_count=None if FLAGS.search else _TRAIN_DATA_MIN_COUNT)\\n\\n compiled_train_files = (train_en, train_en)\\n compiled_eval_files = (val_en, val_en)\\n\\n # Tokenize and save data as Examples in the TFRecord format.\\n logging.info(\\\"Step 3: Preprocessing and saving data\\\")\\n train_tfrecord_files = encode_and_save_files(\\n subtokenizer, FLAGS.data_dir, compiled_train_files, _TRAIN_TAG,\\n _TRAIN_SHARDS)\\n encode_and_save_files(\\n subtokenizer, FLAGS.data_dir, compiled_eval_files, _EVAL_TAG,\\n _EVAL_SHARDS)\\n\\n for fname in train_tfrecord_files:\\n shuffle_records(fname)\",\n \"def run(self):\\n self.pipeline = self.set_pipeline()\\n self.pipeline.fit(self.X,self.y)\\n return self\",\n \"def train(self, absList, modelFilename):\\n pass\",\n \"def train():\\n\\n # Load camera parameters\\n rcams = cameras.load_cameras()\\n\\n # Load 3d data and 2d projections\\n full_train_set_3d, full_test_set_3d, data_mean_3d, data_std_3d, dim_to_ignore_3d, dim_to_use_3d =\\\\\\n data_utils.read_3d_data( FLAGS.camera_frame, rcams, FLAGS.origin_bc, FLAGS.augment_data,\\n FLAGS.procrustes, FLAGS.lowpass )\\n \\n # Read stacked hourglass 2D predictions\\n full_train_set_2d, full_test_set_2d, data_mean_2d, data_std_2d, dim_to_ignore_2d, dim_to_use_2d = \\\\\\n data_utils.read_2d_predictions( FLAGS.origin_bc, FLAGS.augment_data )\\n \\n print(\\\"\\\\n[+] done reading and normalizing data\\\")\\n # Getting the number of training and test subjects\\n tr_subj = 0\\n for v in full_train_set_3d.values():\\n tr_subj += v.shape[0]\\n te_subj = 0\\n for v in full_test_set_3d.values():\\n te_subj += v.shape[0]\\n print(\\\"{0} training subjects, {1} test subjects\\\".format(tr_subj, te_subj))\\n print(dim_to_use_2d)\\n print(dim_to_use_3d)\\n # Un-normalizing data for visualizations\\n unNorm_ftrs2d = data_utils.unNormalize_dic(full_train_set_2d, data_mean_2d, data_std_2d, dim_to_use_2d)\\n unNorm_ftrs3d = data_utils.unNormalize_dic(full_train_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\\n unNorm_ftes3d = data_utils.unNormalize_dic(full_test_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\\n # Visualize the data\\n viz.visualize_train_sample(unNorm_ftrs2d, unNorm_ftrs3d, FLAGS.camera_frame)\\n viz.visualize_files_oneatatime(unNorm_ftrs3d, unNorm_ftes3d)\\n\\n # Getting only the dimensions to use (get rid of body coxas, other limb, antennas, abdomen\\n train_set_3d, train_set_2d, test_set_3d, test_set_2d = {}, {}, {}, {}\\n for k in full_train_set_3d:\\n (f, c) = k\\n train_set_3d[k] = full_train_set_3d[k][:, dim_to_use_3d]\\n train_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\\\\n full_train_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\\n for k in full_test_set_3d:\\n (f, c) = k\\n test_set_3d[k] = full_test_set_3d[k][:, dim_to_use_3d]\\n test_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\\\\n full_test_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\\n \\n print(\\\"3D data mean:\\\")\\n print(data_mean_3d)\\n print(\\\"3D data std:\\\")\\n print(data_std_3d)\\n\\n print(\\\"2D data mean:\\\")\\n print(data_mean_2d)\\n print(\\\"2D data std:\\\")\\n print(data_std_2d)\\n \\n input(\\\"Press Enter to continue...\\\")\\n\\n # Avoid using the GPU if requested\\n device_count = {\\\"GPU\\\": 0} if FLAGS.use_cpu else {\\\"GPU\\\": 1}\\n with tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(\\n device_count=device_count,\\n allow_soft_placement=True )) as sess:\\n\\n # === Create the model ===\\n print(\\\"[*] creating %d bi-layers of %d units.\\\" % (FLAGS.num_layers, FLAGS.linear_size))\\n model = create_model( sess, FLAGS.batch_size )\\n model.train_writer.add_graph( sess.graph )\\n print(\\\"[+] model created\\\")\\n \\n #=== This is the training loop ===\\n step_time, loss, val_loss = 0.0, 0.0, 0.0\\n current_step = 0 if FLAGS.load <= 0 else FLAGS.load + 1\\n previous_losses = []\\n\\n step_time, loss = 0, 0\\n current_epoch = 0\\n log_every_n_batches = 100\\n losses, errors, joint_errors = [], [], []\\n for _ in range( FLAGS.epochs ):\\n current_epoch = current_epoch + 1\\n\\n # === Load training batches for one epoch ===\\n encoder_inputs, decoder_outputs =\\\\\\n model.get_all_batches( train_set_2d, train_set_3d, FLAGS.camera_frame, training=True )\\n nbatches = len( encoder_inputs )\\n print(\\\"[*] there are {0} train batches\\\".format( nbatches ))\\n start_time, loss = time.time(), 0.\\n # === Loop through all the training batches ===\\n for i in range( nbatches ):\\n\\n if (i+1) % log_every_n_batches == 0:\\n # Print progress every log_every_n_batches batches\\n print(\\\"Working on epoch {0}, batch {1} / {2}...\\\".format( current_epoch, i+1, nbatches),end=\\\"\\\" )\\n\\n enc_in, dec_out = encoder_inputs[i], decoder_outputs[i]\\n step_loss, loss_summary, lr_summary, _ =\\\\\\n model.step( sess, enc_in, dec_out, FLAGS.dropout, isTraining=True )\\n\\n if (i+1) % log_every_n_batches == 0:\\n # Log and print progress every log_every_n_batches batchespixels = pixels / pixels[2,:]\\n model.train_writer.add_summary( loss_summary, current_step )\\n model.train_writer.add_summary( lr_summary, current_step )\\n step_time = (time.time() - start_time)\\n start_time = time.time()\\n print(\\\"done in {0:.2f} ms\\\".format( 1000*step_time / log_every_n_batches ) )\\n\\n loss += step_loss\\n current_step += 1\\n # === end looping through training batches ===\\n\\n loss = loss / nbatches\\n losses.append(loss)\\n print(\\\"=============================\\\\n\\\"\\n \\\"Global step: %d\\\\n\\\"\\n \\\"Learning rate: %.2e\\\\n\\\"\\n \\\"Train loss avg: %.4f\\\\n\\\"\\n \\\"=============================\\\" % (model.global_step.eval(),\\n model.learning_rate.eval(), loss) )\\n # === End training for an epoch ===\\n\\n # === Testing after this epoch ===\\n isTraining = False\\n \\n n_joints = len(data_utils.DIMENSIONS_TO_USE)\\n if FLAGS.origin_bc:\\n n_joints -= len(data_utils.ROOT_POSITIONS)\\n\\n encoder_inputs, decoder_outputs =\\\\\\n model.get_all_batches( test_set_2d, test_set_3d, FLAGS.camera_frame, training=False)\\n\\n total_err, coordwise_err, joint_err, step_time, loss = evaluate_batches( sess, model,\\n data_mean_3d, data_std_3d, dim_to_use_3d, dim_to_ignore_3d,\\n data_mean_2d, data_std_2d, dim_to_use_2d, dim_to_ignore_2d,\\n current_step, encoder_inputs, decoder_outputs, current_epoch )\\n\\n print(\\\"=============================\\\\n\\\"\\n \\\"Step-time (ms): %.4f\\\\n\\\"\\n \\\"Val loss avg: %.4f\\\\n\\\"\\n \\\"Val error avg (mm): %.2f (%.2f, %.2f, %.2f)\\\\n\\\"\\n \\\"=============================\\\" % ( 1000*step_time, loss, total_err,\\n coordwise_err[0], coordwise_err[1], coordwise_err[2] ))\\n\\n for i in range(n_joints):\\n # 6 spaces, right-aligned, 5 decimal places\\n print(\\\"Error in joint {0:02d} (mm): {1:>5.2f}\\\".format(i+1, joint_err[i]))\\n print(\\\"=============================\\\")\\n errors.append(coordwise_err)\\n joint_errors.append(joint_err)\\n # Log the error to tensorboard\\n summaries = sess.run( model.err_mm_summary, {model.err_mm: total_err} )\\n model.test_writer.add_summary( summaries, current_step )\\n\\n # Save the model\\n print( \\\"Saving the model... \\\", end=\\\"\\\" )\\n start_time = time.time()\\n model.saver.save(sess, os.path.join(train_dir, 'checkpoint'), global_step=current_step )\\n print( \\\"done in {0:.2f} ms\\\".format(1000*(time.time() - start_time)) )\\n\\n # Reset global time and loss\\n step_time, loss = 0, 0\\n\\n sys.stdout.flush()\\n # Save losses for future plots\\n def print_list_tofile(l, filename):\\n with open(filename, 'wb') as f:\\n pickle.dump(l, f)\\n print_list_tofile(losses, train_dir+\\\"/losses.pkl\\\")\\n print_list_tofile(errors, train_dir+\\\"/errors.pkl\\\")\\n print_list_tofile(joint_errors, train_dir+\\\"/joint_errors.pkl\\\")\",\n \"def predict(cls, input):\\n clf = cls.get_model() \\n\\n input.to_csv(data_dir + 'vdok_predction_src_file.csv')\\n\\n q = qa_serializer_lang_selector(data_dir)\\n q.serialize_record('vdok_predction_src_file.csv', task_name)\\n q.select_lang([1], task_name).to_csv(data_dir + data_file, encoding= 'latin1')\\n\\n pipeline=['pos', 'lemma', 'synset', 'hype', 'hypo']\\n\\n bnlqd = fex_basic_nlp(data_file, data_dir)\\n bnlqd.nlp_run(pipeline[0])\\n bnlqd.nlp_run(pipeline[1])\\n bnlqd.df_ac_lemma.to_csv(data_dir + 'Lemma-' + data_file, encoding= 'latin1')\\n bnlqd.nlp_run(pipeline[2])\\n bnlqd.df_ac_synset.to_csv(data_dir + 'Synset-' + data_file , encoding= 'latin1')\\n bnlqd.nlp_run(pipeline[3])\\n bnlqd.df_ac_hypernyms.to_csv(data_dir + 'Hypernyms-' + data_file, encoding= 'latin1')\\n bnlqd.nlp_run(pipeline[4])\\n bnlqd.df_ac_hyponyms.to_csv(data_dir + 'Hyponyms-' + data_file, encoding= 'latin1')\\n\\n bnlpd = fex_basic_nlp(def_file, data_dir, task_name)\\n bnlpd.nlp_run(pipeline[0])\\n bnlpd.nlp_run(pipeline[1])\\n bnlpd.df_ac_lemma.to_csv(data_dir + 'Lemma-P-' + data_file, encoding= 'latin1')\\n \\n btgqd = bi_trigram(data_file, data_dir)\\n btgqd.nlp_run(r'bigram')\\n btgqd.nlp_run(r'trigram') \\n\\n stop_words_d = cls.remove_non_extracted_stop_word(bnlqd.df_ac_lemma, stop_words)\\n\\n oanc_shelve = oanc_resource + 'ANC-all-lemma-04262014.db'\\n oalqd = odi_oanc_lemma_frequency(data_file, oanc_shelve, None, data_dir, stop_words_d) \\n oalqd.oanc_lemma_frequency('Lemma-' + data_file, 'Student_Question_Index', 'Pre_Col_Name')\\n \\n stop_words_hy_d = cls.remove_non_extracted_stop_word(bnlqd.df_ac_lemma, stop_words_hy)\\n\\n ovlqd = odi_overlapping(data_file, def_file, data_dir, stop_words_d)\\n ovlqd.count_overlapping('Lemma-' + data_file, 'Student_Question_Index',\\n 'Pre_Col_Name', 'Question_ID', 'Question_ID_Sec',\\n 'Lemma-P-' + data_file, 'Question_ID', 'Question_ID_Sec')\\n ovlqd.count_overlapping_synset('Synset-' + data_file)\\n ovlqd.count_overlapping_hypernyms('Hypernyms-' + data_file, stop_words_hy_d)\\n ovlqd.count_overlapping_hyponyms('Hyponyms-' + data_file, stop_words_hy_d)\\n\\n df_ac_pmi_dist_bigram = cls.bi_trigram_pmi_distribution(pmi_bigram_file, data_dir, \\n bnlqd.num_clm_in, btgqd.df_ac_bigram, 'bigram')\\n df_ac_pmi_dist_trigram = cls.bi_trigram_pmi_distribution(pmi_trigram_file, data_dir, \\n bnlqd.num_clm_in, btgqd.df_ac_trigram, 'Trigram')\\n\\n df_ac_aggregate = cls.aggregate_plim(bnlqd, oalqd, ovlqd, df_ac_pmi_dist_bigram, df_ac_pmi_dist_trigram,\\n bnlpd, specific_count_lemmas, stop_words_pos, task_name)\\n df_ac_aggregate.to_csv(data_dir + 'vdok_predction_Aggregate_plim.csv', encoding= 'latin1')\\n df_ac_aggregate_item_level = cls.aggregate_item_level_plim(df_ac_aggregate, oalqd.stem_option_name_clm, \\n task_name)\\n df_ac_aggregate_item_level.to_csv(data_dir + 'vdok_predction_Key_Stem_Passage_Aggregate_plim.csv',\\n encoding= 'latin1')\\n\\n rfrpod = tmv_RF_classify('Independent_Variable_w_Label-Def.csv', data_dir)\\n rfrpod.load_data('vdok_predction_Key_Stem_Passage_Aggregate_plim.csv', True, drop_vars, dependent_var)\\n clf.perform_prediction(rfrpod.df_ac_modeling_values)\\n return clf.df_ac_classified\",\n \"def main():\\n\\n # Create model_dict from arguments\\n model_dict = model_dict_create()\\n\\n # No. of deviations to consider\\n no_of_mags = 50\\n dev_list = np.linspace(0.1, 5.0, no_of_mags)\\n\\n # Load dataset specified in model_dict\\n print('Loading data...')\\n dataset = model_dict['dataset']\\n if (dataset == 'MNIST'):\\n X_train, y_train, X_val, y_val, X_test, y_test = load_dataset(model_dict)\\n # rd_list = [None, 784, 331, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10]\\n rd_list = [None, 331, 100, 80, 60, 40, 20]\\n # rd_list = [None,784,100]\\n elif dataset == 'GTSRB':\\n X_train, y_train, X_val, y_val, X_test, y_test = load_dataset(model_dict)\\n rd_list = [1024, 338, 200, 100, 90, 80, 70, 60, 50, 40, 33, 30, 20, 10]\\n elif dataset == 'HAR':\\n X_train, y_train, X_test, y_test = load_dataset(model_dict)\\n # rd_list = [561, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10]\\n rd_list = [561]\\n X_val = None\\n y_val = None\\n\\n mean = np.mean(X_train, axis=0)\\n X_train -= mean\\n X_test -= mean\\n if (dataset == 'MNIST') or (dataset == 'GTSRB'): X_val -= mean\\n\\n # fig, ax = plt.subplots(nrows=1, ncols=1)\\n\\n # for rd in rd_list:\\n # model_setup_carlini(model_dict, X_train, y_train, X_test, y_test, X_val, y_val, mean, rd, ax)\\n\\n partial_carlini = partial(model_setup_carlini, model_dict=model_dict, X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, X_val=X_val, y_val=y_val,\\n mean=mean)\\n pool=multiprocessing.Pool(processes=8)\\n pool.map(partial_carlini,rd_list,1)\\n pool.close()\\n pool.join()\\n\\n # dim_red = model_dict['dim_red']\\n # plt.legend()\\n # plt.savefig('carlini_l2_hist_'+dim_red+'.png')\",\n \"def run_model(self):\\n hparams = self.hparams\\n\\n # Build the child graph\\n with tf.Graph().as_default(), tf.device(\\n '/cpu:0' if FLAGS.use_cpu else '/gpu:0'):\\n m, meval = self._build_models()\\n\\n # Figure out what epoch we are on\\n starting_epoch = self._calc_starting_epoch(m)\\n\\n # Run the validation error right at the beginning\\n valid_accuracy = self.eval_child_model(\\n meval, self.data_loader, 'val')\\n tf.logging.info('Before Training Epoch: {} Val Acc: {}'.format(\\n starting_epoch, valid_accuracy))\\n training_accuracy = None\\n\\n for curr_epoch in xrange(starting_epoch, hparams.num_epochs):\\n\\n # Run one training epoch\\n training_accuracy = self._run_training_loop(m, curr_epoch)\\n\\n valid_accuracy = self.eval_child_model(\\n meval, self.data_loader, 'val')\\n tf.logging.info('Epoch: {} Valid Acc: {}'.format(\\n curr_epoch, valid_accuracy))\\n\\n valid_accuracy, test_accuracy = self._compute_final_accuracies(\\n meval)\\n\\n tf.logging.info(\\n 'Train Acc: {} Valid Acc: {} Test Acc: {}'.format(\\n training_accuracy, valid_accuracy, test_accuracy))\",\n \"def forward(opt):\\n my_utils.plant_seeds(randomized_seed=opt.randomize)\\n os.makedirs(opt.output_dir, exist_ok=True)\\n\\n trainer = t.Trainer(opt)\\n trainer.build_dataset_train_for_matching()\\n trainer.build_dataset_test_for_matching()\\n trainer.build_network()\\n trainer.build_losses()\\n trainer.network.eval()\\n\\n if opt.eval_list and os.path.isfile(opt.eval_list):\\n source_target_files = np.loadtxt(opt.eval_list, dtype=str)\\n source_target_files = source_target_files.tolist()\\n for i, st in enumerate(source_target_files):\\n source, target = st\\n cat1, fname1 = source.split('/')\\n fname1 = os.path.splitext(fname1)[0]\\n cat2, fname2 = target.split('/')\\n fname2 = os.path.splitext(fname2)[0]\\n if len(opt.shapenetv1_path) > 0:\\n source_target_files[i] = (os.path.join(opt.shapenetv1_path, cat1, fname1, \\\"model.obj\\\"), os.path.join(opt.shapenetv1_path, cat2, fname2, \\\"model.obj\\\"))\\n elif len(opt.shapenetv2_path) > 0:\\n source_target_files[i] = (os.path.join(opt.shapenetv2_path, cat1, fname1, \\\"models\\\", \\\"model_normalized.obj\\\"), os.path.join(opt.shapenetv2_path, cat2, fname2, \\\"models\\\", \\\"model_normalized.obj\\\"))\\n elif (opt.eval_source != \\\"\\\" and opt.eval_source[-4:] == \\\".txt\\\") and (opt.eval_target != \\\"\\\" and opt.eval_target[-4:] == \\\".txt\\\"):\\n source_target_files = [(figure_2_3.convert_path(opt.shapenetv1_path, opt.eval_source), figure_2_3.convert_path(opt.shapenetv1_path, opt.eval_target))]\\n\\n rot_mat = get_3D_rot_matrix(1, np.pi/2)\\n rot_mat_rev = get_3D_rot_matrix(1, -np.pi/2)\\n isV2 = len(opt.shapenetv2_path) > 0\\n for i, source_target in enumerate(source_target_files):\\n basename = get_model_id(source_target[0], isV2) + \\\"-\\\" + get_model_id(source_target[1], isV2)\\n path_deformed = os.path.join(opt.output_dir, basename + \\\"-Sab.ply\\\")\\n path_source = os.path.join(opt.output_dir, basename + \\\"-Sa.ply\\\")\\n path_target = os.path.join(opt.output_dir, basename +\\\"-Sb.ply\\\")\\n\\n mesh_path = source_target[0]\\n print(mesh_path)\\n source_mesh_edge = get_shapenet_model.link(mesh_path)\\n\\n mesh_path = source_target[1]\\n target_mesh_edge = get_shapenet_model.link(mesh_path)\\n\\n\\n print(\\\"Deforming source in target\\\")\\n\\n source = source_mesh_edge.vertices\\n target = target_mesh_edge.vertices\\n\\n pymesh.save_mesh_raw(path_source, source, source_mesh_edge.faces, ascii=True)\\n pymesh.save_mesh_raw(path_target, target, target_mesh_edge.faces, ascii=True)\\n\\n if len(opt.shapenetv2_path) > 0:\\n source = source.dot(rot_mat)\\n target = target.dot(rot_mat)\\n\\n source = torch.from_numpy(source).cuda().float().unsqueeze(0)\\n target = torch.from_numpy(target).cuda().float().unsqueeze(0)\\n\\n with torch.no_grad():\\n source, _, _, _, _ = loss.forward_chamfer(trainer.network, source, target, local_fix=None,\\n distChamfer=trainer.distChamfer)\\n\\n try:\\n source = source.squeeze().cpu().detach().numpy()\\n if len(opt.shapenetv2_path) > 0:\\n source = source.dot(rot_mat_rev)\\n P2_P1_mesh = pymesh.form_mesh(vertices=source, faces=source_mesh_edge.faces)\\n pymesh.save_mesh(path_deformed, P2_P1_mesh, ascii=True)\\n\\n # print(\\\"computing signal tranfer form source to target\\\")\\n # high_frequencies.high_frequency_propagation(path_source, path_deformed, path_target)\\n except Exception as e:\\n print(e)\\n import pdb; pdb.set_trace()\\n path_deformed = path_deformed[:-4] + \\\".pts\\\"\\n save_pts(path_deformed, source.squeeze().cpu().detach().numpy())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6460919","0.6433101","0.63607436","0.6235969","0.6233244","0.62312454","0.61591774","0.61472887","0.6144754","0.6134827","0.61335844","0.612184","0.6115578","0.6104375","0.61010057","0.6084759","0.60830665","0.607298","0.60646755","0.60414994","0.6007215","0.5993939","0.5977056","0.5974232","0.59709936","0.59709936","0.59709936","0.59709936","0.59709936","0.5960003","0.5957162","0.59525347","0.592919","0.59252703","0.5924356","0.59237784","0.5919762","0.5911932","0.59108883","0.5904573","0.5898536","0.58850735","0.58845425","0.5884534","0.58830196","0.5869558","0.5867196","0.5864359","0.5861696","0.5860291","0.58592683","0.5845012","0.584065","0.58350605","0.58189917","0.5816331","0.5814328","0.5806984","0.57990956","0.5797813","0.5796741","0.5764439","0.57627875","0.5760214","0.57548475","0.57516074","0.57506853","0.5750286","0.574019","0.5723372","0.57224596","0.5719212","0.57167256","0.5716697","0.57162726","0.5700779","0.5691496","0.5690236","0.5689354","0.56855065","0.56849754","0.5682413","0.5681548","0.5680366","0.56768936","0.56708187","0.5660837","0.5659621","0.56591344","0.5657244","0.5654809","0.5640072","0.5639402","0.56383467","0.5635162","0.5632676","0.56307167","0.5629427","0.5628916","0.56210124"],"string":"[\n \"0.6460919\",\n \"0.6433101\",\n \"0.63607436\",\n \"0.6235969\",\n \"0.6233244\",\n \"0.62312454\",\n \"0.61591774\",\n \"0.61472887\",\n \"0.6144754\",\n \"0.6134827\",\n \"0.61335844\",\n \"0.612184\",\n \"0.6115578\",\n \"0.6104375\",\n \"0.61010057\",\n \"0.6084759\",\n \"0.60830665\",\n \"0.607298\",\n \"0.60646755\",\n \"0.60414994\",\n \"0.6007215\",\n \"0.5993939\",\n \"0.5977056\",\n \"0.5974232\",\n \"0.59709936\",\n \"0.59709936\",\n \"0.59709936\",\n \"0.59709936\",\n \"0.59709936\",\n \"0.5960003\",\n \"0.5957162\",\n \"0.59525347\",\n \"0.592919\",\n \"0.59252703\",\n \"0.5924356\",\n \"0.59237784\",\n \"0.5919762\",\n \"0.5911932\",\n \"0.59108883\",\n \"0.5904573\",\n \"0.5898536\",\n \"0.58850735\",\n \"0.58845425\",\n \"0.5884534\",\n \"0.58830196\",\n \"0.5869558\",\n \"0.5867196\",\n \"0.5864359\",\n \"0.5861696\",\n \"0.5860291\",\n \"0.58592683\",\n \"0.5845012\",\n \"0.584065\",\n \"0.58350605\",\n \"0.58189917\",\n \"0.5816331\",\n \"0.5814328\",\n \"0.5806984\",\n \"0.57990956\",\n \"0.5797813\",\n \"0.5796741\",\n \"0.5764439\",\n \"0.57627875\",\n \"0.5760214\",\n \"0.57548475\",\n \"0.57516074\",\n \"0.57506853\",\n \"0.5750286\",\n \"0.574019\",\n \"0.5723372\",\n \"0.57224596\",\n \"0.5719212\",\n \"0.57167256\",\n \"0.5716697\",\n \"0.57162726\",\n \"0.5700779\",\n \"0.5691496\",\n \"0.5690236\",\n \"0.5689354\",\n \"0.56855065\",\n \"0.56849754\",\n \"0.5682413\",\n \"0.5681548\",\n \"0.5680366\",\n \"0.56768936\",\n \"0.56708187\",\n \"0.5660837\",\n \"0.5659621\",\n \"0.56591344\",\n \"0.5657244\",\n \"0.5654809\",\n \"0.5640072\",\n \"0.5639402\",\n \"0.56383467\",\n \"0.5635162\",\n \"0.5632676\",\n \"0.56307167\",\n \"0.5629427\",\n \"0.5628916\",\n \"0.56210124\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62978494"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":76074,"cells":{"query":{"kind":"string","value":"Get the Men's Bathroom status."},"document":{"kind":"string","value":"def get_bathroom_buddy_mens_status(message):\n status = subscribe.simple(\n \"Home/mens/state\", hostname=\"m16.cloudmqtt.com\",\n auth={'username': os.environ['USERNAME'],\n 'password': os.environ['SLACK_PASS']},\n port=21775, tls={'ca_certs': certifi.where()})\n\n return(status.payload)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_power_status(self):\n response = self.parent.power_manager.get_status()\n if response is not None:\n response = response[0]\n\n batteries = []\n for batt in response[\"batt_data\"]:\n batteries.append(batt)\n response[\"batt_data\"] = batteries\n\n return response","def get_status(self):\n status = self._status.get_message()\n \n if status == \"N\":\n return \"offline\"\n \n elif status == \"Y\":\n return \"online\"\n \n elif status == \"A\":\n return \"away\"\n \n elif status == \"B\":\n return \"busy\"","def GetStatus(self):\r\n return self.status","def get_status(self):\n r = requests.get(self.base_url + '/status')\n return r.json()","def status(self):\n return STATUSES.get(self._mower_status, {}).get('message', self._mower_status)","def status(self):\n self.refresh()\n # NOTE(priteau): Temporary compatibility with old and new lease status\n if self.lease.get('action') is not None:\n return self.lease['action'], self.lease['status']\n else:\n return self.lease['status']","def get_homed_status():\n\ttarget = send_command('getstatus home')\n\tsplit_ans = target.split()\n\t\n\treturn split_ans","def status(self):\n return self._get(path='status')","def get_health(self):\n return {'status': 'ok'}","def getMyStatus(self):\n my_rpath = self.getCalendar().getRpath()\n for attendee in self.attendees:\n if attendee['rpath'] == my_rpath:\n return attendee['status']","def status(self, station=1):\n return self.statuslist()[station][2]","def get_status(self):\n return self.status","def get_status(self):\n return self.status","def get_status(self):\n return self.status","def agents_status(self):\n return self._get('agents/status')","def Status(self):\r\n\t\treturn self._get_attribute('status')","def status(self):\n return self.get(self._names[\"status\"])","def get_status(self):\n # TODO retrieve from db if not set\n return self.status","def status(self):\n return status_dict[self._get_property_(self.STATUS).upper()]","def state(self):\n return self.roller.battery","def _get_status(self):\n return self.__status","def status(self):\n return self._query_status()['status']","def get(self):\n email = get_jwt_identity()\n args = state_parser.parse_args()\n if self.validate_state(args['State']):\n response = taskroom_service.get_rooms(email, state=args['State'])\n return {'Message': \"Rooms rendered successfully\", 'records': marshal(response, room_response)}\n else:\n return {\"Message\": \"State is not in (active|archived|deleted)\"}","def get_full_juju_status():\n\n status = model.get_status(lifecycle_utils.get_juju_model())\n return status","def get_status(self):\n statuses = dict(ACTIVITY_STATUS_CHOICES)\n return statuses.get(self.status, \"N/A\")","def status(self):\n return self.m.status","def get_all_status():\n return \"\"","def get_bathroom_buddy_womens_status(message):\n status = subscribe.simple(\n \"Home/womens/state\", hostname=\"m16.cloudmqtt.com\",\n auth={'username': os.environ['USERNAME'],\n 'password': os.environ['SLACK_PASS']},\n port=21775, tls={'ca_certs': certifi.where()})\n\n return(status.payload)","def getstatus(self):\n return self.__status","def get_battery(self) -> int:\r\n return self.state['bat']","def status(self):\n return self._data['status']","def get_status(self):\n statuses = dict(PRODUCTHISTORY_CHOICES)\n return statuses.get(self.status, \"N/A\")","def get_status(self):\n return self._status","def health_status(self) -> str:\n return pulumi.get(self, \"health_status\")","def health_status(self) -> str:\n return pulumi.get(self, \"health_status\")","def get_status(self):\n return self.read_register(259, 0, 3)","def getStatus():","def Status(self):\n return self._get_attribute('status')","def status():\n statuses = get_all_statuses()\n return json.dumps(statuses, indent=4)","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def get_status(self):\n\n return self._system","def get_status():\n return ('off', 'off')","def business_status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"business_status\")","def wa(self) -> str:\n return self.shards(\"wa\")[\"unstatus\"]","def status(self) -> dict[str, str] | None:\n return self._status","def get_status_student():\n if (self.status == self.CH_GRADED or \n (self.status == self.CH_AUTOGRADED and self.autograderresult.visible)):\n return \"Graded\"\n \n elif self.status == self.CH_PREVIOUS:\n return \"Previous Sub.\"\n \n return \"Submitted\"","async def fetch_status(self, params={}):\n #\n # [1] # operative\n # [0] # maintenance\n #\n response = await self.publicGetPlatformStatus(params)\n statusRaw = self.safe_string(response, 0)\n return {\n 'status': self.safe_string({'0': 'maintenance', '1': 'ok'}, statusRaw, statusRaw),\n 'updated': None,\n 'eta': None,\n 'url': None,\n 'info': response,\n }","def amtool_status(self, mess, args):\n self.log.info(\"Current config {0}\".format(self.config))\n self.log.info(\n \"Alertmanager @ {0}\".format(self.config['server_address']))\n helper = AmtoolHelper(\n alertmanager_address=self.config['server_address'])\n result = helper.get_status()\n return result","def model_status():\n return juju.CLIENT.Client(request=\"FullStatus\")","def get_game_state(self):\n return self._game_status","def get_battery_level(self) -> int:\n\n try:\n self._serial.transmit(b'\\x51\\x00')\n response = self._get_reply(0x51, 1, 0.25)\n finally:\n self._gpio.sleep()\n\n return response[2]","def _do_get_status(self):\n logging.info(__name__ + ' : Get status of the device.')\n result = self._execute('X')\n usage = {\n 0: \"Channel not in use\",\n 1: \"Channel used for Nitrogen level\",\n 2: \"Channel used for Helium Level (Normal pulsed operation)\",\n 3: \"Channel used for Helium Level (Continuous measurement)\",\n 9: \"Error on channel (Usually means probe unplugged)\"\n }\n # current_flowing = {\n # 0 : \"Curent not flowing in Helium Probe Wire\",\n # 1 : \"Curent not flowing in Helium Probe Wire\"\n # }\n # auto_fill_status = {\n # 00 : \"End Fill (Level > FULL)\",\n # 01 : \"Not Filling (Level < FULL, Level > FILL)\",\n # 10 : \"Filling (Level < FULL, Level > FILL)\",\n # 11 : \"Start Filling (Level < FILL)\"\n # }\n return usage.get(int(result[1]), \"Unknown\")","def status(self):\n self._refresh_state()\n return self._data.get('status')","def status(self):\n return self._dbattr('status')","def Get_Status_Batlevel(raw_data,\n batlevel_startpos,\n batlevel_endpost):\n batlevel = raw_data[batlevel_startpos:batlevel_endpost]\n print(f'| raw_batlevel = {batlevel}')\n return Convert_Hex_To_Decimal(batlevel)","def get_health(self):\n return self.health","def status(name='default'):\n machine_states = dict(_status())\n return machine_states[name]","def GetStatus(reset=\"\"):\n\n if reset == \"reset\":\n state_mgr.states={}\n print \"States successfully reset.\"\n\n elif not reset.strip():\n sorted_keys=state_mgr.states.keys()\n sorted_keys.sort(key=lambda x:int(x[1:]))\n print \"{:<7s}{:^8s}{:^20s}\".format(\"Unit:\", \"State:\", \"Last Update:\")\n\n for unit in sorted_keys:\n try:\n status = str(round(state_mgr.states[unit][0],1))+\"%\"\n except TypeError:\n status = state_mgr.states[unit][0]\n\n t = time.localtime(float(state_mgr.states[unit][1]))\n hr = t.tm_hour\n ampm=\"am\"\n\n if t.tm_hour>11:\n hr -= 12\n ampm=\"pm\"\n\n pretty_time = \"%s:%s:%s %s %s/%s/%s\"%(hr,str(t.tm_min).zfill(2),str(t.tm_sec).zfill(2),ampm,t.tm_mon,t.tm_mday,str(t.tm_year)[2:])\n \n print \"{:<8s}{:8s}{:>20s}\".format(unit, status, pretty_time)\n\n else:\n raise TypeError,\"Invalid argument!\"","def _getCurrentComponentStatus(self):\n resOverall = self.sysAdminClient.getOverallStatus()\n if not resOverall['OK']:\n return resOverall\n currentStatus = {'Down': set(), 'Run': set(), 'All': set()}\n informationDict = resOverall['Value']\n for systemsDict in informationDict.values():\n for system, instancesDict in systemsDict.items():\n for instanceName, instanceInfoDict in instancesDict.items():\n identifier = '%s__%s' % (system, instanceName)\n runitStatus = instanceInfoDict.get('RunitStatus')\n if runitStatus in ('Run', 'Down'):\n currentStatus[runitStatus].add(identifier)\n\n currentStatus['All'] = currentStatus['Run'] | currentStatus['Down']\n return S_OK(currentStatus)","def status():\n aux = {\"Number games\": len(games), \"Path execution\": path_games}\n for j, game in enumerate(games.games_status):\n aux[\"Game \" + str(j)] = game\n return aux","def get_current_health(self):\n return self.health","def battery_level(self):\n return self.battery","def status(self):\n return STATUS[self.fields['status']]","def _get_status(self):\n held_msg=\"\"\n return u'%s%s' % (self.get_status_display(), held_msg)","def getStatus(self):\n return self.json_state.get(\"state\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def book_loan_status(sltBK):\n book_loan_status.status=None\n if sltBK[5] != \"0\":\n book_loan_status.status=\"On Loan\"\n return book_loan_status.status\n elif sltBK[5] == \"0\":\n book_loan_status.status=\"Available\"\n return book_loan_status.status\n else:\n book_loan_status.status=\"Error\"\n return book_loan_status.status","def getStatus(self, key, time):\n return self.get(\"status\", key, time)"],"string":"[\n \"def get_power_status(self):\\n response = self.parent.power_manager.get_status()\\n if response is not None:\\n response = response[0]\\n\\n batteries = []\\n for batt in response[\\\"batt_data\\\"]:\\n batteries.append(batt)\\n response[\\\"batt_data\\\"] = batteries\\n\\n return response\",\n \"def get_status(self):\\n status = self._status.get_message()\\n \\n if status == \\\"N\\\":\\n return \\\"offline\\\"\\n \\n elif status == \\\"Y\\\":\\n return \\\"online\\\"\\n \\n elif status == \\\"A\\\":\\n return \\\"away\\\"\\n \\n elif status == \\\"B\\\":\\n return \\\"busy\\\"\",\n \"def GetStatus(self):\\r\\n return self.status\",\n \"def get_status(self):\\n r = requests.get(self.base_url + '/status')\\n return r.json()\",\n \"def status(self):\\n return STATUSES.get(self._mower_status, {}).get('message', self._mower_status)\",\n \"def status(self):\\n self.refresh()\\n # NOTE(priteau): Temporary compatibility with old and new lease status\\n if self.lease.get('action') is not None:\\n return self.lease['action'], self.lease['status']\\n else:\\n return self.lease['status']\",\n \"def get_homed_status():\\n\\ttarget = send_command('getstatus home')\\n\\tsplit_ans = target.split()\\n\\t\\n\\treturn split_ans\",\n \"def status(self):\\n return self._get(path='status')\",\n \"def get_health(self):\\n return {'status': 'ok'}\",\n \"def getMyStatus(self):\\n my_rpath = self.getCalendar().getRpath()\\n for attendee in self.attendees:\\n if attendee['rpath'] == my_rpath:\\n return attendee['status']\",\n \"def status(self, station=1):\\n return self.statuslist()[station][2]\",\n \"def get_status(self):\\n return self.status\",\n \"def get_status(self):\\n return self.status\",\n \"def get_status(self):\\n return self.status\",\n \"def agents_status(self):\\n return self._get('agents/status')\",\n \"def Status(self):\\r\\n\\t\\treturn self._get_attribute('status')\",\n \"def status(self):\\n return self.get(self._names[\\\"status\\\"])\",\n \"def get_status(self):\\n # TODO retrieve from db if not set\\n return self.status\",\n \"def status(self):\\n return status_dict[self._get_property_(self.STATUS).upper()]\",\n \"def state(self):\\n return self.roller.battery\",\n \"def _get_status(self):\\n return self.__status\",\n \"def status(self):\\n return self._query_status()['status']\",\n \"def get(self):\\n email = get_jwt_identity()\\n args = state_parser.parse_args()\\n if self.validate_state(args['State']):\\n response = taskroom_service.get_rooms(email, state=args['State'])\\n return {'Message': \\\"Rooms rendered successfully\\\", 'records': marshal(response, room_response)}\\n else:\\n return {\\\"Message\\\": \\\"State is not in (active|archived|deleted)\\\"}\",\n \"def get_full_juju_status():\\n\\n status = model.get_status(lifecycle_utils.get_juju_model())\\n return status\",\n \"def get_status(self):\\n statuses = dict(ACTIVITY_STATUS_CHOICES)\\n return statuses.get(self.status, \\\"N/A\\\")\",\n \"def status(self):\\n return self.m.status\",\n \"def get_all_status():\\n return \\\"\\\"\",\n \"def get_bathroom_buddy_womens_status(message):\\n status = subscribe.simple(\\n \\\"Home/womens/state\\\", hostname=\\\"m16.cloudmqtt.com\\\",\\n auth={'username': os.environ['USERNAME'],\\n 'password': os.environ['SLACK_PASS']},\\n port=21775, tls={'ca_certs': certifi.where()})\\n\\n return(status.payload)\",\n \"def getstatus(self):\\n return self.__status\",\n \"def get_battery(self) -> int:\\r\\n return self.state['bat']\",\n \"def status(self):\\n return self._data['status']\",\n \"def get_status(self):\\n statuses = dict(PRODUCTHISTORY_CHOICES)\\n return statuses.get(self.status, \\\"N/A\\\")\",\n \"def get_status(self):\\n return self._status\",\n \"def health_status(self) -> str:\\n return pulumi.get(self, \\\"health_status\\\")\",\n \"def health_status(self) -> str:\\n return pulumi.get(self, \\\"health_status\\\")\",\n \"def get_status(self):\\n return self.read_register(259, 0, 3)\",\n \"def getStatus():\",\n \"def Status(self):\\n return self._get_attribute('status')\",\n \"def status():\\n statuses = get_all_statuses()\\n return json.dumps(statuses, indent=4)\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def get_status(self):\\n\\n return self._system\",\n \"def get_status():\\n return ('off', 'off')\",\n \"def business_status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"business_status\\\")\",\n \"def wa(self) -> str:\\n return self.shards(\\\"wa\\\")[\\\"unstatus\\\"]\",\n \"def status(self) -> dict[str, str] | None:\\n return self._status\",\n \"def get_status_student():\\n if (self.status == self.CH_GRADED or \\n (self.status == self.CH_AUTOGRADED and self.autograderresult.visible)):\\n return \\\"Graded\\\"\\n \\n elif self.status == self.CH_PREVIOUS:\\n return \\\"Previous Sub.\\\"\\n \\n return \\\"Submitted\\\"\",\n \"async def fetch_status(self, params={}):\\n #\\n # [1] # operative\\n # [0] # maintenance\\n #\\n response = await self.publicGetPlatformStatus(params)\\n statusRaw = self.safe_string(response, 0)\\n return {\\n 'status': self.safe_string({'0': 'maintenance', '1': 'ok'}, statusRaw, statusRaw),\\n 'updated': None,\\n 'eta': None,\\n 'url': None,\\n 'info': response,\\n }\",\n \"def amtool_status(self, mess, args):\\n self.log.info(\\\"Current config {0}\\\".format(self.config))\\n self.log.info(\\n \\\"Alertmanager @ {0}\\\".format(self.config['server_address']))\\n helper = AmtoolHelper(\\n alertmanager_address=self.config['server_address'])\\n result = helper.get_status()\\n return result\",\n \"def model_status():\\n return juju.CLIENT.Client(request=\\\"FullStatus\\\")\",\n \"def get_game_state(self):\\n return self._game_status\",\n \"def get_battery_level(self) -> int:\\n\\n try:\\n self._serial.transmit(b'\\\\x51\\\\x00')\\n response = self._get_reply(0x51, 1, 0.25)\\n finally:\\n self._gpio.sleep()\\n\\n return response[2]\",\n \"def _do_get_status(self):\\n logging.info(__name__ + ' : Get status of the device.')\\n result = self._execute('X')\\n usage = {\\n 0: \\\"Channel not in use\\\",\\n 1: \\\"Channel used for Nitrogen level\\\",\\n 2: \\\"Channel used for Helium Level (Normal pulsed operation)\\\",\\n 3: \\\"Channel used for Helium Level (Continuous measurement)\\\",\\n 9: \\\"Error on channel (Usually means probe unplugged)\\\"\\n }\\n # current_flowing = {\\n # 0 : \\\"Curent not flowing in Helium Probe Wire\\\",\\n # 1 : \\\"Curent not flowing in Helium Probe Wire\\\"\\n # }\\n # auto_fill_status = {\\n # 00 : \\\"End Fill (Level > FULL)\\\",\\n # 01 : \\\"Not Filling (Level < FULL, Level > FILL)\\\",\\n # 10 : \\\"Filling (Level < FULL, Level > FILL)\\\",\\n # 11 : \\\"Start Filling (Level < FILL)\\\"\\n # }\\n return usage.get(int(result[1]), \\\"Unknown\\\")\",\n \"def status(self):\\n self._refresh_state()\\n return self._data.get('status')\",\n \"def status(self):\\n return self._dbattr('status')\",\n \"def Get_Status_Batlevel(raw_data,\\n batlevel_startpos,\\n batlevel_endpost):\\n batlevel = raw_data[batlevel_startpos:batlevel_endpost]\\n print(f'| raw_batlevel = {batlevel}')\\n return Convert_Hex_To_Decimal(batlevel)\",\n \"def get_health(self):\\n return self.health\",\n \"def status(name='default'):\\n machine_states = dict(_status())\\n return machine_states[name]\",\n \"def GetStatus(reset=\\\"\\\"):\\n\\n if reset == \\\"reset\\\":\\n state_mgr.states={}\\n print \\\"States successfully reset.\\\"\\n\\n elif not reset.strip():\\n sorted_keys=state_mgr.states.keys()\\n sorted_keys.sort(key=lambda x:int(x[1:]))\\n print \\\"{:<7s}{:^8s}{:^20s}\\\".format(\\\"Unit:\\\", \\\"State:\\\", \\\"Last Update:\\\")\\n\\n for unit in sorted_keys:\\n try:\\n status = str(round(state_mgr.states[unit][0],1))+\\\"%\\\"\\n except TypeError:\\n status = state_mgr.states[unit][0]\\n\\n t = time.localtime(float(state_mgr.states[unit][1]))\\n hr = t.tm_hour\\n ampm=\\\"am\\\"\\n\\n if t.tm_hour>11:\\n hr -= 12\\n ampm=\\\"pm\\\"\\n\\n pretty_time = \\\"%s:%s:%s %s %s/%s/%s\\\"%(hr,str(t.tm_min).zfill(2),str(t.tm_sec).zfill(2),ampm,t.tm_mon,t.tm_mday,str(t.tm_year)[2:])\\n \\n print \\\"{:<8s}{:8s}{:>20s}\\\".format(unit, status, pretty_time)\\n\\n else:\\n raise TypeError,\\\"Invalid argument!\\\"\",\n \"def _getCurrentComponentStatus(self):\\n resOverall = self.sysAdminClient.getOverallStatus()\\n if not resOverall['OK']:\\n return resOverall\\n currentStatus = {'Down': set(), 'Run': set(), 'All': set()}\\n informationDict = resOverall['Value']\\n for systemsDict in informationDict.values():\\n for system, instancesDict in systemsDict.items():\\n for instanceName, instanceInfoDict in instancesDict.items():\\n identifier = '%s__%s' % (system, instanceName)\\n runitStatus = instanceInfoDict.get('RunitStatus')\\n if runitStatus in ('Run', 'Down'):\\n currentStatus[runitStatus].add(identifier)\\n\\n currentStatus['All'] = currentStatus['Run'] | currentStatus['Down']\\n return S_OK(currentStatus)\",\n \"def status():\\n aux = {\\\"Number games\\\": len(games), \\\"Path execution\\\": path_games}\\n for j, game in enumerate(games.games_status):\\n aux[\\\"Game \\\" + str(j)] = game\\n return aux\",\n \"def get_current_health(self):\\n return self.health\",\n \"def battery_level(self):\\n return self.battery\",\n \"def status(self):\\n return STATUS[self.fields['status']]\",\n \"def _get_status(self):\\n held_msg=\\\"\\\"\\n return u'%s%s' % (self.get_status_display(), held_msg)\",\n \"def getStatus(self):\\n return self.json_state.get(\\\"state\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def book_loan_status(sltBK):\\n book_loan_status.status=None\\n if sltBK[5] != \\\"0\\\":\\n book_loan_status.status=\\\"On Loan\\\"\\n return book_loan_status.status\\n elif sltBK[5] == \\\"0\\\":\\n book_loan_status.status=\\\"Available\\\"\\n return book_loan_status.status\\n else:\\n book_loan_status.status=\\\"Error\\\"\\n return book_loan_status.status\",\n \"def getStatus(self, key, time):\\n return self.get(\\\"status\\\", key, time)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6127522","0.6055546","0.599644","0.59283227","0.5925165","0.58408403","0.5754333","0.575369","0.57490945","0.57337254","0.57331556","0.57121","0.57121","0.57121","0.57066834","0.5702639","0.5657467","0.5653847","0.56426734","0.5628258","0.5618401","0.5585015","0.5584481","0.5574048","0.5569957","0.55516","0.5551563","0.55378795","0.5528475","0.55228037","0.5519356","0.55034566","0.55028546","0.54972416","0.54972416","0.5489269","0.54854435","0.5481922","0.54808855","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.54765606","0.5474104","0.5469707","0.5466068","0.54640335","0.546291","0.54571855","0.5456686","0.54531944","0.5436331","0.54311335","0.5429338","0.5429207","0.54274684","0.54102314","0.5395434","0.5386766","0.5385897","0.5383173","0.5380103","0.53706545","0.5367167","0.5363185","0.5359013","0.5357876","0.5356488","0.5355943","0.5355943","0.5355943","0.5355943","0.5355943","0.5355943","0.5355943","0.5355943","0.5355943","0.53557795","0.5349453"],"string":"[\n \"0.6127522\",\n \"0.6055546\",\n \"0.599644\",\n \"0.59283227\",\n \"0.5925165\",\n \"0.58408403\",\n \"0.5754333\",\n \"0.575369\",\n \"0.57490945\",\n \"0.57337254\",\n \"0.57331556\",\n \"0.57121\",\n \"0.57121\",\n \"0.57121\",\n \"0.57066834\",\n \"0.5702639\",\n \"0.5657467\",\n \"0.5653847\",\n \"0.56426734\",\n \"0.5628258\",\n \"0.5618401\",\n \"0.5585015\",\n \"0.5584481\",\n \"0.5574048\",\n \"0.5569957\",\n \"0.55516\",\n \"0.5551563\",\n \"0.55378795\",\n \"0.5528475\",\n \"0.55228037\",\n \"0.5519356\",\n \"0.55034566\",\n \"0.55028546\",\n \"0.54972416\",\n \"0.54972416\",\n \"0.5489269\",\n \"0.54854435\",\n \"0.5481922\",\n \"0.54808855\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.54765606\",\n \"0.5474104\",\n \"0.5469707\",\n \"0.5466068\",\n \"0.54640335\",\n \"0.546291\",\n \"0.54571855\",\n \"0.5456686\",\n \"0.54531944\",\n \"0.5436331\",\n \"0.54311335\",\n \"0.5429338\",\n \"0.5429207\",\n \"0.54274684\",\n \"0.54102314\",\n \"0.5395434\",\n \"0.5386766\",\n \"0.5385897\",\n \"0.5383173\",\n \"0.5380103\",\n \"0.53706545\",\n \"0.5367167\",\n \"0.5363185\",\n \"0.5359013\",\n \"0.5357876\",\n \"0.5356488\",\n \"0.5355943\",\n \"0.5355943\",\n \"0.5355943\",\n \"0.5355943\",\n \"0.5355943\",\n \"0.5355943\",\n \"0.5355943\",\n \"0.5355943\",\n \"0.5355943\",\n \"0.53557795\",\n \"0.5349453\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.54959536"},"document_rank":{"kind":"string","value":"35"}}},{"rowIdx":76075,"cells":{"query":{"kind":"string","value":"Get the Women's Bathroom status."},"document":{"kind":"string","value":"def get_bathroom_buddy_womens_status(message):\n status = subscribe.simple(\n \"Home/womens/state\", hostname=\"m16.cloudmqtt.com\",\n auth={'username': os.environ['USERNAME'],\n 'password': os.environ['SLACK_PASS']},\n port=21775, tls={'ca_certs': certifi.where()})\n\n return(status.payload)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def status(self):\n return STATUSES.get(self._mower_status, {}).get('message', self._mower_status)","def get_power_status(self):\n response = self.parent.power_manager.get_status()\n if response is not None:\n response = response[0]\n\n batteries = []\n for batt in response[\"batt_data\"]:\n batteries.append(batt)\n response[\"batt_data\"] = batteries\n\n return response","def wa(self) -> str:\n return self.shards(\"wa\")[\"unstatus\"]","def get_status(self):\n status = self._status.get_message()\n \n if status == \"N\":\n return \"offline\"\n \n elif status == \"Y\":\n return \"online\"\n \n elif status == \"A\":\n return \"away\"\n \n elif status == \"B\":\n return \"busy\"","def business_status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"business_status\")","def get_health(self):\n return {'status': 'ok'}","def GetStatus(self):\r\n return self.status","def health_status(self) -> str:\n return pulumi.get(self, \"health_status\")","def health_status(self) -> str:\n return pulumi.get(self, \"health_status\")","def getStatusWord(status):\n statusWord = 'owned'\n if status == 0:\n return 'wished'\n elif status == 1:\n return 'ordered'\n return statusWord","def get_status(self):\n return self.status","def get_status(self):\n return self.status","def get_status(self):\n return self.status","def get_status(self):\n r = requests.get(self.base_url + '/status')\n return r.json()","def Status(self):\r\n\t\treturn self._get_attribute('status')","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def status(self) -> str:\n return pulumi.get(self, \"status\")","def get_status_student():\n if (self.status == self.CH_GRADED or \n (self.status == self.CH_AUTOGRADED and self.autograderresult.visible)):\n return \"Graded\"\n \n elif self.status == self.CH_PREVIOUS:\n return \"Previous Sub.\"\n \n return \"Submitted\"","def get_status(self):\n # TODO retrieve from db if not set\n return self.status","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self) -> Optional[str]:\n return pulumi.get(self, \"status\")","def status(self):\n return status_dict[self._get_property_(self.STATUS).upper()]","def status(self):\n return self.get(self._names[\"status\"])","def get_health(self):\n return self.health","def Status(self):\n return self._get_attribute('status')","def get_full_juju_status():\n\n status = model.get_status(lifecycle_utils.get_juju_model())\n return status","def get_status(self):\n return self.read_register(259, 0, 3)","async def get_status(self) -> str:\n return await self.hw_device.status()","def status(self):\n return self._get(path='status')","def get_status(self):\n return self._status","def get_status(self):\n statuses = dict(ACTIVITY_STATUS_CHOICES)\n return statuses.get(self.status, \"N/A\")","def get_bathroom_buddy_mens_status(message):\n status = subscribe.simple(\n \"Home/mens/state\", hostname=\"m16.cloudmqtt.com\",\n auth={'username': os.environ['USERNAME'],\n 'password': os.environ['SLACK_PASS']},\n port=21775, tls={'ca_certs': certifi.where()})\n\n return(status.payload)","def status(self):\n return self._data['status']","def state(self):\n return self.roller.battery","def get_mood(self):\n return self.mood","def get_battery(self) -> int:\r\n return self.state['bat']","def _get_status(self):\n return self.__status","def get_status():\n return ('off', 'off')","def status(self, station=1):\n return self.statuslist()[station][2]","def status(self):\n return self._query_status()['status']","def status(self) -> Optional[int]:\n return pulumi.get(self, \"status\")","def get_status_instructor():\n if self.status == self.CH_SUBMITTED:\n return \"Submitted\"\n \n elif self.status == self.CH_AUTOGRADED:\n if self.autograderresult.visible:\n return \"Autograded (released)\"\n else:\n return \"Autograded (hidden)\"\n \n elif self.status == self.CH_GRADED:\n return \"Graded\"\n \n elif self.status == self.CH_PREVIOUS:\n return \"Previous Sub.\"\n \n elif self.status == self.CH_TO_AUTOGRADE:\n return \"Pending\"","def get_status(self):\n url = \"data_request?id=jobstatus&job=%d&plugin=zwave\" % self.id\n return self.vera.get(url)","def get_current_health(self):\n return self.health","def getstatus(self):\n return self.__status","def heart_status(self):\r\n return 'pumping blood'","def get_health(self):\n return self.__health","def status(self):\n return STATUS[self.fields['status']]","def Gethealth(self):\n return self.health","def get_status():\n data = {\n 'status': 'up',\n }\n jsn = json.dumps(data)\n\n resp = Response(jsn, status=200, mimetype='application/json')\n\n return resp","def status(self):\n return self.m.status","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")","def status(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"status\")"],"string":"[\n \"def status(self):\\n return STATUSES.get(self._mower_status, {}).get('message', self._mower_status)\",\n \"def get_power_status(self):\\n response = self.parent.power_manager.get_status()\\n if response is not None:\\n response = response[0]\\n\\n batteries = []\\n for batt in response[\\\"batt_data\\\"]:\\n batteries.append(batt)\\n response[\\\"batt_data\\\"] = batteries\\n\\n return response\",\n \"def wa(self) -> str:\\n return self.shards(\\\"wa\\\")[\\\"unstatus\\\"]\",\n \"def get_status(self):\\n status = self._status.get_message()\\n \\n if status == \\\"N\\\":\\n return \\\"offline\\\"\\n \\n elif status == \\\"Y\\\":\\n return \\\"online\\\"\\n \\n elif status == \\\"A\\\":\\n return \\\"away\\\"\\n \\n elif status == \\\"B\\\":\\n return \\\"busy\\\"\",\n \"def business_status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"business_status\\\")\",\n \"def get_health(self):\\n return {'status': 'ok'}\",\n \"def GetStatus(self):\\r\\n return self.status\",\n \"def health_status(self) -> str:\\n return pulumi.get(self, \\\"health_status\\\")\",\n \"def health_status(self) -> str:\\n return pulumi.get(self, \\\"health_status\\\")\",\n \"def getStatusWord(status):\\n statusWord = 'owned'\\n if status == 0:\\n return 'wished'\\n elif status == 1:\\n return 'ordered'\\n return statusWord\",\n \"def get_status(self):\\n return self.status\",\n \"def get_status(self):\\n return self.status\",\n \"def get_status(self):\\n return self.status\",\n \"def get_status(self):\\n r = requests.get(self.base_url + '/status')\\n return r.json()\",\n \"def Status(self):\\r\\n\\t\\treturn self._get_attribute('status')\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> str:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def get_status_student():\\n if (self.status == self.CH_GRADED or \\n (self.status == self.CH_AUTOGRADED and self.autograderresult.visible)):\\n return \\\"Graded\\\"\\n \\n elif self.status == self.CH_PREVIOUS:\\n return \\\"Previous Sub.\\\"\\n \\n return \\\"Submitted\\\"\",\n \"def get_status(self):\\n # TODO retrieve from db if not set\\n return self.status\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> Optional[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self):\\n return status_dict[self._get_property_(self.STATUS).upper()]\",\n \"def status(self):\\n return self.get(self._names[\\\"status\\\"])\",\n \"def get_health(self):\\n return self.health\",\n \"def Status(self):\\n return self._get_attribute('status')\",\n \"def get_full_juju_status():\\n\\n status = model.get_status(lifecycle_utils.get_juju_model())\\n return status\",\n \"def get_status(self):\\n return self.read_register(259, 0, 3)\",\n \"async def get_status(self) -> str:\\n return await self.hw_device.status()\",\n \"def status(self):\\n return self._get(path='status')\",\n \"def get_status(self):\\n return self._status\",\n \"def get_status(self):\\n statuses = dict(ACTIVITY_STATUS_CHOICES)\\n return statuses.get(self.status, \\\"N/A\\\")\",\n \"def get_bathroom_buddy_mens_status(message):\\n status = subscribe.simple(\\n \\\"Home/mens/state\\\", hostname=\\\"m16.cloudmqtt.com\\\",\\n auth={'username': os.environ['USERNAME'],\\n 'password': os.environ['SLACK_PASS']},\\n port=21775, tls={'ca_certs': certifi.where()})\\n\\n return(status.payload)\",\n \"def status(self):\\n return self._data['status']\",\n \"def state(self):\\n return self.roller.battery\",\n \"def get_mood(self):\\n return self.mood\",\n \"def get_battery(self) -> int:\\r\\n return self.state['bat']\",\n \"def _get_status(self):\\n return self.__status\",\n \"def get_status():\\n return ('off', 'off')\",\n \"def status(self, station=1):\\n return self.statuslist()[station][2]\",\n \"def status(self):\\n return self._query_status()['status']\",\n \"def status(self) -> Optional[int]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def get_status_instructor():\\n if self.status == self.CH_SUBMITTED:\\n return \\\"Submitted\\\"\\n \\n elif self.status == self.CH_AUTOGRADED:\\n if self.autograderresult.visible:\\n return \\\"Autograded (released)\\\"\\n else:\\n return \\\"Autograded (hidden)\\\"\\n \\n elif self.status == self.CH_GRADED:\\n return \\\"Graded\\\"\\n \\n elif self.status == self.CH_PREVIOUS:\\n return \\\"Previous Sub.\\\"\\n \\n elif self.status == self.CH_TO_AUTOGRADE:\\n return \\\"Pending\\\"\",\n \"def get_status(self):\\n url = \\\"data_request?id=jobstatus&job=%d&plugin=zwave\\\" % self.id\\n return self.vera.get(url)\",\n \"def get_current_health(self):\\n return self.health\",\n \"def getstatus(self):\\n return self.__status\",\n \"def heart_status(self):\\r\\n return 'pumping blood'\",\n \"def get_health(self):\\n return self.__health\",\n \"def status(self):\\n return STATUS[self.fields['status']]\",\n \"def Gethealth(self):\\n return self.health\",\n \"def get_status():\\n data = {\\n 'status': 'up',\\n }\\n jsn = json.dumps(data)\\n\\n resp = Response(jsn, status=200, mimetype='application/json')\\n\\n return resp\",\n \"def status(self):\\n return self.m.status\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\",\n \"def status(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"status\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6468318","0.6393942","0.6363238","0.63195926","0.60368097","0.6002562","0.59756094","0.59639066","0.59639066","0.59282535","0.590928","0.590928","0.590928","0.5900921","0.5868397","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58677864","0.58541423","0.5813017","0.5811408","0.5811408","0.5811408","0.5811408","0.5811408","0.5811408","0.5811408","0.5811408","0.5811408","0.5801176","0.5758044","0.5756339","0.57285506","0.5715704","0.57035446","0.5702114","0.5701415","0.56876004","0.56821597","0.56781054","0.5669554","0.5663279","0.56619555","0.56616503","0.5652825","0.5644184","0.5639623","0.562773","0.5624722","0.5617384","0.5609351","0.56065404","0.5598265","0.55885553","0.55747235","0.55705655","0.55697685","0.55616295","0.55615604","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874","0.5557874"],"string":"[\n \"0.6468318\",\n \"0.6393942\",\n \"0.6363238\",\n \"0.63195926\",\n \"0.60368097\",\n \"0.6002562\",\n \"0.59756094\",\n \"0.59639066\",\n \"0.59639066\",\n \"0.59282535\",\n \"0.590928\",\n \"0.590928\",\n \"0.590928\",\n \"0.5900921\",\n \"0.5868397\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58677864\",\n \"0.58541423\",\n \"0.5813017\",\n \"0.5811408\",\n \"0.5811408\",\n \"0.5811408\",\n \"0.5811408\",\n \"0.5811408\",\n \"0.5811408\",\n \"0.5811408\",\n \"0.5811408\",\n \"0.5811408\",\n \"0.5801176\",\n \"0.5758044\",\n \"0.5756339\",\n \"0.57285506\",\n \"0.5715704\",\n \"0.57035446\",\n \"0.5702114\",\n \"0.5701415\",\n \"0.56876004\",\n \"0.56821597\",\n \"0.56781054\",\n \"0.5669554\",\n \"0.5663279\",\n \"0.56619555\",\n \"0.56616503\",\n \"0.5652825\",\n \"0.5644184\",\n \"0.5639623\",\n \"0.562773\",\n \"0.5624722\",\n \"0.5617384\",\n \"0.5609351\",\n \"0.56065404\",\n \"0.5598265\",\n \"0.55885553\",\n \"0.55747235\",\n \"0.55705655\",\n \"0.55697685\",\n \"0.55616295\",\n \"0.55615604\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\",\n \"0.5557874\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63199383"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":76076,"cells":{"query":{"kind":"string","value":"The following function returns the current weather for South Bend, IN...."},"document":{"kind":"string","value":"def get_weather_south_bend(message):\n weather_api = 'http://api.openweathermap.org/data/2.5/weather?id=4926563&&units=imperial&appid={}'.format(\n os.environ['WEATHER_KEY'])\n weather = requests.get(weather_api).json()\n\n return(\"The current weather at Notre Dame is {} with a temperature of {}.\".format(\n weather['weather'][0]['main'], str(weather['main']['temp'])))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def weather_helper():\n\n weather = get_weather('Chicago')\n conditions = weather['weather'][0]['description']\n temperature = weather['main']['temp']\n location = weather['name']\n\n curr_weather = 'It is currently %s degrees with %s in %s' % (temperature, conditions, location)\n return curr_weather","def get_weather(self):\n return self.__weather","def GetWeatherByLocation():\n Location = GetLocation()\n WeatherUrl =\"http://api.openweathermap.org/data/2.5/weather?\"+ Location +\"&appid=b4bacbe2dc824431289800439f1ec3df&units=metric\"\n WeatherRequest = requests.get(WeatherUrl)\n WeatherInfo = WeatherRequest.json()\n pprint(WeatherInfo)\n WindSpeed = WeatherInfo['wind']['speed']\n pprint(WindSpeed)\n Temp = WeatherInfo['main']['temp']\n Humidity = WeatherInfo['main']['humidity']\n Description = WeatherInfo['weather'][0]['description']\n print(type(Humidity))\n return(Temp, Humidity, Description)","def forecast_weather(self):\n pass","def get_station_boroughs(self):\\","def get_weather(self):\n\n city = self.user_data[\"weatherSettings\"][\"weatherCity\"]\n country = self.user_data[\"weatherSettings\"][\"weatherCountry\"]\n\n host = \"weather.mios.com\"\n temp_scale = \"C\"\n url = \"http://%s/?tempFormat=%s&cityWeather=%s&countryWeather=%s\" % \\\n (host, temp_scale, Vera.urlencode(city), Vera.urlencode(country))\n\n weather = self.proxy_get(url)\n\n return (float(weather[\"temp\"]), weather[\"text\"])","def getLocation(self, state, city, token):\n d = requests.get(\n 'http://api.wunderground.com/api/' + str(token) + '/forecast/q/' + str(state) + '/' + str(city) + '.json')\n json = d.json()\n return json","def get_weather(lat, lon):\r\n\r\n # API key, retrieved from configure.py\r\n api_key = configure.WEATHER_KEY\r\n\r\n # API endpoint\r\n url = f'https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid={api_key}'\r\n\r\n # API call\r\n response = requests.get(url)\r\n\r\n # Collect response in json format\r\n weather = response.json()\r\n\r\n # Interpret Current Weather\r\n current_weather = weather['current']\r\n\r\n # By default, the API returns all requested times in unix format\r\n current_weather['dt'] = epoch_to_human_readable_date(current_weather['dt'])\r\n current_weather['sunrise'] = epoch_to_human_readable_date(current_weather['sunrise'])\r\n current_weather['sunset'] = epoch_to_human_readable_date(current_weather['sunset'])\r\n\r\n # By default, the API returns all temperature values in Kelvin\r\n current_weather['dew_point'] = {'kelvin': current_weather['dew_point'], \r\n 'fahrenheit': round(kelvin_to_fahrenheit(current_weather['dew_point']), 2),\r\n 'celsius': round(kelvin_to_celsius(current_weather['dew_point']), 2)}\r\n\r\n current_weather['feels_like'] = {'kelvin': current_weather['feels_like'], \r\n 'fahrenheit': round(kelvin_to_fahrenheit(current_weather['feels_like']), 2),\r\n 'celsius': round(kelvin_to_celsius(current_weather['feels_like']), 2)}\r\n\r\n current_weather['temp'] = {'kelvin': current_weather['temp'], \r\n 'fahrenheit': round(kelvin_to_fahrenheit(current_weather['temp']), 2),\r\n 'celsius': round(kelvin_to_celsius(current_weather['temp']), 2)}\r\n\r\n # Change icon value to image url to be used in html img tag as src\r\n current_weather['weather'][0]['icon'] = 'http://openweathermap.org/img/wn/' + current_weather['weather'][0]['icon'] + '@2x.png'\r\n\r\n # Interpret Daily Weather\r\n daily_forcast = weather['daily']\r\n\r\n for day in daily_forcast:\r\n # Get readable dates and times\r\n day['dt'] = epoch_to_human_readable_date(day['dt'])\r\n day['sunrise'] = epoch_to_human_readable_date(day['sunrise'])\r\n day['sunset'] = epoch_to_human_readable_date(day['sunset'])\r\n\r\n # Change icon value to image url to be used in html img tag as src\r\n day['weather'][0]['icon'] = 'http://openweathermap.org/img/wn/' + day['weather'][0]['icon'] + '@2x.png'\r\n\r\n\r\n # Convert temperatures in 'feels_like' dictionary from Kelvin to Fahrenheit and Celsius\r\n\r\n for temp in day['feels_like']:\r\n day['feels_like'][temp] = {'kelvin': day['feels_like'][temp], \r\n 'fahrenheit': round(kelvin_to_fahrenheit(day['feels_like'][temp]), 2),\r\n 'celsius': round(kelvin_to_celsius(day['feels_like'][temp]), 2)}\r\n\r\n\r\n # Convert temperatures in 'temp' dictionary from Kelvin to Fahrenheit\r\n\r\n for temp in day['temp']:\r\n day['temp'][temp] = {'kelvin': day['temp'][temp], \r\n 'fahrenheit': round(kelvin_to_fahrenheit(day['temp'][temp]), 2),\r\n 'celsius': round(kelvin_to_celsius(day['temp'][temp]), 2)}\r\n\r\n # Interpret Hourly Weather\r\n hourly_weather = weather['hourly']\r\n\r\n # Only manipulating data for hours of the current date, rest will be ommitted\r\n\r\n curr_date = epoch_to_human_readable_date(hourly_weather[0]['dt']).split(\",\", 1)[1][:3]\r\n\r\n last_hour = 0\r\n\r\n for index, hour in enumerate(hourly_weather):\r\n # Get date in relation to the hour\r\n date = epoch_to_human_readable_date(hour['dt']).split(\",\", 1)[1][:3]\r\n if date != curr_date:\r\n last_hour = index\r\n break\r\n \r\n # Convert temperatures in 'dew_point' dictionary from Kelvin to Fahrenheit and Celsius\r\n hour['dew_point'] = {'Kelvin':hour['dew_point'],\r\n 'fahrenheit': round(kelvin_to_fahrenheit(hour['dew_point']), 2),\r\n 'celsius': round(kelvin_to_celsius(hour['dew_point']), 2)}\r\n\r\n # Get readable dates and times\r\n hour['dt'] = epoch_to_human_readable_date(hour['dt'])\r\n\r\n # Convert temperatures in 'feels_like' dictionary from Kelvin to Fahrenheit and Celsius\r\n hour['feels_like'] = {'kelvin': hour['feels_like'], \r\n 'fahrenheit': round(kelvin_to_fahrenheit(hour['feels_like']), 2),\r\n 'celsius': round(kelvin_to_celsius(hour['feels_like']), 2)}\r\n\r\n # Convert temperatures in 'temp' dictionary from Kelvin to Fahrenheit\r\n hour['temp'] = {'kelvin': hour['temp'], \r\n 'fahrenheit': round(kelvin_to_fahrenheit(hour['temp']), 2),\r\n 'celsius': round(kelvin_to_celsius(hour['temp']), 2)}\r\n\r\n hour['weather'][0]['icon'] = 'http://openweathermap.org/img/wn/' + hour['weather'][0]['icon'] + '@2x.png'\r\n\r\n\r\n return current_weather, daily_forcast, hourly_weather[:last_hour]","def fetch_weather(y):\r\n # request parameter(s): Start with '?'\r\n # separate name and value with '='\r\n # multiple parameter name value pairs are separate with '&'\r\n query_string = \"?id={}&units=imperial&APIKEY={}\".format(y, API_KEY)\r\n request_url = WS_URL + query_string\r\n print(\"Request URL: \", request_url)\r\n response = requests.get(request_url)\r\n if response.status_code == 200:\r\n city_name = response.json()[\"city\"][\"name\"]\r\n lst = response.json()[\"list\"]\r\n tmp_list = []\r\n for i in range(len(lst) // 8):\r\n li = [x for x in range(len(lst)) if x // 8 == i]\r\n tmp_list.append(max([lst[j][\"main\"][\"temp_max\"] for j in li]))\r\n return City(city_name, tmp_list)\r\n else:\r\n print(\"How should I know?\")\r\n return None","def GetLocation():\n IPinfoRequest = requests.get('https://ipinfo.io/')\n IPinfo = IPinfoRequest.json()\n Location = IPinfo['loc'].split(',')\n Latitude = Location[0]\n Longitude = Location[1]\n LocationForOpenweather = \"lat=\"+Latitude+\"&lon=\"+Longitude\n return(LocationForOpenweather)","def get_weather_data(weather_station):\n now = datetime.datetime.now()\n then = now - datetime.timedelta(days=7)\n\n query_date_start = (\"%d%02d%02d\" % (then.year, then.month, then.day))\n query_date_end = (\"%d%02d%02d\" % (now.year, now.month, now.day))\n\n api_key = '/api/%s' % WUNDERGROUND_KEY\n history_key = '/history_%s%s/lang:EN/units:english/bestfct:1/v:2.0' % (query_date_start, query_date_end)\n query = '/q/%s.json?showObs=0&ttl=120' % weather_station\n\n weather_url = (\"%s%s%s%s\" % (WUNDERGROUND_HOST, api_key, history_key, query))\n\n logger.info('Weather URL: %s', weather_url)\n response = requests.get(weather_url).text\n\n max_temp_avg = json.loads(response)['history']['summary']['max_temperature_avg']\n sum_precip = json.loads(response)['history']['summary']['precip_sum']\n\n return max_temp_avg, sum_precip","def trans_weather(string):\r\n\treturn cn2en.WEATHER[string]","def _get_dict_weather_data(self, weather_current):\n\n returned_dict = dict()\n returned_dict[\"weather_status\"] = weather_current.get_detailed_status()\n\n time_format = '%H:%M'\n if self.am_pm_time:\n time_format = '%I:%M %p'\n\n returned_dict[\"sunset\"] = datetime.fromtimestamp(weather_current.get_sunset_time()).strftime(time_format)\n returned_dict[\"sunrise\"] = datetime.fromtimestamp(weather_current.get_sunrise_time()).strftime(time_format)\n\n returned_dict[\"temperature\"] = int(round(weather_current.get_temperature(unit=self.temp_unit)[\"temp\"]))\n returned_dict[\"temperature_min\"] = int(round(weather_current.get_temperature(unit=self.temp_unit)[\"temp_min\"]))\n returned_dict[\"temperature_max\"] = int(round(weather_current.get_temperature(unit=self.temp_unit)[\"temp_max\"]))\n\n returned_dict[\"pressure\"] = weather_current.get_pressure()[\"press\"]\n returned_dict[\"sea_level_pressure\"] = weather_current.get_pressure()[\"sea_level\"]\n\n returned_dict[\"humidity\"] = weather_current.get_humidity()\n\n wind = weather_current.get_wind()\n wind_deg = wind.get(\"deg\", None)\n wind_speed = wind.get(\"speed\", None)\n returned_dict[\"wind_deg\"] = wind_deg\n returned_dict[\"wind_speed\"] = wind_speed\n\n snow_current = weather_current.get_snow()\n snow_current = snow_current.get('all', None)\n rain_current = weather_current.get_rain()\n rain_current = rain_current.get('all', None)\n returned_dict[\"rainfall\"] = rain_current\n returned_dict[\"snow\"] = snow_current\n\n returned_dict[\"clouds_coverage\"] = weather_current.get_clouds()\n\n return returned_dict","def getTodaysWeather(self, keyword, temp):\n\n\t\t# Variables\n\t\tweather = {} \n\t\tfio = self.helper.getFio(keyword, temp) # Getting fio object\n\t\t\n\t\t# Getting todays weather data and populating the dictionary\n\t\tif fio.has_daily() is True and fio.has_hourly() is True:\n\t\t daily = FIODaily.FIODaily(fio)\n\t\t hourly = FIOHourly.FIOHourly(fio)\n\t\t for day in xrange(0, 1):\n\t\t\t\tfor item in daily.get_day(day).keys():\n\t\t\t\t\tif item == \"temperatureMin\":\n\t\t\t\t\t\tweather[item] = str(daily.get_day(day)[item]).split(\".\")[0]\n\t\t\t\t\tif item == \"summary\":\n\t\t\t\t\t\tweather[item] = unicode(daily.get_day(day)[item])\n\t\t\t\t\tif item == \"temperatureMax\":\n\t\t\t\t\t\tweather[item] = str(daily.get_day(day)[item]).split(\".\")[0]\n\t\t\t\t\tif item == \"windSpeed\":\n\t\t\t\t\t\twindSpeed = unicode(daily.get_day(day)[item])\n\t\t\t\t\tif item == \"windBearing\":\n\t\t\t\t\t\twindBearing = unicode(daily.get_day(day)[item])\n\t\t\t\t\t\twindBearing = self.helper.convertWindBearing(windBearing)\n\t\t\t\t\tif item == \"sunsetTime\":\n\t\t\t\t\t\tweather[item] = self.helper.getDateForWeather(daily.get_day(day)[item])\n\t\t\t\t\tif item == \"sunriseTime\":\n\t\t\t\t\t\tweather[item] = self.helper.getDateForWeather(daily.get_day(day)[item])\n\t\t\t\t\tif item == \"precipProbability\":\n\t\t\t\t\t\tweather[item] = str(daily.get_day(day)[item] * 100).split(\".\")[0] + \"%\"\n\t\t\t\tweather[\"wind\"] = windBearing + \" \" + windSpeed + \" mph\"\n\t\t\t\tfor item in hourly.get_hour(day).keys():\n\t\t\t\t\tif item == \"summary\":\n\t\t\t\t\t\tweather[\"current\"] = unicode(hourly.get_hour(0)[item])\n\t\t\t\t\tif item == \"temperature\":\n\t\t\t\t\t\tweather[item] = str(hourly.get_hour(0)[item]).split(\".\")[0]\n\t\t\t\t\tif item == \"icon\":\n\t\t\t\t\t\tweather[item] = unicode(hourly.get_hour(0)[item])\n\t\t\t\t\tif item == \"cloudCover\":\n\t\t\t\t\t\tweather[item] = str(hourly.get_hour(0)[item] * 100).split(\".\")[0] + \"%\"\n\t\t\t\tweather[\"town\"] = self.helper.getCoords(keyword)[2]\n\t\telse:\n\t\t\treturn 'No Todays data'\n\n\t\treturn weather","def weather()->str:\n event_log(\"retrieve weather data...\",\"\")\n location =read_json(\"weather_api\")[0] #grabs infro from json fucntion\n complete_api_link = \"https://api.openweathermap.org/data/2.5/weather?q=\"+location+\"&appid=\"+read_json(\"weather_api\")[1]+\"\"\n api_link = requests.get(complete_api_link)\n api_data = api_link.json()\n weather_desc = api_data['weather'][0]['description']#exctracts the wanted data from api\n return(weather_desc)","def get_weather_with_time(time):\n global DARK\n\n if TIME in range(6, 9):\n DARK = False\n return 1\n elif TIME in range(9, 13):\n return 2\n elif TIME in range(13, 16):\n return 3\n elif TIME in range(16, 19):\n if HAS_RAINCOAT:\n return 4\n else:\n if not NICE_WEATHER:\n add_strength(False, 10)\n return 5\n\n elif TIME in range(19, 22):\n if HAS_RAINCOAT:\n return 7\n else:\n if not NICE_WEATHER:\n add_strength(False, 10)\n return 6\n\n else: # 9 - 6am\n DARK = True\n if HAS_FLASHLIGHT:\n return 9\n else:\n return 8","def temps(lieu):\r\n\r\n key = '5a72ceae1feda40543d5844b2e04a205'\r\n localisation = \"http://api.openweathermap.org/data/2.5/weather?q={0},fr&appid={1}\"\r\n localisation = localisation.format(lieu, key)\r\n request_html = requests.get(localisation)\r\n data = request_html.json()\r\n\r\n weather = data['weather'][0]['main']\r\n\r\n if weather == \"Clear\":\r\n weather = \"Beau\"\r\n\r\n elif weather == \"Clouds\":\r\n weather = \"Nuageux\"\r\n return weather","def weather():\n latlong = request.form.get(\"latlong\")\n latlong = latlong.split(\",\")\n data = lookup_weather(latlong[0],latlong[1])\n return render_template(\"weather.html\", data = data)","def current_weather(city_name, API):\r\n global new_city\r\n try:\r\n if city_name.isnumeric(): # if input is zip\r\n url = f'http://api.openweathermap.org/data/2.5/weather?zip={city_name},&appid={API}'\r\n elif ',' in city_name: # if input has a city,state or city,country\r\n new_city = city_name.split(',')\r\n new_city_name = new_city[0].replace(' ', '%20') # so the url correctly handles spaces in cities\r\n if len(new_city[1]) > 2: # if the state/country code is invalid\r\n return \"Not valid state code/country code\"\r\n url = f'https://api.openweathermap.org/data/2.5/weather?q={new_city_name},{new_city[1]},us&appid={API}'\r\n elif ',' not in city_name: # if searched by only city and not state or country code, works for big cities\r\n url = f'http://api.openweathermap.org/data/2.5/weather?q={city_name}&appid={API}'\r\n response = requests.get(url).json() # getting the proper json data based on the input of the city_name\r\n city_latitude = str(response['coord']['lat'])\r\n city_longitude = str(response['coord']['lon'])\r\n if (new_city[1].upper() in states) and (\r\n response['sys']['country'] != 'US'): # to catch foreign cities with US state codes\r\n return \"Not valid city\"\r\n elif (new_city[1].upper() not in states) and (\r\n new_city[1].upper() != response['sys']['country'] and new_city != 'XXX'):\r\n # to catch US cities with foreign country codes\r\n return 'Not a valid city'\r\n elif states[new_city[1].upper()] != coordinates(city_latitude,\r\n city_longitude):\r\n # Check to see if city is located in provided state\r\n return 'City is not located in that state'\r\n current_temp = response['main']['temp']\r\n max_temp = response['main']['temp_max']\r\n min_temp = response['main']['temp_min']\r\n feels_like_temp = response['main']['feels_like']\r\n curr_temp_fheit = round((current_temp * 1.8) - 459.67) # converting to imperial\r\n max_temp_fheit = round((max_temp * 1.8) - 459.67)\r\n min_temp_fheit = round((min_temp * 1.8) - 459.67)\r\n feels_like_temp_fheit = round((feels_like_temp * 1.8) - 459.67)\r\n description = response['weather'][0]['description']\r\n wind = round(response['wind']['speed'] * 2.23694)\r\n\r\n format_weather = (\"Current weather for \" + str(city_name) + \", \" + response['sys']['country'] +\r\n \"\\nCurrent temp: \" + str(curr_temp_fheit) + '\\nMax Temp: ' + str(\r\n max_temp_fheit) + '\\nMin Temp: ' + str(\r\n min_temp_fheit) + '\\nFeels like: ' + str(\r\n feels_like_temp_fheit) + '\\nOutlook: ' + description + '\\nWind: ' + str(\r\n wind) + ' mph')\r\n # print weather in cleaner format\r\n return format_weather\r\n\r\n except KeyError: # If a city that doesn't exist is entered\r\n return 'Not valid city'","def get_weather_data() -> dict:\n # Creating the url for the api call\n api_key = \"96bba64ba34672da132c1a987ad2fee6\"\n lat = 49.24\n long = -123.15\n config = '&units=metric'\n url = f'https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={long}&appid={api_key}{config}'\n\n # Querying and JSON parsing\n api_return = requests.get(url)\n weather_data = api_return.json()\n return weather_data","def current_weather(self):\n weather = DarkSky(self.coordinates)\n current_weather = weather.current_weather\n reply = [f\"*Current Weather in {self.format_location(self.location)}*\"]\n summary = current_weather['summary']\n temp = current_weather['temperature']\n feels_like = current_weather['apparentTemperature']\n rain_chance = current_weather['precipProbability']\n wind_speed = current_weather['windSpeed']\n cloud_cover = current_weather['cloudCover']\n icon = current_weather['icon']\n emoji = self.get_emoji(icon)\n logging.info(f\"Weather Icon: {icon}\")\n weather_message = [\n f\"{emoji} *{summary}*\",\n f\">*Temperature: `{temp}`*\",\n f\">*Feels Like: `{feels_like}`*\",\n f\">*Chance of Rain: `{rain_chance}`*\",\n f\">*Wind Speed: `{wind_speed}`*\",\n f\">*Cloud Cover: `{cloud_cover}`*\"\n ]\n reply.append(\"\\n\".join(weather_message))\n return \"\\n\".join(reply)","def get_weather(self):\n with urllib.request.urlopen(self.url) as response:\n json_data = response.read().decode('utf-8')\n\n data = json.loads(json_data)\n\n weather = {}\n weather['current'] = {\n 'temp': round(data['current']['temp_f']),\n 'humidity': round(data['current']['humidity']),\n 'summary': data['current']['condition']['text']\n }\n today = data['forecast']['forecastday'][0]['day']\n weather['today'] = {\n 'temp': round(today['maxtemp_f']),\n 'summary': today['condition']['text']\n }\n \n return weather","def get_weather(latitude, longitude, units):\n global API_KEY\n qs = {\n 'lat': latitude,\n 'lon': longitude,\n 'APPID': API_KEY,\n 'units': units\n }\n qs = urllib.parse.urlencode(qs)\n url = \"http://api.openweathermap.org/data/2.5/weather?{}\".format(qs)\n weather = requests.get(url)\n weather_json = json.loads(weather.content)\n category = weather_json['weather'][0]['id']\n temp = weather_json['main']['temp']\n wind_speed = weather_json['wind']['speed']\n\n return category, temp, wind_speed","def get_weather(phenny, input):\n import wunderground\n \n report_type = 'conditions'\n\n unicode_input = unicode(input)\n if unicode_input[1:8] == 'weather':\n location_str = unicode_input[9:]\n elif unicode_input[1:3] == 'w ':\n location_str = unicode_input[3:]\n try:\n json_data = wunderground.format_json(location_str, input.weather_API, report_type)\n output_results(phenny, json_data)\n except Exception, e:\n print e\n phenny.say('Could not find results for \"%s\", please reword the search and try again.' % location_str)","def Getweather(CITY, API_KEY):\n r = urequests.get(\"http://api.openweathermap.org/data/2.5/weather?q=%s&appid=%s\" % (CITY, API_KEY)).json()\n Data = []\n TemperatureMin = int(r[\"main\"][\"temp_min\"] - 273.15)\n Data.append(\"Min: %s C\" % TemperatureMin)\n TemperatureMax = int(r[\"main\"][\"temp_max\"] - 273.15)\n Data.append(\"Max: %s C\" % TemperatureMax)\n ActualTemp = int(r[\"main\"][\"temp\"] - 273.15)\n Data.append(\"Current: %s C\" % ActualTemp)\n Humidity = int(r[\"main\"][\"humidity\"])\n Data.append(\"Humidity: %s\" % Humidity)\n Condition = str(r[\"weather\"][0][\"description\"])\n Data.append(\"Condition: %s\" % Condition)\n return Data","def weather(user):\r\n user = user.lower()\r\n\r\n if user == \"stiv\":\r\n return _stiv_bullshit()\r\n location = USER_LOOKUP.get(user)\r\n\r\n if not location:\r\n return \"Berg was too busy sucking dongs to add your location.\"\r\n\r\n url = ROOT_URL + location\r\n\r\n resp = requests.get(url).json()\r\n weather_data = resp.get(\"observations\", {}).get(\"data\")[0]\r\n temp_f = _get(weather_data, \"air_temp\")\r\n\r\n output = {k: _get(weather_data, k) for k, v in weather_data.items() if k in FIELDS}\r\n output[\"degree\"] = \"\\N{DEGREE SIGN}\"\r\n output[\"temp_f\"] = \"%.2f\" % (temp_f * 9 / 5 + 32)\r\n output[\"username\"] = user if not user == 'mcspud' else 'macspud'\r\n\r\n return _format_output(**output)","def get_weather_data(lat, lon):\n\n # Get weather\n filedata = pvtoolslib.get_s3_filename_df()\n filedata_closest = nsrdbtools.find_closest_datafiles(float(lat), float(lon),\n filedata)\n\n filename = filedata_closest['filename'].iloc[0]\n\n if filename == '124250_37.93_-122.3.npz':\n weather, info = nsrdbtools.get_local_weather_data(filename)\n else:\n weather, info = pvtoolslib.get_s3_weather_data(filename)\n\n return weather, info","def get_weather(html):\n\tcheck_page_type(html)\n\tget_temp(html)\n\tget_table(html)\n\treturn weather_dict","def test_handle_weather_current_calls_darksky_correctly(self):\n pass","def GetWeatherByCity(City):\n WeatherUrl = \"http://api.openweathermap.org/data/2.5/weather?q=\"+ City + \"&appid=b4bacbe2dc824431289800439f1ec3df&units=metric\" \n WeatherRequest = requests.get(WeatherUrl)\n WeatherInfo = WeatherRequest.json()\n if ('main' in WeatherInfo):\n pass\n else:\n print(\"Invalid City Name\")\n exit() \n Temp = WeatherInfo['main']['temp']\n Humidity = WeatherInfo['main']['humidity']\n Description = WeatherInfo['weather'][0]['description']\n return(Temp, Humidity, Description)","def fetch_weather(city):\n wparams = { 'city': city,\n 'key': WEATHERBIT_API_KEY\n }\n resp = requests.get(WEATHERBIT_API_URL, params=wparams)\n # this works, need to likely raise for status?\n full_weather = json.loads(resp.text)\n print(\"Got full_weather: %s\" % (full_weather))\n if not full_weather['data'][0]['precip']:\n print(\"Precip was None, coercing to 0\")\n full_weather['data'][0]['precip'] = 0\n weather_dict = {\n 'temp': farenheit(full_weather['data'][0]['temp']),\n 'conditions': full_weather['data'][0]['weather']['description'].lower(),\n 'precip': full_weather['data'][0]['precip'],\n 'forecast_temp': avg_based_on_forecast(city)\n }\n print(\"Trimmed down weather_dict: %s\" % (weather_dict))\n return weather_dict","def get(self, cityname):\n response = hereService.getWeatherByCity(cityname)\n return response","def weather(self):\r\n try:\r\n return str(self.connect()['weather'][0]['description'])\r\n except:\r\n return '@weather'","def temperatures():\n\n return station_9281","def weather():\r\n def weather_api_call():\r\n with open('config.json', 'r') as conf:\r\n conf = json.load(conf)\r\n # Gets the API key from the config.json file\r\n weather_api_key = conf[\"weather_api_key\"]\r\n weather_city_name = conf['weather_city_name']\r\n response = requests.get(\r\n 'http://api.openweathermap.org/data/2.5/weather?'\r\n 'q=' + weather_city_name + '&units=metric&appid=' + weather_api_key)\r\n resp_json = response.json()\r\n with open('weather.json', 'w') as outfile:\r\n # Uses the data from the API to overwrite the weather data\r\n json.dump(resp_json, outfile)\r\n outfile.close()\r\n\r\n def weather_data_extractor():\r\n with open('weather.json', 'r') as weather_json:\r\n weather_json = json.load(weather_json)\r\n temp = weather_json[\"main\"]\r\n weather_item = weather_json[\"weather\"]\r\n desc = weather_item[0]\r\n current_temperature = \"The current temperature is: \" + \\\r\n str(int(temp[\"temp\"])) + \"C\"\r\n current_feels_like = \"Feels like: \" + \\\r\n str(int(temp[\"feels_like\"])) + \"C\"\r\n forecast = desc[\"main\"]\r\n return current_feels_like, current_temperature, forecast\r\n\r\n weather_api_call()\r\n return weather_data_extractor()","def get_last_location_weather(location=\"Ljubljana\"):\n address = \"http://www.arso.gov.si/vreme/napovedi%20in%20podatki/vreme_avt.html\"\n page = requests.get(address)\n html = page.content\n\n parsed_html = BeautifulSoup(html)\n\n station_data = parsed_html.find(\"table\", attrs={\"class\": \"online\"})\n station_names = [x.string for x in station_data.findAll(\"td\", attrs={\"class\": \"onlineimena\"})]\n station_data = [x for x in station_data.findAll(\"tr\")]\n print station_names\n datad = namedtuple(\"location_weather\", (\"temperature\",\n \"humidity\",\n \"wind_direction\",\n \"wind_speed\",\n \"wind_gusts\",\n \"air_pressure\",\n \"rain\",\n \"sun_radiation\"))\n for i, station_name in enumerate(station_names):\n if station_name.lower() == location.lower():\n print station_name\n data = [x.string for x in station_data[i + 2].findAll(\"td\")]\n data = data[1:]\n d = datad(data[0], data[1], slo_to_eng_compass(data[2]), data[3], data[5], *data[7:])\n return d","def GetWeather(query, api_key):\n try:\n owm = pyowm.OWM(api_key)\n observation = owm.weather_at_place(str(query))\n location = observation.get_location()\n weather = observation.get_weather()\n temp = weather.get_temperature('fahrenheit')\n status = CleanupWeatherStatus(weather.get_detailed_status())\n return 'It is %sF degrees with %s in %s right now.' % (int(temp['temp']),\n status,\n location.get_name())\n except:\n return 'I couldn\\'t find any weather for %s. I am sorry.' % (query)","def get_weather(station_id):\n latitude, longitude = helper.get_station_coordinate(db, station_id)\n return jsonify(scrape(latitude, longitude))","def _get_weather_data(self, lat, long):\n return {}\n try:\n # get the data\n forecast = self.ds.get_forecast(\n lat, long,\n exclude=[weather.HOURLY, weather.MINUTELY,\n weather.DAILY, weather.ALERTS, weather.FLAGS])\n\n # add lat & long to the hourly weather data for composite key in db\n data = forecast.currently\n data.latitude = lat\n data.longitude = long\n data = data.__dict__\n data.pop(\"time\")\n return data\n except Exception as e:\n print(e)\n return None","def _get_twilight(self, datetime_today, lon, lat, alt):\r\n\r\n dusk = self._astral.dusk_utc(datetime_today, lat, lon,\r\n observer_elevation=alt,\r\n depression=self.twilight_alt)\r\n\r\n dawn = self._astral.dawn_utc(datetime_today + _delta_dt, lat, lon,\r\n observer_elevation=alt,\r\n depression=self.twilight_alt)\r\n\r\n return dusk, dawn","def get(self, city: str):\n # Make a call to the OpenWeatherMap API and check the units inserted at the query parameter.\n units = request.args.get('unit', '').casefold()\n weather_data, query_units = self.get_weather(city, units)\n temp = self.check_unit(query_units)\n\n # Get the date from the request if no date is provided use the current date and time.\n date_raw = request.args.get('at')\n self.timezone = datetime.now().astimezone().tzinfo\n\n if date_raw:\n # Two date formats are allow an aware and naive date. If no time info has been given use the current time.\n try:\n date = isoparse(date_raw.replace(' ', '+'))\n except ValueError:\n now = datetime.now()\n date = datetime.strptime(date_raw, '%Y-%m-%d').replace(\n hour=now.hour, minute=now.minute, second=now.second, microsecond=now.microsecond,\n tzinfo=self.timezone\n )\n else:\n now = datetime.now()\n date = datetime.now().replace(\n hour=now.hour, minute=now.minute, second=now.second, microsecond=now.microsecond, tzinfo=self.timezone\n )\n\n # Prepare the error response.\n self.error = {\n 'error': '',\n 'error_code': ''\n }\n\n if self.check_past_date(date):\n return self.error, 400\n\n if type(weather_data) == dict:\n # Based on the date check the index of the weather that corresponds with the date in the weather response.\n index = self.find_index(weather_data, date)\n weather_dict = {\n f'{weather_data[\"list\"][index][\"weather\"][0][\"main\"].lower()}':\n f'{weather_data[\"list\"][index][\"weather\"][0][\"description\"]}',\n 'humidity': f'{weather_data[\"list\"][index][\"main\"][\"humidity\"]}%',\n 'pressure': f'{weather_data[\"list\"][index][\"main\"][\"pressure\"]} hPa',\n 'temperature': f'{str(weather_data[\"list\"][index][\"main\"][\"temp\"]) + temp}',\n }\n return weather_dict, 200\n\n elif '404' in str(weather_data):\n self.error['error'] = f'cannot find the city\"{city}\"'\n self.error['error_code'] = 'city_not_found'\n return self.error, 404\n\n else:\n self.error['error'] = 'Something went wrong'\n self.error['error_code'] = 'internal_server_error'\n return self.error, 500","def get_rain():\n global rain\n\n # Report rain only if the condition is 'rainy' (and not always).\n if weather_condition == CONDITION_RAINY and random.random() > 0.7:\n rain += round(random.random(), 2)\n return rain","def getWeatherInfo(request):\n return JsonResponse(WeatherAPI().returnGeoJson(), safe=False)","def get_weather_data(lat='40.761440',lng='-73.981806'):\r\n key ='********************************'\r\n x = pd.DataFrame()\r\n unix_now = int((dt.datetime.now()- dt.datetime(1970,1,1)).total_seconds())\r\n for time in range(unix_now-86400, unix_now+604800, 86400):\r\n rsp = rq.get('https://api.darksky.net/forecast/{}/{},{},{}'.format(key, lat, lng, time))\r\n rsp_json = json.loads(rsp.text)\r\n row = json_normalize(rsp_json[\"daily\"]['data'])\r\n x = x.append(row)\r\n \r\n x = x[['icon','apparentTemperatureHigh','apparentTemperatureLow','cloudCover','humidity','precipProbability',\r\n 'pressure','visibility','windBearing','windGust','windSpeed']].reset_index(drop=True)\r\n return x","def get_external_temp():\n baseurl = \"http://api.openweathermap.org/data/2.5/weather\"\n query = \"?q=salhouse&mode=xml\"\n url = baseurl + query\n r = requests.get(url)\n root = ET.fromstring(r.text)\n kelvin = float(root[1].attrib.get('value'))\n celcius = kelvin - 272.15\n return celcius","def get_weather(self, lat: Optional[float] = None, long: Optional[float] = None) -> BuienradarWeatherResponse:\n data = self.get_data(lat, long, 60)\n\n return BuienradarWeatherResponse(\n barometer_fc=data.get('barometerfcname'),\n condition_name=data.get('condition', {}).get('condition'),\n condition_name_long=data.get('condition', {}).get('exact'),\n condition_image=data.get('condition', {}).get('image'),\n feel_temperature=data.get('feeltemperature'),\n ground_temperature=data.get('groundtemperature'),\n humidity=data.get('humidity'),\n irradiance=data.get('irradiance'),\n measured=data.get('measured'),\n precipitation=data.get('precipitation'),\n pressure=data.get('pressure'),\n rain_last_24_hours=data.get('rainlast24hour'),\n rain_last_hour=data.get('rainlasthour'),\n station_name=data.get('stationname'),\n temperature=data.get('temperature'),\n visibility=data.get('visibility'),\n wind_azimuth=data.get('windazimuth'),\n wind_direction=data.get('wind_irection'),\n wind_force=data.get('windforce'),\n wind_gust=data.get('windgust'),\n wind_speed=data.get('windspeed')\n )","def get_weather(start: str, end: str) -> Generator[Dict[str, str], None, None]:\n speeds = get_speeds(start, end)\n for data in get_temperatures(start, end):\n data.update(next(speeds))\n yield data","def Fetch_station(long, lat, y):\r\n global ddf\r\n dmin = 1000000\r\n rs = 0\r\n i=0\r\n for i in range(len(ddf[y])):\r\n #Calculate the distance between zip code location and weather station location\r\n dnew = Distance_orthonormique(ddf[y]['LON'][i], ddf[y]['LAT'][i], long, lat)\r\n\r\n if(dmin > dnew):\r\n #If the last smaller distance is superior than the current distance :\r\n #the new smaller distance is the current distance\r\n dmin = dnew\r\n rs = i\r\n\r\n #rs = index dataframe weather station\r\n #ddf[y]['STATION NAME'][rs] = Weather station name\r\n #round(dmin, 2) = Distance between weather station and zip code\r\n \r\n return rs, ddf[y]['STATION NAME'][rs], round(dmin,2)","def get_weather(city: str, units='standard') -> tuple:\n api_key = os.environ.get('API_KEY')\n url = 'https://api.openweathermap.org/data/2.5/forecast?'\n\n try:\n response = requests.get(f'{url}q={city}&APPID={api_key}&units={units}')\n response.raise_for_status()\n return response.json(), units\n except HTTPError as error:\n return error, units","def get_current_water_level(self):\n \n url = f'http://waterservices.usgs.gov/nwis/iv/?format=json&sites={self.site_number}¶meterCd=00060,00065&siteStatus=all'\n\n response = requests.request(\"GET\", url)\n data = json.loads(response.text)\n \n #parses json response to get only value of current water level for given river\n current_water_level = data['value']['timeSeries'][0]['values'][0]['value'][0]['value']\n \n return current_water_level","def get_weather(self, time=None, location=None):\n req = requests.get(self.source_url)\n text = req.text\n moment = self.extract_datetime(text)\n met_data = self.parse_hms_data(text)\n met_data['time'] = moment\n met_data['text'] = text\n return self.source_label, met_data","def weather(obsblock, subarray=DEFAULT) :\n _closeTrial(\"WEATHER\",\n \"Array stopped due to weather conditions. \", subarray=subarray)\n commandlog(\"weather()\", subarray=subarray)\n newProject(\"ct017\", obsblock, \"\", False, subarray=subarray)\n intent(\"noise\", \"O\", subarray=subarray)\n # An integration is required to track the time in the PDB\n _pdbIntegration(subarray=subarray)\n alarmIntegdisable(subarray=subarray)\n print \"Integration alarm disabled...\"","def get_weather_report(takeoff,weather):\n # HINT: Looping through the dictionary is VERY slow because it is so large\n # You should convert the takeoff time to an ISO string and search for that first.\n # Only loop through the dictionary as a back-up if that fails.\n \n # Search for time in dictionary\n # As fall back, find the closest time before takeoff\n \n from dateutil.parser import parse\n \n result = []\n takeofftime = takeoff.isoformat()\n \n if takeofftime in weather.keys():\n result = weather[takeofftime]\n \n elif takeofftime not in weather.keys():\n weatherlist = list(weather.keys())\n count = len(weatherlist)\n for m in weatherlist[::-1]:\n if m < takeofftime:\n result = weather[m]\n \n else: \n result = None\n \n \n return result","def fetch_weather():\n\n # Fetch the current weather.\n response = requests.get(f'https://api.openweathermap.org/data/2.5/weather?q=Manchester,UK&units=metric&APPID={WEATHER_API_KEY}')\n\n # Return the data.\n return response.json()","def get_nearest_station(latitude, longitude):\n url = '{}?api_key={}&filter[latitude]={}&filter[longitude]={}&sort=distance'.format(MBTA_BASE_URL,MBTA_API_KEY,latitude,longitude)\n # print(url)\n station_json = get_json(url)\n # print(station_json)\n station_name = station_json['data'][0]['attributes']['name']\n # # print(station_name)\n # # station_description = station_json['data'][0]['attributes']['description']\n # # if station_description:\n # # station_name = station_description\n # # print(station_description)\n wheelchair_boarding = station_json['data'][0]['attributes']['wheelchair_boarding']\n if wheelchair_boarding:\n wheelchair_boarding = \"This station is wheelchair accesible\"\n else:\n wheelchair_boarding = \"Sorry cripple\"\n # print(wheelchair_boarding)\n return station_name, wheelchair_boarding","def update(self):\n url = '/weather/current/minutely' \\\n '?version=2&lat={}&lon={}&city={}&county={}&village={}' \\\n .format(self.lat, self.lon, self.city, self.county, self.village)\n self.result = self.api.get(url)['weather']['minutely'][0]","def get_today_rain_fall(lat, lon, time=datetime.datetime.now()):\n if not lat or not lon:\n log_utils.log_msg_error(logger=logger, key='DARKSKYAPI0001', msg='lat or lon is None')\n return None\n\n try:\n forecast = forecastio.load_forecast(darksky_config.DARKSKY_API_KEY, lat, lon, time=time)\n rain_fall = forecast.currently().precipIntensity\n except Exception as e:\n log_utils.log_msg_error(logger=logger, key='DARKSKYAPI0002', msg='Get today rainfall from DarkSky API Error',\n exception=e)\n return None\n\n return rain_fall","def weather_daily():\n #Fetches data from API and creates global varibles.\n weather_handle(weather_fetch(config_fetcher('weather_city'), config_fetcher('weather_key')))\n #Creates a message that changes based on the temperature.\n if int(current_temp) <= 15:\n variable_message = \"You better grab a coat!\"\n #Searches for r'ain' in weather_description, without capilization.\n elif 'ain' in weather_description:\n variable_message = \"Pick your favourite umbrella. You deserve it!\"\n else:\n variable_message = \"I'd probably wear a t-shirt if I were you...\"\n #Creates a daily breifing using varibles.\n weather_daily_text = (f\"It's {current_temp}°C right now, but it feels \\\nmore like {feels_like}°C. \\nThe warmest it'll be is {max_temp}°C, and the coldest \\\nit'll be is {min_temp}°C. One could describe the weather as {weather_description}.\\\n\\n{variable_message}\")\n return weather_daily_text","def get_inflation_country():\n print(\">> Downloading WORLD BANK inflation / country data...\")\n url = source_config.inflation_data_url['latest']\n output_file = source_config.inflation_data_files['raw']['latest']\n download_insee_excel(url, output_file, check=False)","def find_weather(city):\n\n\ttry:\n\t\thttp = urllib3.PoolManager()\n\t\tresponse = http.request('GET', \n\t\t\t'http://api.openweathermap.org/data/2.5/weather', \n\t\t\tfields ={\n\t\t\t'q':city, \n\t\t\t'units':'metric', \n\t\t\t\"appid\": \"2bc3e79bb974a007818864813f53fd35\"\n\t\t\t}) \n\t\tparsed_data = json.loads(response.data.decode('utf-8'))\n\t\t\n\t\t\n\t\treturn (\"\\t{}\\t{}\\t{}\").format((parsed_data['name']).ljust(10),(str(parsed_data[\"main\"][\"temp\"])).ljust(10), parsed_data[\"weather\"][0][\"description\"])\n\n\texcept Exception as e:\n\t\tprint (e)","def get_forecast(latlongstr):\r\n response = urllib.request.urlopen(\"https://api.weather.gov/points/\"+latlongstr+\"/forecast\").read() \r\n return json.loads(response)[\"properties\"][\"periods\"]","def get_wind():\n return get_next_random(wind, WIND_MAX, WIND_MIN, WIND_DELTA)","def get_weather_country(self):\n return self.bot_data_file[\"weather\"][\"default_country\"]","def wind_bearing(self) -> float:\r\n return self._first_timeserie[\"data\"][\"instant\"][\"details\"][\r\n \"wind_from_direction\"\r\n ]","def convertToWindDirection(wb):\n if wb >= 0 and wb < 11.25:\n return \"N\"\n elif wb >= 11.25 and wb < 33.75:\n return \"NNE\"\n elif wb >= 33.75 and wb < 56.25:\n return \"NE\"\n elif wb >= 56.25 and wb < 78.75:\n return \"ENE\"\n elif wb >= 78.75 and wb < 101.25:\n return \"E\"\n elif wb >= 101.25 and wb < 123.75:\n return \"ESE\"\n elif wb >= 123.75 and wb < 146.25:\n return \"SE\"\n elif wb >= 146.25 and wb < 168.75:\n return \"SSE\"\n elif wb >= 168.75 and wb < 191.25:\n return \"S\"\n elif wb >= 191.25 and wb < 213.75:\n return \"SSW\"\n elif wb >= 213.75 and wb < 236.25:\n return \"SW\"\n elif wb >= 236.25 and wb < 258.75:\n return \"WSW\"\n elif wb >= 258.75 and wb < 281.25:\n return \"W\"\n elif wb >= 281.25 and wb < 303.75:\n return \"WNW\"\n elif wb >= 303.75 and wb < 326.25:\n return \"NW\"\n elif wb >= 326.25 and wb < 348.75:\n return \"NNW\"\n elif wb >= 348.75 and wb < 360:\n return \"N\"\n else:\n return \"NA\"","def func(self):\n account = self.account\n city_name = 'Phoenix' if not self.args else self.args\n a = Astral()\n a.solar_depression = 'civil'\n city = a[city_name]\n if not city:\n return\n timezone = city.timezone\n sun = city.sun(date=datetime.date.today(), local=True)\n\n account.msg('Information for %s/%s\\n' % (city_name, city.region))\n account.msg('Timezone: %s' % timezone)\n account.msg('Latitude: %.02f; Longitude: %.02f' % (city.latitude, city.longitude))\n account.msg('Dawn: %s' % str(sun['dawn']))\n account.msg('Sunrise: %s' % str(sun['sunrise']))\n account.msg('Noon: %s' % str(sun['noon']))\n account.msg('Sunset: %s' % str(sun['sunset']))\n account.msg('Dusk: %s' % str(sun['dusk']))","def _do_checkWeather(self, mjd, w, config):\n # Convert mjd to the relevant time units of the weather dates.\n time = (mjd - config['sim_start'] + config['%s_start' %(w)]) * _day2sec\n # And wrap the time, if we need to. \n time = time % self.maxtime[w]\n # Find the observations which are closest in time to our requested time.\n time_order = (abs(self.dates[w] - time)).argsort()\n date1 = self.dates[w][time_order[0]]\n date2 = self.dates[w][time_order[1]]\n weather1 = self.weather[w][time_order[0]]\n weather2 = self.weather[w][time_order[1]]\n # Do interpolation for weather at this particular time.\n weather = (weather2 - weather1) / (date2 - date1) * (time - date1) + weather1\n return weather, weather1","def get_weather(location):\n url = \"https://api.openweathermap.org/data/2.5/weather?q={}&units=imperial&appid={}\".format(location, get_api_key())\n r = requests.get(url)\n return r.json()","def today_weather(city_name):\n output = (\n datetime.date.today().strftime(\"%d/%m/%Y\")\n + \"Temperature: \"\n + \"{}\".format(\n get_weather(city_name, datetime.date.today().strftime(\"%d/%m/%Y\"))\n )\n )\n print(output)","def get_weather(api_key, city):\n url = \"https://api.openweathermap.org/data/2.5/forecast?id={}&appid={}\".format(city, api_key)\n r = requests.get(url)\n return r.json()","def getWeatherString(index):\n return Texts.weather_titles[index]","def get_weather_info(forecast):\n day_forecast = {}\n day_forecast['condition_text'] = forecast['day']['condition']['text']\n #this icon is a url to an image that describes the weather condition\n day_forecast['condition_icon'] = forecast['day']['condition']['icon']\n day_forecast['max_temp'] = forecast['day']['maxtemp_c']\n day_forecast['min_temp'] = forecast['day']['mintemp_c']\n day_forecast['avg_temp'] = forecast['day']['avgtemp_c']\n date = datetime.strptime(forecast['date'], \"%Y-%m-%d\").strftime(\"%b %d:%a\")\n date_format = date.split(':')\n day_forecast['day'] = date_format[0]\n day_forecast['weekday'] = date_format[1]\n return day_forecast","def _checkWeather(self, mjd, w, config):\n # Convert mjd to the relevant time units of the weather dates. \n time = (mjd - config['sim_start'] + config['%s_start' %(w)]) * _day2sec\n # And wrap the time, if we need to. \n time = time % self.maxtime[w]\n # Then use numpy interp to find the weather values for all of our times (works for single values or for arrays). \n # Requires that the 'weather' times are monotonically increasing, but this is true. (and checked when weather read in).\n # Find the *interpolated* weather values\n values = numpy.interp(time, self.dates[w], self.weather[w])\n return values","def get_weather(xml_data):\n\n import elementtree.ElementTree as ET\n \n page = ET.fromstring(unicode(xml_data, errors=\"ignore\"))\n\n weather = page.find( \"weather/current_conditions\" )\n\n return {\n 'f' : weather.find( \"temp_f\" ).get( \"data\" ),\n 'c' : weather.find( \"temp_c\" ).get( \"data\" ),\n 'humidity' : weather.find( \"humidity\" ).get( \"data\" ),\n 'wind' : weather.find( \"wind_condition\" ).get( \"data\" )\n }","def get_weather_violation(weather,minimums):\n # Implement this function\n #print(weather)\n #print(minimums)\n \n result = ''\n #print(weather['wind'])\n if weather == None:\n# result = 'Unknown'\n return 'Unknown'\n #elif bad_visibility(weather['visibility'],minimums[1]) == False and bad_winds(weather['wind'], minimums[2], minimums[3]) == False and bad_ceiling(weather['sky'],minimums[0]) == False:\n #result = ''\n \n if bad_winds(weather['wind'], minimums[2], minimums[3]) == True:\n result = 'Winds' if result == '' else 'Weather'\n \n if bad_visibility(weather['visibility'], minimums[1]) == True:\n result = 'Visibility' if result == '' else 'Weather'\n \n if bad_ceiling(weather['sky'], minimums[0]) == True:\n result = 'Ceiling' if result == '' else 'Weather'\n \n #elif \n \n return result","def Kiwi_Bday(bork):\n\tif bork == \"Soft Kiwi\":\n\t\treturn \"17th March 2011\"\n\telif bork == \"Poor Kiwi\":\n\t\treturn \"17th March 2011\"\n\telif bork == \"Nice Kiwi\":\n\t\treturn \"1st November 2009\"\n\telif bork == \"Wise Kiwi\":\n\t\treturn \"25th March 2006\"\n\telif bork == \"17th March 2011\":\n\t\treturn \"Soft Kiwi or Poor Kiwi\"\n\telif bork == \"13th December 2008\":\n\t\treturn \"Nice Kiwi\"\n\telif bork == \"25th March 2006\":\n\t\treturn \"Wise Kiwi\"","def __weather_api_call(\n self, time: datetime, location: tuple, index: int,\n ) -> Weather:\n URL = (\n 'https://weather.visualcrossing.com/VisualCrossingWebServices'\n + '/rest/services/weatherdata/history?'\n )\n time_start = time.strftime('%Y-%m-%dT%H:%M:%S')\n # time_end = (time + timedelta(hours=1, seconds=0)\n # ).strftime('%Y-%m-%dT%H:%M:%S')\n location0_str = f'{location[0]:.5f}'\n location1_str = f'{location[1]:.5f}'\n\n PARAMS = {\n 'aggregateHours': 1,\n 'combinationMethod': 'aggregate',\n 'startDateTime': time_start,\n 'endDateTime': time_start,\n 'maxStations': -1,\n 'maxDistance': -1,\n 'contentType': 'json',\n 'unitGroup': self.unit_group,\n 'locationMode': 'single',\n 'key': self.vc_api_key,\n 'dataElements': 'all',\n 'locations': f'{location0_str}, {location1_str}',\n }\n # sending get request and saving the response as response object\n r = requests.get(url=URL, params=PARAMS)\n # extracting data in json format\n response_data = r.json()\n data_values = response_data['location']['values'][0]\n return Weather(\n temperature=data_values['temp'],\n maximum_temperature=data_values['maxt'],\n minimum_temperature=data_values['mint'],\n wind_chill=data_values['windchill'],\n heat_index=data_values['heatindex'],\n precipitation=data_values['precip'],\n snow_depth=data_values['snowdepth'],\n wind_speed=data_values['wspd'],\n wind_direction=data_values['wdir'],\n sea_level_pressure=data_values['sealevelpressure'],\n visibility=data_values['visibility'],\n cloud_cover=data_values['cloudcover'],\n dew_point=data_values['dew'],\n solar_radiation=data_values['solarradiation'],\n relative_humidity=data_values['humidity'],\n weather_type=data_values['weathertype'],\n conditions=data_values['conditions'],\n date=time,\n location=location,\n index=index,\n )","def findWetWeatherDays(self, dbsession, today):\n wetDays = dbsession.query(self.dt).filter(or_(self.weather_description == \"light rain\", self.weather_description == \"moderate rain\")).all()\n # if one of those days is today return it.\n # else just return a wet day.\n for i in range(len(wetDays)):\n if today == wetDays[i][0].weekday():\n return wetDays[i][0]\n else:\n return wetDays[0][0]","def combine_weather(weather):\n\n weather1 = weather[weather[\"Station\"] == 1]\n weather2 = weather[weather[\"Station\"] == 2]\n\n\n pass","def city():\n\n print(\"Welcome to my weather API\")\n\n yourcity = input(\"Enter A known City name: \")\n api_key = (\"077936f695f61908cd19a5a2452a97fb\") \n #our public Api-key \n response = requests.get(\"http://api.openweathermap.org/data/2.5/weather?q={0}&appid=077936f695f61908cd19a5a2452a97fb\".format(yourcity, api_key)) #api call\n weather = response.json()\n print(\"The current weather in {0} is {1}\".format(yourcity, weather[\"weather\"][0][\"description\"])) #the result","def getData():\n\t\n\ttry:\n\t\tgoogleWeather = pywapi.get_weather_from_google(location)\n\t\tcondition = googleWeather['current_conditions']['condition']\n\t\ttemp = googleWeather['current_conditions']['temp_c']\n\t\treturn \"<weather location=\\\"\" + location + \"\\\" condition=\\\"\" + condition + \"\\\" temp=\\\"\" + temp + \"c\" + \"\\\"/>\"\n\texcept:\n\t\treturn \"\"","def convert_weather(self, description):\n conditions = {\n 'clear sky': 'clear',\n 'few clouds': 'clouds with some sunshine',\n 'scattered clouds': 'cloudy',\n 'broken clouds': 'cloudy',\n 'shower rain': 'showers',\n 'thunderstorm': 'thunder and lightning',\n 'mist': 'fog'\n }\n\n if description in conditions:\n return conditions.get(description, \"Look out of the window.\")\n else:\n return description","def get_weather_data(city):\n url = (f\"https://api.openweathermap.org/data/2.5/weather\" +\n f\"?q={city}&units=imperial&appid={Config.OW_API_KEY}\")\n\n response = requests.get(url)\n \n return response.json()","def buildWeatherURL(month=None, day=None, year=None, airport=None, filter=None):\n current_month,current_day,current_year = currentDate('tuple')\n \n if not month:\n month = current_month\n if not day:\n day = current_day\n if not year:\n year = current_year\n \n # Create the gui's layout using text boxes that allow for user input without checking for valid input\n layout = [\n [sg.Text('Month')],[sg.InputText(month)],\n [sg.Text('Day')],[sg.InputText(day)],\n [sg.Text('Year')],[sg.InputText(year)],\n [sg.Text('Code')],[sg.InputText()],\n [sg.Text('Daily / Weekly / Monthly')],[sg.InputText()],\n [sg.Submit(), sg.Cancel()]\n ] \n\n window = sg.Window('Get The Weather', layout) \n\n event, values = window.read()\n window.close()\n \n month = values[0]\n day = values[1]\n year = values[2]\n code = values[3]\n filter = [4]\n\n sg.popup('You entered', f\"Month: {month}, Day: {day}, Year: {year}, Code: {code}, Filter: {filter}\")\n\n # return the URL to pass to wunderground to get appropriate weather data","def forecast_currently():\n forecast = get_forecast()\n currently = forecast.currently()\n return currently","def getHourlyWeather(self, keyword, temp, last_hour):\n\n\t\t# Variables\n\t\tconditions = []\n\t\tweather = {}\n\n\t\tfio = self.helper.getFio(keyword, temp) # Getting fio object\n\n\t\tif fio.has_hourly() is True:\n\t\t\thourly = FIOHourly.FIOHourly(fio)\n\n\t\t\t# Getting weather forecast for next 12 hours\n\t\t\tfor hour in xrange(1, last_hour):\n\t\t\t\tfor item in hourly.get_hour(hour).keys():\n\t\t\t\t\t# Parsing data from hourly fio object and adding it to weather dictionary\n\t\t\t\t\tif item == \"icon\":\n\t\t\t\t\t\tweather[item] = unicode(hourly.get_hour(hour)[item])\n\t\t\t\t\tif item == \"summary\":\n\t\t\t\t\t\tweather[item] = unicode(hourly.get_hour(hour)[item])\n\t\t\t\t\tif item == \"temperature\":\n\t\t\t\t\t\tif temp == \"f\":\n\t\t\t\t\t\t\tweather[item] = str(hourly.get_hour(hour)[item]).split(\".\")[0] + \"° F\"\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tweather[item] = str(hourly.get_hour(hour)[item]).split(\".\")[0] + \"° C\"\n\t\t\t\t\tif item == \"humidity\":\n\t\t\t\t\t\tweather[item] = str(hourly.get_hour(hour)[item] * 100).split(\".\")[0] + \"%\"\n\t\t\t\t\tif item == \"time\":\n\t\t\t\t\t\tweather[item] = self.helper.getDateForWeather(hourly.get_hour(hour)[item])\n\t\t\t\t\tif item == \"precipProbability\":\n\t\t\t\t\t\tweather[item] = str(hourly.get_hour(hour)[item] * 100).split(\".\")[0] + \"%\"\n\t\t\t\t\tif item == \"windSpeed\":\n\t\t\t\t\t\twindSpeed = unicode(hourly.get_hour(hour)[item])\n\t\t\t\t\tif item == \"windBearing\":\n\t\t\t\t\t\twindBearing = unicode(hourly.get_hour(hour)[item])\n\t\t\t\t\t\twindBearing = self.helper.convertWindBearing(windBearing)\n\t\t\t\t\t\tweather[\"wind\"] = windBearing + \" \" + windSpeed + \" mph\"\n\t\t\t\t\tif item == \"cloudCover\":\n\t\t\t\t\t\tweather[item] = str(hourly.get_hour(hour)[item] * 100).split(\".\")[0] + \"%\"\n\n\t\t\t\t# Populating conditions array with weather dicitonary\n\t\t\t\tconditions.append(weather)\n\t\t\t\tweather = {}\n\t\telse:\n\t\t\treturn 'No hourly data'\n\t\treturn conditions","def nancay():\n return coord.EarthLocation(lat=47.376511*u.deg, lon=2.1924002*u.deg)","def get_location(body, returnthis):\n m = re.search(r\"\\bsteemitworldmap\\b\\s([-+]?([1-8]?\\d(\\.\\d+)?|90(\\.0+)?))\\s\\blat\\b\\s([-+]?(180(\\.0+)?|((1[0-7]\\d)|([1-9]?\\d))(\\.\\d+)?))\", body)\n if m:\n try:\n latitude = m.group(1)\n longitude = m.group(5)\n geolocator = Nominatim(user_agent=\"travelfeed/0.1\")\n rawlocation = geolocator.reverse(latitude+\", \"+longitude, language=\"en\", timeout=10).raw\n address = rawlocation['address']\n state = address.get('state', None)\n if state == None: #Not every location has a state/region/... set!\n state = address.get('region', None)\n if state == None:\n state = address.get('state_district', None)\n if state == None:\n state = address.get('county', None)\n if state == None:\n state = \"\"\n country_code = str(address[\"country_code\"]).upper()\n country_object = pycountry.countries.get(alpha_2=country_code)\n try:\n country = country_object.common_name #Some countries such as Taiwan or Bolivia have a common name that is used instead of the official name\n except:\n country = country_object.name\n continent_code = pycountry_convert.country_alpha2_to_continent_code(country_code)\n if continent_code == \"AF\":\n continent = \"Africa\"\n elif continent_code == \"NA\":\n continent = \"North America\"\n elif continent_code == \"OC\":\n continent = \"Oceania\"\n elif continent_code == \"AN\":\n continent = \"Antarctica\"\n elif continent_code == \"AS\":\n continent = \"Asia\"\n elif continent_code == \"EU\":\n continent = \"Europe\"\n elif continent_code == \"SA\":\n continent = \"South America\"\n if returnthis == None:\n location = state+\", \"+country+\", \"+continent\n return location\n if returnthis == \"continentcode\":\n return continent_code\n except Exception as error:\n logger.warning(\"Could not determine location: \"+repr(error))\n return None\n else:\n return None","def to_WTH_converter(self, weather_data, dest_dir):\n ds_all = weather_data.get_global_dataset()\n if self.country is None:\n print(\"Country given is erroneous:\")\n return\n elif self.country == \"globe\":\n lon_num_start = 0\n lon_num_stop = weather_data.get_num_of_attribute('longitude')\n lat_num_start = 0\n lat_num_stop = weather_data.get_num_of_attribute('latitude')\n else:\n lon_num_start, lon_num_stop, lat_num_start, lat_num_stop = weather_data.get_country_boundary(self.country)\n\n\n # top bottom, left to right\n lon_num_start = 397\n lat_num_start = 184\n for lon_i in range(lon_num_start, lon_num_stop + 1):\n # for lon_i in range(lon_num_start, lon_num_stop+1):\n lon = ds_all.longitude.isel(longitude=lon_i).values.tolist()\n\n for lat_i in range(lat_num_start, lat_num_stop+1):\n # for lat_i in range(lat_num_start, lat_num_stop + 1):\n lat = ds_all.latitude.isel(latitude=lat_i).values.tolist()\n\n # create a dynamic header with updated LON, LAT info and move it into the folder given\n wth_header_u = ut.format_header(lat_i + 1, lon_i + 1, lat, lon)\n wth_header = dest_dir + \"/\" + wth_header_u\n shutil.move(wth_header_u, wth_header)\n\n # open in appending mode\n fwth = open(wth_header, \"a+\")\n\n # loop through daily weather data\n for t, date in enumerate(self.years):\n daily_data_vars = ut.get_daily_data_vars(ds_all, lat_i, lon_i, t)\n # disregard all NAN values\n if daily_data_vars is None:\n fwth.close()\n os.remove(wth_header)\n break\n\n if t == 0:\n ut.update_table(wth_header_u, lat, lon)\n\n entry = ut.format_data_vars_entry(daily_data_vars, date)\n\n # append this entry into the file\n fwth.write(entry)\n print(\"Added entry:\", entry)\n\n # close file after writing\n fwth.close()\n print(\"Output WTH:\", wth_header)","def get_current(location_list):\n import re\n import feedparser\n location, human_location = location_list\n city, state = human_location.split(',')\n url = \"http://rss.wunderground.com/auto/rss_full/%s/%s.xml\" % (state.strip(), city.strip())\n feed = feedparser.parse(url)\n s = feed.entries[0].summary\n current = {'location': location, 'human_location': human_location}\n \n current['observation_time'] = parser.parse(feed.entries[0].updated)\n temperature = re.compile('Temperature: ([\\d\\.]+)')\n current['temperature'] = temperature.search(s).group(1)\n humidity = re.compile('Humidity: (\\d+)')\n current['humidity'] = humidity.search(s).group(1)\n conditions = re.compile('Conditions: ([\\w\\s]+)')\n current['conditions'] = conditions.search(s).group(1)\n windspeed = re.compile('Wind Speed: ([\\d\\.]+)')\n current['wind_speed'] = windspeed.search(s).group(1)\n winddirection = re.compile('Wind Direction: (\\w+)')\n current['wind_direction'] = winddirection.search(s).group(1)\n try:\n f = Forecast(**current)\n f.save()\n except:\n logging.info(\"Current Forecast Data missing or no new data available\")","def read_FMI_weather(ID, start_date, end_date, sourcefile, CO2=380.0):\n \n # OmaTunniste;OmaItä;OmaPohjoinen;Kunta;siteid;vuosi;kk;paiva;longitude;latitude;t_mean;t_max;t_min;\n # rainfall;radiation;hpa;lamposumma_v;rainfall_v;lamposumma;lamposumma_cum\n # -site number\n # -date (yyyy mm dd)\n # -latitude (in KKJ coordinates, metres)\n # -longitude (in KKJ coordinates, metres)\n # -T_mean (degrees celcius)\n # -T_max (degrees celcius)\n # -T_min (degrees celcius)\n # -rainfall (mm)\n # -global radiation (per day in kJ/m2)\n # -H2O partial pressure (hPa)\n\n sourcefile = os.path.join(sourcefile)\n\n #ID = int(ID)\n\n # import forcing data\n fmi = pd.read_csv(sourcefile, sep=';', header='infer', \n usecols=['OmaTunniste', 'Kunta', 'aika', 'longitude',\n 'latitude', 't_mean', 't_max', 't_min', 'rainfall',\n 'radiation', 'hpa', 'lamposumma_v', 'rainfall_v'],\n parse_dates=['aika'],encoding=\"ISO-8859-1\")\n \n time = pd.to_datetime(fmi['aika'], format='%Y%m%d')\n\n fmi.index = time\n fmi = fmi.rename(columns={'OmaTunniste': 'ID', 'longitude': 'lon',\n 'latitude': 'lat', 't_mean': 'T', 't_max': 'Tmax',\n 't_min': 'Tmin', 'rainfall': 'Prec',\n 'radiation': 'Rg', 'hpa': 'h2o', 'lamposumma_v': 'dds',\n 'rainfall_v': 'Prec_a'})\n \n fmi['h2o'] = 1e-1*fmi['h2o'] # hPa-->kPa\n fmi['Rg'] = 1e3 / 86400.0*fmi['Rg'] # kJ/m2/d-1 to Wm-2\n fmi['Par'] = 0.5*fmi['Rg']\n\n # saturated vapor pressure\n esa = 0.6112*np.exp((17.67*fmi['T']) / (fmi['T'] + 273.16 - 29.66)) # kPa\n vpd = esa - fmi['h2o'] # kPa\n vpd[vpd < 0] = 0.0\n rh = 100.0*fmi['h2o'] / esa\n rh[rh < 0] = 0.0\n rh[rh > 100] = 100.0\n\n fmi['RH'] = rh\n fmi['esa'] = esa\n fmi['VPD'] = vpd\n\n fmi['doy'] = fmi.index.dayofyear\n fmi = fmi.drop(['aika'], axis=1)\n # replace nan's in prec with 0.0\n #fmi['Prec'][np.isnan(fmi['Prec'])] = 0.0\n fmi['Prec']= fmi['Prec'].fillna(value=0.0)\n # add CO2 concentration to dataframe\n fmi['CO2'] = float(CO2)\n \n # get desired period\n fmi = fmi[(fmi.index >= start_date) & (fmi.index <= end_date)]\n# if ID > 0:\n# fmi = fmi[fmi['ID'] == ID]\n return fmi","def get_zakopane_hourly_weather():\n zakopane = TwelveHoursWeatherForecast(location.get(\"zakopane\", \"\"))\n zakopane_weather_detail = zakopane.get_hourly_weather_details()\n zakopane_hourly_weather_detail = []\n for data in zakopane_weather_detail:\n zakopane_hourly_weather_detail.append(data)\n return zakopane_hourly_weather_detail","async def current(self) -> dict:\n return await self._request(\n \"get\", \"https://www.asthmaforecast.com/api/forecast/current/asthma\"\n )","def windstow(windOutOf) :\n print windstow.__doc__\n\n weather(\"wind\")\n [ovroAnts,bimaAnts,szaAnts] = antennasByType()\n if windOutOf < 180.0 : windDirection=windOutOf+180.0\n else : windDirection=windOutOf-180.0\n stow(ovroAnts)\n qmove(windDirection, 10.0, bimaAnts)","def outside_temp(self) -> models.PiecewiseConstant:\n month = MONTH_NAMES.index(self.event_month) + 1\n\n wx_station = self.nearest_weather_station()\n temp_profile = caimira.data.weather.mean_hourly_temperatures(wx_station = wx_station[0], month = MONTH_NAMES.index(self.event_month) + 1)\n\n _, utc_offset = self.tz_name_and_utc_offset()\n\n # Offset the source times according to the difference from UTC (as a\n # result the first data value may no longer be a midnight, and the hours\n # no longer ordered modulo 24).\n source_times = np.arange(24) + utc_offset\n times, temp_profile = caimira.data.weather.refine_hourly_data(\n source_times,\n temp_profile,\n npts=24*10, # 10 steps per hour => 6 min steps\n )\n outside_temp = models.PiecewiseConstant(\n tuple(float(t) for t in times), tuple(float(t) for t in temp_profile),\n )\n return outside_temp","async def weather(self, ctx, *, loc: str):\n if self.owm:\n try:\n future = self.loop.run_in_executor(None, self.owm.weather_at_place, loc)\n observation = await future\n\n except pyowm.exceptions.not_found_error.NotFoundError:\n return await ctx.send(\"Location not found.\")\n except Exception as e:\n raise uerrs.ServiceError(e)\n w = observation.get_weather()\n _wg = lambda t: w.get_temperature(t)[\"temp\"]\n _icon = w.get_weather_icon_name()\n icon = OWM_ICONS.get(_icon, \"*<no icon>*\")\n status = w.get_detailed_status()\n location = observation.get_location()\n em = discord.Embed(\n title=f\"Weather for {location.get_name()}\",\n description=f\"{icon} Currently: {status}\\n\"\n \":thermometer: Temperature: \"\n f'**{_wg(\"celsius\")}** °C / '\n f' **{_wg(\"fahrenheit\")}** °F',\n colour=0x690E8,\n )\n await ctx.send(embed=em)\n else:\n raise uerrs.ServiceError(\"OpenWeatherMap API not configured.\")","def getWindAt(self, pos, wind):\r\n return wind[int(pos[0]), int(pos[1])]","def full_broadcast(city_name):\n today_weather(city_name)\n for i in range(1, 4):\n output = (\n (datetime.date.today() + datetime.timedelta(days=i)).strftime(\"%d/%m/%Y\")\n + \"Temperature: \"\n + \"{}\".format(\n get_weather(\n city_name,\n (datetime.date.today() + datetime.timedelta(days=i)).strftime(\n \"%d/%m/%Y\"\n ),\n )\n )\n )\n print(output)","def get_weather(city_name, date):\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:\n server = (SERVER_IP, SERVER_PORT)\n sock.connect(server)\n\n sock.recv(1024)\n\n msg = \"100:REQUEST:city={}&date={}&checksum={}\".format(\n city_name, date, checksum(city_name, date)\n )\n sock.sendall(msg.encode())\n server_msg = sock.recv(1024)\n server_msg = server_msg.decode()\n if \"500\" not in server_msg:\n output = server_msg[server_msg.index(\"temp=\") + 5 :].split(\"&\")\n output[1] = output[1][5:]\n (tuple(output))\n else:\n output = (\n 999,\n server_msg[server_msg.find(\"500:ERROR:\") + len(\"500:ERROR:\") : -1],\n )\n return output","def weather_of_wind(city):\n pattern = re.compile(r'.*(\\d+).*')\n\n time_index = np.load(exp_data_path + os.sep + 'station_list' + os.sep + 'time_index.npy', allow_pickle=True)\n time_index = dict(time_index.tolist())\n numpy_res = np.empty((len(time_index['index']),))\n with open(exp_data_path + os.sep + 'weather' + os.sep + city + os.sep + '{}_wind.csv'.format(city)) as f:\n reader = csv.reader(f)\n for line in reader:\n if '微' in line[1]:\n line[1] = 0\n else:\n line[1] = pattern.match(line[1]).group(1)\n numpy_res[int(line[0])] = int(line[1])\n\n file_name = exp_data_path + os.sep + 'weather' + os.sep + city + os.sep + '{}_wind'.format(city)\n if os.path.exists(file_name):\n os.remove(file_name)\n np.save(file_name, numpy_res)\n pass"],"string":"[\n \"def weather_helper():\\n\\n weather = get_weather('Chicago')\\n conditions = weather['weather'][0]['description']\\n temperature = weather['main']['temp']\\n location = weather['name']\\n\\n curr_weather = 'It is currently %s degrees with %s in %s' % (temperature, conditions, location)\\n return curr_weather\",\n \"def get_weather(self):\\n return self.__weather\",\n \"def GetWeatherByLocation():\\n Location = GetLocation()\\n WeatherUrl =\\\"http://api.openweathermap.org/data/2.5/weather?\\\"+ Location +\\\"&appid=b4bacbe2dc824431289800439f1ec3df&units=metric\\\"\\n WeatherRequest = requests.get(WeatherUrl)\\n WeatherInfo = WeatherRequest.json()\\n pprint(WeatherInfo)\\n WindSpeed = WeatherInfo['wind']['speed']\\n pprint(WindSpeed)\\n Temp = WeatherInfo['main']['temp']\\n Humidity = WeatherInfo['main']['humidity']\\n Description = WeatherInfo['weather'][0]['description']\\n print(type(Humidity))\\n return(Temp, Humidity, Description)\",\n \"def forecast_weather(self):\\n pass\",\n \"def get_station_boroughs(self):\\\\\",\n \"def get_weather(self):\\n\\n city = self.user_data[\\\"weatherSettings\\\"][\\\"weatherCity\\\"]\\n country = self.user_data[\\\"weatherSettings\\\"][\\\"weatherCountry\\\"]\\n\\n host = \\\"weather.mios.com\\\"\\n temp_scale = \\\"C\\\"\\n url = \\\"http://%s/?tempFormat=%s&cityWeather=%s&countryWeather=%s\\\" % \\\\\\n (host, temp_scale, Vera.urlencode(city), Vera.urlencode(country))\\n\\n weather = self.proxy_get(url)\\n\\n return (float(weather[\\\"temp\\\"]), weather[\\\"text\\\"])\",\n \"def getLocation(self, state, city, token):\\n d = requests.get(\\n 'http://api.wunderground.com/api/' + str(token) + '/forecast/q/' + str(state) + '/' + str(city) + '.json')\\n json = d.json()\\n return json\",\n \"def get_weather(lat, lon):\\r\\n\\r\\n # API key, retrieved from configure.py\\r\\n api_key = configure.WEATHER_KEY\\r\\n\\r\\n # API endpoint\\r\\n url = f'https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid={api_key}'\\r\\n\\r\\n # API call\\r\\n response = requests.get(url)\\r\\n\\r\\n # Collect response in json format\\r\\n weather = response.json()\\r\\n\\r\\n # Interpret Current Weather\\r\\n current_weather = weather['current']\\r\\n\\r\\n # By default, the API returns all requested times in unix format\\r\\n current_weather['dt'] = epoch_to_human_readable_date(current_weather['dt'])\\r\\n current_weather['sunrise'] = epoch_to_human_readable_date(current_weather['sunrise'])\\r\\n current_weather['sunset'] = epoch_to_human_readable_date(current_weather['sunset'])\\r\\n\\r\\n # By default, the API returns all temperature values in Kelvin\\r\\n current_weather['dew_point'] = {'kelvin': current_weather['dew_point'], \\r\\n 'fahrenheit': round(kelvin_to_fahrenheit(current_weather['dew_point']), 2),\\r\\n 'celsius': round(kelvin_to_celsius(current_weather['dew_point']), 2)}\\r\\n\\r\\n current_weather['feels_like'] = {'kelvin': current_weather['feels_like'], \\r\\n 'fahrenheit': round(kelvin_to_fahrenheit(current_weather['feels_like']), 2),\\r\\n 'celsius': round(kelvin_to_celsius(current_weather['feels_like']), 2)}\\r\\n\\r\\n current_weather['temp'] = {'kelvin': current_weather['temp'], \\r\\n 'fahrenheit': round(kelvin_to_fahrenheit(current_weather['temp']), 2),\\r\\n 'celsius': round(kelvin_to_celsius(current_weather['temp']), 2)}\\r\\n\\r\\n # Change icon value to image url to be used in html img tag as src\\r\\n current_weather['weather'][0]['icon'] = 'http://openweathermap.org/img/wn/' + current_weather['weather'][0]['icon'] + '@2x.png'\\r\\n\\r\\n # Interpret Daily Weather\\r\\n daily_forcast = weather['daily']\\r\\n\\r\\n for day in daily_forcast:\\r\\n # Get readable dates and times\\r\\n day['dt'] = epoch_to_human_readable_date(day['dt'])\\r\\n day['sunrise'] = epoch_to_human_readable_date(day['sunrise'])\\r\\n day['sunset'] = epoch_to_human_readable_date(day['sunset'])\\r\\n\\r\\n # Change icon value to image url to be used in html img tag as src\\r\\n day['weather'][0]['icon'] = 'http://openweathermap.org/img/wn/' + day['weather'][0]['icon'] + '@2x.png'\\r\\n\\r\\n\\r\\n # Convert temperatures in 'feels_like' dictionary from Kelvin to Fahrenheit and Celsius\\r\\n\\r\\n for temp in day['feels_like']:\\r\\n day['feels_like'][temp] = {'kelvin': day['feels_like'][temp], \\r\\n 'fahrenheit': round(kelvin_to_fahrenheit(day['feels_like'][temp]), 2),\\r\\n 'celsius': round(kelvin_to_celsius(day['feels_like'][temp]), 2)}\\r\\n\\r\\n\\r\\n # Convert temperatures in 'temp' dictionary from Kelvin to Fahrenheit\\r\\n\\r\\n for temp in day['temp']:\\r\\n day['temp'][temp] = {'kelvin': day['temp'][temp], \\r\\n 'fahrenheit': round(kelvin_to_fahrenheit(day['temp'][temp]), 2),\\r\\n 'celsius': round(kelvin_to_celsius(day['temp'][temp]), 2)}\\r\\n\\r\\n # Interpret Hourly Weather\\r\\n hourly_weather = weather['hourly']\\r\\n\\r\\n # Only manipulating data for hours of the current date, rest will be ommitted\\r\\n\\r\\n curr_date = epoch_to_human_readable_date(hourly_weather[0]['dt']).split(\\\",\\\", 1)[1][:3]\\r\\n\\r\\n last_hour = 0\\r\\n\\r\\n for index, hour in enumerate(hourly_weather):\\r\\n # Get date in relation to the hour\\r\\n date = epoch_to_human_readable_date(hour['dt']).split(\\\",\\\", 1)[1][:3]\\r\\n if date != curr_date:\\r\\n last_hour = index\\r\\n break\\r\\n \\r\\n # Convert temperatures in 'dew_point' dictionary from Kelvin to Fahrenheit and Celsius\\r\\n hour['dew_point'] = {'Kelvin':hour['dew_point'],\\r\\n 'fahrenheit': round(kelvin_to_fahrenheit(hour['dew_point']), 2),\\r\\n 'celsius': round(kelvin_to_celsius(hour['dew_point']), 2)}\\r\\n\\r\\n # Get readable dates and times\\r\\n hour['dt'] = epoch_to_human_readable_date(hour['dt'])\\r\\n\\r\\n # Convert temperatures in 'feels_like' dictionary from Kelvin to Fahrenheit and Celsius\\r\\n hour['feels_like'] = {'kelvin': hour['feels_like'], \\r\\n 'fahrenheit': round(kelvin_to_fahrenheit(hour['feels_like']), 2),\\r\\n 'celsius': round(kelvin_to_celsius(hour['feels_like']), 2)}\\r\\n\\r\\n # Convert temperatures in 'temp' dictionary from Kelvin to Fahrenheit\\r\\n hour['temp'] = {'kelvin': hour['temp'], \\r\\n 'fahrenheit': round(kelvin_to_fahrenheit(hour['temp']), 2),\\r\\n 'celsius': round(kelvin_to_celsius(hour['temp']), 2)}\\r\\n\\r\\n hour['weather'][0]['icon'] = 'http://openweathermap.org/img/wn/' + hour['weather'][0]['icon'] + '@2x.png'\\r\\n\\r\\n\\r\\n return current_weather, daily_forcast, hourly_weather[:last_hour]\",\n \"def fetch_weather(y):\\r\\n # request parameter(s): Start with '?'\\r\\n # separate name and value with '='\\r\\n # multiple parameter name value pairs are separate with '&'\\r\\n query_string = \\\"?id={}&units=imperial&APIKEY={}\\\".format(y, API_KEY)\\r\\n request_url = WS_URL + query_string\\r\\n print(\\\"Request URL: \\\", request_url)\\r\\n response = requests.get(request_url)\\r\\n if response.status_code == 200:\\r\\n city_name = response.json()[\\\"city\\\"][\\\"name\\\"]\\r\\n lst = response.json()[\\\"list\\\"]\\r\\n tmp_list = []\\r\\n for i in range(len(lst) // 8):\\r\\n li = [x for x in range(len(lst)) if x // 8 == i]\\r\\n tmp_list.append(max([lst[j][\\\"main\\\"][\\\"temp_max\\\"] for j in li]))\\r\\n return City(city_name, tmp_list)\\r\\n else:\\r\\n print(\\\"How should I know?\\\")\\r\\n return None\",\n \"def GetLocation():\\n IPinfoRequest = requests.get('https://ipinfo.io/')\\n IPinfo = IPinfoRequest.json()\\n Location = IPinfo['loc'].split(',')\\n Latitude = Location[0]\\n Longitude = Location[1]\\n LocationForOpenweather = \\\"lat=\\\"+Latitude+\\\"&lon=\\\"+Longitude\\n return(LocationForOpenweather)\",\n \"def get_weather_data(weather_station):\\n now = datetime.datetime.now()\\n then = now - datetime.timedelta(days=7)\\n\\n query_date_start = (\\\"%d%02d%02d\\\" % (then.year, then.month, then.day))\\n query_date_end = (\\\"%d%02d%02d\\\" % (now.year, now.month, now.day))\\n\\n api_key = '/api/%s' % WUNDERGROUND_KEY\\n history_key = '/history_%s%s/lang:EN/units:english/bestfct:1/v:2.0' % (query_date_start, query_date_end)\\n query = '/q/%s.json?showObs=0&ttl=120' % weather_station\\n\\n weather_url = (\\\"%s%s%s%s\\\" % (WUNDERGROUND_HOST, api_key, history_key, query))\\n\\n logger.info('Weather URL: %s', weather_url)\\n response = requests.get(weather_url).text\\n\\n max_temp_avg = json.loads(response)['history']['summary']['max_temperature_avg']\\n sum_precip = json.loads(response)['history']['summary']['precip_sum']\\n\\n return max_temp_avg, sum_precip\",\n \"def trans_weather(string):\\r\\n\\treturn cn2en.WEATHER[string]\",\n \"def _get_dict_weather_data(self, weather_current):\\n\\n returned_dict = dict()\\n returned_dict[\\\"weather_status\\\"] = weather_current.get_detailed_status()\\n\\n time_format = '%H:%M'\\n if self.am_pm_time:\\n time_format = '%I:%M %p'\\n\\n returned_dict[\\\"sunset\\\"] = datetime.fromtimestamp(weather_current.get_sunset_time()).strftime(time_format)\\n returned_dict[\\\"sunrise\\\"] = datetime.fromtimestamp(weather_current.get_sunrise_time()).strftime(time_format)\\n\\n returned_dict[\\\"temperature\\\"] = int(round(weather_current.get_temperature(unit=self.temp_unit)[\\\"temp\\\"]))\\n returned_dict[\\\"temperature_min\\\"] = int(round(weather_current.get_temperature(unit=self.temp_unit)[\\\"temp_min\\\"]))\\n returned_dict[\\\"temperature_max\\\"] = int(round(weather_current.get_temperature(unit=self.temp_unit)[\\\"temp_max\\\"]))\\n\\n returned_dict[\\\"pressure\\\"] = weather_current.get_pressure()[\\\"press\\\"]\\n returned_dict[\\\"sea_level_pressure\\\"] = weather_current.get_pressure()[\\\"sea_level\\\"]\\n\\n returned_dict[\\\"humidity\\\"] = weather_current.get_humidity()\\n\\n wind = weather_current.get_wind()\\n wind_deg = wind.get(\\\"deg\\\", None)\\n wind_speed = wind.get(\\\"speed\\\", None)\\n returned_dict[\\\"wind_deg\\\"] = wind_deg\\n returned_dict[\\\"wind_speed\\\"] = wind_speed\\n\\n snow_current = weather_current.get_snow()\\n snow_current = snow_current.get('all', None)\\n rain_current = weather_current.get_rain()\\n rain_current = rain_current.get('all', None)\\n returned_dict[\\\"rainfall\\\"] = rain_current\\n returned_dict[\\\"snow\\\"] = snow_current\\n\\n returned_dict[\\\"clouds_coverage\\\"] = weather_current.get_clouds()\\n\\n return returned_dict\",\n \"def getTodaysWeather(self, keyword, temp):\\n\\n\\t\\t# Variables\\n\\t\\tweather = {} \\n\\t\\tfio = self.helper.getFio(keyword, temp) # Getting fio object\\n\\t\\t\\n\\t\\t# Getting todays weather data and populating the dictionary\\n\\t\\tif fio.has_daily() is True and fio.has_hourly() is True:\\n\\t\\t daily = FIODaily.FIODaily(fio)\\n\\t\\t hourly = FIOHourly.FIOHourly(fio)\\n\\t\\t for day in xrange(0, 1):\\n\\t\\t\\t\\tfor item in daily.get_day(day).keys():\\n\\t\\t\\t\\t\\tif item == \\\"temperatureMin\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = str(daily.get_day(day)[item]).split(\\\".\\\")[0]\\n\\t\\t\\t\\t\\tif item == \\\"summary\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = unicode(daily.get_day(day)[item])\\n\\t\\t\\t\\t\\tif item == \\\"temperatureMax\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = str(daily.get_day(day)[item]).split(\\\".\\\")[0]\\n\\t\\t\\t\\t\\tif item == \\\"windSpeed\\\":\\n\\t\\t\\t\\t\\t\\twindSpeed = unicode(daily.get_day(day)[item])\\n\\t\\t\\t\\t\\tif item == \\\"windBearing\\\":\\n\\t\\t\\t\\t\\t\\twindBearing = unicode(daily.get_day(day)[item])\\n\\t\\t\\t\\t\\t\\twindBearing = self.helper.convertWindBearing(windBearing)\\n\\t\\t\\t\\t\\tif item == \\\"sunsetTime\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = self.helper.getDateForWeather(daily.get_day(day)[item])\\n\\t\\t\\t\\t\\tif item == \\\"sunriseTime\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = self.helper.getDateForWeather(daily.get_day(day)[item])\\n\\t\\t\\t\\t\\tif item == \\\"precipProbability\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = str(daily.get_day(day)[item] * 100).split(\\\".\\\")[0] + \\\"%\\\"\\n\\t\\t\\t\\tweather[\\\"wind\\\"] = windBearing + \\\" \\\" + windSpeed + \\\" mph\\\"\\n\\t\\t\\t\\tfor item in hourly.get_hour(day).keys():\\n\\t\\t\\t\\t\\tif item == \\\"summary\\\":\\n\\t\\t\\t\\t\\t\\tweather[\\\"current\\\"] = unicode(hourly.get_hour(0)[item])\\n\\t\\t\\t\\t\\tif item == \\\"temperature\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = str(hourly.get_hour(0)[item]).split(\\\".\\\")[0]\\n\\t\\t\\t\\t\\tif item == \\\"icon\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = unicode(hourly.get_hour(0)[item])\\n\\t\\t\\t\\t\\tif item == \\\"cloudCover\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = str(hourly.get_hour(0)[item] * 100).split(\\\".\\\")[0] + \\\"%\\\"\\n\\t\\t\\t\\tweather[\\\"town\\\"] = self.helper.getCoords(keyword)[2]\\n\\t\\telse:\\n\\t\\t\\treturn 'No Todays data'\\n\\n\\t\\treturn weather\",\n \"def weather()->str:\\n event_log(\\\"retrieve weather data...\\\",\\\"\\\")\\n location =read_json(\\\"weather_api\\\")[0] #grabs infro from json fucntion\\n complete_api_link = \\\"https://api.openweathermap.org/data/2.5/weather?q=\\\"+location+\\\"&appid=\\\"+read_json(\\\"weather_api\\\")[1]+\\\"\\\"\\n api_link = requests.get(complete_api_link)\\n api_data = api_link.json()\\n weather_desc = api_data['weather'][0]['description']#exctracts the wanted data from api\\n return(weather_desc)\",\n \"def get_weather_with_time(time):\\n global DARK\\n\\n if TIME in range(6, 9):\\n DARK = False\\n return 1\\n elif TIME in range(9, 13):\\n return 2\\n elif TIME in range(13, 16):\\n return 3\\n elif TIME in range(16, 19):\\n if HAS_RAINCOAT:\\n return 4\\n else:\\n if not NICE_WEATHER:\\n add_strength(False, 10)\\n return 5\\n\\n elif TIME in range(19, 22):\\n if HAS_RAINCOAT:\\n return 7\\n else:\\n if not NICE_WEATHER:\\n add_strength(False, 10)\\n return 6\\n\\n else: # 9 - 6am\\n DARK = True\\n if HAS_FLASHLIGHT:\\n return 9\\n else:\\n return 8\",\n \"def temps(lieu):\\r\\n\\r\\n key = '5a72ceae1feda40543d5844b2e04a205'\\r\\n localisation = \\\"http://api.openweathermap.org/data/2.5/weather?q={0},fr&appid={1}\\\"\\r\\n localisation = localisation.format(lieu, key)\\r\\n request_html = requests.get(localisation)\\r\\n data = request_html.json()\\r\\n\\r\\n weather = data['weather'][0]['main']\\r\\n\\r\\n if weather == \\\"Clear\\\":\\r\\n weather = \\\"Beau\\\"\\r\\n\\r\\n elif weather == \\\"Clouds\\\":\\r\\n weather = \\\"Nuageux\\\"\\r\\n return weather\",\n \"def weather():\\n latlong = request.form.get(\\\"latlong\\\")\\n latlong = latlong.split(\\\",\\\")\\n data = lookup_weather(latlong[0],latlong[1])\\n return render_template(\\\"weather.html\\\", data = data)\",\n \"def current_weather(city_name, API):\\r\\n global new_city\\r\\n try:\\r\\n if city_name.isnumeric(): # if input is zip\\r\\n url = f'http://api.openweathermap.org/data/2.5/weather?zip={city_name},&appid={API}'\\r\\n elif ',' in city_name: # if input has a city,state or city,country\\r\\n new_city = city_name.split(',')\\r\\n new_city_name = new_city[0].replace(' ', '%20') # so the url correctly handles spaces in cities\\r\\n if len(new_city[1]) > 2: # if the state/country code is invalid\\r\\n return \\\"Not valid state code/country code\\\"\\r\\n url = f'https://api.openweathermap.org/data/2.5/weather?q={new_city_name},{new_city[1]},us&appid={API}'\\r\\n elif ',' not in city_name: # if searched by only city and not state or country code, works for big cities\\r\\n url = f'http://api.openweathermap.org/data/2.5/weather?q={city_name}&appid={API}'\\r\\n response = requests.get(url).json() # getting the proper json data based on the input of the city_name\\r\\n city_latitude = str(response['coord']['lat'])\\r\\n city_longitude = str(response['coord']['lon'])\\r\\n if (new_city[1].upper() in states) and (\\r\\n response['sys']['country'] != 'US'): # to catch foreign cities with US state codes\\r\\n return \\\"Not valid city\\\"\\r\\n elif (new_city[1].upper() not in states) and (\\r\\n new_city[1].upper() != response['sys']['country'] and new_city != 'XXX'):\\r\\n # to catch US cities with foreign country codes\\r\\n return 'Not a valid city'\\r\\n elif states[new_city[1].upper()] != coordinates(city_latitude,\\r\\n city_longitude):\\r\\n # Check to see if city is located in provided state\\r\\n return 'City is not located in that state'\\r\\n current_temp = response['main']['temp']\\r\\n max_temp = response['main']['temp_max']\\r\\n min_temp = response['main']['temp_min']\\r\\n feels_like_temp = response['main']['feels_like']\\r\\n curr_temp_fheit = round((current_temp * 1.8) - 459.67) # converting to imperial\\r\\n max_temp_fheit = round((max_temp * 1.8) - 459.67)\\r\\n min_temp_fheit = round((min_temp * 1.8) - 459.67)\\r\\n feels_like_temp_fheit = round((feels_like_temp * 1.8) - 459.67)\\r\\n description = response['weather'][0]['description']\\r\\n wind = round(response['wind']['speed'] * 2.23694)\\r\\n\\r\\n format_weather = (\\\"Current weather for \\\" + str(city_name) + \\\", \\\" + response['sys']['country'] +\\r\\n \\\"\\\\nCurrent temp: \\\" + str(curr_temp_fheit) + '\\\\nMax Temp: ' + str(\\r\\n max_temp_fheit) + '\\\\nMin Temp: ' + str(\\r\\n min_temp_fheit) + '\\\\nFeels like: ' + str(\\r\\n feels_like_temp_fheit) + '\\\\nOutlook: ' + description + '\\\\nWind: ' + str(\\r\\n wind) + ' mph')\\r\\n # print weather in cleaner format\\r\\n return format_weather\\r\\n\\r\\n except KeyError: # If a city that doesn't exist is entered\\r\\n return 'Not valid city'\",\n \"def get_weather_data() -> dict:\\n # Creating the url for the api call\\n api_key = \\\"96bba64ba34672da132c1a987ad2fee6\\\"\\n lat = 49.24\\n long = -123.15\\n config = '&units=metric'\\n url = f'https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={long}&appid={api_key}{config}'\\n\\n # Querying and JSON parsing\\n api_return = requests.get(url)\\n weather_data = api_return.json()\\n return weather_data\",\n \"def current_weather(self):\\n weather = DarkSky(self.coordinates)\\n current_weather = weather.current_weather\\n reply = [f\\\"*Current Weather in {self.format_location(self.location)}*\\\"]\\n summary = current_weather['summary']\\n temp = current_weather['temperature']\\n feels_like = current_weather['apparentTemperature']\\n rain_chance = current_weather['precipProbability']\\n wind_speed = current_weather['windSpeed']\\n cloud_cover = current_weather['cloudCover']\\n icon = current_weather['icon']\\n emoji = self.get_emoji(icon)\\n logging.info(f\\\"Weather Icon: {icon}\\\")\\n weather_message = [\\n f\\\"{emoji} *{summary}*\\\",\\n f\\\">*Temperature: `{temp}`*\\\",\\n f\\\">*Feels Like: `{feels_like}`*\\\",\\n f\\\">*Chance of Rain: `{rain_chance}`*\\\",\\n f\\\">*Wind Speed: `{wind_speed}`*\\\",\\n f\\\">*Cloud Cover: `{cloud_cover}`*\\\"\\n ]\\n reply.append(\\\"\\\\n\\\".join(weather_message))\\n return \\\"\\\\n\\\".join(reply)\",\n \"def get_weather(self):\\n with urllib.request.urlopen(self.url) as response:\\n json_data = response.read().decode('utf-8')\\n\\n data = json.loads(json_data)\\n\\n weather = {}\\n weather['current'] = {\\n 'temp': round(data['current']['temp_f']),\\n 'humidity': round(data['current']['humidity']),\\n 'summary': data['current']['condition']['text']\\n }\\n today = data['forecast']['forecastday'][0]['day']\\n weather['today'] = {\\n 'temp': round(today['maxtemp_f']),\\n 'summary': today['condition']['text']\\n }\\n \\n return weather\",\n \"def get_weather(latitude, longitude, units):\\n global API_KEY\\n qs = {\\n 'lat': latitude,\\n 'lon': longitude,\\n 'APPID': API_KEY,\\n 'units': units\\n }\\n qs = urllib.parse.urlencode(qs)\\n url = \\\"http://api.openweathermap.org/data/2.5/weather?{}\\\".format(qs)\\n weather = requests.get(url)\\n weather_json = json.loads(weather.content)\\n category = weather_json['weather'][0]['id']\\n temp = weather_json['main']['temp']\\n wind_speed = weather_json['wind']['speed']\\n\\n return category, temp, wind_speed\",\n \"def get_weather(phenny, input):\\n import wunderground\\n \\n report_type = 'conditions'\\n\\n unicode_input = unicode(input)\\n if unicode_input[1:8] == 'weather':\\n location_str = unicode_input[9:]\\n elif unicode_input[1:3] == 'w ':\\n location_str = unicode_input[3:]\\n try:\\n json_data = wunderground.format_json(location_str, input.weather_API, report_type)\\n output_results(phenny, json_data)\\n except Exception, e:\\n print e\\n phenny.say('Could not find results for \\\"%s\\\", please reword the search and try again.' % location_str)\",\n \"def Getweather(CITY, API_KEY):\\n r = urequests.get(\\\"http://api.openweathermap.org/data/2.5/weather?q=%s&appid=%s\\\" % (CITY, API_KEY)).json()\\n Data = []\\n TemperatureMin = int(r[\\\"main\\\"][\\\"temp_min\\\"] - 273.15)\\n Data.append(\\\"Min: %s C\\\" % TemperatureMin)\\n TemperatureMax = int(r[\\\"main\\\"][\\\"temp_max\\\"] - 273.15)\\n Data.append(\\\"Max: %s C\\\" % TemperatureMax)\\n ActualTemp = int(r[\\\"main\\\"][\\\"temp\\\"] - 273.15)\\n Data.append(\\\"Current: %s C\\\" % ActualTemp)\\n Humidity = int(r[\\\"main\\\"][\\\"humidity\\\"])\\n Data.append(\\\"Humidity: %s\\\" % Humidity)\\n Condition = str(r[\\\"weather\\\"][0][\\\"description\\\"])\\n Data.append(\\\"Condition: %s\\\" % Condition)\\n return Data\",\n \"def weather(user):\\r\\n user = user.lower()\\r\\n\\r\\n if user == \\\"stiv\\\":\\r\\n return _stiv_bullshit()\\r\\n location = USER_LOOKUP.get(user)\\r\\n\\r\\n if not location:\\r\\n return \\\"Berg was too busy sucking dongs to add your location.\\\"\\r\\n\\r\\n url = ROOT_URL + location\\r\\n\\r\\n resp = requests.get(url).json()\\r\\n weather_data = resp.get(\\\"observations\\\", {}).get(\\\"data\\\")[0]\\r\\n temp_f = _get(weather_data, \\\"air_temp\\\")\\r\\n\\r\\n output = {k: _get(weather_data, k) for k, v in weather_data.items() if k in FIELDS}\\r\\n output[\\\"degree\\\"] = \\\"\\\\N{DEGREE SIGN}\\\"\\r\\n output[\\\"temp_f\\\"] = \\\"%.2f\\\" % (temp_f * 9 / 5 + 32)\\r\\n output[\\\"username\\\"] = user if not user == 'mcspud' else 'macspud'\\r\\n\\r\\n return _format_output(**output)\",\n \"def get_weather_data(lat, lon):\\n\\n # Get weather\\n filedata = pvtoolslib.get_s3_filename_df()\\n filedata_closest = nsrdbtools.find_closest_datafiles(float(lat), float(lon),\\n filedata)\\n\\n filename = filedata_closest['filename'].iloc[0]\\n\\n if filename == '124250_37.93_-122.3.npz':\\n weather, info = nsrdbtools.get_local_weather_data(filename)\\n else:\\n weather, info = pvtoolslib.get_s3_weather_data(filename)\\n\\n return weather, info\",\n \"def get_weather(html):\\n\\tcheck_page_type(html)\\n\\tget_temp(html)\\n\\tget_table(html)\\n\\treturn weather_dict\",\n \"def test_handle_weather_current_calls_darksky_correctly(self):\\n pass\",\n \"def GetWeatherByCity(City):\\n WeatherUrl = \\\"http://api.openweathermap.org/data/2.5/weather?q=\\\"+ City + \\\"&appid=b4bacbe2dc824431289800439f1ec3df&units=metric\\\" \\n WeatherRequest = requests.get(WeatherUrl)\\n WeatherInfo = WeatherRequest.json()\\n if ('main' in WeatherInfo):\\n pass\\n else:\\n print(\\\"Invalid City Name\\\")\\n exit() \\n Temp = WeatherInfo['main']['temp']\\n Humidity = WeatherInfo['main']['humidity']\\n Description = WeatherInfo['weather'][0]['description']\\n return(Temp, Humidity, Description)\",\n \"def fetch_weather(city):\\n wparams = { 'city': city,\\n 'key': WEATHERBIT_API_KEY\\n }\\n resp = requests.get(WEATHERBIT_API_URL, params=wparams)\\n # this works, need to likely raise for status?\\n full_weather = json.loads(resp.text)\\n print(\\\"Got full_weather: %s\\\" % (full_weather))\\n if not full_weather['data'][0]['precip']:\\n print(\\\"Precip was None, coercing to 0\\\")\\n full_weather['data'][0]['precip'] = 0\\n weather_dict = {\\n 'temp': farenheit(full_weather['data'][0]['temp']),\\n 'conditions': full_weather['data'][0]['weather']['description'].lower(),\\n 'precip': full_weather['data'][0]['precip'],\\n 'forecast_temp': avg_based_on_forecast(city)\\n }\\n print(\\\"Trimmed down weather_dict: %s\\\" % (weather_dict))\\n return weather_dict\",\n \"def get(self, cityname):\\n response = hereService.getWeatherByCity(cityname)\\n return response\",\n \"def weather(self):\\r\\n try:\\r\\n return str(self.connect()['weather'][0]['description'])\\r\\n except:\\r\\n return '@weather'\",\n \"def temperatures():\\n\\n return station_9281\",\n \"def weather():\\r\\n def weather_api_call():\\r\\n with open('config.json', 'r') as conf:\\r\\n conf = json.load(conf)\\r\\n # Gets the API key from the config.json file\\r\\n weather_api_key = conf[\\\"weather_api_key\\\"]\\r\\n weather_city_name = conf['weather_city_name']\\r\\n response = requests.get(\\r\\n 'http://api.openweathermap.org/data/2.5/weather?'\\r\\n 'q=' + weather_city_name + '&units=metric&appid=' + weather_api_key)\\r\\n resp_json = response.json()\\r\\n with open('weather.json', 'w') as outfile:\\r\\n # Uses the data from the API to overwrite the weather data\\r\\n json.dump(resp_json, outfile)\\r\\n outfile.close()\\r\\n\\r\\n def weather_data_extractor():\\r\\n with open('weather.json', 'r') as weather_json:\\r\\n weather_json = json.load(weather_json)\\r\\n temp = weather_json[\\\"main\\\"]\\r\\n weather_item = weather_json[\\\"weather\\\"]\\r\\n desc = weather_item[0]\\r\\n current_temperature = \\\"The current temperature is: \\\" + \\\\\\r\\n str(int(temp[\\\"temp\\\"])) + \\\"C\\\"\\r\\n current_feels_like = \\\"Feels like: \\\" + \\\\\\r\\n str(int(temp[\\\"feels_like\\\"])) + \\\"C\\\"\\r\\n forecast = desc[\\\"main\\\"]\\r\\n return current_feels_like, current_temperature, forecast\\r\\n\\r\\n weather_api_call()\\r\\n return weather_data_extractor()\",\n \"def get_last_location_weather(location=\\\"Ljubljana\\\"):\\n address = \\\"http://www.arso.gov.si/vreme/napovedi%20in%20podatki/vreme_avt.html\\\"\\n page = requests.get(address)\\n html = page.content\\n\\n parsed_html = BeautifulSoup(html)\\n\\n station_data = parsed_html.find(\\\"table\\\", attrs={\\\"class\\\": \\\"online\\\"})\\n station_names = [x.string for x in station_data.findAll(\\\"td\\\", attrs={\\\"class\\\": \\\"onlineimena\\\"})]\\n station_data = [x for x in station_data.findAll(\\\"tr\\\")]\\n print station_names\\n datad = namedtuple(\\\"location_weather\\\", (\\\"temperature\\\",\\n \\\"humidity\\\",\\n \\\"wind_direction\\\",\\n \\\"wind_speed\\\",\\n \\\"wind_gusts\\\",\\n \\\"air_pressure\\\",\\n \\\"rain\\\",\\n \\\"sun_radiation\\\"))\\n for i, station_name in enumerate(station_names):\\n if station_name.lower() == location.lower():\\n print station_name\\n data = [x.string for x in station_data[i + 2].findAll(\\\"td\\\")]\\n data = data[1:]\\n d = datad(data[0], data[1], slo_to_eng_compass(data[2]), data[3], data[5], *data[7:])\\n return d\",\n \"def GetWeather(query, api_key):\\n try:\\n owm = pyowm.OWM(api_key)\\n observation = owm.weather_at_place(str(query))\\n location = observation.get_location()\\n weather = observation.get_weather()\\n temp = weather.get_temperature('fahrenheit')\\n status = CleanupWeatherStatus(weather.get_detailed_status())\\n return 'It is %sF degrees with %s in %s right now.' % (int(temp['temp']),\\n status,\\n location.get_name())\\n except:\\n return 'I couldn\\\\'t find any weather for %s. I am sorry.' % (query)\",\n \"def get_weather(station_id):\\n latitude, longitude = helper.get_station_coordinate(db, station_id)\\n return jsonify(scrape(latitude, longitude))\",\n \"def _get_weather_data(self, lat, long):\\n return {}\\n try:\\n # get the data\\n forecast = self.ds.get_forecast(\\n lat, long,\\n exclude=[weather.HOURLY, weather.MINUTELY,\\n weather.DAILY, weather.ALERTS, weather.FLAGS])\\n\\n # add lat & long to the hourly weather data for composite key in db\\n data = forecast.currently\\n data.latitude = lat\\n data.longitude = long\\n data = data.__dict__\\n data.pop(\\\"time\\\")\\n return data\\n except Exception as e:\\n print(e)\\n return None\",\n \"def _get_twilight(self, datetime_today, lon, lat, alt):\\r\\n\\r\\n dusk = self._astral.dusk_utc(datetime_today, lat, lon,\\r\\n observer_elevation=alt,\\r\\n depression=self.twilight_alt)\\r\\n\\r\\n dawn = self._astral.dawn_utc(datetime_today + _delta_dt, lat, lon,\\r\\n observer_elevation=alt,\\r\\n depression=self.twilight_alt)\\r\\n\\r\\n return dusk, dawn\",\n \"def get(self, city: str):\\n # Make a call to the OpenWeatherMap API and check the units inserted at the query parameter.\\n units = request.args.get('unit', '').casefold()\\n weather_data, query_units = self.get_weather(city, units)\\n temp = self.check_unit(query_units)\\n\\n # Get the date from the request if no date is provided use the current date and time.\\n date_raw = request.args.get('at')\\n self.timezone = datetime.now().astimezone().tzinfo\\n\\n if date_raw:\\n # Two date formats are allow an aware and naive date. If no time info has been given use the current time.\\n try:\\n date = isoparse(date_raw.replace(' ', '+'))\\n except ValueError:\\n now = datetime.now()\\n date = datetime.strptime(date_raw, '%Y-%m-%d').replace(\\n hour=now.hour, minute=now.minute, second=now.second, microsecond=now.microsecond,\\n tzinfo=self.timezone\\n )\\n else:\\n now = datetime.now()\\n date = datetime.now().replace(\\n hour=now.hour, minute=now.minute, second=now.second, microsecond=now.microsecond, tzinfo=self.timezone\\n )\\n\\n # Prepare the error response.\\n self.error = {\\n 'error': '',\\n 'error_code': ''\\n }\\n\\n if self.check_past_date(date):\\n return self.error, 400\\n\\n if type(weather_data) == dict:\\n # Based on the date check the index of the weather that corresponds with the date in the weather response.\\n index = self.find_index(weather_data, date)\\n weather_dict = {\\n f'{weather_data[\\\"list\\\"][index][\\\"weather\\\"][0][\\\"main\\\"].lower()}':\\n f'{weather_data[\\\"list\\\"][index][\\\"weather\\\"][0][\\\"description\\\"]}',\\n 'humidity': f'{weather_data[\\\"list\\\"][index][\\\"main\\\"][\\\"humidity\\\"]}%',\\n 'pressure': f'{weather_data[\\\"list\\\"][index][\\\"main\\\"][\\\"pressure\\\"]} hPa',\\n 'temperature': f'{str(weather_data[\\\"list\\\"][index][\\\"main\\\"][\\\"temp\\\"]) + temp}',\\n }\\n return weather_dict, 200\\n\\n elif '404' in str(weather_data):\\n self.error['error'] = f'cannot find the city\\\"{city}\\\"'\\n self.error['error_code'] = 'city_not_found'\\n return self.error, 404\\n\\n else:\\n self.error['error'] = 'Something went wrong'\\n self.error['error_code'] = 'internal_server_error'\\n return self.error, 500\",\n \"def get_rain():\\n global rain\\n\\n # Report rain only if the condition is 'rainy' (and not always).\\n if weather_condition == CONDITION_RAINY and random.random() > 0.7:\\n rain += round(random.random(), 2)\\n return rain\",\n \"def getWeatherInfo(request):\\n return JsonResponse(WeatherAPI().returnGeoJson(), safe=False)\",\n \"def get_weather_data(lat='40.761440',lng='-73.981806'):\\r\\n key ='********************************'\\r\\n x = pd.DataFrame()\\r\\n unix_now = int((dt.datetime.now()- dt.datetime(1970,1,1)).total_seconds())\\r\\n for time in range(unix_now-86400, unix_now+604800, 86400):\\r\\n rsp = rq.get('https://api.darksky.net/forecast/{}/{},{},{}'.format(key, lat, lng, time))\\r\\n rsp_json = json.loads(rsp.text)\\r\\n row = json_normalize(rsp_json[\\\"daily\\\"]['data'])\\r\\n x = x.append(row)\\r\\n \\r\\n x = x[['icon','apparentTemperatureHigh','apparentTemperatureLow','cloudCover','humidity','precipProbability',\\r\\n 'pressure','visibility','windBearing','windGust','windSpeed']].reset_index(drop=True)\\r\\n return x\",\n \"def get_external_temp():\\n baseurl = \\\"http://api.openweathermap.org/data/2.5/weather\\\"\\n query = \\\"?q=salhouse&mode=xml\\\"\\n url = baseurl + query\\n r = requests.get(url)\\n root = ET.fromstring(r.text)\\n kelvin = float(root[1].attrib.get('value'))\\n celcius = kelvin - 272.15\\n return celcius\",\n \"def get_weather(self, lat: Optional[float] = None, long: Optional[float] = None) -> BuienradarWeatherResponse:\\n data = self.get_data(lat, long, 60)\\n\\n return BuienradarWeatherResponse(\\n barometer_fc=data.get('barometerfcname'),\\n condition_name=data.get('condition', {}).get('condition'),\\n condition_name_long=data.get('condition', {}).get('exact'),\\n condition_image=data.get('condition', {}).get('image'),\\n feel_temperature=data.get('feeltemperature'),\\n ground_temperature=data.get('groundtemperature'),\\n humidity=data.get('humidity'),\\n irradiance=data.get('irradiance'),\\n measured=data.get('measured'),\\n precipitation=data.get('precipitation'),\\n pressure=data.get('pressure'),\\n rain_last_24_hours=data.get('rainlast24hour'),\\n rain_last_hour=data.get('rainlasthour'),\\n station_name=data.get('stationname'),\\n temperature=data.get('temperature'),\\n visibility=data.get('visibility'),\\n wind_azimuth=data.get('windazimuth'),\\n wind_direction=data.get('wind_irection'),\\n wind_force=data.get('windforce'),\\n wind_gust=data.get('windgust'),\\n wind_speed=data.get('windspeed')\\n )\",\n \"def get_weather(start: str, end: str) -> Generator[Dict[str, str], None, None]:\\n speeds = get_speeds(start, end)\\n for data in get_temperatures(start, end):\\n data.update(next(speeds))\\n yield data\",\n \"def Fetch_station(long, lat, y):\\r\\n global ddf\\r\\n dmin = 1000000\\r\\n rs = 0\\r\\n i=0\\r\\n for i in range(len(ddf[y])):\\r\\n #Calculate the distance between zip code location and weather station location\\r\\n dnew = Distance_orthonormique(ddf[y]['LON'][i], ddf[y]['LAT'][i], long, lat)\\r\\n\\r\\n if(dmin > dnew):\\r\\n #If the last smaller distance is superior than the current distance :\\r\\n #the new smaller distance is the current distance\\r\\n dmin = dnew\\r\\n rs = i\\r\\n\\r\\n #rs = index dataframe weather station\\r\\n #ddf[y]['STATION NAME'][rs] = Weather station name\\r\\n #round(dmin, 2) = Distance between weather station and zip code\\r\\n \\r\\n return rs, ddf[y]['STATION NAME'][rs], round(dmin,2)\",\n \"def get_weather(city: str, units='standard') -> tuple:\\n api_key = os.environ.get('API_KEY')\\n url = 'https://api.openweathermap.org/data/2.5/forecast?'\\n\\n try:\\n response = requests.get(f'{url}q={city}&APPID={api_key}&units={units}')\\n response.raise_for_status()\\n return response.json(), units\\n except HTTPError as error:\\n return error, units\",\n \"def get_current_water_level(self):\\n \\n url = f'http://waterservices.usgs.gov/nwis/iv/?format=json&sites={self.site_number}¶meterCd=00060,00065&siteStatus=all'\\n\\n response = requests.request(\\\"GET\\\", url)\\n data = json.loads(response.text)\\n \\n #parses json response to get only value of current water level for given river\\n current_water_level = data['value']['timeSeries'][0]['values'][0]['value'][0]['value']\\n \\n return current_water_level\",\n \"def get_weather(self, time=None, location=None):\\n req = requests.get(self.source_url)\\n text = req.text\\n moment = self.extract_datetime(text)\\n met_data = self.parse_hms_data(text)\\n met_data['time'] = moment\\n met_data['text'] = text\\n return self.source_label, met_data\",\n \"def weather(obsblock, subarray=DEFAULT) :\\n _closeTrial(\\\"WEATHER\\\",\\n \\\"Array stopped due to weather conditions. \\\", subarray=subarray)\\n commandlog(\\\"weather()\\\", subarray=subarray)\\n newProject(\\\"ct017\\\", obsblock, \\\"\\\", False, subarray=subarray)\\n intent(\\\"noise\\\", \\\"O\\\", subarray=subarray)\\n # An integration is required to track the time in the PDB\\n _pdbIntegration(subarray=subarray)\\n alarmIntegdisable(subarray=subarray)\\n print \\\"Integration alarm disabled...\\\"\",\n \"def get_weather_report(takeoff,weather):\\n # HINT: Looping through the dictionary is VERY slow because it is so large\\n # You should convert the takeoff time to an ISO string and search for that first.\\n # Only loop through the dictionary as a back-up if that fails.\\n \\n # Search for time in dictionary\\n # As fall back, find the closest time before takeoff\\n \\n from dateutil.parser import parse\\n \\n result = []\\n takeofftime = takeoff.isoformat()\\n \\n if takeofftime in weather.keys():\\n result = weather[takeofftime]\\n \\n elif takeofftime not in weather.keys():\\n weatherlist = list(weather.keys())\\n count = len(weatherlist)\\n for m in weatherlist[::-1]:\\n if m < takeofftime:\\n result = weather[m]\\n \\n else: \\n result = None\\n \\n \\n return result\",\n \"def fetch_weather():\\n\\n # Fetch the current weather.\\n response = requests.get(f'https://api.openweathermap.org/data/2.5/weather?q=Manchester,UK&units=metric&APPID={WEATHER_API_KEY}')\\n\\n # Return the data.\\n return response.json()\",\n \"def get_nearest_station(latitude, longitude):\\n url = '{}?api_key={}&filter[latitude]={}&filter[longitude]={}&sort=distance'.format(MBTA_BASE_URL,MBTA_API_KEY,latitude,longitude)\\n # print(url)\\n station_json = get_json(url)\\n # print(station_json)\\n station_name = station_json['data'][0]['attributes']['name']\\n # # print(station_name)\\n # # station_description = station_json['data'][0]['attributes']['description']\\n # # if station_description:\\n # # station_name = station_description\\n # # print(station_description)\\n wheelchair_boarding = station_json['data'][0]['attributes']['wheelchair_boarding']\\n if wheelchair_boarding:\\n wheelchair_boarding = \\\"This station is wheelchair accesible\\\"\\n else:\\n wheelchair_boarding = \\\"Sorry cripple\\\"\\n # print(wheelchair_boarding)\\n return station_name, wheelchair_boarding\",\n \"def update(self):\\n url = '/weather/current/minutely' \\\\\\n '?version=2&lat={}&lon={}&city={}&county={}&village={}' \\\\\\n .format(self.lat, self.lon, self.city, self.county, self.village)\\n self.result = self.api.get(url)['weather']['minutely'][0]\",\n \"def get_today_rain_fall(lat, lon, time=datetime.datetime.now()):\\n if not lat or not lon:\\n log_utils.log_msg_error(logger=logger, key='DARKSKYAPI0001', msg='lat or lon is None')\\n return None\\n\\n try:\\n forecast = forecastio.load_forecast(darksky_config.DARKSKY_API_KEY, lat, lon, time=time)\\n rain_fall = forecast.currently().precipIntensity\\n except Exception as e:\\n log_utils.log_msg_error(logger=logger, key='DARKSKYAPI0002', msg='Get today rainfall from DarkSky API Error',\\n exception=e)\\n return None\\n\\n return rain_fall\",\n \"def weather_daily():\\n #Fetches data from API and creates global varibles.\\n weather_handle(weather_fetch(config_fetcher('weather_city'), config_fetcher('weather_key')))\\n #Creates a message that changes based on the temperature.\\n if int(current_temp) <= 15:\\n variable_message = \\\"You better grab a coat!\\\"\\n #Searches for r'ain' in weather_description, without capilization.\\n elif 'ain' in weather_description:\\n variable_message = \\\"Pick your favourite umbrella. You deserve it!\\\"\\n else:\\n variable_message = \\\"I'd probably wear a t-shirt if I were you...\\\"\\n #Creates a daily breifing using varibles.\\n weather_daily_text = (f\\\"It's {current_temp}°C right now, but it feels \\\\\\nmore like {feels_like}°C. \\\\nThe warmest it'll be is {max_temp}°C, and the coldest \\\\\\nit'll be is {min_temp}°C. One could describe the weather as {weather_description}.\\\\\\n\\\\n{variable_message}\\\")\\n return weather_daily_text\",\n \"def get_inflation_country():\\n print(\\\">> Downloading WORLD BANK inflation / country data...\\\")\\n url = source_config.inflation_data_url['latest']\\n output_file = source_config.inflation_data_files['raw']['latest']\\n download_insee_excel(url, output_file, check=False)\",\n \"def find_weather(city):\\n\\n\\ttry:\\n\\t\\thttp = urllib3.PoolManager()\\n\\t\\tresponse = http.request('GET', \\n\\t\\t\\t'http://api.openweathermap.org/data/2.5/weather', \\n\\t\\t\\tfields ={\\n\\t\\t\\t'q':city, \\n\\t\\t\\t'units':'metric', \\n\\t\\t\\t\\\"appid\\\": \\\"2bc3e79bb974a007818864813f53fd35\\\"\\n\\t\\t\\t}) \\n\\t\\tparsed_data = json.loads(response.data.decode('utf-8'))\\n\\t\\t\\n\\t\\t\\n\\t\\treturn (\\\"\\\\t{}\\\\t{}\\\\t{}\\\").format((parsed_data['name']).ljust(10),(str(parsed_data[\\\"main\\\"][\\\"temp\\\"])).ljust(10), parsed_data[\\\"weather\\\"][0][\\\"description\\\"])\\n\\n\\texcept Exception as e:\\n\\t\\tprint (e)\",\n \"def get_forecast(latlongstr):\\r\\n response = urllib.request.urlopen(\\\"https://api.weather.gov/points/\\\"+latlongstr+\\\"/forecast\\\").read() \\r\\n return json.loads(response)[\\\"properties\\\"][\\\"periods\\\"]\",\n \"def get_wind():\\n return get_next_random(wind, WIND_MAX, WIND_MIN, WIND_DELTA)\",\n \"def get_weather_country(self):\\n return self.bot_data_file[\\\"weather\\\"][\\\"default_country\\\"]\",\n \"def wind_bearing(self) -> float:\\r\\n return self._first_timeserie[\\\"data\\\"][\\\"instant\\\"][\\\"details\\\"][\\r\\n \\\"wind_from_direction\\\"\\r\\n ]\",\n \"def convertToWindDirection(wb):\\n if wb >= 0 and wb < 11.25:\\n return \\\"N\\\"\\n elif wb >= 11.25 and wb < 33.75:\\n return \\\"NNE\\\"\\n elif wb >= 33.75 and wb < 56.25:\\n return \\\"NE\\\"\\n elif wb >= 56.25 and wb < 78.75:\\n return \\\"ENE\\\"\\n elif wb >= 78.75 and wb < 101.25:\\n return \\\"E\\\"\\n elif wb >= 101.25 and wb < 123.75:\\n return \\\"ESE\\\"\\n elif wb >= 123.75 and wb < 146.25:\\n return \\\"SE\\\"\\n elif wb >= 146.25 and wb < 168.75:\\n return \\\"SSE\\\"\\n elif wb >= 168.75 and wb < 191.25:\\n return \\\"S\\\"\\n elif wb >= 191.25 and wb < 213.75:\\n return \\\"SSW\\\"\\n elif wb >= 213.75 and wb < 236.25:\\n return \\\"SW\\\"\\n elif wb >= 236.25 and wb < 258.75:\\n return \\\"WSW\\\"\\n elif wb >= 258.75 and wb < 281.25:\\n return \\\"W\\\"\\n elif wb >= 281.25 and wb < 303.75:\\n return \\\"WNW\\\"\\n elif wb >= 303.75 and wb < 326.25:\\n return \\\"NW\\\"\\n elif wb >= 326.25 and wb < 348.75:\\n return \\\"NNW\\\"\\n elif wb >= 348.75 and wb < 360:\\n return \\\"N\\\"\\n else:\\n return \\\"NA\\\"\",\n \"def func(self):\\n account = self.account\\n city_name = 'Phoenix' if not self.args else self.args\\n a = Astral()\\n a.solar_depression = 'civil'\\n city = a[city_name]\\n if not city:\\n return\\n timezone = city.timezone\\n sun = city.sun(date=datetime.date.today(), local=True)\\n\\n account.msg('Information for %s/%s\\\\n' % (city_name, city.region))\\n account.msg('Timezone: %s' % timezone)\\n account.msg('Latitude: %.02f; Longitude: %.02f' % (city.latitude, city.longitude))\\n account.msg('Dawn: %s' % str(sun['dawn']))\\n account.msg('Sunrise: %s' % str(sun['sunrise']))\\n account.msg('Noon: %s' % str(sun['noon']))\\n account.msg('Sunset: %s' % str(sun['sunset']))\\n account.msg('Dusk: %s' % str(sun['dusk']))\",\n \"def _do_checkWeather(self, mjd, w, config):\\n # Convert mjd to the relevant time units of the weather dates.\\n time = (mjd - config['sim_start'] + config['%s_start' %(w)]) * _day2sec\\n # And wrap the time, if we need to. \\n time = time % self.maxtime[w]\\n # Find the observations which are closest in time to our requested time.\\n time_order = (abs(self.dates[w] - time)).argsort()\\n date1 = self.dates[w][time_order[0]]\\n date2 = self.dates[w][time_order[1]]\\n weather1 = self.weather[w][time_order[0]]\\n weather2 = self.weather[w][time_order[1]]\\n # Do interpolation for weather at this particular time.\\n weather = (weather2 - weather1) / (date2 - date1) * (time - date1) + weather1\\n return weather, weather1\",\n \"def get_weather(location):\\n url = \\\"https://api.openweathermap.org/data/2.5/weather?q={}&units=imperial&appid={}\\\".format(location, get_api_key())\\n r = requests.get(url)\\n return r.json()\",\n \"def today_weather(city_name):\\n output = (\\n datetime.date.today().strftime(\\\"%d/%m/%Y\\\")\\n + \\\"Temperature: \\\"\\n + \\\"{}\\\".format(\\n get_weather(city_name, datetime.date.today().strftime(\\\"%d/%m/%Y\\\"))\\n )\\n )\\n print(output)\",\n \"def get_weather(api_key, city):\\n url = \\\"https://api.openweathermap.org/data/2.5/forecast?id={}&appid={}\\\".format(city, api_key)\\n r = requests.get(url)\\n return r.json()\",\n \"def getWeatherString(index):\\n return Texts.weather_titles[index]\",\n \"def get_weather_info(forecast):\\n day_forecast = {}\\n day_forecast['condition_text'] = forecast['day']['condition']['text']\\n #this icon is a url to an image that describes the weather condition\\n day_forecast['condition_icon'] = forecast['day']['condition']['icon']\\n day_forecast['max_temp'] = forecast['day']['maxtemp_c']\\n day_forecast['min_temp'] = forecast['day']['mintemp_c']\\n day_forecast['avg_temp'] = forecast['day']['avgtemp_c']\\n date = datetime.strptime(forecast['date'], \\\"%Y-%m-%d\\\").strftime(\\\"%b %d:%a\\\")\\n date_format = date.split(':')\\n day_forecast['day'] = date_format[0]\\n day_forecast['weekday'] = date_format[1]\\n return day_forecast\",\n \"def _checkWeather(self, mjd, w, config):\\n # Convert mjd to the relevant time units of the weather dates. \\n time = (mjd - config['sim_start'] + config['%s_start' %(w)]) * _day2sec\\n # And wrap the time, if we need to. \\n time = time % self.maxtime[w]\\n # Then use numpy interp to find the weather values for all of our times (works for single values or for arrays). \\n # Requires that the 'weather' times are monotonically increasing, but this is true. (and checked when weather read in).\\n # Find the *interpolated* weather values\\n values = numpy.interp(time, self.dates[w], self.weather[w])\\n return values\",\n \"def get_weather(xml_data):\\n\\n import elementtree.ElementTree as ET\\n \\n page = ET.fromstring(unicode(xml_data, errors=\\\"ignore\\\"))\\n\\n weather = page.find( \\\"weather/current_conditions\\\" )\\n\\n return {\\n 'f' : weather.find( \\\"temp_f\\\" ).get( \\\"data\\\" ),\\n 'c' : weather.find( \\\"temp_c\\\" ).get( \\\"data\\\" ),\\n 'humidity' : weather.find( \\\"humidity\\\" ).get( \\\"data\\\" ),\\n 'wind' : weather.find( \\\"wind_condition\\\" ).get( \\\"data\\\" )\\n }\",\n \"def get_weather_violation(weather,minimums):\\n # Implement this function\\n #print(weather)\\n #print(minimums)\\n \\n result = ''\\n #print(weather['wind'])\\n if weather == None:\\n# result = 'Unknown'\\n return 'Unknown'\\n #elif bad_visibility(weather['visibility'],minimums[1]) == False and bad_winds(weather['wind'], minimums[2], minimums[3]) == False and bad_ceiling(weather['sky'],minimums[0]) == False:\\n #result = ''\\n \\n if bad_winds(weather['wind'], minimums[2], minimums[3]) == True:\\n result = 'Winds' if result == '' else 'Weather'\\n \\n if bad_visibility(weather['visibility'], minimums[1]) == True:\\n result = 'Visibility' if result == '' else 'Weather'\\n \\n if bad_ceiling(weather['sky'], minimums[0]) == True:\\n result = 'Ceiling' if result == '' else 'Weather'\\n \\n #elif \\n \\n return result\",\n \"def Kiwi_Bday(bork):\\n\\tif bork == \\\"Soft Kiwi\\\":\\n\\t\\treturn \\\"17th March 2011\\\"\\n\\telif bork == \\\"Poor Kiwi\\\":\\n\\t\\treturn \\\"17th March 2011\\\"\\n\\telif bork == \\\"Nice Kiwi\\\":\\n\\t\\treturn \\\"1st November 2009\\\"\\n\\telif bork == \\\"Wise Kiwi\\\":\\n\\t\\treturn \\\"25th March 2006\\\"\\n\\telif bork == \\\"17th March 2011\\\":\\n\\t\\treturn \\\"Soft Kiwi or Poor Kiwi\\\"\\n\\telif bork == \\\"13th December 2008\\\":\\n\\t\\treturn \\\"Nice Kiwi\\\"\\n\\telif bork == \\\"25th March 2006\\\":\\n\\t\\treturn \\\"Wise Kiwi\\\"\",\n \"def __weather_api_call(\\n self, time: datetime, location: tuple, index: int,\\n ) -> Weather:\\n URL = (\\n 'https://weather.visualcrossing.com/VisualCrossingWebServices'\\n + '/rest/services/weatherdata/history?'\\n )\\n time_start = time.strftime('%Y-%m-%dT%H:%M:%S')\\n # time_end = (time + timedelta(hours=1, seconds=0)\\n # ).strftime('%Y-%m-%dT%H:%M:%S')\\n location0_str = f'{location[0]:.5f}'\\n location1_str = f'{location[1]:.5f}'\\n\\n PARAMS = {\\n 'aggregateHours': 1,\\n 'combinationMethod': 'aggregate',\\n 'startDateTime': time_start,\\n 'endDateTime': time_start,\\n 'maxStations': -1,\\n 'maxDistance': -1,\\n 'contentType': 'json',\\n 'unitGroup': self.unit_group,\\n 'locationMode': 'single',\\n 'key': self.vc_api_key,\\n 'dataElements': 'all',\\n 'locations': f'{location0_str}, {location1_str}',\\n }\\n # sending get request and saving the response as response object\\n r = requests.get(url=URL, params=PARAMS)\\n # extracting data in json format\\n response_data = r.json()\\n data_values = response_data['location']['values'][0]\\n return Weather(\\n temperature=data_values['temp'],\\n maximum_temperature=data_values['maxt'],\\n minimum_temperature=data_values['mint'],\\n wind_chill=data_values['windchill'],\\n heat_index=data_values['heatindex'],\\n precipitation=data_values['precip'],\\n snow_depth=data_values['snowdepth'],\\n wind_speed=data_values['wspd'],\\n wind_direction=data_values['wdir'],\\n sea_level_pressure=data_values['sealevelpressure'],\\n visibility=data_values['visibility'],\\n cloud_cover=data_values['cloudcover'],\\n dew_point=data_values['dew'],\\n solar_radiation=data_values['solarradiation'],\\n relative_humidity=data_values['humidity'],\\n weather_type=data_values['weathertype'],\\n conditions=data_values['conditions'],\\n date=time,\\n location=location,\\n index=index,\\n )\",\n \"def findWetWeatherDays(self, dbsession, today):\\n wetDays = dbsession.query(self.dt).filter(or_(self.weather_description == \\\"light rain\\\", self.weather_description == \\\"moderate rain\\\")).all()\\n # if one of those days is today return it.\\n # else just return a wet day.\\n for i in range(len(wetDays)):\\n if today == wetDays[i][0].weekday():\\n return wetDays[i][0]\\n else:\\n return wetDays[0][0]\",\n \"def combine_weather(weather):\\n\\n weather1 = weather[weather[\\\"Station\\\"] == 1]\\n weather2 = weather[weather[\\\"Station\\\"] == 2]\\n\\n\\n pass\",\n \"def city():\\n\\n print(\\\"Welcome to my weather API\\\")\\n\\n yourcity = input(\\\"Enter A known City name: \\\")\\n api_key = (\\\"077936f695f61908cd19a5a2452a97fb\\\") \\n #our public Api-key \\n response = requests.get(\\\"http://api.openweathermap.org/data/2.5/weather?q={0}&appid=077936f695f61908cd19a5a2452a97fb\\\".format(yourcity, api_key)) #api call\\n weather = response.json()\\n print(\\\"The current weather in {0} is {1}\\\".format(yourcity, weather[\\\"weather\\\"][0][\\\"description\\\"])) #the result\",\n \"def getData():\\n\\t\\n\\ttry:\\n\\t\\tgoogleWeather = pywapi.get_weather_from_google(location)\\n\\t\\tcondition = googleWeather['current_conditions']['condition']\\n\\t\\ttemp = googleWeather['current_conditions']['temp_c']\\n\\t\\treturn \\\"<weather location=\\\\\\\"\\\" + location + \\\"\\\\\\\" condition=\\\\\\\"\\\" + condition + \\\"\\\\\\\" temp=\\\\\\\"\\\" + temp + \\\"c\\\" + \\\"\\\\\\\"/>\\\"\\n\\texcept:\\n\\t\\treturn \\\"\\\"\",\n \"def convert_weather(self, description):\\n conditions = {\\n 'clear sky': 'clear',\\n 'few clouds': 'clouds with some sunshine',\\n 'scattered clouds': 'cloudy',\\n 'broken clouds': 'cloudy',\\n 'shower rain': 'showers',\\n 'thunderstorm': 'thunder and lightning',\\n 'mist': 'fog'\\n }\\n\\n if description in conditions:\\n return conditions.get(description, \\\"Look out of the window.\\\")\\n else:\\n return description\",\n \"def get_weather_data(city):\\n url = (f\\\"https://api.openweathermap.org/data/2.5/weather\\\" +\\n f\\\"?q={city}&units=imperial&appid={Config.OW_API_KEY}\\\")\\n\\n response = requests.get(url)\\n \\n return response.json()\",\n \"def buildWeatherURL(month=None, day=None, year=None, airport=None, filter=None):\\n current_month,current_day,current_year = currentDate('tuple')\\n \\n if not month:\\n month = current_month\\n if not day:\\n day = current_day\\n if not year:\\n year = current_year\\n \\n # Create the gui's layout using text boxes that allow for user input without checking for valid input\\n layout = [\\n [sg.Text('Month')],[sg.InputText(month)],\\n [sg.Text('Day')],[sg.InputText(day)],\\n [sg.Text('Year')],[sg.InputText(year)],\\n [sg.Text('Code')],[sg.InputText()],\\n [sg.Text('Daily / Weekly / Monthly')],[sg.InputText()],\\n [sg.Submit(), sg.Cancel()]\\n ] \\n\\n window = sg.Window('Get The Weather', layout) \\n\\n event, values = window.read()\\n window.close()\\n \\n month = values[0]\\n day = values[1]\\n year = values[2]\\n code = values[3]\\n filter = [4]\\n\\n sg.popup('You entered', f\\\"Month: {month}, Day: {day}, Year: {year}, Code: {code}, Filter: {filter}\\\")\\n\\n # return the URL to pass to wunderground to get appropriate weather data\",\n \"def forecast_currently():\\n forecast = get_forecast()\\n currently = forecast.currently()\\n return currently\",\n \"def getHourlyWeather(self, keyword, temp, last_hour):\\n\\n\\t\\t# Variables\\n\\t\\tconditions = []\\n\\t\\tweather = {}\\n\\n\\t\\tfio = self.helper.getFio(keyword, temp) # Getting fio object\\n\\n\\t\\tif fio.has_hourly() is True:\\n\\t\\t\\thourly = FIOHourly.FIOHourly(fio)\\n\\n\\t\\t\\t# Getting weather forecast for next 12 hours\\n\\t\\t\\tfor hour in xrange(1, last_hour):\\n\\t\\t\\t\\tfor item in hourly.get_hour(hour).keys():\\n\\t\\t\\t\\t\\t# Parsing data from hourly fio object and adding it to weather dictionary\\n\\t\\t\\t\\t\\tif item == \\\"icon\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = unicode(hourly.get_hour(hour)[item])\\n\\t\\t\\t\\t\\tif item == \\\"summary\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = unicode(hourly.get_hour(hour)[item])\\n\\t\\t\\t\\t\\tif item == \\\"temperature\\\":\\n\\t\\t\\t\\t\\t\\tif temp == \\\"f\\\":\\n\\t\\t\\t\\t\\t\\t\\tweather[item] = str(hourly.get_hour(hour)[item]).split(\\\".\\\")[0] + \\\"° F\\\"\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tweather[item] = str(hourly.get_hour(hour)[item]).split(\\\".\\\")[0] + \\\"° C\\\"\\n\\t\\t\\t\\t\\tif item == \\\"humidity\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = str(hourly.get_hour(hour)[item] * 100).split(\\\".\\\")[0] + \\\"%\\\"\\n\\t\\t\\t\\t\\tif item == \\\"time\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = self.helper.getDateForWeather(hourly.get_hour(hour)[item])\\n\\t\\t\\t\\t\\tif item == \\\"precipProbability\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = str(hourly.get_hour(hour)[item] * 100).split(\\\".\\\")[0] + \\\"%\\\"\\n\\t\\t\\t\\t\\tif item == \\\"windSpeed\\\":\\n\\t\\t\\t\\t\\t\\twindSpeed = unicode(hourly.get_hour(hour)[item])\\n\\t\\t\\t\\t\\tif item == \\\"windBearing\\\":\\n\\t\\t\\t\\t\\t\\twindBearing = unicode(hourly.get_hour(hour)[item])\\n\\t\\t\\t\\t\\t\\twindBearing = self.helper.convertWindBearing(windBearing)\\n\\t\\t\\t\\t\\t\\tweather[\\\"wind\\\"] = windBearing + \\\" \\\" + windSpeed + \\\" mph\\\"\\n\\t\\t\\t\\t\\tif item == \\\"cloudCover\\\":\\n\\t\\t\\t\\t\\t\\tweather[item] = str(hourly.get_hour(hour)[item] * 100).split(\\\".\\\")[0] + \\\"%\\\"\\n\\n\\t\\t\\t\\t# Populating conditions array with weather dicitonary\\n\\t\\t\\t\\tconditions.append(weather)\\n\\t\\t\\t\\tweather = {}\\n\\t\\telse:\\n\\t\\t\\treturn 'No hourly data'\\n\\t\\treturn conditions\",\n \"def nancay():\\n return coord.EarthLocation(lat=47.376511*u.deg, lon=2.1924002*u.deg)\",\n \"def get_location(body, returnthis):\\n m = re.search(r\\\"\\\\bsteemitworldmap\\\\b\\\\s([-+]?([1-8]?\\\\d(\\\\.\\\\d+)?|90(\\\\.0+)?))\\\\s\\\\blat\\\\b\\\\s([-+]?(180(\\\\.0+)?|((1[0-7]\\\\d)|([1-9]?\\\\d))(\\\\.\\\\d+)?))\\\", body)\\n if m:\\n try:\\n latitude = m.group(1)\\n longitude = m.group(5)\\n geolocator = Nominatim(user_agent=\\\"travelfeed/0.1\\\")\\n rawlocation = geolocator.reverse(latitude+\\\", \\\"+longitude, language=\\\"en\\\", timeout=10).raw\\n address = rawlocation['address']\\n state = address.get('state', None)\\n if state == None: #Not every location has a state/region/... set!\\n state = address.get('region', None)\\n if state == None:\\n state = address.get('state_district', None)\\n if state == None:\\n state = address.get('county', None)\\n if state == None:\\n state = \\\"\\\"\\n country_code = str(address[\\\"country_code\\\"]).upper()\\n country_object = pycountry.countries.get(alpha_2=country_code)\\n try:\\n country = country_object.common_name #Some countries such as Taiwan or Bolivia have a common name that is used instead of the official name\\n except:\\n country = country_object.name\\n continent_code = pycountry_convert.country_alpha2_to_continent_code(country_code)\\n if continent_code == \\\"AF\\\":\\n continent = \\\"Africa\\\"\\n elif continent_code == \\\"NA\\\":\\n continent = \\\"North America\\\"\\n elif continent_code == \\\"OC\\\":\\n continent = \\\"Oceania\\\"\\n elif continent_code == \\\"AN\\\":\\n continent = \\\"Antarctica\\\"\\n elif continent_code == \\\"AS\\\":\\n continent = \\\"Asia\\\"\\n elif continent_code == \\\"EU\\\":\\n continent = \\\"Europe\\\"\\n elif continent_code == \\\"SA\\\":\\n continent = \\\"South America\\\"\\n if returnthis == None:\\n location = state+\\\", \\\"+country+\\\", \\\"+continent\\n return location\\n if returnthis == \\\"continentcode\\\":\\n return continent_code\\n except Exception as error:\\n logger.warning(\\\"Could not determine location: \\\"+repr(error))\\n return None\\n else:\\n return None\",\n \"def to_WTH_converter(self, weather_data, dest_dir):\\n ds_all = weather_data.get_global_dataset()\\n if self.country is None:\\n print(\\\"Country given is erroneous:\\\")\\n return\\n elif self.country == \\\"globe\\\":\\n lon_num_start = 0\\n lon_num_stop = weather_data.get_num_of_attribute('longitude')\\n lat_num_start = 0\\n lat_num_stop = weather_data.get_num_of_attribute('latitude')\\n else:\\n lon_num_start, lon_num_stop, lat_num_start, lat_num_stop = weather_data.get_country_boundary(self.country)\\n\\n\\n # top bottom, left to right\\n lon_num_start = 397\\n lat_num_start = 184\\n for lon_i in range(lon_num_start, lon_num_stop + 1):\\n # for lon_i in range(lon_num_start, lon_num_stop+1):\\n lon = ds_all.longitude.isel(longitude=lon_i).values.tolist()\\n\\n for lat_i in range(lat_num_start, lat_num_stop+1):\\n # for lat_i in range(lat_num_start, lat_num_stop + 1):\\n lat = ds_all.latitude.isel(latitude=lat_i).values.tolist()\\n\\n # create a dynamic header with updated LON, LAT info and move it into the folder given\\n wth_header_u = ut.format_header(lat_i + 1, lon_i + 1, lat, lon)\\n wth_header = dest_dir + \\\"/\\\" + wth_header_u\\n shutil.move(wth_header_u, wth_header)\\n\\n # open in appending mode\\n fwth = open(wth_header, \\\"a+\\\")\\n\\n # loop through daily weather data\\n for t, date in enumerate(self.years):\\n daily_data_vars = ut.get_daily_data_vars(ds_all, lat_i, lon_i, t)\\n # disregard all NAN values\\n if daily_data_vars is None:\\n fwth.close()\\n os.remove(wth_header)\\n break\\n\\n if t == 0:\\n ut.update_table(wth_header_u, lat, lon)\\n\\n entry = ut.format_data_vars_entry(daily_data_vars, date)\\n\\n # append this entry into the file\\n fwth.write(entry)\\n print(\\\"Added entry:\\\", entry)\\n\\n # close file after writing\\n fwth.close()\\n print(\\\"Output WTH:\\\", wth_header)\",\n \"def get_current(location_list):\\n import re\\n import feedparser\\n location, human_location = location_list\\n city, state = human_location.split(',')\\n url = \\\"http://rss.wunderground.com/auto/rss_full/%s/%s.xml\\\" % (state.strip(), city.strip())\\n feed = feedparser.parse(url)\\n s = feed.entries[0].summary\\n current = {'location': location, 'human_location': human_location}\\n \\n current['observation_time'] = parser.parse(feed.entries[0].updated)\\n temperature = re.compile('Temperature: ([\\\\d\\\\.]+)')\\n current['temperature'] = temperature.search(s).group(1)\\n humidity = re.compile('Humidity: (\\\\d+)')\\n current['humidity'] = humidity.search(s).group(1)\\n conditions = re.compile('Conditions: ([\\\\w\\\\s]+)')\\n current['conditions'] = conditions.search(s).group(1)\\n windspeed = re.compile('Wind Speed: ([\\\\d\\\\.]+)')\\n current['wind_speed'] = windspeed.search(s).group(1)\\n winddirection = re.compile('Wind Direction: (\\\\w+)')\\n current['wind_direction'] = winddirection.search(s).group(1)\\n try:\\n f = Forecast(**current)\\n f.save()\\n except:\\n logging.info(\\\"Current Forecast Data missing or no new data available\\\")\",\n \"def read_FMI_weather(ID, start_date, end_date, sourcefile, CO2=380.0):\\n \\n # OmaTunniste;OmaItä;OmaPohjoinen;Kunta;siteid;vuosi;kk;paiva;longitude;latitude;t_mean;t_max;t_min;\\n # rainfall;radiation;hpa;lamposumma_v;rainfall_v;lamposumma;lamposumma_cum\\n # -site number\\n # -date (yyyy mm dd)\\n # -latitude (in KKJ coordinates, metres)\\n # -longitude (in KKJ coordinates, metres)\\n # -T_mean (degrees celcius)\\n # -T_max (degrees celcius)\\n # -T_min (degrees celcius)\\n # -rainfall (mm)\\n # -global radiation (per day in kJ/m2)\\n # -H2O partial pressure (hPa)\\n\\n sourcefile = os.path.join(sourcefile)\\n\\n #ID = int(ID)\\n\\n # import forcing data\\n fmi = pd.read_csv(sourcefile, sep=';', header='infer', \\n usecols=['OmaTunniste', 'Kunta', 'aika', 'longitude',\\n 'latitude', 't_mean', 't_max', 't_min', 'rainfall',\\n 'radiation', 'hpa', 'lamposumma_v', 'rainfall_v'],\\n parse_dates=['aika'],encoding=\\\"ISO-8859-1\\\")\\n \\n time = pd.to_datetime(fmi['aika'], format='%Y%m%d')\\n\\n fmi.index = time\\n fmi = fmi.rename(columns={'OmaTunniste': 'ID', 'longitude': 'lon',\\n 'latitude': 'lat', 't_mean': 'T', 't_max': 'Tmax',\\n 't_min': 'Tmin', 'rainfall': 'Prec',\\n 'radiation': 'Rg', 'hpa': 'h2o', 'lamposumma_v': 'dds',\\n 'rainfall_v': 'Prec_a'})\\n \\n fmi['h2o'] = 1e-1*fmi['h2o'] # hPa-->kPa\\n fmi['Rg'] = 1e3 / 86400.0*fmi['Rg'] # kJ/m2/d-1 to Wm-2\\n fmi['Par'] = 0.5*fmi['Rg']\\n\\n # saturated vapor pressure\\n esa = 0.6112*np.exp((17.67*fmi['T']) / (fmi['T'] + 273.16 - 29.66)) # kPa\\n vpd = esa - fmi['h2o'] # kPa\\n vpd[vpd < 0] = 0.0\\n rh = 100.0*fmi['h2o'] / esa\\n rh[rh < 0] = 0.0\\n rh[rh > 100] = 100.0\\n\\n fmi['RH'] = rh\\n fmi['esa'] = esa\\n fmi['VPD'] = vpd\\n\\n fmi['doy'] = fmi.index.dayofyear\\n fmi = fmi.drop(['aika'], axis=1)\\n # replace nan's in prec with 0.0\\n #fmi['Prec'][np.isnan(fmi['Prec'])] = 0.0\\n fmi['Prec']= fmi['Prec'].fillna(value=0.0)\\n # add CO2 concentration to dataframe\\n fmi['CO2'] = float(CO2)\\n \\n # get desired period\\n fmi = fmi[(fmi.index >= start_date) & (fmi.index <= end_date)]\\n# if ID > 0:\\n# fmi = fmi[fmi['ID'] == ID]\\n return fmi\",\n \"def get_zakopane_hourly_weather():\\n zakopane = TwelveHoursWeatherForecast(location.get(\\\"zakopane\\\", \\\"\\\"))\\n zakopane_weather_detail = zakopane.get_hourly_weather_details()\\n zakopane_hourly_weather_detail = []\\n for data in zakopane_weather_detail:\\n zakopane_hourly_weather_detail.append(data)\\n return zakopane_hourly_weather_detail\",\n \"async def current(self) -> dict:\\n return await self._request(\\n \\\"get\\\", \\\"https://www.asthmaforecast.com/api/forecast/current/asthma\\\"\\n )\",\n \"def windstow(windOutOf) :\\n print windstow.__doc__\\n\\n weather(\\\"wind\\\")\\n [ovroAnts,bimaAnts,szaAnts] = antennasByType()\\n if windOutOf < 180.0 : windDirection=windOutOf+180.0\\n else : windDirection=windOutOf-180.0\\n stow(ovroAnts)\\n qmove(windDirection, 10.0, bimaAnts)\",\n \"def outside_temp(self) -> models.PiecewiseConstant:\\n month = MONTH_NAMES.index(self.event_month) + 1\\n\\n wx_station = self.nearest_weather_station()\\n temp_profile = caimira.data.weather.mean_hourly_temperatures(wx_station = wx_station[0], month = MONTH_NAMES.index(self.event_month) + 1)\\n\\n _, utc_offset = self.tz_name_and_utc_offset()\\n\\n # Offset the source times according to the difference from UTC (as a\\n # result the first data value may no longer be a midnight, and the hours\\n # no longer ordered modulo 24).\\n source_times = np.arange(24) + utc_offset\\n times, temp_profile = caimira.data.weather.refine_hourly_data(\\n source_times,\\n temp_profile,\\n npts=24*10, # 10 steps per hour => 6 min steps\\n )\\n outside_temp = models.PiecewiseConstant(\\n tuple(float(t) for t in times), tuple(float(t) for t in temp_profile),\\n )\\n return outside_temp\",\n \"async def weather(self, ctx, *, loc: str):\\n if self.owm:\\n try:\\n future = self.loop.run_in_executor(None, self.owm.weather_at_place, loc)\\n observation = await future\\n\\n except pyowm.exceptions.not_found_error.NotFoundError:\\n return await ctx.send(\\\"Location not found.\\\")\\n except Exception as e:\\n raise uerrs.ServiceError(e)\\n w = observation.get_weather()\\n _wg = lambda t: w.get_temperature(t)[\\\"temp\\\"]\\n _icon = w.get_weather_icon_name()\\n icon = OWM_ICONS.get(_icon, \\\"*<no icon>*\\\")\\n status = w.get_detailed_status()\\n location = observation.get_location()\\n em = discord.Embed(\\n title=f\\\"Weather for {location.get_name()}\\\",\\n description=f\\\"{icon} Currently: {status}\\\\n\\\"\\n \\\":thermometer: Temperature: \\\"\\n f'**{_wg(\\\"celsius\\\")}** °C / '\\n f' **{_wg(\\\"fahrenheit\\\")}** °F',\\n colour=0x690E8,\\n )\\n await ctx.send(embed=em)\\n else:\\n raise uerrs.ServiceError(\\\"OpenWeatherMap API not configured.\\\")\",\n \"def getWindAt(self, pos, wind):\\r\\n return wind[int(pos[0]), int(pos[1])]\",\n \"def full_broadcast(city_name):\\n today_weather(city_name)\\n for i in range(1, 4):\\n output = (\\n (datetime.date.today() + datetime.timedelta(days=i)).strftime(\\\"%d/%m/%Y\\\")\\n + \\\"Temperature: \\\"\\n + \\\"{}\\\".format(\\n get_weather(\\n city_name,\\n (datetime.date.today() + datetime.timedelta(days=i)).strftime(\\n \\\"%d/%m/%Y\\\"\\n ),\\n )\\n )\\n )\\n print(output)\",\n \"def get_weather(city_name, date):\\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:\\n server = (SERVER_IP, SERVER_PORT)\\n sock.connect(server)\\n\\n sock.recv(1024)\\n\\n msg = \\\"100:REQUEST:city={}&date={}&checksum={}\\\".format(\\n city_name, date, checksum(city_name, date)\\n )\\n sock.sendall(msg.encode())\\n server_msg = sock.recv(1024)\\n server_msg = server_msg.decode()\\n if \\\"500\\\" not in server_msg:\\n output = server_msg[server_msg.index(\\\"temp=\\\") + 5 :].split(\\\"&\\\")\\n output[1] = output[1][5:]\\n (tuple(output))\\n else:\\n output = (\\n 999,\\n server_msg[server_msg.find(\\\"500:ERROR:\\\") + len(\\\"500:ERROR:\\\") : -1],\\n )\\n return output\",\n \"def weather_of_wind(city):\\n pattern = re.compile(r'.*(\\\\d+).*')\\n\\n time_index = np.load(exp_data_path + os.sep + 'station_list' + os.sep + 'time_index.npy', allow_pickle=True)\\n time_index = dict(time_index.tolist())\\n numpy_res = np.empty((len(time_index['index']),))\\n with open(exp_data_path + os.sep + 'weather' + os.sep + city + os.sep + '{}_wind.csv'.format(city)) as f:\\n reader = csv.reader(f)\\n for line in reader:\\n if '微' in line[1]:\\n line[1] = 0\\n else:\\n line[1] = pattern.match(line[1]).group(1)\\n numpy_res[int(line[0])] = int(line[1])\\n\\n file_name = exp_data_path + os.sep + 'weather' + os.sep + city + os.sep + '{}_wind'.format(city)\\n if os.path.exists(file_name):\\n os.remove(file_name)\\n np.save(file_name, numpy_res)\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6748897","0.6651157","0.65632546","0.654174","0.64824337","0.62617576","0.6250446","0.62484175","0.611307","0.609392","0.6065452","0.60488474","0.60212094","0.59851736","0.5981115","0.5960446","0.5955273","0.5950651","0.59499425","0.5916722","0.5912138","0.59116685","0.5869278","0.5853556","0.5849318","0.58478874","0.5830757","0.58096915","0.57976824","0.5793255","0.5786532","0.5777347","0.57692057","0.57561314","0.57481647","0.5744713","0.57285076","0.5705646","0.5686678","0.56621414","0.56507903","0.56473327","0.5632481","0.56316656","0.5631395","0.56016004","0.5581536","0.5578692","0.55753946","0.5570636","0.55596685","0.5541486","0.55251753","0.552498","0.5523979","0.55234784","0.5520401","0.5517358","0.55061084","0.5499988","0.54868364","0.54866505","0.5475164","0.5473036","0.546823","0.5462342","0.545535","0.54513264","0.5449803","0.54484886","0.5448366","0.54467833","0.5428956","0.54252994","0.54218906","0.54153043","0.5400029","0.53948534","0.5389246","0.5385131","0.53820586","0.5376827","0.53766644","0.5372216","0.5367697","0.53631496","0.535387","0.5347739","0.532848","0.5325325","0.53200173","0.5314025","0.5312075","0.53091156","0.5306829","0.5306544","0.5306502","0.52967405","0.52938265","0.5292681"],"string":"[\n \"0.6748897\",\n \"0.6651157\",\n \"0.65632546\",\n \"0.654174\",\n \"0.64824337\",\n \"0.62617576\",\n \"0.6250446\",\n \"0.62484175\",\n \"0.611307\",\n \"0.609392\",\n \"0.6065452\",\n \"0.60488474\",\n \"0.60212094\",\n \"0.59851736\",\n \"0.5981115\",\n \"0.5960446\",\n \"0.5955273\",\n \"0.5950651\",\n \"0.59499425\",\n \"0.5916722\",\n \"0.5912138\",\n \"0.59116685\",\n \"0.5869278\",\n \"0.5853556\",\n \"0.5849318\",\n \"0.58478874\",\n \"0.5830757\",\n \"0.58096915\",\n \"0.57976824\",\n \"0.5793255\",\n \"0.5786532\",\n \"0.5777347\",\n \"0.57692057\",\n \"0.57561314\",\n \"0.57481647\",\n \"0.5744713\",\n \"0.57285076\",\n \"0.5705646\",\n \"0.5686678\",\n \"0.56621414\",\n \"0.56507903\",\n \"0.56473327\",\n \"0.5632481\",\n \"0.56316656\",\n \"0.5631395\",\n \"0.56016004\",\n \"0.5581536\",\n \"0.5578692\",\n \"0.55753946\",\n \"0.5570636\",\n \"0.55596685\",\n \"0.5541486\",\n \"0.55251753\",\n \"0.552498\",\n \"0.5523979\",\n \"0.55234784\",\n \"0.5520401\",\n \"0.5517358\",\n \"0.55061084\",\n \"0.5499988\",\n \"0.54868364\",\n \"0.54866505\",\n \"0.5475164\",\n \"0.5473036\",\n \"0.546823\",\n \"0.5462342\",\n \"0.545535\",\n \"0.54513264\",\n \"0.5449803\",\n \"0.54484886\",\n \"0.5448366\",\n \"0.54467833\",\n \"0.5428956\",\n \"0.54252994\",\n \"0.54218906\",\n \"0.54153043\",\n \"0.5400029\",\n \"0.53948534\",\n \"0.5389246\",\n \"0.5385131\",\n \"0.53820586\",\n \"0.5376827\",\n \"0.53766644\",\n \"0.5372216\",\n \"0.5367697\",\n \"0.53631496\",\n \"0.535387\",\n \"0.5347739\",\n \"0.532848\",\n \"0.5325325\",\n \"0.53200173\",\n \"0.5314025\",\n \"0.5312075\",\n \"0.53091156\",\n \"0.5306829\",\n \"0.5306544\",\n \"0.5306502\",\n \"0.52967405\",\n \"0.52938265\",\n \"0.5292681\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67351866"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":76077,"cells":{"query":{"kind":"string","value":"Prometheus helper to quickly see the time in London."},"document":{"kind":"string","value":"def get_uk_time(message):\n time_api = 'http://worldtimeapi.org/api/timezone/Europe/London.json'\n london_time = requests.get(time_api).json()\n\n return(\"The current time in London, England is {}\".format(\n london_time['datetime'][11:16]))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_time(self):\n return self.run_command('get_time')[0]","def timezone():\n \n pass","def get_time_info(self):\n\n raise NotImplementedError","def get_nightly_start_time():\n return 14 # 2PM local Tucson time","def get_time():\n # Use this one for production:\n now_time = pendulum.now(tz=pendulum.timezone(\"America/New_York\"))\n # Use this one for testing and modify as needed:\n # now_time = pendulum.datetime(2019, 7, 21, 20, 00, tz='America/New_York')\n\n return now_time","def get_time() -> int:\n return store.time","def current_time(cls) -> float:","async def server_time(self):\n uri = \"/v3/time\"\n success, error = await self.request(\"GET\", uri)\n return success, error","def get_current_india_time():\n india_offset = datetime.timedelta(hours=5, minutes=30)\n in_time = datetime.datetime.utcnow() + india_offset\n return in_time","def get_time():\r\n return datetime.datetime.now().strftime(\"%H\")+\":\"+datetime.datetime.now().strftime(\"%M\")+\":\"+datetime.datetime.now().strftime(\"%S\")","def getTime(self, request, context):\n\t\t\n date = re.split(\"\\s\", datetime.utcnow().strftime(\"%Y %m %d %H %M %S\"))\n\n return droneconnect_pb2.Time(year = int(date[0]), month = int(date[1]), day = int(date[2]), hour = int(date[3]), minute = int(date[4]), second = int(date[5]))","def get_time() -> dict:\n prague = pytz.timezone('Europe/Prague')\n now = prague.localize(datetime.now())\n fmt = '%H:%M'\n au_tz = pytz.timezone('Australia/Sydney')\n sydney = now.astimezone(au_tz).strftime(fmt)\n lon_tz = pytz.timezone('Europe/London')\n london = now.astimezone(lon_tz).strftime(fmt)\n ny_tz = pytz.timezone('US/Eastern')\n ny = now.astimezone(ny_tz).strftime(fmt)\n sf_tz = pytz.timezone('US/Pacific')\n sf = now.astimezone(sf_tz).strftime(fmt)\n return {\"sydney\": sydney, \"london\": london, \"ny\": ny, \"sf\": sf}","def get_hourly(self):\n pass","async def server_time(self):\n uri = \"/fapi/v1/time\"\n success, error = await self.request(\"GET\", uri)\n return success, error","def get_time(self):\n start=''\n end=''\n time=''\n times=self.times\n print(times[self.istep])\n if self.istep > 0:\n start=ncEarth.beginstr % times[self.istep].isoformat()\n\n\n if self.istep < len(times)-2:\n end = ncEarth.endstr % times[self.istep+1].isoformat()\n\n if start is not '' or end is not '':\n time=ncEarth.timestr % {'begin':start,'end':end}\n\n return time","def proxy_hours_minutes(self):\n\n td = self.convert_last_col_filtered()\n resultat = td.days * 24 + td.seconds // 3600, (td.seconds // 60) % 60\n # print('{} H {} M'.format(*resultat))\n print(resultat)\n return resultat","def running_custom_hour(arg):\n pass","def get_time():\n\teastern = timezone('US/Eastern')\n\tnow = datetime.datetime.now(eastern).time()\n\treturn(now)","def get_region_updated_time(self):","def getTime(self):\n return self.time","def now(self):\n os.environ['TZ'] = conf.timezone\n time.tzset()\n return time.strftime(\"%B %d %Y %H:%M:%S IST\", time.localtime())","def currentTime():\n return strftime(\"%H:%M:%S\", time.localtime())","def time():\n _check_init()\n return _pypm.Time()","def time_now():\n return time.time()","def get_time(self):\n return datetime.datetime.now(self.time_zone)","def local_time():\n return datetime.datetime.now().isoformat()[:len('2017-01-24T10:44:00')]","def GetTime(self, *args, **kwargs):\n pass","def public_get_time(x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):\n request = PublicGetTime.create()\n return run_request(request, additional_headers=x_additional_headers, **kwargs)","def time(self):\n return self.raw[\"logTime\"]","def time():\n return datetime.datetime.now().strftime(\"%Y%m%dT%H%M%SZ\")","def get_system_date_time():\n query = {\"type\": \"op\", \"cmd\": \"<show><clock></clock></show>\"}\n\n return __proxy__[\"panos.call\"](query)","def get_time():\n return datetime.datetime.now()","def polls_open(self):\n if self.is_city_of_london:\n return datetime.time(8, 0)\n\n return datetime.time(7, 0)","def get_time(self) -> float:\n raise NotImplementedError()","def servertime(self):\r\n return servertime.Servertime(self)","def now(self, request):\n identity = self.bot.get_plugin('identity').get_identity_by_request(request)\n\n now = times.now()\n tz = self._get_user_timezone(identity)\n local = times.to_local(now, tz)\n\n request.respond('Server time: {}\\nLocal time:{}'.format(now, local))","def get_hours_per_unit_snap(now):\n print(\"/\"*50)\n print(\"GET hours_per_unit SNAP\")\n print(\"/\"*50)\n plant_settings = PlantSetting.objects.latest('timestamp')\n # print(\"SETINGS\",settings.timestamp)\n print(\"NOW: \", now)\n # preventing processing data before start of defined shift\n start, shift = get_shift_info(plant_settings, now)\n print(\"Start: \", start)\n print(\"Shift: \", shift)\n\n if start > now:\n print(\"NOT IN SHIFT\")\n return\n hours_per_unit_dict = main(start, now)\n hours_per_unit_dict['shift'] = shift\n\n return hours_per_unit_dict","def main(format):\n print(pendulum.now().format(format))","def get_time():\n return {\n 'timestamp': datetime.now()+ timedelta(hours=-1)\n }","def _get_timebase(self):\n return clock()","def _get_timebase(self):\n return clock()","def now():\n return utcfromtimestamp(time.time())","def cpu_time(self):","def time_stats(df, month, day):\n\n print('\\nCalculating The Most regular Times of Travelling\\n Loading Please wait for a while ........\\n')\n start_time = time.time()\n\n # display the most common month\n if(month == 'all'):\n most_similar_month = df['Start Time'].dt.month.value_counts().idxmax()\n print('******************** Most common(popular) month is :'+ str(most_similar_month) + ' *********************')\n\n # display the most common day of week\n if(day == 'all'):\n most_similar_day = df['Start Time'].dt.weekday_name.value_counts().idxmax()\n print('******************** Most common(popular) day is : ' + str(most_similar_day) + ' *********************')\n\n # display the most common start hour\n most_similar_hour = df['Start Time'].dt.hour.value_counts().idxmax()\n print('******************** Most popular hour is : ' + str(most_similar_hour) + ' *********************')\n\n print(\"\\n******************** This took %s seconds. *********************\" % (time.time() - start_time))\n print('-'*40)","def Timer():\n ltime = time.localtime()\n h, m, s = ltime[3:6]\n return h * 3600.0 + m * 60.0 + s","def GetTime():\n import ntptime\n ntptime.settime()\n ts = time.localtime()\n year = ts[0]\n Month = ts[1]\n day = ts[2]\n hour = ts[3]\n mins = ts[4]\n dayYear = ts[7]\n ActualTime = \"%s/%s/%s %s:%s\" % (str(day), str(Month), str(year), str(hour), str(mins))\n return ActualTime","def gettime(self):\n return self.t","def hour():\r\n\r\n date = datetime.datetime.now()\r\n hours = date.hour\r\n minute = date.minute\r\n\r\n return hours, minute","def getTimes():","def getTimes():","def getTimes():","def gettime():\n return libruss.russ_gettime()","def test_time(self):\r\n pass","def time_now():\n return datetime.datetime.now().time()","def time(self):\r\n raise NotImplementedError","def now():\n\treturn time.time() * 1000","def time(self):\n raise NotImplementedError()","def GetTime(self):\n return self.hour, self.minute, self.second","def getCurrentTime():\n\tnow = datetime.datetime.now()\n\thr = now.hour\n\tgreeting = \"\"\n\tampm = \"\"\n\tif (hr < 12): #morning\n\t\thr = hr\n\t\tgreeting = \"morning\"\n\t\tampm = \"am\"\n\telif (hr >= 12 and hr < 1): #afternoon\n\t\thr = hr\n\t\tgreeting = \"afternoon\"\n\t\tampm = \"noon\"\n\telif (hr > 12 and hr < 19): #evening\n\t\thr = hr - 12\n\t\tgreeting = \"evening\"\n\t\tampm = \"pm\"\n\telse: #night\n\t\thr = hr - 12\n\t\tgreeting = \"night\"\n\t\tampm = \"pm\"\n\treturn str(hr) + ':' + str(now.minute),ampm, ' in the ', greeting","def getTimeRegime(*args):\n return args[0].TimeState.TimeRegime.time_regime","def GetMonotime():\n return float(open(PROC_UPTIME).read().split()[0])","async def time(self) -> dt.time:\n now = await self.AD.sched.get_now()\n return now.astimezone(self.AD.tz).time()","def get_time(self):\n\t\treturn time.time()","def show_time(self):\n hour = str(datetime.datetime.now().strftime(\"%H\"))\n minute = str(datetime.datetime.now().strftime(\"%M\"))\n\n hour1 = int(hour[0])\n hour2 = int(hour[1])\n minute1 = int(minute[0])\n minute2 = int(minute[1])\n\n self.light_number(self.numbers[hour1], [0, 5])\n self.light_number(self.numbers[hour2], [0, 0])\n self.light_number(self.numbers[minute1], [5, 5])\n self.light_number(self.numbers[minute2], [5, 0])","def now():\n print(strftime(\"%Y-%m-%d %H:%M:%S\", gmtime()))","def service_time(self):\r\n #print self.node_monitor_address, self.completion_time - self.node_monitor_launch_time\r\n return (self.completion_time - self.node_monitor_launch_time)","def get_times():\n server = datetime.datetime.now().astimezone()\n local = server.astimezone(dwx.dwx_tz())\n target = post_time_today(local)\n return {'server': server, 'local': local, 'target': target}","def get_time(self):\r\n\t\tactual_time = '{}, {} de {} del {} ({}:{} {} (UTC))'\r\n\t\tda_taim = actual_time.format(self.wday, self.day, self.mon,\r\n\t\t\t\t\t\t\t\t\t self.year, self.hour, self.min,\r\n\t\t\t\t\t\t\t\t\t self.day_or_night)\r\n\t\treturn da_taim","def now():\r\n return time.time()","def time_cmd(args):\n result = requete(\"Time:getTime\")\n if result:\n t = result['data']['time']\n result = requete(\"Time:getLocalTimeZoneName\")\n tz = result['data']['timezone']\n print(\"Livebox time: {} ({})\".format(t, tz))","def mean_time():\n return render_template('mean_time_weekday.html')","def time(self):\n return parse_time(self['timestamp'])","def reportTimes(self):\n outputTime = \"Global Time\\t\"+str(self.globalTime/ 60.0)+ \\\n \"\\nMatching Time\\t\" + str(self.globalMatching/ 60.0)+ \\\n \"\\nDeletion Time\\t\" + str(self.globalDeletion/ 60.0)+ \\\n \"\\nSubsumption Time\\t\" + str(self.globalSubsumption/ 60.0)+ \\\n \"\\nSelection Time\\t\"+str(self.globalSelection/ 60.0)+ \\\n \"\\nEvaluation Time\\t\"+str(self.globalEvaluation/ 60.0) + \"\\n\"\n\n return outputTime","def get_current_time() -> int:\n hour_min = datetime.now(\n pytz.timezone('US/Eastern')\n ).strftime(\"%H,%M\").split(',')\n\n return int(''.join(hour_min))","def now(time):\n a = datetime.fromtimestamp(time).strftime('%Y-%m-%d %H:%M:%S')\n return a","def now(time):\n a = datetime.fromtimestamp(time).strftime('%Y-%m-%d %H:%M:%S')\n return a","def now():\n result = query_db('SELECT * FROM climate ORDER BY time DESC LIMIT 1;', one=True)\n return jsonify(result)","def get_time(self):\n return self.time","def dns_fetch_time(self) -> str:\n return pulumi.get(self, \"dns_fetch_time\")","def __init__(self, hour, minute=0, second=0, microsecond=0, tzinfo=None):","def get_time():\r\n \r\n dt = datetime.datetime.now()\r\n dt_parsed = dt.strftime(\"%Y-%m-%d %H:%M:%S\")\r\n return dt_parsed","def time_at_server():\n return time.asctime()","def local_time(self) -> SmartNvmeLocalTime:\n return self._local_time","def test_time(self):\n result = self.test_client.time\n\n assert result == \"15093049123\"","def time(self):\n return time(\n self.hour, self.minute, self.second, self.microsecond, fold=self.fold\n )","def get_time(self):\n return ''","def time(self) -> Optional[str]:\n return pulumi.get(self, \"time\")","def time(self) -> Optional[str]:\n return pulumi.get(self, \"time\")","def time(self) -> Optional[str]:\n return pulumi.get(self, \"time\")","def time(self) -> Optional[str]:\n return pulumi.get(self, \"time\")","def time(self) -> Optional[str]:\n return pulumi.get(self, \"time\")","def time(self) -> Optional[str]:\n return pulumi.get(self, \"time\")","def _timestamp_now(self) -> str:\n date_now = datetime.utcnow().replace(tzinfo=timezone(\"UTC\"))\n if self._app_conf[\"aiscalator\"]:\n pst = timezone(self.app_config().timezone)\n else:\n pst = timezone('Europe/Paris')\n return date_now.astimezone(pst).strftime(\"%Y%m%d%H%M%S\")","def _time(self):\n return self.r.eval(self.LUA_TIME, 1, 1)","def get_time(self):\n return self.get_timed() / 10.0","def get_now_time():\r\n return '[' + datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f') + ']: '","def time_stats(df, city, month, day):\n\n print(f'\\nCalculating The Most Frequent Times of Travel in {city.title()}...\\n')\n start_time = time.time()\n\n # TO DO: display the most common month and change display from (int) to (str)\n popular_month_int = df['month'].mode()[0]\n\n months = pd.Series(data=['January', 'February', 'March', 'April', 'May', 'June'],\n index=[1, 2, 3, 4, 5, 6])\n\n popular_month = months[popular_month_int]\n\n # TO DO: display the most common day of week\n popular_day_of_week = df['day_of_week'].mode()[0]\n\n # TO DO: display the most common start hour in military time\n df['hour'] = df['Start Time'].dt.hour\n popular_hour = df['hour'].mode()[0]\n\n #Reformat 'popular_hour' from military time to standard time\n if popular_hour <= 11:\n popular_hour = str(popular_hour) + ' AM'\n elif popular_hour == 12:\n popular_hour = str(popular_hour) + ' noon'\n elif popular_hour > 12 and popular_hour <= 23:\n popular_hour = str((popular_hour - 12)) + ' PM'\n elif popular_hour == 24:\n popular_hour = str(popular_hour) + ' midnight'\n\n #Print most popular month if user selected 'all'\n if month == 'all' and day == 'all':\n print(f'The most popular month to travel is {popular_month}.')\n elif month == 'all' and day != 'all':\n print(f'The most popular month to travel on a {day.title()} is {popular_month}.')\n\n #Print most popular day if user selected 'all'\n if month == 'all' and day == 'all':\n print(f'The most popular day of the week to travel is {popular_day_of_week}.')\n elif month != 'all' and day == 'all':\n print(f'The most popular day of the week to travel in {popular_month} is {popular_day_of_week}.')\n\n #Print most popular hour, phrasing based on month and/or day == 'all' or != 'all'\n if month == 'all' and day == 'all':\n print(f'The most popular hour to travel is {popular_hour}.')\n elif month == 'all' and day != 'all':\n print(f'The most popular hour to travel on a {day.title()} is {popular_hour}.')\n elif month != 'all' and day == 'all':\n print(f'The most popular hour to travel in {popular_month} is {popular_hour}.')\n elif month != 'all' and day != 'all':\n print(f'The most popular hour to travel in {popular_month} on a {day.title()} is {popular_hour}.')\n\n print(f'\\nThis took {time.time() - start_time}s seconds.')\n print('-'*40)","def get_time(self):\n now = datetime.datetime.now()\n hour = 12 if now.hour % 12 == 0 else now.hour % 12\n meridiem = \"AM\" if now.hour < 12 else \"PM\"\n return \"%d:%02d %s\" % (hour, now.minute, meridiem)","def var(self):\n\n return time_stat(self, stat=\"var\")","def now():\n now = datetime.datetime.now()\n return \"%04d-%02d-%02d %02d:%02d:%02d.%03d\" % ( now.year, now.month,now.day,\n now.hour,now.minute,now.second,int(now.microsecond/1e3))"],"string":"[\n \"def get_time(self):\\n return self.run_command('get_time')[0]\",\n \"def timezone():\\n \\n pass\",\n \"def get_time_info(self):\\n\\n raise NotImplementedError\",\n \"def get_nightly_start_time():\\n return 14 # 2PM local Tucson time\",\n \"def get_time():\\n # Use this one for production:\\n now_time = pendulum.now(tz=pendulum.timezone(\\\"America/New_York\\\"))\\n # Use this one for testing and modify as needed:\\n # now_time = pendulum.datetime(2019, 7, 21, 20, 00, tz='America/New_York')\\n\\n return now_time\",\n \"def get_time() -> int:\\n return store.time\",\n \"def current_time(cls) -> float:\",\n \"async def server_time(self):\\n uri = \\\"/v3/time\\\"\\n success, error = await self.request(\\\"GET\\\", uri)\\n return success, error\",\n \"def get_current_india_time():\\n india_offset = datetime.timedelta(hours=5, minutes=30)\\n in_time = datetime.datetime.utcnow() + india_offset\\n return in_time\",\n \"def get_time():\\r\\n return datetime.datetime.now().strftime(\\\"%H\\\")+\\\":\\\"+datetime.datetime.now().strftime(\\\"%M\\\")+\\\":\\\"+datetime.datetime.now().strftime(\\\"%S\\\")\",\n \"def getTime(self, request, context):\\n\\t\\t\\n date = re.split(\\\"\\\\s\\\", datetime.utcnow().strftime(\\\"%Y %m %d %H %M %S\\\"))\\n\\n return droneconnect_pb2.Time(year = int(date[0]), month = int(date[1]), day = int(date[2]), hour = int(date[3]), minute = int(date[4]), second = int(date[5]))\",\n \"def get_time() -> dict:\\n prague = pytz.timezone('Europe/Prague')\\n now = prague.localize(datetime.now())\\n fmt = '%H:%M'\\n au_tz = pytz.timezone('Australia/Sydney')\\n sydney = now.astimezone(au_tz).strftime(fmt)\\n lon_tz = pytz.timezone('Europe/London')\\n london = now.astimezone(lon_tz).strftime(fmt)\\n ny_tz = pytz.timezone('US/Eastern')\\n ny = now.astimezone(ny_tz).strftime(fmt)\\n sf_tz = pytz.timezone('US/Pacific')\\n sf = now.astimezone(sf_tz).strftime(fmt)\\n return {\\\"sydney\\\": sydney, \\\"london\\\": london, \\\"ny\\\": ny, \\\"sf\\\": sf}\",\n \"def get_hourly(self):\\n pass\",\n \"async def server_time(self):\\n uri = \\\"/fapi/v1/time\\\"\\n success, error = await self.request(\\\"GET\\\", uri)\\n return success, error\",\n \"def get_time(self):\\n start=''\\n end=''\\n time=''\\n times=self.times\\n print(times[self.istep])\\n if self.istep > 0:\\n start=ncEarth.beginstr % times[self.istep].isoformat()\\n\\n\\n if self.istep < len(times)-2:\\n end = ncEarth.endstr % times[self.istep+1].isoformat()\\n\\n if start is not '' or end is not '':\\n time=ncEarth.timestr % {'begin':start,'end':end}\\n\\n return time\",\n \"def proxy_hours_minutes(self):\\n\\n td = self.convert_last_col_filtered()\\n resultat = td.days * 24 + td.seconds // 3600, (td.seconds // 60) % 60\\n # print('{} H {} M'.format(*resultat))\\n print(resultat)\\n return resultat\",\n \"def running_custom_hour(arg):\\n pass\",\n \"def get_time():\\n\\teastern = timezone('US/Eastern')\\n\\tnow = datetime.datetime.now(eastern).time()\\n\\treturn(now)\",\n \"def get_region_updated_time(self):\",\n \"def getTime(self):\\n return self.time\",\n \"def now(self):\\n os.environ['TZ'] = conf.timezone\\n time.tzset()\\n return time.strftime(\\\"%B %d %Y %H:%M:%S IST\\\", time.localtime())\",\n \"def currentTime():\\n return strftime(\\\"%H:%M:%S\\\", time.localtime())\",\n \"def time():\\n _check_init()\\n return _pypm.Time()\",\n \"def time_now():\\n return time.time()\",\n \"def get_time(self):\\n return datetime.datetime.now(self.time_zone)\",\n \"def local_time():\\n return datetime.datetime.now().isoformat()[:len('2017-01-24T10:44:00')]\",\n \"def GetTime(self, *args, **kwargs):\\n pass\",\n \"def public_get_time(x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):\\n request = PublicGetTime.create()\\n return run_request(request, additional_headers=x_additional_headers, **kwargs)\",\n \"def time(self):\\n return self.raw[\\\"logTime\\\"]\",\n \"def time():\\n return datetime.datetime.now().strftime(\\\"%Y%m%dT%H%M%SZ\\\")\",\n \"def get_system_date_time():\\n query = {\\\"type\\\": \\\"op\\\", \\\"cmd\\\": \\\"<show><clock></clock></show>\\\"}\\n\\n return __proxy__[\\\"panos.call\\\"](query)\",\n \"def get_time():\\n return datetime.datetime.now()\",\n \"def polls_open(self):\\n if self.is_city_of_london:\\n return datetime.time(8, 0)\\n\\n return datetime.time(7, 0)\",\n \"def get_time(self) -> float:\\n raise NotImplementedError()\",\n \"def servertime(self):\\r\\n return servertime.Servertime(self)\",\n \"def now(self, request):\\n identity = self.bot.get_plugin('identity').get_identity_by_request(request)\\n\\n now = times.now()\\n tz = self._get_user_timezone(identity)\\n local = times.to_local(now, tz)\\n\\n request.respond('Server time: {}\\\\nLocal time:{}'.format(now, local))\",\n \"def get_hours_per_unit_snap(now):\\n print(\\\"/\\\"*50)\\n print(\\\"GET hours_per_unit SNAP\\\")\\n print(\\\"/\\\"*50)\\n plant_settings = PlantSetting.objects.latest('timestamp')\\n # print(\\\"SETINGS\\\",settings.timestamp)\\n print(\\\"NOW: \\\", now)\\n # preventing processing data before start of defined shift\\n start, shift = get_shift_info(plant_settings, now)\\n print(\\\"Start: \\\", start)\\n print(\\\"Shift: \\\", shift)\\n\\n if start > now:\\n print(\\\"NOT IN SHIFT\\\")\\n return\\n hours_per_unit_dict = main(start, now)\\n hours_per_unit_dict['shift'] = shift\\n\\n return hours_per_unit_dict\",\n \"def main(format):\\n print(pendulum.now().format(format))\",\n \"def get_time():\\n return {\\n 'timestamp': datetime.now()+ timedelta(hours=-1)\\n }\",\n \"def _get_timebase(self):\\n return clock()\",\n \"def _get_timebase(self):\\n return clock()\",\n \"def now():\\n return utcfromtimestamp(time.time())\",\n \"def cpu_time(self):\",\n \"def time_stats(df, month, day):\\n\\n print('\\\\nCalculating The Most regular Times of Travelling\\\\n Loading Please wait for a while ........\\\\n')\\n start_time = time.time()\\n\\n # display the most common month\\n if(month == 'all'):\\n most_similar_month = df['Start Time'].dt.month.value_counts().idxmax()\\n print('******************** Most common(popular) month is :'+ str(most_similar_month) + ' *********************')\\n\\n # display the most common day of week\\n if(day == 'all'):\\n most_similar_day = df['Start Time'].dt.weekday_name.value_counts().idxmax()\\n print('******************** Most common(popular) day is : ' + str(most_similar_day) + ' *********************')\\n\\n # display the most common start hour\\n most_similar_hour = df['Start Time'].dt.hour.value_counts().idxmax()\\n print('******************** Most popular hour is : ' + str(most_similar_hour) + ' *********************')\\n\\n print(\\\"\\\\n******************** This took %s seconds. *********************\\\" % (time.time() - start_time))\\n print('-'*40)\",\n \"def Timer():\\n ltime = time.localtime()\\n h, m, s = ltime[3:6]\\n return h * 3600.0 + m * 60.0 + s\",\n \"def GetTime():\\n import ntptime\\n ntptime.settime()\\n ts = time.localtime()\\n year = ts[0]\\n Month = ts[1]\\n day = ts[2]\\n hour = ts[3]\\n mins = ts[4]\\n dayYear = ts[7]\\n ActualTime = \\\"%s/%s/%s %s:%s\\\" % (str(day), str(Month), str(year), str(hour), str(mins))\\n return ActualTime\",\n \"def gettime(self):\\n return self.t\",\n \"def hour():\\r\\n\\r\\n date = datetime.datetime.now()\\r\\n hours = date.hour\\r\\n minute = date.minute\\r\\n\\r\\n return hours, minute\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def gettime():\\n return libruss.russ_gettime()\",\n \"def test_time(self):\\r\\n pass\",\n \"def time_now():\\n return datetime.datetime.now().time()\",\n \"def time(self):\\r\\n raise NotImplementedError\",\n \"def now():\\n\\treturn time.time() * 1000\",\n \"def time(self):\\n raise NotImplementedError()\",\n \"def GetTime(self):\\n return self.hour, self.minute, self.second\",\n \"def getCurrentTime():\\n\\tnow = datetime.datetime.now()\\n\\thr = now.hour\\n\\tgreeting = \\\"\\\"\\n\\tampm = \\\"\\\"\\n\\tif (hr < 12): #morning\\n\\t\\thr = hr\\n\\t\\tgreeting = \\\"morning\\\"\\n\\t\\tampm = \\\"am\\\"\\n\\telif (hr >= 12 and hr < 1): #afternoon\\n\\t\\thr = hr\\n\\t\\tgreeting = \\\"afternoon\\\"\\n\\t\\tampm = \\\"noon\\\"\\n\\telif (hr > 12 and hr < 19): #evening\\n\\t\\thr = hr - 12\\n\\t\\tgreeting = \\\"evening\\\"\\n\\t\\tampm = \\\"pm\\\"\\n\\telse: #night\\n\\t\\thr = hr - 12\\n\\t\\tgreeting = \\\"night\\\"\\n\\t\\tampm = \\\"pm\\\"\\n\\treturn str(hr) + ':' + str(now.minute),ampm, ' in the ', greeting\",\n \"def getTimeRegime(*args):\\n return args[0].TimeState.TimeRegime.time_regime\",\n \"def GetMonotime():\\n return float(open(PROC_UPTIME).read().split()[0])\",\n \"async def time(self) -> dt.time:\\n now = await self.AD.sched.get_now()\\n return now.astimezone(self.AD.tz).time()\",\n \"def get_time(self):\\n\\t\\treturn time.time()\",\n \"def show_time(self):\\n hour = str(datetime.datetime.now().strftime(\\\"%H\\\"))\\n minute = str(datetime.datetime.now().strftime(\\\"%M\\\"))\\n\\n hour1 = int(hour[0])\\n hour2 = int(hour[1])\\n minute1 = int(minute[0])\\n minute2 = int(minute[1])\\n\\n self.light_number(self.numbers[hour1], [0, 5])\\n self.light_number(self.numbers[hour2], [0, 0])\\n self.light_number(self.numbers[minute1], [5, 5])\\n self.light_number(self.numbers[minute2], [5, 0])\",\n \"def now():\\n print(strftime(\\\"%Y-%m-%d %H:%M:%S\\\", gmtime()))\",\n \"def service_time(self):\\r\\n #print self.node_monitor_address, self.completion_time - self.node_monitor_launch_time\\r\\n return (self.completion_time - self.node_monitor_launch_time)\",\n \"def get_times():\\n server = datetime.datetime.now().astimezone()\\n local = server.astimezone(dwx.dwx_tz())\\n target = post_time_today(local)\\n return {'server': server, 'local': local, 'target': target}\",\n \"def get_time(self):\\r\\n\\t\\tactual_time = '{}, {} de {} del {} ({}:{} {} (UTC))'\\r\\n\\t\\tda_taim = actual_time.format(self.wday, self.day, self.mon,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t self.year, self.hour, self.min,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t self.day_or_night)\\r\\n\\t\\treturn da_taim\",\n \"def now():\\r\\n return time.time()\",\n \"def time_cmd(args):\\n result = requete(\\\"Time:getTime\\\")\\n if result:\\n t = result['data']['time']\\n result = requete(\\\"Time:getLocalTimeZoneName\\\")\\n tz = result['data']['timezone']\\n print(\\\"Livebox time: {} ({})\\\".format(t, tz))\",\n \"def mean_time():\\n return render_template('mean_time_weekday.html')\",\n \"def time(self):\\n return parse_time(self['timestamp'])\",\n \"def reportTimes(self):\\n outputTime = \\\"Global Time\\\\t\\\"+str(self.globalTime/ 60.0)+ \\\\\\n \\\"\\\\nMatching Time\\\\t\\\" + str(self.globalMatching/ 60.0)+ \\\\\\n \\\"\\\\nDeletion Time\\\\t\\\" + str(self.globalDeletion/ 60.0)+ \\\\\\n \\\"\\\\nSubsumption Time\\\\t\\\" + str(self.globalSubsumption/ 60.0)+ \\\\\\n \\\"\\\\nSelection Time\\\\t\\\"+str(self.globalSelection/ 60.0)+ \\\\\\n \\\"\\\\nEvaluation Time\\\\t\\\"+str(self.globalEvaluation/ 60.0) + \\\"\\\\n\\\"\\n\\n return outputTime\",\n \"def get_current_time() -> int:\\n hour_min = datetime.now(\\n pytz.timezone('US/Eastern')\\n ).strftime(\\\"%H,%M\\\").split(',')\\n\\n return int(''.join(hour_min))\",\n \"def now(time):\\n a = datetime.fromtimestamp(time).strftime('%Y-%m-%d %H:%M:%S')\\n return a\",\n \"def now(time):\\n a = datetime.fromtimestamp(time).strftime('%Y-%m-%d %H:%M:%S')\\n return a\",\n \"def now():\\n result = query_db('SELECT * FROM climate ORDER BY time DESC LIMIT 1;', one=True)\\n return jsonify(result)\",\n \"def get_time(self):\\n return self.time\",\n \"def dns_fetch_time(self) -> str:\\n return pulumi.get(self, \\\"dns_fetch_time\\\")\",\n \"def __init__(self, hour, minute=0, second=0, microsecond=0, tzinfo=None):\",\n \"def get_time():\\r\\n \\r\\n dt = datetime.datetime.now()\\r\\n dt_parsed = dt.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\r\\n return dt_parsed\",\n \"def time_at_server():\\n return time.asctime()\",\n \"def local_time(self) -> SmartNvmeLocalTime:\\n return self._local_time\",\n \"def test_time(self):\\n result = self.test_client.time\\n\\n assert result == \\\"15093049123\\\"\",\n \"def time(self):\\n return time(\\n self.hour, self.minute, self.second, self.microsecond, fold=self.fold\\n )\",\n \"def get_time(self):\\n return ''\",\n \"def time(self) -> Optional[str]:\\n return pulumi.get(self, \\\"time\\\")\",\n \"def time(self) -> Optional[str]:\\n return pulumi.get(self, \\\"time\\\")\",\n \"def time(self) -> Optional[str]:\\n return pulumi.get(self, \\\"time\\\")\",\n \"def time(self) -> Optional[str]:\\n return pulumi.get(self, \\\"time\\\")\",\n \"def time(self) -> Optional[str]:\\n return pulumi.get(self, \\\"time\\\")\",\n \"def time(self) -> Optional[str]:\\n return pulumi.get(self, \\\"time\\\")\",\n \"def _timestamp_now(self) -> str:\\n date_now = datetime.utcnow().replace(tzinfo=timezone(\\\"UTC\\\"))\\n if self._app_conf[\\\"aiscalator\\\"]:\\n pst = timezone(self.app_config().timezone)\\n else:\\n pst = timezone('Europe/Paris')\\n return date_now.astimezone(pst).strftime(\\\"%Y%m%d%H%M%S\\\")\",\n \"def _time(self):\\n return self.r.eval(self.LUA_TIME, 1, 1)\",\n \"def get_time(self):\\n return self.get_timed() / 10.0\",\n \"def get_now_time():\\r\\n return '[' + datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f') + ']: '\",\n \"def time_stats(df, city, month, day):\\n\\n print(f'\\\\nCalculating The Most Frequent Times of Travel in {city.title()}...\\\\n')\\n start_time = time.time()\\n\\n # TO DO: display the most common month and change display from (int) to (str)\\n popular_month_int = df['month'].mode()[0]\\n\\n months = pd.Series(data=['January', 'February', 'March', 'April', 'May', 'June'],\\n index=[1, 2, 3, 4, 5, 6])\\n\\n popular_month = months[popular_month_int]\\n\\n # TO DO: display the most common day of week\\n popular_day_of_week = df['day_of_week'].mode()[0]\\n\\n # TO DO: display the most common start hour in military time\\n df['hour'] = df['Start Time'].dt.hour\\n popular_hour = df['hour'].mode()[0]\\n\\n #Reformat 'popular_hour' from military time to standard time\\n if popular_hour <= 11:\\n popular_hour = str(popular_hour) + ' AM'\\n elif popular_hour == 12:\\n popular_hour = str(popular_hour) + ' noon'\\n elif popular_hour > 12 and popular_hour <= 23:\\n popular_hour = str((popular_hour - 12)) + ' PM'\\n elif popular_hour == 24:\\n popular_hour = str(popular_hour) + ' midnight'\\n\\n #Print most popular month if user selected 'all'\\n if month == 'all' and day == 'all':\\n print(f'The most popular month to travel is {popular_month}.')\\n elif month == 'all' and day != 'all':\\n print(f'The most popular month to travel on a {day.title()} is {popular_month}.')\\n\\n #Print most popular day if user selected 'all'\\n if month == 'all' and day == 'all':\\n print(f'The most popular day of the week to travel is {popular_day_of_week}.')\\n elif month != 'all' and day == 'all':\\n print(f'The most popular day of the week to travel in {popular_month} is {popular_day_of_week}.')\\n\\n #Print most popular hour, phrasing based on month and/or day == 'all' or != 'all'\\n if month == 'all' and day == 'all':\\n print(f'The most popular hour to travel is {popular_hour}.')\\n elif month == 'all' and day != 'all':\\n print(f'The most popular hour to travel on a {day.title()} is {popular_hour}.')\\n elif month != 'all' and day == 'all':\\n print(f'The most popular hour to travel in {popular_month} is {popular_hour}.')\\n elif month != 'all' and day != 'all':\\n print(f'The most popular hour to travel in {popular_month} on a {day.title()} is {popular_hour}.')\\n\\n print(f'\\\\nThis took {time.time() - start_time}s seconds.')\\n print('-'*40)\",\n \"def get_time(self):\\n now = datetime.datetime.now()\\n hour = 12 if now.hour % 12 == 0 else now.hour % 12\\n meridiem = \\\"AM\\\" if now.hour < 12 else \\\"PM\\\"\\n return \\\"%d:%02d %s\\\" % (hour, now.minute, meridiem)\",\n \"def var(self):\\n\\n return time_stat(self, stat=\\\"var\\\")\",\n \"def now():\\n now = datetime.datetime.now()\\n return \\\"%04d-%02d-%02d %02d:%02d:%02d.%03d\\\" % ( now.year, now.month,now.day,\\n now.hour,now.minute,now.second,int(now.microsecond/1e3))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59689367","0.59094346","0.5783251","0.57631344","0.57395995","0.5718757","0.5704612","0.5699259","0.56886494","0.5673247","0.5653273","0.5640289","0.56305677","0.558655","0.5577585","0.5576624","0.5555275","0.55360794","0.5501735","0.54946667","0.54841834","0.5471897","0.54671633","0.5459717","0.5451538","0.5450219","0.5445872","0.5439762","0.5433319","0.5431507","0.542956","0.5428717","0.54037255","0.5403576","0.54014385","0.5394462","0.538402","0.5383772","0.5377453","0.5373008","0.5373008","0.536954","0.53538597","0.5344818","0.5341487","0.53375113","0.5334037","0.533198","0.532815","0.532815","0.532815","0.5325116","0.53232104","0.53169364","0.5303422","0.5301835","0.529648","0.5291779","0.52810204","0.52806956","0.5267069","0.5259417","0.525842","0.52569556","0.525366","0.52453315","0.52441025","0.5237635","0.52310026","0.5218087","0.52152276","0.52111554","0.5207258","0.5202685","0.51967216","0.51967216","0.5194721","0.5186048","0.5185192","0.5183773","0.5182927","0.5180527","0.517831","0.51746684","0.5173069","0.5172935","0.51669586","0.51669586","0.51669586","0.51669586","0.51669586","0.51669586","0.5164238","0.51615244","0.515731","0.5155376","0.5154596","0.5154069","0.5153556","0.5138338"],"string":"[\n \"0.59689367\",\n \"0.59094346\",\n \"0.5783251\",\n \"0.57631344\",\n \"0.57395995\",\n \"0.5718757\",\n \"0.5704612\",\n \"0.5699259\",\n \"0.56886494\",\n \"0.5673247\",\n \"0.5653273\",\n \"0.5640289\",\n \"0.56305677\",\n \"0.558655\",\n \"0.5577585\",\n \"0.5576624\",\n \"0.5555275\",\n \"0.55360794\",\n \"0.5501735\",\n \"0.54946667\",\n \"0.54841834\",\n \"0.5471897\",\n \"0.54671633\",\n \"0.5459717\",\n \"0.5451538\",\n \"0.5450219\",\n \"0.5445872\",\n \"0.5439762\",\n \"0.5433319\",\n \"0.5431507\",\n \"0.542956\",\n \"0.5428717\",\n \"0.54037255\",\n \"0.5403576\",\n \"0.54014385\",\n \"0.5394462\",\n \"0.538402\",\n \"0.5383772\",\n \"0.5377453\",\n \"0.5373008\",\n \"0.5373008\",\n \"0.536954\",\n \"0.53538597\",\n \"0.5344818\",\n \"0.5341487\",\n \"0.53375113\",\n \"0.5334037\",\n \"0.533198\",\n \"0.532815\",\n \"0.532815\",\n \"0.532815\",\n \"0.5325116\",\n \"0.53232104\",\n \"0.53169364\",\n \"0.5303422\",\n \"0.5301835\",\n \"0.529648\",\n \"0.5291779\",\n \"0.52810204\",\n \"0.52806956\",\n \"0.5267069\",\n \"0.5259417\",\n \"0.525842\",\n \"0.52569556\",\n \"0.525366\",\n \"0.52453315\",\n \"0.52441025\",\n \"0.5237635\",\n \"0.52310026\",\n \"0.5218087\",\n \"0.52152276\",\n \"0.52111554\",\n \"0.5207258\",\n \"0.5202685\",\n \"0.51967216\",\n \"0.51967216\",\n \"0.5194721\",\n \"0.5186048\",\n \"0.5185192\",\n \"0.5183773\",\n \"0.5182927\",\n \"0.5180527\",\n \"0.517831\",\n \"0.51746684\",\n \"0.5173069\",\n \"0.5172935\",\n \"0.51669586\",\n \"0.51669586\",\n \"0.51669586\",\n \"0.51669586\",\n \"0.51669586\",\n \"0.51669586\",\n \"0.5164238\",\n \"0.51615244\",\n \"0.515731\",\n \"0.5155376\",\n \"0.5154596\",\n \"0.5154069\",\n \"0.5153556\",\n \"0.5138338\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5973397"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76078,"cells":{"query":{"kind":"string","value":"Return the scoreboard information for games matching the parameters as a dictionary."},"document":{"kind":"string","value":"def scoreboard(year, month, day):\n # Get data from mlbgame library\n data = mlbgame.data.get_scoreboard(year, month, day)\n # Parse through returned data\n parsed = etree.parse(data)\n root = parsed.getroot()\n output = []\n # Loop through the list of games that are returned\n for game in root:\n if game.tag == 'data':\n return []\n # Get the Team Names\n teams = game.findall('team')\n home_name = teams[0].attrib['name']\n away_name = teams[1].attrib['name']\n # Building a dictionary\n # I am really only interested in the scores.... not sure if\n # game_id is actually necessary....but here it stays\n game_data = game.find('game')\n game_id = game_data.attrib['id']\n home_team_data = teams[0].find('gameteam')\n home_team = home_name\n home_team_runs = int(home_team_data.attrib['R'])\n away_team_data = teams[1].find('gameteam')\n away_team = away_name\n away_team_runs = int(away_team_data.attrib['R'])\n score = {\n 'home_team': home_team,\n 'home_team_runs': home_team_runs,\n 'away_team': away_team,\n 'away_team_runs': away_team_runs\n }\n output.append(score)\n return output"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def scoreboard(year, month, day, home=None, away=None):\n # get data\n data = mlbgame.data.get_scoreboard(year, month, day)\n # parse data\n parsed = etree.parse(data)\n root = parsed.getroot()\n games = {}\n output = {}\n # loop through games\n for game in root:\n if game.tag == 'data':\n return []\n # get team names\n teams = game.findall('team')\n home_name = teams[0].attrib['name']\n away_name = teams[1].attrib['name']\n # check if teams match parameters\n if (home_name == home and home is not None) \\\n or (away_name == away and away is not None) \\\n or (away is None and home is None):\n # throw all the data into a complicated dictionary\n game_tag = game.tag\n game_data = game.find('game')\n game_id = game_data.attrib['id']\n game_league = game_data.attrib['league']\n game_status = game_data.attrib['status']\n game_start_time = game_data.attrib['start_time']\n home_team_data = teams[0].find('gameteam')\n home_team = home_name\n home_team_runs = int(home_team_data.attrib['R'])\n home_team_hits = int(home_team_data.attrib['H'])\n home_team_errors = int(home_team_data.attrib['E'])\n away_team_data = teams[1].find('gameteam')\n away_team = away_name\n away_team_runs = int(away_team_data.attrib['R'])\n away_team_hits = int(away_team_data.attrib['H'])\n away_team_errors = int(away_team_data.attrib['E'])\n # check type of game\n if game_tag == 'go_game' or game_tag == 'ig_game':\n try:\n w_pitcher_data = game.find('w_pitcher')\n w_pitcher = w_pitcher_data.find('pitcher').attrib['name']\n w_pitcher_wins = int(w_pitcher_data.attrib['wins'])\n w_pitcher_losses = int(w_pitcher_data.attrib['losses'])\n except Exception:\n w_pitcher = \"\"\n w_pitcher_wins = 0\n w_pitcher_losses = 0\n try:\n l_pitcher_data = game.find('l_pitcher')\n l_pitcher = l_pitcher_data.find('pitcher').attrib['name']\n l_pitcher_wins = int(l_pitcher_data.attrib['wins'])\n l_pitcher_losses = int(l_pitcher_data.attrib['losses'])\n except Exception:\n l_pitcher = \"\"\n l_pitcher_wins = 0\n l_pitcher_losses = 0\n try:\n sv_pitcher_data = game.find('sv_pitcher')\n sv_pitcher = sv_pitcher_data.find('pitcher').attrib['name']\n sv_pitcher_saves = int(sv_pitcher_data.attrib['saves'])\n except Exception:\n sv_pitcher = \"\"\n sv_pitcher_saves = 0\n output = {\n 'game_id': game_id,\n 'game_tag': game_tag,\n 'game_league': game_league,\n 'game_status': game_status,\n 'game_start_time': game_start_time,\n 'home_team': home_team,\n 'home_team_runs': home_team_runs,\n 'home_team_hits': home_team_hits,\n 'home_team_errors': home_team_errors,\n 'away_team': away_team,\n 'away_team_runs': away_team_runs,\n 'away_team_hits': away_team_hits,\n 'away_team_errors': away_team_errors,\n 'w_pitcher': w_pitcher,\n 'w_pitcher_wins': w_pitcher_wins,\n 'w_pitcher_losses': w_pitcher_losses,\n 'l_pitcher': l_pitcher,\n 'l_pitcher_wins': l_pitcher_wins,\n 'l_pitcher_losses': l_pitcher_losses,\n 'sv_pitcher': sv_pitcher,\n 'sv_pitcher_saves': sv_pitcher_saves\n }\n # games that were not played\n elif game_tag == 'sg_game':\n try:\n p_pitcher_data = game.findall('p_pitcher')\n p_pitcher_home_data = p_pitcher_data[0]\n p_pitcher_home = p_pitcher_home_data.find(\n 'pitcher').attrib['name']\n p_pitcher_home_wins = int(p_pitcher_home_data.\n attrib['wins'])\n p_pitcher_home_losses = int(p_pitcher_home_data.\n attrib['losses'])\n p_pitcher_away_data = p_pitcher_data[1]\n p_pitcher_away = p_pitcher_away_data.find(\n 'pitcher').attrib['name']\n p_pitcher_away_wins = int(p_pitcher_away_data.\n attrib['wins'])\n p_pitcher_away_losses = int(p_pitcher_away_data.\n attrib['losses'])\n except Exception:\n p_pitcher_home = ''\n p_pitcher_home_wins = 0\n p_pitcher_home_losses = 0\n p_pitcher_away = ''\n p_pitcher_away_wins = 0\n p_pitcher_away_losses = 0\n output = {\n 'game_id': game_id,\n 'game_tag': game_tag,\n 'game_league': game_league,\n 'game_status': game_status,\n 'game_start_time': game_start_time,\n 'home_team': home_team,\n 'home_team_runs': home_team_runs,\n 'home_team_hits': home_team_hits,\n 'home_team_errors': home_team_errors,\n 'away_team': away_team,\n 'away_team_runs': away_team_runs,\n 'away_team_hits': away_team_hits,\n 'away_team_errors': away_team_errors,\n 'p_pitcher_home': p_pitcher_home,\n 'p_pitcher_home_wins': p_pitcher_home_wins,\n 'p_pitcher_home_losses': p_pitcher_home_losses,\n 'p_pitcher_away': p_pitcher_away,\n 'p_pitcher_away_wins': p_pitcher_away_wins,\n 'p_pitcher_away_losses': p_pitcher_away_losses\n }\n # put this dictionary into the larger dictionary\n games[game_id] = output\n return games","def get_matched_game_ranking_info_for_game(app_id: str) -> Dict[str, int]:\n query_res = Game.query.filter_by(app_id=app_id).all()\n if query_res:\n return eval(query_res[0].games_title_match)\n return dict()","def get_games(date):\n scoreboard = nba_py.Scoreboard(month=date.month,\n day=date.day,\n year=date.year)\n line_score = scoreboard.line_score()\n game_header = scoreboard.game_header()\n\n games = []\n current_game = {}\n game_sequence = 0\n game_sequence_counter = 0\n\n # Get HOME TEAM and AWAY TEAM data for each boxscore game in line_score.\n for i, value in enumerate(line_score):\n if (value[\"GAME_SEQUENCE\"] != game_sequence):\n game_sequence += 1\n\n current_game[\"GAME_ID\"] = value[\"GAME_ID\"]\n home_team_id = game_header[game_sequence - 1][\"HOME_TEAM_ID\"]\n\n if (home_team_id == value[\"TEAM_ID\"]):\n current_game[\"HOME_TEAM\"] = value[\"TEAM_ABBREVIATION\"]\n current_game[\"HOME_TEAM_WINS_LOSSES\"] = value[\"TEAM_WINS_LOSSES\"]\n current_game[\"HOME_TEAM_PTS\"] = value[\"PTS\"]\n current_game[\"HOME_TEAM_ID\"] = value[\"TEAM_ID\"]\n if (current_game[\"HOME_TEAM\"] in TEAM_ID_DATA):\n current_game[\"HOME_TEAM_IMG\"] = TEAM_ID_DATA[current_game[\"HOME_TEAM\"]][\"img\"]\n else:\n current_game[\"AWAY_TEAM\"] = value[\"TEAM_ABBREVIATION\"]\n current_game[\"AWAY_TEAM_WINS_LOSSES\"] = value[\"TEAM_WINS_LOSSES\"]\n current_game[\"AWAY_TEAM_PTS\"] = value[\"PTS\"]\n current_game[\"AWAY_TEAM_ID\"] = value[\"TEAM_ID\"]\n if (current_game[\"AWAY_TEAM\"] in TEAM_ID_DATA):\n current_game[\"AWAY_TEAM_IMG\"] = TEAM_ID_DATA[current_game[\"AWAY_TEAM\"]][\"img\"]\n\n if (value[\"TEAM_ABBREVIATION\"] in TEAMS):\n if (home_team_id == value[\"TEAM_ID\"]):\n current_game[\"HOME_TEAM_FULL_NAME\"] = TEAMS[value[\"TEAM_ABBREVIATION\"]][\"city\"] + \\\n \" \" + TEAMS[value[\"TEAM_ABBREVIATION\"]][\"name\"]\n else:\n current_game[\"AWAY_TEAM_FULL_NAME\"] = TEAMS[value[\"TEAM_ABBREVIATION\"]][\"city\"] + \\\n \" \" + TEAMS[value[\"TEAM_ABBREVIATION\"]][\"name\"]\n \n game_sequence = value[\"GAME_SEQUENCE\"]\n game_sequence_counter += 1\n elif game_sequence_counter == 1:\n if (\"AWAY_TEAM\" in current_game):\n current_game[\"HOME_TEAM\"] = value[\"TEAM_ABBREVIATION\"]\n current_game[\"HOME_TEAM_WINS_LOSSES\"] = value[\"TEAM_WINS_LOSSES\"]\n current_game[\"HOME_TEAM_PTS\"] = value[\"PTS\"]\n current_game[\"HOME_TEAM_ID\"] = value[\"TEAM_ID\"]\n if (current_game[\"HOME_TEAM\"] in TEAM_ID_DATA):\n current_game[\"HOME_TEAM_IMG\"] = TEAM_ID_DATA[current_game[\"HOME_TEAM\"]][\"img\"]\n else:\n current_game[\"AWAY_TEAM\"] = value[\"TEAM_ABBREVIATION\"]\n current_game[\"AWAY_TEAM_WINS_LOSSES\"] = value[\"TEAM_WINS_LOSSES\"]\n current_game[\"AWAY_TEAM_PTS\"] = value[\"PTS\"]\n current_game[\"AWAY_TEAM_ID\"] = value[\"TEAM_ID\"]\n if (current_game[\"AWAY_TEAM\"] in TEAM_ID_DATA):\n current_game[\"AWAY_TEAM_IMG\"] = TEAM_ID_DATA[current_game[\"AWAY_TEAM\"]][\"img\"]\n\n if (value[\"TEAM_ABBREVIATION\"] in TEAMS):\n if (\"AWAY_TEAM\" in current_game):\n current_game[\"HOME_TEAM_FULL_NAME\"] = TEAMS[value[\"TEAM_ABBREVIATION\"]][\"city\"] + \\\n \" \" + TEAMS[value[\"TEAM_ABBREVIATION\"]][\"name\"]\n else:\n current_game[\"AWAY_TEAM_FULL_NAME\"] = TEAMS[value[\"TEAM_ABBREVIATION\"]][\"city\"] + \\\n \" \" + TEAMS[value[\"TEAM_ABBREVIATION\"]][\"name\"]\n\n current_game[\"GAME_STATUS_TEXT\"] = game_header[game_sequence - 1][\"GAME_STATUS_TEXT\"]\n if not game_header[game_sequence - 1][\"NATL_TV_BROADCASTER_ABBREVIATION\"]:\n current_game[\"BROADCASTER\"] = \"\"\n else:\n current_game[\"BROADCASTER\"] = game_header[game_sequence - 1][\"NATL_TV_BROADCASTER_ABBREVIATION\"]\n\n games.append(current_game)\n\n current_game = {}\n\n game_sequence = value[\"GAME_SEQUENCE\"]\n game_sequence_counter -= 1\n\n east_standings = scoreboard.east_conf_standings_by_day()\n west_standings = scoreboard.west_conf_standings_by_day()\n\n return (games, east_standings, west_standings)","def extract_games(self) -> Dict[int, Dict[str, Any]]:\n optadocument = self._get_doc()\n attr = assertget(optadocument, '@attributes')\n matchdata = assertget(optadocument, 'MatchData')\n matches = {}\n for match in matchdata:\n matchattr = assertget(match, '@attributes')\n matchinfo = assertget(match, 'MatchInfo')\n matchinfoattr = assertget(matchinfo, '@attributes')\n game_id = int(assertget(matchattr, 'uID')[1:])\n matches[game_id] = dict(\n # Fields required by the base schema\n game_id=game_id,\n competition_id=int(assertget(attr, 'competition_id')),\n season_id=int(assertget(attr, 'season_id')),\n game_day=int(assertget(matchinfoattr, 'MatchDay')),\n game_date=datetime.strptime(assertget(matchinfo, 'Date'), '%Y-%m-%d %H:%M:%S'),\n # home_team_id=see below,\n # away_team_id=see below,\n # Optional fields\n # home_score=see below,\n # away_score=see below,\n # duration=?\n # referee=?\n # venue=?,\n # attendance=?\n # home_manager=?\n # away_manager=?\n )\n teamdata = assertget(match, 'TeamData')\n for team in teamdata:\n teamattr = assertget(team, '@attributes')\n side = assertget(teamattr, 'Side')\n teamid = assertget(teamattr, 'TeamRef')\n score = assertget(teamattr, 'Score')\n if side == 'Home':\n matches[game_id]['home_team_id'] = int(teamid[1:])\n matches[game_id]['home_score'] = int(score)\n else:\n matches[game_id]['away_team_id'] = int(teamid[1:])\n matches[game_id]['away_score'] = int(score)\n return matches","def get_info(self):\n players = self.player_set\n if self.order_by == 'rank':\n players = players.order_by('rank')\n else:\n players = players.order_by('-rating')\n\n # if players have None scores, move to the bottom\n none_players = []\n players = list(players)\n for player in players:\n if ((self.order_by == 'rank' and player.rank is None)\n or (self.order_by == 'rating' and player.rating is None)):\n none_players.append(player)\n players.remove(player)\n players.extend(none_players)\n\n return dict(\n players = players,\n players_json = json.dumps([\n {\n 'id': player.id,\n 'name': \"%d %s\" % (\n player.rank or len(players), player.name)\n }\n for player in players]),\n num_matches = self.match_set.count(),\n num_rounds = Round.objects.filter(match__company = self).count(),\n recent_matches = (self.match_set\n .order_by('-played_time')[:MATCH_RESULT_LIMIT]),\n api_account_id = self.get_api_account_id(),\n api_access_key = self.get_api_access_key()\n )","def get_games(self, split: dataset_split.DatasetSplit = None) -> Dict[str, cereal_bar_game.CerealBarGame]:\n if not split:\n all_games: Dict[str, cereal_bar_game.CerealBarGame] = dict()\n for game_id, game in self._train_games.items():\n all_games[game_id] = game\n for game_id, game in self._dev_games.items():\n all_games[game_id] = game\n for game_id, game in self._test_games.items():\n all_games[game_id] = game\n return all_games\n\n if split in {dataset_split.DatasetSplit.TRAIN, dataset_split.DatasetSplit.UPDATE,\n dataset_split.DatasetSplit.VALIDATION}:\n games: Dict[str, cereal_bar_game.CerealBarGame] = dict()\n for game_id, game in self._train_games.items():\n if split == dataset_split.DatasetSplit.TRAIN:\n games[game_id] = game\n elif split == dataset_split.DatasetSplit.UPDATE and game_id in self._update_ids:\n games[game_id] = game\n elif split == dataset_split.DatasetSplit.VALIDATION and game_id in self._val_ids:\n games[game_id] = game\n return games\n elif split == dataset_split.DatasetSplit.DEV:\n return self._dev_games\n elif split == dataset_split.DatasetSplit.TEST:\n return self._test_games\n else:\n raise ValueError('Getting games with specified filename is not supported')","def get_game_parameters(self, name):\n param = {}\n if self.supported_games.has_key(name):\n param['game_name'] = self.supported_games[name].game_name\n param['rows'] = self.supported_games[name].rows\n param['cols'] = self.supported_games[name].cols\n param['xpad'] = self.supported_games[name].xpad\n param['ypad'] = self.supported_games[name].ypad\n param['aux'] = self.supported_games[name].aux\n return param","def extractData(self) -> Dict[str, str]:\n if self.hasScore():\n result = {}\n result[\"date\"] = self.getMatchDate()\n result[\"score\"] = self.getMatchScore()\n for team in self.TEAMS:\n result[\"team_\" + team] = self.getSquadName(team)\n\n return result\n return None","def status_games(game=None):\n if game is None:\n aux = {}\n for i in range(len(games)):\n aux[\"Game \" + str(i)] = games.games_status[i]['Status']\n return aux\n else:\n game = int(game)\n return {\"Game \" + str(game): games.games_status[game]['Status']}","def get_list_team_scores(self):\n scores = defaultdict(lambda: {\n \"scored_xg\": [],\n \"conceded_xg\": [],\n \"home_adv\": 0,\n \"expected_points\": 0\n })\n\n for g in self.games:\n scores[g.HomeTeam][\"scored_xg\"].append(g.FTHG)\n scores[g.HomeTeam][\"conceded_xg\"].append(g.FTAG)\n scores[g.AwayTeam][\"scored_xg\"].append(g.FTAG)\n scores[g.AwayTeam][\"conceded_xg\"].append(g.FTHG)\n\n for team in scores.keys():\n scores[team][\"expected_points\"] = (self.get_table(metric='points')[team] /\n len(scores[team][\"scored_xg\"]))\n\n return scores","def get_matched_game_ranking_info_for_movie(movie_id: str) -> Dict[str, int]:\n query_res = Movie.query.filter_by(link_id=movie_id).all()\n if query_res:\n return eval(query_res[0].games_title_match)\n return dict()","def box_score(game_id):\n # get data\n data = mlbgame.data.get_box_score(game_id)\n # parse data\n parsed = etree.parse(data)\n root = parsed.getroot()\n linescore = root.find('linescore')\n result = dict()\n result['game_id'] = game_id\n # loop through innings and add them to output\n for x in linescore:\n inning = x.attrib['inning']\n home = value_to_int(x.attrib, 'home')\n away = value_to_int(x.attrib, 'away')\n result[int(inning)] = {'home': home, 'away': away}\n return result","def calculate_scores(players):\n scores = {}\n for player in players.tuple_:\n scores[player.id_] = player.score()\n return scores","def get_initial_scores(self) -> Dict[str, float]:\n temp_game = Game(self.game.configuration, self.game.initialization)\n scores_dict = {\n self.game.configuration.agent_pbk_to_name[agent_pbk]: score\n for agent_pbk, score in temp_game.get_scores().items()\n }\n return scores_dict","def find_games(days_ahead=0):\n headers = {\n 'Host': 'stats.nba.com',\n 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0',\n 'Accept': 'application/json, text/plain, */*',\n 'Accept-Language': 'en-US,en;q=0.5',\n 'Referer': 'https://stats.nba.com/',\n 'Accept-Encoding': 'gzip, deflate, br',\n 'Connection': 'keep-alive',\n 'x-nba-stats-origin': 'stats',\n 'x-nba-stats-token': 'true'\n }\n board = scoreboardv2.ScoreboardV2(day_offset=days_ahead, headers=headers).get_data_frames()[0]\n board.replace(id_to_abrv, inplace=True)\n return board[['GAME_DATE_EST', 'GAME_ID', 'HOME_TEAM_ID', 'VISITOR_TEAM_ID']]","def print_scoreboard(self):\n output = ''\n # parallel dictionaries with innings and scores\n innings = []\n away = []\n home = []\n for x in self:\n innings.append(x['inning'])\n away.append(x['away'])\n home.append(x['home'])\n # go through all the information and make a nice output\n # that looks like a scoreboard\n output += 'Inning\\t'\n for x in innings:\n output += str(x) + ' '\n output += '\\n'\n for x in innings:\n output += '---'\n output += '\\nAway\\t' + self.__enumerate_scoreboard(away)\n output += '\\nHome\\t' + self.__enumerate_scoreboard(home)\n return output","def view_game(game):\n game = int(game)\n return {\"Board_view\": format_view(games.get_board(game)),\n \"TimeStep\": games.get_timestep(game)}","def get_scores(self):\n return [(self.players[p.get_color()], p.get_score()) for p in self.state.get_players()]","def getScorecard(self, **kwargs):\n lstPlayers = []\n for n,sc in enumerate(self._players):\n dct = {\n 'player': sc.doc,\n 'in': sc.dct_net['in'],\n 'out': sc.dct_net['out'],\n 'total': sc.dct_net['total'],\n 'holes': sc.dct_net['holes'],\n 'bumps': sc._bumps,\n }\n line = '{:<3} {:>2}'.format(sc.getInitials(), sc.result.course_handicap)\n for net,bump in zip(sc.dct_net['holes'][:9], sc._bumps[:9]):\n nets = '{}{}'.format(bump*'*', net if net is not None else '')\n line += ' {:>3}'.format(nets)\n line += ' {:>4}'.format(dct['out'])\n for net,bump in zip(sc.dct_net['holes'][9:], sc._bumps[9:]):\n nets = '{}{}'.format(bump*'*', net if net is not None else '')\n line += ' {:>3}'.format(nets)\n line += ' {:>4} {:>4}'.format(dct['in'], dct['total'])\n dct['line'] = line\n lstPlayers.append(dct)\n self.dctScorecard['players'] = lstPlayers\n return self.dctScorecard","def retrieve_score_spread(database_connection: mysql.connector.connect\n ) -> List[Dict]:\n\n cursor = database_connection.cursor()\n query = (\"SELECT pm.panelistscore, COUNT(pm.panelistscore) \"\n \"FROM ww_showpnlmap pm \"\n \"JOIN ww_shows s ON s.showid = pm.showid \"\n \"WHERE pm.panelistscore IS NOT NULL \"\n \"AND s.bestof = 0 AND s.repeatshowid IS NULL \"\n \"GROUP BY pm.panelistscore \"\n \"ORDER BY pm.panelistscore ASC;\")\n cursor.execute(query)\n result = cursor.fetchall()\n cursor.close()\n\n if not result:\n return None\n\n scores = []\n counts = []\n for row in result:\n scores.append(row[0])\n counts.append(row[1])\n\n return {\"scores\": scores, \"counts\": counts}","def get_player_stats_from_game(team, year, week):","def score(self):\n return {\n 'black': self._score[self.BLACK],\n 'white': self._score[self.WHITE],\n }","def get_games(url):\n \n import urllib\n import urllib2\n import re\n\n response = urllib2.urlopen(url + 'matches')\n html = response.read()\n\n games_html = re.findall('<tr class=\"match-row custom\">(.*?)</tr', html, flags=re.MULTILINE|re.DOTALL)\n\n games = []\n\n for game_html in games_html:\n game_match = re.search('.*?<td>(.*?)</td>.*?<td class=\"align-center\">(.*?)</td>.*?<span class=\"match-win\">(.*?)</span>.*?<td class=\"align-right\">[\\r\\n\\t]*(.*?)[\\r\\n\\t]*</td>', game_html, flags=re.MULTILINE|re.DOTALL)\n \n game = {}\n \n if game_match:\n game['map'] = game_match.group(1)\n game['type'] = game_match.group(2)\n game['outcome'] = game_match.group(3)\n game['date'] = game_match.group(4)\n games.append(game)\n \n return games","def get_game_info(game_id):\n url = 'http://stats.nba.com/stats/boxscoresummaryv2?GameID=%s' % (game_id)\n response = requests.get(url, headers=HEADERS)\n while response.status_code != 200:\n response = requests.get(url)\n headers = response.json()['resultSets'][0]['headers']\n data = response.json()['resultSets'][0]['rowSet']\n data = pd.DataFrame(data, columns=headers)\n data = data[['GAME_ID', 'GAMECODE', 'HOME_TEAM_ID', 'VISITOR_TEAM_ID', 'SEASON']].T.squeeze()\n data['GAMECODE'] = data['GAMECODE'].replace('/', '')\n return data","def overview(game_id):\n output = {}\n # get data\n overview = mlbgame.data.get_overview(game_id)\n # parse data\n overview_root = etree.parse(overview).getroot()\n\n try:\n output = add_raw_box_score_attributes(output, game_id)\n except ValueError:\n pass\n\n # get overview attributes\n for x in overview_root.attrib:\n output[x] = overview_root.attrib[x]\n\n # Get probable starter attributes if they exist\n home_pitcher_tree = overview_root.find('home_probable_pitcher')\n if home_pitcher_tree is not None:\n output.update(build_namespaced_attributes(\n 'home_probable_pitcher', home_pitcher_tree))\n else:\n output.update(build_probable_starter_defaults('home'))\n\n away_pitcher_tree = overview_root.find('away_probable_pitcher')\n if away_pitcher_tree is not None:\n output.update(build_namespaced_attributes(\n 'away_probable_pitcher', away_pitcher_tree))\n else:\n output.update(build_probable_starter_defaults('away'))\n\n return output","def match_game(self):\n # TODO: split this out so hold'em is separate\n return ['Settings arenaVersion 1.0',\n 'Settings gameType NLHE',\n 'Settings gameMode tournament', ]","def compile_games(all_games):\n compiled_games = {}\n for game_data in all_games:\n game_id = game_data[4]\n team_data = extract_team_data(game_data)\n home_team_abbrev = get_home_team(game_data[6])\n if team_data[\"team_abbrev\"] == home_team_abbrev:\n home_team = True\n team_data = rename_features(team_data, \"home\")\n else:\n home_team = False\n team_data = rename_features(team_data, \"away\")\n\n if game_id in compiled_games:\n compiled_games[game_id] = {\n **compiled_games[game_id],\n **team_data\n }\n else:\n if home_team:\n winner = 1 if game_data[7] == \"W\" else 0\n else:\n winner = 0 if game_data[7] == \"W\" else 1\n # game_date, win/loss, matchup all needed exactly once\n compiled_games[game_id] = team_data\n compiled_games[game_id][\"winner\"] = winner\n compiled_games[game_id][\"game_date\"] = game_data[5]\n compiled_games[game_id][\"game_id\"] = game_id\n compiled_games[game_id][\"matchup_name\"] = game_data[6]\n\n return compiled_games","def collect_stats(games: List[BaseGame], date_min = None, date_max = None):\n if not games: games = self.games\n\n under2_5 = len(list(filter(lambda g: g.is_total_under(), games)))\n under3_5 = len(list(filter(lambda g: g.is_total_under(3.5), games)))\n under1_5 = len(list(filter(lambda g: g.is_total_under(1.5), games)))\n\n home_score = sum([g.FTHG for g in games])\n away_score = sum([g.FTAG for g in games])\n\n home_wins = sum(1 for _ in filter(lambda g: g.is_home_win(), games))\n away_wins = sum(1 for _ in filter(lambda g: g.is_away_win(), games))\n draws = sum(1 for _ in filter(lambda g: g.is_draw(), games))\n\n return {\n 'under2.5': float(under2_5) / len(games),\n 'under3.5': float(under3_5) / len(games),\n 'under1.5': float(under1_5) / len(games),\n 'avgScoredHome': float(home_score) / len(games),\n 'avgScoredAway': float(away_score) / len(games),\n \"home_wins\": float(home_wins) / len(games),\n \"away_wins\": float(away_wins) / len(games),\n \"draws\": float(draws) / len(games),\n }","def status():\n aux = {\"Number games\": len(games), \"Path execution\": path_games}\n for j, game in enumerate(games.games_status):\n aux[\"Game \" + str(j)] = game\n return aux","def retrieve_grouped_scores(database_connection: mysql.connector.connect\n ) -> Dict:\n cursor = database_connection.cursor()\n query = (\"SELECT pm.panelistscore, COUNT(pm.panelistscore) \"\n \"FROM ww_showpnlmap pm \"\n \"JOIN ww_shows s ON s.showid = pm.showid \"\n \"WHERE pm.panelistscore IS NOT NULL \"\n \"AND s.bestof = 0 AND s.repeatshowid IS NULL \"\n \"GROUP BY pm.panelistscore \"\n \"ORDER BY pm.panelistscore ASC;\")\n cursor.execute(query)\n result = cursor.fetchall()\n\n if not result:\n return None\n\n scores = []\n for row in result:\n score = OrderedDict()\n score[\"score\"] = row[0]\n score[\"count\"] = row[1]\n scores.append(score)\n\n return scores","def getScorecard(self, **kwargs):\n self.dctScorecard[\"players\"] = [team.get_scorecard() for team in self.team_list]\n return self.dctScorecard","def get_score_dict(*args):\n score_dict = {\n 'error_percent': args[0],\n 'error_absolute': args[1],\n 'score': args[2],\n }\n return score_dict","def getLeaderboard(self, **kwargs):\n board = []\n scores = sorted(self._players, key=lambda score: score.dct_net['total'])\n pos = 1\n prev_total = None\n for sc in scores:\n score_dct = {\n 'player': sc.doc,\n 'total' : sc.dct_net['total'],\n }\n if prev_total != None and score_dct['total'] > prev_total:\n pos += 1\n prev_total = score_dct['total']\n score_dct['pos'] = pos\n for n,net in enumerate(sc.dct_net['holes']):\n if net == None:\n break\n else:\n n += 1\n score_dct['thru'] = n\n score_dct['line'] = '{:<3} {:<6} {:>5} {:>4}'.format(\n score_dct['pos'], score_dct['player'].nick_name, score_dct['total'], score_dct['thru'])\n board.append(score_dct)\n self.dctLeaderboard['leaderboard'] = board\n return self.dctLeaderboard","def as_dict(self):\n return {\n \"__bbref_boxscore__\": True,\n \"boxscore_url\": self.boxscore_url,\n \"bbref_game_id\": self.bbref_game_id,\n \"game_meta_info\": self.game_meta_info.as_dict(),\n \"away_team_data\": self.away_team_data.as_dict(),\n \"home_team_data\": self.home_team_data.as_dict(),\n \"innings_list\": as_dict_list(self.innings_list),\n \"player_id_match_log\": self.player_id_match_log,\n \"umpires\": as_dict_list(self.umpires),\n \"player_team_dict\": self.player_team_dict,\n \"player_name_dict\": self.player_name_dict,\n }","def instantiate_team_and_player_data(self, game_summary):\n self.HomeTeamId = str(game_summary['g']['hls']['tid'])\n self.VisitorTeamId = str(game_summary['g']['vls']['tid'])\n self.HomeTeamAbbreviation = str(game_summary['g']['hls']['ta'])\n self.VisitorTeamAbbreviation = str(game_summary['g']['vls']['ta'])\n self.GameDate = game_summary['g']['gdte']\n\n self.Players = {\n self.HomeTeamId: {\n str(player['pid']): player['fn'] + ' ' + player['ln']\n for player in game_summary['g']['hls']['pstsg'] if player['totsec'] > 0 # only keep track of stats for players who played\n },\n self.VisitorTeamId: {\n str(player['pid']): player['fn'] + ' ' + player['ln']\n for player in game_summary['g']['vls']['pstsg'] if player['totsec'] > 0 # only keep track of stats for players who played\n },\n }\n if self.GameId in PLAYERS_MISSING_FROM_BOXSCORE.keys():\n for team_id in PLAYERS_MISSING_FROM_BOXSCORE[self.GameId].keys():\n for player_id in PLAYERS_MISSING_FROM_BOXSCORE[self.GameId][team_id].keys():\n self.Players[team_id][player_id] = PLAYERS_MISSING_FROM_BOXSCORE[self.GameId][team_id][player_id]","def _run_match(bots, nr_of_games) -> dict:\n\n start, game_results = datetime.now().timestamp(), _run_games(nr_of_games, bots)\n match_duration = datetime.now().timestamp() - start\n\n match_json = _match_result(game_results, match_duration)\n _print_match_end_score(match_json, match_duration)\n return match_json","def playerStandings(matchid):\n DB = dbc()\n c = DB.cursor()\n c.execute('SELECT matches.playerid, name, win, total_matches, \\\n score, played, bye \\\n FROM matches JOIN players \\\n ON matches.playerid = players.playerid \\\n WHERE matches.matchid = %s \\\n ORDER BY matches.score DESC', (matchid,))\n player_stats = c.fetchall()\n DB.close()\n return player_stats","def get_past_matches_data(team):\n matches = team.get_past_matches()\n match_list = []\n for match in matches:\n match_dict = {}\n match_dict['match_date'] = match.match_date\n match_dict['match_name'] = match.__str__()\n match_dict['id'] = match.id\n innings = match.get_innings()\n if len(innings):\n if innings[0].runs > innings[1].runs:\n match_dict['winner_team'] = innings[0].bat_team\n match_dict['win_margin'] = innings[0].runs - innings[1].runs\n match_dict['win_type'] = 'Runs'\n match_dict['winner_score'] = str(innings[0].runs) + '/' + str(innings[0].wickets)\n else:\n match_dict['winner_team'] = innings[1].bat_team\n match_dict['win_margin'] = 10 - innings[1].wickets\n match_dict['win_type'] = 'Wickets'\n match_dict['winner_score'] = str(innings[1].runs) + '/' + str(innings[1].wickets)\n match_list.append(match_dict)\n return match_list","def maps(matches):\n if not matches:\n print('no matches')\n return None\n\n maps = {}\n for match in matches:\n map = match['map']\n score = match['score']\n result = match['result']\n # add map to dictionary\n if not map in maps:\n maps[map] = {'wins': 0, 'losses': 0, 'winrate': 0.0}\n map_data = maps[map]\n if result:\n map_data['wins'] += 1\n else:\n map_data['losses'] += 1\n matches_played = map_data['wins'] + map_data['losses']\n\n # compute moving average on winrate\n map_data['winrate'] = map_data['winrate'] + (result - map_data['winrate']) / matches_played\n return maps","def print_game_stats(games_won=games_won):\n for k,v in games_won.items():\n print(k)\n print(v)\n if v == 1:\n print(f'{k} has won {v} game')\n else:\n print(f'{k} has won {v} games')","def playerStandings():\n # place all players in a dictionary\n player_dict = {}\n conn, c = connect()\n c.execute(\"\"\"SELECT * FROM players;\"\"\")\n for row in c.fetchall():\n player_dict[row[0]] = [row[1], 0, 0]\n\n # count the number of win and matches in for all matches\n c.execute(\"\"\"SELECT winner, loser FROM matches;\"\"\")\n for row in c.fetchall():\n if row[0] in player_dict:\n player_dict[row[0]][1] += 1\n player_dict[row[0]][2] += 1\n if row[1] in player_dict:\n player_dict[row[1]][2] += 1\n\n # compile win counts as the key to dictionary\n win_count = {}\n for i in player_dict:\n wins = player_dict[i][1]\n if wins in win_count:\n win_count[wins].append((i, player_dict[i][0],\n wins, player_dict[i][2]))\n else:\n win_count[wins] = [(i, player_dict[i][0],\n wins, player_dict[i][2])]\n\n # compile output list\n output_list = []\n for i in sorted(win_count.keys(), reverse=True):\n for j in win_count[i]:\n output_list.append(j)\n\n return output_list","def __show_scoreboard(self):\n self.clear_screen()\n\n print('\\n' * 2, end=\"\")\n for line in self.__fame:\n print((\" \" * 5) + line, end=\"\")\n print('\\n' * 2, end=\"\")\n\n with open(\"mastermind/assets/scores.json\", \"r\") as data:\n board = list(load(data).items())\n\n space = \" \" * 11\n print(f\"{space}RANK {'PLAYER':<30}\" +\n f\"{'TIME':>7} (seconds){'POINTS':>29}\\n\")\n\n lines_printed = 0\n for idx, entry in enumerate(board[:10]):\n lines_printed += 1\n space = \" \" * 10\n n = idx + 1\n year, month, day, time = entry[0].split(\" \")\n points = entry[1][\"points\"]\n playtime = entry[1][\"playtime\"]\n player = entry[1][\"player\"]\n\n print(f\"{space}{n:>4}. {player:<30}\" +\n f\"{playtime:>7,.2f}{points:>36}/15\")\n\n lines = \"\\n\" * (12 - lines_printed)\n print(f\"{lines}{space}\", end=\"\")\n sleep(.25)\n self.cool_print(\"Press ENTER to return to player menu.\",\n newline=False, margin=0)\n input()","def get_results(state): # TODO: Add equality case.\n tie = False\n if state.score[-1] == state.score[1]:\n tie = True\n\n return {'tie': tie, 'winner': max(state.score, key=state.score.get),\n 'score': state.score}","def get_learning_data(self):\n if self.teams is None:\n self.build_teams()\n\n # now put together X and y for every match\n return self.games.get_games(self.teams)","def get_scoreboard(self):\n cases = len(self.start_player_list)\n\n opponent03 = \"N/A\"\n opponent04 = \"N/A\"\n opponent05 = \"N/A\"\n opponent06 = \"N/A\"\n opponent07 = \"N/A\"\n opponent08 = \"N/A\"\n opponent09 = \"N/A\"\n opponent10 = \"N/A\"\n opponent11 = \"N/A\"\n opponent12 = \"N/A\"\n opponent13 = \"N/A\"\n opponent14 = \"N/A\"\n winner = \"N/A\"\n\n display = \"\\n\"\n\n # Game with 3 players\n if cases == 3:\n opponent01 = self.all_opponents[0][0][0]\n opponent02 = self.all_opponents[0][0][1]\n if len(self.all_opponents) == 2:\n opponent03 = self.all_opponents[1][0][0]\n opponent04 = self.all_opponents[1][0][1]\n if len(self.winner_list) == 2:\n winner = self.winner_list[1][0]\n\n first_game = [opponent01, opponent02]\n max_string = len(max(first_game, key=len))\n string_size1 = len(opponent01)\n padding1 = \"\".ljust((int(max_string-string_size1)), '-')\n string_size2 = len(max([opponent01, opponent02], key=len))\n padding2 = \"\".ljust(string_size2, ' ')\n string_size3 = len(opponent02)\n padding3 = \"\".ljust((int(max_string)-string_size3), '-')\n string_size4 = len(padding2+\"|---\")\n padding4 = \"\".ljust(string_size4, ' ')\n string_size6 = max(len(opponent03), len(opponent04)) - len(opponent03)\n padding6 = \"\".ljust(string_size6, '-')\n string_size7 = max(len(opponent03), len(opponent04)) - len(opponent04)\n padding7 = \"\".ljust(string_size7, '-')\n string_size5 = len(padding4+opponent04+padding7) - len(opponent02+padding3) - 1\n padding5 = \"\".ljust(string_size5, ' ')\n\n display += opponent01+padding1+\"|\"+\"\\n\"\n display += padding2+\"|---\"+opponent03+padding6+\"|\"+\"\\n\"\n display += opponent02+padding3+\"|\"+padding5+\"|---\"+winner+\"\\n\"\n display += padding4+opponent04+padding7+\"|\"+\"\\n\"\n\n # Game with 4 players\n if cases == 4:\n opponent01 = self.all_opponents[0][0][0]\n opponent02 = self.all_opponents[0][0][1]\n opponent03 = self.all_opponents[0][1][0]\n opponent04 = self.all_opponents[0][1][1]\n if len(self.winner_list_temp) == 1:\n opponent05 = self.winner_list_temp[0]\n if len(self.winner_list) >= 1:\n opponent05 = self.winner_list[0][0]\n opponent06 = self.winner_list[0][1]\n if self.winner_state == 1:\n winner = self.winner_list[1][0]\n\n first_game = [opponent01, opponent02, opponent03, opponent04]\n max_string = len(max(first_game, key=len))\n string_size1 = len(opponent01)\n padding1 = \"\".ljust(int(max_string-string_size1), '-')\n string_size2 = max_string\n padding2 = \"\".ljust(string_size2, ' ')\n string_size3 = len(opponent02)\n padding3 = \"\".ljust(int(max_string-string_size3), '-')\n string_size5 = len(opponent03)\n padding5 = \"\".ljust(int(max_string-string_size5), '-')\n string_size6 = max_string\n padding6 = \"\".ljust(string_size6, ' ')\n string_size7 = len(opponent04)\n padding7 = \"\".ljust(int(max_string-string_size7), '-')\n string_size8 = max(len(opponent05), len(opponent06)) - len(opponent05)\n padding8 = \"\".ljust(string_size8, '-')\n string_size9 = max(len(opponent05), len(opponent06)) - len(opponent06)\n padding9 = \"\".ljust(string_size9, '-')\n string_size4 = max(len(\"\"+padding2+\"|---\"+opponent05+padding8+\"|\"), (len(\"\"+padding6+\"|---\"+opponent06+padding9+\"|\"))) - 1\n padding4 = \"\".ljust(string_size4, ' ')\n string_size10 = len(padding4) - len(\"\"+opponent02+padding3+\"|\")\n padding10 = \"\".ljust(string_size10, ' ')\n string_size11 = len(padding4) - len(\"\"+opponent03+padding5+\"|\")\n padding11 = \"\".ljust(string_size11, ' ')\n\n display += opponent01+padding1+\"|\"+\"\\n\"\n display += padding2+\"|---\"+opponent05+padding8+\"|\"+\"\\n\"\n display += opponent02+padding3+\"|\"+padding10+\"|\"+\"\\n\"\n display += padding4+\"|---\"+winner+\"\\n\"\n display += opponent03+padding5+\"|\"+padding11+\"|\"+\"\\n\"\n display += padding6+\"|---\"+opponent06+padding9+\"|\"+\"\\n\"\n display += opponent04+padding7+\"|\"+\"\\n\"\n\n # Game with 5 players\n if cases == 5:\n opponent01 = self.all_opponents[0][0][0]\n opponent02 = self.all_opponents[0][0][1]\n if len(self.all_opponents) >= 2:\n opponent03 = self.all_opponents[1][0][0]\n opponent04 = self.all_opponents[1][0][1]\n opponent05 = self.all_opponents[1][1][0]\n opponent06 = self.all_opponents[1][1][1]\n if len(self.winner_list_temp) == 1:\n opponent07 = self.winner_list_temp[0]\n if len(self.winner_list) >= 2:\n opponent07 = self.winner_list[1][0]\n opponent08 = self.winner_list[1][1]\n if len(self.winner_list) == 3:\n winner = self.winner_list[2][0]\n\n first_game = [opponent01, opponent02]\n max_string = len(max(first_game, key=len))\n string_size1 = len(opponent01)\n padding1 = \"\".ljust(int(max_string-string_size1), '-')\n string_size2 = max_string\n padding2 = \"\".ljust(string_size2, ' ')\n string_size3 = len(opponent02)\n padding3 = \"\".ljust(int(max_string-string_size3), '-')\n string_size4 = max(len(\"\"+opponent01+padding1), len(\"\"+opponent01+padding1)) + 4\n padding4 = \"\".ljust(string_size4, ' ')\n string_size5 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06))\n padding5 = \"\".ljust((string_size5 - len(opponent03)), '-')\n string_size7 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06))\n padding7 = \"\".ljust((string_size7 - len(opponent04)), '-')\n string_size8 = len(\"\"+padding2+\"|---\")\n padding8 = \"\".ljust(string_size8, ' ')\n string_size6 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06)) + 3\n padding6 = \"\".ljust(string_size6, ' ')\n string_size9 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06)) - len(opponent05)\n padding9 = \"\".ljust(string_size9, '-')\n string_size10 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06)) - len(opponent06)\n padding10 = \"\".ljust(string_size10, '-')\n string_size11 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06)) + len(padding4)\n padding11 = \"\".ljust(string_size11, ' ')\n string_size12 = max(len(opponent07), len(opponent08)) - len(opponent07)\n padding12 = \"\".ljust(string_size12, '-')\n string_size13 = max(len(opponent07), len(opponent08)) - len(opponent08)\n padding13 = \"\".ljust(string_size13, '-')\n string_size14 = max(len(opponent07), len(opponent08)) + 3\n padding14 = \"\".ljust(string_size14, ' ')\n string_size15 = max(len(opponent07), len(opponent08)) + 3\n padding15 = \"\".ljust(string_size15, ' ')\n string_size16 = len(\"\"+padding11+\"|---\"+opponent08+padding13)\n padding16 = \"\".ljust(string_size16, ' ')\n\n display += opponent01+padding1+\"|\"+\"\\n\"\n display += padding2+\"|---\"+opponent03+padding5+\"|\"+\"\\n\"\n display += opponent02+padding3+\"|\"+padding6+\"|---\"+opponent07+padding12+\"|\"+\"\\n\"\n display += padding4+opponent04+padding7+\"|\"+padding14+\"|\"+\"\\n\"\n display += padding16+\"|---\"+winner+\"\\n\"\n display += padding8+opponent05+padding9+\"|\"+padding15+\"|\"+\"\\n\"\n display += padding11+\"|---\"+opponent08+padding13+\"|\"+\"\\n\"\n display += padding8+opponent06+padding10+\"|\"+\"\\n\"\n\n # Game with 6 players\n if cases == 6:\n opponent01 = self.all_opponents[0][0][0]\n opponent02 = self.all_opponents[0][0][1]\n opponent03 = self.all_opponents[0][1][0]\n opponent04 = self.all_opponents[0][1][1]\n opponent05 = self.all_opponents[0][2][0]\n opponent06 = self.all_opponents[0][2][1]\n if len(self.winner_list_temp) >= 1:\n opponent07 = self.winner_list_temp[0]\n if len(self.winner_list_temp) >= 2:\n opponent08 = self.winner_list_temp[1]\n if len(self.winner_list) >= 1:\n print(self.winner_list)\n opponent07 = self.winner_list[0][0]\n opponent08 = self.winner_list[0][1]\n opponent09 = self.winner_list[0][2]\n if len(self.all_opponents) >= 3:\n opponent10 = self.all_opponents[2][0][0]\n if len(self.winner_list) == 3:\n winner = self.winner_list[2][0]\n\n first_game = [opponent01, opponent02, opponent03, opponent04, opponent05, opponent06,]\n max_string = len(max(first_game, key=len))\n string_size1 = len(opponent01)\n padding1 = \"\".ljust(int(max_string-string_size1), '-')\n string_size2 = len(opponent02)\n padding2 = \"\".ljust(int(max_string-string_size2), '-')\n string_size3 = len(opponent03)\n padding3 = \"\".ljust(int(max_string-string_size3), '-')\n string_size4 = len(opponent04)\n padding4 = \"\".ljust(int(max_string-string_size4), '-')\n string_size5 = len(opponent05)\n padding5 = \"\".ljust(int(max_string-string_size5), '-')\n string_size6 = len(opponent06)\n padding6 = \"\".ljust(int(max_string-string_size6), '-')\n string_size7 = max_string\n padding7 = \"\".ljust(string_size7, ' ')\n string_size8 = max(len(opponent07), len(opponent08), len(opponent09)) - len(opponent07)\n padding8 = \"\".ljust(string_size8, '-')\n string_size9 = max(len(opponent07), len(opponent08), len(opponent09)) - len(opponent08)\n padding9 = \"\".ljust(string_size9, '-')\n string_size10 = max(len(opponent07), len(opponent08), len(opponent09)) - len(opponent09)\n padding10 = \"\".ljust(string_size10, '-')\n string_size12 = len(\"\"+padding7+\"|---\"+opponent09+padding10)\n padding12 = \"\".ljust(string_size12, ' ')\n string_size14 = max(len(opponent07), len(opponent08), len(opponent09)) + 3\n padding14 = \"\".ljust(string_size14, ' ')\n string_size15 = len(\"\"+padding12+\"|---\"+opponent10) - len(\"\"+padding7+\"|---\"+opponent09)\n padding15 = \"\".ljust(string_size15, '-')\n string_size16 = len(padding7+\"|---\"+opponent09+padding15) - len(opponent05+padding5+\"|\")\n padding16 = \"\".ljust(string_size16, ' ')\n string_size17 = len(padding7+\"|---\"+opponent09+padding15)\n padding17 = \"\".ljust(string_size17, ' ')\n string_size18 = len(opponent09 + padding15) + 3\n padding18 = \"\".ljust(string_size18, ' ')\n string_size19 = len(\"|---\"+opponent10) - 1\n padding19 = \"\".ljust(string_size19, ' ')\n\n display += opponent01+padding1+\"|\"+\"\\n\"\n display += padding7+\"|---\"+opponent07+padding8+\"|\"+\"\\n\"\n display += opponent02+padding2+\"|\"+padding14+\"|\"+\"\\n\"\n display += padding12+\"|---\"+opponent10+\"|\"+\"\\n\"\n display += opponent03+padding3+\"|\"+padding14+\"|\"+padding19+\"|\"+\"\\n\"\n display += padding7+\"|---\"+opponent08+padding9+\"|\"+padding19+\"|\"+\"\\n\"\n display += opponent04+padding4+\"|\"+padding18+\"|---\"+winner+\"\\n\"\n display += padding17+\"|\"+\"\\n\"\n display += opponent05+padding5+\"|\"+padding16+\"|\"+\"\\n\"\n display += padding7+\"|---\"+opponent09+padding15+\"|\"+\"\\n\"\n display += opponent06+padding6+\"|\"+\"\\n\"\n\n # Game with 7 players\n if cases == 7:\n opponent01 = self.all_opponents[0][0][0]\n opponent02 = self.all_opponents[0][0][1]\n if len(self.all_opponents) >= 2:\n\n opponent03 = self.all_opponents[1][0][0]\n opponent04 = self.all_opponents[1][0][1]\n opponent05 = self.all_opponents[1][1][0]\n opponent06 = self.all_opponents[1][1][1]\n opponent07 = self.all_opponents[1][2][0]\n opponent08 = self.all_opponents[1][2][1]\n if len(self.winner_list_temp) >= 1:\n opponent09 = self.winner_list_temp[0]\n if len(self.winner_list_temp) >= 2:\n opponent10 = self.winner_list_temp[1]\n if len(self.winner_list) >= 2:\n opponent09 = self.winner_list[1][0]\n opponent10 = self.winner_list[1][1]\n opponent11 = self.winner_list[1][2]\n if len(self.all_opponents) >= 4:\n opponent12 = self.all_opponents[3][0][0]\n if len(self.winner_list) == 4:\n winner = self.winner_list[3][0]\n\n string_size1 = max(len(opponent01), len(opponent02)) - len(opponent01)\n padding1 = \"\".ljust(string_size1, '-')\n string_size2 = max(len(opponent01), len(opponent02)) - len(opponent02)\n padding2 = \"\".ljust(string_size2, '-')\n string_size3 = len(opponent01+padding1)\n padding3 = \"\".ljust(string_size3, ' ')\n string_size4 = len(opponent01+padding1) + 4\n padding4 = \"\".ljust(string_size4, ' ')\n string_size5 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent03)\n padding5 = \"\".ljust(string_size5, '-')\n string_size6 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent04)\n padding6 = \"\".ljust(string_size6, '-')\n string_size7 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent05)\n padding7 = \"\".ljust(string_size7, '-')\n string_size8 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent06)\n padding8 = \"\".ljust(string_size8, '-')\n string_size9 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent07)\n padding9 = \"\".ljust(string_size9, '-')\n string_size10 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent08)\n padding10 = \"\".ljust(string_size10, '-')\n string_size11 = len(padding4+opponent08+padding10)\n padding11 = \"\".ljust(string_size11, ' ')\n string_size12 = len(padding4+opponent08+padding10) - len(opponent02+padding2) - 1\n padding12 = \"\".ljust(string_size12, ' ')\n string_size13 = max(len(opponent09), len(opponent10)) - len(opponent09)\n padding13 = \"\".ljust(string_size13, '-')\n string_size14 = max(len(opponent09), len(opponent10)) - len(opponent10)\n padding14 = \"\".ljust(string_size14, '-')\n string_size15 = len(opponent09+padding13) + 3\n padding15 = \"\".ljust(string_size15, ' ')\n string_size16 = len(opponent02+padding2+\"|\"+padding12+\"|---\"+opponent09+padding13)\n padding16 = \"\".ljust(string_size16, ' ')\n string_size17 = len(\"---\"+opponent12)\n padding17 = \"\".ljust(string_size17, ' ')\n string_size18 = len(\"---\"+opponent12) + len(\"---\"+opponent10+padding14) + 1\n padding18 = \"\".ljust(string_size18, ' ')\n string_size19 = len(padding4+opponent06+padding8+\"|\"+padding18)\n padding19 = \"\".ljust(string_size19, ' ')\n string_size20 = len(padding18) - len(opponent11) - 3\n padding20 = \"\".ljust(string_size20, '-')\n\n display += opponent01+padding1+\"|\"+\"\\n\"\n display += padding3+\"|---\"+opponent03+padding5+\"|\"+\"\\n\"\n display += opponent02+padding2+\"|\"+padding12+\"|---\"+opponent09+padding13+\"|\"+\"\\n\"\n display += padding4+opponent04+padding6+\"|\"+padding15+\"|\"+\"\\n\"\n display += padding16+\"|---\"+opponent12+\"|\"+\"\\n\"\n display += padding4+opponent05+padding7+\"|\"+padding15+\"|\"+padding17+\"|\"+\"\\n\"\n display += padding11+\"|---\"+opponent10+padding14+\"|\"+padding17+\"|\"+\"\\n\"\n display += padding4+opponent06+padding8+\"|\"+padding18+\"|---\"+winner+\"\\n\"\n display += padding19+\"|\"+\"\\n\"\n display += padding4+opponent07+padding9+\"|\"+padding18+\"|\"+\"\\n\"\n display += padding11+\"|---\"+opponent11+padding20+\"|\"+\"\\n\"\n display += padding4+opponent08+padding10+\"|\"+\"\\n\"\n\n # Game with 8 players\n if cases == 8:\n opponent01 = self.all_opponents[0][0][0]\n opponent02 = self.all_opponents[0][0][1]\n opponent03 = self.all_opponents[0][1][0]\n opponent04 = self.all_opponents[0][1][1]\n opponent05 = self.all_opponents[0][2][0]\n opponent06 = self.all_opponents[0][2][1]\n opponent07 = self.all_opponents[0][3][0]\n opponent08 = self.all_opponents[0][3][1]\n if len(self.all_opponents) == 1:\n if len(self.winner_list_temp) >= 1:\n opponent09 = self.winner_list_temp[0]\n if len(self.winner_list_temp) >= 2:\n opponent10 = self.winner_list_temp[1]\n if len(self.winner_list_temp) >= 3:\n opponent11 = self.winner_list_temp[2]\n if len(self.all_opponents) >= 2:\n opponent09 = self.all_opponents[1][0][0]\n opponent10 = self.all_opponents[1][0][1]\n opponent11 = self.all_opponents[1][1][0]\n opponent12 = self.all_opponents[1][1][1]\n if len(self.winner_list_temp) >= 1:\n opponent13 = self.winner_list_temp[0]\n if len(self.all_opponents) >= 3:\n opponent13 = self.all_opponents[2][0][0]\n opponent14 = self.all_opponents[2][0][1]\n if len(self.winner_list) == 3:\n winner = self.winner_list[2][0]\n\n first_game = [opponent01, opponent02, opponent03, opponent04, opponent05, opponent06, opponent07, opponent08]\n max_string = len(max(first_game, key=len))\n string_size1 = len(opponent01)\n padding1 = \"\".ljust(int(max_string-string_size1), '-')\n string_size2 = len(opponent02)\n padding2 = \"\".ljust(int(max_string-string_size2), '-')\n string_size3 = len(opponent03)\n padding3 = \"\".ljust(int(max_string-string_size3), '-')\n string_size4 = len(opponent04)\n padding4 = \"\".ljust(int(max_string-string_size4), '-')\n string_size5 = len(opponent05)\n padding5 = \"\".ljust(int(max_string-string_size5), '-')\n string_size6 = len(opponent06)\n padding6 = \"\".ljust(int(max_string-string_size6), '-')\n string_size7 = len(opponent07)\n padding7 = \"\".ljust(int(max_string-string_size7), '-')\n string_size8 = len(opponent08)\n padding8 = \"\".ljust(int(max_string-string_size8), '-')\n string_size9 = len(opponent01+padding1)\n padding9 = \"\".ljust(string_size9, ' ')\n string_size10 = max(len(opponent09), len(opponent10), len(opponent11), len(opponent12)) - len(opponent09)\n padding10 = \"\".ljust(string_size10, '-')\n string_size11 = max(len(opponent09), len(opponent10), len(opponent11), len(opponent12)) - len(opponent10)\n padding11 = \"\".ljust(string_size11, '-')\n string_size12 = max(len(opponent09), len(opponent10), len(opponent11), len(opponent12)) - len(opponent11)\n padding12 = \"\".ljust(string_size12, '-')\n string_size13 = max(len(opponent09), len(opponent10), len(opponent11), len(opponent12)) - len(opponent12)\n padding13 = \"\".ljust(string_size13, '-')\n string_size14 = len(padding9+\"|---\"+opponent09+padding10) - len(opponent02+padding2) - 1\n padding14 = \"\".ljust(string_size14, ' ')\n string_size15 = len(padding9+\"|---\"+opponent09+padding10)\n padding15 = \"\".ljust(string_size15, ' ')\n string_size16 = max(len(opponent13), len(opponent14)) - len(opponent13)\n padding16 = \"\".ljust(string_size16, '-')\n string_size17 = max(len(opponent13), len(opponent14)) - len(opponent14)\n padding17 = \"\".ljust(string_size17, '-')\n string_size18 = len(opponent14+padding17) + 3\n padding18 = \"\".ljust(string_size18, ' ')\n string_size19 = len(padding15+\"|---\"+opponent14+padding17) - len(opponent08+padding8) - 1\n padding19 = \"\".ljust(string_size19, ' ')\n string_size20 = len(padding15+\"|---\"+opponent14+padding17)\n padding20 = \"\".ljust(string_size20, ' ')\n\n display += opponent01+padding1+\"|\"+\"\\n\"\n display += padding9+\"|---\"+opponent09+padding10+\"|\"+\"\\n\"\n display += opponent02+padding2+\"|\"+padding14+\"|\"+\"\\n\"\n display += padding15+\"|---\"+opponent13+padding16+\"|\"+\"\\n\"\n display += opponent03+padding3+\"|\"+padding14+\"|\"+padding18+\"|\"+\"\\n\"\n display += padding9+\"|---\"+opponent10+padding11+\"|\"+padding18+\"|\"+\"\\n\"\n display += opponent04+padding4+\"|\"+padding19+\"|\"+\"\\n\"\n display += padding20+\"|---\"+winner+\"\\n\"\n display += opponent05+padding5+\"|\"+padding19+\"|\"+\"\\n\"\n display += padding9+\"|---\"+opponent11+padding12+\"|\"+padding18+\"|\"+\"\\n\"\n display += opponent06+padding6+\"|\"+padding14+\"|\"+padding18+\"|\"+\"\\n\"\n display += padding15+\"|---\"+opponent14+padding17+\"|\"+\"\\n\"\n display += opponent07+padding7+\"|\"+padding14+\"|\"+\"\\n\"\n display += padding9+\"|---\"+opponent12+padding13+\"|\"+\"\\n\"\n display += opponent08+padding8+\"|\"+\"\\n\"\n\n return display","def get_top_games_from_title_for_game(app_id: str, candidate_games: List[str],\n threshold=0.5) -> List[Dict]:\n if not app_id or not candidate_games:\n return []\n ranking_info = get_matched_game_ranking_info_for_game(app_id=app_id)\n res = []\n for app_id, score in ranking_info.items():\n if score >= threshold and app_id in candidate_games:\n game_obj: Game = Game.query.filter_by(app_id=app_id).all()[0]\n game_info = {\n 'app_id': app_id,\n 'name': game_obj.name,\n 'developer': \", \".join(json.loads(game_obj.developer)),\n 'publisher': \", \".join(json.loads(game_obj.publisher)),\n 'tags': json.loads(game_obj.tags),\n 'genre': json.loads(game_obj.genre),\n 'single_player': game_obj.single_player,\n 'multi_player': game_obj.multi_player,\n 'rating': game_obj.rating,\n 'mature_content': game_obj.mature_content,\n 'title_match_score': score}\n res.append(game_info)\n return res","def get_scoreboard() -> Tuple[Union[None, Dict[int, Dict[str, int]]], Error]:\n sql = '''\n SELECT\n `group_id`,\n `task_id`,\n COALESCE(SUM(`is_correct` = 1), 0) AS `success_count`,\n COALESCE(SUM(`is_correct` = 0), 0) AS `fail_count`\n FROM `submissions`\n GROUP BY `group_id`, `task_id`\n '''\n\n try:\n cur = con.execute(sql)\n rows = cur.fetchall()\n con.commit()\n\n tasks = get_all_tasks()\n table = {i: {task['task_id']: 0 for task in tasks} for i in range(1, 10)}\n\n if rows is None:\n return (table, None)\n\n for row in rows:\n group_id, task_id, success_count, fail_count = row\n task = get_task_by_id(task_id)\n\n if task is None:\n continue\n\n status = 0\n if 'max_attempt' in task and fail_count >= task['max_attempt']:\n status = -1\n elif success_count > 0:\n status = 1\n\n table[group_id][task_id] = status\n\n return (table, None)\n\n except sqlite3.Error as err:\n handle_error(err)\n return (None, ' '.join(err.args))","def FromGameInfo(cls, info, team_tourney_map):\n teams = [\n Team(score_reporter_id=team_tourney_map.get(info.home_team_link, '')),\n Team(score_reporter_id=team_tourney_map.get(info.away_team_link, '')),\n ]\n\n start_time = ParseStartTime(info.date, info.time)\n\n scores = []\n try:\n scores = [int(info.home_team_score),\n int(info.away_team_score)]\n except ValueError as e:\n if info.home_team_score.strip().lower() == 'w':\n scores = [1, -1]\n elif info.away_team_score.strip().lower() == 'w':\n scores = [-1, 1]\n else:\n # Unknown scores\n scores = [-1, -1]\n source = GameSource(type=scores_messages.GameSourceType.SCORE_REPORTER,\n score_reporter_url=info.tourney_id,\n update_date_time=datetime.utcnow()) \n \n name = info.bracket_title or info.pool_name\n status = scores_messages.GameStatus.UNKNOWN\n if info.status.lower() == 'final':\n status = scores_messages.GameStatus.FINAL\n return Game(id_str=info.id,\n name=name,\n teams=teams,\n scores=scores,\n tournament_id=info.tourney_name,\n tournament_name=info.tourney_name.replace('-', ' '),\n division=info.division,\n age_bracket=info.age_bracket,\n league=scores_messages.League.USAU,\n game_status=status,\n created_at=info.created_at,\n start_time=start_time,\n last_modified_at=datetime.utcnow(),\n sources=[source],\n key=game_key_full(info.id))","def readGameFile(games_data_filename):\n\tgame_stats = {}\n\tteam_stats = {}\n\twith open(games_data_filename) as csvfile:\n\t reader = csv.DictReader(csvfile)\n\t for row in reader:\n\t \tgame_id = row['game_id']\n\t \tteam_id = row['team_id']\n\t \twinner_id = row['winner_id']\n\t \tloser_id = None\n\t \t\n\t \twin = 0\n\t \tif team_id == winner_id:\n\t \t\twin = 1\n\t \telse:\n\t \t\tloser_id = team_id\n\n\t \tif not game_stats.get(game_id):\n\t \t\tgame_stats[game_id] = {'winner_team_id': winner_id, 'loser_team_id':'', 'winner_player_ids':[], 'loser_player_ids':[], 'winner_kills': 0, 'loser_kills': 0, 'winner_deaths': 0, 'loser_deaths': 0, 'winner_assists': 0, 'loser_assists': 0, 'winner_gold': 0, 'loser_gold': 0}\n\n\t \tif loser_id is not None:\n\t \t\tgame_stats[game_id]['loser_team_id'] = loser_id\n\treturn game_stats","def test_get_player_stats_from_game():\n team = \"Titans\"\n year = \"2018\"\n week = \"1\"\n expected_team_stats = {}\n\n assert ff_team.get_player_stats_from_game(\n team, year, week) == expected_team_stats","def calculate_scores(self):\n words = self.walk_board()\n player_scores = {}\n for word in words:\n player = word.get_owning_player()\n if player not in player_scores:\n player_scores[player] = 0\n player_scores[player] += word.get_score()\n return player_scores","def get_team_scores(self, team, include_home=True, include_away=True):\n if include_away:\n away_games = list(filter(lambda g: team == g.AwayTeam, self.games))\n else:\n away_games = []\n\n if include_home:\n home_games = list(filter(lambda g: team == g.HomeTeam, self.games))\n else:\n home_games = []\n\n scored_h = [g.FTHG for g in home_games]\n scored_a = [g.FTAG for g in away_games]\n\n conceded_h = [g.FTAG for g in home_games]\n conceded_a = [g.FTHG for g in away_games]\n\n try:\n mean_gd = mean(scored_h + scored_a) - mean(conceded_h + conceded_a)\n home_gd = mean(scored_h) - mean(conceded_h)\n home_adv = home_gd - mean_gd\n except Exception:\n home_adv = 0\n\n return {\n \"scored_xg\": scored_h + scored_a,\n \"conceded_xg\": conceded_h + conceded_a,\n \"home_adv\": home_adv,\n \"expected_points\": self.get_table(metric='points')[team] /\n len(home_games + away_games)\n }","def retrieveGames():\n result = cs411_game.getGames()\n return prepJSON(result)","def get_stats():\n team_dict = {}\n # parse team names\n with open('../data/teams.txt') as teams:\n team_name_list = teams.readlines()\n for team in team_name_list:\n team_dict[team.rstrip()] = Team(team)\n\n # parse rankings\n with open('../data/rankings.csv') as csv_file:\n csv_reader = csv.reader(csv_file, delimiter=',')\n line_count = 0\n for row in csv_reader:\n for team_name in team_dict.keys():\n if team_name == \"Northeastern\" and \"REB MAR\" in row: # bad patch\n team_dict[team_name].stats.append(0)\n elif team_name in row:\n team_dict[team_name].stats.append(row[-1])\n matrix = np.array([t.stats for t in team_dict.values()])\n return team_dict, matrix","def leaderboard(request):\r\n\tMEDIA_URL = '/media/'\r\n\tgames = Game.objects.all()\r\n\tuser_high_scores = []\r\n\tgame_high_scores = []\r\n\tnew = {}\r\n\t# Get global scores\r\n\tfor game in games:\r\n\t\tgame_intermediate_high = Score.objects.filter(game = game.id).order_by('-current_score').values('game__name', 'player__user__username', 'current_score')[:1]\r\n\t\tif (game_intermediate_high.count() > 0):\r\n\t\t\tgame_high_scores.append(game_intermediate_high)\r\n\t# Check if user is authenticated and get user's scores\r\n\tif (request.user.is_authenticated):\r\n\t\tfor game in games:\r\n\t\t\t\tuser_intermediate_high = Score.objects.filter(game=game.id, player = request.user.profile).order_by('-current_score').values('player__user__username','game__name', 'current_score').distinct()[:1]\r\n\t\t\t\tif (user_intermediate_high.count() > 0):\r\n\t\t\t\t\tuser_high_scores.append(user_intermediate_high)\r\n\r\n\treturn render(request, 'leaderboard.html',{'MEDIA_URL' : MEDIA_URL,'games': games, 'user_high_scores': user_high_scores, 'game_high_scores': game_high_scores})","def matchscore(self):\n print(self.team1.name + \" \" + str(self.team1score) + \" - \" + str(self.team2score) + \" \" + self.team2.name)","def _get_live_games(self):\n response = requests.get(self._get_score_url())\n if response.status_code == 200:\n return [g for g in response.json()['games'] if g['status']['state'] == self.desired_game_state]","def display_get_game():\n title = input(\"Please give me a title searched game: \")\n info_about_game = reports.get_game(filename, title)\n print(\"Properties of the game: {}\\n\".format(info_about_game))","def play_n_game(n_games, n_toss):\n results_list = []\n for _ in range(n_games):\n results_list.append(play_one_game(n_toss))\n dict_proba = {}\n for j in range (n_toss + 1):\n if results_list.count(j) != 0:\n dict_proba[j] = results_list.count(j)/n_games\n else:\n continue\n return dict_proba","def live_scores():\n live_scores = cache.get('FOOTBALL_LIVE_SCORES')\n if live_scores:\n scores_array = []\n for score in json.loads(live_scores)[0:3]:\n if not score['LIVE']:\n scores_array.append(score) \n return {'live_scores': scores_array}\n else:\n return {}","def reduce_games(game):#game=player_games[0]\n res = []\n res.append(('id', game['id']) )\n res.append(('annulled', game['annulled']))\n res.append(('black', int(game['black'])))\n res.append(('white', int(game['white'])))\n res.append(('white_lost', int(game['white_lost']) ))\n res.append(('black_lost', int(game['black_lost']) ))\n res.append(('outcome', game['outcome']))\n res.append(('handicap', game['handicap']))\n res.append(('komi', game['komi']))\n res.append(('ranked', game['ranked']))\n res.append(('width', game['width']))\n res.append(('height', game['height']))\n res.append(('rules', game['rules']))\n res.append(('started', game['started']))\n res.append(('ended', game['ended']))\n players = game['historical_ratings'].keys()\n res.append(('black_rating', game['historical_ratings']['black']['ratings']['overall']['rating'] if 'black' in players else None))\n res.append(('white_rating', game['historical_ratings']['white']['ratings']['overall']['rating'] if 'white' in players else None))\n res.append(('black_deviation', game['historical_ratings']['black']['ratings']['overall']['deviation'] if 'black' in players else None))\n res.append(('white_deviation', game['historical_ratings']['white']['ratings']['overall']['deviation'] if 'white' in players else None))\n res.append(('black_volatility', game['historical_ratings']['black']['ratings']['overall']['volatility'] if 'black' in players else None))\n res.append(('white_volatility', game['historical_ratings']['white']['ratings']['overall']['volatility'] if 'white' in players else None))\n res.append(('black_ranking', game['historical_ratings']['black']['ranking'] if 'black' in players else None))\n res.append(('white_ranking', game['historical_ratings']['white']['ranking'] if 'white' in players else None))\n res.append(('tournament', not game['tournament'] is None))\n return res","async def check_games(self, ctx):\n print(self.data)\n print(self.games_info)","def get(self, request):\n\n queries = request.GET.dict()\n user = UserValidator.validate_user(request.user.id)\n\n if user is None:\n return JsonResponse({\n \"message\": \"Invalid credentials.\",\n }, status=400)\n\n if user is None:\n return JsonResponse({\n \"message\": \"Invalid credentials.\",\n }, status=400)\n\n try:\n game = Game.value_of(queries[\"game\"].lower())\n\n except (KeyError, ValueError, Exception):\n game = None\n\n try:\n sort = queries[\"sort\"].lower()\n\n if sort not in [\"wins\", \"total\",]:\n raise ValueError(\"invalid key value\")\n\n except (KeyError, ValueError, Exception):\n sort = \"wins\"\n\n entries = GameModel.objects.values(\"player\").filter(is_deleted=False)\n\n if game is not None:\n entries = entries.filter(game_played=game)\n game = game.value\n else:\n game = \"All\"\n\n entries = entries.annotate(\n wins=(Count(\"player\", filter=Q(did_win=True))),\n total=(Count(\"player\"))\n )\n\n if sort == \"wins\":\n entries = entries.order_by(\"-wins\")\n elif sort == \"total\":\n entries = entries.order_by(\"-total\")\n\n board = ScoreboardView.get_board_from_db_rows(entries)\n\n token = Token.get_tokens_for_user(user)\n\n return JsonResponse({\n \"game\": game,\n \"board\": board,\n \"access\": token[\"access\"],\n \"refresh\": token[\"refresh\"],\n })","def get_top_games_from_title_for_movie(mov_tmt_path: str,\n candidate_games: List[str],\n threshold=0.5) -> List[Dict]:\n if not mov_tmt_path or not candidate_games:\n return []\n ranking_info = get_matched_game_ranking_info_for_movie(\n movie_id=mov_tmt_path)\n res = []\n for app_id, score in ranking_info.items():\n if score >= threshold and app_id in candidate_games:\n game_obj: Game = Game.query.filter_by(app_id=app_id).all()[0]\n game_info = {\n 'app_id': app_id,\n 'name': game_obj.name,\n 'developer': \", \".join(json.loads(game_obj.developer)),\n 'publisher': \", \".join(json.loads(game_obj.publisher)),\n 'tags': json.loads(game_obj.tags),\n 'genre': json.loads(game_obj.genre),\n 'single_player': game_obj.single_player,\n 'multi_player': game_obj.multi_player,\n 'rating': game_obj.rating,\n 'mature_content': game_obj.mature_content,\n 'title_match_score': score}\n res.append(game_info)\n return res","def play_by_play(game_id):\n\n # HTML Content\n r = requests.get('https://www.basketball-reference.com/boxscores/pbp/' + game_id + '.html')\n soup = BeautifulSoup(r.content, \"html.parser\")\n table = soup.find(id='pbp').find_all('tr')\n\n # MongoDB Collection\n m = mongo.Mongo()\n\n pbp = {\n 'home': [],\n 'away': []\n }\n\n quarter = 0\n pattern = re.compile('^[0-9]{1,3}:[0-9]{2}\\.[0-9]{1}$')\n\n for item in table:\n\n time = None\n x = 0\n\n play = {}\n\n # Iterate through row of stats, each row has 6 columns one half for each team\n for stat in item.find_all('td'):\n\n x += 1\n\n check = True\n\n # A player scored\n if \"makes\" in stat.text:\n scrape_utils.field_goal_update(stat.find('a')['href'], stat.text, play, True)\n # Player missed a shot\n elif \"misses\" in stat.text:\n scrape_utils.field_goal_update(stat.find('a')['href'], stat.text, play, False)\n # Account for other basketball stats\n elif \"Defensive rebound\" in stat.text:\n if 'Team' not in stat.text:\n play['drb'] = 1\n elif \"Offensive rebound\" in stat.text:\n if 'Team' not in stat.text:\n play['orb'] = 1\n elif \"Turnover\" in stat.text:\n play['turnover'] = 1\n elif \"foul\" in stat.text:\n play['foul'] = 1\n elif \"timeout\" in stat.text:\n play['timeout'] = 1\n elif \"enters\" in stat.text:\n play['sub'] = 1\n else:\n check = False\n\n # Determine if home or away\n if check is True:\n if x == 2:\n play['home'] = 0\n elif x == 6:\n play['home'] = 1\n\n # Different quarters including multiple overtimes\n if pattern.match(stat.text):\n time = scrape_utils.play_time(quarter, stat.text[:-2])\n\n if play:\n play['time'] = time\n\n if play['home'] == 1:\n del play['home']\n pbp['home'].append(play)\n else:\n del play['home']\n pbp['away'].append(play)\n\n # Going to next quarter\n if time is None:\n quarter += 1\n\n # Insert into database\n m.update('game_log', {'_id': game_id}, {'$set': {'pbp': pbp}})","def winning_games_stats(self):\n self.winning_games_up_to_2013 = (\n self.df\n .pipe(lambda x:x.assign(winning_num_counts = 1))\n .query(\"Season <= 2013\")\n .groupby(['Season','WTeamID'])\n .agg({\"WScore\":\"sum\",\"WFGM\":\"sum\",\"WFGA\":\"sum\",\"WFGM3\":\"sum\",\"WFGA3\":\"sum\",\"WFTM\":\"sum\",\"WFTA\":\"sum\",\"LScore\":\"sum\",\"winning_num_counts\":\"sum\",\n \"WOR\":\"sum\",\"WDR\":\"sum\",\"LFGM\":\"sum\",\"LFGA\":\"sum\",\n \"WAst\":\"sum\",\"WTO\":\"sum\",\"WStl\":\"sum\",\"WBlk\":\"sum\",\"WPF\":\"sum\"})\n .reset_index()\n .rename(columns={\"LScore\":\"losing_opponent_score\"})\n # rebounds\n .pipe(lambda x:x.assign(total_winning_rebounds = x.WOR + x.WDR))\n .pipe(lambda x:x.assign(winning_off_rebounds_percent = x.WOR/x.total_winning_rebounds))\n .pipe(lambda x:x.assign(winning_def_rebounds_percent = x.WDR/x.total_winning_rebounds))\n .pipe(lambda x:x.assign(team_missed_attempts = x.WFGA - x.WFGM))\n .pipe(lambda x:x.assign(opp_team_missed_attempts = x.LFGA - x.LFGM))\n .pipe(lambda x:x.assign(winning_rebound_possession_percent = x.WOR/x.team_missed_attempts))\n .pipe(lambda x:x.assign(winning_rebound_possessiongain_percent = x.WDR/x.opp_team_missed_attempts))\n # blocks, steals, assists and turnovers\n .pipe(lambda x:x.assign(winning_block_opp_FGA_percent = x.WBlk/x.LFGA))\n .pipe(lambda x:x.assign(winning_assist_per_fgm = x.WAst/x.WFGM))\n .pipe(lambda x:x.assign(winning_assist_turnover_ratio = x.WAst/x.WTO))\n # rename columns to prevent duplication when joining with losing stats. example: WFGM_x\n .rename(columns={\"LFGA\":\"LFGA_opp\",\"LFGM\":\"LFGM_opp\"})\n )","def gameOfLife(self, board: List[List[int]]) -> None:\n res = {}\n for i in range(len(board)):\n for j in range(len(board[0])):\n count = 0\n # top line\n if i-1 >= 0:\n # left-top\n if j-1>=0:\n if board[i-1][j-1]==1:\n count += 1\n # top\n if board[i-1][j]==1:\n count += 1\n # right-top\n if j+1<len(board[0]):\n if board[i-1][j+1]==1:\n count += 1\n # same line\n # left\n if j-1>=0:\n if board[i][j-1]==1:\n count += 1\n # right\n if j+1 < len(board[0]):\n if board[i][j+1]==1:\n count += 1\n # bottom line\n if i+1 < len(board):\n # left-bottom\n if j-1 >= 0:\n if board[i+1][j-1]==1:\n count += 1\n # bottom\n if board[i+1][j]==1:\n count += 1\n # right-bottom\n if j+1 < len(board[0]):\n if board[i+1][j+1]==1:\n count += 1\n # check\n if board[i][j]==0 and count==3:\n res[(i,j)] = 1\n if board[i][j]==1 and (count<2 or count>3):\n res[(i,j)] = 0\n for key in res:\n board[key[0]][key[1]] = res[key]","def get_team_stats(players: list[Player]) -> dict[int]:\n\n team_stats = {}\n\n total_reaction = 0\n total_mechanical_skill = 0\n total_tactical_skill = 0\n total_game_knowledge = 0\n total_xp = 0\n\n for player in players:\n total_reaction += player.reaction\n total_mechanical_skill += player.mechanical_skill\n total_tactical_skill += player.tactical_skill\n total_game_knowledge += player.game_knowledge\n total_xp += player.xp\n\n team_stats.update(\n {\"reaction\": total_reaction,\n \"mechanical_skill\": total_mechanical_skill,\n \"tactical_skill\": total_tactical_skill,\n \"game_knowledge\": total_game_knowledge,\n \"xp\": total_xp})\n\n return team_stats","def get_scores(self):\n precision = self.right / self.count\n APs = self.right_labels / self.count\n mAP = np.mean(APs)\n distance = self.distance / self.count\n\n return {'precision': precision,\n 'APs': APs,\n 'mAP': mAP,\n 'distance': distance\n }","def get_game_urls(year, week):\n base_url = \"https://www.pro-football-reference.com\"\n\n # URL for the summary of all games for a given week\n # This page has the each match up for the week and\n # a link to the detailed game stats \n url = \"https://www.pro-football-reference.com/years/{}/week_{}.htm\".format(\n year, week)\n\n response = get(url)\n\n week_summary = BeautifulSoup(response.content, 'html.parser')\n\n # Get just the game summary content\n week_summary_games = week_summary.find_all(\n attrs={\"class\": \"game_summary expanded nohover\"})\n\n losing_teams = []\n winning_teams = []\n game_link = []\n\n # For each game played, extract the losing team,\n # the winning team, and the detailed game stats link\n for game in week_summary_games:\n try:\n losing_team_strings = [text for text in game.find(\n attrs={\"class\": \"loser\"}).stripped_strings]\n losing_teams.append(losing_team_strings[0])\n except AttributeError:\n pass\n\n try:\n winning_team_strings = [text for text in game.find(\n attrs={\"class\": \"winner\"}).stripped_strings]\n winning_teams.append(winning_team_strings[0])\n except AttributeError:\n pass\n\n for link in game.find_all(href=re.compile(\"boxscores\")):\n game_link.append(base_url + link.get('href'))\n\n\n game_urls = dict(zip(losing_teams, game_link))\n game_urls.update(dict(zip(winning_teams, game_link)))\n\n return game_urls","def get_scores(self):\n\n\t\tscores = np.dot(self.rankings, self.weights)\n\t\tranked_indices = np.argsort(scores)\n\t\tranked_sources = self.source_names[ranked_indices]\n\t\tranked_scores = sorted(scores)\n\t\tself.scores = {source:score for source, score in zip(ranked_sources, ranked_scores)}\n\n\t\treturn self.scores","def get_smmry_data(soup, game_dict):\n\n # Get date and time data.\n try:\n date_soup = soup.find(\"div\", {\"class\": \"spielbericht_tipp_status\"})\n league = date_soup.div.span.text\n date_string = date_soup.div.text\n date = re.search(r'\\d{2}.\\d{2}.\\d{2}', date_string).group(0)\n time = re.search(r'\\d{2}:\\d{2}', date_string).group(0)\n matchday = re.search(r'[|]\\d+', date_string).group(0)[1:]\n\n game_dict[\"league\"] = league\n game_dict[\"fb_date\"] = date\n game_dict[\"fb_time\"] = time\n game_dict[\"matchday\"] = matchday\n except AttributeError:\n pass\n\n # Get game result.\n try:\n result = soup.find(\"div\", {\"class\": \"stand\"}).text\n game_dict[\"result\"] = result\n except AttributeError:\n pass\n\n # Try to get the referee name.\n try:\n referee = soup.find(\"span\", {\"class\": \"schiri_link\"}).text\n game_dict[\"referee\"] = referee\n except AttributeError:\n pass\n\n # Get team, club name and repective url by team.\n try:\n smmry_soup = soup.find(\n \"div\", {\"class\": \"spielbericht_ergebnis_wrapper\"})\n club_title = smmry_soup.find_all(\"img\")\n team_title = smmry_soup.findAll(\"div\", {\"class\": \"teaminfo\"})\n\n # Loop through teams.\n for j, team in enumerate([\"home_\", \"away_\"]):\n game_dict[team + \"team\"] = team_title[j].a[\"title\"]\n game_dict[team + \"team_url\"] = team_title[j].a[\"href\"]\n game_dict[team + \"club\"] = club_title[j][\"title\"]\n except (AttributeError, TypeError):\n pass\n\n return game_dict","def parse_scores(option, table_num, language, min_score, max_score):\n html = query_by_lang(BASE_URL + '/' + option, language)\n table = html.find_all(\"table\")[table_num]\n freq_list = table.find_all(\"tr\")[2:]\n\n # Create the dictionary\n list_min = find_min(freq_list)\n list_max = find_max(freq_list)\n return create_dict(freq_list, list_min, list_max, min_score, max_score)","def get_perfect_information(self):\n state = {}\n state[\"chips\"] = [self.game.players[i].in_chips for i in range(self.player_num)]\n state[\"public_card\"] = (\n self.game.public_card.get_index() if self.game.public_card else None\n )\n state[\"hand_cards\"] = [\n self.game.players[i].hand.get_index() for i in range(self.player_num)\n ]\n state[\"current_round\"] = self.game.round_counter\n state[\"current_player\"] = self.game.game_pointer\n state[\"legal_actions\"] = self.game.get_legal_actions()\n return state","def apiGameState(game_id):\n if game_id not in games:\n abort(404)\n room = games[game_id]\n # Maybe we also want like, \"last move\"?\n info = dict(board = room.game._board.tolist(),\n n_players = room.game.n_players,\n last_played = room.last_move)\n if room.time_limit > 0:\n info[\"time_limit\"] = room.time_limit\n\n # Indicate the state of the game\n if not room.full():\n info[\"state\"] = \"waiting\"\n info[\"joined\"] = len(room.players)\n elif room.game.winner is not None:\n info[\"state\"] = \"finished\"\n info[\"winner\"] = room.game.winner\n else:\n info[\"state\"] = \"playing\"\n info[\"turn\"] = room.game.player_turn\n return info","def get_games():\n page: int = int(flask.request.args.get(\"page\", 1))\n size: int = int(flask.request.args.get(\"size\", 10))\n\n request = GetPageRequest(page, size)\n response = minesweeper_service.get_game_page(request)\n return flask.jsonify(response)","def get_baseball_data():\n\n baseball_data = [\n {\n 'team_name': 'Boston', 'wins': 103, 'losses': 47,\n 'wins_in_last_ten': 7, 'streak': 'W2'\n },\n {\n 'team_name': 'NY Yankees', 'wins': 91, 'losses': 58,\n 'wins_in_last_ten': 4, 'streak': 'L2'\n },\n {\n 'team_name': 'Tampa Bay', 'wins': 83, 'losses': 66,\n 'wins_in_last_ten': 8, 'streak': 'W3'\n },\n {\n 'team_name': 'Toronto', 'wins': 68, 'losses': 82,\n 'wins_in_last_ten': 5, 'streak': 'W3'\n },\n {\n 'team_name': 'Baltimore', 'wins': 43, 'losses': 107,\n 'wins_in_last_ten': 2, 'streak': 'L1'\n },\n {\n 'team_name': 'Cleveland', 'wins': 83, 'losses': 66,\n 'wins_in_last_ten': 4, 'streak': 'L1'\n },\n {\n 'team_name': 'Minnesota', 'wins': 69, 'losses': 81,\n 'wins_in_last_ten': 5, 'streak': 'W2'\n },\n {\n 'team_name': 'Detroit', 'wins': 61, 'losses': 89,\n 'wins_in_last_ten': 4, 'streak': 'L1'\n },\n {\n 'team_name': 'Chi White Sox', 'wins': 59, 'losses': 90,\n 'wins_in_last_ten': 3, 'streak': 'L1'\n },\n {\n 'team_name': 'Kansas City', 'wins': 52, 'losses': 98,\n 'wins_in_last_ten': 6, 'streak': 'L2'\n },\n {\n 'team_name': 'Houston', 'wins': 94, 'losses': 56,\n 'wins_in_last_ten': 7, 'streak': 'L1'\n },\n {\n 'team_name': 'Oakland', 'wins': 90, 'losses': 60,\n 'wins_in_last_ten': 7, 'streak': 'L2'\n },\n {\n 'team_name': 'Seattle', 'wins': 83, 'losses': 67,\n 'wins_in_last_ten': 5, 'streak': 'W1'\n },\n {\n 'team_name': 'LA Angels', 'wins': 74, 'losses': 76,\n 'wins_in_last_ten': 6, 'streak': 'W1'\n },\n {\n 'team_name': 'Texas', 'wins': 64, 'losses': 86,\n 'wins_in_last_ten': 3, 'streak': 'L2'\n }\n ]\n\n return baseball_data","def get_scores(self, tournament: Tournament):\n self.model.eval()\n # collate_fn = lambda x: collate_teams(x, tournament.max_members)\n dl_rank = DataLoader(tournament.ranking, num_workers=self.jobs, batch_size=self.bs, shuffle=False)\n iterator = tqdm(dl_rank, position=0, desc=f'{tournament.tournament_id} ranking', disable=True)\n scores = []\n for i, team in enumerate(iterator):\n score = self.model.get_team_score(team.to(self.device))\n scores.append(score.cpu().numpy())\n\n scores = np.concatenate(scores)\n return scores.flatten()","def get_eq_scores(self) -> Dict[str, float]:\n eq_agent_states = dict(\n (\n agent_pbk,\n AgentState(\n self.game.initialization.eq_money_holdings[i],\n [int(h) for h in self.game.initialization.eq_good_holdings[i]],\n self.game.initialization.utility_params[i],\n ),\n )\n for agent_pbk, i in zip(\n self.game.configuration.agent_pbks,\n range(self.game.configuration.nb_agents),\n )\n ) # type: Dict[str, AgentState]\n\n result = {\n self.game.configuration.agent_pbk_to_name[\n agent_pbk\n ]: eq_agent_state.get_score()\n for agent_pbk, eq_agent_state in eq_agent_states.items()\n }\n return result","def get_games():\n\n return jsonify({\"games\": list(map(make_public_game, games))})","def perform_get_scores(responder, options):\n match = options['<match-id>']\n all_scores = scores.get_match_scores(match)\n\n if options.get(yaml_opt, False):\n responder(yaml.dump({'scores': all_scores}))\n else:\n if all_scores is None:\n responder('No scores available for match {0}'.format(match))\n else:\n for tla, score in all_scores.iteritems():\n responder('Team {0} scored {1} in match {2}'.format(tla, score, match))","def getScore(self,board):\n return board.getScore()[self.tile]","def players(game_id):\n # get data\n data = mlbgame.data.get_players(game_id)\n # parse data\n parsed = etree.parse(data)\n root = parsed.getroot()\n\n output = {}\n output['game_id'] = game_id\n\n # get player/coach data\n for team in root.findall('team'):\n type = team.attrib['type'] + \"_team\"\n # the type is either home_team or away_team\n output[type] = {}\n output[type]['players'] = []\n output[type]['coaches'] = []\n\n for p in team.findall('player'):\n player = {}\n for key in p.keys():\n player[key] = p.get(key)\n output[type]['players'].append(player)\n\n for c in team.findall('coach'):\n coach = {}\n for key in c.keys():\n coach[key] = c.get(key)\n output[type]['coaches'].append(coach)\n\n # get umpire data\n output['umpires'] = []\n for u in root.find('umpires').findall('umpire'):\n umpire = {}\n for key in u.keys():\n umpire[key] = u.get(key)\n output['umpires'].append(umpire)\n\n return output","def print_scores(board: Connect4Board) -> None:\r\n print('')\r\n # print('\\n******************************')\r\n # print('************SCORES************')\r\n # print('******************************')\r\n # print(' BLACK = {} & WHITE = {} '.format(board.get_score('B'), board.get_score('W')))\r\n # print('******************************\\n')\r","def getScores():\r\n results = \"\"\r\n with sqlite3.connect(database_file) as conn:\r\n cursor = conn.cursor()\r\n team_scores = cursor.execute(\"\"\" SELECT * FROM scores;\"\"\")\r\n\r\n for row in team_scores.fetchall():\r\n teamname, auto, rc, spirit, video = row\r\n results += result_string.format(teamname, auto, rc, spirit, video) + \"\\n\"\r\n return results","def get_games_overall(self, uuid):\n\n return self.template(uuid, \"games\")","def test_get_game_boxscore(self):\n pass","async def finish_game(self, ctx: commands.Context, score: dict):\n # Print out scoreboard, and winner, then give the winners their points\n scoreboard = sorted(score.items(), key=lambda x:x[1], reverse=True)\n result = \"**SCOREBOARD:**\\n\"\n condition = min(len(scoreboard), 9)\n\n # Find up to the 9th place\n # ranking_index[i] will give the index of the first person in the (i+1)th place\n ranking_index = [0]\n\n for i in range(1, len(scoreboard)):\n if scoreboard[i][1] == scoreboard[i-1][1]:\n continue\n ranking_index.append(i)\n if i >= condition: # Only want up to the 9th place\n break\n else:\n ranking_index.append(len(scoreboard))\n \n # Construct results of game and send to channel\n for i in range(len(ranking_index) - 1):\n result += (self.word_placing[i] \n + f\" place - {scoreboard[i][1]} points - \"\n + ', '.join(str(x[0]) for x in scoreboard[ranking_index[i]:ranking_index[i+1]])\n + '\\n')\n\n # Give points to everyone in first place\n for person in scoreboard[ranking_index[0]:ranking_index[1]]:\n self.data[ctx.guild.id]['score'][person[0].id] += 1\n\n result += \"Players in first place have earned one point each.\"\n await ctx.send(result)\n # Clear the database\n self.games_info[ctx.guild.id] = gamesDict()","def get_number_games(season: str, team_id: int, game_type_code: str = \"R\") -> dict:\n args = arguments.get_arguments()\n\n endpoint = f\"/schedule?teamId={team_id}&season={season}&gameType={game_type_code}\"\n response = api.nhl_api(endpoint)\n\n if response:\n schedule = response.json()\n games_total = schedule[\"totalItems\"]\n return games_total\n\n # If no valid response, just return default number of games (82)\n return 82","def nbaWorkout(gameInfo):\n \n if gameInfo['myScore'] >= 0 and gameInfo['opponentScore'] >= 0:\n if gameInfo['myScore'] > gameInfo['opponentScore']:\n determineRocketLeagueWin(gameInfo['goals'], gameInfo['assist'], gameInfo['saves'])\n else:\n determineRocketLeagueLoss(gameInfo['goals'], gameInfo['assist'], gameInfo['saves'])\n else:\n print(\"Doesn't make sense dude\")\n return workoutInfo","def _aggregate_scores(self,\n game_scores: List[Dict[str, int]]) -> task.ScoreData:\n\n relative_score = []\n recall = []\n num_incorrect = []\n precision = []\n\n for score_dict in game_scores:\n\n relative_score.append(score_dict['score']/score_dict['max_score'])\n recall.append(score_dict['num_correct']/score_dict['word_count'])\n num_incorrect.append(score_dict['num_incorrect'])\n\n # Precision -- defined to be 1 if no words are guessed.\n num_guesses = score_dict['num_correct'] + score_dict['num_incorrect']\n if num_guesses > 0:\n precision.append(score_dict['num_correct'] / num_guesses)\n else:\n precision.append(1.0)\n\n relative_score = np.mean(relative_score)\n recall = np.mean(recall)\n num_incorrect = np.mean(num_incorrect)\n precision = np.mean(precision)\n\n score_data = task.ScoreData(\n {'relative_score': relative_score,\n 'recall': recall,\n 'num_incorrect': num_incorrect,\n 'precision': precision},\n preferred_score='relative_score',\n low_score=0.0,\n high_score=1.0,\n number_of_shots=-1,\n subtask_description=('A simplified implementation of the NYT '\n 'Spelling Bee game. Individual game scoring is '\n 'defined in the class deffinition. Reported '\n 'scores are normalized to game maximums.'\n 'All scores are averaged over each game played '\n 'in an evaluation run.'))\n\n return score_data","def _get_current_teams_score(self):\n for game in self._get_live_games():\n teams_playing = [x['abbreviation'] for index, x in game['teams'].items()]\n if self.team in teams_playing:\n # Our team is playing in this game, get the score \n return int(game['scores'][self.team])","def rlWorkout(gameInfo):\n \n if gameInfo['myScore'] >= 0 and gameInfo['opponentScore'] >= 0:\n if gameInfo['myScore'] > gameInfo['opponentScore']:\n determineRocketLeagueWin(gameInfo['goals'], gameInfo['assist'], gameInfo['saves'])\n else:\n determineRocketLeagueLoss(gameInfo['goals'], gameInfo['assist'], gameInfo['saves'])\n else:\n print(\"Doesn't make sense dude\")\n return workoutInfo","def scores_for(self, board):\r\n scores = [50] * board.width\r\n\r\n for col in range(board.width):\r\n if not board.can_add_to(col):\r\n scores[col] = -1\r\n elif board.is_win_for(self.checker):\r\n scores[col] = 100\r\n elif board.is_win_for(self.opponent_checker()):\r\n scores[col] = 0\r\n elif self.lookahead == 0:\r\n scores[col] = 50\r\n else: \r\n board.add_checker(self.checker, col)\r\n opponent = AIPlayer(self.opponent_checker(), self.tiebreak, self.lookahead - 1)\r\n opp_scores = opponent.scores_for(board)\r\n if max(opp_scores) == 100:\r\n scores[col] = 0\r\n elif max(opp_scores) == 0:\r\n scores[col] = 100\r\n else:\r\n scores[col] = 50\r\n board.remove_checker(col)\r\n\r\n return scores","def get_player_data(soup, game_dict):\n\n # Loop through teams to store information by team.\n for i, team in enumerate([\"home\", \"away\"]):\n try:\n plyrs_soup = soup.findAll(\n \"div\", {\"class\": \"aufstellung_ausgabe_block {}side\".format(team)})[0]\n plyr_data = plyrs_soup.findAll(\"a\", {\"class\": \"spieler_linkurl\"})\n\n # Loop through players by team.\n for j, plyr in enumerate(plyr_data):\n try:\n game_dict[\"{}_plyr_{}\".format(team, j)] = plyr.text\n game_dict[\"{}_plyr_url_{}\".format(team, j)] = plyr[\"href\"]\n except AttributeError:\n pass\n except (AttributeError, IndexError):\n pass\n\n return game_dict","def games(self, competition_id: int, season_id: int) -> DataFrame[Any]:","def split_by_wins(matches, team_id):\n\n sorted_matches = {\n \"wins\": [],\n \"losses\": [],\n \"ties\": []\n }\n\n scores = {}\n\n for match_id, match in matches.items():\n this_team_score = 0\n other_team_score = 0\n if match.hometeam.team_id == team_id:\n this_team_score = match.homegoals\n other_team_score = match.awaygoals\n elif match.awayteam.team_id == team_id:\n this_team_score = match.awaygoals\n other_team_score = match.homegoals\n else:\n continue\n\n scores[match_id] = (this_team_score, other_team_score)\n\n if this_team_score > other_team_score:\n sorted_matches[\"wins\"].append(match_id)\n elif this_team_score < other_team_score:\n sorted_matches[\"losses\"].append(match_id)\n else:\n sorted_matches[\"ties\"].append(match_id)\n\n return sorted_matches, scores","def get_video_games(self, **kwargs):\n return self.get('video_games.json', **kwargs)","def main():\n\n # Ask for games to compare.\n games = {}\n more_games = True\n\n while more_games:\n search = input(\"Enter board game to search (leave empty if finished):\")\n\n if search:\n matches = bgg_compare.find_game(search)\n\n print(\"Games found:\")\n for game_id, name in matches.items():\n print(game_id + \"\\t\" + name)\n id = input(\"Enter the number before the intended game:\")\n games[id] = matches[id]\n\n else:\n more_games = False\n\n # If no games entered, compare all downloaded ratings.\n if not games:\n ids = []\n for f in glob.glob(\"[0-9]*.csv\"):\n id = os.path.splitext(f)[0]\n ids.append(id)\n game_info = bgg_compare.get_game_info(ids)\n for i, info in enumerate(game_info):\n name = info.find(\"name\", attrs={\"type\": \"primary\"})[\"value\"]\n games[ids[i]] = name\n\n print(\"Comparing games:\")\n\n all_ratings = []\n\n for game_id, name in games.items():\n\n print(name)\n\n ratings = {}\n filename = \"%s.csv\" % game_id\n\n try:\n ratings = bgg_compare.read_ratings(filename)\n except:\n ratings = bgg_compare.get_ratings(game_id)\n bgg_compare.write_ratings(ratings, filename)\n\n all_ratings.append(ratings)\n\n rankings = bgg_compare.condorcet_irv(all_ratings, list(games.keys()))\n\n print(\"Games ranked by Condorcet-IRV:\")\n\n header = [\"Rank\", \"ID\", \"Game\", \"Tiebreak\"]\n print(\"\\t\".join(header))\n\n for i, (game_id, tiebreak) in enumerate(rankings, 1):\n print(\"\\t\".join([str(i), game_id, games[game_id], str(tiebreak)]))\n\n outfile = input(\"Enter filename to save results (leave empty to not save)\")\n\n if outfile:\n with open(outfile, \"w\") as csvfile:\n writer = csv.writer(csvfile)\n writer.writerow(header)\n for i, (game_id, tiebreak) in enumerate(rankings, 1):\n writer.writerow([str(i), game_id, games[game_id], str(tiebreak)])","def main():\n\tresults = collections.OrderedDict()\n\n\tdb = read_database()\n\tprint(db)\n\tfor name in db.keys():\n\t\tresults[name] = []\n\n\n\tfor i in range(NUMBER_OF_RACES):\n\t\tsimulation = simulate_performance(db)\n\t\tpos = position(simulation)\n\n\t\tfor score, name in enumerate(pos,start = 1):\n\t\t\tresults[name].append(score)\n\t\t\n\n\tprint(results)\n\tresults = list(results.items()) # converts OrderedDict to the list\n\tprint(results)\n\tprint()\n\tprint(\"SORTED SCORES\")\n\tprint(sorted_scores(results))\n\tfor idx, sailor in enumerate(sorted_scores(results), start=1):\n\t\tprint(\"{:>2} {:>10} {:>10}\".format(idx, sailor[0], total_score(sailor)))\n\tss = sorted_scores(results)\n\n\tprint(\"\\n\\n*** PLACINGS ***\")\n\tprint(results)\n\treturn results\n\n\tprint(\"\\n\\n*** THE ORDER ***\")\n\tprint([x[0] for x in sorted_scores(results)])\n\treturn [x[0] for x in sorted_scores(results)]"],"string":"[\n \"def scoreboard(year, month, day, home=None, away=None):\\n # get data\\n data = mlbgame.data.get_scoreboard(year, month, day)\\n # parse data\\n parsed = etree.parse(data)\\n root = parsed.getroot()\\n games = {}\\n output = {}\\n # loop through games\\n for game in root:\\n if game.tag == 'data':\\n return []\\n # get team names\\n teams = game.findall('team')\\n home_name = teams[0].attrib['name']\\n away_name = teams[1].attrib['name']\\n # check if teams match parameters\\n if (home_name == home and home is not None) \\\\\\n or (away_name == away and away is not None) \\\\\\n or (away is None and home is None):\\n # throw all the data into a complicated dictionary\\n game_tag = game.tag\\n game_data = game.find('game')\\n game_id = game_data.attrib['id']\\n game_league = game_data.attrib['league']\\n game_status = game_data.attrib['status']\\n game_start_time = game_data.attrib['start_time']\\n home_team_data = teams[0].find('gameteam')\\n home_team = home_name\\n home_team_runs = int(home_team_data.attrib['R'])\\n home_team_hits = int(home_team_data.attrib['H'])\\n home_team_errors = int(home_team_data.attrib['E'])\\n away_team_data = teams[1].find('gameteam')\\n away_team = away_name\\n away_team_runs = int(away_team_data.attrib['R'])\\n away_team_hits = int(away_team_data.attrib['H'])\\n away_team_errors = int(away_team_data.attrib['E'])\\n # check type of game\\n if game_tag == 'go_game' or game_tag == 'ig_game':\\n try:\\n w_pitcher_data = game.find('w_pitcher')\\n w_pitcher = w_pitcher_data.find('pitcher').attrib['name']\\n w_pitcher_wins = int(w_pitcher_data.attrib['wins'])\\n w_pitcher_losses = int(w_pitcher_data.attrib['losses'])\\n except Exception:\\n w_pitcher = \\\"\\\"\\n w_pitcher_wins = 0\\n w_pitcher_losses = 0\\n try:\\n l_pitcher_data = game.find('l_pitcher')\\n l_pitcher = l_pitcher_data.find('pitcher').attrib['name']\\n l_pitcher_wins = int(l_pitcher_data.attrib['wins'])\\n l_pitcher_losses = int(l_pitcher_data.attrib['losses'])\\n except Exception:\\n l_pitcher = \\\"\\\"\\n l_pitcher_wins = 0\\n l_pitcher_losses = 0\\n try:\\n sv_pitcher_data = game.find('sv_pitcher')\\n sv_pitcher = sv_pitcher_data.find('pitcher').attrib['name']\\n sv_pitcher_saves = int(sv_pitcher_data.attrib['saves'])\\n except Exception:\\n sv_pitcher = \\\"\\\"\\n sv_pitcher_saves = 0\\n output = {\\n 'game_id': game_id,\\n 'game_tag': game_tag,\\n 'game_league': game_league,\\n 'game_status': game_status,\\n 'game_start_time': game_start_time,\\n 'home_team': home_team,\\n 'home_team_runs': home_team_runs,\\n 'home_team_hits': home_team_hits,\\n 'home_team_errors': home_team_errors,\\n 'away_team': away_team,\\n 'away_team_runs': away_team_runs,\\n 'away_team_hits': away_team_hits,\\n 'away_team_errors': away_team_errors,\\n 'w_pitcher': w_pitcher,\\n 'w_pitcher_wins': w_pitcher_wins,\\n 'w_pitcher_losses': w_pitcher_losses,\\n 'l_pitcher': l_pitcher,\\n 'l_pitcher_wins': l_pitcher_wins,\\n 'l_pitcher_losses': l_pitcher_losses,\\n 'sv_pitcher': sv_pitcher,\\n 'sv_pitcher_saves': sv_pitcher_saves\\n }\\n # games that were not played\\n elif game_tag == 'sg_game':\\n try:\\n p_pitcher_data = game.findall('p_pitcher')\\n p_pitcher_home_data = p_pitcher_data[0]\\n p_pitcher_home = p_pitcher_home_data.find(\\n 'pitcher').attrib['name']\\n p_pitcher_home_wins = int(p_pitcher_home_data.\\n attrib['wins'])\\n p_pitcher_home_losses = int(p_pitcher_home_data.\\n attrib['losses'])\\n p_pitcher_away_data = p_pitcher_data[1]\\n p_pitcher_away = p_pitcher_away_data.find(\\n 'pitcher').attrib['name']\\n p_pitcher_away_wins = int(p_pitcher_away_data.\\n attrib['wins'])\\n p_pitcher_away_losses = int(p_pitcher_away_data.\\n attrib['losses'])\\n except Exception:\\n p_pitcher_home = ''\\n p_pitcher_home_wins = 0\\n p_pitcher_home_losses = 0\\n p_pitcher_away = ''\\n p_pitcher_away_wins = 0\\n p_pitcher_away_losses = 0\\n output = {\\n 'game_id': game_id,\\n 'game_tag': game_tag,\\n 'game_league': game_league,\\n 'game_status': game_status,\\n 'game_start_time': game_start_time,\\n 'home_team': home_team,\\n 'home_team_runs': home_team_runs,\\n 'home_team_hits': home_team_hits,\\n 'home_team_errors': home_team_errors,\\n 'away_team': away_team,\\n 'away_team_runs': away_team_runs,\\n 'away_team_hits': away_team_hits,\\n 'away_team_errors': away_team_errors,\\n 'p_pitcher_home': p_pitcher_home,\\n 'p_pitcher_home_wins': p_pitcher_home_wins,\\n 'p_pitcher_home_losses': p_pitcher_home_losses,\\n 'p_pitcher_away': p_pitcher_away,\\n 'p_pitcher_away_wins': p_pitcher_away_wins,\\n 'p_pitcher_away_losses': p_pitcher_away_losses\\n }\\n # put this dictionary into the larger dictionary\\n games[game_id] = output\\n return games\",\n \"def get_matched_game_ranking_info_for_game(app_id: str) -> Dict[str, int]:\\n query_res = Game.query.filter_by(app_id=app_id).all()\\n if query_res:\\n return eval(query_res[0].games_title_match)\\n return dict()\",\n \"def get_games(date):\\n scoreboard = nba_py.Scoreboard(month=date.month,\\n day=date.day,\\n year=date.year)\\n line_score = scoreboard.line_score()\\n game_header = scoreboard.game_header()\\n\\n games = []\\n current_game = {}\\n game_sequence = 0\\n game_sequence_counter = 0\\n\\n # Get HOME TEAM and AWAY TEAM data for each boxscore game in line_score.\\n for i, value in enumerate(line_score):\\n if (value[\\\"GAME_SEQUENCE\\\"] != game_sequence):\\n game_sequence += 1\\n\\n current_game[\\\"GAME_ID\\\"] = value[\\\"GAME_ID\\\"]\\n home_team_id = game_header[game_sequence - 1][\\\"HOME_TEAM_ID\\\"]\\n\\n if (home_team_id == value[\\\"TEAM_ID\\\"]):\\n current_game[\\\"HOME_TEAM\\\"] = value[\\\"TEAM_ABBREVIATION\\\"]\\n current_game[\\\"HOME_TEAM_WINS_LOSSES\\\"] = value[\\\"TEAM_WINS_LOSSES\\\"]\\n current_game[\\\"HOME_TEAM_PTS\\\"] = value[\\\"PTS\\\"]\\n current_game[\\\"HOME_TEAM_ID\\\"] = value[\\\"TEAM_ID\\\"]\\n if (current_game[\\\"HOME_TEAM\\\"] in TEAM_ID_DATA):\\n current_game[\\\"HOME_TEAM_IMG\\\"] = TEAM_ID_DATA[current_game[\\\"HOME_TEAM\\\"]][\\\"img\\\"]\\n else:\\n current_game[\\\"AWAY_TEAM\\\"] = value[\\\"TEAM_ABBREVIATION\\\"]\\n current_game[\\\"AWAY_TEAM_WINS_LOSSES\\\"] = value[\\\"TEAM_WINS_LOSSES\\\"]\\n current_game[\\\"AWAY_TEAM_PTS\\\"] = value[\\\"PTS\\\"]\\n current_game[\\\"AWAY_TEAM_ID\\\"] = value[\\\"TEAM_ID\\\"]\\n if (current_game[\\\"AWAY_TEAM\\\"] in TEAM_ID_DATA):\\n current_game[\\\"AWAY_TEAM_IMG\\\"] = TEAM_ID_DATA[current_game[\\\"AWAY_TEAM\\\"]][\\\"img\\\"]\\n\\n if (value[\\\"TEAM_ABBREVIATION\\\"] in TEAMS):\\n if (home_team_id == value[\\\"TEAM_ID\\\"]):\\n current_game[\\\"HOME_TEAM_FULL_NAME\\\"] = TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"city\\\"] + \\\\\\n \\\" \\\" + TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"name\\\"]\\n else:\\n current_game[\\\"AWAY_TEAM_FULL_NAME\\\"] = TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"city\\\"] + \\\\\\n \\\" \\\" + TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"name\\\"]\\n \\n game_sequence = value[\\\"GAME_SEQUENCE\\\"]\\n game_sequence_counter += 1\\n elif game_sequence_counter == 1:\\n if (\\\"AWAY_TEAM\\\" in current_game):\\n current_game[\\\"HOME_TEAM\\\"] = value[\\\"TEAM_ABBREVIATION\\\"]\\n current_game[\\\"HOME_TEAM_WINS_LOSSES\\\"] = value[\\\"TEAM_WINS_LOSSES\\\"]\\n current_game[\\\"HOME_TEAM_PTS\\\"] = value[\\\"PTS\\\"]\\n current_game[\\\"HOME_TEAM_ID\\\"] = value[\\\"TEAM_ID\\\"]\\n if (current_game[\\\"HOME_TEAM\\\"] in TEAM_ID_DATA):\\n current_game[\\\"HOME_TEAM_IMG\\\"] = TEAM_ID_DATA[current_game[\\\"HOME_TEAM\\\"]][\\\"img\\\"]\\n else:\\n current_game[\\\"AWAY_TEAM\\\"] = value[\\\"TEAM_ABBREVIATION\\\"]\\n current_game[\\\"AWAY_TEAM_WINS_LOSSES\\\"] = value[\\\"TEAM_WINS_LOSSES\\\"]\\n current_game[\\\"AWAY_TEAM_PTS\\\"] = value[\\\"PTS\\\"]\\n current_game[\\\"AWAY_TEAM_ID\\\"] = value[\\\"TEAM_ID\\\"]\\n if (current_game[\\\"AWAY_TEAM\\\"] in TEAM_ID_DATA):\\n current_game[\\\"AWAY_TEAM_IMG\\\"] = TEAM_ID_DATA[current_game[\\\"AWAY_TEAM\\\"]][\\\"img\\\"]\\n\\n if (value[\\\"TEAM_ABBREVIATION\\\"] in TEAMS):\\n if (\\\"AWAY_TEAM\\\" in current_game):\\n current_game[\\\"HOME_TEAM_FULL_NAME\\\"] = TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"city\\\"] + \\\\\\n \\\" \\\" + TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"name\\\"]\\n else:\\n current_game[\\\"AWAY_TEAM_FULL_NAME\\\"] = TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"city\\\"] + \\\\\\n \\\" \\\" + TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"name\\\"]\\n\\n current_game[\\\"GAME_STATUS_TEXT\\\"] = game_header[game_sequence - 1][\\\"GAME_STATUS_TEXT\\\"]\\n if not game_header[game_sequence - 1][\\\"NATL_TV_BROADCASTER_ABBREVIATION\\\"]:\\n current_game[\\\"BROADCASTER\\\"] = \\\"\\\"\\n else:\\n current_game[\\\"BROADCASTER\\\"] = game_header[game_sequence - 1][\\\"NATL_TV_BROADCASTER_ABBREVIATION\\\"]\\n\\n games.append(current_game)\\n\\n current_game = {}\\n\\n game_sequence = value[\\\"GAME_SEQUENCE\\\"]\\n game_sequence_counter -= 1\\n\\n east_standings = scoreboard.east_conf_standings_by_day()\\n west_standings = scoreboard.west_conf_standings_by_day()\\n\\n return (games, east_standings, west_standings)\",\n \"def extract_games(self) -> Dict[int, Dict[str, Any]]:\\n optadocument = self._get_doc()\\n attr = assertget(optadocument, '@attributes')\\n matchdata = assertget(optadocument, 'MatchData')\\n matches = {}\\n for match in matchdata:\\n matchattr = assertget(match, '@attributes')\\n matchinfo = assertget(match, 'MatchInfo')\\n matchinfoattr = assertget(matchinfo, '@attributes')\\n game_id = int(assertget(matchattr, 'uID')[1:])\\n matches[game_id] = dict(\\n # Fields required by the base schema\\n game_id=game_id,\\n competition_id=int(assertget(attr, 'competition_id')),\\n season_id=int(assertget(attr, 'season_id')),\\n game_day=int(assertget(matchinfoattr, 'MatchDay')),\\n game_date=datetime.strptime(assertget(matchinfo, 'Date'), '%Y-%m-%d %H:%M:%S'),\\n # home_team_id=see below,\\n # away_team_id=see below,\\n # Optional fields\\n # home_score=see below,\\n # away_score=see below,\\n # duration=?\\n # referee=?\\n # venue=?,\\n # attendance=?\\n # home_manager=?\\n # away_manager=?\\n )\\n teamdata = assertget(match, 'TeamData')\\n for team in teamdata:\\n teamattr = assertget(team, '@attributes')\\n side = assertget(teamattr, 'Side')\\n teamid = assertget(teamattr, 'TeamRef')\\n score = assertget(teamattr, 'Score')\\n if side == 'Home':\\n matches[game_id]['home_team_id'] = int(teamid[1:])\\n matches[game_id]['home_score'] = int(score)\\n else:\\n matches[game_id]['away_team_id'] = int(teamid[1:])\\n matches[game_id]['away_score'] = int(score)\\n return matches\",\n \"def get_info(self):\\n players = self.player_set\\n if self.order_by == 'rank':\\n players = players.order_by('rank')\\n else:\\n players = players.order_by('-rating')\\n\\n # if players have None scores, move to the bottom\\n none_players = []\\n players = list(players)\\n for player in players:\\n if ((self.order_by == 'rank' and player.rank is None)\\n or (self.order_by == 'rating' and player.rating is None)):\\n none_players.append(player)\\n players.remove(player)\\n players.extend(none_players)\\n\\n return dict(\\n players = players,\\n players_json = json.dumps([\\n {\\n 'id': player.id,\\n 'name': \\\"%d %s\\\" % (\\n player.rank or len(players), player.name)\\n }\\n for player in players]),\\n num_matches = self.match_set.count(),\\n num_rounds = Round.objects.filter(match__company = self).count(),\\n recent_matches = (self.match_set\\n .order_by('-played_time')[:MATCH_RESULT_LIMIT]),\\n api_account_id = self.get_api_account_id(),\\n api_access_key = self.get_api_access_key()\\n )\",\n \"def get_games(self, split: dataset_split.DatasetSplit = None) -> Dict[str, cereal_bar_game.CerealBarGame]:\\n if not split:\\n all_games: Dict[str, cereal_bar_game.CerealBarGame] = dict()\\n for game_id, game in self._train_games.items():\\n all_games[game_id] = game\\n for game_id, game in self._dev_games.items():\\n all_games[game_id] = game\\n for game_id, game in self._test_games.items():\\n all_games[game_id] = game\\n return all_games\\n\\n if split in {dataset_split.DatasetSplit.TRAIN, dataset_split.DatasetSplit.UPDATE,\\n dataset_split.DatasetSplit.VALIDATION}:\\n games: Dict[str, cereal_bar_game.CerealBarGame] = dict()\\n for game_id, game in self._train_games.items():\\n if split == dataset_split.DatasetSplit.TRAIN:\\n games[game_id] = game\\n elif split == dataset_split.DatasetSplit.UPDATE and game_id in self._update_ids:\\n games[game_id] = game\\n elif split == dataset_split.DatasetSplit.VALIDATION and game_id in self._val_ids:\\n games[game_id] = game\\n return games\\n elif split == dataset_split.DatasetSplit.DEV:\\n return self._dev_games\\n elif split == dataset_split.DatasetSplit.TEST:\\n return self._test_games\\n else:\\n raise ValueError('Getting games with specified filename is not supported')\",\n \"def get_game_parameters(self, name):\\n param = {}\\n if self.supported_games.has_key(name):\\n param['game_name'] = self.supported_games[name].game_name\\n param['rows'] = self.supported_games[name].rows\\n param['cols'] = self.supported_games[name].cols\\n param['xpad'] = self.supported_games[name].xpad\\n param['ypad'] = self.supported_games[name].ypad\\n param['aux'] = self.supported_games[name].aux\\n return param\",\n \"def extractData(self) -> Dict[str, str]:\\n if self.hasScore():\\n result = {}\\n result[\\\"date\\\"] = self.getMatchDate()\\n result[\\\"score\\\"] = self.getMatchScore()\\n for team in self.TEAMS:\\n result[\\\"team_\\\" + team] = self.getSquadName(team)\\n\\n return result\\n return None\",\n \"def status_games(game=None):\\n if game is None:\\n aux = {}\\n for i in range(len(games)):\\n aux[\\\"Game \\\" + str(i)] = games.games_status[i]['Status']\\n return aux\\n else:\\n game = int(game)\\n return {\\\"Game \\\" + str(game): games.games_status[game]['Status']}\",\n \"def get_list_team_scores(self):\\n scores = defaultdict(lambda: {\\n \\\"scored_xg\\\": [],\\n \\\"conceded_xg\\\": [],\\n \\\"home_adv\\\": 0,\\n \\\"expected_points\\\": 0\\n })\\n\\n for g in self.games:\\n scores[g.HomeTeam][\\\"scored_xg\\\"].append(g.FTHG)\\n scores[g.HomeTeam][\\\"conceded_xg\\\"].append(g.FTAG)\\n scores[g.AwayTeam][\\\"scored_xg\\\"].append(g.FTAG)\\n scores[g.AwayTeam][\\\"conceded_xg\\\"].append(g.FTHG)\\n\\n for team in scores.keys():\\n scores[team][\\\"expected_points\\\"] = (self.get_table(metric='points')[team] /\\n len(scores[team][\\\"scored_xg\\\"]))\\n\\n return scores\",\n \"def get_matched_game_ranking_info_for_movie(movie_id: str) -> Dict[str, int]:\\n query_res = Movie.query.filter_by(link_id=movie_id).all()\\n if query_res:\\n return eval(query_res[0].games_title_match)\\n return dict()\",\n \"def box_score(game_id):\\n # get data\\n data = mlbgame.data.get_box_score(game_id)\\n # parse data\\n parsed = etree.parse(data)\\n root = parsed.getroot()\\n linescore = root.find('linescore')\\n result = dict()\\n result['game_id'] = game_id\\n # loop through innings and add them to output\\n for x in linescore:\\n inning = x.attrib['inning']\\n home = value_to_int(x.attrib, 'home')\\n away = value_to_int(x.attrib, 'away')\\n result[int(inning)] = {'home': home, 'away': away}\\n return result\",\n \"def calculate_scores(players):\\n scores = {}\\n for player in players.tuple_:\\n scores[player.id_] = player.score()\\n return scores\",\n \"def get_initial_scores(self) -> Dict[str, float]:\\n temp_game = Game(self.game.configuration, self.game.initialization)\\n scores_dict = {\\n self.game.configuration.agent_pbk_to_name[agent_pbk]: score\\n for agent_pbk, score in temp_game.get_scores().items()\\n }\\n return scores_dict\",\n \"def find_games(days_ahead=0):\\n headers = {\\n 'Host': 'stats.nba.com',\\n 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0',\\n 'Accept': 'application/json, text/plain, */*',\\n 'Accept-Language': 'en-US,en;q=0.5',\\n 'Referer': 'https://stats.nba.com/',\\n 'Accept-Encoding': 'gzip, deflate, br',\\n 'Connection': 'keep-alive',\\n 'x-nba-stats-origin': 'stats',\\n 'x-nba-stats-token': 'true'\\n }\\n board = scoreboardv2.ScoreboardV2(day_offset=days_ahead, headers=headers).get_data_frames()[0]\\n board.replace(id_to_abrv, inplace=True)\\n return board[['GAME_DATE_EST', 'GAME_ID', 'HOME_TEAM_ID', 'VISITOR_TEAM_ID']]\",\n \"def print_scoreboard(self):\\n output = ''\\n # parallel dictionaries with innings and scores\\n innings = []\\n away = []\\n home = []\\n for x in self:\\n innings.append(x['inning'])\\n away.append(x['away'])\\n home.append(x['home'])\\n # go through all the information and make a nice output\\n # that looks like a scoreboard\\n output += 'Inning\\\\t'\\n for x in innings:\\n output += str(x) + ' '\\n output += '\\\\n'\\n for x in innings:\\n output += '---'\\n output += '\\\\nAway\\\\t' + self.__enumerate_scoreboard(away)\\n output += '\\\\nHome\\\\t' + self.__enumerate_scoreboard(home)\\n return output\",\n \"def view_game(game):\\n game = int(game)\\n return {\\\"Board_view\\\": format_view(games.get_board(game)),\\n \\\"TimeStep\\\": games.get_timestep(game)}\",\n \"def get_scores(self):\\n return [(self.players[p.get_color()], p.get_score()) for p in self.state.get_players()]\",\n \"def getScorecard(self, **kwargs):\\n lstPlayers = []\\n for n,sc in enumerate(self._players):\\n dct = {\\n 'player': sc.doc,\\n 'in': sc.dct_net['in'],\\n 'out': sc.dct_net['out'],\\n 'total': sc.dct_net['total'],\\n 'holes': sc.dct_net['holes'],\\n 'bumps': sc._bumps,\\n }\\n line = '{:<3} {:>2}'.format(sc.getInitials(), sc.result.course_handicap)\\n for net,bump in zip(sc.dct_net['holes'][:9], sc._bumps[:9]):\\n nets = '{}{}'.format(bump*'*', net if net is not None else '')\\n line += ' {:>3}'.format(nets)\\n line += ' {:>4}'.format(dct['out'])\\n for net,bump in zip(sc.dct_net['holes'][9:], sc._bumps[9:]):\\n nets = '{}{}'.format(bump*'*', net if net is not None else '')\\n line += ' {:>3}'.format(nets)\\n line += ' {:>4} {:>4}'.format(dct['in'], dct['total'])\\n dct['line'] = line\\n lstPlayers.append(dct)\\n self.dctScorecard['players'] = lstPlayers\\n return self.dctScorecard\",\n \"def retrieve_score_spread(database_connection: mysql.connector.connect\\n ) -> List[Dict]:\\n\\n cursor = database_connection.cursor()\\n query = (\\\"SELECT pm.panelistscore, COUNT(pm.panelistscore) \\\"\\n \\\"FROM ww_showpnlmap pm \\\"\\n \\\"JOIN ww_shows s ON s.showid = pm.showid \\\"\\n \\\"WHERE pm.panelistscore IS NOT NULL \\\"\\n \\\"AND s.bestof = 0 AND s.repeatshowid IS NULL \\\"\\n \\\"GROUP BY pm.panelistscore \\\"\\n \\\"ORDER BY pm.panelistscore ASC;\\\")\\n cursor.execute(query)\\n result = cursor.fetchall()\\n cursor.close()\\n\\n if not result:\\n return None\\n\\n scores = []\\n counts = []\\n for row in result:\\n scores.append(row[0])\\n counts.append(row[1])\\n\\n return {\\\"scores\\\": scores, \\\"counts\\\": counts}\",\n \"def get_player_stats_from_game(team, year, week):\",\n \"def score(self):\\n return {\\n 'black': self._score[self.BLACK],\\n 'white': self._score[self.WHITE],\\n }\",\n \"def get_games(url):\\n \\n import urllib\\n import urllib2\\n import re\\n\\n response = urllib2.urlopen(url + 'matches')\\n html = response.read()\\n\\n games_html = re.findall('<tr class=\\\"match-row custom\\\">(.*?)</tr', html, flags=re.MULTILINE|re.DOTALL)\\n\\n games = []\\n\\n for game_html in games_html:\\n game_match = re.search('.*?<td>(.*?)</td>.*?<td class=\\\"align-center\\\">(.*?)</td>.*?<span class=\\\"match-win\\\">(.*?)</span>.*?<td class=\\\"align-right\\\">[\\\\r\\\\n\\\\t]*(.*?)[\\\\r\\\\n\\\\t]*</td>', game_html, flags=re.MULTILINE|re.DOTALL)\\n \\n game = {}\\n \\n if game_match:\\n game['map'] = game_match.group(1)\\n game['type'] = game_match.group(2)\\n game['outcome'] = game_match.group(3)\\n game['date'] = game_match.group(4)\\n games.append(game)\\n \\n return games\",\n \"def get_game_info(game_id):\\n url = 'http://stats.nba.com/stats/boxscoresummaryv2?GameID=%s' % (game_id)\\n response = requests.get(url, headers=HEADERS)\\n while response.status_code != 200:\\n response = requests.get(url)\\n headers = response.json()['resultSets'][0]['headers']\\n data = response.json()['resultSets'][0]['rowSet']\\n data = pd.DataFrame(data, columns=headers)\\n data = data[['GAME_ID', 'GAMECODE', 'HOME_TEAM_ID', 'VISITOR_TEAM_ID', 'SEASON']].T.squeeze()\\n data['GAMECODE'] = data['GAMECODE'].replace('/', '')\\n return data\",\n \"def overview(game_id):\\n output = {}\\n # get data\\n overview = mlbgame.data.get_overview(game_id)\\n # parse data\\n overview_root = etree.parse(overview).getroot()\\n\\n try:\\n output = add_raw_box_score_attributes(output, game_id)\\n except ValueError:\\n pass\\n\\n # get overview attributes\\n for x in overview_root.attrib:\\n output[x] = overview_root.attrib[x]\\n\\n # Get probable starter attributes if they exist\\n home_pitcher_tree = overview_root.find('home_probable_pitcher')\\n if home_pitcher_tree is not None:\\n output.update(build_namespaced_attributes(\\n 'home_probable_pitcher', home_pitcher_tree))\\n else:\\n output.update(build_probable_starter_defaults('home'))\\n\\n away_pitcher_tree = overview_root.find('away_probable_pitcher')\\n if away_pitcher_tree is not None:\\n output.update(build_namespaced_attributes(\\n 'away_probable_pitcher', away_pitcher_tree))\\n else:\\n output.update(build_probable_starter_defaults('away'))\\n\\n return output\",\n \"def match_game(self):\\n # TODO: split this out so hold'em is separate\\n return ['Settings arenaVersion 1.0',\\n 'Settings gameType NLHE',\\n 'Settings gameMode tournament', ]\",\n \"def compile_games(all_games):\\n compiled_games = {}\\n for game_data in all_games:\\n game_id = game_data[4]\\n team_data = extract_team_data(game_data)\\n home_team_abbrev = get_home_team(game_data[6])\\n if team_data[\\\"team_abbrev\\\"] == home_team_abbrev:\\n home_team = True\\n team_data = rename_features(team_data, \\\"home\\\")\\n else:\\n home_team = False\\n team_data = rename_features(team_data, \\\"away\\\")\\n\\n if game_id in compiled_games:\\n compiled_games[game_id] = {\\n **compiled_games[game_id],\\n **team_data\\n }\\n else:\\n if home_team:\\n winner = 1 if game_data[7] == \\\"W\\\" else 0\\n else:\\n winner = 0 if game_data[7] == \\\"W\\\" else 1\\n # game_date, win/loss, matchup all needed exactly once\\n compiled_games[game_id] = team_data\\n compiled_games[game_id][\\\"winner\\\"] = winner\\n compiled_games[game_id][\\\"game_date\\\"] = game_data[5]\\n compiled_games[game_id][\\\"game_id\\\"] = game_id\\n compiled_games[game_id][\\\"matchup_name\\\"] = game_data[6]\\n\\n return compiled_games\",\n \"def collect_stats(games: List[BaseGame], date_min = None, date_max = None):\\n if not games: games = self.games\\n\\n under2_5 = len(list(filter(lambda g: g.is_total_under(), games)))\\n under3_5 = len(list(filter(lambda g: g.is_total_under(3.5), games)))\\n under1_5 = len(list(filter(lambda g: g.is_total_under(1.5), games)))\\n\\n home_score = sum([g.FTHG for g in games])\\n away_score = sum([g.FTAG for g in games])\\n\\n home_wins = sum(1 for _ in filter(lambda g: g.is_home_win(), games))\\n away_wins = sum(1 for _ in filter(lambda g: g.is_away_win(), games))\\n draws = sum(1 for _ in filter(lambda g: g.is_draw(), games))\\n\\n return {\\n 'under2.5': float(under2_5) / len(games),\\n 'under3.5': float(under3_5) / len(games),\\n 'under1.5': float(under1_5) / len(games),\\n 'avgScoredHome': float(home_score) / len(games),\\n 'avgScoredAway': float(away_score) / len(games),\\n \\\"home_wins\\\": float(home_wins) / len(games),\\n \\\"away_wins\\\": float(away_wins) / len(games),\\n \\\"draws\\\": float(draws) / len(games),\\n }\",\n \"def status():\\n aux = {\\\"Number games\\\": len(games), \\\"Path execution\\\": path_games}\\n for j, game in enumerate(games.games_status):\\n aux[\\\"Game \\\" + str(j)] = game\\n return aux\",\n \"def retrieve_grouped_scores(database_connection: mysql.connector.connect\\n ) -> Dict:\\n cursor = database_connection.cursor()\\n query = (\\\"SELECT pm.panelistscore, COUNT(pm.panelistscore) \\\"\\n \\\"FROM ww_showpnlmap pm \\\"\\n \\\"JOIN ww_shows s ON s.showid = pm.showid \\\"\\n \\\"WHERE pm.panelistscore IS NOT NULL \\\"\\n \\\"AND s.bestof = 0 AND s.repeatshowid IS NULL \\\"\\n \\\"GROUP BY pm.panelistscore \\\"\\n \\\"ORDER BY pm.panelistscore ASC;\\\")\\n cursor.execute(query)\\n result = cursor.fetchall()\\n\\n if not result:\\n return None\\n\\n scores = []\\n for row in result:\\n score = OrderedDict()\\n score[\\\"score\\\"] = row[0]\\n score[\\\"count\\\"] = row[1]\\n scores.append(score)\\n\\n return scores\",\n \"def getScorecard(self, **kwargs):\\n self.dctScorecard[\\\"players\\\"] = [team.get_scorecard() for team in self.team_list]\\n return self.dctScorecard\",\n \"def get_score_dict(*args):\\n score_dict = {\\n 'error_percent': args[0],\\n 'error_absolute': args[1],\\n 'score': args[2],\\n }\\n return score_dict\",\n \"def getLeaderboard(self, **kwargs):\\n board = []\\n scores = sorted(self._players, key=lambda score: score.dct_net['total'])\\n pos = 1\\n prev_total = None\\n for sc in scores:\\n score_dct = {\\n 'player': sc.doc,\\n 'total' : sc.dct_net['total'],\\n }\\n if prev_total != None and score_dct['total'] > prev_total:\\n pos += 1\\n prev_total = score_dct['total']\\n score_dct['pos'] = pos\\n for n,net in enumerate(sc.dct_net['holes']):\\n if net == None:\\n break\\n else:\\n n += 1\\n score_dct['thru'] = n\\n score_dct['line'] = '{:<3} {:<6} {:>5} {:>4}'.format(\\n score_dct['pos'], score_dct['player'].nick_name, score_dct['total'], score_dct['thru'])\\n board.append(score_dct)\\n self.dctLeaderboard['leaderboard'] = board\\n return self.dctLeaderboard\",\n \"def as_dict(self):\\n return {\\n \\\"__bbref_boxscore__\\\": True,\\n \\\"boxscore_url\\\": self.boxscore_url,\\n \\\"bbref_game_id\\\": self.bbref_game_id,\\n \\\"game_meta_info\\\": self.game_meta_info.as_dict(),\\n \\\"away_team_data\\\": self.away_team_data.as_dict(),\\n \\\"home_team_data\\\": self.home_team_data.as_dict(),\\n \\\"innings_list\\\": as_dict_list(self.innings_list),\\n \\\"player_id_match_log\\\": self.player_id_match_log,\\n \\\"umpires\\\": as_dict_list(self.umpires),\\n \\\"player_team_dict\\\": self.player_team_dict,\\n \\\"player_name_dict\\\": self.player_name_dict,\\n }\",\n \"def instantiate_team_and_player_data(self, game_summary):\\n self.HomeTeamId = str(game_summary['g']['hls']['tid'])\\n self.VisitorTeamId = str(game_summary['g']['vls']['tid'])\\n self.HomeTeamAbbreviation = str(game_summary['g']['hls']['ta'])\\n self.VisitorTeamAbbreviation = str(game_summary['g']['vls']['ta'])\\n self.GameDate = game_summary['g']['gdte']\\n\\n self.Players = {\\n self.HomeTeamId: {\\n str(player['pid']): player['fn'] + ' ' + player['ln']\\n for player in game_summary['g']['hls']['pstsg'] if player['totsec'] > 0 # only keep track of stats for players who played\\n },\\n self.VisitorTeamId: {\\n str(player['pid']): player['fn'] + ' ' + player['ln']\\n for player in game_summary['g']['vls']['pstsg'] if player['totsec'] > 0 # only keep track of stats for players who played\\n },\\n }\\n if self.GameId in PLAYERS_MISSING_FROM_BOXSCORE.keys():\\n for team_id in PLAYERS_MISSING_FROM_BOXSCORE[self.GameId].keys():\\n for player_id in PLAYERS_MISSING_FROM_BOXSCORE[self.GameId][team_id].keys():\\n self.Players[team_id][player_id] = PLAYERS_MISSING_FROM_BOXSCORE[self.GameId][team_id][player_id]\",\n \"def _run_match(bots, nr_of_games) -> dict:\\n\\n start, game_results = datetime.now().timestamp(), _run_games(nr_of_games, bots)\\n match_duration = datetime.now().timestamp() - start\\n\\n match_json = _match_result(game_results, match_duration)\\n _print_match_end_score(match_json, match_duration)\\n return match_json\",\n \"def playerStandings(matchid):\\n DB = dbc()\\n c = DB.cursor()\\n c.execute('SELECT matches.playerid, name, win, total_matches, \\\\\\n score, played, bye \\\\\\n FROM matches JOIN players \\\\\\n ON matches.playerid = players.playerid \\\\\\n WHERE matches.matchid = %s \\\\\\n ORDER BY matches.score DESC', (matchid,))\\n player_stats = c.fetchall()\\n DB.close()\\n return player_stats\",\n \"def get_past_matches_data(team):\\n matches = team.get_past_matches()\\n match_list = []\\n for match in matches:\\n match_dict = {}\\n match_dict['match_date'] = match.match_date\\n match_dict['match_name'] = match.__str__()\\n match_dict['id'] = match.id\\n innings = match.get_innings()\\n if len(innings):\\n if innings[0].runs > innings[1].runs:\\n match_dict['winner_team'] = innings[0].bat_team\\n match_dict['win_margin'] = innings[0].runs - innings[1].runs\\n match_dict['win_type'] = 'Runs'\\n match_dict['winner_score'] = str(innings[0].runs) + '/' + str(innings[0].wickets)\\n else:\\n match_dict['winner_team'] = innings[1].bat_team\\n match_dict['win_margin'] = 10 - innings[1].wickets\\n match_dict['win_type'] = 'Wickets'\\n match_dict['winner_score'] = str(innings[1].runs) + '/' + str(innings[1].wickets)\\n match_list.append(match_dict)\\n return match_list\",\n \"def maps(matches):\\n if not matches:\\n print('no matches')\\n return None\\n\\n maps = {}\\n for match in matches:\\n map = match['map']\\n score = match['score']\\n result = match['result']\\n # add map to dictionary\\n if not map in maps:\\n maps[map] = {'wins': 0, 'losses': 0, 'winrate': 0.0}\\n map_data = maps[map]\\n if result:\\n map_data['wins'] += 1\\n else:\\n map_data['losses'] += 1\\n matches_played = map_data['wins'] + map_data['losses']\\n\\n # compute moving average on winrate\\n map_data['winrate'] = map_data['winrate'] + (result - map_data['winrate']) / matches_played\\n return maps\",\n \"def print_game_stats(games_won=games_won):\\n for k,v in games_won.items():\\n print(k)\\n print(v)\\n if v == 1:\\n print(f'{k} has won {v} game')\\n else:\\n print(f'{k} has won {v} games')\",\n \"def playerStandings():\\n # place all players in a dictionary\\n player_dict = {}\\n conn, c = connect()\\n c.execute(\\\"\\\"\\\"SELECT * FROM players;\\\"\\\"\\\")\\n for row in c.fetchall():\\n player_dict[row[0]] = [row[1], 0, 0]\\n\\n # count the number of win and matches in for all matches\\n c.execute(\\\"\\\"\\\"SELECT winner, loser FROM matches;\\\"\\\"\\\")\\n for row in c.fetchall():\\n if row[0] in player_dict:\\n player_dict[row[0]][1] += 1\\n player_dict[row[0]][2] += 1\\n if row[1] in player_dict:\\n player_dict[row[1]][2] += 1\\n\\n # compile win counts as the key to dictionary\\n win_count = {}\\n for i in player_dict:\\n wins = player_dict[i][1]\\n if wins in win_count:\\n win_count[wins].append((i, player_dict[i][0],\\n wins, player_dict[i][2]))\\n else:\\n win_count[wins] = [(i, player_dict[i][0],\\n wins, player_dict[i][2])]\\n\\n # compile output list\\n output_list = []\\n for i in sorted(win_count.keys(), reverse=True):\\n for j in win_count[i]:\\n output_list.append(j)\\n\\n return output_list\",\n \"def __show_scoreboard(self):\\n self.clear_screen()\\n\\n print('\\\\n' * 2, end=\\\"\\\")\\n for line in self.__fame:\\n print((\\\" \\\" * 5) + line, end=\\\"\\\")\\n print('\\\\n' * 2, end=\\\"\\\")\\n\\n with open(\\\"mastermind/assets/scores.json\\\", \\\"r\\\") as data:\\n board = list(load(data).items())\\n\\n space = \\\" \\\" * 11\\n print(f\\\"{space}RANK {'PLAYER':<30}\\\" +\\n f\\\"{'TIME':>7} (seconds){'POINTS':>29}\\\\n\\\")\\n\\n lines_printed = 0\\n for idx, entry in enumerate(board[:10]):\\n lines_printed += 1\\n space = \\\" \\\" * 10\\n n = idx + 1\\n year, month, day, time = entry[0].split(\\\" \\\")\\n points = entry[1][\\\"points\\\"]\\n playtime = entry[1][\\\"playtime\\\"]\\n player = entry[1][\\\"player\\\"]\\n\\n print(f\\\"{space}{n:>4}. {player:<30}\\\" +\\n f\\\"{playtime:>7,.2f}{points:>36}/15\\\")\\n\\n lines = \\\"\\\\n\\\" * (12 - lines_printed)\\n print(f\\\"{lines}{space}\\\", end=\\\"\\\")\\n sleep(.25)\\n self.cool_print(\\\"Press ENTER to return to player menu.\\\",\\n newline=False, margin=0)\\n input()\",\n \"def get_results(state): # TODO: Add equality case.\\n tie = False\\n if state.score[-1] == state.score[1]:\\n tie = True\\n\\n return {'tie': tie, 'winner': max(state.score, key=state.score.get),\\n 'score': state.score}\",\n \"def get_learning_data(self):\\n if self.teams is None:\\n self.build_teams()\\n\\n # now put together X and y for every match\\n return self.games.get_games(self.teams)\",\n \"def get_scoreboard(self):\\n cases = len(self.start_player_list)\\n\\n opponent03 = \\\"N/A\\\"\\n opponent04 = \\\"N/A\\\"\\n opponent05 = \\\"N/A\\\"\\n opponent06 = \\\"N/A\\\"\\n opponent07 = \\\"N/A\\\"\\n opponent08 = \\\"N/A\\\"\\n opponent09 = \\\"N/A\\\"\\n opponent10 = \\\"N/A\\\"\\n opponent11 = \\\"N/A\\\"\\n opponent12 = \\\"N/A\\\"\\n opponent13 = \\\"N/A\\\"\\n opponent14 = \\\"N/A\\\"\\n winner = \\\"N/A\\\"\\n\\n display = \\\"\\\\n\\\"\\n\\n # Game with 3 players\\n if cases == 3:\\n opponent01 = self.all_opponents[0][0][0]\\n opponent02 = self.all_opponents[0][0][1]\\n if len(self.all_opponents) == 2:\\n opponent03 = self.all_opponents[1][0][0]\\n opponent04 = self.all_opponents[1][0][1]\\n if len(self.winner_list) == 2:\\n winner = self.winner_list[1][0]\\n\\n first_game = [opponent01, opponent02]\\n max_string = len(max(first_game, key=len))\\n string_size1 = len(opponent01)\\n padding1 = \\\"\\\".ljust((int(max_string-string_size1)), '-')\\n string_size2 = len(max([opponent01, opponent02], key=len))\\n padding2 = \\\"\\\".ljust(string_size2, ' ')\\n string_size3 = len(opponent02)\\n padding3 = \\\"\\\".ljust((int(max_string)-string_size3), '-')\\n string_size4 = len(padding2+\\\"|---\\\")\\n padding4 = \\\"\\\".ljust(string_size4, ' ')\\n string_size6 = max(len(opponent03), len(opponent04)) - len(opponent03)\\n padding6 = \\\"\\\".ljust(string_size6, '-')\\n string_size7 = max(len(opponent03), len(opponent04)) - len(opponent04)\\n padding7 = \\\"\\\".ljust(string_size7, '-')\\n string_size5 = len(padding4+opponent04+padding7) - len(opponent02+padding3) - 1\\n padding5 = \\\"\\\".ljust(string_size5, ' ')\\n\\n display += opponent01+padding1+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding2+\\\"|---\\\"+opponent03+padding6+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent02+padding3+\\\"|\\\"+padding5+\\\"|---\\\"+winner+\\\"\\\\n\\\"\\n display += padding4+opponent04+padding7+\\\"|\\\"+\\\"\\\\n\\\"\\n\\n # Game with 4 players\\n if cases == 4:\\n opponent01 = self.all_opponents[0][0][0]\\n opponent02 = self.all_opponents[0][0][1]\\n opponent03 = self.all_opponents[0][1][0]\\n opponent04 = self.all_opponents[0][1][1]\\n if len(self.winner_list_temp) == 1:\\n opponent05 = self.winner_list_temp[0]\\n if len(self.winner_list) >= 1:\\n opponent05 = self.winner_list[0][0]\\n opponent06 = self.winner_list[0][1]\\n if self.winner_state == 1:\\n winner = self.winner_list[1][0]\\n\\n first_game = [opponent01, opponent02, opponent03, opponent04]\\n max_string = len(max(first_game, key=len))\\n string_size1 = len(opponent01)\\n padding1 = \\\"\\\".ljust(int(max_string-string_size1), '-')\\n string_size2 = max_string\\n padding2 = \\\"\\\".ljust(string_size2, ' ')\\n string_size3 = len(opponent02)\\n padding3 = \\\"\\\".ljust(int(max_string-string_size3), '-')\\n string_size5 = len(opponent03)\\n padding5 = \\\"\\\".ljust(int(max_string-string_size5), '-')\\n string_size6 = max_string\\n padding6 = \\\"\\\".ljust(string_size6, ' ')\\n string_size7 = len(opponent04)\\n padding7 = \\\"\\\".ljust(int(max_string-string_size7), '-')\\n string_size8 = max(len(opponent05), len(opponent06)) - len(opponent05)\\n padding8 = \\\"\\\".ljust(string_size8, '-')\\n string_size9 = max(len(opponent05), len(opponent06)) - len(opponent06)\\n padding9 = \\\"\\\".ljust(string_size9, '-')\\n string_size4 = max(len(\\\"\\\"+padding2+\\\"|---\\\"+opponent05+padding8+\\\"|\\\"), (len(\\\"\\\"+padding6+\\\"|---\\\"+opponent06+padding9+\\\"|\\\"))) - 1\\n padding4 = \\\"\\\".ljust(string_size4, ' ')\\n string_size10 = len(padding4) - len(\\\"\\\"+opponent02+padding3+\\\"|\\\")\\n padding10 = \\\"\\\".ljust(string_size10, ' ')\\n string_size11 = len(padding4) - len(\\\"\\\"+opponent03+padding5+\\\"|\\\")\\n padding11 = \\\"\\\".ljust(string_size11, ' ')\\n\\n display += opponent01+padding1+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding2+\\\"|---\\\"+opponent05+padding8+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent02+padding3+\\\"|\\\"+padding10+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding4+\\\"|---\\\"+winner+\\\"\\\\n\\\"\\n display += opponent03+padding5+\\\"|\\\"+padding11+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding6+\\\"|---\\\"+opponent06+padding9+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent04+padding7+\\\"|\\\"+\\\"\\\\n\\\"\\n\\n # Game with 5 players\\n if cases == 5:\\n opponent01 = self.all_opponents[0][0][0]\\n opponent02 = self.all_opponents[0][0][1]\\n if len(self.all_opponents) >= 2:\\n opponent03 = self.all_opponents[1][0][0]\\n opponent04 = self.all_opponents[1][0][1]\\n opponent05 = self.all_opponents[1][1][0]\\n opponent06 = self.all_opponents[1][1][1]\\n if len(self.winner_list_temp) == 1:\\n opponent07 = self.winner_list_temp[0]\\n if len(self.winner_list) >= 2:\\n opponent07 = self.winner_list[1][0]\\n opponent08 = self.winner_list[1][1]\\n if len(self.winner_list) == 3:\\n winner = self.winner_list[2][0]\\n\\n first_game = [opponent01, opponent02]\\n max_string = len(max(first_game, key=len))\\n string_size1 = len(opponent01)\\n padding1 = \\\"\\\".ljust(int(max_string-string_size1), '-')\\n string_size2 = max_string\\n padding2 = \\\"\\\".ljust(string_size2, ' ')\\n string_size3 = len(opponent02)\\n padding3 = \\\"\\\".ljust(int(max_string-string_size3), '-')\\n string_size4 = max(len(\\\"\\\"+opponent01+padding1), len(\\\"\\\"+opponent01+padding1)) + 4\\n padding4 = \\\"\\\".ljust(string_size4, ' ')\\n string_size5 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06))\\n padding5 = \\\"\\\".ljust((string_size5 - len(opponent03)), '-')\\n string_size7 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06))\\n padding7 = \\\"\\\".ljust((string_size7 - len(opponent04)), '-')\\n string_size8 = len(\\\"\\\"+padding2+\\\"|---\\\")\\n padding8 = \\\"\\\".ljust(string_size8, ' ')\\n string_size6 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06)) + 3\\n padding6 = \\\"\\\".ljust(string_size6, ' ')\\n string_size9 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06)) - len(opponent05)\\n padding9 = \\\"\\\".ljust(string_size9, '-')\\n string_size10 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06)) - len(opponent06)\\n padding10 = \\\"\\\".ljust(string_size10, '-')\\n string_size11 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06)) + len(padding4)\\n padding11 = \\\"\\\".ljust(string_size11, ' ')\\n string_size12 = max(len(opponent07), len(opponent08)) - len(opponent07)\\n padding12 = \\\"\\\".ljust(string_size12, '-')\\n string_size13 = max(len(opponent07), len(opponent08)) - len(opponent08)\\n padding13 = \\\"\\\".ljust(string_size13, '-')\\n string_size14 = max(len(opponent07), len(opponent08)) + 3\\n padding14 = \\\"\\\".ljust(string_size14, ' ')\\n string_size15 = max(len(opponent07), len(opponent08)) + 3\\n padding15 = \\\"\\\".ljust(string_size15, ' ')\\n string_size16 = len(\\\"\\\"+padding11+\\\"|---\\\"+opponent08+padding13)\\n padding16 = \\\"\\\".ljust(string_size16, ' ')\\n\\n display += opponent01+padding1+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding2+\\\"|---\\\"+opponent03+padding5+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent02+padding3+\\\"|\\\"+padding6+\\\"|---\\\"+opponent07+padding12+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding4+opponent04+padding7+\\\"|\\\"+padding14+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding16+\\\"|---\\\"+winner+\\\"\\\\n\\\"\\n display += padding8+opponent05+padding9+\\\"|\\\"+padding15+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding11+\\\"|---\\\"+opponent08+padding13+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding8+opponent06+padding10+\\\"|\\\"+\\\"\\\\n\\\"\\n\\n # Game with 6 players\\n if cases == 6:\\n opponent01 = self.all_opponents[0][0][0]\\n opponent02 = self.all_opponents[0][0][1]\\n opponent03 = self.all_opponents[0][1][0]\\n opponent04 = self.all_opponents[0][1][1]\\n opponent05 = self.all_opponents[0][2][0]\\n opponent06 = self.all_opponents[0][2][1]\\n if len(self.winner_list_temp) >= 1:\\n opponent07 = self.winner_list_temp[0]\\n if len(self.winner_list_temp) >= 2:\\n opponent08 = self.winner_list_temp[1]\\n if len(self.winner_list) >= 1:\\n print(self.winner_list)\\n opponent07 = self.winner_list[0][0]\\n opponent08 = self.winner_list[0][1]\\n opponent09 = self.winner_list[0][2]\\n if len(self.all_opponents) >= 3:\\n opponent10 = self.all_opponents[2][0][0]\\n if len(self.winner_list) == 3:\\n winner = self.winner_list[2][0]\\n\\n first_game = [opponent01, opponent02, opponent03, opponent04, opponent05, opponent06,]\\n max_string = len(max(first_game, key=len))\\n string_size1 = len(opponent01)\\n padding1 = \\\"\\\".ljust(int(max_string-string_size1), '-')\\n string_size2 = len(opponent02)\\n padding2 = \\\"\\\".ljust(int(max_string-string_size2), '-')\\n string_size3 = len(opponent03)\\n padding3 = \\\"\\\".ljust(int(max_string-string_size3), '-')\\n string_size4 = len(opponent04)\\n padding4 = \\\"\\\".ljust(int(max_string-string_size4), '-')\\n string_size5 = len(opponent05)\\n padding5 = \\\"\\\".ljust(int(max_string-string_size5), '-')\\n string_size6 = len(opponent06)\\n padding6 = \\\"\\\".ljust(int(max_string-string_size6), '-')\\n string_size7 = max_string\\n padding7 = \\\"\\\".ljust(string_size7, ' ')\\n string_size8 = max(len(opponent07), len(opponent08), len(opponent09)) - len(opponent07)\\n padding8 = \\\"\\\".ljust(string_size8, '-')\\n string_size9 = max(len(opponent07), len(opponent08), len(opponent09)) - len(opponent08)\\n padding9 = \\\"\\\".ljust(string_size9, '-')\\n string_size10 = max(len(opponent07), len(opponent08), len(opponent09)) - len(opponent09)\\n padding10 = \\\"\\\".ljust(string_size10, '-')\\n string_size12 = len(\\\"\\\"+padding7+\\\"|---\\\"+opponent09+padding10)\\n padding12 = \\\"\\\".ljust(string_size12, ' ')\\n string_size14 = max(len(opponent07), len(opponent08), len(opponent09)) + 3\\n padding14 = \\\"\\\".ljust(string_size14, ' ')\\n string_size15 = len(\\\"\\\"+padding12+\\\"|---\\\"+opponent10) - len(\\\"\\\"+padding7+\\\"|---\\\"+opponent09)\\n padding15 = \\\"\\\".ljust(string_size15, '-')\\n string_size16 = len(padding7+\\\"|---\\\"+opponent09+padding15) - len(opponent05+padding5+\\\"|\\\")\\n padding16 = \\\"\\\".ljust(string_size16, ' ')\\n string_size17 = len(padding7+\\\"|---\\\"+opponent09+padding15)\\n padding17 = \\\"\\\".ljust(string_size17, ' ')\\n string_size18 = len(opponent09 + padding15) + 3\\n padding18 = \\\"\\\".ljust(string_size18, ' ')\\n string_size19 = len(\\\"|---\\\"+opponent10) - 1\\n padding19 = \\\"\\\".ljust(string_size19, ' ')\\n\\n display += opponent01+padding1+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding7+\\\"|---\\\"+opponent07+padding8+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent02+padding2+\\\"|\\\"+padding14+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding12+\\\"|---\\\"+opponent10+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent03+padding3+\\\"|\\\"+padding14+\\\"|\\\"+padding19+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding7+\\\"|---\\\"+opponent08+padding9+\\\"|\\\"+padding19+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent04+padding4+\\\"|\\\"+padding18+\\\"|---\\\"+winner+\\\"\\\\n\\\"\\n display += padding17+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent05+padding5+\\\"|\\\"+padding16+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding7+\\\"|---\\\"+opponent09+padding15+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent06+padding6+\\\"|\\\"+\\\"\\\\n\\\"\\n\\n # Game with 7 players\\n if cases == 7:\\n opponent01 = self.all_opponents[0][0][0]\\n opponent02 = self.all_opponents[0][0][1]\\n if len(self.all_opponents) >= 2:\\n\\n opponent03 = self.all_opponents[1][0][0]\\n opponent04 = self.all_opponents[1][0][1]\\n opponent05 = self.all_opponents[1][1][0]\\n opponent06 = self.all_opponents[1][1][1]\\n opponent07 = self.all_opponents[1][2][0]\\n opponent08 = self.all_opponents[1][2][1]\\n if len(self.winner_list_temp) >= 1:\\n opponent09 = self.winner_list_temp[0]\\n if len(self.winner_list_temp) >= 2:\\n opponent10 = self.winner_list_temp[1]\\n if len(self.winner_list) >= 2:\\n opponent09 = self.winner_list[1][0]\\n opponent10 = self.winner_list[1][1]\\n opponent11 = self.winner_list[1][2]\\n if len(self.all_opponents) >= 4:\\n opponent12 = self.all_opponents[3][0][0]\\n if len(self.winner_list) == 4:\\n winner = self.winner_list[3][0]\\n\\n string_size1 = max(len(opponent01), len(opponent02)) - len(opponent01)\\n padding1 = \\\"\\\".ljust(string_size1, '-')\\n string_size2 = max(len(opponent01), len(opponent02)) - len(opponent02)\\n padding2 = \\\"\\\".ljust(string_size2, '-')\\n string_size3 = len(opponent01+padding1)\\n padding3 = \\\"\\\".ljust(string_size3, ' ')\\n string_size4 = len(opponent01+padding1) + 4\\n padding4 = \\\"\\\".ljust(string_size4, ' ')\\n string_size5 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent03)\\n padding5 = \\\"\\\".ljust(string_size5, '-')\\n string_size6 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent04)\\n padding6 = \\\"\\\".ljust(string_size6, '-')\\n string_size7 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent05)\\n padding7 = \\\"\\\".ljust(string_size7, '-')\\n string_size8 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent06)\\n padding8 = \\\"\\\".ljust(string_size8, '-')\\n string_size9 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent07)\\n padding9 = \\\"\\\".ljust(string_size9, '-')\\n string_size10 = max(len(opponent03), len(opponent04), len(opponent05), len(opponent06), len(opponent07), len(opponent08)) - len(opponent08)\\n padding10 = \\\"\\\".ljust(string_size10, '-')\\n string_size11 = len(padding4+opponent08+padding10)\\n padding11 = \\\"\\\".ljust(string_size11, ' ')\\n string_size12 = len(padding4+opponent08+padding10) - len(opponent02+padding2) - 1\\n padding12 = \\\"\\\".ljust(string_size12, ' ')\\n string_size13 = max(len(opponent09), len(opponent10)) - len(opponent09)\\n padding13 = \\\"\\\".ljust(string_size13, '-')\\n string_size14 = max(len(opponent09), len(opponent10)) - len(opponent10)\\n padding14 = \\\"\\\".ljust(string_size14, '-')\\n string_size15 = len(opponent09+padding13) + 3\\n padding15 = \\\"\\\".ljust(string_size15, ' ')\\n string_size16 = len(opponent02+padding2+\\\"|\\\"+padding12+\\\"|---\\\"+opponent09+padding13)\\n padding16 = \\\"\\\".ljust(string_size16, ' ')\\n string_size17 = len(\\\"---\\\"+opponent12)\\n padding17 = \\\"\\\".ljust(string_size17, ' ')\\n string_size18 = len(\\\"---\\\"+opponent12) + len(\\\"---\\\"+opponent10+padding14) + 1\\n padding18 = \\\"\\\".ljust(string_size18, ' ')\\n string_size19 = len(padding4+opponent06+padding8+\\\"|\\\"+padding18)\\n padding19 = \\\"\\\".ljust(string_size19, ' ')\\n string_size20 = len(padding18) - len(opponent11) - 3\\n padding20 = \\\"\\\".ljust(string_size20, '-')\\n\\n display += opponent01+padding1+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding3+\\\"|---\\\"+opponent03+padding5+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent02+padding2+\\\"|\\\"+padding12+\\\"|---\\\"+opponent09+padding13+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding4+opponent04+padding6+\\\"|\\\"+padding15+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding16+\\\"|---\\\"+opponent12+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding4+opponent05+padding7+\\\"|\\\"+padding15+\\\"|\\\"+padding17+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding11+\\\"|---\\\"+opponent10+padding14+\\\"|\\\"+padding17+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding4+opponent06+padding8+\\\"|\\\"+padding18+\\\"|---\\\"+winner+\\\"\\\\n\\\"\\n display += padding19+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding4+opponent07+padding9+\\\"|\\\"+padding18+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding11+\\\"|---\\\"+opponent11+padding20+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding4+opponent08+padding10+\\\"|\\\"+\\\"\\\\n\\\"\\n\\n # Game with 8 players\\n if cases == 8:\\n opponent01 = self.all_opponents[0][0][0]\\n opponent02 = self.all_opponents[0][0][1]\\n opponent03 = self.all_opponents[0][1][0]\\n opponent04 = self.all_opponents[0][1][1]\\n opponent05 = self.all_opponents[0][2][0]\\n opponent06 = self.all_opponents[0][2][1]\\n opponent07 = self.all_opponents[0][3][0]\\n opponent08 = self.all_opponents[0][3][1]\\n if len(self.all_opponents) == 1:\\n if len(self.winner_list_temp) >= 1:\\n opponent09 = self.winner_list_temp[0]\\n if len(self.winner_list_temp) >= 2:\\n opponent10 = self.winner_list_temp[1]\\n if len(self.winner_list_temp) >= 3:\\n opponent11 = self.winner_list_temp[2]\\n if len(self.all_opponents) >= 2:\\n opponent09 = self.all_opponents[1][0][0]\\n opponent10 = self.all_opponents[1][0][1]\\n opponent11 = self.all_opponents[1][1][0]\\n opponent12 = self.all_opponents[1][1][1]\\n if len(self.winner_list_temp) >= 1:\\n opponent13 = self.winner_list_temp[0]\\n if len(self.all_opponents) >= 3:\\n opponent13 = self.all_opponents[2][0][0]\\n opponent14 = self.all_opponents[2][0][1]\\n if len(self.winner_list) == 3:\\n winner = self.winner_list[2][0]\\n\\n first_game = [opponent01, opponent02, opponent03, opponent04, opponent05, opponent06, opponent07, opponent08]\\n max_string = len(max(first_game, key=len))\\n string_size1 = len(opponent01)\\n padding1 = \\\"\\\".ljust(int(max_string-string_size1), '-')\\n string_size2 = len(opponent02)\\n padding2 = \\\"\\\".ljust(int(max_string-string_size2), '-')\\n string_size3 = len(opponent03)\\n padding3 = \\\"\\\".ljust(int(max_string-string_size3), '-')\\n string_size4 = len(opponent04)\\n padding4 = \\\"\\\".ljust(int(max_string-string_size4), '-')\\n string_size5 = len(opponent05)\\n padding5 = \\\"\\\".ljust(int(max_string-string_size5), '-')\\n string_size6 = len(opponent06)\\n padding6 = \\\"\\\".ljust(int(max_string-string_size6), '-')\\n string_size7 = len(opponent07)\\n padding7 = \\\"\\\".ljust(int(max_string-string_size7), '-')\\n string_size8 = len(opponent08)\\n padding8 = \\\"\\\".ljust(int(max_string-string_size8), '-')\\n string_size9 = len(opponent01+padding1)\\n padding9 = \\\"\\\".ljust(string_size9, ' ')\\n string_size10 = max(len(opponent09), len(opponent10), len(opponent11), len(opponent12)) - len(opponent09)\\n padding10 = \\\"\\\".ljust(string_size10, '-')\\n string_size11 = max(len(opponent09), len(opponent10), len(opponent11), len(opponent12)) - len(opponent10)\\n padding11 = \\\"\\\".ljust(string_size11, '-')\\n string_size12 = max(len(opponent09), len(opponent10), len(opponent11), len(opponent12)) - len(opponent11)\\n padding12 = \\\"\\\".ljust(string_size12, '-')\\n string_size13 = max(len(opponent09), len(opponent10), len(opponent11), len(opponent12)) - len(opponent12)\\n padding13 = \\\"\\\".ljust(string_size13, '-')\\n string_size14 = len(padding9+\\\"|---\\\"+opponent09+padding10) - len(opponent02+padding2) - 1\\n padding14 = \\\"\\\".ljust(string_size14, ' ')\\n string_size15 = len(padding9+\\\"|---\\\"+opponent09+padding10)\\n padding15 = \\\"\\\".ljust(string_size15, ' ')\\n string_size16 = max(len(opponent13), len(opponent14)) - len(opponent13)\\n padding16 = \\\"\\\".ljust(string_size16, '-')\\n string_size17 = max(len(opponent13), len(opponent14)) - len(opponent14)\\n padding17 = \\\"\\\".ljust(string_size17, '-')\\n string_size18 = len(opponent14+padding17) + 3\\n padding18 = \\\"\\\".ljust(string_size18, ' ')\\n string_size19 = len(padding15+\\\"|---\\\"+opponent14+padding17) - len(opponent08+padding8) - 1\\n padding19 = \\\"\\\".ljust(string_size19, ' ')\\n string_size20 = len(padding15+\\\"|---\\\"+opponent14+padding17)\\n padding20 = \\\"\\\".ljust(string_size20, ' ')\\n\\n display += opponent01+padding1+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding9+\\\"|---\\\"+opponent09+padding10+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent02+padding2+\\\"|\\\"+padding14+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding15+\\\"|---\\\"+opponent13+padding16+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent03+padding3+\\\"|\\\"+padding14+\\\"|\\\"+padding18+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding9+\\\"|---\\\"+opponent10+padding11+\\\"|\\\"+padding18+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent04+padding4+\\\"|\\\"+padding19+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding20+\\\"|---\\\"+winner+\\\"\\\\n\\\"\\n display += opponent05+padding5+\\\"|\\\"+padding19+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding9+\\\"|---\\\"+opponent11+padding12+\\\"|\\\"+padding18+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent06+padding6+\\\"|\\\"+padding14+\\\"|\\\"+padding18+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding15+\\\"|---\\\"+opponent14+padding17+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent07+padding7+\\\"|\\\"+padding14+\\\"|\\\"+\\\"\\\\n\\\"\\n display += padding9+\\\"|---\\\"+opponent12+padding13+\\\"|\\\"+\\\"\\\\n\\\"\\n display += opponent08+padding8+\\\"|\\\"+\\\"\\\\n\\\"\\n\\n return display\",\n \"def get_top_games_from_title_for_game(app_id: str, candidate_games: List[str],\\n threshold=0.5) -> List[Dict]:\\n if not app_id or not candidate_games:\\n return []\\n ranking_info = get_matched_game_ranking_info_for_game(app_id=app_id)\\n res = []\\n for app_id, score in ranking_info.items():\\n if score >= threshold and app_id in candidate_games:\\n game_obj: Game = Game.query.filter_by(app_id=app_id).all()[0]\\n game_info = {\\n 'app_id': app_id,\\n 'name': game_obj.name,\\n 'developer': \\\", \\\".join(json.loads(game_obj.developer)),\\n 'publisher': \\\", \\\".join(json.loads(game_obj.publisher)),\\n 'tags': json.loads(game_obj.tags),\\n 'genre': json.loads(game_obj.genre),\\n 'single_player': game_obj.single_player,\\n 'multi_player': game_obj.multi_player,\\n 'rating': game_obj.rating,\\n 'mature_content': game_obj.mature_content,\\n 'title_match_score': score}\\n res.append(game_info)\\n return res\",\n \"def get_scoreboard() -> Tuple[Union[None, Dict[int, Dict[str, int]]], Error]:\\n sql = '''\\n SELECT\\n `group_id`,\\n `task_id`,\\n COALESCE(SUM(`is_correct` = 1), 0) AS `success_count`,\\n COALESCE(SUM(`is_correct` = 0), 0) AS `fail_count`\\n FROM `submissions`\\n GROUP BY `group_id`, `task_id`\\n '''\\n\\n try:\\n cur = con.execute(sql)\\n rows = cur.fetchall()\\n con.commit()\\n\\n tasks = get_all_tasks()\\n table = {i: {task['task_id']: 0 for task in tasks} for i in range(1, 10)}\\n\\n if rows is None:\\n return (table, None)\\n\\n for row in rows:\\n group_id, task_id, success_count, fail_count = row\\n task = get_task_by_id(task_id)\\n\\n if task is None:\\n continue\\n\\n status = 0\\n if 'max_attempt' in task and fail_count >= task['max_attempt']:\\n status = -1\\n elif success_count > 0:\\n status = 1\\n\\n table[group_id][task_id] = status\\n\\n return (table, None)\\n\\n except sqlite3.Error as err:\\n handle_error(err)\\n return (None, ' '.join(err.args))\",\n \"def FromGameInfo(cls, info, team_tourney_map):\\n teams = [\\n Team(score_reporter_id=team_tourney_map.get(info.home_team_link, '')),\\n Team(score_reporter_id=team_tourney_map.get(info.away_team_link, '')),\\n ]\\n\\n start_time = ParseStartTime(info.date, info.time)\\n\\n scores = []\\n try:\\n scores = [int(info.home_team_score),\\n int(info.away_team_score)]\\n except ValueError as e:\\n if info.home_team_score.strip().lower() == 'w':\\n scores = [1, -1]\\n elif info.away_team_score.strip().lower() == 'w':\\n scores = [-1, 1]\\n else:\\n # Unknown scores\\n scores = [-1, -1]\\n source = GameSource(type=scores_messages.GameSourceType.SCORE_REPORTER,\\n score_reporter_url=info.tourney_id,\\n update_date_time=datetime.utcnow()) \\n \\n name = info.bracket_title or info.pool_name\\n status = scores_messages.GameStatus.UNKNOWN\\n if info.status.lower() == 'final':\\n status = scores_messages.GameStatus.FINAL\\n return Game(id_str=info.id,\\n name=name,\\n teams=teams,\\n scores=scores,\\n tournament_id=info.tourney_name,\\n tournament_name=info.tourney_name.replace('-', ' '),\\n division=info.division,\\n age_bracket=info.age_bracket,\\n league=scores_messages.League.USAU,\\n game_status=status,\\n created_at=info.created_at,\\n start_time=start_time,\\n last_modified_at=datetime.utcnow(),\\n sources=[source],\\n key=game_key_full(info.id))\",\n \"def readGameFile(games_data_filename):\\n\\tgame_stats = {}\\n\\tteam_stats = {}\\n\\twith open(games_data_filename) as csvfile:\\n\\t reader = csv.DictReader(csvfile)\\n\\t for row in reader:\\n\\t \\tgame_id = row['game_id']\\n\\t \\tteam_id = row['team_id']\\n\\t \\twinner_id = row['winner_id']\\n\\t \\tloser_id = None\\n\\t \\t\\n\\t \\twin = 0\\n\\t \\tif team_id == winner_id:\\n\\t \\t\\twin = 1\\n\\t \\telse:\\n\\t \\t\\tloser_id = team_id\\n\\n\\t \\tif not game_stats.get(game_id):\\n\\t \\t\\tgame_stats[game_id] = {'winner_team_id': winner_id, 'loser_team_id':'', 'winner_player_ids':[], 'loser_player_ids':[], 'winner_kills': 0, 'loser_kills': 0, 'winner_deaths': 0, 'loser_deaths': 0, 'winner_assists': 0, 'loser_assists': 0, 'winner_gold': 0, 'loser_gold': 0}\\n\\n\\t \\tif loser_id is not None:\\n\\t \\t\\tgame_stats[game_id]['loser_team_id'] = loser_id\\n\\treturn game_stats\",\n \"def test_get_player_stats_from_game():\\n team = \\\"Titans\\\"\\n year = \\\"2018\\\"\\n week = \\\"1\\\"\\n expected_team_stats = {}\\n\\n assert ff_team.get_player_stats_from_game(\\n team, year, week) == expected_team_stats\",\n \"def calculate_scores(self):\\n words = self.walk_board()\\n player_scores = {}\\n for word in words:\\n player = word.get_owning_player()\\n if player not in player_scores:\\n player_scores[player] = 0\\n player_scores[player] += word.get_score()\\n return player_scores\",\n \"def get_team_scores(self, team, include_home=True, include_away=True):\\n if include_away:\\n away_games = list(filter(lambda g: team == g.AwayTeam, self.games))\\n else:\\n away_games = []\\n\\n if include_home:\\n home_games = list(filter(lambda g: team == g.HomeTeam, self.games))\\n else:\\n home_games = []\\n\\n scored_h = [g.FTHG for g in home_games]\\n scored_a = [g.FTAG for g in away_games]\\n\\n conceded_h = [g.FTAG for g in home_games]\\n conceded_a = [g.FTHG for g in away_games]\\n\\n try:\\n mean_gd = mean(scored_h + scored_a) - mean(conceded_h + conceded_a)\\n home_gd = mean(scored_h) - mean(conceded_h)\\n home_adv = home_gd - mean_gd\\n except Exception:\\n home_adv = 0\\n\\n return {\\n \\\"scored_xg\\\": scored_h + scored_a,\\n \\\"conceded_xg\\\": conceded_h + conceded_a,\\n \\\"home_adv\\\": home_adv,\\n \\\"expected_points\\\": self.get_table(metric='points')[team] /\\n len(home_games + away_games)\\n }\",\n \"def retrieveGames():\\n result = cs411_game.getGames()\\n return prepJSON(result)\",\n \"def get_stats():\\n team_dict = {}\\n # parse team names\\n with open('../data/teams.txt') as teams:\\n team_name_list = teams.readlines()\\n for team in team_name_list:\\n team_dict[team.rstrip()] = Team(team)\\n\\n # parse rankings\\n with open('../data/rankings.csv') as csv_file:\\n csv_reader = csv.reader(csv_file, delimiter=',')\\n line_count = 0\\n for row in csv_reader:\\n for team_name in team_dict.keys():\\n if team_name == \\\"Northeastern\\\" and \\\"REB MAR\\\" in row: # bad patch\\n team_dict[team_name].stats.append(0)\\n elif team_name in row:\\n team_dict[team_name].stats.append(row[-1])\\n matrix = np.array([t.stats for t in team_dict.values()])\\n return team_dict, matrix\",\n \"def leaderboard(request):\\r\\n\\tMEDIA_URL = '/media/'\\r\\n\\tgames = Game.objects.all()\\r\\n\\tuser_high_scores = []\\r\\n\\tgame_high_scores = []\\r\\n\\tnew = {}\\r\\n\\t# Get global scores\\r\\n\\tfor game in games:\\r\\n\\t\\tgame_intermediate_high = Score.objects.filter(game = game.id).order_by('-current_score').values('game__name', 'player__user__username', 'current_score')[:1]\\r\\n\\t\\tif (game_intermediate_high.count() > 0):\\r\\n\\t\\t\\tgame_high_scores.append(game_intermediate_high)\\r\\n\\t# Check if user is authenticated and get user's scores\\r\\n\\tif (request.user.is_authenticated):\\r\\n\\t\\tfor game in games:\\r\\n\\t\\t\\t\\tuser_intermediate_high = Score.objects.filter(game=game.id, player = request.user.profile).order_by('-current_score').values('player__user__username','game__name', 'current_score').distinct()[:1]\\r\\n\\t\\t\\t\\tif (user_intermediate_high.count() > 0):\\r\\n\\t\\t\\t\\t\\tuser_high_scores.append(user_intermediate_high)\\r\\n\\r\\n\\treturn render(request, 'leaderboard.html',{'MEDIA_URL' : MEDIA_URL,'games': games, 'user_high_scores': user_high_scores, 'game_high_scores': game_high_scores})\",\n \"def matchscore(self):\\n print(self.team1.name + \\\" \\\" + str(self.team1score) + \\\" - \\\" + str(self.team2score) + \\\" \\\" + self.team2.name)\",\n \"def _get_live_games(self):\\n response = requests.get(self._get_score_url())\\n if response.status_code == 200:\\n return [g for g in response.json()['games'] if g['status']['state'] == self.desired_game_state]\",\n \"def display_get_game():\\n title = input(\\\"Please give me a title searched game: \\\")\\n info_about_game = reports.get_game(filename, title)\\n print(\\\"Properties of the game: {}\\\\n\\\".format(info_about_game))\",\n \"def play_n_game(n_games, n_toss):\\n results_list = []\\n for _ in range(n_games):\\n results_list.append(play_one_game(n_toss))\\n dict_proba = {}\\n for j in range (n_toss + 1):\\n if results_list.count(j) != 0:\\n dict_proba[j] = results_list.count(j)/n_games\\n else:\\n continue\\n return dict_proba\",\n \"def live_scores():\\n live_scores = cache.get('FOOTBALL_LIVE_SCORES')\\n if live_scores:\\n scores_array = []\\n for score in json.loads(live_scores)[0:3]:\\n if not score['LIVE']:\\n scores_array.append(score) \\n return {'live_scores': scores_array}\\n else:\\n return {}\",\n \"def reduce_games(game):#game=player_games[0]\\n res = []\\n res.append(('id', game['id']) )\\n res.append(('annulled', game['annulled']))\\n res.append(('black', int(game['black'])))\\n res.append(('white', int(game['white'])))\\n res.append(('white_lost', int(game['white_lost']) ))\\n res.append(('black_lost', int(game['black_lost']) ))\\n res.append(('outcome', game['outcome']))\\n res.append(('handicap', game['handicap']))\\n res.append(('komi', game['komi']))\\n res.append(('ranked', game['ranked']))\\n res.append(('width', game['width']))\\n res.append(('height', game['height']))\\n res.append(('rules', game['rules']))\\n res.append(('started', game['started']))\\n res.append(('ended', game['ended']))\\n players = game['historical_ratings'].keys()\\n res.append(('black_rating', game['historical_ratings']['black']['ratings']['overall']['rating'] if 'black' in players else None))\\n res.append(('white_rating', game['historical_ratings']['white']['ratings']['overall']['rating'] if 'white' in players else None))\\n res.append(('black_deviation', game['historical_ratings']['black']['ratings']['overall']['deviation'] if 'black' in players else None))\\n res.append(('white_deviation', game['historical_ratings']['white']['ratings']['overall']['deviation'] if 'white' in players else None))\\n res.append(('black_volatility', game['historical_ratings']['black']['ratings']['overall']['volatility'] if 'black' in players else None))\\n res.append(('white_volatility', game['historical_ratings']['white']['ratings']['overall']['volatility'] if 'white' in players else None))\\n res.append(('black_ranking', game['historical_ratings']['black']['ranking'] if 'black' in players else None))\\n res.append(('white_ranking', game['historical_ratings']['white']['ranking'] if 'white' in players else None))\\n res.append(('tournament', not game['tournament'] is None))\\n return res\",\n \"async def check_games(self, ctx):\\n print(self.data)\\n print(self.games_info)\",\n \"def get(self, request):\\n\\n queries = request.GET.dict()\\n user = UserValidator.validate_user(request.user.id)\\n\\n if user is None:\\n return JsonResponse({\\n \\\"message\\\": \\\"Invalid credentials.\\\",\\n }, status=400)\\n\\n if user is None:\\n return JsonResponse({\\n \\\"message\\\": \\\"Invalid credentials.\\\",\\n }, status=400)\\n\\n try:\\n game = Game.value_of(queries[\\\"game\\\"].lower())\\n\\n except (KeyError, ValueError, Exception):\\n game = None\\n\\n try:\\n sort = queries[\\\"sort\\\"].lower()\\n\\n if sort not in [\\\"wins\\\", \\\"total\\\",]:\\n raise ValueError(\\\"invalid key value\\\")\\n\\n except (KeyError, ValueError, Exception):\\n sort = \\\"wins\\\"\\n\\n entries = GameModel.objects.values(\\\"player\\\").filter(is_deleted=False)\\n\\n if game is not None:\\n entries = entries.filter(game_played=game)\\n game = game.value\\n else:\\n game = \\\"All\\\"\\n\\n entries = entries.annotate(\\n wins=(Count(\\\"player\\\", filter=Q(did_win=True))),\\n total=(Count(\\\"player\\\"))\\n )\\n\\n if sort == \\\"wins\\\":\\n entries = entries.order_by(\\\"-wins\\\")\\n elif sort == \\\"total\\\":\\n entries = entries.order_by(\\\"-total\\\")\\n\\n board = ScoreboardView.get_board_from_db_rows(entries)\\n\\n token = Token.get_tokens_for_user(user)\\n\\n return JsonResponse({\\n \\\"game\\\": game,\\n \\\"board\\\": board,\\n \\\"access\\\": token[\\\"access\\\"],\\n \\\"refresh\\\": token[\\\"refresh\\\"],\\n })\",\n \"def get_top_games_from_title_for_movie(mov_tmt_path: str,\\n candidate_games: List[str],\\n threshold=0.5) -> List[Dict]:\\n if not mov_tmt_path or not candidate_games:\\n return []\\n ranking_info = get_matched_game_ranking_info_for_movie(\\n movie_id=mov_tmt_path)\\n res = []\\n for app_id, score in ranking_info.items():\\n if score >= threshold and app_id in candidate_games:\\n game_obj: Game = Game.query.filter_by(app_id=app_id).all()[0]\\n game_info = {\\n 'app_id': app_id,\\n 'name': game_obj.name,\\n 'developer': \\\", \\\".join(json.loads(game_obj.developer)),\\n 'publisher': \\\", \\\".join(json.loads(game_obj.publisher)),\\n 'tags': json.loads(game_obj.tags),\\n 'genre': json.loads(game_obj.genre),\\n 'single_player': game_obj.single_player,\\n 'multi_player': game_obj.multi_player,\\n 'rating': game_obj.rating,\\n 'mature_content': game_obj.mature_content,\\n 'title_match_score': score}\\n res.append(game_info)\\n return res\",\n \"def play_by_play(game_id):\\n\\n # HTML Content\\n r = requests.get('https://www.basketball-reference.com/boxscores/pbp/' + game_id + '.html')\\n soup = BeautifulSoup(r.content, \\\"html.parser\\\")\\n table = soup.find(id='pbp').find_all('tr')\\n\\n # MongoDB Collection\\n m = mongo.Mongo()\\n\\n pbp = {\\n 'home': [],\\n 'away': []\\n }\\n\\n quarter = 0\\n pattern = re.compile('^[0-9]{1,3}:[0-9]{2}\\\\.[0-9]{1}$')\\n\\n for item in table:\\n\\n time = None\\n x = 0\\n\\n play = {}\\n\\n # Iterate through row of stats, each row has 6 columns one half for each team\\n for stat in item.find_all('td'):\\n\\n x += 1\\n\\n check = True\\n\\n # A player scored\\n if \\\"makes\\\" in stat.text:\\n scrape_utils.field_goal_update(stat.find('a')['href'], stat.text, play, True)\\n # Player missed a shot\\n elif \\\"misses\\\" in stat.text:\\n scrape_utils.field_goal_update(stat.find('a')['href'], stat.text, play, False)\\n # Account for other basketball stats\\n elif \\\"Defensive rebound\\\" in stat.text:\\n if 'Team' not in stat.text:\\n play['drb'] = 1\\n elif \\\"Offensive rebound\\\" in stat.text:\\n if 'Team' not in stat.text:\\n play['orb'] = 1\\n elif \\\"Turnover\\\" in stat.text:\\n play['turnover'] = 1\\n elif \\\"foul\\\" in stat.text:\\n play['foul'] = 1\\n elif \\\"timeout\\\" in stat.text:\\n play['timeout'] = 1\\n elif \\\"enters\\\" in stat.text:\\n play['sub'] = 1\\n else:\\n check = False\\n\\n # Determine if home or away\\n if check is True:\\n if x == 2:\\n play['home'] = 0\\n elif x == 6:\\n play['home'] = 1\\n\\n # Different quarters including multiple overtimes\\n if pattern.match(stat.text):\\n time = scrape_utils.play_time(quarter, stat.text[:-2])\\n\\n if play:\\n play['time'] = time\\n\\n if play['home'] == 1:\\n del play['home']\\n pbp['home'].append(play)\\n else:\\n del play['home']\\n pbp['away'].append(play)\\n\\n # Going to next quarter\\n if time is None:\\n quarter += 1\\n\\n # Insert into database\\n m.update('game_log', {'_id': game_id}, {'$set': {'pbp': pbp}})\",\n \"def winning_games_stats(self):\\n self.winning_games_up_to_2013 = (\\n self.df\\n .pipe(lambda x:x.assign(winning_num_counts = 1))\\n .query(\\\"Season <= 2013\\\")\\n .groupby(['Season','WTeamID'])\\n .agg({\\\"WScore\\\":\\\"sum\\\",\\\"WFGM\\\":\\\"sum\\\",\\\"WFGA\\\":\\\"sum\\\",\\\"WFGM3\\\":\\\"sum\\\",\\\"WFGA3\\\":\\\"sum\\\",\\\"WFTM\\\":\\\"sum\\\",\\\"WFTA\\\":\\\"sum\\\",\\\"LScore\\\":\\\"sum\\\",\\\"winning_num_counts\\\":\\\"sum\\\",\\n \\\"WOR\\\":\\\"sum\\\",\\\"WDR\\\":\\\"sum\\\",\\\"LFGM\\\":\\\"sum\\\",\\\"LFGA\\\":\\\"sum\\\",\\n \\\"WAst\\\":\\\"sum\\\",\\\"WTO\\\":\\\"sum\\\",\\\"WStl\\\":\\\"sum\\\",\\\"WBlk\\\":\\\"sum\\\",\\\"WPF\\\":\\\"sum\\\"})\\n .reset_index()\\n .rename(columns={\\\"LScore\\\":\\\"losing_opponent_score\\\"})\\n # rebounds\\n .pipe(lambda x:x.assign(total_winning_rebounds = x.WOR + x.WDR))\\n .pipe(lambda x:x.assign(winning_off_rebounds_percent = x.WOR/x.total_winning_rebounds))\\n .pipe(lambda x:x.assign(winning_def_rebounds_percent = x.WDR/x.total_winning_rebounds))\\n .pipe(lambda x:x.assign(team_missed_attempts = x.WFGA - x.WFGM))\\n .pipe(lambda x:x.assign(opp_team_missed_attempts = x.LFGA - x.LFGM))\\n .pipe(lambda x:x.assign(winning_rebound_possession_percent = x.WOR/x.team_missed_attempts))\\n .pipe(lambda x:x.assign(winning_rebound_possessiongain_percent = x.WDR/x.opp_team_missed_attempts))\\n # blocks, steals, assists and turnovers\\n .pipe(lambda x:x.assign(winning_block_opp_FGA_percent = x.WBlk/x.LFGA))\\n .pipe(lambda x:x.assign(winning_assist_per_fgm = x.WAst/x.WFGM))\\n .pipe(lambda x:x.assign(winning_assist_turnover_ratio = x.WAst/x.WTO))\\n # rename columns to prevent duplication when joining with losing stats. example: WFGM_x\\n .rename(columns={\\\"LFGA\\\":\\\"LFGA_opp\\\",\\\"LFGM\\\":\\\"LFGM_opp\\\"})\\n )\",\n \"def gameOfLife(self, board: List[List[int]]) -> None:\\n res = {}\\n for i in range(len(board)):\\n for j in range(len(board[0])):\\n count = 0\\n # top line\\n if i-1 >= 0:\\n # left-top\\n if j-1>=0:\\n if board[i-1][j-1]==1:\\n count += 1\\n # top\\n if board[i-1][j]==1:\\n count += 1\\n # right-top\\n if j+1<len(board[0]):\\n if board[i-1][j+1]==1:\\n count += 1\\n # same line\\n # left\\n if j-1>=0:\\n if board[i][j-1]==1:\\n count += 1\\n # right\\n if j+1 < len(board[0]):\\n if board[i][j+1]==1:\\n count += 1\\n # bottom line\\n if i+1 < len(board):\\n # left-bottom\\n if j-1 >= 0:\\n if board[i+1][j-1]==1:\\n count += 1\\n # bottom\\n if board[i+1][j]==1:\\n count += 1\\n # right-bottom\\n if j+1 < len(board[0]):\\n if board[i+1][j+1]==1:\\n count += 1\\n # check\\n if board[i][j]==0 and count==3:\\n res[(i,j)] = 1\\n if board[i][j]==1 and (count<2 or count>3):\\n res[(i,j)] = 0\\n for key in res:\\n board[key[0]][key[1]] = res[key]\",\n \"def get_team_stats(players: list[Player]) -> dict[int]:\\n\\n team_stats = {}\\n\\n total_reaction = 0\\n total_mechanical_skill = 0\\n total_tactical_skill = 0\\n total_game_knowledge = 0\\n total_xp = 0\\n\\n for player in players:\\n total_reaction += player.reaction\\n total_mechanical_skill += player.mechanical_skill\\n total_tactical_skill += player.tactical_skill\\n total_game_knowledge += player.game_knowledge\\n total_xp += player.xp\\n\\n team_stats.update(\\n {\\\"reaction\\\": total_reaction,\\n \\\"mechanical_skill\\\": total_mechanical_skill,\\n \\\"tactical_skill\\\": total_tactical_skill,\\n \\\"game_knowledge\\\": total_game_knowledge,\\n \\\"xp\\\": total_xp})\\n\\n return team_stats\",\n \"def get_scores(self):\\n precision = self.right / self.count\\n APs = self.right_labels / self.count\\n mAP = np.mean(APs)\\n distance = self.distance / self.count\\n\\n return {'precision': precision,\\n 'APs': APs,\\n 'mAP': mAP,\\n 'distance': distance\\n }\",\n \"def get_game_urls(year, week):\\n base_url = \\\"https://www.pro-football-reference.com\\\"\\n\\n # URL for the summary of all games for a given week\\n # This page has the each match up for the week and\\n # a link to the detailed game stats \\n url = \\\"https://www.pro-football-reference.com/years/{}/week_{}.htm\\\".format(\\n year, week)\\n\\n response = get(url)\\n\\n week_summary = BeautifulSoup(response.content, 'html.parser')\\n\\n # Get just the game summary content\\n week_summary_games = week_summary.find_all(\\n attrs={\\\"class\\\": \\\"game_summary expanded nohover\\\"})\\n\\n losing_teams = []\\n winning_teams = []\\n game_link = []\\n\\n # For each game played, extract the losing team,\\n # the winning team, and the detailed game stats link\\n for game in week_summary_games:\\n try:\\n losing_team_strings = [text for text in game.find(\\n attrs={\\\"class\\\": \\\"loser\\\"}).stripped_strings]\\n losing_teams.append(losing_team_strings[0])\\n except AttributeError:\\n pass\\n\\n try:\\n winning_team_strings = [text for text in game.find(\\n attrs={\\\"class\\\": \\\"winner\\\"}).stripped_strings]\\n winning_teams.append(winning_team_strings[0])\\n except AttributeError:\\n pass\\n\\n for link in game.find_all(href=re.compile(\\\"boxscores\\\")):\\n game_link.append(base_url + link.get('href'))\\n\\n\\n game_urls = dict(zip(losing_teams, game_link))\\n game_urls.update(dict(zip(winning_teams, game_link)))\\n\\n return game_urls\",\n \"def get_scores(self):\\n\\n\\t\\tscores = np.dot(self.rankings, self.weights)\\n\\t\\tranked_indices = np.argsort(scores)\\n\\t\\tranked_sources = self.source_names[ranked_indices]\\n\\t\\tranked_scores = sorted(scores)\\n\\t\\tself.scores = {source:score for source, score in zip(ranked_sources, ranked_scores)}\\n\\n\\t\\treturn self.scores\",\n \"def get_smmry_data(soup, game_dict):\\n\\n # Get date and time data.\\n try:\\n date_soup = soup.find(\\\"div\\\", {\\\"class\\\": \\\"spielbericht_tipp_status\\\"})\\n league = date_soup.div.span.text\\n date_string = date_soup.div.text\\n date = re.search(r'\\\\d{2}.\\\\d{2}.\\\\d{2}', date_string).group(0)\\n time = re.search(r'\\\\d{2}:\\\\d{2}', date_string).group(0)\\n matchday = re.search(r'[|]\\\\d+', date_string).group(0)[1:]\\n\\n game_dict[\\\"league\\\"] = league\\n game_dict[\\\"fb_date\\\"] = date\\n game_dict[\\\"fb_time\\\"] = time\\n game_dict[\\\"matchday\\\"] = matchday\\n except AttributeError:\\n pass\\n\\n # Get game result.\\n try:\\n result = soup.find(\\\"div\\\", {\\\"class\\\": \\\"stand\\\"}).text\\n game_dict[\\\"result\\\"] = result\\n except AttributeError:\\n pass\\n\\n # Try to get the referee name.\\n try:\\n referee = soup.find(\\\"span\\\", {\\\"class\\\": \\\"schiri_link\\\"}).text\\n game_dict[\\\"referee\\\"] = referee\\n except AttributeError:\\n pass\\n\\n # Get team, club name and repective url by team.\\n try:\\n smmry_soup = soup.find(\\n \\\"div\\\", {\\\"class\\\": \\\"spielbericht_ergebnis_wrapper\\\"})\\n club_title = smmry_soup.find_all(\\\"img\\\")\\n team_title = smmry_soup.findAll(\\\"div\\\", {\\\"class\\\": \\\"teaminfo\\\"})\\n\\n # Loop through teams.\\n for j, team in enumerate([\\\"home_\\\", \\\"away_\\\"]):\\n game_dict[team + \\\"team\\\"] = team_title[j].a[\\\"title\\\"]\\n game_dict[team + \\\"team_url\\\"] = team_title[j].a[\\\"href\\\"]\\n game_dict[team + \\\"club\\\"] = club_title[j][\\\"title\\\"]\\n except (AttributeError, TypeError):\\n pass\\n\\n return game_dict\",\n \"def parse_scores(option, table_num, language, min_score, max_score):\\n html = query_by_lang(BASE_URL + '/' + option, language)\\n table = html.find_all(\\\"table\\\")[table_num]\\n freq_list = table.find_all(\\\"tr\\\")[2:]\\n\\n # Create the dictionary\\n list_min = find_min(freq_list)\\n list_max = find_max(freq_list)\\n return create_dict(freq_list, list_min, list_max, min_score, max_score)\",\n \"def get_perfect_information(self):\\n state = {}\\n state[\\\"chips\\\"] = [self.game.players[i].in_chips for i in range(self.player_num)]\\n state[\\\"public_card\\\"] = (\\n self.game.public_card.get_index() if self.game.public_card else None\\n )\\n state[\\\"hand_cards\\\"] = [\\n self.game.players[i].hand.get_index() for i in range(self.player_num)\\n ]\\n state[\\\"current_round\\\"] = self.game.round_counter\\n state[\\\"current_player\\\"] = self.game.game_pointer\\n state[\\\"legal_actions\\\"] = self.game.get_legal_actions()\\n return state\",\n \"def apiGameState(game_id):\\n if game_id not in games:\\n abort(404)\\n room = games[game_id]\\n # Maybe we also want like, \\\"last move\\\"?\\n info = dict(board = room.game._board.tolist(),\\n n_players = room.game.n_players,\\n last_played = room.last_move)\\n if room.time_limit > 0:\\n info[\\\"time_limit\\\"] = room.time_limit\\n\\n # Indicate the state of the game\\n if not room.full():\\n info[\\\"state\\\"] = \\\"waiting\\\"\\n info[\\\"joined\\\"] = len(room.players)\\n elif room.game.winner is not None:\\n info[\\\"state\\\"] = \\\"finished\\\"\\n info[\\\"winner\\\"] = room.game.winner\\n else:\\n info[\\\"state\\\"] = \\\"playing\\\"\\n info[\\\"turn\\\"] = room.game.player_turn\\n return info\",\n \"def get_games():\\n page: int = int(flask.request.args.get(\\\"page\\\", 1))\\n size: int = int(flask.request.args.get(\\\"size\\\", 10))\\n\\n request = GetPageRequest(page, size)\\n response = minesweeper_service.get_game_page(request)\\n return flask.jsonify(response)\",\n \"def get_baseball_data():\\n\\n baseball_data = [\\n {\\n 'team_name': 'Boston', 'wins': 103, 'losses': 47,\\n 'wins_in_last_ten': 7, 'streak': 'W2'\\n },\\n {\\n 'team_name': 'NY Yankees', 'wins': 91, 'losses': 58,\\n 'wins_in_last_ten': 4, 'streak': 'L2'\\n },\\n {\\n 'team_name': 'Tampa Bay', 'wins': 83, 'losses': 66,\\n 'wins_in_last_ten': 8, 'streak': 'W3'\\n },\\n {\\n 'team_name': 'Toronto', 'wins': 68, 'losses': 82,\\n 'wins_in_last_ten': 5, 'streak': 'W3'\\n },\\n {\\n 'team_name': 'Baltimore', 'wins': 43, 'losses': 107,\\n 'wins_in_last_ten': 2, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Cleveland', 'wins': 83, 'losses': 66,\\n 'wins_in_last_ten': 4, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Minnesota', 'wins': 69, 'losses': 81,\\n 'wins_in_last_ten': 5, 'streak': 'W2'\\n },\\n {\\n 'team_name': 'Detroit', 'wins': 61, 'losses': 89,\\n 'wins_in_last_ten': 4, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Chi White Sox', 'wins': 59, 'losses': 90,\\n 'wins_in_last_ten': 3, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Kansas City', 'wins': 52, 'losses': 98,\\n 'wins_in_last_ten': 6, 'streak': 'L2'\\n },\\n {\\n 'team_name': 'Houston', 'wins': 94, 'losses': 56,\\n 'wins_in_last_ten': 7, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Oakland', 'wins': 90, 'losses': 60,\\n 'wins_in_last_ten': 7, 'streak': 'L2'\\n },\\n {\\n 'team_name': 'Seattle', 'wins': 83, 'losses': 67,\\n 'wins_in_last_ten': 5, 'streak': 'W1'\\n },\\n {\\n 'team_name': 'LA Angels', 'wins': 74, 'losses': 76,\\n 'wins_in_last_ten': 6, 'streak': 'W1'\\n },\\n {\\n 'team_name': 'Texas', 'wins': 64, 'losses': 86,\\n 'wins_in_last_ten': 3, 'streak': 'L2'\\n }\\n ]\\n\\n return baseball_data\",\n \"def get_scores(self, tournament: Tournament):\\n self.model.eval()\\n # collate_fn = lambda x: collate_teams(x, tournament.max_members)\\n dl_rank = DataLoader(tournament.ranking, num_workers=self.jobs, batch_size=self.bs, shuffle=False)\\n iterator = tqdm(dl_rank, position=0, desc=f'{tournament.tournament_id} ranking', disable=True)\\n scores = []\\n for i, team in enumerate(iterator):\\n score = self.model.get_team_score(team.to(self.device))\\n scores.append(score.cpu().numpy())\\n\\n scores = np.concatenate(scores)\\n return scores.flatten()\",\n \"def get_eq_scores(self) -> Dict[str, float]:\\n eq_agent_states = dict(\\n (\\n agent_pbk,\\n AgentState(\\n self.game.initialization.eq_money_holdings[i],\\n [int(h) for h in self.game.initialization.eq_good_holdings[i]],\\n self.game.initialization.utility_params[i],\\n ),\\n )\\n for agent_pbk, i in zip(\\n self.game.configuration.agent_pbks,\\n range(self.game.configuration.nb_agents),\\n )\\n ) # type: Dict[str, AgentState]\\n\\n result = {\\n self.game.configuration.agent_pbk_to_name[\\n agent_pbk\\n ]: eq_agent_state.get_score()\\n for agent_pbk, eq_agent_state in eq_agent_states.items()\\n }\\n return result\",\n \"def get_games():\\n\\n return jsonify({\\\"games\\\": list(map(make_public_game, games))})\",\n \"def perform_get_scores(responder, options):\\n match = options['<match-id>']\\n all_scores = scores.get_match_scores(match)\\n\\n if options.get(yaml_opt, False):\\n responder(yaml.dump({'scores': all_scores}))\\n else:\\n if all_scores is None:\\n responder('No scores available for match {0}'.format(match))\\n else:\\n for tla, score in all_scores.iteritems():\\n responder('Team {0} scored {1} in match {2}'.format(tla, score, match))\",\n \"def getScore(self,board):\\n return board.getScore()[self.tile]\",\n \"def players(game_id):\\n # get data\\n data = mlbgame.data.get_players(game_id)\\n # parse data\\n parsed = etree.parse(data)\\n root = parsed.getroot()\\n\\n output = {}\\n output['game_id'] = game_id\\n\\n # get player/coach data\\n for team in root.findall('team'):\\n type = team.attrib['type'] + \\\"_team\\\"\\n # the type is either home_team or away_team\\n output[type] = {}\\n output[type]['players'] = []\\n output[type]['coaches'] = []\\n\\n for p in team.findall('player'):\\n player = {}\\n for key in p.keys():\\n player[key] = p.get(key)\\n output[type]['players'].append(player)\\n\\n for c in team.findall('coach'):\\n coach = {}\\n for key in c.keys():\\n coach[key] = c.get(key)\\n output[type]['coaches'].append(coach)\\n\\n # get umpire data\\n output['umpires'] = []\\n for u in root.find('umpires').findall('umpire'):\\n umpire = {}\\n for key in u.keys():\\n umpire[key] = u.get(key)\\n output['umpires'].append(umpire)\\n\\n return output\",\n \"def print_scores(board: Connect4Board) -> None:\\r\\n print('')\\r\\n # print('\\\\n******************************')\\r\\n # print('************SCORES************')\\r\\n # print('******************************')\\r\\n # print(' BLACK = {} & WHITE = {} '.format(board.get_score('B'), board.get_score('W')))\\r\\n # print('******************************\\\\n')\\r\",\n \"def getScores():\\r\\n results = \\\"\\\"\\r\\n with sqlite3.connect(database_file) as conn:\\r\\n cursor = conn.cursor()\\r\\n team_scores = cursor.execute(\\\"\\\"\\\" SELECT * FROM scores;\\\"\\\"\\\")\\r\\n\\r\\n for row in team_scores.fetchall():\\r\\n teamname, auto, rc, spirit, video = row\\r\\n results += result_string.format(teamname, auto, rc, spirit, video) + \\\"\\\\n\\\"\\r\\n return results\",\n \"def get_games_overall(self, uuid):\\n\\n return self.template(uuid, \\\"games\\\")\",\n \"def test_get_game_boxscore(self):\\n pass\",\n \"async def finish_game(self, ctx: commands.Context, score: dict):\\n # Print out scoreboard, and winner, then give the winners their points\\n scoreboard = sorted(score.items(), key=lambda x:x[1], reverse=True)\\n result = \\\"**SCOREBOARD:**\\\\n\\\"\\n condition = min(len(scoreboard), 9)\\n\\n # Find up to the 9th place\\n # ranking_index[i] will give the index of the first person in the (i+1)th place\\n ranking_index = [0]\\n\\n for i in range(1, len(scoreboard)):\\n if scoreboard[i][1] == scoreboard[i-1][1]:\\n continue\\n ranking_index.append(i)\\n if i >= condition: # Only want up to the 9th place\\n break\\n else:\\n ranking_index.append(len(scoreboard))\\n \\n # Construct results of game and send to channel\\n for i in range(len(ranking_index) - 1):\\n result += (self.word_placing[i] \\n + f\\\" place - {scoreboard[i][1]} points - \\\"\\n + ', '.join(str(x[0]) for x in scoreboard[ranking_index[i]:ranking_index[i+1]])\\n + '\\\\n')\\n\\n # Give points to everyone in first place\\n for person in scoreboard[ranking_index[0]:ranking_index[1]]:\\n self.data[ctx.guild.id]['score'][person[0].id] += 1\\n\\n result += \\\"Players in first place have earned one point each.\\\"\\n await ctx.send(result)\\n # Clear the database\\n self.games_info[ctx.guild.id] = gamesDict()\",\n \"def get_number_games(season: str, team_id: int, game_type_code: str = \\\"R\\\") -> dict:\\n args = arguments.get_arguments()\\n\\n endpoint = f\\\"/schedule?teamId={team_id}&season={season}&gameType={game_type_code}\\\"\\n response = api.nhl_api(endpoint)\\n\\n if response:\\n schedule = response.json()\\n games_total = schedule[\\\"totalItems\\\"]\\n return games_total\\n\\n # If no valid response, just return default number of games (82)\\n return 82\",\n \"def nbaWorkout(gameInfo):\\n \\n if gameInfo['myScore'] >= 0 and gameInfo['opponentScore'] >= 0:\\n if gameInfo['myScore'] > gameInfo['opponentScore']:\\n determineRocketLeagueWin(gameInfo['goals'], gameInfo['assist'], gameInfo['saves'])\\n else:\\n determineRocketLeagueLoss(gameInfo['goals'], gameInfo['assist'], gameInfo['saves'])\\n else:\\n print(\\\"Doesn't make sense dude\\\")\\n return workoutInfo\",\n \"def _aggregate_scores(self,\\n game_scores: List[Dict[str, int]]) -> task.ScoreData:\\n\\n relative_score = []\\n recall = []\\n num_incorrect = []\\n precision = []\\n\\n for score_dict in game_scores:\\n\\n relative_score.append(score_dict['score']/score_dict['max_score'])\\n recall.append(score_dict['num_correct']/score_dict['word_count'])\\n num_incorrect.append(score_dict['num_incorrect'])\\n\\n # Precision -- defined to be 1 if no words are guessed.\\n num_guesses = score_dict['num_correct'] + score_dict['num_incorrect']\\n if num_guesses > 0:\\n precision.append(score_dict['num_correct'] / num_guesses)\\n else:\\n precision.append(1.0)\\n\\n relative_score = np.mean(relative_score)\\n recall = np.mean(recall)\\n num_incorrect = np.mean(num_incorrect)\\n precision = np.mean(precision)\\n\\n score_data = task.ScoreData(\\n {'relative_score': relative_score,\\n 'recall': recall,\\n 'num_incorrect': num_incorrect,\\n 'precision': precision},\\n preferred_score='relative_score',\\n low_score=0.0,\\n high_score=1.0,\\n number_of_shots=-1,\\n subtask_description=('A simplified implementation of the NYT '\\n 'Spelling Bee game. Individual game scoring is '\\n 'defined in the class deffinition. Reported '\\n 'scores are normalized to game maximums.'\\n 'All scores are averaged over each game played '\\n 'in an evaluation run.'))\\n\\n return score_data\",\n \"def _get_current_teams_score(self):\\n for game in self._get_live_games():\\n teams_playing = [x['abbreviation'] for index, x in game['teams'].items()]\\n if self.team in teams_playing:\\n # Our team is playing in this game, get the score \\n return int(game['scores'][self.team])\",\n \"def rlWorkout(gameInfo):\\n \\n if gameInfo['myScore'] >= 0 and gameInfo['opponentScore'] >= 0:\\n if gameInfo['myScore'] > gameInfo['opponentScore']:\\n determineRocketLeagueWin(gameInfo['goals'], gameInfo['assist'], gameInfo['saves'])\\n else:\\n determineRocketLeagueLoss(gameInfo['goals'], gameInfo['assist'], gameInfo['saves'])\\n else:\\n print(\\\"Doesn't make sense dude\\\")\\n return workoutInfo\",\n \"def scores_for(self, board):\\r\\n scores = [50] * board.width\\r\\n\\r\\n for col in range(board.width):\\r\\n if not board.can_add_to(col):\\r\\n scores[col] = -1\\r\\n elif board.is_win_for(self.checker):\\r\\n scores[col] = 100\\r\\n elif board.is_win_for(self.opponent_checker()):\\r\\n scores[col] = 0\\r\\n elif self.lookahead == 0:\\r\\n scores[col] = 50\\r\\n else: \\r\\n board.add_checker(self.checker, col)\\r\\n opponent = AIPlayer(self.opponent_checker(), self.tiebreak, self.lookahead - 1)\\r\\n opp_scores = opponent.scores_for(board)\\r\\n if max(opp_scores) == 100:\\r\\n scores[col] = 0\\r\\n elif max(opp_scores) == 0:\\r\\n scores[col] = 100\\r\\n else:\\r\\n scores[col] = 50\\r\\n board.remove_checker(col)\\r\\n\\r\\n return scores\",\n \"def get_player_data(soup, game_dict):\\n\\n # Loop through teams to store information by team.\\n for i, team in enumerate([\\\"home\\\", \\\"away\\\"]):\\n try:\\n plyrs_soup = soup.findAll(\\n \\\"div\\\", {\\\"class\\\": \\\"aufstellung_ausgabe_block {}side\\\".format(team)})[0]\\n plyr_data = plyrs_soup.findAll(\\\"a\\\", {\\\"class\\\": \\\"spieler_linkurl\\\"})\\n\\n # Loop through players by team.\\n for j, plyr in enumerate(plyr_data):\\n try:\\n game_dict[\\\"{}_plyr_{}\\\".format(team, j)] = plyr.text\\n game_dict[\\\"{}_plyr_url_{}\\\".format(team, j)] = plyr[\\\"href\\\"]\\n except AttributeError:\\n pass\\n except (AttributeError, IndexError):\\n pass\\n\\n return game_dict\",\n \"def games(self, competition_id: int, season_id: int) -> DataFrame[Any]:\",\n \"def split_by_wins(matches, team_id):\\n\\n sorted_matches = {\\n \\\"wins\\\": [],\\n \\\"losses\\\": [],\\n \\\"ties\\\": []\\n }\\n\\n scores = {}\\n\\n for match_id, match in matches.items():\\n this_team_score = 0\\n other_team_score = 0\\n if match.hometeam.team_id == team_id:\\n this_team_score = match.homegoals\\n other_team_score = match.awaygoals\\n elif match.awayteam.team_id == team_id:\\n this_team_score = match.awaygoals\\n other_team_score = match.homegoals\\n else:\\n continue\\n\\n scores[match_id] = (this_team_score, other_team_score)\\n\\n if this_team_score > other_team_score:\\n sorted_matches[\\\"wins\\\"].append(match_id)\\n elif this_team_score < other_team_score:\\n sorted_matches[\\\"losses\\\"].append(match_id)\\n else:\\n sorted_matches[\\\"ties\\\"].append(match_id)\\n\\n return sorted_matches, scores\",\n \"def get_video_games(self, **kwargs):\\n return self.get('video_games.json', **kwargs)\",\n \"def main():\\n\\n # Ask for games to compare.\\n games = {}\\n more_games = True\\n\\n while more_games:\\n search = input(\\\"Enter board game to search (leave empty if finished):\\\")\\n\\n if search:\\n matches = bgg_compare.find_game(search)\\n\\n print(\\\"Games found:\\\")\\n for game_id, name in matches.items():\\n print(game_id + \\\"\\\\t\\\" + name)\\n id = input(\\\"Enter the number before the intended game:\\\")\\n games[id] = matches[id]\\n\\n else:\\n more_games = False\\n\\n # If no games entered, compare all downloaded ratings.\\n if not games:\\n ids = []\\n for f in glob.glob(\\\"[0-9]*.csv\\\"):\\n id = os.path.splitext(f)[0]\\n ids.append(id)\\n game_info = bgg_compare.get_game_info(ids)\\n for i, info in enumerate(game_info):\\n name = info.find(\\\"name\\\", attrs={\\\"type\\\": \\\"primary\\\"})[\\\"value\\\"]\\n games[ids[i]] = name\\n\\n print(\\\"Comparing games:\\\")\\n\\n all_ratings = []\\n\\n for game_id, name in games.items():\\n\\n print(name)\\n\\n ratings = {}\\n filename = \\\"%s.csv\\\" % game_id\\n\\n try:\\n ratings = bgg_compare.read_ratings(filename)\\n except:\\n ratings = bgg_compare.get_ratings(game_id)\\n bgg_compare.write_ratings(ratings, filename)\\n\\n all_ratings.append(ratings)\\n\\n rankings = bgg_compare.condorcet_irv(all_ratings, list(games.keys()))\\n\\n print(\\\"Games ranked by Condorcet-IRV:\\\")\\n\\n header = [\\\"Rank\\\", \\\"ID\\\", \\\"Game\\\", \\\"Tiebreak\\\"]\\n print(\\\"\\\\t\\\".join(header))\\n\\n for i, (game_id, tiebreak) in enumerate(rankings, 1):\\n print(\\\"\\\\t\\\".join([str(i), game_id, games[game_id], str(tiebreak)]))\\n\\n outfile = input(\\\"Enter filename to save results (leave empty to not save)\\\")\\n\\n if outfile:\\n with open(outfile, \\\"w\\\") as csvfile:\\n writer = csv.writer(csvfile)\\n writer.writerow(header)\\n for i, (game_id, tiebreak) in enumerate(rankings, 1):\\n writer.writerow([str(i), game_id, games[game_id], str(tiebreak)])\",\n \"def main():\\n\\tresults = collections.OrderedDict()\\n\\n\\tdb = read_database()\\n\\tprint(db)\\n\\tfor name in db.keys():\\n\\t\\tresults[name] = []\\n\\n\\n\\tfor i in range(NUMBER_OF_RACES):\\n\\t\\tsimulation = simulate_performance(db)\\n\\t\\tpos = position(simulation)\\n\\n\\t\\tfor score, name in enumerate(pos,start = 1):\\n\\t\\t\\tresults[name].append(score)\\n\\t\\t\\n\\n\\tprint(results)\\n\\tresults = list(results.items()) # converts OrderedDict to the list\\n\\tprint(results)\\n\\tprint()\\n\\tprint(\\\"SORTED SCORES\\\")\\n\\tprint(sorted_scores(results))\\n\\tfor idx, sailor in enumerate(sorted_scores(results), start=1):\\n\\t\\tprint(\\\"{:>2} {:>10} {:>10}\\\".format(idx, sailor[0], total_score(sailor)))\\n\\tss = sorted_scores(results)\\n\\n\\tprint(\\\"\\\\n\\\\n*** PLACINGS ***\\\")\\n\\tprint(results)\\n\\treturn results\\n\\n\\tprint(\\\"\\\\n\\\\n*** THE ORDER ***\\\")\\n\\tprint([x[0] for x in sorted_scores(results)])\\n\\treturn [x[0] for x in sorted_scores(results)]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6896654","0.6882706","0.6848933","0.6711905","0.63978255","0.6303648","0.6230028","0.6196659","0.61953855","0.61835605","0.61832064","0.6141031","0.6121574","0.60932535","0.60710603","0.60630333","0.60620886","0.60424584","0.60335046","0.60295945","0.60288495","0.600515","0.5984335","0.5968887","0.59294456","0.59275806","0.5902201","0.5891683","0.5884166","0.58779943","0.58716655","0.58489144","0.5848338","0.58423907","0.5833691","0.58335596","0.581325","0.58113563","0.5804834","0.5788949","0.57883644","0.5775294","0.5767394","0.57673526","0.5766596","0.5766395","0.576251","0.57533485","0.5748691","0.5744176","0.5729973","0.5727486","0.57091737","0.5705592","0.5701361","0.56921786","0.5678506","0.5649619","0.56422776","0.563763","0.5633538","0.5631577","0.56244963","0.5624162","0.5615294","0.5593827","0.55690736","0.5567078","0.5563893","0.5551549","0.5538209","0.5527561","0.552513","0.5521674","0.5519466","0.5518387","0.5506002","0.5505372","0.5495223","0.54937124","0.54847443","0.5472239","0.54619455","0.54605275","0.5456023","0.5455958","0.5453786","0.5450295","0.5445998","0.54458195","0.54439104","0.5440406","0.5438654","0.54384625","0.5436093","0.54262304","0.5418979","0.54172546","0.54151547","0.5408856"],"string":"[\n \"0.6896654\",\n \"0.6882706\",\n \"0.6848933\",\n \"0.6711905\",\n \"0.63978255\",\n \"0.6303648\",\n \"0.6230028\",\n \"0.6196659\",\n \"0.61953855\",\n \"0.61835605\",\n \"0.61832064\",\n \"0.6141031\",\n \"0.6121574\",\n \"0.60932535\",\n \"0.60710603\",\n \"0.60630333\",\n \"0.60620886\",\n \"0.60424584\",\n \"0.60335046\",\n \"0.60295945\",\n \"0.60288495\",\n \"0.600515\",\n \"0.5984335\",\n \"0.5968887\",\n \"0.59294456\",\n \"0.59275806\",\n \"0.5902201\",\n \"0.5891683\",\n \"0.5884166\",\n \"0.58779943\",\n \"0.58716655\",\n \"0.58489144\",\n \"0.5848338\",\n \"0.58423907\",\n \"0.5833691\",\n \"0.58335596\",\n \"0.581325\",\n \"0.58113563\",\n \"0.5804834\",\n \"0.5788949\",\n \"0.57883644\",\n \"0.5775294\",\n \"0.5767394\",\n \"0.57673526\",\n \"0.5766596\",\n \"0.5766395\",\n \"0.576251\",\n \"0.57533485\",\n \"0.5748691\",\n \"0.5744176\",\n \"0.5729973\",\n \"0.5727486\",\n \"0.57091737\",\n \"0.5705592\",\n \"0.5701361\",\n \"0.56921786\",\n \"0.5678506\",\n \"0.5649619\",\n \"0.56422776\",\n \"0.563763\",\n \"0.5633538\",\n \"0.5631577\",\n \"0.56244963\",\n \"0.5624162\",\n \"0.5615294\",\n \"0.5593827\",\n \"0.55690736\",\n \"0.5567078\",\n \"0.5563893\",\n \"0.5551549\",\n \"0.5538209\",\n \"0.5527561\",\n \"0.552513\",\n \"0.5521674\",\n \"0.5519466\",\n \"0.5518387\",\n \"0.5506002\",\n \"0.5505372\",\n \"0.5495223\",\n \"0.54937124\",\n \"0.54847443\",\n \"0.5472239\",\n \"0.54619455\",\n \"0.54605275\",\n \"0.5456023\",\n \"0.5455958\",\n \"0.5453786\",\n \"0.5450295\",\n \"0.5445998\",\n \"0.54458195\",\n \"0.54439104\",\n \"0.5440406\",\n \"0.5438654\",\n \"0.54384625\",\n \"0.5436093\",\n \"0.54262304\",\n \"0.5418979\",\n \"0.54172546\",\n \"0.54151547\",\n \"0.5408856\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68596184"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":76079,"cells":{"query":{"kind":"string","value":"This function will fetch yesterday's mlb scores and return them in a similar fashion to how nhl scores are being returned."},"document":{"kind":"string","value":"def get_mlb_scores(message):\n yesterday = datetime.date.today() - datetime.timedelta(days=1)\n games = scoreboard(yesterday.year,\n yesterday.month,\n yesterday.day)\n scores = []\n\n for game in games:\n home = \"{} {}\\n\".format(\n game['home_team'],\n str(game['home_team_runs']))\n away = \"{} {}\\n\".format(\n game['away_team'],\n str(game['away_team_runs']))\n\n scores.append(away+home)\n\n if len(scores) > 0:\n return('\\n'.join(str(score) for score in scores))\n else:\n return (\"There were no MLB games yesterday :mattstairs:\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getDayAheadMarketLBMPZonal(self):\n\n\t\t# Variables\n\t\ttoday = self.helper.getYear() + self.helper.getMonth() + self.helper.getDay()\n\t\turl = 'http://mis.nyiso.com/public/csv/damlbmp/'+today+'damlbmp_zone.csv' \n\t\tresponse = urllib2.urlopen(url)\n\t\tmarket_data = sorted(csv.reader(response), key=operator.itemgetter(1)) # Converting data to python csv\n\t\tcounter = 0 # Counter used for determining which hour we are curretly on\n\t\tlbmpZonal = {}\n\t\ttimestamp = {}\n\t\ttimestamps = []\n\t\tmarket_info = {}\n\n\t\t# Converting csv data to market data and returning it\n\t\tfor row in market_data:\n\t\t\t# Ignoring header row\n\t\t\tif row[0] != 'Time Stamp':\n\t\t\t\tmarket_info['LBMP ($/MWHr)'] = float(row[3])\n\t\t\t\tmarket_info['Marginal Cost Losses ($/MWHr)'] = float(row[4])\n\t\t\t\tmarket_info['Marginal Cost Congestion ($/MWHr)'] = float(row[5])\n\t\t\t\trow[0] = self.helper.getDateInEpoch(row[0])\n\t\t\t\ttimestamp[row[0]] = market_info\n\t\t\t\tmarket_info = {}\n\t\t\t\ttimestamps.append(timestamp)\n\t\t\t\ttimestamp = {}\n\t\t\t\tcounter +=1\n\t\t\t\t# if counter == 23:\n\t\t\t\t\t# key = row[1]\n\t\t\t\tif counter == 24:\n\t\t\t\t\tlbmpZonal[row[1]] = timestamps\n\t\t\t\t\ttimestamps = []\n\t\t\t\t\tcounter = 0\n\t\treturn lbmpZonal","def live_scores():\n live_scores = cache.get('FOOTBALL_LIVE_SCORES')\n if live_scores:\n scores_array = []\n for score in json.loads(live_scores)[0:3]:\n if not score['LIVE']:\n scores_array.append(score) \n return {'live_scores': scores_array}\n else:\n return {}","def scoreboard(year, month, day):\n # Get data from mlbgame library\n data = mlbgame.data.get_scoreboard(year, month, day)\n # Parse through returned data\n parsed = etree.parse(data)\n root = parsed.getroot()\n output = []\n # Loop through the list of games that are returned\n for game in root:\n if game.tag == 'data':\n return []\n # Get the Team Names\n teams = game.findall('team')\n home_name = teams[0].attrib['name']\n away_name = teams[1].attrib['name']\n # Building a dictionary\n # I am really only interested in the scores.... not sure if\n # game_id is actually necessary....but here it stays\n game_data = game.find('game')\n game_id = game_data.attrib['id']\n home_team_data = teams[0].find('gameteam')\n home_team = home_name\n home_team_runs = int(home_team_data.attrib['R'])\n away_team_data = teams[1].find('gameteam')\n away_team = away_name\n away_team_runs = int(away_team_data.attrib['R'])\n score = {\n 'home_team': home_team,\n 'home_team_runs': home_team_runs,\n 'away_team': away_team,\n 'away_team_runs': away_team_runs\n }\n output.append(score)\n return output","def mlbarrests(self, irc, msg, args): \n \n url = self._b64decode('aHR0cDovL2FycmVzdG5hdGlvbi5jb20vY2F0ZWdvcnkvcHJvLWJhc2ViYWxsLw==')\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to open: %s\" % url)\n return\n \n html = html.replace(' ',' ').replace('’','’')\n\n soup = BeautifulSoup(html)\n lastDate = soup.findAll('span', attrs={'class':'time'})[0] \n divs = soup.findAll('div', attrs={'class':'entry'})\n\n append_list = []\n\n for div in divs:\n title = div.find('h2')\n datet = div.find('span', attrs={'class':'time'})\n datet = self._dateFmt(str(datet.getText()))\n arrestedFor = div.find('strong', text=re.compile('Team:')) \n if arrestedFor:\n matches = re.search(r'<strong>Team:.*?</strong>(.*?)<br />', arrestedFor.findParent('p').renderContents(), re.I|re.S|re.M)\n if matches:\n college = matches.group(1).replace('(MLB)','').strip()\n else:\n college = \"None\"\n else:\n college = \"None\"\n \n append_list.append(ircutils.bold(datet) + \" :: \" + title.getText() + \" - \" + college) # finally add it all\n \n daysSince = self._daysSince(str(lastDate.getText()))\n irc.reply(\"{0} days since last MLB arrest\".format(ircutils.mircColor(daysSince, 'red')))\n \n for each in append_list[0:6]:\n irc.reply(each)","def latest(scores):\n return scores[-1]","def latest(scores):\n return scores[-1]","def fetchHistory(self, token):\n history = self.loadHistory(token)\n if len(history):\n startStamp = history[-1][\"timestamp\"] + 1000 + random.random()*1000 # Add some random number of seconds\n startDateStr = time.strftime(\"%Y%m%d\", time.gmtime(int(startStamp)))\n else:\n startDateStr = \"20130428\" # Date of the first bitcoin valuation ?\n dateStr = time.strftime(\"%Y%m%d\")\n uri = self.historyTemplate % (token, startDateStr, dateStr)\n print(\"Fetching history\")\n html = BeautifulSoup(urlrequest.urlopen(uri).read().decode(), \"html.parser\")\n print(\"parsing html\")\n dataRows = html.find(\"div\", {\"id\": \"historical-data\"}).find(\"table\", {\"id\", \"table\"}).find(\"tbody\").find_all(\"tr\", {\"class\": \"text-right\"})\n headers = [\"date.string\", \"open\", \"high\", \"low\", \"close\", \"volume\", \"market.cap\"]\n dataPts = []\n print(\"translating data\")\n for row in dataRows:\n rowObj = {}\n for i, td in enumerate(row.find_all(\"td\")):\n if i == 0:\n try:\n rowObj[headers[i]] = td.get_text()\n rowObj[\"timestamp\"] = helpers.stamp2dayStamp(datetime.datetime.strptime(td.get_text(), \"%b %d, %Y\").timestamp())\n except Exception:\n print(\"failed to parse float from `%s`\" % td.get_text())\n rowObj[headers[i]] = \"Dec 31, 1999\"\n elif i < 5:\n try:\n rowObj[headers[i]] = float(td.get_text())\n except Exception:\n print(\"failed to parse float from `%s`\" % td.get_text())\n rowObj[headers[i]] = 0.0\n else:\n try:\n rowObj[headers[i]] = int(td.get_text().replace(\",\", \"\"))\n except Exception:\n print(\"failed to parse integer from `%s`\" % td.get_text())\n rowObj[headers[i]] = 0\n dataPts.append(rowObj)\n for pt in sorted(dataPts, key=lambda p: p[\"timestamp\"]):\n if len(history) == 0 or pt[\"timestamp\"] > history[-1][\"timestamp\"]:\n history.append(pt)\n self.saveHistory(token, history)\n return history","def get_mke_scores():\n _scores = {k:[] for k in time_str_to_time.keys()} \n _scores['all'] = [] # add key for all milwaukee and all time zones\n for zip_ in zip_populations.keys(): \n res = query_all_crimes(zip_=zip_)\n print(f'[PROCESSING] {zip_}')\n crimes = to_df(res)\n create_crime_cat(crimes)\n integrate_weight_to_df(crimes)\n for time_sl in time_str_to_time.keys():\n sub = extract_crimes_by_sl(crimes, time_str_to_time[time_sl]) \n cas = compute_crime_score(sub, zip_) \n _scores[time_sl].append(cas)\n _scores['all'].append(cas)\n return _scores","def calculate(self, prev_scores):\n self.set_scores(prev_scores)\n for match in self.week.matches:\n if match.played:\n # Fetch old scores\n winner_score = float(prev_scores[match.winner])\n loser_score = float(prev_scores[match.loser])\n\n # Update this ranking's scores\n score_delta = loser_score * 0.1\n self.score[match.winner] = winner_score + score_delta\n self.score[match.loser] = loser_score - score_delta","def calculate_scores():\n all_people = models.Leaderboard.query.order_by(\n models.Leaderboard.score.desc()).all()\n print(all_people)\n users = []\n scores = []\n for person in all_people:\n users.append(person.username)\n scores.append(person.score)\n return users, scores","def get_scores(self, query):\n self.init()\n tokens = self.tokenizer.tokenize(query)\n return self.bm25_instance.get_scores(query=tokens)","def getDataForLBMPvsLoadComparisons(self):\n\n\t\t# Variables\n\t\tlbmp_data = self.getDataForLBMPZonalComparison()[14] # Getting CAPITL zone\n\t\tload_data = self.getLoadData()\n\t\tfinal_data = []\n\t\tlbmp_dict = {}\n\t\tload_dict = {}\n\t\tload_values = []\n\t\tdates = []\n\t\tprice_values = []\n\n\t\t# Getting needed lbmp_data\n\t\tkey = \"LBMP ($/MWHr) in \" + lbmp_data['key']\n\t\tfor value in lbmp_data['values']:\n\t\t\tdates_and_prices = []\n\t\t\tdates_and_prices.append(value['x'])\n\t\t\tdates.append(value['x'])\n\t\t\tdates_and_prices.append(value['y'])\n\t\t\tprice_values.append(dates_and_prices)\n\t\tlbmp_dict['key'] = key\n\t\tlbmp_dict['values'] = price_values\n\t\tfinal_data.append(lbmp_dict)\n\t\tdata_dict = {}\n\n\t\t# Getting needed load data\n\t\tyesterday = self.helper.getYesterday()\n\t\tloads = load_data[yesterday[0]][int(yesterday[1])][int(yesterday[2])]\n\t\tfor i in range(0,len(loads)):\n\t\t\tdates_and_loads = []\n\t\t\tdates_and_loads.append(dates[i])\n\t\t\tdates_and_loads.append(loads[i])\n\t\t\tload_values.append(dates_and_loads)\n\t\tload_dict['key'] = lbmp_data['key'] + \" Area Loads\"\n\t\tload_dict['values'] = load_values\n\t\tload_dict['bar'] = 'True'\n\t\tfinal_data.append(load_dict)\n\t\treturn final_data","def test_get_historical_gold_rate(self):\n rates = [153.50, 162.49, 123.86, 155.10]\n helper.gold_loop_helper(get_historical_gold_rate, TestHistoricalRates.dates_rate, rates)","def mlbvaluations(self, irc, msg, args):\n \n url = self._b64decode('aHR0cDovL3d3dy5mb3JiZXMuY29tL21sYi12YWx1YXRpb25zL2xpc3Qv')\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to load: %s\" % url)\n return\n \n soup = BeautifulSoup(html)\n tbody = soup.find('tbody', attrs={'id':'listbody'})\n rows = tbody.findAll('tr')\n\n object_list = []\n\n for row in rows:\n rank = row.find('td', attrs={'class':'rank'})\n team = rank.findNext('td')\n value = team.findNext('td')\n yrchange = value.findNext('td')\n debtvalue = yrchange.findNext('td')\n revenue = debtvalue.findNext('td')\n operinc = revenue.findNext('td')\n d = collections.OrderedDict()\n d['rank'] = rank.renderContents().strip()\n d['team'] = team.find('h3').renderContents().strip()\n d['value'] = value.renderContents().strip()\n d['yrchange'] = yrchange.renderContents().strip()\n d['debtvalue'] = debtvalue.renderContents().strip()\n d['revenue'] = revenue.renderContents().strip()\n d['operinc'] = operinc.renderContents().strip()\n object_list.append(d)\n \n irc.reply(ircutils.mircColor(\"Current MLB Team Values\", 'red') + \" (in millions):\")\n \n for N in self._batch(object_list, 7):\n irc.reply(' '.join(str(str(n['rank']) + \".\" + \" \" + ircutils.bold(n['team'])) + \" (\" + n['value'] + \"M)\" for n in N))","def get_highscores(self):\n return self.filter(active=False, finished=True).order_by(\"-score\")","def scoreboard(year, month, day, home=None, away=None):\n # get data\n data = mlbgame.data.get_scoreboard(year, month, day)\n # parse data\n parsed = etree.parse(data)\n root = parsed.getroot()\n games = {}\n output = {}\n # loop through games\n for game in root:\n if game.tag == 'data':\n return []\n # get team names\n teams = game.findall('team')\n home_name = teams[0].attrib['name']\n away_name = teams[1].attrib['name']\n # check if teams match parameters\n if (home_name == home and home is not None) \\\n or (away_name == away and away is not None) \\\n or (away is None and home is None):\n # throw all the data into a complicated dictionary\n game_tag = game.tag\n game_data = game.find('game')\n game_id = game_data.attrib['id']\n game_league = game_data.attrib['league']\n game_status = game_data.attrib['status']\n game_start_time = game_data.attrib['start_time']\n home_team_data = teams[0].find('gameteam')\n home_team = home_name\n home_team_runs = int(home_team_data.attrib['R'])\n home_team_hits = int(home_team_data.attrib['H'])\n home_team_errors = int(home_team_data.attrib['E'])\n away_team_data = teams[1].find('gameteam')\n away_team = away_name\n away_team_runs = int(away_team_data.attrib['R'])\n away_team_hits = int(away_team_data.attrib['H'])\n away_team_errors = int(away_team_data.attrib['E'])\n # check type of game\n if game_tag == 'go_game' or game_tag == 'ig_game':\n try:\n w_pitcher_data = game.find('w_pitcher')\n w_pitcher = w_pitcher_data.find('pitcher').attrib['name']\n w_pitcher_wins = int(w_pitcher_data.attrib['wins'])\n w_pitcher_losses = int(w_pitcher_data.attrib['losses'])\n except Exception:\n w_pitcher = \"\"\n w_pitcher_wins = 0\n w_pitcher_losses = 0\n try:\n l_pitcher_data = game.find('l_pitcher')\n l_pitcher = l_pitcher_data.find('pitcher').attrib['name']\n l_pitcher_wins = int(l_pitcher_data.attrib['wins'])\n l_pitcher_losses = int(l_pitcher_data.attrib['losses'])\n except Exception:\n l_pitcher = \"\"\n l_pitcher_wins = 0\n l_pitcher_losses = 0\n try:\n sv_pitcher_data = game.find('sv_pitcher')\n sv_pitcher = sv_pitcher_data.find('pitcher').attrib['name']\n sv_pitcher_saves = int(sv_pitcher_data.attrib['saves'])\n except Exception:\n sv_pitcher = \"\"\n sv_pitcher_saves = 0\n output = {\n 'game_id': game_id,\n 'game_tag': game_tag,\n 'game_league': game_league,\n 'game_status': game_status,\n 'game_start_time': game_start_time,\n 'home_team': home_team,\n 'home_team_runs': home_team_runs,\n 'home_team_hits': home_team_hits,\n 'home_team_errors': home_team_errors,\n 'away_team': away_team,\n 'away_team_runs': away_team_runs,\n 'away_team_hits': away_team_hits,\n 'away_team_errors': away_team_errors,\n 'w_pitcher': w_pitcher,\n 'w_pitcher_wins': w_pitcher_wins,\n 'w_pitcher_losses': w_pitcher_losses,\n 'l_pitcher': l_pitcher,\n 'l_pitcher_wins': l_pitcher_wins,\n 'l_pitcher_losses': l_pitcher_losses,\n 'sv_pitcher': sv_pitcher,\n 'sv_pitcher_saves': sv_pitcher_saves\n }\n # games that were not played\n elif game_tag == 'sg_game':\n try:\n p_pitcher_data = game.findall('p_pitcher')\n p_pitcher_home_data = p_pitcher_data[0]\n p_pitcher_home = p_pitcher_home_data.find(\n 'pitcher').attrib['name']\n p_pitcher_home_wins = int(p_pitcher_home_data.\n attrib['wins'])\n p_pitcher_home_losses = int(p_pitcher_home_data.\n attrib['losses'])\n p_pitcher_away_data = p_pitcher_data[1]\n p_pitcher_away = p_pitcher_away_data.find(\n 'pitcher').attrib['name']\n p_pitcher_away_wins = int(p_pitcher_away_data.\n attrib['wins'])\n p_pitcher_away_losses = int(p_pitcher_away_data.\n attrib['losses'])\n except Exception:\n p_pitcher_home = ''\n p_pitcher_home_wins = 0\n p_pitcher_home_losses = 0\n p_pitcher_away = ''\n p_pitcher_away_wins = 0\n p_pitcher_away_losses = 0\n output = {\n 'game_id': game_id,\n 'game_tag': game_tag,\n 'game_league': game_league,\n 'game_status': game_status,\n 'game_start_time': game_start_time,\n 'home_team': home_team,\n 'home_team_runs': home_team_runs,\n 'home_team_hits': home_team_hits,\n 'home_team_errors': home_team_errors,\n 'away_team': away_team,\n 'away_team_runs': away_team_runs,\n 'away_team_hits': away_team_hits,\n 'away_team_errors': away_team_errors,\n 'p_pitcher_home': p_pitcher_home,\n 'p_pitcher_home_wins': p_pitcher_home_wins,\n 'p_pitcher_home_losses': p_pitcher_home_losses,\n 'p_pitcher_away': p_pitcher_away,\n 'p_pitcher_away_wins': p_pitcher_away_wins,\n 'p_pitcher_away_losses': p_pitcher_away_losses\n }\n # put this dictionary into the larger dictionary\n games[game_id] = output\n return games","def get_games(date):\n scoreboard = nba_py.Scoreboard(month=date.month,\n day=date.day,\n year=date.year)\n line_score = scoreboard.line_score()\n game_header = scoreboard.game_header()\n\n games = []\n current_game = {}\n game_sequence = 0\n game_sequence_counter = 0\n\n # Get HOME TEAM and AWAY TEAM data for each boxscore game in line_score.\n for i, value in enumerate(line_score):\n if (value[\"GAME_SEQUENCE\"] != game_sequence):\n game_sequence += 1\n\n current_game[\"GAME_ID\"] = value[\"GAME_ID\"]\n home_team_id = game_header[game_sequence - 1][\"HOME_TEAM_ID\"]\n\n if (home_team_id == value[\"TEAM_ID\"]):\n current_game[\"HOME_TEAM\"] = value[\"TEAM_ABBREVIATION\"]\n current_game[\"HOME_TEAM_WINS_LOSSES\"] = value[\"TEAM_WINS_LOSSES\"]\n current_game[\"HOME_TEAM_PTS\"] = value[\"PTS\"]\n current_game[\"HOME_TEAM_ID\"] = value[\"TEAM_ID\"]\n if (current_game[\"HOME_TEAM\"] in TEAM_ID_DATA):\n current_game[\"HOME_TEAM_IMG\"] = TEAM_ID_DATA[current_game[\"HOME_TEAM\"]][\"img\"]\n else:\n current_game[\"AWAY_TEAM\"] = value[\"TEAM_ABBREVIATION\"]\n current_game[\"AWAY_TEAM_WINS_LOSSES\"] = value[\"TEAM_WINS_LOSSES\"]\n current_game[\"AWAY_TEAM_PTS\"] = value[\"PTS\"]\n current_game[\"AWAY_TEAM_ID\"] = value[\"TEAM_ID\"]\n if (current_game[\"AWAY_TEAM\"] in TEAM_ID_DATA):\n current_game[\"AWAY_TEAM_IMG\"] = TEAM_ID_DATA[current_game[\"AWAY_TEAM\"]][\"img\"]\n\n if (value[\"TEAM_ABBREVIATION\"] in TEAMS):\n if (home_team_id == value[\"TEAM_ID\"]):\n current_game[\"HOME_TEAM_FULL_NAME\"] = TEAMS[value[\"TEAM_ABBREVIATION\"]][\"city\"] + \\\n \" \" + TEAMS[value[\"TEAM_ABBREVIATION\"]][\"name\"]\n else:\n current_game[\"AWAY_TEAM_FULL_NAME\"] = TEAMS[value[\"TEAM_ABBREVIATION\"]][\"city\"] + \\\n \" \" + TEAMS[value[\"TEAM_ABBREVIATION\"]][\"name\"]\n \n game_sequence = value[\"GAME_SEQUENCE\"]\n game_sequence_counter += 1\n elif game_sequence_counter == 1:\n if (\"AWAY_TEAM\" in current_game):\n current_game[\"HOME_TEAM\"] = value[\"TEAM_ABBREVIATION\"]\n current_game[\"HOME_TEAM_WINS_LOSSES\"] = value[\"TEAM_WINS_LOSSES\"]\n current_game[\"HOME_TEAM_PTS\"] = value[\"PTS\"]\n current_game[\"HOME_TEAM_ID\"] = value[\"TEAM_ID\"]\n if (current_game[\"HOME_TEAM\"] in TEAM_ID_DATA):\n current_game[\"HOME_TEAM_IMG\"] = TEAM_ID_DATA[current_game[\"HOME_TEAM\"]][\"img\"]\n else:\n current_game[\"AWAY_TEAM\"] = value[\"TEAM_ABBREVIATION\"]\n current_game[\"AWAY_TEAM_WINS_LOSSES\"] = value[\"TEAM_WINS_LOSSES\"]\n current_game[\"AWAY_TEAM_PTS\"] = value[\"PTS\"]\n current_game[\"AWAY_TEAM_ID\"] = value[\"TEAM_ID\"]\n if (current_game[\"AWAY_TEAM\"] in TEAM_ID_DATA):\n current_game[\"AWAY_TEAM_IMG\"] = TEAM_ID_DATA[current_game[\"AWAY_TEAM\"]][\"img\"]\n\n if (value[\"TEAM_ABBREVIATION\"] in TEAMS):\n if (\"AWAY_TEAM\" in current_game):\n current_game[\"HOME_TEAM_FULL_NAME\"] = TEAMS[value[\"TEAM_ABBREVIATION\"]][\"city\"] + \\\n \" \" + TEAMS[value[\"TEAM_ABBREVIATION\"]][\"name\"]\n else:\n current_game[\"AWAY_TEAM_FULL_NAME\"] = TEAMS[value[\"TEAM_ABBREVIATION\"]][\"city\"] + \\\n \" \" + TEAMS[value[\"TEAM_ABBREVIATION\"]][\"name\"]\n\n current_game[\"GAME_STATUS_TEXT\"] = game_header[game_sequence - 1][\"GAME_STATUS_TEXT\"]\n if not game_header[game_sequence - 1][\"NATL_TV_BROADCASTER_ABBREVIATION\"]:\n current_game[\"BROADCASTER\"] = \"\"\n else:\n current_game[\"BROADCASTER\"] = game_header[game_sequence - 1][\"NATL_TV_BROADCASTER_ABBREVIATION\"]\n\n games.append(current_game)\n\n current_game = {}\n\n game_sequence = value[\"GAME_SEQUENCE\"]\n game_sequence_counter -= 1\n\n east_standings = scoreboard.east_conf_standings_by_day()\n west_standings = scoreboard.west_conf_standings_by_day()\n\n return (games, east_standings, west_standings)","def get_past_matches_data(team):\n matches = team.get_past_matches()\n match_list = []\n for match in matches:\n match_dict = {}\n match_dict['match_date'] = match.match_date\n match_dict['match_name'] = match.__str__()\n match_dict['id'] = match.id\n innings = match.get_innings()\n if len(innings):\n if innings[0].runs > innings[1].runs:\n match_dict['winner_team'] = innings[0].bat_team\n match_dict['win_margin'] = innings[0].runs - innings[1].runs\n match_dict['win_type'] = 'Runs'\n match_dict['winner_score'] = str(innings[0].runs) + '/' + str(innings[0].wickets)\n else:\n match_dict['winner_team'] = innings[1].bat_team\n match_dict['win_margin'] = 10 - innings[1].wickets\n match_dict['win_type'] = 'Wickets'\n match_dict['winner_score'] = str(innings[1].runs) + '/' + str(innings[1].wickets)\n match_list.append(match_dict)\n return match_list","def getScores(self,query):\n pass","def get_highscores(self):\n return self.database.get_high_scores(self.difficulty)","def get_btcoin_day_data(self):\n cursor = self.__connect().cursor()\n limit = (str(int(time.time() - 24*60*60)),)\n hashdata = []\n rewarddata = []\n summ = 0\n for row in cursor.execute('SELECT * from btcoin where key > ? ORDER BY key ASC', limit):\n date = int(row[0])\n hashrate = str(row[1])\n hashrate = self.convert_hashrate_to_float(hashrate)\n summ = summ + hashrate\n reward = float(row[2])\n hashdata.append([date, hashrate])\n rewarddata.append([date, reward])\n cursor.close()\n self.__disconnect()\n if len(hashdata) != 0:\n hashaverage = summ / len(hashdata)\n return (hashaverage, hashdata, rewarddata)\n else:\n return (-1, hashdata, rewarddata)","def retrieve_score(wb,tick,increase,write):\n sheetn = wb.sheetnames[1:] # get all the excel sheets\n sheet_names = ['Environmental','Social','Governance','ESG_combined','ESG_controvesies','ESG_score'] # their names\n \n if write:\n list_year= [\"09\",\"10\",\"11\",\"12\",\"13\",\"14\",\\\n \"15\",\"16\",\"17\",\"18\",\"19\",\"20\",\\\n \"21\"]\n\n else:\n list_year = [tick+\"09\",tick+\"10\",tick+\"11\",tick+\"12\",tick+\"13\",tick+\"14\",\\\n tick+\"15\",tick+\"16\",tick+\"17\",tick+\"18\",tick+\"19\",tick+\"20\",\\\n tick+\"21\"] # indeces for the dataframe\n \n sr = wb[sheetn[1]]\n\n # first find the row of the Ticker\n \n row = None\n wb[sheetn[1]]\n for i in range(1,sr.max_row+1):\n k = 'A' + str(i)\n if sr[k].value == tick:\n row = i\n else:\n continue\n \n assert row != None, \"Ticker Not Found\"\n\n if increase==True:\n if write==True:\n if not os.path.isdir(os.getcwd().replace(\"\\\\\",\"/\") + \"/Bloomberg_Score_Change\"):\n os.makedirs(os.getcwd().replace(\"\\\\\",\"/\") + \"/Bloomberg_Score_Change\")\n filename = os.getcwd().replace(\"\\\\\",\"/\") + '/Bloomberg_Score_Change'+'/Bsi_'+tick+'.txt'\n\n list_cell = ['AD'+ str(row),'AE'+ str(row),'AF'+ str(row),'AG'+ str(row),'AH'+ str(row),'AI'+ str(row),\\\n 'AJ'+ str(row),'AK'+ str(row),'AL'+ str(row),'AM'+ str(row),'AN'+ str(row),'AO'+ str(row),\\\n 'AP'+ str(row)]\n er = [\"#DIV/0!\",\"#VALUE!\"]\n \n\n else:\n if write==True:\n\n if not os.path.isdir(os.getcwd().replace(\"\\\\\",\"/\") + \"/Bloomberg_Score\"):\n os.makedirs(os.getcwd().replace(\"\\\\\",\"/\") + \"/Bloomberg_Score\")\n filename =os.getcwd().replace(\"\\\\\",\"/\") + '/Bloomberg_Score'+'/Bs_'+tick+'.txt'\n\n list_cell = ['F'+ str(row),'G'+ str(row),'H'+ str(row),'I'+ str(row),'J'+ str(row),'K'+ str(row),\\\n 'L'+ str(row),'M'+ str(row),'N'+ str(row),'O'+ str(row),'P'+ str(row),'Q'+ str(row),\\\n 'R'+ str(row)]\n er = []\n \n \n \n assert len(list_cell) == len(list_year), \"Missing Year or Cells\"\n\n score = [] #initializing the score\n\n for sheet in sheetn: # looping through all the sheets\n \n sr = wb[sheet] # assigining the searech engine\n \n topic_score = [] # creating the topic score list\n\n for cell in list_cell: # for every cell in the list cells \n\n if sr[cell].value not in er: # if its not in the error list\n \n topic_score.append(sr[cell].value) # append it\n\n else: # otherwise\n topic_score.append(0) # append 0 (only the case for the change in scores)\n\n score.append(topic_score) # appending to score list\n del topic_score # deleting to conserve memory\n \n \n data = pd.DataFrame(data = zip(score[0],score[1],score[2],score[3],score[4],score[5]),\\\n columns = sheet_names,index = list_year) # creating data frame\n\n \n\n if write==True:\n txtfile = open(filename,'w+',encoding='utf-8') # opening text file\n txtfile.write(data.to_string()) # writing the dataframe in the text file\n txtfile.close # closing the file\n return None\n\n else:\n return data","def get_scores(tmp_dir, profile_file_directory, stderr_log_output):\r\n\t\r\n\tranges = pickle.load(open(os.path.join(tmp_dir, \"ranges.pkl\")))\r\n\t\r\n\t(database, locusList,list_of_all_allele_numbers_tuple) = try_and_except(stderr_log_output,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tget_profiles,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tprofile_file_directory)\r\n\t\r\n\tresults = try_and_except(stderr_log_output,\r\n\t\t\t\t\t\t\t score,\r\n\t\t\t\t\t\t\t tmp_dir,\r\n\t\t\t\t\t\t\t locusList,\r\n\t\t\t\t\t\t\t ranges)\r\n\t\r\n\treturn results, database, locusList, list_of_all_allele_numbers_tuple","def get_mlb_today_lineup_by_team_abbv(team_abbv_name):\n games = get_today_games_from_team_abbv(team_abbv_name)\n players = []\n # Is a forloop because 1 team can play 2 games in 1 day\n for game in games:\n try:\n home_lineups, away_lineups = get_lineups_from_mlbgame(game)\n players.append(get_players_from_mlb_lineups(away_lineups, home_lineups))\n except LineUpFoundException as error:\n print(error)\n\n return players","def mlbpowerrankings(self, irc, msg, args):\n \n url = self._b64decode('aHR0cDovL2VzcG4uZ28uY29tL21sYi9wb3dlcnJhbmtpbmdz')\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to fetch: %s\" % url)\n return\n \n html = html.replace(\"evenrow\", \"oddrow\")\n\n soup = BeautifulSoup(html)\n table = soup.find('table', attrs={'class': 'tablehead'})\n prdate = table.find('td', attrs={'colspan': '6'}).renderContents()\n t1 = table.findAll('tr', attrs={'class': 'oddrow'})\n\n if len(t1) < 30:\n irc.reply(\"Failed to parse MLB Power Rankings. Did something break?\")\n return\n\n object_list = []\n\n for row in t1:\n rowrank = row.find('td', attrs={'class': 'pr-rank'}).renderContents().strip()\n rowteam = row.find('div', attrs={'style': re.compile('^padding.*')}).find('a').text.strip()\n rowrecord = row.find('span', attrs={'class': 'pr-record'}).renderContents().strip()\n rowlastweek = row.find('span', attrs={'class': 'pr-last'}).renderContents().strip().replace(\"Last Week\", \"prev\") \n\n d = collections.OrderedDict()\n d['rank'] = int(rowrank)\n d['team'] = str(rowteam)\n d['record'] = str(rowrecord)\n d['lastweek'] = str(rowlastweek)\n object_list.append(d)\n\n if prdate:\n irc.reply(ircutils.mircColor(prdate, 'blue'))\n\n for N in self._batch(object_list, 6):\n irc.reply(' '.join(str(str(n['rank']) + \".\" + \" \" + ircutils.bold(n['team'])) + \" (\" + n['lastweek'] + \")\" for n in N))","def find_games(days_ahead=0):\n headers = {\n 'Host': 'stats.nba.com',\n 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0',\n 'Accept': 'application/json, text/plain, */*',\n 'Accept-Language': 'en-US,en;q=0.5',\n 'Referer': 'https://stats.nba.com/',\n 'Accept-Encoding': 'gzip, deflate, br',\n 'Connection': 'keep-alive',\n 'x-nba-stats-origin': 'stats',\n 'x-nba-stats-token': 'true'\n }\n board = scoreboardv2.ScoreboardV2(day_offset=days_ahead, headers=headers).get_data_frames()[0]\n board.replace(id_to_abrv, inplace=True)\n return board[['GAME_DATE_EST', 'GAME_ID', 'HOME_TEAM_ID', 'VISITOR_TEAM_ID']]","def getHighscores():\n\n # sort and load the profiles from the external file\n sortProfiles()\n profiles = loadProfiles()\n\n highscores = []\n for i in range(0, 5):\n # make sure we aren't exceeding the index of the array\n if i < len(profiles):\n # omit the password from the dict\n highscore = {\n 'username': profiles[i]['username'],\n 'score': profiles[i]['score']\n }\n highscores.append(highscore)\n else:\n break\n\n return highscores","def calc_scores(unscored_list, master_list):\n num_scores = len(unscored_list)\n best_score = master_list[0]['score']\n worst_score = master_list[num_scores]['score']\n score_interval = (best_score - worst_score) / num_scores\n score = best_score\n\n for item in unscored_list:\n item['score'] = score\n score -= score_interval\n return unscored_list","def liblin_cleanscores(liblin_scores, liblin_labellist, nclasses):\n lowscore = np.min(liblin_scores) - 1\n scores = []\n for lls in liblin_scores:\n s = np.ones(nclasses) * lowscore\n s[liblin_labellist] = lls\n scores.append(s)\n return scores","def getScore(self):\n\t\tself.scoreList = [submissionsss.score for submissionsss in self.subreddit.top(time_filter = 'day', limit = self.limits)]\n\t\treturn self.scoreList","def get_liwc_scores(self) -> Tuple[pd.DataFrame, pd.DataFrame]:\n big_five_cols = ['Openness', 'Conscientiousness', 'Extraversion',\n 'Agreeableness', 'Neuroticism']\n\n liwc_data = self._get_category_scores(self._get_liwc_df())\n liwc_scores = pd.DataFrame(columns=big_five_cols)\n liwc_scores[big_five_cols] = liwc_data.swifter.apply(\n self.get_big_five_scores, axis=1, result_type='expand'\n )\n liwc_scores = self.apply_corrections(liwc_data, liwc_scores)\n if self.author == 'golbeck':\n liwc_scores = self.add_sentiment_scores(liwc_scores)\n\n # Min-max normalization\n liwc_scores_normalized = (liwc_scores - liwc_scores.min()) / (\n liwc_scores.max() - liwc_scores.min()) * 100\n return liwc_scores.round(15), liwc_scores_normalized.round(15)","def list_of_scores(self):\n with open(Constant.this_score, \"r\") as f:\n final= f.read()\n final = int(final)\n with open(Constant.list_scores, \"r\") as li:\n points_file = json.load(li)\n points = points_file['HighScores']\n\n with open(Constant.list_scores,\"w\") as files:\n\n if len(points) == 5:\n if points[0] < final:\n for i in range(len(points)-1,0,-1):\n points[i] = points[i-1]\n points[0] = final\n json.dump(points_file,files)\n elif points[0] > final:\n if points[1] < final:\n for i in range(len(points)-1,1,-1):\n points[i] = points[i-1]\n points[1] = final\n json.dump(points_file,files)\n elif points[1] > final:\n if points[2] < final:\n for i in range(len(points)-1,2,-1):\n points[i] = points[i-1]\n points[2] = final\n json.dump(points_file,files)\n elif points[2] > final:\n if points[3] < final:\n for i in range(len(points)-1,3,-1):\n points[i] = points[i-1]\n points[3] = final\n json.dump(points_file,files)\n elif points[3] > final:\n if points[4] < final:\n points[4] = final\n json.dump(points_file,files)\n else:\n json.dump(points_file,files)\n else:\n json.dump(points_file,files)\n else:\n json.dump(points_file,files)\n else:\n json.dump(points_file,files)\n else:\n json.dump(points_file,files)","def latest(scores: list) -> int:\n return scores[-1]","def parse_scores(option, table_num, language, min_score, max_score):\n html = query_by_lang(BASE_URL + '/' + option, language)\n table = html.find_all(\"table\")[table_num]\n freq_list = table.find_all(\"tr\")[2:]\n\n # Create the dictionary\n list_min = find_min(freq_list)\n list_max = find_max(freq_list)\n return create_dict(freq_list, list_min, list_max, min_score, max_score)","def get_high_scores(self,request):\n if request.number_of_results:\n scores = Score.query(Score.won == True).order(Score.attempts_allowed,Score.guesses).fetch(request.number_of_results)\n else:\n scores = Score.query(Score.won == True).order(Score.attempts_allowed,Score.guesses).fetch()\n return ScoreForms(items=[score.to_form() for score in scores])","def get_baseball_data():\n\n baseball_data = [\n {\n 'team_name': 'Boston', 'wins': 103, 'losses': 47,\n 'wins_in_last_ten': 7, 'streak': 'W2'\n },\n {\n 'team_name': 'NY Yankees', 'wins': 91, 'losses': 58,\n 'wins_in_last_ten': 4, 'streak': 'L2'\n },\n {\n 'team_name': 'Tampa Bay', 'wins': 83, 'losses': 66,\n 'wins_in_last_ten': 8, 'streak': 'W3'\n },\n {\n 'team_name': 'Toronto', 'wins': 68, 'losses': 82,\n 'wins_in_last_ten': 5, 'streak': 'W3'\n },\n {\n 'team_name': 'Baltimore', 'wins': 43, 'losses': 107,\n 'wins_in_last_ten': 2, 'streak': 'L1'\n },\n {\n 'team_name': 'Cleveland', 'wins': 83, 'losses': 66,\n 'wins_in_last_ten': 4, 'streak': 'L1'\n },\n {\n 'team_name': 'Minnesota', 'wins': 69, 'losses': 81,\n 'wins_in_last_ten': 5, 'streak': 'W2'\n },\n {\n 'team_name': 'Detroit', 'wins': 61, 'losses': 89,\n 'wins_in_last_ten': 4, 'streak': 'L1'\n },\n {\n 'team_name': 'Chi White Sox', 'wins': 59, 'losses': 90,\n 'wins_in_last_ten': 3, 'streak': 'L1'\n },\n {\n 'team_name': 'Kansas City', 'wins': 52, 'losses': 98,\n 'wins_in_last_ten': 6, 'streak': 'L2'\n },\n {\n 'team_name': 'Houston', 'wins': 94, 'losses': 56,\n 'wins_in_last_ten': 7, 'streak': 'L1'\n },\n {\n 'team_name': 'Oakland', 'wins': 90, 'losses': 60,\n 'wins_in_last_ten': 7, 'streak': 'L2'\n },\n {\n 'team_name': 'Seattle', 'wins': 83, 'losses': 67,\n 'wins_in_last_ten': 5, 'streak': 'W1'\n },\n {\n 'team_name': 'LA Angels', 'wins': 74, 'losses': 76,\n 'wins_in_last_ten': 6, 'streak': 'W1'\n },\n {\n 'team_name': 'Texas', 'wins': 64, 'losses': 86,\n 'wins_in_last_ten': 3, 'streak': 'L2'\n }\n ]\n\n return baseball_data","def yesterday(self):\r\n return RecordsYesterday(self)","def mlbteamleaders(self, irc, msg, args, optteam, optcategory):\n\n optteam = optteam.upper().strip()\n optcategory = optcategory.lower().strip()\n \n if optteam not in self._validteams():\n irc.reply(\"Team not found. Must be one of: %s\" % self._validteams())\n return\n \n category = {'avg':'avg', 'hr':'homeRuns', 'rbi':'RBIs', 'r':'runs', 'ab':'atBats', 'obp':'onBasePct', \n 'slug':'slugAvg', 'ops':'OPS', 'sb':'stolenBases', 'runscreated':'runsCreated',\n 'w': 'wins', 'l': 'losses', 'win%': 'winPct', 'era': 'ERA', 'k': 'strikeouts', \n 'k/9ip': 'strikeoutsPerNineInnings', 'holds': 'holds', 's': 'saves',\n 'gp': 'gamesPlayed', 'cg': 'completeGames', 'qs': 'qualityStarts', 'whip': 'WHIP' }\n\n if optcategory not in category:\n irc.reply(\"Error. Category must be one of: %s\" % category.keys())\n return\n\n lookupteam = self._translateTeam('eid', 'team', optteam)\n\n url = self._b64decode('aHR0cDovL20uZXNwbi5nby5jb20vbWxiL3RlYW1zdGF0cw==') + '?teamId=%s&lang=EN&category=%s&y=1&wjb=' % (lookupteam, category[optcategory]) \n # &season=2012\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to fetch: %s\" % url)\n return\n\n html = html.replace('<b >', '<b>')\n html = html.replace('class=\"ind alt', 'class=\"ind')\n html = html.replace('class=\"ind tL', 'class=\"ind')\n\n soup = BeautifulSoup(html)\n table = soup.find('table', attrs={'class':'table'})\n rows = table.findAll('tr')\n\n object_list = []\n\n for row in rows[1:6]: # grab the first through ten.\n rank = row.find('td', attrs={'class':'ind', 'width': '10%'}).renderContents().strip()\n player = row.find('td', attrs={'class':'ind', 'width': '65%'}).find('a').renderContents().strip()\n stat = row.find('td', attrs={'class':'ind', 'width': '25%'}).renderContents().strip()\n object_list.append(rank + \". \" + player + \" \" + stat)\n\n thelist = string.join([item for item in object_list], \" | \")\n irc.reply(\"Leaders in %s for %s: %s\" % (ircutils.bold(optteam.upper()), ircutils.bold(optcategory.upper()), thelist))","def mlbleagueleaders(self, irc, msg, args, optleague, optcategory):\n\n league = {'mlb': '9', 'al':'7', 'nl':'8'} # do our own translation here for league/category.\n category = {'avg':'avg', 'hr':'homeRuns', 'rbi':'RBIs', 'ra':'runs', 'sb':'stolenBases', 'era':'ERA', 'whip':'whip', 'k':'strikeoutsPerNineInnings'}\n\n optleague = optleague.lower()\n optcategory = optcategory.lower()\n\n if optleague not in league:\n irc.reply(\"League must be one of: %s\" % league.keys())\n return\n\n if optcategory not in category:\n irc.reply(\"Category must be one of: %s\" % category.keys())\n return\n\n url = self._b64decode('aHR0cDovL20uZXNwbi5nby5jb20vbWxiL2FnZ3JlZ2F0ZXM=') + '?category=%s&groupId=%s&y=1&wjb=' % (category[optcategory], league[optleague])\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to fetch: %s\" % url)\n return\n \n html = html.replace('class=\"ind alt nw\"', 'class=\"ind nw\"')\n\n soup = BeautifulSoup(html)\n table = soup.find('table', attrs={'class':'table'})\n rows = table.findAll('tr')\n \n append_list = []\n \n for row in rows[1:6]:\n rank = row.find('td', attrs={'class':'ind nw', 'nowrap':'nowrap', 'width':'10%'}).renderContents()\n team = row.find('td', attrs={'class':'ind nw', 'nowrap':'nowrap', 'width':'70%'}).find('a').text\n num = row.find('td', attrs={'class':'ind nw', 'nowrap':'nowrap', 'width':'20%'}).renderContents()\n append_list.append(rank + \". \" + team + \" \" + num)\n\n thelist = string.join([item for item in append_list], \" | \")\n\n irc.reply(\"Leaders in %s for %s: %s\" % (ircutils.bold(optleague.upper()), ircutils.bold(optcategory.upper()), thelist))","def extract_mn_score(hospital_score_file, mn_score_file):\n score = pd.read_csv(hospital_score)\n #print(score)\n\n mn_score = score[score[\"State\"] == \"MN\"][[\"Provider Number\", \"Hospital Name\",\n \"Location\", \"City\", \"ZIP Code\", \"County Name\",\n \"Total Performance Score\"]]\n #print(mn_score)\n #print(mn_score['Total Performance Score'].describe())\n mn_score['Location'] = mn_score['Location'].apply(lambda x:x.replace('\\n', ' '))\n mn_score.to_csv(mn_score_file, sep='\\t', index=False)","def scores(datestring):\n return render_score_page(\"scores.html\", datestring, datestring)","def mlbplayoffs(self, irc, msg, args):\n \n url = self._b64decode('aHR0cDovL2VzcG4uZ28uY29tL21sYi9odW50Zm9yb2N0b2Jlcg==')\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply('Failed to fetch: %s' % (self._b64decode('url')))\n return\n \n html = html.replace('sdg', 'sd').replace('sfo', 'sf').replace('tam', 'tb').replace('was', 'wsh').replace('kan', 'kc').replace('chw', 'cws')\n \n soup = BeautifulSoup(html)\n each = soup.findAll('td', attrs={'width':'25%'})\n\n ol = []\n\n for ea in each: # man is this just a horrible stopgap. \n links = ea.findAll('a')\n for link in links:\n linksplit = link['href'].split('/')\n team = linksplit[7]\n ol.append(team.upper())\n\n irc.reply(\"Playoffs: AL ({0} vs {1}) vs. {2} | {3} vs. {4} || NL: ({5} vs. {6}) vs. {7} | {8} vs. {9}\".format(\\\n ircutils.bold(ol[0]), ircutils.bold(ol[1]), ircutils.bold(ol[2]), ircutils.bold(ol[3]), ircutils.bold(ol[4]),\\\n ircutils.bold(ol[5]), ircutils.bold(ol[6]), ircutils.bold(ol[7]), ircutils.bold(ol[8]), ircutils.bold(ol[9])))","def query_monthly_hits(cls,N=10):\n bmkey = 'BookMonthlyHits'\n bks = from_cache(bmkey)\n if not bks:\n dt = datetime.utcnow() - timedelta(days=30)\n daus = SuiDau.all().filter('date >=',dt).order('-visits').fetch(N)\n bids = [d.book for d in daus]\n bks = map(lambda e:str(e.key().id()),SuiBook.get_by_id(bids))\n to_cache(bmkey,bks)\n return bks","def get_coin_history(self, coin=None, end_date=None, start_date=None):\n if coin:\n try:\n coin_url = self.coins[coin]\n except:\n print('Coin ' + str(coin) + ' does not exist in local database!')\n if start_date:\n start_date = start_date\n else:\n start_date = '20130428'\n if end_date:\n end_date = end_date\n else:\n now = str(datetime.now().date()).replace('-', '')\n end_date = now\n coin_url = coin_url + '/historical-data/?start=' + start_date + '&end=' + end_date\n content = urlopen(coin_url).read()\n soup = BeautifulSoup(content, 'html.parser')\n results = soup.find_all(\"tr\", class_=\"text-right\")\n infos = []\n for result in results:\n date = result.find_all('td')[0].text\n\n open_val = result.find_all('td')[1].text\n if open_val == '-':\n open_val = None\n else:\n open_val = float(result.find_all('td')[1].text.replace(',', ''))\n\n high_val = result.find_all('td')[2].textoc\n if high_val == '-':\n high_val = None\n else:\n high_val = float(result.find_all('td')[2].text.replace(',', ''))\n\n low_val = result.find_all('td')[3].text\n if low_val == '-':\n low_val = None\n else:\n low_val = float(result.find_all('td')[3].text.replace(',', ''))\n\n close_val = result.find_all('td')[4].text\n if close_val == '-':\n close_val = None\n else:\n close_val = float(result.find_all('td')[4].text.replace(',', ''))\n\n volume = result.find_all('td')[5].text\n if volume == '-':\n volume = None\n else:\n volume = float(result.find_all('td')[5].text.replace(',', ''))\n\n market_cap = result.find_all('td')[6].text\n if market_cap == '-':\n market_cap = None\n else:\n market_cap = float(result.find_all('td')[6].text.replace(',', ''))\n temp = {\n \"coin\": soup.title.text.split()[0],\n \"date\": date,\n \"symbol\": soup.title.text.split()[1].replace('(', '').replace(')', ''),\n \"open_val\": open_val,\n \"high_val\": high_val,\n \"low_val\": low_val,\n \"close_val\": close_val,\n \"volume\": volume,\n \"market_cap\": market_cap\n }\n infos.append(temp)\n df_all = pd.DataFrame.from_dict(infos)\n df_all['middle_val'] = (df_all.high_val + df_all.low_val) / 2\n df_all['datetime'] = pd.to_datetime(df_all['date'])\n df_all = df_all.sort_values(by='datetime')\n return df_all\n else:\n return None","def mlbstats(self, irc, msg, args, optlist, optplayer):\n\n (first, last) = optplayer.split(\" \", 1) #playername needs to be \"first-last\"\n searchplayer = first + '-' + last\n\n optyear = False\n for (option, arg) in optlist:\n if option == 'year':\n optyear = arg\n \n url = self._b64decode('aHR0cDovL3NlYXJjaC5lc3BuLmdvLmNvbS8=') + '%s' % searchplayer\n \n #self.log.info(url)\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to open: %s\" % url)\n return\n \n soup = BeautifulSoup(html)\n \n if not soup.find('li', attrs={'class':'result mod-smart-card'}):\n irc.reply(\"I didn't find a link for: %s. Perhaps you should be more specific and give a full playername\" % optplayer)\n return\n else: \n playercard = soup.find('li', attrs={'class':'result mod-smart-card'})\n \n if 'http://espn.go.com/mlb/players/stats?playerId=' not in playercard.renderContents():\n irc.reply(\"Could not find a link to career stats for: %s\" % optplayer)\n return\n else:\n #if playercard.find('a', attrs={'href':re.compile('.*?espn.go.com/mlb/players/stats.*?')}):\n link = playercard.find('a', attrs={'href':re.compile('.*?espn.go.com/mlb/players/stats.*?')})['href']\n \n if not link:\n irc.reply(\"I didn't find the link I needed for career stats. Did something break?\")\n return\n else:\n try:\n req = urllib2.Request(link)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to open: %s\" % link)\n return\n \n soup = BeautifulSoup(html)\n playerName = soup.find('title')\n table = soup.find('table', attrs={'class':'tablehead'}) # everything stems from the table.\n header = table.find('tr', attrs={'class':'colhead'}).findAll('td') # columns to reference.\n\n if optyear:\n seasonrows = table.findAll('tr', attrs={'class':re.compile('^oddrow$|^evenrow$')}) # find all outside the season+totals\n season_data = collections.defaultdict(list) # key will be the year.\n \n for row in seasonrows: \n tds = row.findAll('td')\n for i,td in enumerate(tds):\n season_data[str(tds[0].getText())].append(str(ircutils.bold(header[i].getText()) + \": \" + td.getText()))\n \n outyear = season_data.get(str(optyear), None)\n \n if not outyear:\n irc.reply(\"No stats found for %s in %s\" % (optplayer, optyear))\n else:\n outyear = string.join([item for item in outyear], \" | \")\n irc.reply(\"{0} :: {1}\".format(optplayer,outyear)) \n else:\n endrows = table.findAll('tr', attrs={'class':re.compile('^evenrow bi$|^oddrow bi$')})\n \n for total in endrows:\n if total.find('td', text=\"Total\"):\n totals = total.findAll('td')\n if total.find('td', text=\"Season Averages\"):\n seasonaverages = total.findAll('td')\n \n del seasonaverages[0] #remove the first td, but match up header via j+2\n del totals[0:2]\n\n seasonstring = string.join([header[i+2].getText() + \": \" + td.getText() for i,td in enumerate(seasonaverages)], \" | \")\n totalstring = string.join([header[i+2].getText() + \": \" + td.getText() for i,td in enumerate(totals)], \" | \")\n \n irc.reply(\"{0} Season Averages :: {1}\".format(ircutils.bold(optplayer), seasonstring))\n irc.reply(\"{0} Career Totals :: {1}\".format(ircutils.bold(optplayer), totalstring))","def getScore(data):\n return score","def nflweeklyleaders(self, irc, msg, args):\n \n url = self._b64decode('aHR0cDovL2VzcG4uZ28uY29tL25mbC93ZWVrbHkvbGVhZGVycw==')\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to open: %s\" % url)\n return\n\n html = html.replace('class=\"oddrow','class=\"evenrow')\n\n soup = BeautifulSoup(html)\n weeklytitle = soup.find('h1', attrs={'class':'h2'}).renderContents().strip()\n tables = soup.findAll('table', attrs={'class':'tablehead'})\n\n object_list = []\n\n for table in tables:\n statcategory = table.find('tr', attrs={'class':'stathead'}).find('td')\n rows = table.findAll('tr', attrs={'class': re.compile('evenrow.*')})\n for row in rows:\n player = row.find('td', attrs={'align':'left'})\n team = player.findNext('td') \n d = collections.OrderedDict()\n d['category'] = statcategory.renderContents().strip()\n d['player'] = str(player.text.replace('.','. '))\n d['team'] = team.renderContents().strip()\n object_list.append(d)\n \n passinglist = []\n rushinglist = []\n receivinglist = []\n defensivelist = []\n\n for each in object_list:\n if each['category'] == \"Passing Leaders\":\n passinglist.append(each['player'] + \"(\" + each['team'] + \")\")\n if each['category'] == \"Rushing Leaders\":\n rushinglist.append(each['player'] + \"(\" + each['team'] + \")\")\n if each['category'] == \"Receiving Leaders\":\n receivinglist.append(each['player'] + \"(\" + each['team'] + \")\") \n if each['category'] == \"Defensive Leaders\":\n defensivelist.append(each['player'] + \"(\" + each['team'] + \")\")\n \n irc.reply(ircutils.mircColor(weeklytitle, 'red'))\n irc.reply(ircutils.bold(\"Passing Leaders: \") + string.join([item for item in passinglist], \" | \"))\n irc.reply(ircutils.bold(\"Rushing Leaders: \") + string.join([item for item in rushinglist], \" | \"))\n irc.reply(ircutils.bold(\"Receiving Leaders: \") + string.join([item for item in receivinglist], \" | \"))\n irc.reply(ircutils.bold(\"Defensive Leaders: \") + string.join([item for item in defensivelist], \" | \"))","def get_score(url):\n result = requests.get(url)\n c = result.content\n\n soup = BeautifulSoup(c)\n\n date = soup.find(\"strong\", {\"class\": \"watch-time-text\"}).text\n date = datetime.strptime(date, 'Published on %b %d, %Y')\n \n child = str(soup.find(\"div\", {\"id\": \"watch-description-text\"}))\n \n #tknizer = nltk.tokenize.ToktokTokenizer()\n\n #tokenized = tknizer.tokenize(child)\n tokenized = nltk.tokenize.casual_tokenize(child)\n\n str_score = ''\n \n for i, token in enumerate(tokenized):\n if \"/10\" == token:\n str_score = tokenized[i-1]\n ind = i\n break\n elif (\"10\" == token and '/' == tokenized[i-1]):\n str_score = tokenized[i-2]\n break\n elif (\"10\" == token and '/' in tokenized[i-1]):\n str_score = tokenized[i-1].split(\"/\")[0]\n break\n elif \"/10\" in str(token) and len(token) < 10:\n str_score = tokenized[i].split(\"/\")[0]\n ind = i\n break\n\n if str_score == '':\n score = None\n else: \n if str_score.isdigit():\n score = int(str_score)\n else:\n score = str_score\n \n appending_fave = False\n appending_lfave = False\n fave_tracks = []\n lfave_track = []\n\n for i, token in enumerate(tokenized):\n if appending_fave:\n if token == '<br/>' or token == '<p/>':\n appending_fave = False\n else:\n fave_tracks.append(token)\n \n if appending_lfave:\n if token == '<br/>' or token == '<p/>':\n appending_lfave = False\n break\n else:\n lfave_track.append(token)\n \n if tokenized[i-1] == \"TRACKS\" and token == \":\":\n appending_fave = True\n \n if tokenized[i-1] == \"TRACK\":\n appending_lfave = True\n \n \n if fave_tracks != []: \n fave_tracks = ' '.join(fave_tracks)\n fave_tracks = fave_tracks.split(\", \")\n else:\n fave_tracks = []\n if lfave_track != []:\n lfave_track = ' '.join(lfave_track)\n else:\n lfave_track = ''\n return score, date, fave_tracks, lfave_track","def get_score_history(self):\n return self._score_history","def get_scores(model, X, y):\n y_hat = model.predict(X)\n pred = pd.get_dummies(y_hat.argmax(axis=1))\n acc = accuracy_score(y,pred)\n rec = recall_score(y,pred, average='weighted')\n pre = precision_score(y,pred, average='weighted')\n f1 = f1_score(y,pred, average='weighted')\n print(f\"ACC: {acc}\")\n print(f\"REC: {rec}\")\n print(f\"PRE: {pre}\")\n print(f\"F1: {f1}\")\n return acc, rec, pre, f1, pred","def get_big_five_scores(self, cat_scores) -> Tuple[float, float, float, float, float]:\n return self.get_openness(cat_scores), self.get_conscientiousness(\n cat_scores), self.get_extraversion(cat_scores), self.get_agreeableness(\n cat_scores), self.get_neuroticism(cat_scores)","def alt_score(objects):\n scores = {}\n for tweet in objects:\n data = tweet._json\n raw_time = datetime.strptime(\n data['created_at'],\n '%a %b %d %H:%M:%S +0000 %Y'\n )\n age = ((datetime.utcnow() - raw_time).seconds / 60) + 1\n rt = data['retweet_count']\n fave = data['favorite_count']\n fol = data['user']['followers_count']\n weight = 1.5\n e2f = ((weight * rt + fave) / (fol / 2)) * 1000\n e2a = enagement / age\n score = e2f + e2a\n scores[score] = data['id']\n embeds = []\n for item in sorted(scores.items(), reverse=True)[:13]:\n embed = twitter.get_oembed(id=item[1], align='center')\n embeds.append(embed['html'])\n return embeds","def get_all_coins_history(self, end_date=None, start_date=None, verbose=True):\n infos = []\n for coin in self.get_coins():\n if verbose:\n print(\"Collecting data for >> \" + coin)\n if start_date:\n start_date = start_date\n else:\n start_date = '20130428'\n if end_date:\n end_date = end_date\n else:\n now = str(datetime.now().date()).replace('-', '')\n end_date = now\n coin_url = self.coins[coin]\n coin_url = coin_url + '/historical-data/?start=' + start_date + '&end=' + end_date\n content = urlopen(coin_url).read()\n soup = BeautifulSoup(content, 'html.parser')\n results = soup.find_all(\"tr\", class_=\"text-right\")\n\n for result in results:\n date = result.find_all('td')[0].text\n\n open_val = result.find_all('td')[1].text\n if open_val == '-':\n open_val = None\n else:\n open_val = float(result.find_all('td')[1].text.replace(',', ''))\n\n high_val = result.find_all('td')[2].text\n if high_val == '-':\n high_val = None\n else:\n high_val = float(result.find_all('td')[2].text.replace(',', ''))\n\n low_val = result.find_all('td')[3].text\n if low_val == '-':\n low_val = None\n else:\n low_val = float(result.find_all('td')[3].text.replace(',', ''))\n\n close_val = result.find_all('td')[4].text\n if close_val == '-':\n close_val = None\n else:\n close_val = float(result.find_all('td')[4].text.replace(',', ''))\n\n volume = result.find_all('td')[5].text\n if volume == '-':\n volume = None\n else:\n volume = float(result.find_all('td')[5].text.replace(',', ''))\n\n market_cap = result.find_all('td')[6].text\n if market_cap == '-':\n market_cap = None\n else:\n market_cap = float(result.find_all('td')[6].text.replace(',', ''))\n temp = {\n \"coin\": coin, # soup.title.text.split()[0],\n \"date\": date,\n \"symbol\": soup.title.text.split()[1].replace('(', '').replace(')', ''),\n \"open_val\": open_val,\n \"high_val\": high_val,\n \"low_val\": low_val,\n \"close_val\": close_val,\n \"volume\": volume,\n \"market_cap\": market_cap\n }\n infos.append(temp)\n df_all = pd.DataFrame.from_dict(infos)\n df_all['middle_val'] = (df_all.high_val + df_all.low_val) / 2\n df_all['datetime'] = pd.to_datetime(df_all['date'])\n df_all = df_all.sort_values(by='datetime')\n self.coins_history = df_all","def getHourlyLoads(self):\n\n\t\tloads_data = self.getDataForLoadComparisons()\n\t\tload_values = [] # Array that will contain all the load data\n\t\tload_data = {} # Dictionary of load data\n\t\thour = 0 # Counter that determines the 24 hours in a day\n\n\t\t# Parsing load data\n\t\ttoday = self.helper.getMonth() + \"/\" + self.helper.getDay() + \"/\" + self.helper.getYear()\n\t\tfor data in loads_data[0]['values']:\t\t\t\n\t\t\tif data[\"label\"] == \"12:00 AM\":\n\t\t\t\tdata[\"label\"] = \" 00:00\"\n\t\t\telif data[\"label\"].split(\" \")[1] == \"AM\":\n\n\t\t\t\thour = int(data[\"label\"].split(\":\")[0])\n\t\t\t\tif hour < 10:\n\t\t\t\t\tdata[\"label\"] = \" 0\" + str(hour) + \":00\"\n\t\t\t\telse:\n\t\t\t\t\tdata[\"label\"] = str(hour) + \":00\"\n\t\t\telif data[\"label\"].split(\" \")[1] == \"PM\":\n\t\t\t\tif data[\"label\"] == \"12:00 PM\":\n\t\t\t\t\tdata[\"label\"] = \" 12:00\"\n\t\t\t\telse:\n\t\t\t\t\thour = int(data[\"label\"].split(\":\")[0])\n\t\t\t\t\thour += 12\n\t\t\t\t\tdata[\"label\"] = \" \" + str(hour) + \":00\"\n\t\t\tload_data[\"x\"] = self.helper.getDateInEpoch(today + \" \" + data[\"label\"])\n\t\t\tload_data[\"y\"] = float(data[\"value\"])\n\t\t\tload_values.append(load_data)\n\t\t\tload_data = {}\n\n\t\treturn load_values","def score(self, epochs=None, y=None):\n if epochs is not None:\n self.predict(epochs)\n else:\n if not hasattr(self, 'y_pred_'):\n raise RuntimeError('Please predict() epochs first or pass '\n 'epochs to score()')\n self._prep_times()\n super(TimeDecoding, self).score(epochs=None, y=y)\n self._clean_times()\n return self.scores_","def get_list_team_scores(self):\n scores = defaultdict(lambda: {\n \"scored_xg\": [],\n \"conceded_xg\": [],\n \"home_adv\": 0,\n \"expected_points\": 0\n })\n\n for g in self.games:\n scores[g.HomeTeam][\"scored_xg\"].append(g.FTHG)\n scores[g.HomeTeam][\"conceded_xg\"].append(g.FTAG)\n scores[g.AwayTeam][\"scored_xg\"].append(g.FTAG)\n scores[g.AwayTeam][\"conceded_xg\"].append(g.FTHG)\n\n for team in scores.keys():\n scores[team][\"expected_points\"] = (self.get_table(metric='points')[team] /\n len(scores[team][\"scored_xg\"]))\n\n return scores","def read_leaderboard(self):\n \n with open(\"Leaderboard.csv\", 'r') as in_file:\n reader = csv.reader(in_file)\n history_score = {rows[0]:float(rows[1]) for rows in reader}\n \n return history_score","def get_score(self):\n for response in self.response_list:\n self.score += response.get_score","def calc_lf_season(seasons, fuel_region_yh, average_fuel_yd):\n seasons_lfs = {}\n for season, yeardays_modelled in seasons.items():\n\n average_fuel_yd_full_year = np.average(\n average_fuel_yd[:, ],\n axis=1)\n\n # Calculate maximum hour in year\n max_load_h_days_season = np.max(\n fuel_region_yh[:, yeardays_modelled],\n axis=2)\n\n max_load_h_season = np.max(max_load_h_days_season, axis=1)\n\n # Unable local RuntimeWarning: divide by zero encountered\n with np.errstate(divide='ignore', invalid='ignore'):\n\n #convert to percentage\n season_lf = (average_fuel_yd_full_year / max_load_h_season) * 100\n\n # Replace\n season_lf[np.isinf(season_lf)] = 0\n season_lf[np.isnan(season_lf)] = 0\n\n seasons_lfs[season] = season_lf\n\n return seasons_lfs","def get_homework_statuses(current_timestamp: int) -> dict:\n data = {\"from_date\": current_timestamp}\n headers = {\"Authorization\": f\"OAuth {PRAKTIKUM_TOKEN}\"}\n try:\n homework_statuses = requests.get(\n PRAKTIKUM_API_URL,\n params=data,\n headers=headers,\n )\n # Заккоментриовал, т.к. валятся тесты\n # homework_statuses.raise_for_status()\n except requests.exceptions.RequestException as e:\n logger.exception(e)\n send_message(str(e))\n raise\n return homework_statuses.json()","def vm_get_sla(self, vm_node_history):\n sla = float(0)\n\n for i in vm_node_history:\n try:\n serviceid = self._zabbix_get_serviceid(i['node_hostname'])\n node_sla = self._zabbix_get_sla(serviceid, i['since'], i['till'])\n except ZabbixAPIException as exc:\n err = 'Zabbix API Error when retrieving SLA (%s)' % exc\n self.log(ERROR, err)\n raise InternalMonitoringError(err)\n except MonitoringError as exc:\n err = 'Could not parse Zabbix API output when retrieving SLA (%s)' % exc\n self.log(ERROR, err)\n raise exc.__class__(err)\n else:\n sla += float(node_sla) * i['weight']\n\n return sla","def __lm_scores(en_id, txt, prefix):\n feat_field_dict = {'title': econfig.TITLE, 'sAbs': econfig.SHORT_ABS, 'lAbs': econfig.LONG_ABS,\n 'links': econfig.WIKILINKS, 'cats': econfig.CATEGORIES, 'catchall': Lucene.FIELDNAME_CONTENTS}\n ftr_extractor = QuerySimFeat(txt)\n scores = dict()\n for feature_name, field in feat_field_dict.iteritems():\n lm_score = ftr_extractor.nllr_lm_score(en_id, field) # lm_score(en_id, field)\n scores[prefix + feature_name] = lm_score if lm_score is not None else 0\n return scores","def getDataForLoadComparisons(self):\n\n\t\t# Variables\n\t\tload_data = self.getLoadData() \n\t\tvalues = [] \n\t\tinner_dict = {}\n\t\touter_dict = {}\n\t\tfinal_data = []\n\t\tyesterday = self.helper.getYesterday()\n\t\tkey = self.helper.getYear() + self.helper.getMonth() + self.helper.getDay() + \"-loadData\"\n\t\tdata = load_data[yesterday[0]][int(yesterday[1])][int(yesterday[2])]\n\t\tdates = (['12:00 AM','1:00 AM','2:00 AM','3:00 AM','4:00 AM','5:00 AM',\n\t\t\t'6:00 AM','7:00 AM','8:00 AM','9:00 AM','10:00 AM','11:00 AM',\n\t\t\t'12:00 PM','1:00 PM','2:00 PM','3:00 PM','4:00 PM','5:00 PM',\n\t\t\t'6:00 PM','7:00 PM','8:00 PM','9:00 PM','10:00 PM','11:00 PM'])\n\n\t\t# Populating values array\n\t\tfor i in range(0,len(data)):\n\t\t\tinner_dict['label'] = dates[i]\n\t\t\tinner_dict['value'] = data[i]\n\t\t\tvalues.append(inner_dict)\n\t\t\tinner_dict = {}\n\n\t\t# Populating the final_data array and returning it\n\t\touter_dict['key'] = key\n\t\touter_dict['values'] = values\n\t\tfinal_data.append(outer_dict)\n\n\t\treturn final_data","def sorting_score(self):\r\n # Make courses that have an announcement date shave a lower\r\n # score than courses than don't, older courses should have a\r\n # higher score.\r\n announcement, start, now = self._sorting_dates()\r\n scale = 300.0 # about a year\r\n if announcement:\r\n days = (now - announcement).days\r\n score = -exp(-days / scale)\r\n else:\r\n days = (now - start).days\r\n score = exp(days / scale)\r\n return score","def get_scores(self):\n return self.score","def get_site_mau_history_metrics(site, months_back):\n history = []\n\n # We will not have the current month's data because metrics are calculated\n # after the month is over\n for rec in SiteMonthlyMetrics.objects.filter(site=site).order_by('-month_for')[:months_back]:\n period = '{year}/{month}'.format(year=rec.month_for.year,\n month=str(rec.month_for.month).zfill(2))\n history.append(dict(period=period, value=rec.active_user_count))\n\n # Get our latest stored site MAU count\n sdm = SiteDailyMetrics.latest_previous_record(site=site)\n current_month_active = sdm.mau if sdm else 0\n\n if history:\n # reverse the list because it is currently in reverser chronological order\n history.reverse()\n\n current_month = datetime.datetime.utcnow().date()\n period = '{year}/{month}'.format(year=current_month.year,\n month=str(current_month.month).zfill(2))\n history.append(dict(period=period, value=current_month_active))\n return dict(current_month=current_month_active, history=history)","def get_games_behind_history(self, team):\n abbr = convert_name(team, how='abbr')\n res = self._db.Teams.aggregate([{'$match': {'Tm' : abbr}},\n {'$unwind': '$Schedule'},\n {'$project':\n {'_id' : 0,\n 'Date' : '$Schedule.Date',\n 'GB': '$Schedule.GB'}}])\n hist = [x for x in list(res) if 'GB' in x.keys()]\n return hist","def get_all_f_blast_x_scores(self):\n listOfScoreBlast = []\n sqlObj = _F_score_blast_X_sql()\n results = sqlObj.select_all_score_blast_x_all_attributes()\n for element in results:\n listOfScoreBlast.append(F_score_blast_X(element[0], element[1], element[2], element[3], element[4], element[5], element[6], element[7], element[8], element[9], element[10], element[11], element[12], element[13], element[14]))\n return listOfScoreBlast","def score(self, X, y):\n return self.top30_score(y, self.predict(X))","def get_prediction_scores(self, X_te, Y_te, scoring):\n X_te = X_te - self.Xm\n if self.scale_X:\n X_te = X_te / self.Xs\n M_te = X_te @ self.Q\n\n scores = torch.zeros(Y_te.shape[1], len(self.ls), dtype=X_te.dtype)\n for j, Y_te_j in enumerate(Y_te.t()):\n N_te_j = None\n for k, l in enumerate(self.ls):\n Yhat_te_j, N_te_j = self._predict_single(\n X_te, M_te, j, l, N_te_j\n )\n scores[j, k] = scoring(Y_te_j, Yhat_te_j).item()\n return scores","def scrape_espn_feed():\n thescores = doScoresScrape()\n fixScores(thescores, 'MLB')\n logger.info(\"Scores scraped\")","def get_high_scores(self, request):\n result_count = 10\n if request.number_of_results is not None:\n result_count = request.number_of_results\n return ScoreForms(items=[score.to_form() for score in Score.query().\n order(-Score.points).fetch(result_count)])","def scrape_scores(main_soup):\n ul = main_soup.find('ul', {'class': 'quality-mark-bar-list'})\n\n labels = []\n for li in ul.find_all('li'):\n label = str(li.text).strip()\n if label is not '' and '.' not in label:\n labels.append(label)\n\n scores = []\n for div in ul.find_all('div'):\n scores.append(div['data-tooltip-text'])\n\n return labels, scores","def ml_pred_data_query(ticker='AMZN', db_name='test_stock_pred', collection_name='amzn_pred', \nstock_last_date=None, n_future_days=5, n_past_days=90):\n\n stock_db = db_client[db_name]\n stock_collection = stock_db[collection_name]\n \n if stock_last_date is str:\n stock_last_date = datetime.strptime(stock_last_date, '%Y-%m-%d')\n \n query_result = stock_collection.find({'Stock': ticker,\n 'Datetime': stock_last_date,\n 'n_future_days': n_future_days,\n 'n_past_days': n_past_days})\n return query_result","def _get_belt(self, new_score):\r\n for score in reversed(scores):\r\n if new_score >= score:\r\n return BELTS[score].capitalize()\r\n return None","def get_high_scores(self, request):\n difficulty = validateGameDifficultyValue(request, True)\n type(request)\n scores = Score.query()\n scores = scores.order(Score.guesses)\n scores = scores.order(-Score.date)\n # Filter by game difficulty and only wons that resulted in a win\n scores = scores.filter(Score.difficulty == difficulty,\\\n Score.won == True)\n # Get only the limit of results requested\n # Validate number_of_results is a positive integer\n if int(request.number_of_results) < 1:\n raise endpoints.BadRequestException(\n 'Number of results must be a positive value')\n scores = scores.fetch(int(request.number_of_results))\n return ScoreForms(items=[score.to_form() for score in scores])","def dummy_scores(result):\n\n # Get students assigned to this year\n req_year = result['subject']['year_id']\n req_user = result['user_id']\n sinfo = models.Students.query.filter_by(year_id=req_year, user_id=req_user).all()\n\n # Loop through and add dummy scores\n for i, student in enumerate(sinfo):\n print(student)\n models.Scores.add_dummy(student.id, result['id'], req_user)","def mlbrosterstats(self, irc, msg, args, optteam):\n\n if optteam:\n optteam = optteam.upper()\n if optteam not in self._validteams():\n irc.reply(\"Team not found. Must be one of: %s\" % self._validteams())\n return\n \n url = self._b64decode('aHR0cDovL2VzcG4uZ28uY29tL21sYi9zdGF0cy9yb3N0ZXJz')\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to open: %s\" % url)\n return\n \n soup = BeautifulSoup(html)\n table = soup.find('table', attrs={'class':'tablehead'})\n rows = table.findAll('tr')[2:]\n\n object_list = []\n\n for row in rows:\n rank = row.find('td')\n team = rank.findNext('td')\n rhb = team.findNext('td')\n lhb = rhb.findNext('td')\n sh = lhb.findNext('td')\n rhp = sh.findNext('td')\n lhp = rhp.findNext('td')\n ht = lhp.findNext('td')\n wt = ht.findNext('td')\n age = wt.findNext('td')\n young = age.findNext('td')\n old = young.findNext('td')\n \n aString = str(\"RHB: \" + rhb.getText() + \" LHB: \" + lhb.getText() + \" SH: \" + sh.getText() + \" RHP: \" + rhp.getText() + \" LHP: \" + lhp.getText()\\\n + \" AVG HT: \" + ht.getText() + \" AVG WEIGHT: \" + wt.getText() + \" AVG AGE: \" + age.getText() + \" YOUNGEST: \" + young.getText() + \" OLDEST: \" + old.getText())\n \n d = collections.OrderedDict()\n d['team'] = str(self._translateTeam('team', 'ename', team.getText()))\n d['data'] = str(aString)\n object_list.append(d)\n \n if optteam:\n for each in object_list:\n if each['team'] == optteam: # list will have all teams so we don't need to check\n output = \"{0} Roster Stats :: {1}\".format(ircutils.bold(each['team']), each['data'])\n \n irc.reply(output)\n \n else:\n \n youngest_list = []\n oldest_list = []\n \n for each in object_list[0:5]:\n youngest_list.append(each['team'])\n for each in object_list[-6:-1]:\n oldest_list.append(each['team'])\n \n output = \"{0} :: {1}\".format(ircutils.bold(\"5 Youngest MLB Teams:\"), string.join([item for item in youngest_list], \" | \"))\n irc.reply(output)\n \n output = \"{0} :: {1}\".format(ircutils.bold(\"5 Oldest MLB Teams:\"), string.join([item for item in oldest_list], \" | \"))\n irc.reply(output)","def get_fresh_data(get_team):\n\n \"\"\" Create the URL for today \"\"\"\n now = datetime.datetime.now()\n url = \"http://gd2.mlb.com/gdcross/components/game/mlb/year_\" + '{}'.format(now.year) + \"/month_\" + '{:02d}'.format(now.month) + \"/day_\" + '{:02d}'.format(now.day) + \"/miniscoreboard.json\"\n\n \"\"\" Grab the first response and write it to a file, we'll update it once the game starts \"\"\"\n data_write_file = status_dir + '{}'.format(now.year) + '{:02d}'.format(now.month) + '{:02d}'.format(now.day) + \".json\"\n\n \"\"\" Get the json data if the file doesn't exist, or if it's over three minutes old \"\"\"\n if not os.path.isfile(data_write_file) or time.time() - os.path.getmtime(data_write_file) > 60:\n response = urllib.urlopen(url)\n full_data = json.loads(response.read())\n with open(data_write_file, 'w') as outfile:\n json.dump(full_data, outfile, sort_keys=True, indent=2, ensure_ascii=False)\n\n \"\"\" Use the data from the status file \"\"\"\n with open(data_write_file, 'r') as json_data:\n full_data = json.load(json_data)\n\n \"\"\" This will return false if there is no game today, else will return json data for just our team \"\"\"\n my_game = False\n for game in full_data['data']['games']['game']:\n if get_team in game['home_file_code'] or get_team in game['away_file_code']:\n my_game = game\n \n return my_game","def get_data(end_date, n, local, foreign):\n URL = \"https://api.exchangeratesapi.io/history\"\n PARAMS = {'start_at': str(get_weekday_n_days_ago(end_date, n)),\n 'end_at': str(end_date),\n 'symbols': foreign,\n 'base': local}\n r = requests.get(url=URL, params=PARAMS)\n data = r.json()\n input_data = []\n for day in data['rates']:\n input_data.append([datetime.strptime(day, '%Y-%m-%d').date(),\n float(\"{:.8f}\".format(data['rates'][day][foreign]))])\n input_data.sort(key=lambda x: x[0])\n return input_data[-n:]","def rescraper(url):\n\tresponse = urlopen(url)\n\tplayed_games = response.read().decode()\n\tfor line in played_games.split('\\n'):\n\t\tif '<table class=\"linescore' in line:\n\t\t\ttext = line\n\t\t\tscores = re.findall(r'<td class=\"final score\">(\\d+)</td>',text)\n\t\t\tteams = re.findall(r'<a.*?>(.*?)</a>', text)\n\t\t\tprint('{} {}, {} {}'.format(teams[0],scores[0],teams[1],scores[1]))","def lzs (inlist):\r\n zscores = []\r\n for item in inlist:\r\n zscores.append(z(inlist,item))\r\n return zscores","def latest(scores: List) -> List:\n # Check the argument type\n if not isinstance(scores, List):\n raise TypeError(\"Argument 'scores' must be of type list.\")\n\n return scores[-1]","def run_past_matches(self):\n for year in self.store.years:\n # print(year)\n for event in self.store.events[year]:\n for match in self.store.matches[year][event.key]:\n red_alliance = match.red_alliance\n blue_alliance = match.blue_alliance\n\n for team in red_alliance + blue_alliance:\n if team not in self.scores.keys():\n self.scores[team] = self.default_score\n\n prediction = self.predict(red_alliance, blue_alliance, key=match.key)\n self.update_score(red_alliance, blue_alliance, prediction,\n match.red_score, match.blue_score)","def make_zscores(relfreqs, means, stdevs):\n normalized = relfreqs.sub(means, axis=\"index\")\n save_dataframe(normalized, \"2-normalized.csv\")\n #print(normalized.head())\n zscores = normalized.div(stdevs, axis=\"index\")\n save_dataframe(zscores, \"3-zscores.csv\")\n #print(zscores.head())\n return zscores","def lz (inlist, score):\r\n z = (score-mean(inlist))/samplestdev(inlist)\r\n return z","def nflleagueleaders(self, irc, msg, args, optlist, optcategory, optstat, optyear): \n \n statsCategories = { \n 'Passing': { \n 'qbr':'49', \n 'comp':'1',\n 'att':'2',\n 'comp%':'41',\n 'yards':'4',\n 'yards/gm':'42',\n 'td':'5',\n 'int':'3',\n 'sacked':'8',\n 'sackedyardslost':'9',\n 'fumbles':'47',\n 'fumbleslost':'48'\n },\n 'Rushing': {\n 'rushes':'16',\n 'yards':'17',\n 'yards/g':'39',\n 'avg':'40',\n 'td':'18',\n 'fumbles':'47',\n 'fumbleslost':'48'\n },\n 'Receiving': {\n 'receptions':'27',\n 'recyards':'28',\n 'yards/gm':'44',\n 'yards/avg':'45',\n 'longest':'30',\n 'yac':'46',\n '1stdowns':'33',\n 'tds':'29',\n 'fumbles':'47',\n 'fumbleslost':'48'\n },\n 'Kicking': {\n '0-19':'208',\n '20-29':'210',\n '30-39':'212',\n '40-49':'214',\n '50+':'216',\n 'fgm':'222',\n 'fga':'221',\n 'pct':'230',\n 'longest':'224',\n 'xpm':'225',\n 'xpa':'226',\n 'xp%':'231' \n },\n 'Returns':{\n 'kickoffreturns':'311',\n 'kickoffyards':'312',\n 'kickoffavg':'319',\n 'kickofflongest':'314',\n 'kickofftd':'315',\n 'puntreturns':'301',\n 'puntreturnyards':'302',\n 'puntreturnavg':'320',\n 'puntreturnlongest':'304',\n 'puntreturntds':'305'\n },\n 'Punting': {\n 'punts':'402',\n 'puntyards':'403',\n 'puntavg':'411',\n 'puntlong':'408',\n 'puntwithin20':'404',\n 'puntwithin10':'405',\n 'faircatch':'401',\n 'touchback':'406',\n 'blocked':'407' \n },\n 'Defense':{\n 'solotackles':'128',\n 'assistedtackles':'129',\n 'totaltackles':'130',\n 'sacks':'106',\n 'sacksyardslost':'107',\n 'stuffs':'101',\n 'stuffsyardslost':'102',\n 'int':'108',\n 'intyards':'109',\n 'inttds':'110',\n 'deftd':'103',\n 'forcedfumbles':'114',\n 'pd':'113',\n 'safety':'115' \n } \n }\n \n optcategory = optcategory.title() # must title this category\n \n if optcategory not in statsCategories:\n irc.reply(\"Category must be one of: %s\" % statsCategories.keys())\n return\n \n optstat = optstat.lower() # stat key is lower. value is #. \n \n if optstat not in statsCategories[optcategory]:\n irc.reply(\"Stat for %s must be one of: %s\" % (optcategory, statsCategories[optcategory].keys()))\n return\n \n if optyear: \n testdate = self._validate(optyear, '%Y')\n if not testdate:\n irc.reply(\"Invalid year. Must be YYYY.\")\n return\n if int(optyear) < 2000:\n irc.reply(\"Year must be 2001 or after.\")\n return\n\n postseason, outlimit = False, '10'\n for (option, arg) in optlist:\n if option == 'postseason':\n postseason = True\n if option == 'num20':\n outlimit = '20'\n \n url = self._b64decode('aHR0cDovL3Nwb3J0cy55YWhvby5jb20vbmZsL3N0YXRzL2J5Y2F0ZWdvcnk=')\n url += '?cat=%s&conference=NFL&sort=%s&timeframe=All' % (optcategory, statsCategories[optcategory][optstat])\n \n if optyear: # don't need year for most current.\n if not postseason:\n url += '&year=season_%s' % optyear\n else:\n url += '&year=postseason_%s' % optyear \n \n #self.log.info(url)\n \n try: \n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Failed to open: %s\" % url)\n return\n\n html = html.replace(' ','')\n \n soup = BeautifulSoup(html)\n selectedyear = soup.find('select', attrs={'name':'year'}).find('option', attrs={'selected':'selected'}) # creative way to find the year.\n table = soup.find('tr', attrs={'class':'ysptblthmsts', 'align':'center'}).findParent('table')\n header = table.findAll('tr')[1].findAll('td')\n rows = table.findAll('tr')[2:]\n\n append_list = []\n\n for row in rows[0:int(outlimit)]:\n name = str(row.findAll('td')[0].getText()) # always first\n team = str(row.findAll('td')[1].getText()) # always next\n sortfield = row.find('span', attrs={'class':'yspscores'}) # whatever field you are sorting by will have this span inside the td. \n append_list.append(ircutils.bold(name) + \"(\" + team + \") - \" + str(sortfield.getText()))\n\n title = \"Top %s in %s(%s) for %s\" % (outlimit, optcategory, optstat, selectedyear.getText())\n descstring = string.join([item for item in append_list], \" | \")\n \n output = \"{0} :: {1}\".format(ircutils.mircColor(title, 'red'), descstring)\n irc.reply(output)","def scraper_bloomberg() -> None:\n\thtmltext = urllib.urlopen('http://www.bloomberg.com/markets/watchlist/recent-ticker/AAPL:US')\n\tdata = json.load(htmltext)\n\n\tprint data[\"last_price\"]\n\n\treturn None","def get_monthly_history_metric(func, site, date_for, months_back,\n include_current_in_history=True): # pylint: disable=unused-argument\n date_for = as_date(date_for)\n history = []\n\n for month in previous_months_iterator(month_for=date_for, months_back=months_back,):\n period = period_str(month)\n value = func(\n site=site,\n start_date=datetime.date(month[0], month[1], 1),\n end_date=datetime.date(month[0], month[1], month[2]),\n )\n history.append(dict(period=period, value=value,))\n\n if history:\n # use the last entry\n current_month = history[-1]['value']\n else:\n # This should work for float too since '0 == 0.0' resolves to True\n current_month = 0\n return dict(\n current_month=current_month,\n history=history,)","def fetchSlackFeed(startTimestamp,endTimestamp):\n\tsc = SlackClient(k.SLACK_TOKEN)\n\tresponse = sc.api_call(\n\t\t\"conversations.history\",\n\t\tchannel = k.SLACK_CHANNEL_ID,\n\t\toldest = startTimestamp,\n\t\tlatest = endTimestamp,\n\t\tcount = 100\n\t)\n\treturn response","def merge_scores(self): # pragma: no cover\n\n merged_scores = []\n score_end_indices = []\n\n for i, score in enumerate(self.anom_scores):\n if not score['start_idx']-1 in score_end_indices:\n merged_scores.append(score['score'])\n score_end_indices.append(score['end_idx'])","def L50(self):\n\t\tstats = self.scores()\n\t\treturn stats['l50']","def get_highscores(self):\n\t\ttry:\n\t\t\twith open(self.filename) as f_obj:\n\t\t\t\tcontents = f_obj.read()\n\t\texcept FileNotFoundError:\n\t\t\tprint('File for highscores not found! Call 016 733 7043 for assistance.')\n\t\telse:\n\t\t\tjson_contents = json.loads(contents)\n\t\t\treturn sorted(json_contents, key=self.extract_score)","def test_get_league_leaders___daily(self):\n msg = \"Response status is not 200\"\n response = self.api.get_league_leaders___daily(self.year1, self.nhl_season, self.year2, self.month, self.day)\n self.assertEqual(response.status_code, 200, msg)","def get_full_history(symbol):\n to_date = int(datetime.datetime.timestamp(datetime.datetime.now()))\n from_date = int(datetime.datetime.timestamp(datetime.datetime(1990, 1, 1, 1, 0, 0)))\n url_base = \"https://query1.finance.yahoo.com/v7/finance/download/\"\n url_params = f\"{symbol}.NS?period1={from_date}&period2={to_date}&interval=1d&events=history\"\n resp = requests.get(url_base + url_params)\n a = csv_to_list(resp)[1:]\n return create_price(symbol, a)","def __fillScores(self, contentScores):\n\n list_of_data_frames = list()\n\n for cntScr in contentScores:\n res = json.loads(cntScr.score)\n\n df_pro = pd.DataFrame(res)\n df_pro[\"productId_requested\"] = cntScr.productId\n df_pro[\"cart_score\"] = self.cart_score_repository.get_by_products(list(df_pro.productid))\n df_pro[\"passed_day_score\"] = self.passed_day_score_repository.get_by_products(list(df_pro.productid))\n df_pro[\"final_score\"] = (df_pro.score + df_pro.cart_score + df_pro.passed_day_score) / 3\n best_product = df_pro.set_index(\"productid\")[\"final_score\"].idxmax(axis=\"columns\")\n df_pro[\"bias_score\"] = df_pro.apply(lambda x: self.__set_bias_score(x, best_product), axis=1)\n list_of_data_frames.append(df_pro)\n df = pd.concat(list_of_data_frames)\n return df","def score():\n highscore = session.get(\"highscore\", 0)\n nplays = session.get(\"nplays\", 0)\n score = request.json[\"score\"]\n if score > highscore:\n highscore = score\n session['highscore'] = highscore\n session['nplays'] = nplays +1\n\n return jsonify(brokeRecord = highscore)","def compute_desc_stats(score_d):\n _scores = {k:{} for k in time_str_to_time.keys()} \n _scores['all'] = {} # add key for all milwaukee and all time zones\n for d in score_d: \n mean = np.mean(score_d[d])\n std = np.std(score_d[d])\n _scores[d]['mean'] = mean\n _scores[d]['std'] = std\n _scores[d]['max'] = max(score_d[d])\n _scores[d]['min'] = min(score_d[d])\n \n return _scores","def retrieve_scores(num_letters, language, folder, min_score, max_score):\n if (num_letters == 1):\n return retrieve_letter_scores(1, language, folder, min_score, max_score)\n elif (num_letters == 2):\n return retrieve_syllable_scores(num_letters, 1, language, folder, min_score, max_score)\n elif (num_letters == 3):\n return retrieve_syllable_scores(num_letters, 3, language, folder, min_score, max_score)\n else:\n print(\"Error: incorrect number of letters. Value ranges from 1 to 3.\\n\")","def displayHighScore():\r\n compiled_scores = []\r\n all_scores = getScores()\r\n for row in all_scores.splitlines():\r\n compiled_scores += [(row.split()[1], int(row.split()[4])+int(row.split()[7])+\r\n int(row.split()[10])+int(row.split()[13]))]\r\n print(compiled_scores)\r\n PrintHighScores.formatDisplay(compiled_scores)"],"string":"[\n \"def getDayAheadMarketLBMPZonal(self):\\n\\n\\t\\t# Variables\\n\\t\\ttoday = self.helper.getYear() + self.helper.getMonth() + self.helper.getDay()\\n\\t\\turl = 'http://mis.nyiso.com/public/csv/damlbmp/'+today+'damlbmp_zone.csv' \\n\\t\\tresponse = urllib2.urlopen(url)\\n\\t\\tmarket_data = sorted(csv.reader(response), key=operator.itemgetter(1)) # Converting data to python csv\\n\\t\\tcounter = 0 # Counter used for determining which hour we are curretly on\\n\\t\\tlbmpZonal = {}\\n\\t\\ttimestamp = {}\\n\\t\\ttimestamps = []\\n\\t\\tmarket_info = {}\\n\\n\\t\\t# Converting csv data to market data and returning it\\n\\t\\tfor row in market_data:\\n\\t\\t\\t# Ignoring header row\\n\\t\\t\\tif row[0] != 'Time Stamp':\\n\\t\\t\\t\\tmarket_info['LBMP ($/MWHr)'] = float(row[3])\\n\\t\\t\\t\\tmarket_info['Marginal Cost Losses ($/MWHr)'] = float(row[4])\\n\\t\\t\\t\\tmarket_info['Marginal Cost Congestion ($/MWHr)'] = float(row[5])\\n\\t\\t\\t\\trow[0] = self.helper.getDateInEpoch(row[0])\\n\\t\\t\\t\\ttimestamp[row[0]] = market_info\\n\\t\\t\\t\\tmarket_info = {}\\n\\t\\t\\t\\ttimestamps.append(timestamp)\\n\\t\\t\\t\\ttimestamp = {}\\n\\t\\t\\t\\tcounter +=1\\n\\t\\t\\t\\t# if counter == 23:\\n\\t\\t\\t\\t\\t# key = row[1]\\n\\t\\t\\t\\tif counter == 24:\\n\\t\\t\\t\\t\\tlbmpZonal[row[1]] = timestamps\\n\\t\\t\\t\\t\\ttimestamps = []\\n\\t\\t\\t\\t\\tcounter = 0\\n\\t\\treturn lbmpZonal\",\n \"def live_scores():\\n live_scores = cache.get('FOOTBALL_LIVE_SCORES')\\n if live_scores:\\n scores_array = []\\n for score in json.loads(live_scores)[0:3]:\\n if not score['LIVE']:\\n scores_array.append(score) \\n return {'live_scores': scores_array}\\n else:\\n return {}\",\n \"def scoreboard(year, month, day):\\n # Get data from mlbgame library\\n data = mlbgame.data.get_scoreboard(year, month, day)\\n # Parse through returned data\\n parsed = etree.parse(data)\\n root = parsed.getroot()\\n output = []\\n # Loop through the list of games that are returned\\n for game in root:\\n if game.tag == 'data':\\n return []\\n # Get the Team Names\\n teams = game.findall('team')\\n home_name = teams[0].attrib['name']\\n away_name = teams[1].attrib['name']\\n # Building a dictionary\\n # I am really only interested in the scores.... not sure if\\n # game_id is actually necessary....but here it stays\\n game_data = game.find('game')\\n game_id = game_data.attrib['id']\\n home_team_data = teams[0].find('gameteam')\\n home_team = home_name\\n home_team_runs = int(home_team_data.attrib['R'])\\n away_team_data = teams[1].find('gameteam')\\n away_team = away_name\\n away_team_runs = int(away_team_data.attrib['R'])\\n score = {\\n 'home_team': home_team,\\n 'home_team_runs': home_team_runs,\\n 'away_team': away_team,\\n 'away_team_runs': away_team_runs\\n }\\n output.append(score)\\n return output\",\n \"def mlbarrests(self, irc, msg, args): \\n \\n url = self._b64decode('aHR0cDovL2FycmVzdG5hdGlvbi5jb20vY2F0ZWdvcnkvcHJvLWJhc2ViYWxsLw==')\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to open: %s\\\" % url)\\n return\\n \\n html = html.replace(' ',' ').replace('’','’')\\n\\n soup = BeautifulSoup(html)\\n lastDate = soup.findAll('span', attrs={'class':'time'})[0] \\n divs = soup.findAll('div', attrs={'class':'entry'})\\n\\n append_list = []\\n\\n for div in divs:\\n title = div.find('h2')\\n datet = div.find('span', attrs={'class':'time'})\\n datet = self._dateFmt(str(datet.getText()))\\n arrestedFor = div.find('strong', text=re.compile('Team:')) \\n if arrestedFor:\\n matches = re.search(r'<strong>Team:.*?</strong>(.*?)<br />', arrestedFor.findParent('p').renderContents(), re.I|re.S|re.M)\\n if matches:\\n college = matches.group(1).replace('(MLB)','').strip()\\n else:\\n college = \\\"None\\\"\\n else:\\n college = \\\"None\\\"\\n \\n append_list.append(ircutils.bold(datet) + \\\" :: \\\" + title.getText() + \\\" - \\\" + college) # finally add it all\\n \\n daysSince = self._daysSince(str(lastDate.getText()))\\n irc.reply(\\\"{0} days since last MLB arrest\\\".format(ircutils.mircColor(daysSince, 'red')))\\n \\n for each in append_list[0:6]:\\n irc.reply(each)\",\n \"def latest(scores):\\n return scores[-1]\",\n \"def latest(scores):\\n return scores[-1]\",\n \"def fetchHistory(self, token):\\n history = self.loadHistory(token)\\n if len(history):\\n startStamp = history[-1][\\\"timestamp\\\"] + 1000 + random.random()*1000 # Add some random number of seconds\\n startDateStr = time.strftime(\\\"%Y%m%d\\\", time.gmtime(int(startStamp)))\\n else:\\n startDateStr = \\\"20130428\\\" # Date of the first bitcoin valuation ?\\n dateStr = time.strftime(\\\"%Y%m%d\\\")\\n uri = self.historyTemplate % (token, startDateStr, dateStr)\\n print(\\\"Fetching history\\\")\\n html = BeautifulSoup(urlrequest.urlopen(uri).read().decode(), \\\"html.parser\\\")\\n print(\\\"parsing html\\\")\\n dataRows = html.find(\\\"div\\\", {\\\"id\\\": \\\"historical-data\\\"}).find(\\\"table\\\", {\\\"id\\\", \\\"table\\\"}).find(\\\"tbody\\\").find_all(\\\"tr\\\", {\\\"class\\\": \\\"text-right\\\"})\\n headers = [\\\"date.string\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"volume\\\", \\\"market.cap\\\"]\\n dataPts = []\\n print(\\\"translating data\\\")\\n for row in dataRows:\\n rowObj = {}\\n for i, td in enumerate(row.find_all(\\\"td\\\")):\\n if i == 0:\\n try:\\n rowObj[headers[i]] = td.get_text()\\n rowObj[\\\"timestamp\\\"] = helpers.stamp2dayStamp(datetime.datetime.strptime(td.get_text(), \\\"%b %d, %Y\\\").timestamp())\\n except Exception:\\n print(\\\"failed to parse float from `%s`\\\" % td.get_text())\\n rowObj[headers[i]] = \\\"Dec 31, 1999\\\"\\n elif i < 5:\\n try:\\n rowObj[headers[i]] = float(td.get_text())\\n except Exception:\\n print(\\\"failed to parse float from `%s`\\\" % td.get_text())\\n rowObj[headers[i]] = 0.0\\n else:\\n try:\\n rowObj[headers[i]] = int(td.get_text().replace(\\\",\\\", \\\"\\\"))\\n except Exception:\\n print(\\\"failed to parse integer from `%s`\\\" % td.get_text())\\n rowObj[headers[i]] = 0\\n dataPts.append(rowObj)\\n for pt in sorted(dataPts, key=lambda p: p[\\\"timestamp\\\"]):\\n if len(history) == 0 or pt[\\\"timestamp\\\"] > history[-1][\\\"timestamp\\\"]:\\n history.append(pt)\\n self.saveHistory(token, history)\\n return history\",\n \"def get_mke_scores():\\n _scores = {k:[] for k in time_str_to_time.keys()} \\n _scores['all'] = [] # add key for all milwaukee and all time zones\\n for zip_ in zip_populations.keys(): \\n res = query_all_crimes(zip_=zip_)\\n print(f'[PROCESSING] {zip_}')\\n crimes = to_df(res)\\n create_crime_cat(crimes)\\n integrate_weight_to_df(crimes)\\n for time_sl in time_str_to_time.keys():\\n sub = extract_crimes_by_sl(crimes, time_str_to_time[time_sl]) \\n cas = compute_crime_score(sub, zip_) \\n _scores[time_sl].append(cas)\\n _scores['all'].append(cas)\\n return _scores\",\n \"def calculate(self, prev_scores):\\n self.set_scores(prev_scores)\\n for match in self.week.matches:\\n if match.played:\\n # Fetch old scores\\n winner_score = float(prev_scores[match.winner])\\n loser_score = float(prev_scores[match.loser])\\n\\n # Update this ranking's scores\\n score_delta = loser_score * 0.1\\n self.score[match.winner] = winner_score + score_delta\\n self.score[match.loser] = loser_score - score_delta\",\n \"def calculate_scores():\\n all_people = models.Leaderboard.query.order_by(\\n models.Leaderboard.score.desc()).all()\\n print(all_people)\\n users = []\\n scores = []\\n for person in all_people:\\n users.append(person.username)\\n scores.append(person.score)\\n return users, scores\",\n \"def get_scores(self, query):\\n self.init()\\n tokens = self.tokenizer.tokenize(query)\\n return self.bm25_instance.get_scores(query=tokens)\",\n \"def getDataForLBMPvsLoadComparisons(self):\\n\\n\\t\\t# Variables\\n\\t\\tlbmp_data = self.getDataForLBMPZonalComparison()[14] # Getting CAPITL zone\\n\\t\\tload_data = self.getLoadData()\\n\\t\\tfinal_data = []\\n\\t\\tlbmp_dict = {}\\n\\t\\tload_dict = {}\\n\\t\\tload_values = []\\n\\t\\tdates = []\\n\\t\\tprice_values = []\\n\\n\\t\\t# Getting needed lbmp_data\\n\\t\\tkey = \\\"LBMP ($/MWHr) in \\\" + lbmp_data['key']\\n\\t\\tfor value in lbmp_data['values']:\\n\\t\\t\\tdates_and_prices = []\\n\\t\\t\\tdates_and_prices.append(value['x'])\\n\\t\\t\\tdates.append(value['x'])\\n\\t\\t\\tdates_and_prices.append(value['y'])\\n\\t\\t\\tprice_values.append(dates_and_prices)\\n\\t\\tlbmp_dict['key'] = key\\n\\t\\tlbmp_dict['values'] = price_values\\n\\t\\tfinal_data.append(lbmp_dict)\\n\\t\\tdata_dict = {}\\n\\n\\t\\t# Getting needed load data\\n\\t\\tyesterday = self.helper.getYesterday()\\n\\t\\tloads = load_data[yesterday[0]][int(yesterday[1])][int(yesterday[2])]\\n\\t\\tfor i in range(0,len(loads)):\\n\\t\\t\\tdates_and_loads = []\\n\\t\\t\\tdates_and_loads.append(dates[i])\\n\\t\\t\\tdates_and_loads.append(loads[i])\\n\\t\\t\\tload_values.append(dates_and_loads)\\n\\t\\tload_dict['key'] = lbmp_data['key'] + \\\" Area Loads\\\"\\n\\t\\tload_dict['values'] = load_values\\n\\t\\tload_dict['bar'] = 'True'\\n\\t\\tfinal_data.append(load_dict)\\n\\t\\treturn final_data\",\n \"def test_get_historical_gold_rate(self):\\n rates = [153.50, 162.49, 123.86, 155.10]\\n helper.gold_loop_helper(get_historical_gold_rate, TestHistoricalRates.dates_rate, rates)\",\n \"def mlbvaluations(self, irc, msg, args):\\n \\n url = self._b64decode('aHR0cDovL3d3dy5mb3JiZXMuY29tL21sYi12YWx1YXRpb25zL2xpc3Qv')\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to load: %s\\\" % url)\\n return\\n \\n soup = BeautifulSoup(html)\\n tbody = soup.find('tbody', attrs={'id':'listbody'})\\n rows = tbody.findAll('tr')\\n\\n object_list = []\\n\\n for row in rows:\\n rank = row.find('td', attrs={'class':'rank'})\\n team = rank.findNext('td')\\n value = team.findNext('td')\\n yrchange = value.findNext('td')\\n debtvalue = yrchange.findNext('td')\\n revenue = debtvalue.findNext('td')\\n operinc = revenue.findNext('td')\\n d = collections.OrderedDict()\\n d['rank'] = rank.renderContents().strip()\\n d['team'] = team.find('h3').renderContents().strip()\\n d['value'] = value.renderContents().strip()\\n d['yrchange'] = yrchange.renderContents().strip()\\n d['debtvalue'] = debtvalue.renderContents().strip()\\n d['revenue'] = revenue.renderContents().strip()\\n d['operinc'] = operinc.renderContents().strip()\\n object_list.append(d)\\n \\n irc.reply(ircutils.mircColor(\\\"Current MLB Team Values\\\", 'red') + \\\" (in millions):\\\")\\n \\n for N in self._batch(object_list, 7):\\n irc.reply(' '.join(str(str(n['rank']) + \\\".\\\" + \\\" \\\" + ircutils.bold(n['team'])) + \\\" (\\\" + n['value'] + \\\"M)\\\" for n in N))\",\n \"def get_highscores(self):\\n return self.filter(active=False, finished=True).order_by(\\\"-score\\\")\",\n \"def scoreboard(year, month, day, home=None, away=None):\\n # get data\\n data = mlbgame.data.get_scoreboard(year, month, day)\\n # parse data\\n parsed = etree.parse(data)\\n root = parsed.getroot()\\n games = {}\\n output = {}\\n # loop through games\\n for game in root:\\n if game.tag == 'data':\\n return []\\n # get team names\\n teams = game.findall('team')\\n home_name = teams[0].attrib['name']\\n away_name = teams[1].attrib['name']\\n # check if teams match parameters\\n if (home_name == home and home is not None) \\\\\\n or (away_name == away and away is not None) \\\\\\n or (away is None and home is None):\\n # throw all the data into a complicated dictionary\\n game_tag = game.tag\\n game_data = game.find('game')\\n game_id = game_data.attrib['id']\\n game_league = game_data.attrib['league']\\n game_status = game_data.attrib['status']\\n game_start_time = game_data.attrib['start_time']\\n home_team_data = teams[0].find('gameteam')\\n home_team = home_name\\n home_team_runs = int(home_team_data.attrib['R'])\\n home_team_hits = int(home_team_data.attrib['H'])\\n home_team_errors = int(home_team_data.attrib['E'])\\n away_team_data = teams[1].find('gameteam')\\n away_team = away_name\\n away_team_runs = int(away_team_data.attrib['R'])\\n away_team_hits = int(away_team_data.attrib['H'])\\n away_team_errors = int(away_team_data.attrib['E'])\\n # check type of game\\n if game_tag == 'go_game' or game_tag == 'ig_game':\\n try:\\n w_pitcher_data = game.find('w_pitcher')\\n w_pitcher = w_pitcher_data.find('pitcher').attrib['name']\\n w_pitcher_wins = int(w_pitcher_data.attrib['wins'])\\n w_pitcher_losses = int(w_pitcher_data.attrib['losses'])\\n except Exception:\\n w_pitcher = \\\"\\\"\\n w_pitcher_wins = 0\\n w_pitcher_losses = 0\\n try:\\n l_pitcher_data = game.find('l_pitcher')\\n l_pitcher = l_pitcher_data.find('pitcher').attrib['name']\\n l_pitcher_wins = int(l_pitcher_data.attrib['wins'])\\n l_pitcher_losses = int(l_pitcher_data.attrib['losses'])\\n except Exception:\\n l_pitcher = \\\"\\\"\\n l_pitcher_wins = 0\\n l_pitcher_losses = 0\\n try:\\n sv_pitcher_data = game.find('sv_pitcher')\\n sv_pitcher = sv_pitcher_data.find('pitcher').attrib['name']\\n sv_pitcher_saves = int(sv_pitcher_data.attrib['saves'])\\n except Exception:\\n sv_pitcher = \\\"\\\"\\n sv_pitcher_saves = 0\\n output = {\\n 'game_id': game_id,\\n 'game_tag': game_tag,\\n 'game_league': game_league,\\n 'game_status': game_status,\\n 'game_start_time': game_start_time,\\n 'home_team': home_team,\\n 'home_team_runs': home_team_runs,\\n 'home_team_hits': home_team_hits,\\n 'home_team_errors': home_team_errors,\\n 'away_team': away_team,\\n 'away_team_runs': away_team_runs,\\n 'away_team_hits': away_team_hits,\\n 'away_team_errors': away_team_errors,\\n 'w_pitcher': w_pitcher,\\n 'w_pitcher_wins': w_pitcher_wins,\\n 'w_pitcher_losses': w_pitcher_losses,\\n 'l_pitcher': l_pitcher,\\n 'l_pitcher_wins': l_pitcher_wins,\\n 'l_pitcher_losses': l_pitcher_losses,\\n 'sv_pitcher': sv_pitcher,\\n 'sv_pitcher_saves': sv_pitcher_saves\\n }\\n # games that were not played\\n elif game_tag == 'sg_game':\\n try:\\n p_pitcher_data = game.findall('p_pitcher')\\n p_pitcher_home_data = p_pitcher_data[0]\\n p_pitcher_home = p_pitcher_home_data.find(\\n 'pitcher').attrib['name']\\n p_pitcher_home_wins = int(p_pitcher_home_data.\\n attrib['wins'])\\n p_pitcher_home_losses = int(p_pitcher_home_data.\\n attrib['losses'])\\n p_pitcher_away_data = p_pitcher_data[1]\\n p_pitcher_away = p_pitcher_away_data.find(\\n 'pitcher').attrib['name']\\n p_pitcher_away_wins = int(p_pitcher_away_data.\\n attrib['wins'])\\n p_pitcher_away_losses = int(p_pitcher_away_data.\\n attrib['losses'])\\n except Exception:\\n p_pitcher_home = ''\\n p_pitcher_home_wins = 0\\n p_pitcher_home_losses = 0\\n p_pitcher_away = ''\\n p_pitcher_away_wins = 0\\n p_pitcher_away_losses = 0\\n output = {\\n 'game_id': game_id,\\n 'game_tag': game_tag,\\n 'game_league': game_league,\\n 'game_status': game_status,\\n 'game_start_time': game_start_time,\\n 'home_team': home_team,\\n 'home_team_runs': home_team_runs,\\n 'home_team_hits': home_team_hits,\\n 'home_team_errors': home_team_errors,\\n 'away_team': away_team,\\n 'away_team_runs': away_team_runs,\\n 'away_team_hits': away_team_hits,\\n 'away_team_errors': away_team_errors,\\n 'p_pitcher_home': p_pitcher_home,\\n 'p_pitcher_home_wins': p_pitcher_home_wins,\\n 'p_pitcher_home_losses': p_pitcher_home_losses,\\n 'p_pitcher_away': p_pitcher_away,\\n 'p_pitcher_away_wins': p_pitcher_away_wins,\\n 'p_pitcher_away_losses': p_pitcher_away_losses\\n }\\n # put this dictionary into the larger dictionary\\n games[game_id] = output\\n return games\",\n \"def get_games(date):\\n scoreboard = nba_py.Scoreboard(month=date.month,\\n day=date.day,\\n year=date.year)\\n line_score = scoreboard.line_score()\\n game_header = scoreboard.game_header()\\n\\n games = []\\n current_game = {}\\n game_sequence = 0\\n game_sequence_counter = 0\\n\\n # Get HOME TEAM and AWAY TEAM data for each boxscore game in line_score.\\n for i, value in enumerate(line_score):\\n if (value[\\\"GAME_SEQUENCE\\\"] != game_sequence):\\n game_sequence += 1\\n\\n current_game[\\\"GAME_ID\\\"] = value[\\\"GAME_ID\\\"]\\n home_team_id = game_header[game_sequence - 1][\\\"HOME_TEAM_ID\\\"]\\n\\n if (home_team_id == value[\\\"TEAM_ID\\\"]):\\n current_game[\\\"HOME_TEAM\\\"] = value[\\\"TEAM_ABBREVIATION\\\"]\\n current_game[\\\"HOME_TEAM_WINS_LOSSES\\\"] = value[\\\"TEAM_WINS_LOSSES\\\"]\\n current_game[\\\"HOME_TEAM_PTS\\\"] = value[\\\"PTS\\\"]\\n current_game[\\\"HOME_TEAM_ID\\\"] = value[\\\"TEAM_ID\\\"]\\n if (current_game[\\\"HOME_TEAM\\\"] in TEAM_ID_DATA):\\n current_game[\\\"HOME_TEAM_IMG\\\"] = TEAM_ID_DATA[current_game[\\\"HOME_TEAM\\\"]][\\\"img\\\"]\\n else:\\n current_game[\\\"AWAY_TEAM\\\"] = value[\\\"TEAM_ABBREVIATION\\\"]\\n current_game[\\\"AWAY_TEAM_WINS_LOSSES\\\"] = value[\\\"TEAM_WINS_LOSSES\\\"]\\n current_game[\\\"AWAY_TEAM_PTS\\\"] = value[\\\"PTS\\\"]\\n current_game[\\\"AWAY_TEAM_ID\\\"] = value[\\\"TEAM_ID\\\"]\\n if (current_game[\\\"AWAY_TEAM\\\"] in TEAM_ID_DATA):\\n current_game[\\\"AWAY_TEAM_IMG\\\"] = TEAM_ID_DATA[current_game[\\\"AWAY_TEAM\\\"]][\\\"img\\\"]\\n\\n if (value[\\\"TEAM_ABBREVIATION\\\"] in TEAMS):\\n if (home_team_id == value[\\\"TEAM_ID\\\"]):\\n current_game[\\\"HOME_TEAM_FULL_NAME\\\"] = TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"city\\\"] + \\\\\\n \\\" \\\" + TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"name\\\"]\\n else:\\n current_game[\\\"AWAY_TEAM_FULL_NAME\\\"] = TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"city\\\"] + \\\\\\n \\\" \\\" + TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"name\\\"]\\n \\n game_sequence = value[\\\"GAME_SEQUENCE\\\"]\\n game_sequence_counter += 1\\n elif game_sequence_counter == 1:\\n if (\\\"AWAY_TEAM\\\" in current_game):\\n current_game[\\\"HOME_TEAM\\\"] = value[\\\"TEAM_ABBREVIATION\\\"]\\n current_game[\\\"HOME_TEAM_WINS_LOSSES\\\"] = value[\\\"TEAM_WINS_LOSSES\\\"]\\n current_game[\\\"HOME_TEAM_PTS\\\"] = value[\\\"PTS\\\"]\\n current_game[\\\"HOME_TEAM_ID\\\"] = value[\\\"TEAM_ID\\\"]\\n if (current_game[\\\"HOME_TEAM\\\"] in TEAM_ID_DATA):\\n current_game[\\\"HOME_TEAM_IMG\\\"] = TEAM_ID_DATA[current_game[\\\"HOME_TEAM\\\"]][\\\"img\\\"]\\n else:\\n current_game[\\\"AWAY_TEAM\\\"] = value[\\\"TEAM_ABBREVIATION\\\"]\\n current_game[\\\"AWAY_TEAM_WINS_LOSSES\\\"] = value[\\\"TEAM_WINS_LOSSES\\\"]\\n current_game[\\\"AWAY_TEAM_PTS\\\"] = value[\\\"PTS\\\"]\\n current_game[\\\"AWAY_TEAM_ID\\\"] = value[\\\"TEAM_ID\\\"]\\n if (current_game[\\\"AWAY_TEAM\\\"] in TEAM_ID_DATA):\\n current_game[\\\"AWAY_TEAM_IMG\\\"] = TEAM_ID_DATA[current_game[\\\"AWAY_TEAM\\\"]][\\\"img\\\"]\\n\\n if (value[\\\"TEAM_ABBREVIATION\\\"] in TEAMS):\\n if (\\\"AWAY_TEAM\\\" in current_game):\\n current_game[\\\"HOME_TEAM_FULL_NAME\\\"] = TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"city\\\"] + \\\\\\n \\\" \\\" + TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"name\\\"]\\n else:\\n current_game[\\\"AWAY_TEAM_FULL_NAME\\\"] = TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"city\\\"] + \\\\\\n \\\" \\\" + TEAMS[value[\\\"TEAM_ABBREVIATION\\\"]][\\\"name\\\"]\\n\\n current_game[\\\"GAME_STATUS_TEXT\\\"] = game_header[game_sequence - 1][\\\"GAME_STATUS_TEXT\\\"]\\n if not game_header[game_sequence - 1][\\\"NATL_TV_BROADCASTER_ABBREVIATION\\\"]:\\n current_game[\\\"BROADCASTER\\\"] = \\\"\\\"\\n else:\\n current_game[\\\"BROADCASTER\\\"] = game_header[game_sequence - 1][\\\"NATL_TV_BROADCASTER_ABBREVIATION\\\"]\\n\\n games.append(current_game)\\n\\n current_game = {}\\n\\n game_sequence = value[\\\"GAME_SEQUENCE\\\"]\\n game_sequence_counter -= 1\\n\\n east_standings = scoreboard.east_conf_standings_by_day()\\n west_standings = scoreboard.west_conf_standings_by_day()\\n\\n return (games, east_standings, west_standings)\",\n \"def get_past_matches_data(team):\\n matches = team.get_past_matches()\\n match_list = []\\n for match in matches:\\n match_dict = {}\\n match_dict['match_date'] = match.match_date\\n match_dict['match_name'] = match.__str__()\\n match_dict['id'] = match.id\\n innings = match.get_innings()\\n if len(innings):\\n if innings[0].runs > innings[1].runs:\\n match_dict['winner_team'] = innings[0].bat_team\\n match_dict['win_margin'] = innings[0].runs - innings[1].runs\\n match_dict['win_type'] = 'Runs'\\n match_dict['winner_score'] = str(innings[0].runs) + '/' + str(innings[0].wickets)\\n else:\\n match_dict['winner_team'] = innings[1].bat_team\\n match_dict['win_margin'] = 10 - innings[1].wickets\\n match_dict['win_type'] = 'Wickets'\\n match_dict['winner_score'] = str(innings[1].runs) + '/' + str(innings[1].wickets)\\n match_list.append(match_dict)\\n return match_list\",\n \"def getScores(self,query):\\n pass\",\n \"def get_highscores(self):\\n return self.database.get_high_scores(self.difficulty)\",\n \"def get_btcoin_day_data(self):\\n cursor = self.__connect().cursor()\\n limit = (str(int(time.time() - 24*60*60)),)\\n hashdata = []\\n rewarddata = []\\n summ = 0\\n for row in cursor.execute('SELECT * from btcoin where key > ? ORDER BY key ASC', limit):\\n date = int(row[0])\\n hashrate = str(row[1])\\n hashrate = self.convert_hashrate_to_float(hashrate)\\n summ = summ + hashrate\\n reward = float(row[2])\\n hashdata.append([date, hashrate])\\n rewarddata.append([date, reward])\\n cursor.close()\\n self.__disconnect()\\n if len(hashdata) != 0:\\n hashaverage = summ / len(hashdata)\\n return (hashaverage, hashdata, rewarddata)\\n else:\\n return (-1, hashdata, rewarddata)\",\n \"def retrieve_score(wb,tick,increase,write):\\n sheetn = wb.sheetnames[1:] # get all the excel sheets\\n sheet_names = ['Environmental','Social','Governance','ESG_combined','ESG_controvesies','ESG_score'] # their names\\n \\n if write:\\n list_year= [\\\"09\\\",\\\"10\\\",\\\"11\\\",\\\"12\\\",\\\"13\\\",\\\"14\\\",\\\\\\n \\\"15\\\",\\\"16\\\",\\\"17\\\",\\\"18\\\",\\\"19\\\",\\\"20\\\",\\\\\\n \\\"21\\\"]\\n\\n else:\\n list_year = [tick+\\\"09\\\",tick+\\\"10\\\",tick+\\\"11\\\",tick+\\\"12\\\",tick+\\\"13\\\",tick+\\\"14\\\",\\\\\\n tick+\\\"15\\\",tick+\\\"16\\\",tick+\\\"17\\\",tick+\\\"18\\\",tick+\\\"19\\\",tick+\\\"20\\\",\\\\\\n tick+\\\"21\\\"] # indeces for the dataframe\\n \\n sr = wb[sheetn[1]]\\n\\n # first find the row of the Ticker\\n \\n row = None\\n wb[sheetn[1]]\\n for i in range(1,sr.max_row+1):\\n k = 'A' + str(i)\\n if sr[k].value == tick:\\n row = i\\n else:\\n continue\\n \\n assert row != None, \\\"Ticker Not Found\\\"\\n\\n if increase==True:\\n if write==True:\\n if not os.path.isdir(os.getcwd().replace(\\\"\\\\\\\\\\\",\\\"/\\\") + \\\"/Bloomberg_Score_Change\\\"):\\n os.makedirs(os.getcwd().replace(\\\"\\\\\\\\\\\",\\\"/\\\") + \\\"/Bloomberg_Score_Change\\\")\\n filename = os.getcwd().replace(\\\"\\\\\\\\\\\",\\\"/\\\") + '/Bloomberg_Score_Change'+'/Bsi_'+tick+'.txt'\\n\\n list_cell = ['AD'+ str(row),'AE'+ str(row),'AF'+ str(row),'AG'+ str(row),'AH'+ str(row),'AI'+ str(row),\\\\\\n 'AJ'+ str(row),'AK'+ str(row),'AL'+ str(row),'AM'+ str(row),'AN'+ str(row),'AO'+ str(row),\\\\\\n 'AP'+ str(row)]\\n er = [\\\"#DIV/0!\\\",\\\"#VALUE!\\\"]\\n \\n\\n else:\\n if write==True:\\n\\n if not os.path.isdir(os.getcwd().replace(\\\"\\\\\\\\\\\",\\\"/\\\") + \\\"/Bloomberg_Score\\\"):\\n os.makedirs(os.getcwd().replace(\\\"\\\\\\\\\\\",\\\"/\\\") + \\\"/Bloomberg_Score\\\")\\n filename =os.getcwd().replace(\\\"\\\\\\\\\\\",\\\"/\\\") + '/Bloomberg_Score'+'/Bs_'+tick+'.txt'\\n\\n list_cell = ['F'+ str(row),'G'+ str(row),'H'+ str(row),'I'+ str(row),'J'+ str(row),'K'+ str(row),\\\\\\n 'L'+ str(row),'M'+ str(row),'N'+ str(row),'O'+ str(row),'P'+ str(row),'Q'+ str(row),\\\\\\n 'R'+ str(row)]\\n er = []\\n \\n \\n \\n assert len(list_cell) == len(list_year), \\\"Missing Year or Cells\\\"\\n\\n score = [] #initializing the score\\n\\n for sheet in sheetn: # looping through all the sheets\\n \\n sr = wb[sheet] # assigining the searech engine\\n \\n topic_score = [] # creating the topic score list\\n\\n for cell in list_cell: # for every cell in the list cells \\n\\n if sr[cell].value not in er: # if its not in the error list\\n \\n topic_score.append(sr[cell].value) # append it\\n\\n else: # otherwise\\n topic_score.append(0) # append 0 (only the case for the change in scores)\\n\\n score.append(topic_score) # appending to score list\\n del topic_score # deleting to conserve memory\\n \\n \\n data = pd.DataFrame(data = zip(score[0],score[1],score[2],score[3],score[4],score[5]),\\\\\\n columns = sheet_names,index = list_year) # creating data frame\\n\\n \\n\\n if write==True:\\n txtfile = open(filename,'w+',encoding='utf-8') # opening text file\\n txtfile.write(data.to_string()) # writing the dataframe in the text file\\n txtfile.close # closing the file\\n return None\\n\\n else:\\n return data\",\n \"def get_scores(tmp_dir, profile_file_directory, stderr_log_output):\\r\\n\\t\\r\\n\\tranges = pickle.load(open(os.path.join(tmp_dir, \\\"ranges.pkl\\\")))\\r\\n\\t\\r\\n\\t(database, locusList,list_of_all_allele_numbers_tuple) = try_and_except(stderr_log_output,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tget_profiles,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprofile_file_directory)\\r\\n\\t\\r\\n\\tresults = try_and_except(stderr_log_output,\\r\\n\\t\\t\\t\\t\\t\\t\\t score,\\r\\n\\t\\t\\t\\t\\t\\t\\t tmp_dir,\\r\\n\\t\\t\\t\\t\\t\\t\\t locusList,\\r\\n\\t\\t\\t\\t\\t\\t\\t ranges)\\r\\n\\t\\r\\n\\treturn results, database, locusList, list_of_all_allele_numbers_tuple\",\n \"def get_mlb_today_lineup_by_team_abbv(team_abbv_name):\\n games = get_today_games_from_team_abbv(team_abbv_name)\\n players = []\\n # Is a forloop because 1 team can play 2 games in 1 day\\n for game in games:\\n try:\\n home_lineups, away_lineups = get_lineups_from_mlbgame(game)\\n players.append(get_players_from_mlb_lineups(away_lineups, home_lineups))\\n except LineUpFoundException as error:\\n print(error)\\n\\n return players\",\n \"def mlbpowerrankings(self, irc, msg, args):\\n \\n url = self._b64decode('aHR0cDovL2VzcG4uZ28uY29tL21sYi9wb3dlcnJhbmtpbmdz')\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to fetch: %s\\\" % url)\\n return\\n \\n html = html.replace(\\\"evenrow\\\", \\\"oddrow\\\")\\n\\n soup = BeautifulSoup(html)\\n table = soup.find('table', attrs={'class': 'tablehead'})\\n prdate = table.find('td', attrs={'colspan': '6'}).renderContents()\\n t1 = table.findAll('tr', attrs={'class': 'oddrow'})\\n\\n if len(t1) < 30:\\n irc.reply(\\\"Failed to parse MLB Power Rankings. Did something break?\\\")\\n return\\n\\n object_list = []\\n\\n for row in t1:\\n rowrank = row.find('td', attrs={'class': 'pr-rank'}).renderContents().strip()\\n rowteam = row.find('div', attrs={'style': re.compile('^padding.*')}).find('a').text.strip()\\n rowrecord = row.find('span', attrs={'class': 'pr-record'}).renderContents().strip()\\n rowlastweek = row.find('span', attrs={'class': 'pr-last'}).renderContents().strip().replace(\\\"Last Week\\\", \\\"prev\\\") \\n\\n d = collections.OrderedDict()\\n d['rank'] = int(rowrank)\\n d['team'] = str(rowteam)\\n d['record'] = str(rowrecord)\\n d['lastweek'] = str(rowlastweek)\\n object_list.append(d)\\n\\n if prdate:\\n irc.reply(ircutils.mircColor(prdate, 'blue'))\\n\\n for N in self._batch(object_list, 6):\\n irc.reply(' '.join(str(str(n['rank']) + \\\".\\\" + \\\" \\\" + ircutils.bold(n['team'])) + \\\" (\\\" + n['lastweek'] + \\\")\\\" for n in N))\",\n \"def find_games(days_ahead=0):\\n headers = {\\n 'Host': 'stats.nba.com',\\n 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0',\\n 'Accept': 'application/json, text/plain, */*',\\n 'Accept-Language': 'en-US,en;q=0.5',\\n 'Referer': 'https://stats.nba.com/',\\n 'Accept-Encoding': 'gzip, deflate, br',\\n 'Connection': 'keep-alive',\\n 'x-nba-stats-origin': 'stats',\\n 'x-nba-stats-token': 'true'\\n }\\n board = scoreboardv2.ScoreboardV2(day_offset=days_ahead, headers=headers).get_data_frames()[0]\\n board.replace(id_to_abrv, inplace=True)\\n return board[['GAME_DATE_EST', 'GAME_ID', 'HOME_TEAM_ID', 'VISITOR_TEAM_ID']]\",\n \"def getHighscores():\\n\\n # sort and load the profiles from the external file\\n sortProfiles()\\n profiles = loadProfiles()\\n\\n highscores = []\\n for i in range(0, 5):\\n # make sure we aren't exceeding the index of the array\\n if i < len(profiles):\\n # omit the password from the dict\\n highscore = {\\n 'username': profiles[i]['username'],\\n 'score': profiles[i]['score']\\n }\\n highscores.append(highscore)\\n else:\\n break\\n\\n return highscores\",\n \"def calc_scores(unscored_list, master_list):\\n num_scores = len(unscored_list)\\n best_score = master_list[0]['score']\\n worst_score = master_list[num_scores]['score']\\n score_interval = (best_score - worst_score) / num_scores\\n score = best_score\\n\\n for item in unscored_list:\\n item['score'] = score\\n score -= score_interval\\n return unscored_list\",\n \"def liblin_cleanscores(liblin_scores, liblin_labellist, nclasses):\\n lowscore = np.min(liblin_scores) - 1\\n scores = []\\n for lls in liblin_scores:\\n s = np.ones(nclasses) * lowscore\\n s[liblin_labellist] = lls\\n scores.append(s)\\n return scores\",\n \"def getScore(self):\\n\\t\\tself.scoreList = [submissionsss.score for submissionsss in self.subreddit.top(time_filter = 'day', limit = self.limits)]\\n\\t\\treturn self.scoreList\",\n \"def get_liwc_scores(self) -> Tuple[pd.DataFrame, pd.DataFrame]:\\n big_five_cols = ['Openness', 'Conscientiousness', 'Extraversion',\\n 'Agreeableness', 'Neuroticism']\\n\\n liwc_data = self._get_category_scores(self._get_liwc_df())\\n liwc_scores = pd.DataFrame(columns=big_five_cols)\\n liwc_scores[big_five_cols] = liwc_data.swifter.apply(\\n self.get_big_five_scores, axis=1, result_type='expand'\\n )\\n liwc_scores = self.apply_corrections(liwc_data, liwc_scores)\\n if self.author == 'golbeck':\\n liwc_scores = self.add_sentiment_scores(liwc_scores)\\n\\n # Min-max normalization\\n liwc_scores_normalized = (liwc_scores - liwc_scores.min()) / (\\n liwc_scores.max() - liwc_scores.min()) * 100\\n return liwc_scores.round(15), liwc_scores_normalized.round(15)\",\n \"def list_of_scores(self):\\n with open(Constant.this_score, \\\"r\\\") as f:\\n final= f.read()\\n final = int(final)\\n with open(Constant.list_scores, \\\"r\\\") as li:\\n points_file = json.load(li)\\n points = points_file['HighScores']\\n\\n with open(Constant.list_scores,\\\"w\\\") as files:\\n\\n if len(points) == 5:\\n if points[0] < final:\\n for i in range(len(points)-1,0,-1):\\n points[i] = points[i-1]\\n points[0] = final\\n json.dump(points_file,files)\\n elif points[0] > final:\\n if points[1] < final:\\n for i in range(len(points)-1,1,-1):\\n points[i] = points[i-1]\\n points[1] = final\\n json.dump(points_file,files)\\n elif points[1] > final:\\n if points[2] < final:\\n for i in range(len(points)-1,2,-1):\\n points[i] = points[i-1]\\n points[2] = final\\n json.dump(points_file,files)\\n elif points[2] > final:\\n if points[3] < final:\\n for i in range(len(points)-1,3,-1):\\n points[i] = points[i-1]\\n points[3] = final\\n json.dump(points_file,files)\\n elif points[3] > final:\\n if points[4] < final:\\n points[4] = final\\n json.dump(points_file,files)\\n else:\\n json.dump(points_file,files)\\n else:\\n json.dump(points_file,files)\\n else:\\n json.dump(points_file,files)\\n else:\\n json.dump(points_file,files)\\n else:\\n json.dump(points_file,files)\",\n \"def latest(scores: list) -> int:\\n return scores[-1]\",\n \"def parse_scores(option, table_num, language, min_score, max_score):\\n html = query_by_lang(BASE_URL + '/' + option, language)\\n table = html.find_all(\\\"table\\\")[table_num]\\n freq_list = table.find_all(\\\"tr\\\")[2:]\\n\\n # Create the dictionary\\n list_min = find_min(freq_list)\\n list_max = find_max(freq_list)\\n return create_dict(freq_list, list_min, list_max, min_score, max_score)\",\n \"def get_high_scores(self,request):\\n if request.number_of_results:\\n scores = Score.query(Score.won == True).order(Score.attempts_allowed,Score.guesses).fetch(request.number_of_results)\\n else:\\n scores = Score.query(Score.won == True).order(Score.attempts_allowed,Score.guesses).fetch()\\n return ScoreForms(items=[score.to_form() for score in scores])\",\n \"def get_baseball_data():\\n\\n baseball_data = [\\n {\\n 'team_name': 'Boston', 'wins': 103, 'losses': 47,\\n 'wins_in_last_ten': 7, 'streak': 'W2'\\n },\\n {\\n 'team_name': 'NY Yankees', 'wins': 91, 'losses': 58,\\n 'wins_in_last_ten': 4, 'streak': 'L2'\\n },\\n {\\n 'team_name': 'Tampa Bay', 'wins': 83, 'losses': 66,\\n 'wins_in_last_ten': 8, 'streak': 'W3'\\n },\\n {\\n 'team_name': 'Toronto', 'wins': 68, 'losses': 82,\\n 'wins_in_last_ten': 5, 'streak': 'W3'\\n },\\n {\\n 'team_name': 'Baltimore', 'wins': 43, 'losses': 107,\\n 'wins_in_last_ten': 2, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Cleveland', 'wins': 83, 'losses': 66,\\n 'wins_in_last_ten': 4, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Minnesota', 'wins': 69, 'losses': 81,\\n 'wins_in_last_ten': 5, 'streak': 'W2'\\n },\\n {\\n 'team_name': 'Detroit', 'wins': 61, 'losses': 89,\\n 'wins_in_last_ten': 4, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Chi White Sox', 'wins': 59, 'losses': 90,\\n 'wins_in_last_ten': 3, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Kansas City', 'wins': 52, 'losses': 98,\\n 'wins_in_last_ten': 6, 'streak': 'L2'\\n },\\n {\\n 'team_name': 'Houston', 'wins': 94, 'losses': 56,\\n 'wins_in_last_ten': 7, 'streak': 'L1'\\n },\\n {\\n 'team_name': 'Oakland', 'wins': 90, 'losses': 60,\\n 'wins_in_last_ten': 7, 'streak': 'L2'\\n },\\n {\\n 'team_name': 'Seattle', 'wins': 83, 'losses': 67,\\n 'wins_in_last_ten': 5, 'streak': 'W1'\\n },\\n {\\n 'team_name': 'LA Angels', 'wins': 74, 'losses': 76,\\n 'wins_in_last_ten': 6, 'streak': 'W1'\\n },\\n {\\n 'team_name': 'Texas', 'wins': 64, 'losses': 86,\\n 'wins_in_last_ten': 3, 'streak': 'L2'\\n }\\n ]\\n\\n return baseball_data\",\n \"def yesterday(self):\\r\\n return RecordsYesterday(self)\",\n \"def mlbteamleaders(self, irc, msg, args, optteam, optcategory):\\n\\n optteam = optteam.upper().strip()\\n optcategory = optcategory.lower().strip()\\n \\n if optteam not in self._validteams():\\n irc.reply(\\\"Team not found. Must be one of: %s\\\" % self._validteams())\\n return\\n \\n category = {'avg':'avg', 'hr':'homeRuns', 'rbi':'RBIs', 'r':'runs', 'ab':'atBats', 'obp':'onBasePct', \\n 'slug':'slugAvg', 'ops':'OPS', 'sb':'stolenBases', 'runscreated':'runsCreated',\\n 'w': 'wins', 'l': 'losses', 'win%': 'winPct', 'era': 'ERA', 'k': 'strikeouts', \\n 'k/9ip': 'strikeoutsPerNineInnings', 'holds': 'holds', 's': 'saves',\\n 'gp': 'gamesPlayed', 'cg': 'completeGames', 'qs': 'qualityStarts', 'whip': 'WHIP' }\\n\\n if optcategory not in category:\\n irc.reply(\\\"Error. Category must be one of: %s\\\" % category.keys())\\n return\\n\\n lookupteam = self._translateTeam('eid', 'team', optteam)\\n\\n url = self._b64decode('aHR0cDovL20uZXNwbi5nby5jb20vbWxiL3RlYW1zdGF0cw==') + '?teamId=%s&lang=EN&category=%s&y=1&wjb=' % (lookupteam, category[optcategory]) \\n # &season=2012\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to fetch: %s\\\" % url)\\n return\\n\\n html = html.replace('<b >', '<b>')\\n html = html.replace('class=\\\"ind alt', 'class=\\\"ind')\\n html = html.replace('class=\\\"ind tL', 'class=\\\"ind')\\n\\n soup = BeautifulSoup(html)\\n table = soup.find('table', attrs={'class':'table'})\\n rows = table.findAll('tr')\\n\\n object_list = []\\n\\n for row in rows[1:6]: # grab the first through ten.\\n rank = row.find('td', attrs={'class':'ind', 'width': '10%'}).renderContents().strip()\\n player = row.find('td', attrs={'class':'ind', 'width': '65%'}).find('a').renderContents().strip()\\n stat = row.find('td', attrs={'class':'ind', 'width': '25%'}).renderContents().strip()\\n object_list.append(rank + \\\". \\\" + player + \\\" \\\" + stat)\\n\\n thelist = string.join([item for item in object_list], \\\" | \\\")\\n irc.reply(\\\"Leaders in %s for %s: %s\\\" % (ircutils.bold(optteam.upper()), ircutils.bold(optcategory.upper()), thelist))\",\n \"def mlbleagueleaders(self, irc, msg, args, optleague, optcategory):\\n\\n league = {'mlb': '9', 'al':'7', 'nl':'8'} # do our own translation here for league/category.\\n category = {'avg':'avg', 'hr':'homeRuns', 'rbi':'RBIs', 'ra':'runs', 'sb':'stolenBases', 'era':'ERA', 'whip':'whip', 'k':'strikeoutsPerNineInnings'}\\n\\n optleague = optleague.lower()\\n optcategory = optcategory.lower()\\n\\n if optleague not in league:\\n irc.reply(\\\"League must be one of: %s\\\" % league.keys())\\n return\\n\\n if optcategory not in category:\\n irc.reply(\\\"Category must be one of: %s\\\" % category.keys())\\n return\\n\\n url = self._b64decode('aHR0cDovL20uZXNwbi5nby5jb20vbWxiL2FnZ3JlZ2F0ZXM=') + '?category=%s&groupId=%s&y=1&wjb=' % (category[optcategory], league[optleague])\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to fetch: %s\\\" % url)\\n return\\n \\n html = html.replace('class=\\\"ind alt nw\\\"', 'class=\\\"ind nw\\\"')\\n\\n soup = BeautifulSoup(html)\\n table = soup.find('table', attrs={'class':'table'})\\n rows = table.findAll('tr')\\n \\n append_list = []\\n \\n for row in rows[1:6]:\\n rank = row.find('td', attrs={'class':'ind nw', 'nowrap':'nowrap', 'width':'10%'}).renderContents()\\n team = row.find('td', attrs={'class':'ind nw', 'nowrap':'nowrap', 'width':'70%'}).find('a').text\\n num = row.find('td', attrs={'class':'ind nw', 'nowrap':'nowrap', 'width':'20%'}).renderContents()\\n append_list.append(rank + \\\". \\\" + team + \\\" \\\" + num)\\n\\n thelist = string.join([item for item in append_list], \\\" | \\\")\\n\\n irc.reply(\\\"Leaders in %s for %s: %s\\\" % (ircutils.bold(optleague.upper()), ircutils.bold(optcategory.upper()), thelist))\",\n \"def extract_mn_score(hospital_score_file, mn_score_file):\\n score = pd.read_csv(hospital_score)\\n #print(score)\\n\\n mn_score = score[score[\\\"State\\\"] == \\\"MN\\\"][[\\\"Provider Number\\\", \\\"Hospital Name\\\",\\n \\\"Location\\\", \\\"City\\\", \\\"ZIP Code\\\", \\\"County Name\\\",\\n \\\"Total Performance Score\\\"]]\\n #print(mn_score)\\n #print(mn_score['Total Performance Score'].describe())\\n mn_score['Location'] = mn_score['Location'].apply(lambda x:x.replace('\\\\n', ' '))\\n mn_score.to_csv(mn_score_file, sep='\\\\t', index=False)\",\n \"def scores(datestring):\\n return render_score_page(\\\"scores.html\\\", datestring, datestring)\",\n \"def mlbplayoffs(self, irc, msg, args):\\n \\n url = self._b64decode('aHR0cDovL2VzcG4uZ28uY29tL21sYi9odW50Zm9yb2N0b2Jlcg==')\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply('Failed to fetch: %s' % (self._b64decode('url')))\\n return\\n \\n html = html.replace('sdg', 'sd').replace('sfo', 'sf').replace('tam', 'tb').replace('was', 'wsh').replace('kan', 'kc').replace('chw', 'cws')\\n \\n soup = BeautifulSoup(html)\\n each = soup.findAll('td', attrs={'width':'25%'})\\n\\n ol = []\\n\\n for ea in each: # man is this just a horrible stopgap. \\n links = ea.findAll('a')\\n for link in links:\\n linksplit = link['href'].split('/')\\n team = linksplit[7]\\n ol.append(team.upper())\\n\\n irc.reply(\\\"Playoffs: AL ({0} vs {1}) vs. {2} | {3} vs. {4} || NL: ({5} vs. {6}) vs. {7} | {8} vs. {9}\\\".format(\\\\\\n ircutils.bold(ol[0]), ircutils.bold(ol[1]), ircutils.bold(ol[2]), ircutils.bold(ol[3]), ircutils.bold(ol[4]),\\\\\\n ircutils.bold(ol[5]), ircutils.bold(ol[6]), ircutils.bold(ol[7]), ircutils.bold(ol[8]), ircutils.bold(ol[9])))\",\n \"def query_monthly_hits(cls,N=10):\\n bmkey = 'BookMonthlyHits'\\n bks = from_cache(bmkey)\\n if not bks:\\n dt = datetime.utcnow() - timedelta(days=30)\\n daus = SuiDau.all().filter('date >=',dt).order('-visits').fetch(N)\\n bids = [d.book for d in daus]\\n bks = map(lambda e:str(e.key().id()),SuiBook.get_by_id(bids))\\n to_cache(bmkey,bks)\\n return bks\",\n \"def get_coin_history(self, coin=None, end_date=None, start_date=None):\\n if coin:\\n try:\\n coin_url = self.coins[coin]\\n except:\\n print('Coin ' + str(coin) + ' does not exist in local database!')\\n if start_date:\\n start_date = start_date\\n else:\\n start_date = '20130428'\\n if end_date:\\n end_date = end_date\\n else:\\n now = str(datetime.now().date()).replace('-', '')\\n end_date = now\\n coin_url = coin_url + '/historical-data/?start=' + start_date + '&end=' + end_date\\n content = urlopen(coin_url).read()\\n soup = BeautifulSoup(content, 'html.parser')\\n results = soup.find_all(\\\"tr\\\", class_=\\\"text-right\\\")\\n infos = []\\n for result in results:\\n date = result.find_all('td')[0].text\\n\\n open_val = result.find_all('td')[1].text\\n if open_val == '-':\\n open_val = None\\n else:\\n open_val = float(result.find_all('td')[1].text.replace(',', ''))\\n\\n high_val = result.find_all('td')[2].textoc\\n if high_val == '-':\\n high_val = None\\n else:\\n high_val = float(result.find_all('td')[2].text.replace(',', ''))\\n\\n low_val = result.find_all('td')[3].text\\n if low_val == '-':\\n low_val = None\\n else:\\n low_val = float(result.find_all('td')[3].text.replace(',', ''))\\n\\n close_val = result.find_all('td')[4].text\\n if close_val == '-':\\n close_val = None\\n else:\\n close_val = float(result.find_all('td')[4].text.replace(',', ''))\\n\\n volume = result.find_all('td')[5].text\\n if volume == '-':\\n volume = None\\n else:\\n volume = float(result.find_all('td')[5].text.replace(',', ''))\\n\\n market_cap = result.find_all('td')[6].text\\n if market_cap == '-':\\n market_cap = None\\n else:\\n market_cap = float(result.find_all('td')[6].text.replace(',', ''))\\n temp = {\\n \\\"coin\\\": soup.title.text.split()[0],\\n \\\"date\\\": date,\\n \\\"symbol\\\": soup.title.text.split()[1].replace('(', '').replace(')', ''),\\n \\\"open_val\\\": open_val,\\n \\\"high_val\\\": high_val,\\n \\\"low_val\\\": low_val,\\n \\\"close_val\\\": close_val,\\n \\\"volume\\\": volume,\\n \\\"market_cap\\\": market_cap\\n }\\n infos.append(temp)\\n df_all = pd.DataFrame.from_dict(infos)\\n df_all['middle_val'] = (df_all.high_val + df_all.low_val) / 2\\n df_all['datetime'] = pd.to_datetime(df_all['date'])\\n df_all = df_all.sort_values(by='datetime')\\n return df_all\\n else:\\n return None\",\n \"def mlbstats(self, irc, msg, args, optlist, optplayer):\\n\\n (first, last) = optplayer.split(\\\" \\\", 1) #playername needs to be \\\"first-last\\\"\\n searchplayer = first + '-' + last\\n\\n optyear = False\\n for (option, arg) in optlist:\\n if option == 'year':\\n optyear = arg\\n \\n url = self._b64decode('aHR0cDovL3NlYXJjaC5lc3BuLmdvLmNvbS8=') + '%s' % searchplayer\\n \\n #self.log.info(url)\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to open: %s\\\" % url)\\n return\\n \\n soup = BeautifulSoup(html)\\n \\n if not soup.find('li', attrs={'class':'result mod-smart-card'}):\\n irc.reply(\\\"I didn't find a link for: %s. Perhaps you should be more specific and give a full playername\\\" % optplayer)\\n return\\n else: \\n playercard = soup.find('li', attrs={'class':'result mod-smart-card'})\\n \\n if 'http://espn.go.com/mlb/players/stats?playerId=' not in playercard.renderContents():\\n irc.reply(\\\"Could not find a link to career stats for: %s\\\" % optplayer)\\n return\\n else:\\n #if playercard.find('a', attrs={'href':re.compile('.*?espn.go.com/mlb/players/stats.*?')}):\\n link = playercard.find('a', attrs={'href':re.compile('.*?espn.go.com/mlb/players/stats.*?')})['href']\\n \\n if not link:\\n irc.reply(\\\"I didn't find the link I needed for career stats. Did something break?\\\")\\n return\\n else:\\n try:\\n req = urllib2.Request(link)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to open: %s\\\" % link)\\n return\\n \\n soup = BeautifulSoup(html)\\n playerName = soup.find('title')\\n table = soup.find('table', attrs={'class':'tablehead'}) # everything stems from the table.\\n header = table.find('tr', attrs={'class':'colhead'}).findAll('td') # columns to reference.\\n\\n if optyear:\\n seasonrows = table.findAll('tr', attrs={'class':re.compile('^oddrow$|^evenrow$')}) # find all outside the season+totals\\n season_data = collections.defaultdict(list) # key will be the year.\\n \\n for row in seasonrows: \\n tds = row.findAll('td')\\n for i,td in enumerate(tds):\\n season_data[str(tds[0].getText())].append(str(ircutils.bold(header[i].getText()) + \\\": \\\" + td.getText()))\\n \\n outyear = season_data.get(str(optyear), None)\\n \\n if not outyear:\\n irc.reply(\\\"No stats found for %s in %s\\\" % (optplayer, optyear))\\n else:\\n outyear = string.join([item for item in outyear], \\\" | \\\")\\n irc.reply(\\\"{0} :: {1}\\\".format(optplayer,outyear)) \\n else:\\n endrows = table.findAll('tr', attrs={'class':re.compile('^evenrow bi$|^oddrow bi$')})\\n \\n for total in endrows:\\n if total.find('td', text=\\\"Total\\\"):\\n totals = total.findAll('td')\\n if total.find('td', text=\\\"Season Averages\\\"):\\n seasonaverages = total.findAll('td')\\n \\n del seasonaverages[0] #remove the first td, but match up header via j+2\\n del totals[0:2]\\n\\n seasonstring = string.join([header[i+2].getText() + \\\": \\\" + td.getText() for i,td in enumerate(seasonaverages)], \\\" | \\\")\\n totalstring = string.join([header[i+2].getText() + \\\": \\\" + td.getText() for i,td in enumerate(totals)], \\\" | \\\")\\n \\n irc.reply(\\\"{0} Season Averages :: {1}\\\".format(ircutils.bold(optplayer), seasonstring))\\n irc.reply(\\\"{0} Career Totals :: {1}\\\".format(ircutils.bold(optplayer), totalstring))\",\n \"def getScore(data):\\n return score\",\n \"def nflweeklyleaders(self, irc, msg, args):\\n \\n url = self._b64decode('aHR0cDovL2VzcG4uZ28uY29tL25mbC93ZWVrbHkvbGVhZGVycw==')\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to open: %s\\\" % url)\\n return\\n\\n html = html.replace('class=\\\"oddrow','class=\\\"evenrow')\\n\\n soup = BeautifulSoup(html)\\n weeklytitle = soup.find('h1', attrs={'class':'h2'}).renderContents().strip()\\n tables = soup.findAll('table', attrs={'class':'tablehead'})\\n\\n object_list = []\\n\\n for table in tables:\\n statcategory = table.find('tr', attrs={'class':'stathead'}).find('td')\\n rows = table.findAll('tr', attrs={'class': re.compile('evenrow.*')})\\n for row in rows:\\n player = row.find('td', attrs={'align':'left'})\\n team = player.findNext('td') \\n d = collections.OrderedDict()\\n d['category'] = statcategory.renderContents().strip()\\n d['player'] = str(player.text.replace('.','. '))\\n d['team'] = team.renderContents().strip()\\n object_list.append(d)\\n \\n passinglist = []\\n rushinglist = []\\n receivinglist = []\\n defensivelist = []\\n\\n for each in object_list:\\n if each['category'] == \\\"Passing Leaders\\\":\\n passinglist.append(each['player'] + \\\"(\\\" + each['team'] + \\\")\\\")\\n if each['category'] == \\\"Rushing Leaders\\\":\\n rushinglist.append(each['player'] + \\\"(\\\" + each['team'] + \\\")\\\")\\n if each['category'] == \\\"Receiving Leaders\\\":\\n receivinglist.append(each['player'] + \\\"(\\\" + each['team'] + \\\")\\\") \\n if each['category'] == \\\"Defensive Leaders\\\":\\n defensivelist.append(each['player'] + \\\"(\\\" + each['team'] + \\\")\\\")\\n \\n irc.reply(ircutils.mircColor(weeklytitle, 'red'))\\n irc.reply(ircutils.bold(\\\"Passing Leaders: \\\") + string.join([item for item in passinglist], \\\" | \\\"))\\n irc.reply(ircutils.bold(\\\"Rushing Leaders: \\\") + string.join([item for item in rushinglist], \\\" | \\\"))\\n irc.reply(ircutils.bold(\\\"Receiving Leaders: \\\") + string.join([item for item in receivinglist], \\\" | \\\"))\\n irc.reply(ircutils.bold(\\\"Defensive Leaders: \\\") + string.join([item for item in defensivelist], \\\" | \\\"))\",\n \"def get_score(url):\\n result = requests.get(url)\\n c = result.content\\n\\n soup = BeautifulSoup(c)\\n\\n date = soup.find(\\\"strong\\\", {\\\"class\\\": \\\"watch-time-text\\\"}).text\\n date = datetime.strptime(date, 'Published on %b %d, %Y')\\n \\n child = str(soup.find(\\\"div\\\", {\\\"id\\\": \\\"watch-description-text\\\"}))\\n \\n #tknizer = nltk.tokenize.ToktokTokenizer()\\n\\n #tokenized = tknizer.tokenize(child)\\n tokenized = nltk.tokenize.casual_tokenize(child)\\n\\n str_score = ''\\n \\n for i, token in enumerate(tokenized):\\n if \\\"/10\\\" == token:\\n str_score = tokenized[i-1]\\n ind = i\\n break\\n elif (\\\"10\\\" == token and '/' == tokenized[i-1]):\\n str_score = tokenized[i-2]\\n break\\n elif (\\\"10\\\" == token and '/' in tokenized[i-1]):\\n str_score = tokenized[i-1].split(\\\"/\\\")[0]\\n break\\n elif \\\"/10\\\" in str(token) and len(token) < 10:\\n str_score = tokenized[i].split(\\\"/\\\")[0]\\n ind = i\\n break\\n\\n if str_score == '':\\n score = None\\n else: \\n if str_score.isdigit():\\n score = int(str_score)\\n else:\\n score = str_score\\n \\n appending_fave = False\\n appending_lfave = False\\n fave_tracks = []\\n lfave_track = []\\n\\n for i, token in enumerate(tokenized):\\n if appending_fave:\\n if token == '<br/>' or token == '<p/>':\\n appending_fave = False\\n else:\\n fave_tracks.append(token)\\n \\n if appending_lfave:\\n if token == '<br/>' or token == '<p/>':\\n appending_lfave = False\\n break\\n else:\\n lfave_track.append(token)\\n \\n if tokenized[i-1] == \\\"TRACKS\\\" and token == \\\":\\\":\\n appending_fave = True\\n \\n if tokenized[i-1] == \\\"TRACK\\\":\\n appending_lfave = True\\n \\n \\n if fave_tracks != []: \\n fave_tracks = ' '.join(fave_tracks)\\n fave_tracks = fave_tracks.split(\\\", \\\")\\n else:\\n fave_tracks = []\\n if lfave_track != []:\\n lfave_track = ' '.join(lfave_track)\\n else:\\n lfave_track = ''\\n return score, date, fave_tracks, lfave_track\",\n \"def get_score_history(self):\\n return self._score_history\",\n \"def get_scores(model, X, y):\\n y_hat = model.predict(X)\\n pred = pd.get_dummies(y_hat.argmax(axis=1))\\n acc = accuracy_score(y,pred)\\n rec = recall_score(y,pred, average='weighted')\\n pre = precision_score(y,pred, average='weighted')\\n f1 = f1_score(y,pred, average='weighted')\\n print(f\\\"ACC: {acc}\\\")\\n print(f\\\"REC: {rec}\\\")\\n print(f\\\"PRE: {pre}\\\")\\n print(f\\\"F1: {f1}\\\")\\n return acc, rec, pre, f1, pred\",\n \"def get_big_five_scores(self, cat_scores) -> Tuple[float, float, float, float, float]:\\n return self.get_openness(cat_scores), self.get_conscientiousness(\\n cat_scores), self.get_extraversion(cat_scores), self.get_agreeableness(\\n cat_scores), self.get_neuroticism(cat_scores)\",\n \"def alt_score(objects):\\n scores = {}\\n for tweet in objects:\\n data = tweet._json\\n raw_time = datetime.strptime(\\n data['created_at'],\\n '%a %b %d %H:%M:%S +0000 %Y'\\n )\\n age = ((datetime.utcnow() - raw_time).seconds / 60) + 1\\n rt = data['retweet_count']\\n fave = data['favorite_count']\\n fol = data['user']['followers_count']\\n weight = 1.5\\n e2f = ((weight * rt + fave) / (fol / 2)) * 1000\\n e2a = enagement / age\\n score = e2f + e2a\\n scores[score] = data['id']\\n embeds = []\\n for item in sorted(scores.items(), reverse=True)[:13]:\\n embed = twitter.get_oembed(id=item[1], align='center')\\n embeds.append(embed['html'])\\n return embeds\",\n \"def get_all_coins_history(self, end_date=None, start_date=None, verbose=True):\\n infos = []\\n for coin in self.get_coins():\\n if verbose:\\n print(\\\"Collecting data for >> \\\" + coin)\\n if start_date:\\n start_date = start_date\\n else:\\n start_date = '20130428'\\n if end_date:\\n end_date = end_date\\n else:\\n now = str(datetime.now().date()).replace('-', '')\\n end_date = now\\n coin_url = self.coins[coin]\\n coin_url = coin_url + '/historical-data/?start=' + start_date + '&end=' + end_date\\n content = urlopen(coin_url).read()\\n soup = BeautifulSoup(content, 'html.parser')\\n results = soup.find_all(\\\"tr\\\", class_=\\\"text-right\\\")\\n\\n for result in results:\\n date = result.find_all('td')[0].text\\n\\n open_val = result.find_all('td')[1].text\\n if open_val == '-':\\n open_val = None\\n else:\\n open_val = float(result.find_all('td')[1].text.replace(',', ''))\\n\\n high_val = result.find_all('td')[2].text\\n if high_val == '-':\\n high_val = None\\n else:\\n high_val = float(result.find_all('td')[2].text.replace(',', ''))\\n\\n low_val = result.find_all('td')[3].text\\n if low_val == '-':\\n low_val = None\\n else:\\n low_val = float(result.find_all('td')[3].text.replace(',', ''))\\n\\n close_val = result.find_all('td')[4].text\\n if close_val == '-':\\n close_val = None\\n else:\\n close_val = float(result.find_all('td')[4].text.replace(',', ''))\\n\\n volume = result.find_all('td')[5].text\\n if volume == '-':\\n volume = None\\n else:\\n volume = float(result.find_all('td')[5].text.replace(',', ''))\\n\\n market_cap = result.find_all('td')[6].text\\n if market_cap == '-':\\n market_cap = None\\n else:\\n market_cap = float(result.find_all('td')[6].text.replace(',', ''))\\n temp = {\\n \\\"coin\\\": coin, # soup.title.text.split()[0],\\n \\\"date\\\": date,\\n \\\"symbol\\\": soup.title.text.split()[1].replace('(', '').replace(')', ''),\\n \\\"open_val\\\": open_val,\\n \\\"high_val\\\": high_val,\\n \\\"low_val\\\": low_val,\\n \\\"close_val\\\": close_val,\\n \\\"volume\\\": volume,\\n \\\"market_cap\\\": market_cap\\n }\\n infos.append(temp)\\n df_all = pd.DataFrame.from_dict(infos)\\n df_all['middle_val'] = (df_all.high_val + df_all.low_val) / 2\\n df_all['datetime'] = pd.to_datetime(df_all['date'])\\n df_all = df_all.sort_values(by='datetime')\\n self.coins_history = df_all\",\n \"def getHourlyLoads(self):\\n\\n\\t\\tloads_data = self.getDataForLoadComparisons()\\n\\t\\tload_values = [] # Array that will contain all the load data\\n\\t\\tload_data = {} # Dictionary of load data\\n\\t\\thour = 0 # Counter that determines the 24 hours in a day\\n\\n\\t\\t# Parsing load data\\n\\t\\ttoday = self.helper.getMonth() + \\\"/\\\" + self.helper.getDay() + \\\"/\\\" + self.helper.getYear()\\n\\t\\tfor data in loads_data[0]['values']:\\t\\t\\t\\n\\t\\t\\tif data[\\\"label\\\"] == \\\"12:00 AM\\\":\\n\\t\\t\\t\\tdata[\\\"label\\\"] = \\\" 00:00\\\"\\n\\t\\t\\telif data[\\\"label\\\"].split(\\\" \\\")[1] == \\\"AM\\\":\\n\\n\\t\\t\\t\\thour = int(data[\\\"label\\\"].split(\\\":\\\")[0])\\n\\t\\t\\t\\tif hour < 10:\\n\\t\\t\\t\\t\\tdata[\\\"label\\\"] = \\\" 0\\\" + str(hour) + \\\":00\\\"\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tdata[\\\"label\\\"] = str(hour) + \\\":00\\\"\\n\\t\\t\\telif data[\\\"label\\\"].split(\\\" \\\")[1] == \\\"PM\\\":\\n\\t\\t\\t\\tif data[\\\"label\\\"] == \\\"12:00 PM\\\":\\n\\t\\t\\t\\t\\tdata[\\\"label\\\"] = \\\" 12:00\\\"\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\thour = int(data[\\\"label\\\"].split(\\\":\\\")[0])\\n\\t\\t\\t\\t\\thour += 12\\n\\t\\t\\t\\t\\tdata[\\\"label\\\"] = \\\" \\\" + str(hour) + \\\":00\\\"\\n\\t\\t\\tload_data[\\\"x\\\"] = self.helper.getDateInEpoch(today + \\\" \\\" + data[\\\"label\\\"])\\n\\t\\t\\tload_data[\\\"y\\\"] = float(data[\\\"value\\\"])\\n\\t\\t\\tload_values.append(load_data)\\n\\t\\t\\tload_data = {}\\n\\n\\t\\treturn load_values\",\n \"def score(self, epochs=None, y=None):\\n if epochs is not None:\\n self.predict(epochs)\\n else:\\n if not hasattr(self, 'y_pred_'):\\n raise RuntimeError('Please predict() epochs first or pass '\\n 'epochs to score()')\\n self._prep_times()\\n super(TimeDecoding, self).score(epochs=None, y=y)\\n self._clean_times()\\n return self.scores_\",\n \"def get_list_team_scores(self):\\n scores = defaultdict(lambda: {\\n \\\"scored_xg\\\": [],\\n \\\"conceded_xg\\\": [],\\n \\\"home_adv\\\": 0,\\n \\\"expected_points\\\": 0\\n })\\n\\n for g in self.games:\\n scores[g.HomeTeam][\\\"scored_xg\\\"].append(g.FTHG)\\n scores[g.HomeTeam][\\\"conceded_xg\\\"].append(g.FTAG)\\n scores[g.AwayTeam][\\\"scored_xg\\\"].append(g.FTAG)\\n scores[g.AwayTeam][\\\"conceded_xg\\\"].append(g.FTHG)\\n\\n for team in scores.keys():\\n scores[team][\\\"expected_points\\\"] = (self.get_table(metric='points')[team] /\\n len(scores[team][\\\"scored_xg\\\"]))\\n\\n return scores\",\n \"def read_leaderboard(self):\\n \\n with open(\\\"Leaderboard.csv\\\", 'r') as in_file:\\n reader = csv.reader(in_file)\\n history_score = {rows[0]:float(rows[1]) for rows in reader}\\n \\n return history_score\",\n \"def get_score(self):\\n for response in self.response_list:\\n self.score += response.get_score\",\n \"def calc_lf_season(seasons, fuel_region_yh, average_fuel_yd):\\n seasons_lfs = {}\\n for season, yeardays_modelled in seasons.items():\\n\\n average_fuel_yd_full_year = np.average(\\n average_fuel_yd[:, ],\\n axis=1)\\n\\n # Calculate maximum hour in year\\n max_load_h_days_season = np.max(\\n fuel_region_yh[:, yeardays_modelled],\\n axis=2)\\n\\n max_load_h_season = np.max(max_load_h_days_season, axis=1)\\n\\n # Unable local RuntimeWarning: divide by zero encountered\\n with np.errstate(divide='ignore', invalid='ignore'):\\n\\n #convert to percentage\\n season_lf = (average_fuel_yd_full_year / max_load_h_season) * 100\\n\\n # Replace\\n season_lf[np.isinf(season_lf)] = 0\\n season_lf[np.isnan(season_lf)] = 0\\n\\n seasons_lfs[season] = season_lf\\n\\n return seasons_lfs\",\n \"def get_homework_statuses(current_timestamp: int) -> dict:\\n data = {\\\"from_date\\\": current_timestamp}\\n headers = {\\\"Authorization\\\": f\\\"OAuth {PRAKTIKUM_TOKEN}\\\"}\\n try:\\n homework_statuses = requests.get(\\n PRAKTIKUM_API_URL,\\n params=data,\\n headers=headers,\\n )\\n # Заккоментриовал, т.к. валятся тесты\\n # homework_statuses.raise_for_status()\\n except requests.exceptions.RequestException as e:\\n logger.exception(e)\\n send_message(str(e))\\n raise\\n return homework_statuses.json()\",\n \"def vm_get_sla(self, vm_node_history):\\n sla = float(0)\\n\\n for i in vm_node_history:\\n try:\\n serviceid = self._zabbix_get_serviceid(i['node_hostname'])\\n node_sla = self._zabbix_get_sla(serviceid, i['since'], i['till'])\\n except ZabbixAPIException as exc:\\n err = 'Zabbix API Error when retrieving SLA (%s)' % exc\\n self.log(ERROR, err)\\n raise InternalMonitoringError(err)\\n except MonitoringError as exc:\\n err = 'Could not parse Zabbix API output when retrieving SLA (%s)' % exc\\n self.log(ERROR, err)\\n raise exc.__class__(err)\\n else:\\n sla += float(node_sla) * i['weight']\\n\\n return sla\",\n \"def __lm_scores(en_id, txt, prefix):\\n feat_field_dict = {'title': econfig.TITLE, 'sAbs': econfig.SHORT_ABS, 'lAbs': econfig.LONG_ABS,\\n 'links': econfig.WIKILINKS, 'cats': econfig.CATEGORIES, 'catchall': Lucene.FIELDNAME_CONTENTS}\\n ftr_extractor = QuerySimFeat(txt)\\n scores = dict()\\n for feature_name, field in feat_field_dict.iteritems():\\n lm_score = ftr_extractor.nllr_lm_score(en_id, field) # lm_score(en_id, field)\\n scores[prefix + feature_name] = lm_score if lm_score is not None else 0\\n return scores\",\n \"def getDataForLoadComparisons(self):\\n\\n\\t\\t# Variables\\n\\t\\tload_data = self.getLoadData() \\n\\t\\tvalues = [] \\n\\t\\tinner_dict = {}\\n\\t\\touter_dict = {}\\n\\t\\tfinal_data = []\\n\\t\\tyesterday = self.helper.getYesterday()\\n\\t\\tkey = self.helper.getYear() + self.helper.getMonth() + self.helper.getDay() + \\\"-loadData\\\"\\n\\t\\tdata = load_data[yesterday[0]][int(yesterday[1])][int(yesterday[2])]\\n\\t\\tdates = (['12:00 AM','1:00 AM','2:00 AM','3:00 AM','4:00 AM','5:00 AM',\\n\\t\\t\\t'6:00 AM','7:00 AM','8:00 AM','9:00 AM','10:00 AM','11:00 AM',\\n\\t\\t\\t'12:00 PM','1:00 PM','2:00 PM','3:00 PM','4:00 PM','5:00 PM',\\n\\t\\t\\t'6:00 PM','7:00 PM','8:00 PM','9:00 PM','10:00 PM','11:00 PM'])\\n\\n\\t\\t# Populating values array\\n\\t\\tfor i in range(0,len(data)):\\n\\t\\t\\tinner_dict['label'] = dates[i]\\n\\t\\t\\tinner_dict['value'] = data[i]\\n\\t\\t\\tvalues.append(inner_dict)\\n\\t\\t\\tinner_dict = {}\\n\\n\\t\\t# Populating the final_data array and returning it\\n\\t\\touter_dict['key'] = key\\n\\t\\touter_dict['values'] = values\\n\\t\\tfinal_data.append(outer_dict)\\n\\n\\t\\treturn final_data\",\n \"def sorting_score(self):\\r\\n # Make courses that have an announcement date shave a lower\\r\\n # score than courses than don't, older courses should have a\\r\\n # higher score.\\r\\n announcement, start, now = self._sorting_dates()\\r\\n scale = 300.0 # about a year\\r\\n if announcement:\\r\\n days = (now - announcement).days\\r\\n score = -exp(-days / scale)\\r\\n else:\\r\\n days = (now - start).days\\r\\n score = exp(days / scale)\\r\\n return score\",\n \"def get_scores(self):\\n return self.score\",\n \"def get_site_mau_history_metrics(site, months_back):\\n history = []\\n\\n # We will not have the current month's data because metrics are calculated\\n # after the month is over\\n for rec in SiteMonthlyMetrics.objects.filter(site=site).order_by('-month_for')[:months_back]:\\n period = '{year}/{month}'.format(year=rec.month_for.year,\\n month=str(rec.month_for.month).zfill(2))\\n history.append(dict(period=period, value=rec.active_user_count))\\n\\n # Get our latest stored site MAU count\\n sdm = SiteDailyMetrics.latest_previous_record(site=site)\\n current_month_active = sdm.mau if sdm else 0\\n\\n if history:\\n # reverse the list because it is currently in reverser chronological order\\n history.reverse()\\n\\n current_month = datetime.datetime.utcnow().date()\\n period = '{year}/{month}'.format(year=current_month.year,\\n month=str(current_month.month).zfill(2))\\n history.append(dict(period=period, value=current_month_active))\\n return dict(current_month=current_month_active, history=history)\",\n \"def get_games_behind_history(self, team):\\n abbr = convert_name(team, how='abbr')\\n res = self._db.Teams.aggregate([{'$match': {'Tm' : abbr}},\\n {'$unwind': '$Schedule'},\\n {'$project':\\n {'_id' : 0,\\n 'Date' : '$Schedule.Date',\\n 'GB': '$Schedule.GB'}}])\\n hist = [x for x in list(res) if 'GB' in x.keys()]\\n return hist\",\n \"def get_all_f_blast_x_scores(self):\\n listOfScoreBlast = []\\n sqlObj = _F_score_blast_X_sql()\\n results = sqlObj.select_all_score_blast_x_all_attributes()\\n for element in results:\\n listOfScoreBlast.append(F_score_blast_X(element[0], element[1], element[2], element[3], element[4], element[5], element[6], element[7], element[8], element[9], element[10], element[11], element[12], element[13], element[14]))\\n return listOfScoreBlast\",\n \"def score(self, X, y):\\n return self.top30_score(y, self.predict(X))\",\n \"def get_prediction_scores(self, X_te, Y_te, scoring):\\n X_te = X_te - self.Xm\\n if self.scale_X:\\n X_te = X_te / self.Xs\\n M_te = X_te @ self.Q\\n\\n scores = torch.zeros(Y_te.shape[1], len(self.ls), dtype=X_te.dtype)\\n for j, Y_te_j in enumerate(Y_te.t()):\\n N_te_j = None\\n for k, l in enumerate(self.ls):\\n Yhat_te_j, N_te_j = self._predict_single(\\n X_te, M_te, j, l, N_te_j\\n )\\n scores[j, k] = scoring(Y_te_j, Yhat_te_j).item()\\n return scores\",\n \"def scrape_espn_feed():\\n thescores = doScoresScrape()\\n fixScores(thescores, 'MLB')\\n logger.info(\\\"Scores scraped\\\")\",\n \"def get_high_scores(self, request):\\n result_count = 10\\n if request.number_of_results is not None:\\n result_count = request.number_of_results\\n return ScoreForms(items=[score.to_form() for score in Score.query().\\n order(-Score.points).fetch(result_count)])\",\n \"def scrape_scores(main_soup):\\n ul = main_soup.find('ul', {'class': 'quality-mark-bar-list'})\\n\\n labels = []\\n for li in ul.find_all('li'):\\n label = str(li.text).strip()\\n if label is not '' and '.' not in label:\\n labels.append(label)\\n\\n scores = []\\n for div in ul.find_all('div'):\\n scores.append(div['data-tooltip-text'])\\n\\n return labels, scores\",\n \"def ml_pred_data_query(ticker='AMZN', db_name='test_stock_pred', collection_name='amzn_pred', \\nstock_last_date=None, n_future_days=5, n_past_days=90):\\n\\n stock_db = db_client[db_name]\\n stock_collection = stock_db[collection_name]\\n \\n if stock_last_date is str:\\n stock_last_date = datetime.strptime(stock_last_date, '%Y-%m-%d')\\n \\n query_result = stock_collection.find({'Stock': ticker,\\n 'Datetime': stock_last_date,\\n 'n_future_days': n_future_days,\\n 'n_past_days': n_past_days})\\n return query_result\",\n \"def _get_belt(self, new_score):\\r\\n for score in reversed(scores):\\r\\n if new_score >= score:\\r\\n return BELTS[score].capitalize()\\r\\n return None\",\n \"def get_high_scores(self, request):\\n difficulty = validateGameDifficultyValue(request, True)\\n type(request)\\n scores = Score.query()\\n scores = scores.order(Score.guesses)\\n scores = scores.order(-Score.date)\\n # Filter by game difficulty and only wons that resulted in a win\\n scores = scores.filter(Score.difficulty == difficulty,\\\\\\n Score.won == True)\\n # Get only the limit of results requested\\n # Validate number_of_results is a positive integer\\n if int(request.number_of_results) < 1:\\n raise endpoints.BadRequestException(\\n 'Number of results must be a positive value')\\n scores = scores.fetch(int(request.number_of_results))\\n return ScoreForms(items=[score.to_form() for score in scores])\",\n \"def dummy_scores(result):\\n\\n # Get students assigned to this year\\n req_year = result['subject']['year_id']\\n req_user = result['user_id']\\n sinfo = models.Students.query.filter_by(year_id=req_year, user_id=req_user).all()\\n\\n # Loop through and add dummy scores\\n for i, student in enumerate(sinfo):\\n print(student)\\n models.Scores.add_dummy(student.id, result['id'], req_user)\",\n \"def mlbrosterstats(self, irc, msg, args, optteam):\\n\\n if optteam:\\n optteam = optteam.upper()\\n if optteam not in self._validteams():\\n irc.reply(\\\"Team not found. Must be one of: %s\\\" % self._validteams())\\n return\\n \\n url = self._b64decode('aHR0cDovL2VzcG4uZ28uY29tL21sYi9zdGF0cy9yb3N0ZXJz')\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to open: %s\\\" % url)\\n return\\n \\n soup = BeautifulSoup(html)\\n table = soup.find('table', attrs={'class':'tablehead'})\\n rows = table.findAll('tr')[2:]\\n\\n object_list = []\\n\\n for row in rows:\\n rank = row.find('td')\\n team = rank.findNext('td')\\n rhb = team.findNext('td')\\n lhb = rhb.findNext('td')\\n sh = lhb.findNext('td')\\n rhp = sh.findNext('td')\\n lhp = rhp.findNext('td')\\n ht = lhp.findNext('td')\\n wt = ht.findNext('td')\\n age = wt.findNext('td')\\n young = age.findNext('td')\\n old = young.findNext('td')\\n \\n aString = str(\\\"RHB: \\\" + rhb.getText() + \\\" LHB: \\\" + lhb.getText() + \\\" SH: \\\" + sh.getText() + \\\" RHP: \\\" + rhp.getText() + \\\" LHP: \\\" + lhp.getText()\\\\\\n + \\\" AVG HT: \\\" + ht.getText() + \\\" AVG WEIGHT: \\\" + wt.getText() + \\\" AVG AGE: \\\" + age.getText() + \\\" YOUNGEST: \\\" + young.getText() + \\\" OLDEST: \\\" + old.getText())\\n \\n d = collections.OrderedDict()\\n d['team'] = str(self._translateTeam('team', 'ename', team.getText()))\\n d['data'] = str(aString)\\n object_list.append(d)\\n \\n if optteam:\\n for each in object_list:\\n if each['team'] == optteam: # list will have all teams so we don't need to check\\n output = \\\"{0} Roster Stats :: {1}\\\".format(ircutils.bold(each['team']), each['data'])\\n \\n irc.reply(output)\\n \\n else:\\n \\n youngest_list = []\\n oldest_list = []\\n \\n for each in object_list[0:5]:\\n youngest_list.append(each['team'])\\n for each in object_list[-6:-1]:\\n oldest_list.append(each['team'])\\n \\n output = \\\"{0} :: {1}\\\".format(ircutils.bold(\\\"5 Youngest MLB Teams:\\\"), string.join([item for item in youngest_list], \\\" | \\\"))\\n irc.reply(output)\\n \\n output = \\\"{0} :: {1}\\\".format(ircutils.bold(\\\"5 Oldest MLB Teams:\\\"), string.join([item for item in oldest_list], \\\" | \\\"))\\n irc.reply(output)\",\n \"def get_fresh_data(get_team):\\n\\n \\\"\\\"\\\" Create the URL for today \\\"\\\"\\\"\\n now = datetime.datetime.now()\\n url = \\\"http://gd2.mlb.com/gdcross/components/game/mlb/year_\\\" + '{}'.format(now.year) + \\\"/month_\\\" + '{:02d}'.format(now.month) + \\\"/day_\\\" + '{:02d}'.format(now.day) + \\\"/miniscoreboard.json\\\"\\n\\n \\\"\\\"\\\" Grab the first response and write it to a file, we'll update it once the game starts \\\"\\\"\\\"\\n data_write_file = status_dir + '{}'.format(now.year) + '{:02d}'.format(now.month) + '{:02d}'.format(now.day) + \\\".json\\\"\\n\\n \\\"\\\"\\\" Get the json data if the file doesn't exist, or if it's over three minutes old \\\"\\\"\\\"\\n if not os.path.isfile(data_write_file) or time.time() - os.path.getmtime(data_write_file) > 60:\\n response = urllib.urlopen(url)\\n full_data = json.loads(response.read())\\n with open(data_write_file, 'w') as outfile:\\n json.dump(full_data, outfile, sort_keys=True, indent=2, ensure_ascii=False)\\n\\n \\\"\\\"\\\" Use the data from the status file \\\"\\\"\\\"\\n with open(data_write_file, 'r') as json_data:\\n full_data = json.load(json_data)\\n\\n \\\"\\\"\\\" This will return false if there is no game today, else will return json data for just our team \\\"\\\"\\\"\\n my_game = False\\n for game in full_data['data']['games']['game']:\\n if get_team in game['home_file_code'] or get_team in game['away_file_code']:\\n my_game = game\\n \\n return my_game\",\n \"def get_data(end_date, n, local, foreign):\\n URL = \\\"https://api.exchangeratesapi.io/history\\\"\\n PARAMS = {'start_at': str(get_weekday_n_days_ago(end_date, n)),\\n 'end_at': str(end_date),\\n 'symbols': foreign,\\n 'base': local}\\n r = requests.get(url=URL, params=PARAMS)\\n data = r.json()\\n input_data = []\\n for day in data['rates']:\\n input_data.append([datetime.strptime(day, '%Y-%m-%d').date(),\\n float(\\\"{:.8f}\\\".format(data['rates'][day][foreign]))])\\n input_data.sort(key=lambda x: x[0])\\n return input_data[-n:]\",\n \"def rescraper(url):\\n\\tresponse = urlopen(url)\\n\\tplayed_games = response.read().decode()\\n\\tfor line in played_games.split('\\\\n'):\\n\\t\\tif '<table class=\\\"linescore' in line:\\n\\t\\t\\ttext = line\\n\\t\\t\\tscores = re.findall(r'<td class=\\\"final score\\\">(\\\\d+)</td>',text)\\n\\t\\t\\tteams = re.findall(r'<a.*?>(.*?)</a>', text)\\n\\t\\t\\tprint('{} {}, {} {}'.format(teams[0],scores[0],teams[1],scores[1]))\",\n \"def lzs (inlist):\\r\\n zscores = []\\r\\n for item in inlist:\\r\\n zscores.append(z(inlist,item))\\r\\n return zscores\",\n \"def latest(scores: List) -> List:\\n # Check the argument type\\n if not isinstance(scores, List):\\n raise TypeError(\\\"Argument 'scores' must be of type list.\\\")\\n\\n return scores[-1]\",\n \"def run_past_matches(self):\\n for year in self.store.years:\\n # print(year)\\n for event in self.store.events[year]:\\n for match in self.store.matches[year][event.key]:\\n red_alliance = match.red_alliance\\n blue_alliance = match.blue_alliance\\n\\n for team in red_alliance + blue_alliance:\\n if team not in self.scores.keys():\\n self.scores[team] = self.default_score\\n\\n prediction = self.predict(red_alliance, blue_alliance, key=match.key)\\n self.update_score(red_alliance, blue_alliance, prediction,\\n match.red_score, match.blue_score)\",\n \"def make_zscores(relfreqs, means, stdevs):\\n normalized = relfreqs.sub(means, axis=\\\"index\\\")\\n save_dataframe(normalized, \\\"2-normalized.csv\\\")\\n #print(normalized.head())\\n zscores = normalized.div(stdevs, axis=\\\"index\\\")\\n save_dataframe(zscores, \\\"3-zscores.csv\\\")\\n #print(zscores.head())\\n return zscores\",\n \"def lz (inlist, score):\\r\\n z = (score-mean(inlist))/samplestdev(inlist)\\r\\n return z\",\n \"def nflleagueleaders(self, irc, msg, args, optlist, optcategory, optstat, optyear): \\n \\n statsCategories = { \\n 'Passing': { \\n 'qbr':'49', \\n 'comp':'1',\\n 'att':'2',\\n 'comp%':'41',\\n 'yards':'4',\\n 'yards/gm':'42',\\n 'td':'5',\\n 'int':'3',\\n 'sacked':'8',\\n 'sackedyardslost':'9',\\n 'fumbles':'47',\\n 'fumbleslost':'48'\\n },\\n 'Rushing': {\\n 'rushes':'16',\\n 'yards':'17',\\n 'yards/g':'39',\\n 'avg':'40',\\n 'td':'18',\\n 'fumbles':'47',\\n 'fumbleslost':'48'\\n },\\n 'Receiving': {\\n 'receptions':'27',\\n 'recyards':'28',\\n 'yards/gm':'44',\\n 'yards/avg':'45',\\n 'longest':'30',\\n 'yac':'46',\\n '1stdowns':'33',\\n 'tds':'29',\\n 'fumbles':'47',\\n 'fumbleslost':'48'\\n },\\n 'Kicking': {\\n '0-19':'208',\\n '20-29':'210',\\n '30-39':'212',\\n '40-49':'214',\\n '50+':'216',\\n 'fgm':'222',\\n 'fga':'221',\\n 'pct':'230',\\n 'longest':'224',\\n 'xpm':'225',\\n 'xpa':'226',\\n 'xp%':'231' \\n },\\n 'Returns':{\\n 'kickoffreturns':'311',\\n 'kickoffyards':'312',\\n 'kickoffavg':'319',\\n 'kickofflongest':'314',\\n 'kickofftd':'315',\\n 'puntreturns':'301',\\n 'puntreturnyards':'302',\\n 'puntreturnavg':'320',\\n 'puntreturnlongest':'304',\\n 'puntreturntds':'305'\\n },\\n 'Punting': {\\n 'punts':'402',\\n 'puntyards':'403',\\n 'puntavg':'411',\\n 'puntlong':'408',\\n 'puntwithin20':'404',\\n 'puntwithin10':'405',\\n 'faircatch':'401',\\n 'touchback':'406',\\n 'blocked':'407' \\n },\\n 'Defense':{\\n 'solotackles':'128',\\n 'assistedtackles':'129',\\n 'totaltackles':'130',\\n 'sacks':'106',\\n 'sacksyardslost':'107',\\n 'stuffs':'101',\\n 'stuffsyardslost':'102',\\n 'int':'108',\\n 'intyards':'109',\\n 'inttds':'110',\\n 'deftd':'103',\\n 'forcedfumbles':'114',\\n 'pd':'113',\\n 'safety':'115' \\n } \\n }\\n \\n optcategory = optcategory.title() # must title this category\\n \\n if optcategory not in statsCategories:\\n irc.reply(\\\"Category must be one of: %s\\\" % statsCategories.keys())\\n return\\n \\n optstat = optstat.lower() # stat key is lower. value is #. \\n \\n if optstat not in statsCategories[optcategory]:\\n irc.reply(\\\"Stat for %s must be one of: %s\\\" % (optcategory, statsCategories[optcategory].keys()))\\n return\\n \\n if optyear: \\n testdate = self._validate(optyear, '%Y')\\n if not testdate:\\n irc.reply(\\\"Invalid year. Must be YYYY.\\\")\\n return\\n if int(optyear) < 2000:\\n irc.reply(\\\"Year must be 2001 or after.\\\")\\n return\\n\\n postseason, outlimit = False, '10'\\n for (option, arg) in optlist:\\n if option == 'postseason':\\n postseason = True\\n if option == 'num20':\\n outlimit = '20'\\n \\n url = self._b64decode('aHR0cDovL3Nwb3J0cy55YWhvby5jb20vbmZsL3N0YXRzL2J5Y2F0ZWdvcnk=')\\n url += '?cat=%s&conference=NFL&sort=%s&timeframe=All' % (optcategory, statsCategories[optcategory][optstat])\\n \\n if optyear: # don't need year for most current.\\n if not postseason:\\n url += '&year=season_%s' % optyear\\n else:\\n url += '&year=postseason_%s' % optyear \\n \\n #self.log.info(url)\\n \\n try: \\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Failed to open: %s\\\" % url)\\n return\\n\\n html = html.replace(' ','')\\n \\n soup = BeautifulSoup(html)\\n selectedyear = soup.find('select', attrs={'name':'year'}).find('option', attrs={'selected':'selected'}) # creative way to find the year.\\n table = soup.find('tr', attrs={'class':'ysptblthmsts', 'align':'center'}).findParent('table')\\n header = table.findAll('tr')[1].findAll('td')\\n rows = table.findAll('tr')[2:]\\n\\n append_list = []\\n\\n for row in rows[0:int(outlimit)]:\\n name = str(row.findAll('td')[0].getText()) # always first\\n team = str(row.findAll('td')[1].getText()) # always next\\n sortfield = row.find('span', attrs={'class':'yspscores'}) # whatever field you are sorting by will have this span inside the td. \\n append_list.append(ircutils.bold(name) + \\\"(\\\" + team + \\\") - \\\" + str(sortfield.getText()))\\n\\n title = \\\"Top %s in %s(%s) for %s\\\" % (outlimit, optcategory, optstat, selectedyear.getText())\\n descstring = string.join([item for item in append_list], \\\" | \\\")\\n \\n output = \\\"{0} :: {1}\\\".format(ircutils.mircColor(title, 'red'), descstring)\\n irc.reply(output)\",\n \"def scraper_bloomberg() -> None:\\n\\thtmltext = urllib.urlopen('http://www.bloomberg.com/markets/watchlist/recent-ticker/AAPL:US')\\n\\tdata = json.load(htmltext)\\n\\n\\tprint data[\\\"last_price\\\"]\\n\\n\\treturn None\",\n \"def get_monthly_history_metric(func, site, date_for, months_back,\\n include_current_in_history=True): # pylint: disable=unused-argument\\n date_for = as_date(date_for)\\n history = []\\n\\n for month in previous_months_iterator(month_for=date_for, months_back=months_back,):\\n period = period_str(month)\\n value = func(\\n site=site,\\n start_date=datetime.date(month[0], month[1], 1),\\n end_date=datetime.date(month[0], month[1], month[2]),\\n )\\n history.append(dict(period=period, value=value,))\\n\\n if history:\\n # use the last entry\\n current_month = history[-1]['value']\\n else:\\n # This should work for float too since '0 == 0.0' resolves to True\\n current_month = 0\\n return dict(\\n current_month=current_month,\\n history=history,)\",\n \"def fetchSlackFeed(startTimestamp,endTimestamp):\\n\\tsc = SlackClient(k.SLACK_TOKEN)\\n\\tresponse = sc.api_call(\\n\\t\\t\\\"conversations.history\\\",\\n\\t\\tchannel = k.SLACK_CHANNEL_ID,\\n\\t\\toldest = startTimestamp,\\n\\t\\tlatest = endTimestamp,\\n\\t\\tcount = 100\\n\\t)\\n\\treturn response\",\n \"def merge_scores(self): # pragma: no cover\\n\\n merged_scores = []\\n score_end_indices = []\\n\\n for i, score in enumerate(self.anom_scores):\\n if not score['start_idx']-1 in score_end_indices:\\n merged_scores.append(score['score'])\\n score_end_indices.append(score['end_idx'])\",\n \"def L50(self):\\n\\t\\tstats = self.scores()\\n\\t\\treturn stats['l50']\",\n \"def get_highscores(self):\\n\\t\\ttry:\\n\\t\\t\\twith open(self.filename) as f_obj:\\n\\t\\t\\t\\tcontents = f_obj.read()\\n\\t\\texcept FileNotFoundError:\\n\\t\\t\\tprint('File for highscores not found! Call 016 733 7043 for assistance.')\\n\\t\\telse:\\n\\t\\t\\tjson_contents = json.loads(contents)\\n\\t\\t\\treturn sorted(json_contents, key=self.extract_score)\",\n \"def test_get_league_leaders___daily(self):\\n msg = \\\"Response status is not 200\\\"\\n response = self.api.get_league_leaders___daily(self.year1, self.nhl_season, self.year2, self.month, self.day)\\n self.assertEqual(response.status_code, 200, msg)\",\n \"def get_full_history(symbol):\\n to_date = int(datetime.datetime.timestamp(datetime.datetime.now()))\\n from_date = int(datetime.datetime.timestamp(datetime.datetime(1990, 1, 1, 1, 0, 0)))\\n url_base = \\\"https://query1.finance.yahoo.com/v7/finance/download/\\\"\\n url_params = f\\\"{symbol}.NS?period1={from_date}&period2={to_date}&interval=1d&events=history\\\"\\n resp = requests.get(url_base + url_params)\\n a = csv_to_list(resp)[1:]\\n return create_price(symbol, a)\",\n \"def __fillScores(self, contentScores):\\n\\n list_of_data_frames = list()\\n\\n for cntScr in contentScores:\\n res = json.loads(cntScr.score)\\n\\n df_pro = pd.DataFrame(res)\\n df_pro[\\\"productId_requested\\\"] = cntScr.productId\\n df_pro[\\\"cart_score\\\"] = self.cart_score_repository.get_by_products(list(df_pro.productid))\\n df_pro[\\\"passed_day_score\\\"] = self.passed_day_score_repository.get_by_products(list(df_pro.productid))\\n df_pro[\\\"final_score\\\"] = (df_pro.score + df_pro.cart_score + df_pro.passed_day_score) / 3\\n best_product = df_pro.set_index(\\\"productid\\\")[\\\"final_score\\\"].idxmax(axis=\\\"columns\\\")\\n df_pro[\\\"bias_score\\\"] = df_pro.apply(lambda x: self.__set_bias_score(x, best_product), axis=1)\\n list_of_data_frames.append(df_pro)\\n df = pd.concat(list_of_data_frames)\\n return df\",\n \"def score():\\n highscore = session.get(\\\"highscore\\\", 0)\\n nplays = session.get(\\\"nplays\\\", 0)\\n score = request.json[\\\"score\\\"]\\n if score > highscore:\\n highscore = score\\n session['highscore'] = highscore\\n session['nplays'] = nplays +1\\n\\n return jsonify(brokeRecord = highscore)\",\n \"def compute_desc_stats(score_d):\\n _scores = {k:{} for k in time_str_to_time.keys()} \\n _scores['all'] = {} # add key for all milwaukee and all time zones\\n for d in score_d: \\n mean = np.mean(score_d[d])\\n std = np.std(score_d[d])\\n _scores[d]['mean'] = mean\\n _scores[d]['std'] = std\\n _scores[d]['max'] = max(score_d[d])\\n _scores[d]['min'] = min(score_d[d])\\n \\n return _scores\",\n \"def retrieve_scores(num_letters, language, folder, min_score, max_score):\\n if (num_letters == 1):\\n return retrieve_letter_scores(1, language, folder, min_score, max_score)\\n elif (num_letters == 2):\\n return retrieve_syllable_scores(num_letters, 1, language, folder, min_score, max_score)\\n elif (num_letters == 3):\\n return retrieve_syllable_scores(num_letters, 3, language, folder, min_score, max_score)\\n else:\\n print(\\\"Error: incorrect number of letters. Value ranges from 1 to 3.\\\\n\\\")\",\n \"def displayHighScore():\\r\\n compiled_scores = []\\r\\n all_scores = getScores()\\r\\n for row in all_scores.splitlines():\\r\\n compiled_scores += [(row.split()[1], int(row.split()[4])+int(row.split()[7])+\\r\\n int(row.split()[10])+int(row.split()[13]))]\\r\\n print(compiled_scores)\\r\\n PrintHighScores.formatDisplay(compiled_scores)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5864733","0.5720611","0.5628312","0.54834133","0.54429305","0.54429305","0.5391816","0.53706133","0.5342564","0.52987903","0.5291811","0.52855325","0.52515596","0.5246376","0.51850957","0.51413584","0.50993174","0.50862217","0.5074362","0.5064369","0.5055002","0.504508","0.50449264","0.5030509","0.50261563","0.5002658","0.49989465","0.4994392","0.49789917","0.49789122","0.49597788","0.49518755","0.49504247","0.49417737","0.49380288","0.49342713","0.49244305","0.490996","0.49015838","0.48892647","0.48823076","0.48760825","0.48627406","0.48611024","0.48587072","0.48586357","0.48537573","0.48473516","0.48403668","0.48393384","0.4833335","0.48284125","0.48234522","0.4822737","0.48219582","0.48188195","0.48165676","0.48155388","0.48024797","0.4794142","0.4789298","0.478909","0.47747537","0.47730923","0.47712523","0.47703314","0.47674266","0.4763522","0.47634917","0.47624844","0.47553295","0.47550493","0.47545475","0.47511217","0.47483432","0.47475597","0.47461098","0.47453812","0.47444513","0.47391975","0.47372505","0.4737149","0.47323015","0.4705719","0.47019082","0.4695906","0.46954983","0.46935695","0.46811503","0.46773726","0.46752486","0.46708956","0.46707612","0.46643567","0.46560857","0.4655904","0.46497256","0.46361133","0.46317714","0.46317312"],"string":"[\n \"0.5864733\",\n \"0.5720611\",\n \"0.5628312\",\n \"0.54834133\",\n \"0.54429305\",\n \"0.54429305\",\n \"0.5391816\",\n \"0.53706133\",\n \"0.5342564\",\n \"0.52987903\",\n \"0.5291811\",\n \"0.52855325\",\n \"0.52515596\",\n \"0.5246376\",\n \"0.51850957\",\n \"0.51413584\",\n \"0.50993174\",\n \"0.50862217\",\n \"0.5074362\",\n \"0.5064369\",\n \"0.5055002\",\n \"0.504508\",\n \"0.50449264\",\n \"0.5030509\",\n \"0.50261563\",\n \"0.5002658\",\n \"0.49989465\",\n \"0.4994392\",\n \"0.49789917\",\n \"0.49789122\",\n \"0.49597788\",\n \"0.49518755\",\n \"0.49504247\",\n \"0.49417737\",\n \"0.49380288\",\n \"0.49342713\",\n \"0.49244305\",\n \"0.490996\",\n \"0.49015838\",\n \"0.48892647\",\n \"0.48823076\",\n \"0.48760825\",\n \"0.48627406\",\n \"0.48611024\",\n \"0.48587072\",\n \"0.48586357\",\n \"0.48537573\",\n \"0.48473516\",\n \"0.48403668\",\n \"0.48393384\",\n \"0.4833335\",\n \"0.48284125\",\n \"0.48234522\",\n \"0.4822737\",\n \"0.48219582\",\n \"0.48188195\",\n \"0.48165676\",\n \"0.48155388\",\n \"0.48024797\",\n \"0.4794142\",\n \"0.4789298\",\n \"0.478909\",\n \"0.47747537\",\n \"0.47730923\",\n \"0.47712523\",\n \"0.47703314\",\n \"0.47674266\",\n \"0.4763522\",\n \"0.47634917\",\n \"0.47624844\",\n \"0.47553295\",\n \"0.47550493\",\n \"0.47545475\",\n \"0.47511217\",\n \"0.47483432\",\n \"0.47475597\",\n \"0.47461098\",\n \"0.47453812\",\n \"0.47444513\",\n \"0.47391975\",\n \"0.47372505\",\n \"0.4737149\",\n \"0.47323015\",\n \"0.4705719\",\n \"0.47019082\",\n \"0.4695906\",\n \"0.46954983\",\n \"0.46935695\",\n \"0.46811503\",\n \"0.46773726\",\n \"0.46752486\",\n \"0.46708956\",\n \"0.46707612\",\n \"0.46643567\",\n \"0.46560857\",\n \"0.4655904\",\n \"0.46497256\",\n \"0.46361133\",\n \"0.46317714\",\n \"0.46317312\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7069956"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76080,"cells":{"query":{"kind":"string","value":"This function gets updated Covid stats for the state of Indiana."},"document":{"kind":"string","value":"def get_indiana_covid_stats(message):\n api_link = \"https://corona.lmao.ninja/v2/states\"\n get_stats = requests.get(api_link)\n\n for state in get_stats.json():\n if state['state'] == \"Indiana\":\n cases = state['cases']\n deaths = state['deaths']\n\n covid_message = \":coronavirus: In Indiana, there are currently {} confirmed cases of COVID-19, resulting in {} deaths. :coronavirus:\".format(\n cases, deaths)\n\n return covid_message"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_covid_stats_for_all_states():\n url = \"https://corona.lmao.ninja/v2/states/\"\n response = requests.get(url)\n data = response.json()\n\n states = []\n\n for state in data:\n stateName = state[\"state\"]\n\n cases = state[\"cases\"]\n todaysCases = state[\"todayCases\"]\n deaths = state[\"deaths\"]\n todayDeaths = state[\"todayDeaths\"]\n recovered = state[\"recovered\"]\n activeCases = state[\"active\"]\n tests = state[\"tests\"]\n casesPerMil = state[\"casesPerOneMillion\"]\n deathsPerMil = state[\"deathsPerOneMillion\"]\n testsPerMil = state[\"testsPerOneMillion\"]\n\n population = state[\"population\"]\n\n if population != 0:\n millionsOfPop = population / 1000000.0\n activeCasesPerMil = activeCases / millionsOfPop\n color = get_color(activeCasesPerMil)\n states.append(\n StateStats(\n stateName,\n cases,\n todaysCases,\n activeCases,\n casesPerMil,\n deaths,\n todayDeaths,\n deathsPerMil,\n recovered,\n tests,\n testsPerMil,\n color,\n )\n )\n else:\n states.append(\n StateStats(\n stateName,\n cases,\n todaysCases,\n activeCases,\n casesPerMil,\n deaths,\n todayDeaths,\n deathsPerMil,\n recovered,\n tests,\n testsPerMil,\n )\n )\n\n return states","def collect_stat(self):\n\n cnstat_dict, ratestat_dict = self.get_cnstat()\n self.cnstat_dict.update(cnstat_dict)\n self.ratestat_dict.update(ratestat_dict)","def update_server_stats(self):\n try:\n aio.run(self.client.execute, 'ANALYZE')\n except Exception:\n pass # swallow; CrateDB 4.1.0+ is required to run ANALYZE","def update_stats(self):\n\n self.raw_data_index = 0\n start_time = time.time()\n data_frame = load_data(self.selections)\n user_stats = get_user_stats(data_frame)\n\n self.time_stats_data.config(text=get_time_stats(data_frame))\n self.station_stats_data.config(text=get_station_stats(data_frame))\n self.trip_stats_data.config(text=get_trip_duration_stats(data_frame))\n\n self.user_stats_data.config(text=user_stats[0])\n self.gender_stats_data.config(text=user_stats[1])\n self.age_stats_data.config(text=user_stats[2])\n self.status.config(\n text=f\"Updated statistics in {round((time.time() - start_time), 2)} seconds. Modify filters using left radio buttons as desired...\"\n )","def updatestats(self):\n result = self.statsfromcounts(self.hypCountByScenario)\n self.pScenario = result[\"p\"]\n self.scenarioEntropy = result[\"entropy\"]","def update(self):\n stats = self._thread.stats()\n if self._var_id == CONTAINER_MONITOR_STATUS:\n self._state = stats.get('status', None)\n elif self._var_id == CONTAINER_MONITOR_MEMORY_USAGE:\n self._state = stats.get('memory_usage', None)\n elif self._var_id == CONTAINER_MONITOR_CPU_PERCENTAGE:\n self._state = stats.get('cpu_percent', None)\n if 'cpu' in stats:\n self._attributes[ATTR_ONLINE_CPUS] = stats['cpu'].get('online_cpus', None)\n elif self._var_id == CONTAINER_MONITOR_MEMORY_PERCENTAGE:\n self._state = stats.get('memory_percent', None)\n # Network\n elif self._var_id == CONTAINER_MONITOR_NETWORK_UP:\n self._state = round(stats.get('network_up', None) / 1024.0, PRECISION)\n elif self._var_id == CONTAINER_MONITOR_NETWORK_DOWN:\n self._state = round(stats.get('network_down', None) / 1024.0, PRECISION)","def get_covid_stats_by_state(state):\n url = \"https://corona.lmao.ninja/v2/states/\" + state + \"?yesterday=\"\n response = requests.get(url)\n data = response.json()\n cases = data[\"cases\"]\n todaysCases = data[\"todayCases\"]\n deaths = data[\"deaths\"]\n todayDeaths = data[\"todayDeaths\"]\n recovered = data[\"recovered\"]\n activeCases = data[\"active\"]\n tests = data[\"tests\"]\n casesPerMil = data[\"casesPerOneMillion\"]\n deathsPerMil = data[\"deathsPerOneMillion\"]\n testsPerMil = data[\"testsPerOneMillion\"]\n\n return StateStats(\n state,\n cases,\n todaysCases,\n activeCases,\n casesPerMil,\n deaths,\n todayDeaths,\n deathsPerMil,\n recovered,\n tests,\n testsPerMil,\n )","def update(self):\n changes = {}\n for coord in INDICES: # the need for two for loops is necessary\n if self.chart[coord] == ALIVE and (\n self.number_of_neighbors(coord) < 2 or self.number_of_neighbors(coord) > 3):\n changes[coord] = KILL\n elif self.number_of_neighbors(coord) == 3:\n changes[coord] = REVIVE\n for coord in changes.keys(): # because the evolution is discrete\n if changes[coord] == KILL:\n self.kill(coord)\n elif changes[coord] == REVIVE:\n self.givebirth(coord)","def update_data(self):\n for sai_id_key in self.if_id_map:\n namespace, sai_id = mibs.split_sai_id_key(sai_id_key)\n if_idx = mibs.get_index_from_str(self.if_id_map[sai_id_key])\n counter_table = self.namespace_db_map[namespace].get_all(mibs.COUNTERS_DB, \\\n mibs.counter_table(sai_id))\n if counter_table is None:\n counter_table = {}\n self.if_counters[if_idx] = counter_table\n\n\n self.lag_name_if_name_map, \\\n self.if_name_lag_name_map, \\\n self.oid_lag_name_map, _, _ = Namespace.get_sync_d_from_all_namespace(mibs.init_sync_d_lag_tables, self.db_conn)\n\n self.if_range = sorted(list(self.oid_name_map.keys()) + list(self.oid_lag_name_map.keys()))\n self.if_range = [(i,) for i in self.if_range]","def get_cnstat(self):\n def get_counters(table_id):\n \"\"\"\n Get the counters from specific table.\n \"\"\"\n fields = [\"0\"]*BUCKET_NUM\n\n for pos, cntr_list in counter_bucket_dict.items():\n for counter_name in cntr_list:\n full_table_id = COUNTER_TABLE_PREFIX + table_id\n counter_data = self.db.get(self.db.COUNTERS_DB, full_table_id, counter_name)\n if counter_data is None:\n fields[pos] = STATUS_NA\n elif fields[pos] != STATUS_NA:\n fields[pos] = str(int(fields[pos]) + int(counter_data))\n\n cntr = NStats._make(fields)\n return cntr\n\n def get_rates(table_id):\n \"\"\"\n Get the rates from specific table.\n \"\"\"\n fields = [\"0\",\"0\",\"0\",\"0\",\"0\",\"0\"]\n for pos, name in enumerate(rates_key_list):\n full_table_id = RATES_TABLE_PREFIX + table_id\n counter_data = self.db.get(self.db.COUNTERS_DB, full_table_id, name)\n if counter_data is None:\n fields[pos] = STATUS_NA\n elif fields[pos] != STATUS_NA:\n fields[pos] = float(counter_data)\n cntr = RateStats._make(fields)\n return cntr\n\n # Get the info from database\n counter_port_name_map = self.db.get_all(self.db.COUNTERS_DB, COUNTERS_PORT_NAME_MAP);\n # Build a dictionary of the stats\n cnstat_dict = OrderedDict()\n cnstat_dict['time'] = datetime.datetime.now()\n ratestat_dict = OrderedDict()\n if counter_port_name_map is None:\n return cnstat_dict, ratestat_dict\n for port in natsorted(counter_port_name_map):\n port_name = port.split(\":\")[0]\n if self.multi_asic.skip_display(constants.PORT_OBJ, port_name):\n continue\n cnstat_dict[port] = get_counters(counter_port_name_map[port])\n ratestat_dict[port] = get_rates(counter_port_name_map[port])\n return cnstat_dict, ratestat_dict","def _update_odi_collection(self, player_id):\n logging.info('updating odi stats for {}'.format(player_id))\n url = '{}{}{}'.format(self.base_url, self.odi, player_id)\n extracted_fields = self._field_extract(url)\n extracted_fields['_id'] = player_id\n extracted_fields['serious'] = 'odi'\n self.db_sync(dataset=extracted_fields, db_name=self.db_name, db_collection=self.odi_collection,\n db_operation=self.DB_UPDATE_ONE)","def compute_stats(self):\n from vmc.common.oal import osobj\n d = osobj.get_iface_stats()\n d.addCallback(self.update_stats)","def update(self):\n\n self.stats = statistics.get()\n self.ticker = exchangerates.get_ticker()","def update_status(self, server):\r\n\r\n\t\tcards = self.ice.getCardsAlive()\r\n\t\talarm_list = self.ice.getAlarmStatus()\r\n\t\tstatus_list = self.ice.getStatus()\r\n\t\twarning_list = self.ice.getWarnings()\r\n\r\n\t\tdateTimeObj = datetime.now()\r\n\t\ttimestampStr = dateTimeObj.strftime(\"%d-%b-%Y (%H:%M:%S)\")\r\n\t\tfor i in range(len(cards)):\r\n\t\t\tjson_body = {'alarm':alarm_list[i], 'status':status_list[i], 'warning':warning_list[i], 'update':timestampStr, 'hostname':self.ip}\r\n\t\t\tserver.update(index='icepap_info', id=self.ip + '_' + str(cards[i]), body={\"doc\":json_body})","def stats(self):","def update():","def update():","def update_stats(self, idx, key):\n\n stats = self.stats\n if not stats.has_key(idx):\n stats[idx] = {}\n if stats[idx].has_key(key):\n stats[idx][key] += 1\n else:\n stats[idx][key] = 1","async def async_update(self):\n data = await nooa.get_data()\n self._state = data[\"0\"][self._unit][\"Scale\"]\n self.filter_attributes(data)","def get_covid_stats_by_county(state, county):\n url = \"https://corona.lmao.ninja/v2/jhucsse/counties/\" + county\n response = requests.get(url)\n data = response.json()\n counties = []\n for res in data:\n if res[\"province\"] == state:\n county1 = res[\"county\"]\n updatedAt = res[\"updatedAt\"]\n stats = res[\"stats\"]\n confirmed = stats[\"confirmed\"]\n deaths = stats[\"deaths\"]\n recovered = stats[\"recovered\"]\n counties.append(\n CountyStats(state, county1, updatedAt, confirmed, deaths, recovered)\n )\n # return CountyStats(state,county,updatedAt,confirmed,deaths,recovered)\n return counties","def update( ):\r\n pass","def _update_on_refresh():\n cities = City.query.all()\n\n #Iterates over all cities in the database and updates their value\n for city in cities:\n metric_resp, imperial_resp = _get_open_weather_requests(city.name)\n\n metric_json = metric_resp.json()\n imperial_json = imperial_resp.json()\n\n city.temp_celsius = int(metric_json[MAIN][TEMPERATURE])\n city.temp_fahrenheit = int(imperial_json[MAIN][TEMPERATURE])\n db.session.commit()","def updateVisits(self):\n self.nVisits += 1","def get_vaccine_stats(self):\n final_response = {}\n dataframe = self.query_api()\n filtered_dataframe = self.filter_state(dataframe, self.state)\n final_response[self.state] = self.get_stats(filtered_dataframe, self.state)\n filtered_dataframe = self.filter_state(dataframe, \"India\")\n final_response[\"India\"] = self.get_stats(filtered_dataframe, \"India\")\n return json.dumps(final_response, indent=2)","def update(self):\n self.data.update()\n for sensor in self.data.daikinskyport.get_sensors(self._index):\n if sensor[\"type\"] == self._type and self._sensor_name == sensor[\"name\"]:\n self._state = sensor[\"value\"]","def update(self):\n self.data_service.update()\n attr = self.data_service.attributes.get(self._json_key)\n self._state = attr[\"soc\"]","def update(self):\n if self.api is None:\n return\n self.api.update()\n\n if self.var_type == 'Time':\n self.var_state = self.api.result['timeObservation']\n return\n result = self.api.result[self.var_type.lower()]\n if self.var_type == 'Sky':\n self.var_state = result['name']\n self.var_icon = get_sky_icon(result['code'])\n elif self.var_type == 'Temperature':\n self.var_state = round(float(result['tc']), 1)\n elif self.var_type == 'Humidity':\n self.var_state = result\n elif self.var_type == 'Wind':\n if self.var_detail == 'Direction':\n self.var_state = round(float(result['wdir']), 1)\n else:\n self.var_state = round(float(result['wspd']), 1)\n elif self.var_type == 'Precipitation':\n self.var_state = round(float(result['sinceOntime']), 1)\n p_type = result['type']\n if p_type == 0:\n self.var_units = 'mm'\n self.var_icon = 'mdi:weather-sunny'\n elif p_type == 1:\n self.var_units = 'mm'\n self.var_icon = 'mdi:weather-rainy'\n elif p_type == 2:\n self.var_units = 'mm'\n self.var_icon = 'mdi:weather-snowy'\n elif p_type == 3:\n self.var_units = 'cm'\n self.var_icon = 'mdi:weather-snowy-rainy'\n elif self.var_type == 'Pressure':\n if self.var_detail == 'Surface':\n self.var_state = round(float(result['surface']), 1)\n else:\n self.var_state = round(float(result['seaLevel']), 1)\n elif self.var_type == 'Lightning':\n if result == '1':\n self.var_state = 'Exist'\n else:\n self.var_state = 'None'","def stats(self):\n pass","def update_count(self):\n count_metrics = self._fetch_count_metrics_and_clear()\n self._logger.info('update_count. count_metrics = %s',\n build_metrics_counter_data(count_metrics))","def update(self):\r\n self._data.update()\r\n if self._data == None:\r\n _Log.error('No data!')\r\n\r\n\r\n expedite = self._data.data['trafficinfo']['evaluation']['expedite']\r\n congested = self._data.data['trafficinfo']['evaluation']['congested']\r\n blocked = self._data.data['trafficinfo']['evaluation']['blocked']\r\n unknown = self._data.data['trafficinfo']['evaluation']['unknown']\r\n description = self._data.data['trafficinfo']['evaluation']['description']\r\n status = self._data.data['trafficinfo']['evaluation']['status']\r\n if status == '0':\r\n traffic_status = '未知'\r\n elif status == '1':\r\n traffic_status = '畅通'\r\n elif status == '2':\r\n traffic_status = '缓行'\r\n elif status == '3':\r\n traffic_status = '拥堵'\r\n elif status == '4':\r\n traffic_status = '超堵'\r\n else:\r\n traffic_status = '无数据'\r\n self._state = traffic_status\r\n\r\n adddict = {\r\n '畅通所占百分比':expedite,\r\n '缓行所占百分比':congested,\r\n '拥堵所占百分比':blocked,\r\n '未知路段所占百分比':unknown,\r\n '道路描述':description,\r\n '路况': self._data.data['trafficinfo']['description'],\r\n '更新时间':datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\r\n self.attributes=adddict","def _notify_update(self, cuds_object):","def update(self):\n if self.account and OPTION.COMET in self.account.options:\n if self.get_conn().get_browser() not in IFRAME_BROWSERS:\n self.game_request.write(OUTPUT_END_TAG)\n self.seconds_played += 1\n self.inactivity += 1\n\n if FLAG.INGESTED in self.flags:\n return\n\n pass","def update_state(self):\n if self._coordinator.data:\n # get consumption value\n value_list = self._coordinator.data['values']\n values = [v['value'] for v in value_list]\n self._state = f\"{sum(values):.2f}\"","def update_usage_stats(self):\n self._usage.increment_usage_stats()","def update(self, terminal_state):\n\t\tself.visits += 1\n\t\tif self.player_just_moved is not None:\n\t\t\tself.wins += terminal_state.get_result(self.player_just_moved)","def vi_fetch_voting_info_from_scb(self):\r\n\r\n # map counties and county codes using 'GET' request\r\n response = requests.get(self.url)\r\n if response.status_code == requests.codes.ok:\r\n try:\r\n data = json.loads(response.text)\r\n for code, county in zip(data['variables'][0]['values'], \\\r\n data['variables'][0]['valueTexts']):\r\n self.counties_codes[code] = county\r\n # self.vi_log_msg(self.counties_codes)\r\n except Exception as e:\r\n self.vi_log_msg('CRITICAL_ERROR : ', str(e), '. Exiting!!')\r\n sys.exit()\r\n else:\r\n self.vi_log_msg('\"GET\" request failed. Received error code:', \\\r\n response.status_code)\r\n\r\n # 'POST' required query (json query) to SCB url & get relevant info\r\n # json_query must state response format as json\r\n response = requests.post(self.url, json=self.json_query)\r\n if response.status_code == requests.codes.ok:\r\n try:\r\n json_response_obj = json.loads(codecs.encode(response.text, \\\r\n 'utf-8'))\r\n\r\n # json_response_obj['data'] is in below format\r\n # {\"key\":[county_code, voting_year],\"values\":\\\r\n # [voting_percentage]}\r\n # Eg: {\"key\":[\"01L\",\"1973\"],\"values\":[\"90.0\"]}\r\n for voting_data in json_response_obj['data']:\r\n county_code = voting_data['key'][0]\r\n voting_year = int(voting_data['key'][1])\r\n voting_percentage = voting_data['values'][0]\r\n # voting_percentage not available\r\n if voting_percentage == '..':\r\n voting_percentage = 0.0\r\n else:\r\n voting_percentage = float(voting_percentage)\r\n # get county name from county code\r\n county_name = self.counties_codes[county_code]\r\n \r\n # map voting information with voting year & county, i.e,\r\n # voting_information[voting_year][county] = \\\r\n # voting_percentage\r\n # Eg: voting_information[1973]['Stockholm county council'] \\\r\n # = 90.0\r\n if voting_year not in self.voting_information.keys():\r\n self.voting_information[voting_year] = {}\r\n self.voting_information[voting_year][county_name] = \\\r\n voting_percentage\r\n except Exception as e:\r\n self.vi_log_msg('CRITICAL_ERROR : ', str(e), '. Exiting!!')\r\n sys.exit()\r\n else:\r\n self.vi_log_msg('\"POST\" request failed. Received error code:', \\\r\n response.status_code)","def update(self):\n self.probe.update()","def update(self):\n self.probe.update()","def update(self):\n self.probe.update()","def update_progress(self, argv):\n data = {}\n arg_types = [{\n \"type\": \"cognitive\",\n \"rating\": argv.c,\n \"description\": argv.cd\n },\n {\n \"type\": \"emotional\",\n \"rating\": argv.e,\n \"description\": argv.ed\n }\n , {\n \"type\": \"physical\",\n \"rating\": argv.p,\n \"description\": argv.pd\n }\n\n ]\n\n for data_type in arg_types:\n if data_type[\"rating\"]:\n if 100 >= int(data_type[\"rating\"]) > 0:\n data[data_type[\"type\"]] = {\n \"rating\": data_type[\"rating\"],\n \"description\": data_type[\"description\"],\n \"sentiment\": self.get_sentiment(data_type[\"description\"])\n }\n else:\n logging.error(\"Invalid Rating, must be 1-10\")\n exit(1)\n today = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M\")\n insert_data = {today: {\"data\": data, \"weather\": Weather.get_weather()}}\n logging.info(\"Updating Progress\")\n self.prog_logs.insert(insert_data)","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update_count(self):\n pass","def update(self):\n if self.api is None:\n return\n self.api.update()\n\n if self.var_type == 'Time':\n self.var_state = self.api.result['timeRelease']\n return\n\n result = self.api.result[self.var_period.lower()]\n if self.var_type == 'Sky':\n sky = result['sky']\n self.var_state = sky['name']\n self.var_icon = get_sky_icon(sky['code'])\n else:\n temp = result['temperature']\n if self.var_detail == 'Max':\n self.var_state = round(float(temp['tmax']), 1)\n else:\n self.var_state = round(float(temp['tmin']), 1)","def update_capital_stats(self):\n short_capital = 0\n long_capital = 0\n\n for pos in (self.active_long_positions + self.active_short_positions):\n\n if pos.order_type == Consts.LONG:\n long_capital += pos.get_current_liquid_capital()\n else:\n short_capital += pos.get_current_liquid_capital()\n\n self.short_capital = short_capital\n self.long_capital = long_capital","def update(self):\n _LOGGER.debug(\"Updating status using the client AC instance...\")\n self.ac.update_status()\n _LOGGER.debug(\"Status updated using the client AC instance\")","def updateVisitStatistics(self, s, a, s_) :\n self.N[s, a, s_] += 1\n self.Ntotal[s, a] += 1\n self.PHat[s, a] = self.N[s, a] / self.Ntotal[s, a]\n self.omega[s, a] = confidenceRadius(self.mdp, self.Ntotal[s, a], self.delta_)","def update(self):\n\n pass","async def update_stats(self):\r\n\r\n\t\twhile True:\r\n\t\t\tlogging.info('Attempting to post server count')\r\n\t\t\ttry:\r\n\t\t\t\tawait self.dblpy.post_server_count()\r\n\t\t\t\tlogging.info(f'Posted server count ({len(self.bot.guilds)})')\r\n\t\t\texcept Exception as e:\r\n\t\t\t\tlogging.exception(f'Failed to post server count\\n{type(e).__name__}: {e}')\r\n\t\t\tawait asyncio.sleep(1800)","def _update(self):\n pass","def refresh_status(self):\n\n pass","def covid_handle(covid_data):\n global areaName, newCasesToday, cumCasesToday, newCasesYesterday, cumDeathsYesterday, newDeathsYesterday\n #Create dictionary for all COVID data from today\n covid_today = covid_data[0]\n #Create dictionary for all COVID data from yesterday\n covid_yesterday = covid_data[1]\n #Assigns the data to the variables\n areaName = covid_today['areaName']\n newCasesToday = covid_today['newCasesByPublishDate']\n cumCasesToday = covid_today['cumCasesByPublishDate']\n newCasesYesterday = covid_yesterday['newCasesByPublishDate']\n cumDeathsYesterday = covid_yesterday['cumDeathsByDeathDate']\n newDeathsYesterday = covid_yesterday['newDeathsByDeathDate']\n return","def printInstHealthStats(old, new):\n\n duty_cycle = computeInstDutyCycle(old, new)\n ops_per_sec = computeInstOpsPerSec(old, new)\n\n # in the case that we cannot get the values from between ads,\n # just print the recent DC stats\n if (duty_cycle is None) or (ops_per_sec is None):\n return printRecentHealthStats(new)\n\n lines = 0\n\n # print the time between ads\n t_old, t_new = computeUpdateTimes(old, new)\n t_old, t_new = [datetime.datetime.fromtimestamp(t) for t in [t_old, t_new]]\n sys.stdout.write('DC status from {0} to {1}:\\n'.format(t_old, t_new))\n lines += 1\n\n # print the stats\n sys.stdout.write('Duty Cycle: {0:.2f}% '.format(duty_cycle))\n sys.stdout.write('Ops/second: {0:.3f}\\n'.format(ops_per_sec))\n lines += 1\n\n sys.stdout.write('\\n')\n lines += 1\n\n return lines","def update_stats(self, datastruct):\n counter = datastruct.counter\n stats_dict = datastruct.compute_stats()\n if counter == 0:\n self.box1.addstr(5, 2, self.STATS_INIT)\n else:\n self.box1.move(2, 1)\n self.box1.clrtobot()\n self.box1.box()\n if datastruct.last_hits == 0:\n self.box1.addstr(5, 2, self.STATS_SECTION0 + str(datastruct.counter))\n self.box1.addstr(8, 2, self.STATS_NOTRAFFIC)\n else:\n self.box1.addstr(5, 2, self.STATS_SECTION0 + str(datastruct.counter))\n self.box1.addstr(8, 2, self.STATS_SECTION1 + str(datastruct.last_hits))\n self.box1.addstr(11, 2, self.STATS_SECTION2)\n for index, (section, hits) in enumerate(stats_dict[\"top_sections\"]):\n self.box1.addstr(13+2*index, 4, str(index + 1) + \".\" + section + \":\" + str(hits))\n self.box1.addstr(20, 2, self.STATS_SECTION3)\n for index, (user, hits) in enumerate(stats_dict[\"top_users\"]):\n self.box1.addstr(22+2*index, 4, str(index + 1) + \".\" + user + \":\" + str(hits))\n self.box1.addstr(29, 2, self.STATS_SECTION4)\n for index, (error, hits) in enumerate(stats_dict[\"errors\"]):\n self.box1.addstr(31+2*index, 4, str(index + 1) + \".\" + error + \":\" + str(hits))\n self.box1.addstr(38, 2, self.STATS_SECTION5 + str(datastruct.last_traffic))\n self._refresh_screen()","def update_status(request=None, key=None):\n status_keys = ('global_stats', 'language_pair_stats', 'group_stats',\n 'user_stats', 'clusters')\n \n # If a key is given, we only update the requested sub status.\n if key:\n status_keys = (key,)\n \n for status_key in status_keys:\n if status_key == 'global_stats':\n STATUS_CACHE[status_key] = _compute_global_stats()\n \n elif status_key == 'language_pair_stats':\n STATUS_CACHE[status_key] = _compute_language_pair_stats()\n \n elif status_key == 'group_stats':\n STATUS_CACHE[status_key] = _compute_group_stats()\n \n elif status_key == 'user_stats':\n # Only show top 25 contributors.\n user_stats = _compute_user_stats()\n STATUS_CACHE[status_key] = user_stats[:25]\n \n if request is not None:\n return HttpResponse('Status updated successfully')","def _update_(self, data):\n # imports\n from intervals import Interval, LinkedIntervalSet\n \n # create a LinkedIntervalSet to store the time-based states for this\n # hero\n states = [Interval(dict((HER_KWD_MAP.get(k, k), d[1][k]) for k in d[1]), d[0]) for d in data]\n self.states = LinkedIntervalSet.from_starts(states)","def update_cid(cid):\n st = time.time()\n count = 0\n for i, g in enumerate(query_to_tuples(\"select distinct group_id from hits_mv where crawl_id = %s\", cid)):\n g = g[0]\n if i == 0:\n log.info(\"processing %s, %s %s\", i, cid, g)\n\n updatehitgroup(g, cid)\n count += 1\n\n execute_sql(\"commit;\")\n\n log.info(\"Updated crawl {0} in {1}. {2} groups processed\".format(\n cid, time.time() - st, count))\n\n return count","def update(self,dt):\n #print self._state\n if self._state == STATE_INACTIVE:\n self._inactive()\n elif self._state == STATE_COUNTDOWN:\n self._countdown()\n elif self._state == STATE_PAUSED:\n self._paused()\n elif self._state == STATE_ACTIVE:\n self._active()\n elif self._state == STATE_RESET:\n self._reset()\n elif self._state == STATE_COMPLETE:\n self._complete()","def update_cnt_map(self,s):\r\n cnts = []\r\n num_grid = self.cnt_map.shape[0]*self.cnt_map.shape[1]\r\n old_coverage =num_grid- self.cnt_map.flatten().tolist().count(0)\r\n for sj in s:\r\n grid_s = self.get_gridState(sj)\r\n self.cnt_map[grid_s[0], grid_s[1]] += 1\r\n cnts.append(self.cnt_map[grid_s[0], grid_s[1]])\r\n\r\n self.map_coverage = num_grid - self.cnt_map.flatten().tolist().count(0)\r\n print(\"Coverage:\",self.map_coverage)\r\n print(\"Change of coverage:\",self.map_coverage-old_coverage)\r\n\r\n return cnts","def update(self, **kwargs):\n self.status = status.parse(status.get(host=self._host, port=self._port))","def report_update():\r\n resources[\"water\"] = resources[\"water\"] - MENU[order][\"ingredients\"][\"water\"]\r\n resources[\"milk\"] = resources[\"milk\"] - MENU[order][\"ingredients\"][\"milk\"]\r\n resources[\"coffee\"] = resources[\"coffee\"] - MENU[order][\"ingredients\"][\"coffee\"]\r\n resources[\"money\"] = resources[\"money\"] + total","def statistics(update_global=True):\n info = {\n \"Q\": 0,\n \"D\": 0,\n \"T\": 0,\n \"R\": 0,\n \"E\": 0,\n \"F\": 0\n }\n\n for task in all_tasks:\n info[task.status] += 1\n\n global status\n if update_global:\n status = info\n else:\n status = {}\n\n return info","def update_data():\n pass","def update_count(self):\n pass # Do nothing","def update(self):\r\n pass","def update_status_bars():\n for status_bar_name in init.game_state.status_bars.keys():\n gradual_status_bar_fluctuation(status_bar_name)","def update_instigator_state(self, state: InstigatorState):","def update_state_occupancy_count(self, obs):\n obs_hash = self.compute_obs_hash(obs)\n matches_previous_obs = self.prev_obs_hash is not None and obs_hash == self.prev_obs_hash\n self.state_occupancy_counts[obs_hash] += 1\n self.prev_obs_hash = obs_hash\n return {\n \"occupancy_count\": self.state_occupancy_counts[obs_hash],\n \"num_unique_states\": len(self.state_occupancy_counts),\n \"matches_previous_obs\": matches_previous_obs\n }","async def _async_update_data(self) -> dict[str, Any]:\n try:\n stats = await self._api.async_get_stats()\n self.server_status = STATUS_RUNNING\n return stats\n except FrigateApiClientError as exc:\n self.server_status = STATUS_ERROR\n raise UpdateFailed from exc","def _update(self, data):\n self.status = data['status']\n self.progress = data['progress']","def audit(self):\n self.ping()","def update(self):\n _LOGGER.debug(\"Updating meals of the day.\")\n self._state = STATE_ONLINE\n self._categories = self.get_meals_of_the_day()","def update_frequencies():\n pass","def update_db_stats(verse_ob):\n\t\t\n\tbook_stats = dict()\n\ttranslation_stats = dict()\n\tsubreddit_stats = dict()\n\t\n\tfor verse in verse_ob.get_verse_data():\n\t\tif verse[0] in book_stats:\n\t\t\tbook_stats[verse[0]] += 1\n\t\telse:\n\t\t\tbook_stats[verse[0]] = 1\n\t\t\n\t\tif verse[3] in translation_stats:\n\t\t\ttranslation_stats[verse[3]] += 1\n\t\telse:\n\t\t\ttranslation_stats[verse[3]] = 1\n\t\t\t\n\t\tif verse[5] in subreddit_stats:\n\t\t\tsubreddit_stats[verse[5]] += 1\n\t\telse:\n\t\t\tsubreddit_stats[verse[5]] = 1\n\t\t\t\n\tupdate_book_stats(book_stats)\n\tupdate_translation_stats(translation_stats)\n\tupdate_subreddit_stats(subreddit_stats)\n\t\n\treturn","def update_stat_file(self):\n logfile = \"../data/{}_stat.json\".format(self.ID)\n statobj = {\n 'hp': self.hp,\n 'max_hp': MAX_TANK_HP,\n 'ammo': self.ammo,\n 'score': self.score,\n 'age': self.age,\n 'alive': not self.is_dead(),\n 'color': TANK_COLORS[self.color],\n }\n if USE_SIMULATOR:\n js.globals.handle_stat(self.ID, json.dumps(statobj))\n else:\n with open(logfile, 'w') as f:\n f.write(json.dumps(statobj))","def _update_basestation_status_indicators(self):\n container = self._basestation_stats_container\n\n # Ports the label number to the first index of the statistic id\n stats_id_port = {1: 0, 2: 1, 3: 4, 4: 5}\n\n for bs in range(2):\n for stats_indicator_id in range(1, 5):\n bs_indicator_id = bs + 1\n label = container.itemAtPosition(bs_indicator_id, stats_indicator_id).widget()\n stats_id = stats_id_port.get(stats_indicator_id)\n temp_set = self._bs_stats[stats_id]\n\n if bs in temp_set:\n # If the status bar for calibration data is handled, have an intermeddiate status\n # else just have red or green.\n if stats_indicator_id == 2:\n label.setStyleSheet(STYLE_BLUE_BACKGROUND)\n label.setToolTip('Calibration data from cache')\n\n calib_confirm = bs in self._bs_stats[stats_id + 1]\n calib_updated = bs in self._bs_stats[stats_id + 2]\n\n if calib_confirm:\n label.setStyleSheet(STYLE_GREEN_BACKGROUND)\n label.setToolTip('Calibration data verified')\n if calib_updated:\n label.setStyleSheet(STYLE_ORANGE_BACKGROUND)\n label.setToolTip('Calibration data updated, the geometry probably needs to be re-estimated')\n else:\n label.setStyleSheet(STYLE_GREEN_BACKGROUND)\n else:\n label.setStyleSheet(STYLE_RED_BACKGROUND)\n label.setToolTip('')","def update_state(self, context):\n pass","def update_statistics(status):\n if not os.path.isfile(CONFIG['stats_file']):\n current_stats = {}\n else:\n current_stats = json.loads(open(CONFIG['stats_file'], 'r').read())\n # current_stats = delete_old_statistics(current_stats)\n\n current_key = int(datetime.datetime.now().strftime('%Y%m%d%H%M'))\n for host, state in ((h['host'], h['status']) for h in status):\n if host not in current_stats:\n current_stats[host] = {}\n\n # get newest entry of host\n newest_state = None, None\n for key, entry in current_stats[host].items():\n if newest_state[0] is None or int(key) > int(newest_state[0]):\n newest_state = key, entry\n if newest_state[1] != state:\n # state has changed. Write it.\n current_stats[host][current_key] = state\n\n # write stats\n open(CONFIG['stats_file'], 'w').write(json.dumps(current_stats))","def overall(update: Update, context: CallbackContext) -> None:\n\n today, _ = get_latest_stats_from_db()\n seven_day, rolling_avg = return_weekly_figure()\n \n logger.info(\"Getting overall stats for \" + str(update.message.chat_id))\n \n text = \\\n (\n \"📊*Overall stats as of \" + today['date'] + \"*\\n\\n\"\n + \"\\t\\t\\t🔢 Overall Total - \" + str('{:,}'.format(today['totalVaccinations']))\n + \"\\n\\n\\t\\t\\t🅿️ Pfizer : \" + str('{:,}'.format(today['pfizer']))\n + \"\\n\\t\\t\\t🅰️ AstraZeneca : \" + str('{:,}'.format(today['astraZeneca']))\n + \"\\n\\t\\t\\tⓂ️ Moderna : \" + str('{:,}'.format(today['moderna']))\n + \"\\n\\t\\t\\t🇯 J&J - \" + str('{:,}'.format(today['jj'])) + \"\\n\\n\"\n + \"*🧑 Total population vaccinated*\\n\\n\"\n + \"\\t\\t\\t🌓 First dose (of a two dose vaccine) - \" + str('{0:.2%}'.format(today['firstDose']/4977400)) + \"\\n\"\n + \"\\t\\t\\t🌓 Single dose vaccine - \" + str('{0:.2%}'.format(today['jj']/4977400)) + \"\\n\"\n + \"\\t\\t\\t🌝 Fully vaccinated - \" + str('{0:.2%}'.format(today['secondDose']/4977400)) + \"\\n\"\n +\"\\n\\n*🧑 12+ population vaccinated*\\n\"\n +\"\\n\\t\\t\\t🌓 First dose (of a two dose vaccine) - \" + str('{0:.2%}'.format(today['firstDose']/4183700))\n +\"\\n\\t\\t\\t🌓 Single dose vaccine - \" + str('{0:.2%}'.format(today['jj']/4183700))\n +\"\\n\\t\\t\\t🌝 Fully vaccinated - \" + str('{0:.2%}'.format(today['secondDose']/4183700)) + \"\\n\"\n + \"\\n📅 *Rolling 7 Day Stats*\\n\" \n + \"\\n\\t\\t\\t📈 Rolling 7 Day Doses - \" + str('{:,}'.format(seven_day))\n + \"\\n\\t\\t\\t💉 Average Daily Doses - \" + str('{:,}'.format(rolling_avg))\n + \"\\n\\n👇* Commands *\"\n + \"\\n\\n\\t\\t\\t/daily - Subscribe for daily updates\"\n + \"\\n\\n\\t\\t\\t/unsubscribe - Unsubscribe from updates\"\n + \"\\n\\n\\t\\t\\t/start - See all commands\"\n )\n\n update.message.reply_markdown(text)","def update_stats(self):\n modEnum = Mod_Enum()\n self.attack = self.baseAttack + self.get_stat(modEnum.MOD_ATTACK)\n self.defense = self.baseDefense + self.get_stat(modEnum.MOD_DEFENSE)\n self.hp[1] = 100 * ( 1 + self.get_stat(modEnum.MOD_HP) )\n self.absorbtion = self.get_stat(modEnum.MOD_ABSORB)\n self.regen = 0.00 + self.get_stat(modEnum.MOD_REGEN)\n self.lifeLeech = 0.00 + self.get_stat(modEnum.MOD_LEECH)\n self.crit = 0.00 + self.get_stat(modEnum.MOD_CRIT)\n self.attackSpeedMultiplier = 1.0 + self.get_stat(modEnum.MOD_ATTACK_SPEED)\n self.moveSpeedMultiplier = 1.0 + self.get_stat(modEnum.MOD_MOVE_SPEED)\n #cap move speed\n if self.moveSpeedMultiplier > 4.0:\n self.moveSpeedMultiplier = 4.0 + 0.25 * (self.moveSpeedMultiplier - 4.0)\n \n self.speed = self.baseSpeed * self.moveSpeedMultiplier","def sync_status_to_vc(status, context):\n conn = self._vc_connection\n conn.vip.health.set_status(status, context)","def get_all_incidents():\n allIncidents = Incident.get_all()\n #allCops = get_all_cops()\n incidents = []\n for i in allIncidents:\n if(\n (i['operations_center']['id'] in allCops) and\n (inicioAmostragem <= i.reporting_date and i.reporting_date <=terminoAmostragem)\n ):\n \n i['operations_center']['id'] = changeCop(i['operations_center']['id'])\n incidents.append(i)\n \n return incidents","def update_status(cls):\n for job in cls.query.filter(cls.finished == False):\n num_hits_left = session.query(BoxHit).filter_by(training_job_id = job.id, outstanding=True).count()\n urls_left = session.query(VideoTrainingURL).filter_by(training_job_id=job.id, processed = False)\n dynamo = DynamoIngestionStatusClient()\n num_urls_left = 0\n for url in urls_left:\n dynamo_url = dynamo.get(url.url)\n if dynamo_url is None or dynamo_url['status'] == 'Failed':\n # will never be processed, so ignore for our purposes\n url.processed = True\n else:\n num_urls_left += 1\n if num_hits_left+num_urls_left == 0:\n job.finished = True\n print '*** Job ID: %s is complete ***' % str(job.id)\n\n print '------------- Stats for Job ID: %s -------------' % str(job.id)\n print 'Total URLs : %i' % VideoTrainingURL.query.filter_by(training_job_id = job.id).count()\n print 'Total HITs : %i' % BoxHit.query.filter_by(training_job_id = job.id).count()\n if not job.finished:\n print 'unprocessed URLs: %i' % num_urls_left\n print 'outstanding HITs: %i\\n' % num_hits_left\n session.flush()","def update(self):","def update(self):","def update(self):","def update(self):\n url = '/weather/summary?version=2&lat={}&lon={}' \\\n .format(self.lat, self.lon)\n self.result = self.api.get(url)['weather']['summary'][0]"],"string":"[\n \"def get_covid_stats_for_all_states():\\n url = \\\"https://corona.lmao.ninja/v2/states/\\\"\\n response = requests.get(url)\\n data = response.json()\\n\\n states = []\\n\\n for state in data:\\n stateName = state[\\\"state\\\"]\\n\\n cases = state[\\\"cases\\\"]\\n todaysCases = state[\\\"todayCases\\\"]\\n deaths = state[\\\"deaths\\\"]\\n todayDeaths = state[\\\"todayDeaths\\\"]\\n recovered = state[\\\"recovered\\\"]\\n activeCases = state[\\\"active\\\"]\\n tests = state[\\\"tests\\\"]\\n casesPerMil = state[\\\"casesPerOneMillion\\\"]\\n deathsPerMil = state[\\\"deathsPerOneMillion\\\"]\\n testsPerMil = state[\\\"testsPerOneMillion\\\"]\\n\\n population = state[\\\"population\\\"]\\n\\n if population != 0:\\n millionsOfPop = population / 1000000.0\\n activeCasesPerMil = activeCases / millionsOfPop\\n color = get_color(activeCasesPerMil)\\n states.append(\\n StateStats(\\n stateName,\\n cases,\\n todaysCases,\\n activeCases,\\n casesPerMil,\\n deaths,\\n todayDeaths,\\n deathsPerMil,\\n recovered,\\n tests,\\n testsPerMil,\\n color,\\n )\\n )\\n else:\\n states.append(\\n StateStats(\\n stateName,\\n cases,\\n todaysCases,\\n activeCases,\\n casesPerMil,\\n deaths,\\n todayDeaths,\\n deathsPerMil,\\n recovered,\\n tests,\\n testsPerMil,\\n )\\n )\\n\\n return states\",\n \"def collect_stat(self):\\n\\n cnstat_dict, ratestat_dict = self.get_cnstat()\\n self.cnstat_dict.update(cnstat_dict)\\n self.ratestat_dict.update(ratestat_dict)\",\n \"def update_server_stats(self):\\n try:\\n aio.run(self.client.execute, 'ANALYZE')\\n except Exception:\\n pass # swallow; CrateDB 4.1.0+ is required to run ANALYZE\",\n \"def update_stats(self):\\n\\n self.raw_data_index = 0\\n start_time = time.time()\\n data_frame = load_data(self.selections)\\n user_stats = get_user_stats(data_frame)\\n\\n self.time_stats_data.config(text=get_time_stats(data_frame))\\n self.station_stats_data.config(text=get_station_stats(data_frame))\\n self.trip_stats_data.config(text=get_trip_duration_stats(data_frame))\\n\\n self.user_stats_data.config(text=user_stats[0])\\n self.gender_stats_data.config(text=user_stats[1])\\n self.age_stats_data.config(text=user_stats[2])\\n self.status.config(\\n text=f\\\"Updated statistics in {round((time.time() - start_time), 2)} seconds. Modify filters using left radio buttons as desired...\\\"\\n )\",\n \"def updatestats(self):\\n result = self.statsfromcounts(self.hypCountByScenario)\\n self.pScenario = result[\\\"p\\\"]\\n self.scenarioEntropy = result[\\\"entropy\\\"]\",\n \"def update(self):\\n stats = self._thread.stats()\\n if self._var_id == CONTAINER_MONITOR_STATUS:\\n self._state = stats.get('status', None)\\n elif self._var_id == CONTAINER_MONITOR_MEMORY_USAGE:\\n self._state = stats.get('memory_usage', None)\\n elif self._var_id == CONTAINER_MONITOR_CPU_PERCENTAGE:\\n self._state = stats.get('cpu_percent', None)\\n if 'cpu' in stats:\\n self._attributes[ATTR_ONLINE_CPUS] = stats['cpu'].get('online_cpus', None)\\n elif self._var_id == CONTAINER_MONITOR_MEMORY_PERCENTAGE:\\n self._state = stats.get('memory_percent', None)\\n # Network\\n elif self._var_id == CONTAINER_MONITOR_NETWORK_UP:\\n self._state = round(stats.get('network_up', None) / 1024.0, PRECISION)\\n elif self._var_id == CONTAINER_MONITOR_NETWORK_DOWN:\\n self._state = round(stats.get('network_down', None) / 1024.0, PRECISION)\",\n \"def get_covid_stats_by_state(state):\\n url = \\\"https://corona.lmao.ninja/v2/states/\\\" + state + \\\"?yesterday=\\\"\\n response = requests.get(url)\\n data = response.json()\\n cases = data[\\\"cases\\\"]\\n todaysCases = data[\\\"todayCases\\\"]\\n deaths = data[\\\"deaths\\\"]\\n todayDeaths = data[\\\"todayDeaths\\\"]\\n recovered = data[\\\"recovered\\\"]\\n activeCases = data[\\\"active\\\"]\\n tests = data[\\\"tests\\\"]\\n casesPerMil = data[\\\"casesPerOneMillion\\\"]\\n deathsPerMil = data[\\\"deathsPerOneMillion\\\"]\\n testsPerMil = data[\\\"testsPerOneMillion\\\"]\\n\\n return StateStats(\\n state,\\n cases,\\n todaysCases,\\n activeCases,\\n casesPerMil,\\n deaths,\\n todayDeaths,\\n deathsPerMil,\\n recovered,\\n tests,\\n testsPerMil,\\n )\",\n \"def update(self):\\n changes = {}\\n for coord in INDICES: # the need for two for loops is necessary\\n if self.chart[coord] == ALIVE and (\\n self.number_of_neighbors(coord) < 2 or self.number_of_neighbors(coord) > 3):\\n changes[coord] = KILL\\n elif self.number_of_neighbors(coord) == 3:\\n changes[coord] = REVIVE\\n for coord in changes.keys(): # because the evolution is discrete\\n if changes[coord] == KILL:\\n self.kill(coord)\\n elif changes[coord] == REVIVE:\\n self.givebirth(coord)\",\n \"def update_data(self):\\n for sai_id_key in self.if_id_map:\\n namespace, sai_id = mibs.split_sai_id_key(sai_id_key)\\n if_idx = mibs.get_index_from_str(self.if_id_map[sai_id_key])\\n counter_table = self.namespace_db_map[namespace].get_all(mibs.COUNTERS_DB, \\\\\\n mibs.counter_table(sai_id))\\n if counter_table is None:\\n counter_table = {}\\n self.if_counters[if_idx] = counter_table\\n\\n\\n self.lag_name_if_name_map, \\\\\\n self.if_name_lag_name_map, \\\\\\n self.oid_lag_name_map, _, _ = Namespace.get_sync_d_from_all_namespace(mibs.init_sync_d_lag_tables, self.db_conn)\\n\\n self.if_range = sorted(list(self.oid_name_map.keys()) + list(self.oid_lag_name_map.keys()))\\n self.if_range = [(i,) for i in self.if_range]\",\n \"def get_cnstat(self):\\n def get_counters(table_id):\\n \\\"\\\"\\\"\\n Get the counters from specific table.\\n \\\"\\\"\\\"\\n fields = [\\\"0\\\"]*BUCKET_NUM\\n\\n for pos, cntr_list in counter_bucket_dict.items():\\n for counter_name in cntr_list:\\n full_table_id = COUNTER_TABLE_PREFIX + table_id\\n counter_data = self.db.get(self.db.COUNTERS_DB, full_table_id, counter_name)\\n if counter_data is None:\\n fields[pos] = STATUS_NA\\n elif fields[pos] != STATUS_NA:\\n fields[pos] = str(int(fields[pos]) + int(counter_data))\\n\\n cntr = NStats._make(fields)\\n return cntr\\n\\n def get_rates(table_id):\\n \\\"\\\"\\\"\\n Get the rates from specific table.\\n \\\"\\\"\\\"\\n fields = [\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\"]\\n for pos, name in enumerate(rates_key_list):\\n full_table_id = RATES_TABLE_PREFIX + table_id\\n counter_data = self.db.get(self.db.COUNTERS_DB, full_table_id, name)\\n if counter_data is None:\\n fields[pos] = STATUS_NA\\n elif fields[pos] != STATUS_NA:\\n fields[pos] = float(counter_data)\\n cntr = RateStats._make(fields)\\n return cntr\\n\\n # Get the info from database\\n counter_port_name_map = self.db.get_all(self.db.COUNTERS_DB, COUNTERS_PORT_NAME_MAP);\\n # Build a dictionary of the stats\\n cnstat_dict = OrderedDict()\\n cnstat_dict['time'] = datetime.datetime.now()\\n ratestat_dict = OrderedDict()\\n if counter_port_name_map is None:\\n return cnstat_dict, ratestat_dict\\n for port in natsorted(counter_port_name_map):\\n port_name = port.split(\\\":\\\")[0]\\n if self.multi_asic.skip_display(constants.PORT_OBJ, port_name):\\n continue\\n cnstat_dict[port] = get_counters(counter_port_name_map[port])\\n ratestat_dict[port] = get_rates(counter_port_name_map[port])\\n return cnstat_dict, ratestat_dict\",\n \"def _update_odi_collection(self, player_id):\\n logging.info('updating odi stats for {}'.format(player_id))\\n url = '{}{}{}'.format(self.base_url, self.odi, player_id)\\n extracted_fields = self._field_extract(url)\\n extracted_fields['_id'] = player_id\\n extracted_fields['serious'] = 'odi'\\n self.db_sync(dataset=extracted_fields, db_name=self.db_name, db_collection=self.odi_collection,\\n db_operation=self.DB_UPDATE_ONE)\",\n \"def compute_stats(self):\\n from vmc.common.oal import osobj\\n d = osobj.get_iface_stats()\\n d.addCallback(self.update_stats)\",\n \"def update(self):\\n\\n self.stats = statistics.get()\\n self.ticker = exchangerates.get_ticker()\",\n \"def update_status(self, server):\\r\\n\\r\\n\\t\\tcards = self.ice.getCardsAlive()\\r\\n\\t\\talarm_list = self.ice.getAlarmStatus()\\r\\n\\t\\tstatus_list = self.ice.getStatus()\\r\\n\\t\\twarning_list = self.ice.getWarnings()\\r\\n\\r\\n\\t\\tdateTimeObj = datetime.now()\\r\\n\\t\\ttimestampStr = dateTimeObj.strftime(\\\"%d-%b-%Y (%H:%M:%S)\\\")\\r\\n\\t\\tfor i in range(len(cards)):\\r\\n\\t\\t\\tjson_body = {'alarm':alarm_list[i], 'status':status_list[i], 'warning':warning_list[i], 'update':timestampStr, 'hostname':self.ip}\\r\\n\\t\\t\\tserver.update(index='icepap_info', id=self.ip + '_' + str(cards[i]), body={\\\"doc\\\":json_body})\",\n \"def stats(self):\",\n \"def update():\",\n \"def update():\",\n \"def update_stats(self, idx, key):\\n\\n stats = self.stats\\n if not stats.has_key(idx):\\n stats[idx] = {}\\n if stats[idx].has_key(key):\\n stats[idx][key] += 1\\n else:\\n stats[idx][key] = 1\",\n \"async def async_update(self):\\n data = await nooa.get_data()\\n self._state = data[\\\"0\\\"][self._unit][\\\"Scale\\\"]\\n self.filter_attributes(data)\",\n \"def get_covid_stats_by_county(state, county):\\n url = \\\"https://corona.lmao.ninja/v2/jhucsse/counties/\\\" + county\\n response = requests.get(url)\\n data = response.json()\\n counties = []\\n for res in data:\\n if res[\\\"province\\\"] == state:\\n county1 = res[\\\"county\\\"]\\n updatedAt = res[\\\"updatedAt\\\"]\\n stats = res[\\\"stats\\\"]\\n confirmed = stats[\\\"confirmed\\\"]\\n deaths = stats[\\\"deaths\\\"]\\n recovered = stats[\\\"recovered\\\"]\\n counties.append(\\n CountyStats(state, county1, updatedAt, confirmed, deaths, recovered)\\n )\\n # return CountyStats(state,county,updatedAt,confirmed,deaths,recovered)\\n return counties\",\n \"def update( ):\\r\\n pass\",\n \"def _update_on_refresh():\\n cities = City.query.all()\\n\\n #Iterates over all cities in the database and updates their value\\n for city in cities:\\n metric_resp, imperial_resp = _get_open_weather_requests(city.name)\\n\\n metric_json = metric_resp.json()\\n imperial_json = imperial_resp.json()\\n\\n city.temp_celsius = int(metric_json[MAIN][TEMPERATURE])\\n city.temp_fahrenheit = int(imperial_json[MAIN][TEMPERATURE])\\n db.session.commit()\",\n \"def updateVisits(self):\\n self.nVisits += 1\",\n \"def get_vaccine_stats(self):\\n final_response = {}\\n dataframe = self.query_api()\\n filtered_dataframe = self.filter_state(dataframe, self.state)\\n final_response[self.state] = self.get_stats(filtered_dataframe, self.state)\\n filtered_dataframe = self.filter_state(dataframe, \\\"India\\\")\\n final_response[\\\"India\\\"] = self.get_stats(filtered_dataframe, \\\"India\\\")\\n return json.dumps(final_response, indent=2)\",\n \"def update(self):\\n self.data.update()\\n for sensor in self.data.daikinskyport.get_sensors(self._index):\\n if sensor[\\\"type\\\"] == self._type and self._sensor_name == sensor[\\\"name\\\"]:\\n self._state = sensor[\\\"value\\\"]\",\n \"def update(self):\\n self.data_service.update()\\n attr = self.data_service.attributes.get(self._json_key)\\n self._state = attr[\\\"soc\\\"]\",\n \"def update(self):\\n if self.api is None:\\n return\\n self.api.update()\\n\\n if self.var_type == 'Time':\\n self.var_state = self.api.result['timeObservation']\\n return\\n result = self.api.result[self.var_type.lower()]\\n if self.var_type == 'Sky':\\n self.var_state = result['name']\\n self.var_icon = get_sky_icon(result['code'])\\n elif self.var_type == 'Temperature':\\n self.var_state = round(float(result['tc']), 1)\\n elif self.var_type == 'Humidity':\\n self.var_state = result\\n elif self.var_type == 'Wind':\\n if self.var_detail == 'Direction':\\n self.var_state = round(float(result['wdir']), 1)\\n else:\\n self.var_state = round(float(result['wspd']), 1)\\n elif self.var_type == 'Precipitation':\\n self.var_state = round(float(result['sinceOntime']), 1)\\n p_type = result['type']\\n if p_type == 0:\\n self.var_units = 'mm'\\n self.var_icon = 'mdi:weather-sunny'\\n elif p_type == 1:\\n self.var_units = 'mm'\\n self.var_icon = 'mdi:weather-rainy'\\n elif p_type == 2:\\n self.var_units = 'mm'\\n self.var_icon = 'mdi:weather-snowy'\\n elif p_type == 3:\\n self.var_units = 'cm'\\n self.var_icon = 'mdi:weather-snowy-rainy'\\n elif self.var_type == 'Pressure':\\n if self.var_detail == 'Surface':\\n self.var_state = round(float(result['surface']), 1)\\n else:\\n self.var_state = round(float(result['seaLevel']), 1)\\n elif self.var_type == 'Lightning':\\n if result == '1':\\n self.var_state = 'Exist'\\n else:\\n self.var_state = 'None'\",\n \"def stats(self):\\n pass\",\n \"def update_count(self):\\n count_metrics = self._fetch_count_metrics_and_clear()\\n self._logger.info('update_count. count_metrics = %s',\\n build_metrics_counter_data(count_metrics))\",\n \"def update(self):\\r\\n self._data.update()\\r\\n if self._data == None:\\r\\n _Log.error('No data!')\\r\\n\\r\\n\\r\\n expedite = self._data.data['trafficinfo']['evaluation']['expedite']\\r\\n congested = self._data.data['trafficinfo']['evaluation']['congested']\\r\\n blocked = self._data.data['trafficinfo']['evaluation']['blocked']\\r\\n unknown = self._data.data['trafficinfo']['evaluation']['unknown']\\r\\n description = self._data.data['trafficinfo']['evaluation']['description']\\r\\n status = self._data.data['trafficinfo']['evaluation']['status']\\r\\n if status == '0':\\r\\n traffic_status = '未知'\\r\\n elif status == '1':\\r\\n traffic_status = '畅通'\\r\\n elif status == '2':\\r\\n traffic_status = '缓行'\\r\\n elif status == '3':\\r\\n traffic_status = '拥堵'\\r\\n elif status == '4':\\r\\n traffic_status = '超堵'\\r\\n else:\\r\\n traffic_status = '无数据'\\r\\n self._state = traffic_status\\r\\n\\r\\n adddict = {\\r\\n '畅通所占百分比':expedite,\\r\\n '缓行所占百分比':congested,\\r\\n '拥堵所占百分比':blocked,\\r\\n '未知路段所占百分比':unknown,\\r\\n '道路描述':description,\\r\\n '路况': self._data.data['trafficinfo']['description'],\\r\\n '更新时间':datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\\r\\n self.attributes=adddict\",\n \"def _notify_update(self, cuds_object):\",\n \"def update(self):\\n if self.account and OPTION.COMET in self.account.options:\\n if self.get_conn().get_browser() not in IFRAME_BROWSERS:\\n self.game_request.write(OUTPUT_END_TAG)\\n self.seconds_played += 1\\n self.inactivity += 1\\n\\n if FLAG.INGESTED in self.flags:\\n return\\n\\n pass\",\n \"def update_state(self):\\n if self._coordinator.data:\\n # get consumption value\\n value_list = self._coordinator.data['values']\\n values = [v['value'] for v in value_list]\\n self._state = f\\\"{sum(values):.2f}\\\"\",\n \"def update_usage_stats(self):\\n self._usage.increment_usage_stats()\",\n \"def update(self, terminal_state):\\n\\t\\tself.visits += 1\\n\\t\\tif self.player_just_moved is not None:\\n\\t\\t\\tself.wins += terminal_state.get_result(self.player_just_moved)\",\n \"def vi_fetch_voting_info_from_scb(self):\\r\\n\\r\\n # map counties and county codes using 'GET' request\\r\\n response = requests.get(self.url)\\r\\n if response.status_code == requests.codes.ok:\\r\\n try:\\r\\n data = json.loads(response.text)\\r\\n for code, county in zip(data['variables'][0]['values'], \\\\\\r\\n data['variables'][0]['valueTexts']):\\r\\n self.counties_codes[code] = county\\r\\n # self.vi_log_msg(self.counties_codes)\\r\\n except Exception as e:\\r\\n self.vi_log_msg('CRITICAL_ERROR : ', str(e), '. Exiting!!')\\r\\n sys.exit()\\r\\n else:\\r\\n self.vi_log_msg('\\\"GET\\\" request failed. Received error code:', \\\\\\r\\n response.status_code)\\r\\n\\r\\n # 'POST' required query (json query) to SCB url & get relevant info\\r\\n # json_query must state response format as json\\r\\n response = requests.post(self.url, json=self.json_query)\\r\\n if response.status_code == requests.codes.ok:\\r\\n try:\\r\\n json_response_obj = json.loads(codecs.encode(response.text, \\\\\\r\\n 'utf-8'))\\r\\n\\r\\n # json_response_obj['data'] is in below format\\r\\n # {\\\"key\\\":[county_code, voting_year],\\\"values\\\":\\\\\\r\\n # [voting_percentage]}\\r\\n # Eg: {\\\"key\\\":[\\\"01L\\\",\\\"1973\\\"],\\\"values\\\":[\\\"90.0\\\"]}\\r\\n for voting_data in json_response_obj['data']:\\r\\n county_code = voting_data['key'][0]\\r\\n voting_year = int(voting_data['key'][1])\\r\\n voting_percentage = voting_data['values'][0]\\r\\n # voting_percentage not available\\r\\n if voting_percentage == '..':\\r\\n voting_percentage = 0.0\\r\\n else:\\r\\n voting_percentage = float(voting_percentage)\\r\\n # get county name from county code\\r\\n county_name = self.counties_codes[county_code]\\r\\n \\r\\n # map voting information with voting year & county, i.e,\\r\\n # voting_information[voting_year][county] = \\\\\\r\\n # voting_percentage\\r\\n # Eg: voting_information[1973]['Stockholm county council'] \\\\\\r\\n # = 90.0\\r\\n if voting_year not in self.voting_information.keys():\\r\\n self.voting_information[voting_year] = {}\\r\\n self.voting_information[voting_year][county_name] = \\\\\\r\\n voting_percentage\\r\\n except Exception as e:\\r\\n self.vi_log_msg('CRITICAL_ERROR : ', str(e), '. Exiting!!')\\r\\n sys.exit()\\r\\n else:\\r\\n self.vi_log_msg('\\\"POST\\\" request failed. Received error code:', \\\\\\r\\n response.status_code)\",\n \"def update(self):\\n self.probe.update()\",\n \"def update(self):\\n self.probe.update()\",\n \"def update(self):\\n self.probe.update()\",\n \"def update_progress(self, argv):\\n data = {}\\n arg_types = [{\\n \\\"type\\\": \\\"cognitive\\\",\\n \\\"rating\\\": argv.c,\\n \\\"description\\\": argv.cd\\n },\\n {\\n \\\"type\\\": \\\"emotional\\\",\\n \\\"rating\\\": argv.e,\\n \\\"description\\\": argv.ed\\n }\\n , {\\n \\\"type\\\": \\\"physical\\\",\\n \\\"rating\\\": argv.p,\\n \\\"description\\\": argv.pd\\n }\\n\\n ]\\n\\n for data_type in arg_types:\\n if data_type[\\\"rating\\\"]:\\n if 100 >= int(data_type[\\\"rating\\\"]) > 0:\\n data[data_type[\\\"type\\\"]] = {\\n \\\"rating\\\": data_type[\\\"rating\\\"],\\n \\\"description\\\": data_type[\\\"description\\\"],\\n \\\"sentiment\\\": self.get_sentiment(data_type[\\\"description\\\"])\\n }\\n else:\\n logging.error(\\\"Invalid Rating, must be 1-10\\\")\\n exit(1)\\n today = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M\\\")\\n insert_data = {today: {\\\"data\\\": data, \\\"weather\\\": Weather.get_weather()}}\\n logging.info(\\\"Updating Progress\\\")\\n self.prog_logs.insert(insert_data)\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update_count(self):\\n pass\",\n \"def update(self):\\n if self.api is None:\\n return\\n self.api.update()\\n\\n if self.var_type == 'Time':\\n self.var_state = self.api.result['timeRelease']\\n return\\n\\n result = self.api.result[self.var_period.lower()]\\n if self.var_type == 'Sky':\\n sky = result['sky']\\n self.var_state = sky['name']\\n self.var_icon = get_sky_icon(sky['code'])\\n else:\\n temp = result['temperature']\\n if self.var_detail == 'Max':\\n self.var_state = round(float(temp['tmax']), 1)\\n else:\\n self.var_state = round(float(temp['tmin']), 1)\",\n \"def update_capital_stats(self):\\n short_capital = 0\\n long_capital = 0\\n\\n for pos in (self.active_long_positions + self.active_short_positions):\\n\\n if pos.order_type == Consts.LONG:\\n long_capital += pos.get_current_liquid_capital()\\n else:\\n short_capital += pos.get_current_liquid_capital()\\n\\n self.short_capital = short_capital\\n self.long_capital = long_capital\",\n \"def update(self):\\n _LOGGER.debug(\\\"Updating status using the client AC instance...\\\")\\n self.ac.update_status()\\n _LOGGER.debug(\\\"Status updated using the client AC instance\\\")\",\n \"def updateVisitStatistics(self, s, a, s_) :\\n self.N[s, a, s_] += 1\\n self.Ntotal[s, a] += 1\\n self.PHat[s, a] = self.N[s, a] / self.Ntotal[s, a]\\n self.omega[s, a] = confidenceRadius(self.mdp, self.Ntotal[s, a], self.delta_)\",\n \"def update(self):\\n\\n pass\",\n \"async def update_stats(self):\\r\\n\\r\\n\\t\\twhile True:\\r\\n\\t\\t\\tlogging.info('Attempting to post server count')\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tawait self.dblpy.post_server_count()\\r\\n\\t\\t\\t\\tlogging.info(f'Posted server count ({len(self.bot.guilds)})')\\r\\n\\t\\t\\texcept Exception as e:\\r\\n\\t\\t\\t\\tlogging.exception(f'Failed to post server count\\\\n{type(e).__name__}: {e}')\\r\\n\\t\\t\\tawait asyncio.sleep(1800)\",\n \"def _update(self):\\n pass\",\n \"def refresh_status(self):\\n\\n pass\",\n \"def covid_handle(covid_data):\\n global areaName, newCasesToday, cumCasesToday, newCasesYesterday, cumDeathsYesterday, newDeathsYesterday\\n #Create dictionary for all COVID data from today\\n covid_today = covid_data[0]\\n #Create dictionary for all COVID data from yesterday\\n covid_yesterday = covid_data[1]\\n #Assigns the data to the variables\\n areaName = covid_today['areaName']\\n newCasesToday = covid_today['newCasesByPublishDate']\\n cumCasesToday = covid_today['cumCasesByPublishDate']\\n newCasesYesterday = covid_yesterday['newCasesByPublishDate']\\n cumDeathsYesterday = covid_yesterday['cumDeathsByDeathDate']\\n newDeathsYesterday = covid_yesterday['newDeathsByDeathDate']\\n return\",\n \"def printInstHealthStats(old, new):\\n\\n duty_cycle = computeInstDutyCycle(old, new)\\n ops_per_sec = computeInstOpsPerSec(old, new)\\n\\n # in the case that we cannot get the values from between ads,\\n # just print the recent DC stats\\n if (duty_cycle is None) or (ops_per_sec is None):\\n return printRecentHealthStats(new)\\n\\n lines = 0\\n\\n # print the time between ads\\n t_old, t_new = computeUpdateTimes(old, new)\\n t_old, t_new = [datetime.datetime.fromtimestamp(t) for t in [t_old, t_new]]\\n sys.stdout.write('DC status from {0} to {1}:\\\\n'.format(t_old, t_new))\\n lines += 1\\n\\n # print the stats\\n sys.stdout.write('Duty Cycle: {0:.2f}% '.format(duty_cycle))\\n sys.stdout.write('Ops/second: {0:.3f}\\\\n'.format(ops_per_sec))\\n lines += 1\\n\\n sys.stdout.write('\\\\n')\\n lines += 1\\n\\n return lines\",\n \"def update_stats(self, datastruct):\\n counter = datastruct.counter\\n stats_dict = datastruct.compute_stats()\\n if counter == 0:\\n self.box1.addstr(5, 2, self.STATS_INIT)\\n else:\\n self.box1.move(2, 1)\\n self.box1.clrtobot()\\n self.box1.box()\\n if datastruct.last_hits == 0:\\n self.box1.addstr(5, 2, self.STATS_SECTION0 + str(datastruct.counter))\\n self.box1.addstr(8, 2, self.STATS_NOTRAFFIC)\\n else:\\n self.box1.addstr(5, 2, self.STATS_SECTION0 + str(datastruct.counter))\\n self.box1.addstr(8, 2, self.STATS_SECTION1 + str(datastruct.last_hits))\\n self.box1.addstr(11, 2, self.STATS_SECTION2)\\n for index, (section, hits) in enumerate(stats_dict[\\\"top_sections\\\"]):\\n self.box1.addstr(13+2*index, 4, str(index + 1) + \\\".\\\" + section + \\\":\\\" + str(hits))\\n self.box1.addstr(20, 2, self.STATS_SECTION3)\\n for index, (user, hits) in enumerate(stats_dict[\\\"top_users\\\"]):\\n self.box1.addstr(22+2*index, 4, str(index + 1) + \\\".\\\" + user + \\\":\\\" + str(hits))\\n self.box1.addstr(29, 2, self.STATS_SECTION4)\\n for index, (error, hits) in enumerate(stats_dict[\\\"errors\\\"]):\\n self.box1.addstr(31+2*index, 4, str(index + 1) + \\\".\\\" + error + \\\":\\\" + str(hits))\\n self.box1.addstr(38, 2, self.STATS_SECTION5 + str(datastruct.last_traffic))\\n self._refresh_screen()\",\n \"def update_status(request=None, key=None):\\n status_keys = ('global_stats', 'language_pair_stats', 'group_stats',\\n 'user_stats', 'clusters')\\n \\n # If a key is given, we only update the requested sub status.\\n if key:\\n status_keys = (key,)\\n \\n for status_key in status_keys:\\n if status_key == 'global_stats':\\n STATUS_CACHE[status_key] = _compute_global_stats()\\n \\n elif status_key == 'language_pair_stats':\\n STATUS_CACHE[status_key] = _compute_language_pair_stats()\\n \\n elif status_key == 'group_stats':\\n STATUS_CACHE[status_key] = _compute_group_stats()\\n \\n elif status_key == 'user_stats':\\n # Only show top 25 contributors.\\n user_stats = _compute_user_stats()\\n STATUS_CACHE[status_key] = user_stats[:25]\\n \\n if request is not None:\\n return HttpResponse('Status updated successfully')\",\n \"def _update_(self, data):\\n # imports\\n from intervals import Interval, LinkedIntervalSet\\n \\n # create a LinkedIntervalSet to store the time-based states for this\\n # hero\\n states = [Interval(dict((HER_KWD_MAP.get(k, k), d[1][k]) for k in d[1]), d[0]) for d in data]\\n self.states = LinkedIntervalSet.from_starts(states)\",\n \"def update_cid(cid):\\n st = time.time()\\n count = 0\\n for i, g in enumerate(query_to_tuples(\\\"select distinct group_id from hits_mv where crawl_id = %s\\\", cid)):\\n g = g[0]\\n if i == 0:\\n log.info(\\\"processing %s, %s %s\\\", i, cid, g)\\n\\n updatehitgroup(g, cid)\\n count += 1\\n\\n execute_sql(\\\"commit;\\\")\\n\\n log.info(\\\"Updated crawl {0} in {1}. {2} groups processed\\\".format(\\n cid, time.time() - st, count))\\n\\n return count\",\n \"def update(self,dt):\\n #print self._state\\n if self._state == STATE_INACTIVE:\\n self._inactive()\\n elif self._state == STATE_COUNTDOWN:\\n self._countdown()\\n elif self._state == STATE_PAUSED:\\n self._paused()\\n elif self._state == STATE_ACTIVE:\\n self._active()\\n elif self._state == STATE_RESET:\\n self._reset()\\n elif self._state == STATE_COMPLETE:\\n self._complete()\",\n \"def update_cnt_map(self,s):\\r\\n cnts = []\\r\\n num_grid = self.cnt_map.shape[0]*self.cnt_map.shape[1]\\r\\n old_coverage =num_grid- self.cnt_map.flatten().tolist().count(0)\\r\\n for sj in s:\\r\\n grid_s = self.get_gridState(sj)\\r\\n self.cnt_map[grid_s[0], grid_s[1]] += 1\\r\\n cnts.append(self.cnt_map[grid_s[0], grid_s[1]])\\r\\n\\r\\n self.map_coverage = num_grid - self.cnt_map.flatten().tolist().count(0)\\r\\n print(\\\"Coverage:\\\",self.map_coverage)\\r\\n print(\\\"Change of coverage:\\\",self.map_coverage-old_coverage)\\r\\n\\r\\n return cnts\",\n \"def update(self, **kwargs):\\n self.status = status.parse(status.get(host=self._host, port=self._port))\",\n \"def report_update():\\r\\n resources[\\\"water\\\"] = resources[\\\"water\\\"] - MENU[order][\\\"ingredients\\\"][\\\"water\\\"]\\r\\n resources[\\\"milk\\\"] = resources[\\\"milk\\\"] - MENU[order][\\\"ingredients\\\"][\\\"milk\\\"]\\r\\n resources[\\\"coffee\\\"] = resources[\\\"coffee\\\"] - MENU[order][\\\"ingredients\\\"][\\\"coffee\\\"]\\r\\n resources[\\\"money\\\"] = resources[\\\"money\\\"] + total\",\n \"def statistics(update_global=True):\\n info = {\\n \\\"Q\\\": 0,\\n \\\"D\\\": 0,\\n \\\"T\\\": 0,\\n \\\"R\\\": 0,\\n \\\"E\\\": 0,\\n \\\"F\\\": 0\\n }\\n\\n for task in all_tasks:\\n info[task.status] += 1\\n\\n global status\\n if update_global:\\n status = info\\n else:\\n status = {}\\n\\n return info\",\n \"def update_data():\\n pass\",\n \"def update_count(self):\\n pass # Do nothing\",\n \"def update(self):\\r\\n pass\",\n \"def update_status_bars():\\n for status_bar_name in init.game_state.status_bars.keys():\\n gradual_status_bar_fluctuation(status_bar_name)\",\n \"def update_instigator_state(self, state: InstigatorState):\",\n \"def update_state_occupancy_count(self, obs):\\n obs_hash = self.compute_obs_hash(obs)\\n matches_previous_obs = self.prev_obs_hash is not None and obs_hash == self.prev_obs_hash\\n self.state_occupancy_counts[obs_hash] += 1\\n self.prev_obs_hash = obs_hash\\n return {\\n \\\"occupancy_count\\\": self.state_occupancy_counts[obs_hash],\\n \\\"num_unique_states\\\": len(self.state_occupancy_counts),\\n \\\"matches_previous_obs\\\": matches_previous_obs\\n }\",\n \"async def _async_update_data(self) -> dict[str, Any]:\\n try:\\n stats = await self._api.async_get_stats()\\n self.server_status = STATUS_RUNNING\\n return stats\\n except FrigateApiClientError as exc:\\n self.server_status = STATUS_ERROR\\n raise UpdateFailed from exc\",\n \"def _update(self, data):\\n self.status = data['status']\\n self.progress = data['progress']\",\n \"def audit(self):\\n self.ping()\",\n \"def update(self):\\n _LOGGER.debug(\\\"Updating meals of the day.\\\")\\n self._state = STATE_ONLINE\\n self._categories = self.get_meals_of_the_day()\",\n \"def update_frequencies():\\n pass\",\n \"def update_db_stats(verse_ob):\\n\\t\\t\\n\\tbook_stats = dict()\\n\\ttranslation_stats = dict()\\n\\tsubreddit_stats = dict()\\n\\t\\n\\tfor verse in verse_ob.get_verse_data():\\n\\t\\tif verse[0] in book_stats:\\n\\t\\t\\tbook_stats[verse[0]] += 1\\n\\t\\telse:\\n\\t\\t\\tbook_stats[verse[0]] = 1\\n\\t\\t\\n\\t\\tif verse[3] in translation_stats:\\n\\t\\t\\ttranslation_stats[verse[3]] += 1\\n\\t\\telse:\\n\\t\\t\\ttranslation_stats[verse[3]] = 1\\n\\t\\t\\t\\n\\t\\tif verse[5] in subreddit_stats:\\n\\t\\t\\tsubreddit_stats[verse[5]] += 1\\n\\t\\telse:\\n\\t\\t\\tsubreddit_stats[verse[5]] = 1\\n\\t\\t\\t\\n\\tupdate_book_stats(book_stats)\\n\\tupdate_translation_stats(translation_stats)\\n\\tupdate_subreddit_stats(subreddit_stats)\\n\\t\\n\\treturn\",\n \"def update_stat_file(self):\\n logfile = \\\"../data/{}_stat.json\\\".format(self.ID)\\n statobj = {\\n 'hp': self.hp,\\n 'max_hp': MAX_TANK_HP,\\n 'ammo': self.ammo,\\n 'score': self.score,\\n 'age': self.age,\\n 'alive': not self.is_dead(),\\n 'color': TANK_COLORS[self.color],\\n }\\n if USE_SIMULATOR:\\n js.globals.handle_stat(self.ID, json.dumps(statobj))\\n else:\\n with open(logfile, 'w') as f:\\n f.write(json.dumps(statobj))\",\n \"def _update_basestation_status_indicators(self):\\n container = self._basestation_stats_container\\n\\n # Ports the label number to the first index of the statistic id\\n stats_id_port = {1: 0, 2: 1, 3: 4, 4: 5}\\n\\n for bs in range(2):\\n for stats_indicator_id in range(1, 5):\\n bs_indicator_id = bs + 1\\n label = container.itemAtPosition(bs_indicator_id, stats_indicator_id).widget()\\n stats_id = stats_id_port.get(stats_indicator_id)\\n temp_set = self._bs_stats[stats_id]\\n\\n if bs in temp_set:\\n # If the status bar for calibration data is handled, have an intermeddiate status\\n # else just have red or green.\\n if stats_indicator_id == 2:\\n label.setStyleSheet(STYLE_BLUE_BACKGROUND)\\n label.setToolTip('Calibration data from cache')\\n\\n calib_confirm = bs in self._bs_stats[stats_id + 1]\\n calib_updated = bs in self._bs_stats[stats_id + 2]\\n\\n if calib_confirm:\\n label.setStyleSheet(STYLE_GREEN_BACKGROUND)\\n label.setToolTip('Calibration data verified')\\n if calib_updated:\\n label.setStyleSheet(STYLE_ORANGE_BACKGROUND)\\n label.setToolTip('Calibration data updated, the geometry probably needs to be re-estimated')\\n else:\\n label.setStyleSheet(STYLE_GREEN_BACKGROUND)\\n else:\\n label.setStyleSheet(STYLE_RED_BACKGROUND)\\n label.setToolTip('')\",\n \"def update_state(self, context):\\n pass\",\n \"def update_statistics(status):\\n if not os.path.isfile(CONFIG['stats_file']):\\n current_stats = {}\\n else:\\n current_stats = json.loads(open(CONFIG['stats_file'], 'r').read())\\n # current_stats = delete_old_statistics(current_stats)\\n\\n current_key = int(datetime.datetime.now().strftime('%Y%m%d%H%M'))\\n for host, state in ((h['host'], h['status']) for h in status):\\n if host not in current_stats:\\n current_stats[host] = {}\\n\\n # get newest entry of host\\n newest_state = None, None\\n for key, entry in current_stats[host].items():\\n if newest_state[0] is None or int(key) > int(newest_state[0]):\\n newest_state = key, entry\\n if newest_state[1] != state:\\n # state has changed. Write it.\\n current_stats[host][current_key] = state\\n\\n # write stats\\n open(CONFIG['stats_file'], 'w').write(json.dumps(current_stats))\",\n \"def overall(update: Update, context: CallbackContext) -> None:\\n\\n today, _ = get_latest_stats_from_db()\\n seven_day, rolling_avg = return_weekly_figure()\\n \\n logger.info(\\\"Getting overall stats for \\\" + str(update.message.chat_id))\\n \\n text = \\\\\\n (\\n \\\"📊*Overall stats as of \\\" + today['date'] + \\\"*\\\\n\\\\n\\\"\\n + \\\"\\\\t\\\\t\\\\t🔢 Overall Total - \\\" + str('{:,}'.format(today['totalVaccinations']))\\n + \\\"\\\\n\\\\n\\\\t\\\\t\\\\t🅿️ Pfizer : \\\" + str('{:,}'.format(today['pfizer']))\\n + \\\"\\\\n\\\\t\\\\t\\\\t🅰️ AstraZeneca : \\\" + str('{:,}'.format(today['astraZeneca']))\\n + \\\"\\\\n\\\\t\\\\t\\\\tⓂ️ Moderna : \\\" + str('{:,}'.format(today['moderna']))\\n + \\\"\\\\n\\\\t\\\\t\\\\t🇯 J&J - \\\" + str('{:,}'.format(today['jj'])) + \\\"\\\\n\\\\n\\\"\\n + \\\"*🧑 Total population vaccinated*\\\\n\\\\n\\\"\\n + \\\"\\\\t\\\\t\\\\t🌓 First dose (of a two dose vaccine) - \\\" + str('{0:.2%}'.format(today['firstDose']/4977400)) + \\\"\\\\n\\\"\\n + \\\"\\\\t\\\\t\\\\t🌓 Single dose vaccine - \\\" + str('{0:.2%}'.format(today['jj']/4977400)) + \\\"\\\\n\\\"\\n + \\\"\\\\t\\\\t\\\\t🌝 Fully vaccinated - \\\" + str('{0:.2%}'.format(today['secondDose']/4977400)) + \\\"\\\\n\\\"\\n +\\\"\\\\n\\\\n*🧑 12+ population vaccinated*\\\\n\\\"\\n +\\\"\\\\n\\\\t\\\\t\\\\t🌓 First dose (of a two dose vaccine) - \\\" + str('{0:.2%}'.format(today['firstDose']/4183700))\\n +\\\"\\\\n\\\\t\\\\t\\\\t🌓 Single dose vaccine - \\\" + str('{0:.2%}'.format(today['jj']/4183700))\\n +\\\"\\\\n\\\\t\\\\t\\\\t🌝 Fully vaccinated - \\\" + str('{0:.2%}'.format(today['secondDose']/4183700)) + \\\"\\\\n\\\"\\n + \\\"\\\\n📅 *Rolling 7 Day Stats*\\\\n\\\" \\n + \\\"\\\\n\\\\t\\\\t\\\\t📈 Rolling 7 Day Doses - \\\" + str('{:,}'.format(seven_day))\\n + \\\"\\\\n\\\\t\\\\t\\\\t💉 Average Daily Doses - \\\" + str('{:,}'.format(rolling_avg))\\n + \\\"\\\\n\\\\n👇* Commands *\\\"\\n + \\\"\\\\n\\\\n\\\\t\\\\t\\\\t/daily - Subscribe for daily updates\\\"\\n + \\\"\\\\n\\\\n\\\\t\\\\t\\\\t/unsubscribe - Unsubscribe from updates\\\"\\n + \\\"\\\\n\\\\n\\\\t\\\\t\\\\t/start - See all commands\\\"\\n )\\n\\n update.message.reply_markdown(text)\",\n \"def update_stats(self):\\n modEnum = Mod_Enum()\\n self.attack = self.baseAttack + self.get_stat(modEnum.MOD_ATTACK)\\n self.defense = self.baseDefense + self.get_stat(modEnum.MOD_DEFENSE)\\n self.hp[1] = 100 * ( 1 + self.get_stat(modEnum.MOD_HP) )\\n self.absorbtion = self.get_stat(modEnum.MOD_ABSORB)\\n self.regen = 0.00 + self.get_stat(modEnum.MOD_REGEN)\\n self.lifeLeech = 0.00 + self.get_stat(modEnum.MOD_LEECH)\\n self.crit = 0.00 + self.get_stat(modEnum.MOD_CRIT)\\n self.attackSpeedMultiplier = 1.0 + self.get_stat(modEnum.MOD_ATTACK_SPEED)\\n self.moveSpeedMultiplier = 1.0 + self.get_stat(modEnum.MOD_MOVE_SPEED)\\n #cap move speed\\n if self.moveSpeedMultiplier > 4.0:\\n self.moveSpeedMultiplier = 4.0 + 0.25 * (self.moveSpeedMultiplier - 4.0)\\n \\n self.speed = self.baseSpeed * self.moveSpeedMultiplier\",\n \"def sync_status_to_vc(status, context):\\n conn = self._vc_connection\\n conn.vip.health.set_status(status, context)\",\n \"def get_all_incidents():\\n allIncidents = Incident.get_all()\\n #allCops = get_all_cops()\\n incidents = []\\n for i in allIncidents:\\n if(\\n (i['operations_center']['id'] in allCops) and\\n (inicioAmostragem <= i.reporting_date and i.reporting_date <=terminoAmostragem)\\n ):\\n \\n i['operations_center']['id'] = changeCop(i['operations_center']['id'])\\n incidents.append(i)\\n \\n return incidents\",\n \"def update_status(cls):\\n for job in cls.query.filter(cls.finished == False):\\n num_hits_left = session.query(BoxHit).filter_by(training_job_id = job.id, outstanding=True).count()\\n urls_left = session.query(VideoTrainingURL).filter_by(training_job_id=job.id, processed = False)\\n dynamo = DynamoIngestionStatusClient()\\n num_urls_left = 0\\n for url in urls_left:\\n dynamo_url = dynamo.get(url.url)\\n if dynamo_url is None or dynamo_url['status'] == 'Failed':\\n # will never be processed, so ignore for our purposes\\n url.processed = True\\n else:\\n num_urls_left += 1\\n if num_hits_left+num_urls_left == 0:\\n job.finished = True\\n print '*** Job ID: %s is complete ***' % str(job.id)\\n\\n print '------------- Stats for Job ID: %s -------------' % str(job.id)\\n print 'Total URLs : %i' % VideoTrainingURL.query.filter_by(training_job_id = job.id).count()\\n print 'Total HITs : %i' % BoxHit.query.filter_by(training_job_id = job.id).count()\\n if not job.finished:\\n print 'unprocessed URLs: %i' % num_urls_left\\n print 'outstanding HITs: %i\\\\n' % num_hits_left\\n session.flush()\",\n \"def update(self):\",\n \"def update(self):\",\n \"def update(self):\",\n \"def update(self):\\n url = '/weather/summary?version=2&lat={}&lon={}' \\\\\\n .format(self.lat, self.lon)\\n self.result = self.api.get(url)['weather']['summary'][0]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5786061","0.57647926","0.5751267","0.5653311","0.5646003","0.5581366","0.5580781","0.55658996","0.5481031","0.5458222","0.54489946","0.5434017","0.54039675","0.5381794","0.5363166","0.5323404","0.5323404","0.52979153","0.52888215","0.5287419","0.5280991","0.52791","0.5275564","0.52455205","0.52390206","0.52325","0.52234674","0.5221336","0.5204652","0.5204392","0.51793647","0.51638407","0.51604927","0.5148257","0.5122029","0.51047856","0.5100307","0.5100307","0.5100307","0.5090881","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50898236","0.50879645","0.5086822","0.5081608","0.5074328","0.5072805","0.50600076","0.5051223","0.50506884","0.5050175","0.5048795","0.50426215","0.50345236","0.5032698","0.5024088","0.5022176","0.5018058","0.5015252","0.50120443","0.5010295","0.50051785","0.5002855","0.4992338","0.499153","0.49872804","0.4985213","0.4980376","0.49703917","0.49684283","0.49595398","0.4956873","0.49546564","0.49532348","0.49519312","0.4950004","0.49496502","0.49393362","0.4935395","0.49347383","0.49294153","0.4927845","0.4927436","0.49244583","0.49244583","0.49244583","0.49240506"],"string":"[\n \"0.5786061\",\n \"0.57647926\",\n \"0.5751267\",\n \"0.5653311\",\n \"0.5646003\",\n \"0.5581366\",\n \"0.5580781\",\n \"0.55658996\",\n \"0.5481031\",\n \"0.5458222\",\n \"0.54489946\",\n \"0.5434017\",\n \"0.54039675\",\n \"0.5381794\",\n \"0.5363166\",\n \"0.5323404\",\n \"0.5323404\",\n \"0.52979153\",\n \"0.52888215\",\n \"0.5287419\",\n \"0.5280991\",\n \"0.52791\",\n \"0.5275564\",\n \"0.52455205\",\n \"0.52390206\",\n \"0.52325\",\n \"0.52234674\",\n \"0.5221336\",\n \"0.5204652\",\n \"0.5204392\",\n \"0.51793647\",\n \"0.51638407\",\n \"0.51604927\",\n \"0.5148257\",\n \"0.5122029\",\n \"0.51047856\",\n \"0.5100307\",\n \"0.5100307\",\n \"0.5100307\",\n \"0.5090881\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50898236\",\n \"0.50879645\",\n \"0.5086822\",\n \"0.5081608\",\n \"0.5074328\",\n \"0.5072805\",\n \"0.50600076\",\n \"0.5051223\",\n \"0.50506884\",\n \"0.5050175\",\n \"0.5048795\",\n \"0.50426215\",\n \"0.50345236\",\n \"0.5032698\",\n \"0.5024088\",\n \"0.5022176\",\n \"0.5018058\",\n \"0.5015252\",\n \"0.50120443\",\n \"0.5010295\",\n \"0.50051785\",\n \"0.5002855\",\n \"0.4992338\",\n \"0.499153\",\n \"0.49872804\",\n \"0.4985213\",\n \"0.4980376\",\n \"0.49703917\",\n \"0.49684283\",\n \"0.49595398\",\n \"0.4956873\",\n \"0.49546564\",\n \"0.49532348\",\n \"0.49519312\",\n \"0.4950004\",\n \"0.49496502\",\n \"0.49393362\",\n \"0.4935395\",\n \"0.49347383\",\n \"0.49294153\",\n \"0.4927845\",\n \"0.4927436\",\n \"0.49244583\",\n \"0.49244583\",\n \"0.49244583\",\n \"0.49240506\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55448335"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":76081,"cells":{"query":{"kind":"string","value":"Returns a random Chuck Norris joke."},"document":{"kind":"string","value":"def chuck_norris_jokes(message):\n\n joke = requests.get(\"https://api.chucknorris.io/jokes/random\").json()\n\n return joke['value']"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_chuck_norris_joke():\n response = requests.get(\"https://api.chucknorris.io/jokes/random\")\n json_data = response.json()\n return json_data[\"value\"]","def get_joke(self):\n if not self.jokes:\n self.__init__()\n index = random.randint(0, len(self.jokes) - 1)\n joke = self.jokes.pop(index)\n return joke","def get_joke():\r\n return pyjokes.get_joke()","def get_joke():\n joke = None\n\n while joke is None:\n service_num = randint(1, NUM_SERVICES)\n joke = load_joke(service_num)\n return joke","async def joke(message):\n return random.choice(jokes)","def telljoke(name):\n with open(\"mudules/jokes/default.txt\") as f:\n lines = f.readlines()\n\n joke_list = []\n for line in lines:\n joke_list.append(line)\n\n # Bug with Discord is causing me to have to do this. Angery\n joke = str(random.choice(joke_list)).replace(\"NEWLINE\", \"\\n\")\n\n # We put the joke in a string to ward off the \\n monster.\n if \"{}\" in joke:\n return (joke.format(name))\n else:\n return (joke)","def chuck():\n joke = get_chuck_norris_joke()\n return render_template(\"chuck.html.j2\", joke=joke)","async def tell_joke(intent: NluIntent):\n _LOGGER.info(\"TellJoke\")\n \n return EndSession(random.choice(jokes))","def randomChestplate():\n return random.choice(CHESTPLATES)","def joke():\n jokerequest = requests.get(\"https://icanhazdadjoke.com/\", headers = {\"Accept\":\"application/json\"})\n jokedata = json.loads(jokerequest.text)\n return jokedata[\"joke\"]","def get_random_motif(dna, k):\n assert (is_dna(dna))\n assert (len(dna) - k + 1 > 0)\n start = randrange(len(dna) - k + 1)\n return dna[start:start + k]","def mock_tweet():\n count = random.randint(70, 140)\n return ''.join([random.choice(string.letters) for i in xrange(count)])","def randj():#could be combined with randik\n return(int(round(random.random()*1)))","def rand_kmer(rng, k_low, k_high=None):\n if k_high is None:\n k_high = k_low\n k_len = rng.randint(k_low, k_high + 1)\n return ''.join([NUCLEOTIDES[x] for x in rng.randint(4, size=k_len)])","def get_word():\n index = random.randrange(3)\n print(index)\n if index == 0:\n return 'HAPPIE'\n elif index == 1:\n return 'PYTHON'\n else:\n return 'COMPUTER'","def get_random_song(self):\n songs = self.get_all_song_names()\n song_name = songs[random.randrange(len(songs))]\n hits = self.get_song_data(song_name=song_name)\n if len(hits) == 0:\n # Just return Oops! I did it again by Britney\n return 'spotify:track:6naxalmIoLFWR0siv8dnQQ'\n else:\n return hits[0].get('spotify_uri')","def randomHelmet():\n return random.choice(HELMETS)","def random_string(k: int) -> str:\n characters = string.ascii_letters + string.digits + ' '\n return ''.join(random.choices(characters, k=k))","def computer_random():\r\n ci = random.sample(range(1,43),5)\r\n return ci","def main():\n joke_util = JokeUtility()\n for i in xrange(7):\n print \"{}. \".format(i + 1) + joke_util.get_joke()","def generate_random_candy() -> Candy:\n contains_nuts = True if randint(0, 1) == 0 else False\n pack_size = randint(1, 5)\n return CremeEggs(contains_nuts, pack_size)","def generate_hks():\n return ''.join((random.choice(string.ascii_letters) for x in range(26)))","def get_random_word(self):\n pass","def get_random_lastname_middleclass ():\n if one_chance_in(8):\n return get_random_lastname_upperclass()\n elif one_chance_in(3):\n return get_random_lastname_simple()\n elif coinflip():\n return get_random_lastname_family()\n else:\n return get_random_lastname_combo()","async def jokowi(ctx):\r\n await ctx.channel.send(random.choice(kutipan_jokowi))","def nickname():\n return jsonify(name=getRandomLine(nickNamesFile))","def get_random_naughty_string():\n return (random.choice(naughty_string_list)).encode('utf-8').decode('utf-8')","def get_random(cls):\n\n\t\tnum = randint(0, 6)\n\n\t\treturn Tetromino(num)","def test_twenty_rounds_joss_for_noncyclers(self):\n seed = 4\n match = axl.Match(\n (axl.FirstByJoss(), axl.AntiCycler()), turns=20, seed=seed\n )\n match.play()\n self.versus_test(\n axl.AntiCycler(), expected_actions=match.result, seed=seed\n )","def random_ticket():\n ts = time.time()\n return \"%s_%s\" % (ts, random_str(6, string.digits))","def __init__(self, _gameBeingPlayed, _charcter):\n self.name = \"random\"\n random.seed(2)\n self.game = _gameBeingPlayed\n self.character = _charcter\n self.neutralCharacter = self.game.neutralCharacter","def computer_generate(self):\n return choice[random.randrange(3)]","def Jokes():\n filename = './story/joke/jokes.json'\n with open(filename, 'r') as f: \n jokes = json.load(f)\n \n keys = jokes.keys()\n random.shuffle(keys)\n for key in keys:\n yield key, jokes[key]","def get_random_song(self):\n return random.choice(self.song_list)","def choose_random(N):\n db = pymongo.MongoClient('localhost',27020).chembldb\n # Get all CHEMBL IDs\n db.molecules.ensure_index('chembl_id')\n chembl_ids = [m['chembl_id'] for m in db.molecules.find().sort('chembl_id')]\n print len(chembl_ids)\n random.seed(201405291515)\n rands = random.sample(chembl_ids, N)\n return(rands)","def getRandomLickTitle():\n wikipedia.set_rate_limiting(True)\n try:\n titles = wikipedia.random(10)\n except wikipedia.exceptions.HTTPTimeoutError as e:\n print(f\"Wikipedia timout exception: {e}\")\n time.sleep(TIMEOUT_BACKOFF)\n main()\n except wikipedia.exceptions.WikipediaException as e:\n print(f\"Wikipedia exception: {e}\")\n sys.exit(1)\n except Exception as e:\n print(f\"Exception while fetching wiki titles: {e}\")\n sys.exit(1)\n\n for title in titles:\n if words.isLick(title):\n return title\n return None","def random_string():\n\n k = random.randint(5, 10)\n return ''.join(random.choices(string.ascii_letters + string.digits, k=k))","def computer_username():\r\n\t#possible username the computer can have\r\n\tusernames = ['bella_123','$lade(99)','BADOO_0!','V1rus**',\t\t\r\n\t\t'Gh0stO_O', '1ce_man','MoneyBa9$','1ucy=_=', 'F1ash~_~',\r\n\t\t'<an9el>','-NeGaT1Ve-', '__M4dCat__','|Re$pEcT0|','-D1ggerR-',\r\n\t\t'k^T3st','n1ce!™']\r\n\trandom.SystemRandom().shuffle(usernames)\t\r\n\tselect_username = ''.join(random.sample(usernames, 1))\t#select a random username\r\n\treturn select_username","async def joke(self, mask, target, args):\n # List of available APIs\n jokes_api = {\n 'icndb': 'http://api.icndb.com/jokes/random?escape=javascript',\n 'yomomma': 'http://api.yomomma.info/',\n }\n\n # Check if there is some subject\n subject = None\n if '<subject>' in args and len(args['<subject>']) > 0:\n # Convert subjects to a single lower case string\n subject_list = [ s.lower() for s in args['<subject>'] ]\n subject = ' '.join(subject_list)\n\n # Choose one API to request\n url = None\n\n if subject == 'chuck norris':\n # Pick one from icndb API\n url = jokes_api['icndb']\n elif subject == 'yo momma':\n # Pick one from yo momma API\n url = jokes_api['yomomma']\n else:\n # Pick a random source\n url = random.choice(list(jokes_api.values()))\n\n try:\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as response:\n response = await response.json(content_type=None)\n\n # There is two different structure possible for the response\n # one has a 'joke' field at the response root\n # the other one the 'joke' field is inside an element called 'value'\n # so we must try both\n if type(response) is dict:\n if 'joke' in response:\n return response['joke']\n elif ('value' in response\n and type(response['value']) is dict\n and 'joke' in response['value']):\n return response['value']['joke']\n\n # No joke? That it is really sad :(\n raise Exception('No joke found')\n\n except Exception as e:\n print(e)\n return 'All work and no play makes Jack a dull boy'","def make_music_rand():\n pass","def get_random_lastname_scottish ():\n name = db.get_database(DB_LAST_GAELIC2).random_pop()\n if not name:\n return get_random_lastname_simple()\n return \"%s%s\" % (random.choice(('Mc', 'Mac')), name)","def chuck(jarvis, s):\n req = requests.get(\"https://api.chucknorris.io/jokes/random\")\n chuck_json = req.json()\n\n chuck_fact = chuck_json[\"value\"]\n jarvis.say(chuck_fact, Fore.RED)","def randomperc(self):\n\n self.jrand += 1\n if (self.jrand >= 55):\n self.jrand = 1\n self.oldrand = advance_random(self.oldrand)\n return self.oldrand[self.jrand]","def _gen_rand_name(n=10):\n # Ensure the name starts with a letter.\n return ''.join([random.choice(LETTER_LIST)]\n + random.choices(CHAR_LIST, k=n-1))","def get_random_manor_name(owner = None):\n if not owner:\n owner = get_random_lastname_upperclass()\n manor_name = \"%s %s\" % (owner, random.choice((\"Hall\", \"Manor\")))\n\n return manor_name","def random_lottery():\n\treturn 0","def get_random_lastname_family ():\n if one_chance_in(3):\n return get_random_lastname_irish ()\n elif coinflip():\n return get_random_lastname_scottish ()\n else:\n return get_random_lastname_nameson()","def pick_random_word():\r\n # open the sowpods dictionary\r\n with open(\"resources/ex30/sowpos.txt\", 'r') as f:\r\n words = f.readlines()\r\n\r\n # generate a random index\r\n # -1 because len(words) is not a valid index into the list `words`\r\n index = random.randint(0, len(words) - 1)\r\n\r\n # print out the word at that index\r\n word = words[index].strip()\r\n return word","def _random_doi():\n return \"10.\" + _random_string(3, 4) + \"/\" + _random_string(5, 10)","def random_username():\n return str(uuid.uuid4().hex.upper())","def random_character(latin_chance=0.6):\n if random.random() < latin_chance:\n return random.choice(LATIN) + random.choice(LATIN)\n else:\n return random.choice(NON_LATIN)","def get_random(self,num):\n return ''.join(sample('abcdefghijklmnopqrstuvwxyz1234567890!',8))","def get_computers_choice():\n choices = ['Rock', 'Paper', 'Scissors']\n choice_index = randint(0, 2)\n choice = choices[choice_index]\n return choice","def random_string() -> str:\n\n k = random.randint(5, 10)\n return ''.join(random.choices(string.ascii_letters + string.digits, k=k))","def get_random_cell(self, who=None):\n\n\t\tcandidates = []\n\t\tcnts = []\n\t\tfor i in self.VARS.CELLS:\n\t\t\tif i != who:\n\t\t\t\tcnts.append(i.count_rules)\n\t\t\t\tfor j in range(i.count_rules):\n\t\t\t\t\tcandidates.append(i)\n\n\t\treturn self.VARS.RNG.sample(candidates, 1)[0]","def random_string():\n return \"\".join(random.choice(string.ascii_letters) for i in range(6))","def get_nick(infraction_id: int, member_id: int) -> str:\n rng = random.Random(str(infraction_id) + str(member_id))\n return rng.choice(STAR_NAMES)","def roll(self):\n return randint(1,6)","def get_random_lastname_irish ():\n name = db.get_database(DB_LAST_GAELIC1).random_pop()\n if not name:\n return get_random_lastname_simple()\n return \"O'%s\" % name","def test_adds_kith_notes(campaign):\n\n npc.commands.create_character.changeling('changeling mann', 'Beast', 'Hunterheart')\n character = campaign.get_character('changeling mann.nwod')\n assert ' Kith Hunterheart (Unarmed attacks deal lethal damage)' in character.read()","def __init__(self, player_id = 0):\n all_players = ['adiumy', 'amanda', 'beastie', 'emule', 'gavroche', 'hexley', 'kiki', 'konqi', 'nolok', 'pidgin', 'puffy', 'sara_the_racer', 'sara_the_wizard', 'suzanne', 'tux', 'wilber', 'xue']\n self.kart = all_players[np.random.choice(len(all_players))]","def random_player(board_state, _):\n moves = list(available_moves(board_state))\n return random.choice(moves)","def get_random_plaintext(self):\n return gmpy.mpz_urandomb(self.rand, self.pk.bits) % self.pk.n","def random_number(length=6):\n return randint(10**(length-1), (10**(length)-1))","def generate_key():\n key = list(Fleissner.default)\n random.shuffle(key)\n done = False\n while not done:\n try:\n Fleissner(key=\"\".join(key))\n done = True\n except:\n random.shuffle(key)\n return \"\".join(key)","def generate_randomkey(length):\n chars = string.letters + string.digits\n return ''.join([choice(chars) for i in range(length)])","def randwalk(number_of_players=4, number_of_pieces=4):\n\n # `ghost_players` is a LUDOpy specific way to specify the number of\n # players. So, if we want 2 players, the code below will generate a list:\n #\n # [3, 2, 1, 0]\n #\n # and slice it so it omits players 2 and 3.\n #\n # [3, 2, 1, 0][:2] == [3, 2]\n\n g = ludopy.Game(\n ghost_players=list(reversed(range(0, 4)))[:-number_of_players],\n number_of_pieces=number_of_pieces\n )\n there_is_a_winner = False\n\n while not there_is_a_winner:\n (dice, move_pieces, player_pieces, enemy_pieces, player_is_a_winner,\n there_is_a_winner), player_i = g.get_observation()\n\n if len(move_pieces):\n piece_to_move = \\\n move_pieces[np.random.randint(0, len(move_pieces))]\n else:\n piece_to_move = -1\n\n _, _, _, _, _, there_is_a_winner = g.answer_observation(piece_to_move)\n\n return g","def career():\r\n cursor.execute('SELECT name FROM careers order by RANDOM() limit 1;')\r\n return cursor.fetchone()[0]","def randomKmers(dna, k):\n kmers = []\n for seq in dna:\n n = len(seq)\n i = random.randint(0, n-k)\n kmer = seq[i:i+k]\n kmers.append( kmer)\n return kmers","def generate_RME():\n RME = [\"ogre\", \"goblin\", \"gnoll\", \"orc\", \"personal injury lawyer\"]\n monster = random.choice(RME)\n return monster","def get_random_lastname_lowerclass ():\n if one_chance_in(5):\n return get_random_lastname_combo()\n elif one_chance_in(3):\n return get_random_lastname_family()\n else:\n return get_random_lastname_simple()","def random_replicate_name(len=12):\n out = random.choices('abcdefghijklmnopqrtuvwxyzABCDEFGHIJKLMNOPQRTUVWXYZ0123456789', k=len)\n return ''.join(out)","def triplet():\n ends = digraphs + list(consonants)\n spaces = [ends, list(vowels), ends]\n bit = \"\".join([random.sample(x, 1)[0] for x in spaces])\n if random.randint(0, 1) == 1:\n bit = bit.title()\n return bit","def rand_string():\n out = ''\n for _ in range(24):\n out += choice(ascii_letters)\n return out","def single_temp() -> str:\n return '36.' + str(random.randint(1, 5))","def get_random_chord_type(self) -> str:\n i = random.randint(0, len(self._chord_types) - 1)\n return self._chord_types[i]","def random_die():\n return randrange(1, 6)","def jump(underwater=False):\n random.choice(JUMPS_UW if underwater else JUMPS).play()","def random_name(size=6):\r\n chars = string.ascii_uppercase + string.digits\r\n return 'test-' + ''.join(random.choice(chars) for x in range(size))","def generate_novel_prefix(self):\n return self.tree.generate_novel_prefix(self.random)","def random():\n return constant(1)","def random_v_random(n=1):\n p1_strategy = strategies.RandomStrategy()\n p2_strategy = strategies.RandomStrategy()\n p1 = player.Player('X', p1_strategy)\n p2 = player.Player('O', p2_strategy)\n board = tictactoe.Board()\n game = rl_game.Game(p1, p2, board)\n game.play_one()","def die_roll():\n roll = random.randint(1,6)\n return roll","def get_random_lastname_simple ():\n return db_random_pop_default(DB_LAST_SIMPLE, \"Doe\")","def rolldie():\n return int(random.random()*6)+1 # or use randrange()","def getRandomCentroids(data_points, k):\n return random.sample(data_points, k)","def test_twenty_rounds_joss_for_cyclers(self):\n seed = 4\n match = axl.Match(\n (axl.FirstByJoss(), axl.Alternator()), turns=20, seed=seed\n )\n match.play()\n self.versus_test(\n axl.Alternator(), expected_actions=match.result, seed=seed\n )","def gen_randomkey(length):\n chars = string.letters + string.digits + string.punctuation\n return ''.join([choice(chars) for _ in xrange(int(str(length)))])","def random_number() -> int:\r\n return random.randint(1, 3)","def generate_random_key(self):\n self.key = ''.join(choice(ascii_letters + digits) for i in range(300))","def rand(self):\n raise NotImplementedError(\"Not implemented yet.\")","def random_name_maker():\n new_out = ''\n for i in range(10):\n random_letter_or_number = random.randint(1, 2)\n if random_letter_or_number is 1:\n new_out += random_letter(letters)\n if random_letter_or_number is 2:\n new_out += str(random.randint(0, 9))\n if new_out not in names_generated: # it's unique\n names_generated.append(new_out)\n return new_out","def random_number():\n return random.randint(0, 9999)","def _rollOneDie(self):\n return random.randint(1, 6)","def spinWheel():\n\tt = random.randrange(8)\n\tif t == 7:\n\t\treturn \"00\"\n\treturn str(t)","def generate_username():\n return ''.join(choice(ascii_letters + digits) for _ in range(15))","def tubeid():\n return binascii.hexlify(os.urandom(12))","def get_random_emoji():\n return (random.choice(get_emoji_list())).encode('utf-8').decode('utf-8')","def pickSecretNumber(): \n return random.randrange(1, 11)","def random_character(self, script):\n if script in self.script_characters['Script'].values:\n\n script_index = list(self.script_characters['Script'].values).index(script)\n\n character_set = list(self.script_characters['Characters'][script_index].decode(\"utf-8\"))\n\n # selecting random character from all characters within script\n characters_in_script = len(character_set)\n character = character_set[np.random.randint(0, characters_in_script)]\n\n # TODO find a more elegant solution to double width characters\n # to deal with hanzi characters being twice the width of other unicode characters, simply delete half of\n # them\n # if script == 'hanzi':\n # if np.random.randint(0,2) > 0:\n # character = ''\n\n # print(character)\n\n return character\n\n raise ValueError('unsupported script')"],"string":"[\n \"def get_chuck_norris_joke():\\n response = requests.get(\\\"https://api.chucknorris.io/jokes/random\\\")\\n json_data = response.json()\\n return json_data[\\\"value\\\"]\",\n \"def get_joke(self):\\n if not self.jokes:\\n self.__init__()\\n index = random.randint(0, len(self.jokes) - 1)\\n joke = self.jokes.pop(index)\\n return joke\",\n \"def get_joke():\\r\\n return pyjokes.get_joke()\",\n \"def get_joke():\\n joke = None\\n\\n while joke is None:\\n service_num = randint(1, NUM_SERVICES)\\n joke = load_joke(service_num)\\n return joke\",\n \"async def joke(message):\\n return random.choice(jokes)\",\n \"def telljoke(name):\\n with open(\\\"mudules/jokes/default.txt\\\") as f:\\n lines = f.readlines()\\n\\n joke_list = []\\n for line in lines:\\n joke_list.append(line)\\n\\n # Bug with Discord is causing me to have to do this. Angery\\n joke = str(random.choice(joke_list)).replace(\\\"NEWLINE\\\", \\\"\\\\n\\\")\\n\\n # We put the joke in a string to ward off the \\\\n monster.\\n if \\\"{}\\\" in joke:\\n return (joke.format(name))\\n else:\\n return (joke)\",\n \"def chuck():\\n joke = get_chuck_norris_joke()\\n return render_template(\\\"chuck.html.j2\\\", joke=joke)\",\n \"async def tell_joke(intent: NluIntent):\\n _LOGGER.info(\\\"TellJoke\\\")\\n \\n return EndSession(random.choice(jokes))\",\n \"def randomChestplate():\\n return random.choice(CHESTPLATES)\",\n \"def joke():\\n jokerequest = requests.get(\\\"https://icanhazdadjoke.com/\\\", headers = {\\\"Accept\\\":\\\"application/json\\\"})\\n jokedata = json.loads(jokerequest.text)\\n return jokedata[\\\"joke\\\"]\",\n \"def get_random_motif(dna, k):\\n assert (is_dna(dna))\\n assert (len(dna) - k + 1 > 0)\\n start = randrange(len(dna) - k + 1)\\n return dna[start:start + k]\",\n \"def mock_tweet():\\n count = random.randint(70, 140)\\n return ''.join([random.choice(string.letters) for i in xrange(count)])\",\n \"def randj():#could be combined with randik\\n return(int(round(random.random()*1)))\",\n \"def rand_kmer(rng, k_low, k_high=None):\\n if k_high is None:\\n k_high = k_low\\n k_len = rng.randint(k_low, k_high + 1)\\n return ''.join([NUCLEOTIDES[x] for x in rng.randint(4, size=k_len)])\",\n \"def get_word():\\n index = random.randrange(3)\\n print(index)\\n if index == 0:\\n return 'HAPPIE'\\n elif index == 1:\\n return 'PYTHON'\\n else:\\n return 'COMPUTER'\",\n \"def get_random_song(self):\\n songs = self.get_all_song_names()\\n song_name = songs[random.randrange(len(songs))]\\n hits = self.get_song_data(song_name=song_name)\\n if len(hits) == 0:\\n # Just return Oops! I did it again by Britney\\n return 'spotify:track:6naxalmIoLFWR0siv8dnQQ'\\n else:\\n return hits[0].get('spotify_uri')\",\n \"def randomHelmet():\\n return random.choice(HELMETS)\",\n \"def random_string(k: int) -> str:\\n characters = string.ascii_letters + string.digits + ' '\\n return ''.join(random.choices(characters, k=k))\",\n \"def computer_random():\\r\\n ci = random.sample(range(1,43),5)\\r\\n return ci\",\n \"def main():\\n joke_util = JokeUtility()\\n for i in xrange(7):\\n print \\\"{}. \\\".format(i + 1) + joke_util.get_joke()\",\n \"def generate_random_candy() -> Candy:\\n contains_nuts = True if randint(0, 1) == 0 else False\\n pack_size = randint(1, 5)\\n return CremeEggs(contains_nuts, pack_size)\",\n \"def generate_hks():\\n return ''.join((random.choice(string.ascii_letters) for x in range(26)))\",\n \"def get_random_word(self):\\n pass\",\n \"def get_random_lastname_middleclass ():\\n if one_chance_in(8):\\n return get_random_lastname_upperclass()\\n elif one_chance_in(3):\\n return get_random_lastname_simple()\\n elif coinflip():\\n return get_random_lastname_family()\\n else:\\n return get_random_lastname_combo()\",\n \"async def jokowi(ctx):\\r\\n await ctx.channel.send(random.choice(kutipan_jokowi))\",\n \"def nickname():\\n return jsonify(name=getRandomLine(nickNamesFile))\",\n \"def get_random_naughty_string():\\n return (random.choice(naughty_string_list)).encode('utf-8').decode('utf-8')\",\n \"def get_random(cls):\\n\\n\\t\\tnum = randint(0, 6)\\n\\n\\t\\treturn Tetromino(num)\",\n \"def test_twenty_rounds_joss_for_noncyclers(self):\\n seed = 4\\n match = axl.Match(\\n (axl.FirstByJoss(), axl.AntiCycler()), turns=20, seed=seed\\n )\\n match.play()\\n self.versus_test(\\n axl.AntiCycler(), expected_actions=match.result, seed=seed\\n )\",\n \"def random_ticket():\\n ts = time.time()\\n return \\\"%s_%s\\\" % (ts, random_str(6, string.digits))\",\n \"def __init__(self, _gameBeingPlayed, _charcter):\\n self.name = \\\"random\\\"\\n random.seed(2)\\n self.game = _gameBeingPlayed\\n self.character = _charcter\\n self.neutralCharacter = self.game.neutralCharacter\",\n \"def computer_generate(self):\\n return choice[random.randrange(3)]\",\n \"def Jokes():\\n filename = './story/joke/jokes.json'\\n with open(filename, 'r') as f: \\n jokes = json.load(f)\\n \\n keys = jokes.keys()\\n random.shuffle(keys)\\n for key in keys:\\n yield key, jokes[key]\",\n \"def get_random_song(self):\\n return random.choice(self.song_list)\",\n \"def choose_random(N):\\n db = pymongo.MongoClient('localhost',27020).chembldb\\n # Get all CHEMBL IDs\\n db.molecules.ensure_index('chembl_id')\\n chembl_ids = [m['chembl_id'] for m in db.molecules.find().sort('chembl_id')]\\n print len(chembl_ids)\\n random.seed(201405291515)\\n rands = random.sample(chembl_ids, N)\\n return(rands)\",\n \"def getRandomLickTitle():\\n wikipedia.set_rate_limiting(True)\\n try:\\n titles = wikipedia.random(10)\\n except wikipedia.exceptions.HTTPTimeoutError as e:\\n print(f\\\"Wikipedia timout exception: {e}\\\")\\n time.sleep(TIMEOUT_BACKOFF)\\n main()\\n except wikipedia.exceptions.WikipediaException as e:\\n print(f\\\"Wikipedia exception: {e}\\\")\\n sys.exit(1)\\n except Exception as e:\\n print(f\\\"Exception while fetching wiki titles: {e}\\\")\\n sys.exit(1)\\n\\n for title in titles:\\n if words.isLick(title):\\n return title\\n return None\",\n \"def random_string():\\n\\n k = random.randint(5, 10)\\n return ''.join(random.choices(string.ascii_letters + string.digits, k=k))\",\n \"def computer_username():\\r\\n\\t#possible username the computer can have\\r\\n\\tusernames = ['bella_123','$lade(99)','BADOO_0!','V1rus**',\\t\\t\\r\\n\\t\\t'Gh0stO_O', '1ce_man','MoneyBa9$','1ucy=_=', 'F1ash~_~',\\r\\n\\t\\t'<an9el>','-NeGaT1Ve-', '__M4dCat__','|Re$pEcT0|','-D1ggerR-',\\r\\n\\t\\t'k^T3st','n1ce!™']\\r\\n\\trandom.SystemRandom().shuffle(usernames)\\t\\r\\n\\tselect_username = ''.join(random.sample(usernames, 1))\\t#select a random username\\r\\n\\treturn select_username\",\n \"async def joke(self, mask, target, args):\\n # List of available APIs\\n jokes_api = {\\n 'icndb': 'http://api.icndb.com/jokes/random?escape=javascript',\\n 'yomomma': 'http://api.yomomma.info/',\\n }\\n\\n # Check if there is some subject\\n subject = None\\n if '<subject>' in args and len(args['<subject>']) > 0:\\n # Convert subjects to a single lower case string\\n subject_list = [ s.lower() for s in args['<subject>'] ]\\n subject = ' '.join(subject_list)\\n\\n # Choose one API to request\\n url = None\\n\\n if subject == 'chuck norris':\\n # Pick one from icndb API\\n url = jokes_api['icndb']\\n elif subject == 'yo momma':\\n # Pick one from yo momma API\\n url = jokes_api['yomomma']\\n else:\\n # Pick a random source\\n url = random.choice(list(jokes_api.values()))\\n\\n try:\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as response:\\n response = await response.json(content_type=None)\\n\\n # There is two different structure possible for the response\\n # one has a 'joke' field at the response root\\n # the other one the 'joke' field is inside an element called 'value'\\n # so we must try both\\n if type(response) is dict:\\n if 'joke' in response:\\n return response['joke']\\n elif ('value' in response\\n and type(response['value']) is dict\\n and 'joke' in response['value']):\\n return response['value']['joke']\\n\\n # No joke? That it is really sad :(\\n raise Exception('No joke found')\\n\\n except Exception as e:\\n print(e)\\n return 'All work and no play makes Jack a dull boy'\",\n \"def make_music_rand():\\n pass\",\n \"def get_random_lastname_scottish ():\\n name = db.get_database(DB_LAST_GAELIC2).random_pop()\\n if not name:\\n return get_random_lastname_simple()\\n return \\\"%s%s\\\" % (random.choice(('Mc', 'Mac')), name)\",\n \"def chuck(jarvis, s):\\n req = requests.get(\\\"https://api.chucknorris.io/jokes/random\\\")\\n chuck_json = req.json()\\n\\n chuck_fact = chuck_json[\\\"value\\\"]\\n jarvis.say(chuck_fact, Fore.RED)\",\n \"def randomperc(self):\\n\\n self.jrand += 1\\n if (self.jrand >= 55):\\n self.jrand = 1\\n self.oldrand = advance_random(self.oldrand)\\n return self.oldrand[self.jrand]\",\n \"def _gen_rand_name(n=10):\\n # Ensure the name starts with a letter.\\n return ''.join([random.choice(LETTER_LIST)]\\n + random.choices(CHAR_LIST, k=n-1))\",\n \"def get_random_manor_name(owner = None):\\n if not owner:\\n owner = get_random_lastname_upperclass()\\n manor_name = \\\"%s %s\\\" % (owner, random.choice((\\\"Hall\\\", \\\"Manor\\\")))\\n\\n return manor_name\",\n \"def random_lottery():\\n\\treturn 0\",\n \"def get_random_lastname_family ():\\n if one_chance_in(3):\\n return get_random_lastname_irish ()\\n elif coinflip():\\n return get_random_lastname_scottish ()\\n else:\\n return get_random_lastname_nameson()\",\n \"def pick_random_word():\\r\\n # open the sowpods dictionary\\r\\n with open(\\\"resources/ex30/sowpos.txt\\\", 'r') as f:\\r\\n words = f.readlines()\\r\\n\\r\\n # generate a random index\\r\\n # -1 because len(words) is not a valid index into the list `words`\\r\\n index = random.randint(0, len(words) - 1)\\r\\n\\r\\n # print out the word at that index\\r\\n word = words[index].strip()\\r\\n return word\",\n \"def _random_doi():\\n return \\\"10.\\\" + _random_string(3, 4) + \\\"/\\\" + _random_string(5, 10)\",\n \"def random_username():\\n return str(uuid.uuid4().hex.upper())\",\n \"def random_character(latin_chance=0.6):\\n if random.random() < latin_chance:\\n return random.choice(LATIN) + random.choice(LATIN)\\n else:\\n return random.choice(NON_LATIN)\",\n \"def get_random(self,num):\\n return ''.join(sample('abcdefghijklmnopqrstuvwxyz1234567890!',8))\",\n \"def get_computers_choice():\\n choices = ['Rock', 'Paper', 'Scissors']\\n choice_index = randint(0, 2)\\n choice = choices[choice_index]\\n return choice\",\n \"def random_string() -> str:\\n\\n k = random.randint(5, 10)\\n return ''.join(random.choices(string.ascii_letters + string.digits, k=k))\",\n \"def get_random_cell(self, who=None):\\n\\n\\t\\tcandidates = []\\n\\t\\tcnts = []\\n\\t\\tfor i in self.VARS.CELLS:\\n\\t\\t\\tif i != who:\\n\\t\\t\\t\\tcnts.append(i.count_rules)\\n\\t\\t\\t\\tfor j in range(i.count_rules):\\n\\t\\t\\t\\t\\tcandidates.append(i)\\n\\n\\t\\treturn self.VARS.RNG.sample(candidates, 1)[0]\",\n \"def random_string():\\n return \\\"\\\".join(random.choice(string.ascii_letters) for i in range(6))\",\n \"def get_nick(infraction_id: int, member_id: int) -> str:\\n rng = random.Random(str(infraction_id) + str(member_id))\\n return rng.choice(STAR_NAMES)\",\n \"def roll(self):\\n return randint(1,6)\",\n \"def get_random_lastname_irish ():\\n name = db.get_database(DB_LAST_GAELIC1).random_pop()\\n if not name:\\n return get_random_lastname_simple()\\n return \\\"O'%s\\\" % name\",\n \"def test_adds_kith_notes(campaign):\\n\\n npc.commands.create_character.changeling('changeling mann', 'Beast', 'Hunterheart')\\n character = campaign.get_character('changeling mann.nwod')\\n assert ' Kith Hunterheart (Unarmed attacks deal lethal damage)' in character.read()\",\n \"def __init__(self, player_id = 0):\\n all_players = ['adiumy', 'amanda', 'beastie', 'emule', 'gavroche', 'hexley', 'kiki', 'konqi', 'nolok', 'pidgin', 'puffy', 'sara_the_racer', 'sara_the_wizard', 'suzanne', 'tux', 'wilber', 'xue']\\n self.kart = all_players[np.random.choice(len(all_players))]\",\n \"def random_player(board_state, _):\\n moves = list(available_moves(board_state))\\n return random.choice(moves)\",\n \"def get_random_plaintext(self):\\n return gmpy.mpz_urandomb(self.rand, self.pk.bits) % self.pk.n\",\n \"def random_number(length=6):\\n return randint(10**(length-1), (10**(length)-1))\",\n \"def generate_key():\\n key = list(Fleissner.default)\\n random.shuffle(key)\\n done = False\\n while not done:\\n try:\\n Fleissner(key=\\\"\\\".join(key))\\n done = True\\n except:\\n random.shuffle(key)\\n return \\\"\\\".join(key)\",\n \"def generate_randomkey(length):\\n chars = string.letters + string.digits\\n return ''.join([choice(chars) for i in range(length)])\",\n \"def randwalk(number_of_players=4, number_of_pieces=4):\\n\\n # `ghost_players` is a LUDOpy specific way to specify the number of\\n # players. So, if we want 2 players, the code below will generate a list:\\n #\\n # [3, 2, 1, 0]\\n #\\n # and slice it so it omits players 2 and 3.\\n #\\n # [3, 2, 1, 0][:2] == [3, 2]\\n\\n g = ludopy.Game(\\n ghost_players=list(reversed(range(0, 4)))[:-number_of_players],\\n number_of_pieces=number_of_pieces\\n )\\n there_is_a_winner = False\\n\\n while not there_is_a_winner:\\n (dice, move_pieces, player_pieces, enemy_pieces, player_is_a_winner,\\n there_is_a_winner), player_i = g.get_observation()\\n\\n if len(move_pieces):\\n piece_to_move = \\\\\\n move_pieces[np.random.randint(0, len(move_pieces))]\\n else:\\n piece_to_move = -1\\n\\n _, _, _, _, _, there_is_a_winner = g.answer_observation(piece_to_move)\\n\\n return g\",\n \"def career():\\r\\n cursor.execute('SELECT name FROM careers order by RANDOM() limit 1;')\\r\\n return cursor.fetchone()[0]\",\n \"def randomKmers(dna, k):\\n kmers = []\\n for seq in dna:\\n n = len(seq)\\n i = random.randint(0, n-k)\\n kmer = seq[i:i+k]\\n kmers.append( kmer)\\n return kmers\",\n \"def generate_RME():\\n RME = [\\\"ogre\\\", \\\"goblin\\\", \\\"gnoll\\\", \\\"orc\\\", \\\"personal injury lawyer\\\"]\\n monster = random.choice(RME)\\n return monster\",\n \"def get_random_lastname_lowerclass ():\\n if one_chance_in(5):\\n return get_random_lastname_combo()\\n elif one_chance_in(3):\\n return get_random_lastname_family()\\n else:\\n return get_random_lastname_simple()\",\n \"def random_replicate_name(len=12):\\n out = random.choices('abcdefghijklmnopqrtuvwxyzABCDEFGHIJKLMNOPQRTUVWXYZ0123456789', k=len)\\n return ''.join(out)\",\n \"def triplet():\\n ends = digraphs + list(consonants)\\n spaces = [ends, list(vowels), ends]\\n bit = \\\"\\\".join([random.sample(x, 1)[0] for x in spaces])\\n if random.randint(0, 1) == 1:\\n bit = bit.title()\\n return bit\",\n \"def rand_string():\\n out = ''\\n for _ in range(24):\\n out += choice(ascii_letters)\\n return out\",\n \"def single_temp() -> str:\\n return '36.' + str(random.randint(1, 5))\",\n \"def get_random_chord_type(self) -> str:\\n i = random.randint(0, len(self._chord_types) - 1)\\n return self._chord_types[i]\",\n \"def random_die():\\n return randrange(1, 6)\",\n \"def jump(underwater=False):\\n random.choice(JUMPS_UW if underwater else JUMPS).play()\",\n \"def random_name(size=6):\\r\\n chars = string.ascii_uppercase + string.digits\\r\\n return 'test-' + ''.join(random.choice(chars) for x in range(size))\",\n \"def generate_novel_prefix(self):\\n return self.tree.generate_novel_prefix(self.random)\",\n \"def random():\\n return constant(1)\",\n \"def random_v_random(n=1):\\n p1_strategy = strategies.RandomStrategy()\\n p2_strategy = strategies.RandomStrategy()\\n p1 = player.Player('X', p1_strategy)\\n p2 = player.Player('O', p2_strategy)\\n board = tictactoe.Board()\\n game = rl_game.Game(p1, p2, board)\\n game.play_one()\",\n \"def die_roll():\\n roll = random.randint(1,6)\\n return roll\",\n \"def get_random_lastname_simple ():\\n return db_random_pop_default(DB_LAST_SIMPLE, \\\"Doe\\\")\",\n \"def rolldie():\\n return int(random.random()*6)+1 # or use randrange()\",\n \"def getRandomCentroids(data_points, k):\\n return random.sample(data_points, k)\",\n \"def test_twenty_rounds_joss_for_cyclers(self):\\n seed = 4\\n match = axl.Match(\\n (axl.FirstByJoss(), axl.Alternator()), turns=20, seed=seed\\n )\\n match.play()\\n self.versus_test(\\n axl.Alternator(), expected_actions=match.result, seed=seed\\n )\",\n \"def gen_randomkey(length):\\n chars = string.letters + string.digits + string.punctuation\\n return ''.join([choice(chars) for _ in xrange(int(str(length)))])\",\n \"def random_number() -> int:\\r\\n return random.randint(1, 3)\",\n \"def generate_random_key(self):\\n self.key = ''.join(choice(ascii_letters + digits) for i in range(300))\",\n \"def rand(self):\\n raise NotImplementedError(\\\"Not implemented yet.\\\")\",\n \"def random_name_maker():\\n new_out = ''\\n for i in range(10):\\n random_letter_or_number = random.randint(1, 2)\\n if random_letter_or_number is 1:\\n new_out += random_letter(letters)\\n if random_letter_or_number is 2:\\n new_out += str(random.randint(0, 9))\\n if new_out not in names_generated: # it's unique\\n names_generated.append(new_out)\\n return new_out\",\n \"def random_number():\\n return random.randint(0, 9999)\",\n \"def _rollOneDie(self):\\n return random.randint(1, 6)\",\n \"def spinWheel():\\n\\tt = random.randrange(8)\\n\\tif t == 7:\\n\\t\\treturn \\\"00\\\"\\n\\treturn str(t)\",\n \"def generate_username():\\n return ''.join(choice(ascii_letters + digits) for _ in range(15))\",\n \"def tubeid():\\n return binascii.hexlify(os.urandom(12))\",\n \"def get_random_emoji():\\n return (random.choice(get_emoji_list())).encode('utf-8').decode('utf-8')\",\n \"def pickSecretNumber(): \\n return random.randrange(1, 11)\",\n \"def random_character(self, script):\\n if script in self.script_characters['Script'].values:\\n\\n script_index = list(self.script_characters['Script'].values).index(script)\\n\\n character_set = list(self.script_characters['Characters'][script_index].decode(\\\"utf-8\\\"))\\n\\n # selecting random character from all characters within script\\n characters_in_script = len(character_set)\\n character = character_set[np.random.randint(0, characters_in_script)]\\n\\n # TODO find a more elegant solution to double width characters\\n # to deal with hanzi characters being twice the width of other unicode characters, simply delete half of\\n # them\\n # if script == 'hanzi':\\n # if np.random.randint(0,2) > 0:\\n # character = ''\\n\\n # print(character)\\n\\n return character\\n\\n raise ValueError('unsupported script')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7100957","0.6707431","0.6292626","0.62484074","0.6244774","0.62309253","0.5957998","0.56890154","0.56367815","0.5604061","0.5515048","0.5499996","0.54988563","0.54531413","0.5436678","0.5425449","0.5397241","0.53819555","0.537299","0.5371237","0.53581554","0.53371197","0.5302013","0.5298162","0.5280704","0.5266929","0.5261555","0.5255174","0.52537584","0.52293456","0.52129906","0.5181989","0.5152293","0.51368713","0.5132757","0.51243305","0.5123825","0.51118386","0.5106271","0.5104747","0.50817275","0.50772685","0.50708866","0.5067042","0.5061044","0.5059948","0.5052217","0.5048998","0.50480616","0.5038409","0.5023564","0.50153625","0.5011786","0.5010876","0.49952403","0.49945676","0.4993638","0.4993197","0.499225","0.4991102","0.49832514","0.495513","0.49524346","0.4936365","0.49341494","0.49178603","0.49178433","0.49123707","0.491198","0.4911024","0.4901329","0.4898837","0.4897482","0.48875296","0.488451","0.488309","0.48822752","0.48804852","0.48800498","0.48781446","0.4878105","0.4875814","0.48751172","0.48746127","0.4873506","0.48709637","0.48692778","0.48664984","0.48647115","0.486254","0.48620185","0.48612466","0.48547068","0.48487344","0.48458984","0.48431468","0.48413488","0.4839411","0.48391548","0.48383322"],"string":"[\n \"0.7100957\",\n \"0.6707431\",\n \"0.6292626\",\n \"0.62484074\",\n \"0.6244774\",\n \"0.62309253\",\n \"0.5957998\",\n \"0.56890154\",\n \"0.56367815\",\n \"0.5604061\",\n \"0.5515048\",\n \"0.5499996\",\n \"0.54988563\",\n \"0.54531413\",\n \"0.5436678\",\n \"0.5425449\",\n \"0.5397241\",\n \"0.53819555\",\n \"0.537299\",\n \"0.5371237\",\n \"0.53581554\",\n \"0.53371197\",\n \"0.5302013\",\n \"0.5298162\",\n \"0.5280704\",\n \"0.5266929\",\n \"0.5261555\",\n \"0.5255174\",\n \"0.52537584\",\n \"0.52293456\",\n \"0.52129906\",\n \"0.5181989\",\n \"0.5152293\",\n \"0.51368713\",\n \"0.5132757\",\n \"0.51243305\",\n \"0.5123825\",\n \"0.51118386\",\n \"0.5106271\",\n \"0.5104747\",\n \"0.50817275\",\n \"0.50772685\",\n \"0.50708866\",\n \"0.5067042\",\n \"0.5061044\",\n \"0.5059948\",\n \"0.5052217\",\n \"0.5048998\",\n \"0.50480616\",\n \"0.5038409\",\n \"0.5023564\",\n \"0.50153625\",\n \"0.5011786\",\n \"0.5010876\",\n \"0.49952403\",\n \"0.49945676\",\n \"0.4993638\",\n \"0.4993197\",\n \"0.499225\",\n \"0.4991102\",\n \"0.49832514\",\n \"0.495513\",\n \"0.49524346\",\n \"0.4936365\",\n \"0.49341494\",\n \"0.49178603\",\n \"0.49178433\",\n \"0.49123707\",\n \"0.491198\",\n \"0.4911024\",\n \"0.4901329\",\n \"0.4898837\",\n \"0.4897482\",\n \"0.48875296\",\n \"0.488451\",\n \"0.488309\",\n \"0.48822752\",\n \"0.48804852\",\n \"0.48800498\",\n \"0.48781446\",\n \"0.4878105\",\n \"0.4875814\",\n \"0.48751172\",\n \"0.48746127\",\n \"0.4873506\",\n \"0.48709637\",\n \"0.48692778\",\n \"0.48664984\",\n \"0.48647115\",\n \"0.486254\",\n \"0.48620185\",\n \"0.48612466\",\n \"0.48547068\",\n \"0.48487344\",\n \"0.48458984\",\n \"0.48431468\",\n \"0.48413488\",\n \"0.4839411\",\n \"0.48391548\",\n \"0.48383322\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61729395"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":76082,"cells":{"query":{"kind":"string","value":"Returns a random bit of advice."},"document":{"kind":"string","value":"def random_advice(message):\n advice = requests.get(\"https://api.adviceslip.com/advice\").json()['slip']['advice']\n\n return advice"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def random_test(self):\r\n return 1","def random_test(self):\r\n return 1","def randomHelmet():\n return random.choice(HELMETS)","def randomMethod(self):\n return random.random()","def RandomAgentProgram(actions):\n return lambda percept: random.choice(actions)","def RandomAgentProgram(actions):\n return lambda percept: random.choice(actions)","def choose_random_action(self):\r\n return Action.HIT if random.random() <= 0.5 else Action.STICK","def randomAction():\n return np.random.randint(0, POSSIBLE_ACTIONS)","def random(self):\r\n return random.randint(1, 4)","def random():\n return constant(1)","def random_agent(self, state):\n\t\trndint = random.randint\n\t\treturn self.state[state][rndint(0, len(self.state[state]))]","def get_random_excuse():\n return excuses[random.randint(1, len(excuses) - 1)]","def _choose_action(self):\n return random.randint(0,self.num_bandits-1)","def rand(self):\n raise NotImplementedError","def sample(self, action):\n selector = random.random()\n return 1 if selector <= self.pay_offs[action] else 0","async def random_why(self):\r\n data_response = await self.http.endpoint(\"why\")\r\n return result.TextResult(data_response, target=\"why\")","def random_importance_function():\n return random()","def getRandom(self) -> int:","def getRandom(self) -> int:","def random_legal_move():\n return random.choice(legal_moves())","def act(self, observation, testing=False):\n if testing:\n dist = self.learner.get_target_policy(observation)\n else:\n dist = self.learner.get_behaviour_policy(observation)\n return np.random.choice(len(dist), 1, p=dist)[0]","def rand(self):\n raise NotImplementedError(\"Not implemented yet.\")","def random_attk_int(self):\n attk_random = random.randint(1, 2)\n return attk_random","def __call__(self, num_actions):\n return np.random.choice(num_actions)","def __call__(self):\n return random.choice(self.fakers)","def i_rand_a():\n return i_random() % 95 + 32","def beatRandom(yourAgent):\n\n print(\"\")\n try:\n r = RandomPlayer()\n p = yourAgent()\n game = Board(r, p, 7, 7)\n output_b = game.copy()\n winner, move_history, termination = game.play_isolation(time_limit=1000, print_moves=True)\n print(\"\\n\", winner, \" has won. Reason: \", termination)\n # Uncomment to see game\n # print game_as_text(winner, move_history, termination, output_b)\n except NotImplementedError:\n print('CustomPlayer Test: Not Implemented')\n except:\n print('CustomPlayer Test: ERROR OCCURRED')\n print(traceback.format_exc())\n \n print()","def chooseAction(self, gameState):\n actions = gameState.getLegalActions(self.index)\n\n ''' \n You should change this in your own agent.\n '''\n\n return random.choice(actions)","def sample_action(self, state):\n # YOUR CODE HERE\n \n action = np.random.choice(1)\n \n \n return action","def diceroll(self, mess, args):\n return random.randint(1, 6)","def attack(self):\n return random.randint(self.max_damage//2, self.max_damage)","def somebells():\n return random.randint(100, 500)","def get_random_action():\n # Define an array containing the available actions for the UAV\n # in the final work, takeoff and land must be added\n action_list = ['left', 'right', 'forward', 'backward', 'stop', 'descend']\n # Choose a random action within the array\n #action_index = STDrandom.randint(0, len(action_list) - 1)\n # forward,backward,left,right, stop and land\n probability_descend = 0.25\n probability = (1 - probability_descend)/ (len(action_list) -1)\n action_probability = [probability, probability, probability, probability, probability, probability_descend]\n action = np.random.choice(action_list, 1, p=action_probability)[0]\n #action_index = STDrandom.randint(0, 10)\n #action = action_list[action_index]\n\n return action","def chance_hit():\r\n rand_num = random.randint(1, 14)\r\n if rand_num >= random.randint(1, 5):\r\n hit = 1\r\n else:\r\n hit = 0\r\n return hit","def attack(self):\n return random.randint(0, self.attack_strength)","def whoGoesFirst(self):\n\t\treturn random.randint(1, 2)","def gen_random_fightID():\n pass","def act(self):\n return np.random.randint(-1, 2)","def challenge() : \n\treturn [random.randint(1,9) for i in range(5)]","def random():\r\n return R.NextDouble()","def random(self):\n return self._randomize()","def sample_from_concept(self):\n return random.choice(self.active_concept.extension)","def sample(self):\n return gc.rand_state.choice(self.domain)","def _random_function(self, random_state):\n return random_state.rand","def getStatusMessage():\n\n now = datetime.datetime.now()\n hour = now.hour\n mood = Sentience.getPrimaryMood()\n exp_mood = Sentience.getExposedPositivity()\n\n random.seed((time.time()//86400*86400))\n\n #sleeping\n if not (9 <= hour < 21) and (mood <= 0.5 or not 7 <= hour < 23):\n if exp_mood < -0.1:\n return random.choice([\n \"bleh\",\n \"not sleeping well\",\n \"why's chat so noisy\",\n \"can't sleep\",\n \"do not disturb pls thx\",\n ])\n\n if mood < 0:\n return random.choice([\n \"crying myself to sleep rn\",\n \":(\",\n \"had a nightmare\",\n \"can't sleep\",\n \"._.\"\n ])\n\n return random.choice([\n \"zzz...\",\n \"sweet dreams\",\n \"good night\",\n \"sleeping...\",\n \"having some rest\"\n ])\n\n if Sentience.isExposedPositivityOverloaded():\n return random.choice([\n \"i'm done\",\n \"too much\"\n \"goodbye\",\n \"tired\",\n \"need rest\",\n ])\n\n #happy\n if mood >= 0.7:\n return random.choice([\n \":D\",\n \"great day\",\n \"happy happy\",\n \"hehe\",\n \"good times\",\n \"yay\",\n \"what's up\",\n \"happiness\",\n \"nice day\",\n ])\n #moody-ish\n if mood >= 0.4:\n return random.choice([\n \"hmm\",\n \"yeet\",\n \"bleh\",\n \"oh\",\n \"moody rn\",\n \"nothing\"\n ])\n #more moody\n if mood >= -0.3:\n return random.choice([\n \"moody rn\",\n \"not happy\",\n \"i'm fine.\",\n \"bleh\",\n \"._.\",\n \":(\",\n ])\n #very unhappy\n return random.choice([\n \"sad\",\n \"cries\",\n \"roar\",\n \":_(\",\n \">:(\",\n \"mad\",\n \"angry\",\n \"I'M FINE.\",\n \"bleh\",\n \"no\",\n ])","def getAction(self, state):\n # Pick Action\n legalActions = self.getLegalActions(state)\n action = None\n \"*** YOUR CODE HERE ***\"\n # util.raiseNotDefined()\n if random.random() < self.epsilon:\n action = random.choice(legalActions)\n else:\n action = self.getPolicy(state)\n return action","def rand(self):\n return self.State.rand()","def random_die():\n return randrange(1, 6)","def crit_ai(crit):\n if crit['type'] == 'crawler':\n # Crawlers move at random.\n return random.choice(['left','right','up','down'])\n #if crit['type'] == 'bullet':\n # return crit['dir']\n return None","def maybe(self):\n return random.getrandbits(1)","def get_lucky(self):\n lucky_animal = random.choice(self.adoption_pool)\n return self.finish_successful_adoption(lucky_animal)","def getRandom(self):\n return random.choice(self.data)","def __call__(self, state):\n if random.random() > self._epsilon:\n return self._max_policy(state)\n return random.choice(np.arange(self._action_size))","def testrandom(self):\n for i in range(100):\n AmuletAbility()","def decision():\n return random.random() > 0.5","def _get_random_returns(self): \n return self.asset_process.distrib.random()","def attack(self):\n \n half_max_damage = int(self.max_damage) // 2\n random_value = randint(half_max_damage, int(self.max_damage))\n\n return random_value","def choose_random_action(env):\n return env.action_space.sample()","def DoRandomAction(self, gameState: TekkenGameState):\n actionRNG = random.randint(1, 100)\n # Anything generated above this number, the bot chooses to poke\n POKE_CAP = 50\n DASH_CAP = 35\n DUCK_CAP = 20\n SIDESTEP_CAP = 10\n WALK_CAP = 5\n\n TARGET_DISTANCE = 2000.0 # 2.00\n\n # Ensure we dont do nothing for twice in a row\n if self.last_rand_action_was_nth:\n actionRNG += SIDESTEP_CAP\n self.last_rand_action_was_nth = False\n\n # Try to poke if the last action was spent getting\n # into range for pokes\n if self.last_asked_poke:\n actionRNG += POKE_CAP\n\n if actionRNG >= POKE_CAP:\n # Not in range, dash towards\n if TARGET_DISTANCE < gameState.GetDist():\n self.DashTowardsTargetDist(TARGET_DISTANCE, gameState)\n self.last_asked_poke = not self.last_asked_poke\n else:\n self.RandomPoke()\n self.last_asked_poke = False\n elif actionRNG >= DASH_CAP:\n self.DashTowardsTargetDist(TARGET_DISTANCE, gameState)\n elif actionRNG >= DUCK_CAP:\n # duck for a few frames\n self.botCommands.BlockLowFull(random.randint(8, 12))\n elif actionRNG >= SIDESTEP_CAP:\n # Pick between SS up or down\n if (random.randint(0, 1) == 0):\n self.botCommands.SidestepUp()\n else:\n self.botCommands.SidestepDown()\n elif actionRNG >= WALK_CAP:\n self.WalkTowardsTargetDist(TARGET_DISTANCE, gameState)\n else:\n self.last_rand_action_was_nth = True\n\n self.tick_till_next_rand = 0","def should_pay_attention(self):\n return random.randint(1,100) > self.wander","def computer_random():\r\n ci = random.sample(range(1,43),5)\r\n return ci","def create_challenge():\n\treturn os.urandom(12)","def p_banner():\n return random.choice([banner, banner_two, banner_three, banner_four, banner_five])","def base_pick():\n\n rnd = generate_random(2, 15)\n return rnd","def get_random(self):\n return random.choice(self.proxies)","def get_action(self, state):\n return random.choice(state.get_legal_actions(self.index))","def get_random_word(self):\n pass","def decision():\n return random.choice(['GoToNormal','GoToSleep'])","def get_random_phrase():\n return random.choices(PHRASES, WEIGHTS, k=1)[0]","def sample(self, s):\n rng = np.random.default_rng()\n return rng.choice(np.arange(self.n_actions), p=self.eval(s))","def getRandomEvent(p = 0.5):\n if random.random() < p: return 1\n else: return 0","def get_random_gestures(_):\n random_seed = random.getrandbits(32)\n gesture = 'monkey,%s' % str(random_seed)\n return [gesture]","def get_advice():\n json_response = random_adviceslip()\n advice = parse_advice(json_response=json_response)\n return advice","def act(self):\n return np.random.randint(self.k)","def pickSecretNumber(): \n return random.randrange(1, 11)","def get_randomness(request, election):\n return {\n \"randomness\" : base64.b64encode(os.urandom(32)).decode('utf-8')\n }","def single_introduction(end):\n return [random.randint(0,end)]","def Thunder(robot):\n robot_return = Random_Actuation.myopic(\"Thunder\",robot,0.5,20) # with a %20 chance myopic will be triggered\n robot_return = Random_Actuation.hobbler(\"Thunder\",robot,0.5,20) # with a %20 change hobbler will be triggered\n return robot_return","def chooseAction(self, gameState):\n actions = gameState.getLegalActions(self.index)\n\n '''\n You should change this in your own agent.\n '''\n\n return random.choice(actions)","def chooseAction(self, gameState):\n actions = gameState.getLegalActions(self.index)\n\n '''\n You should change this in your own agent.\n '''\n\n return random.choice(actions)","def goals():\n rand_nmr = random.random()\n if rand_nmr < 0.5:\n return 1\n elif rand_nmr < 0.8:\n return 2\n elif rand_nmr < 0.97:\n return 3\n else:\n return 4","def chooseAction(self,state):\r\n #generate float btwn 0-1\r\n choice = random.random()\r\n feat = self.feat_funct(state)\r\n #choose according to that number\r\n if choice > self.epsilon:\r\n return(self.maxQ(feat)[1])\r\n else:\r\n #choose randomly\r\n return(self.actions[random.randrange(0,len(self.actions))])","def __get_function(self):\n return random.choice(self.FUNCTIONS)","def random_operation():\r\n operation = random.choice([\"add\",\"subtract\",\"multiply\",\"divide\"])\r\n return operation","def random(self, random_mode):\n resp = yield from self.command('random {}'.format(random_mode))\n return True","def choose_random_action(all_actions: int) -> int:\n return np.random.randint(all_actions)","def acquisition_function_random(gp_reward_model: BasicGPRewardModel) -> int:\n return np.random.randint(0, len(gp_reward_model.candidate_queries))","def totem_random():\n random_head()\n random_head()\n random_head()","def random_gene(self):\n size = random.randint(1,50)\n gene = \"\"\n for i in range(0,size,1):\n gene+=random.choice(self.instructions)\n return gene","async def tapir(self):\n tapir_list = self.config.get('tapirs', [])\n tapir = tapir_list[random.randrange(len(tapir_list))]\n try:\n await self.bot.say(tapir)\n except:\n await self.bot.whisper(tapir)","def make_rand_task():\n rand_type = all_tasks.keys()[random.randint(0, len(all_tasks.keys()) - 1)]\n rand_hit = all_tasks[rand_type][random.randint(0, len(all_tasks[rand_type]) - 1)]\n\n if rand_hit['type'] == 'img':\n rand_hit['img_src'] = get_rand_img()\n\n return rand_hit","def randomLeggings():\n return random.choice(LEGGINGS)","def random_lottery():\n\treturn 0","def get_word():\n index = random.randrange(3)\n print(index)\n if index == 0:\n return 'HAPPIE'\n elif index == 1:\n return 'PYTHON'\n else:\n return 'COMPUTER'","def random_head():\n x = random.randint(1,3)\n if x==1: \n head_hearteyes()\n elif x==2:\n head_surprised()\n else:\n head_plain()","def confused(self, rand):\n return rand > 0","def get_random_inspirational_quote(self):\n return random.choice(self.inspirational_quotes)","def get_user_input(self, game, hand, message, allowed_actions):\n if random.random() < 0.5:\n return 'hit'\n else:\n return 'stand'","def randomly_pick_recipe(cls):\n return random.choice(cls._recipes)","def get_random(self):\n return self._get_random()"],"string":"[\n \"def random_test(self):\\r\\n return 1\",\n \"def random_test(self):\\r\\n return 1\",\n \"def randomHelmet():\\n return random.choice(HELMETS)\",\n \"def randomMethod(self):\\n return random.random()\",\n \"def RandomAgentProgram(actions):\\n return lambda percept: random.choice(actions)\",\n \"def RandomAgentProgram(actions):\\n return lambda percept: random.choice(actions)\",\n \"def choose_random_action(self):\\r\\n return Action.HIT if random.random() <= 0.5 else Action.STICK\",\n \"def randomAction():\\n return np.random.randint(0, POSSIBLE_ACTIONS)\",\n \"def random(self):\\r\\n return random.randint(1, 4)\",\n \"def random():\\n return constant(1)\",\n \"def random_agent(self, state):\\n\\t\\trndint = random.randint\\n\\t\\treturn self.state[state][rndint(0, len(self.state[state]))]\",\n \"def get_random_excuse():\\n return excuses[random.randint(1, len(excuses) - 1)]\",\n \"def _choose_action(self):\\n return random.randint(0,self.num_bandits-1)\",\n \"def rand(self):\\n raise NotImplementedError\",\n \"def sample(self, action):\\n selector = random.random()\\n return 1 if selector <= self.pay_offs[action] else 0\",\n \"async def random_why(self):\\r\\n data_response = await self.http.endpoint(\\\"why\\\")\\r\\n return result.TextResult(data_response, target=\\\"why\\\")\",\n \"def random_importance_function():\\n return random()\",\n \"def getRandom(self) -> int:\",\n \"def getRandom(self) -> int:\",\n \"def random_legal_move():\\n return random.choice(legal_moves())\",\n \"def act(self, observation, testing=False):\\n if testing:\\n dist = self.learner.get_target_policy(observation)\\n else:\\n dist = self.learner.get_behaviour_policy(observation)\\n return np.random.choice(len(dist), 1, p=dist)[0]\",\n \"def rand(self):\\n raise NotImplementedError(\\\"Not implemented yet.\\\")\",\n \"def random_attk_int(self):\\n attk_random = random.randint(1, 2)\\n return attk_random\",\n \"def __call__(self, num_actions):\\n return np.random.choice(num_actions)\",\n \"def __call__(self):\\n return random.choice(self.fakers)\",\n \"def i_rand_a():\\n return i_random() % 95 + 32\",\n \"def beatRandom(yourAgent):\\n\\n print(\\\"\\\")\\n try:\\n r = RandomPlayer()\\n p = yourAgent()\\n game = Board(r, p, 7, 7)\\n output_b = game.copy()\\n winner, move_history, termination = game.play_isolation(time_limit=1000, print_moves=True)\\n print(\\\"\\\\n\\\", winner, \\\" has won. Reason: \\\", termination)\\n # Uncomment to see game\\n # print game_as_text(winner, move_history, termination, output_b)\\n except NotImplementedError:\\n print('CustomPlayer Test: Not Implemented')\\n except:\\n print('CustomPlayer Test: ERROR OCCURRED')\\n print(traceback.format_exc())\\n \\n print()\",\n \"def chooseAction(self, gameState):\\n actions = gameState.getLegalActions(self.index)\\n\\n ''' \\n You should change this in your own agent.\\n '''\\n\\n return random.choice(actions)\",\n \"def sample_action(self, state):\\n # YOUR CODE HERE\\n \\n action = np.random.choice(1)\\n \\n \\n return action\",\n \"def diceroll(self, mess, args):\\n return random.randint(1, 6)\",\n \"def attack(self):\\n return random.randint(self.max_damage//2, self.max_damage)\",\n \"def somebells():\\n return random.randint(100, 500)\",\n \"def get_random_action():\\n # Define an array containing the available actions for the UAV\\n # in the final work, takeoff and land must be added\\n action_list = ['left', 'right', 'forward', 'backward', 'stop', 'descend']\\n # Choose a random action within the array\\n #action_index = STDrandom.randint(0, len(action_list) - 1)\\n # forward,backward,left,right, stop and land\\n probability_descend = 0.25\\n probability = (1 - probability_descend)/ (len(action_list) -1)\\n action_probability = [probability, probability, probability, probability, probability, probability_descend]\\n action = np.random.choice(action_list, 1, p=action_probability)[0]\\n #action_index = STDrandom.randint(0, 10)\\n #action = action_list[action_index]\\n\\n return action\",\n \"def chance_hit():\\r\\n rand_num = random.randint(1, 14)\\r\\n if rand_num >= random.randint(1, 5):\\r\\n hit = 1\\r\\n else:\\r\\n hit = 0\\r\\n return hit\",\n \"def attack(self):\\n return random.randint(0, self.attack_strength)\",\n \"def whoGoesFirst(self):\\n\\t\\treturn random.randint(1, 2)\",\n \"def gen_random_fightID():\\n pass\",\n \"def act(self):\\n return np.random.randint(-1, 2)\",\n \"def challenge() : \\n\\treturn [random.randint(1,9) for i in range(5)]\",\n \"def random():\\r\\n return R.NextDouble()\",\n \"def random(self):\\n return self._randomize()\",\n \"def sample_from_concept(self):\\n return random.choice(self.active_concept.extension)\",\n \"def sample(self):\\n return gc.rand_state.choice(self.domain)\",\n \"def _random_function(self, random_state):\\n return random_state.rand\",\n \"def getStatusMessage():\\n\\n now = datetime.datetime.now()\\n hour = now.hour\\n mood = Sentience.getPrimaryMood()\\n exp_mood = Sentience.getExposedPositivity()\\n\\n random.seed((time.time()//86400*86400))\\n\\n #sleeping\\n if not (9 <= hour < 21) and (mood <= 0.5 or not 7 <= hour < 23):\\n if exp_mood < -0.1:\\n return random.choice([\\n \\\"bleh\\\",\\n \\\"not sleeping well\\\",\\n \\\"why's chat so noisy\\\",\\n \\\"can't sleep\\\",\\n \\\"do not disturb pls thx\\\",\\n ])\\n\\n if mood < 0:\\n return random.choice([\\n \\\"crying myself to sleep rn\\\",\\n \\\":(\\\",\\n \\\"had a nightmare\\\",\\n \\\"can't sleep\\\",\\n \\\"._.\\\"\\n ])\\n\\n return random.choice([\\n \\\"zzz...\\\",\\n \\\"sweet dreams\\\",\\n \\\"good night\\\",\\n \\\"sleeping...\\\",\\n \\\"having some rest\\\"\\n ])\\n\\n if Sentience.isExposedPositivityOverloaded():\\n return random.choice([\\n \\\"i'm done\\\",\\n \\\"too much\\\"\\n \\\"goodbye\\\",\\n \\\"tired\\\",\\n \\\"need rest\\\",\\n ])\\n\\n #happy\\n if mood >= 0.7:\\n return random.choice([\\n \\\":D\\\",\\n \\\"great day\\\",\\n \\\"happy happy\\\",\\n \\\"hehe\\\",\\n \\\"good times\\\",\\n \\\"yay\\\",\\n \\\"what's up\\\",\\n \\\"happiness\\\",\\n \\\"nice day\\\",\\n ])\\n #moody-ish\\n if mood >= 0.4:\\n return random.choice([\\n \\\"hmm\\\",\\n \\\"yeet\\\",\\n \\\"bleh\\\",\\n \\\"oh\\\",\\n \\\"moody rn\\\",\\n \\\"nothing\\\"\\n ])\\n #more moody\\n if mood >= -0.3:\\n return random.choice([\\n \\\"moody rn\\\",\\n \\\"not happy\\\",\\n \\\"i'm fine.\\\",\\n \\\"bleh\\\",\\n \\\"._.\\\",\\n \\\":(\\\",\\n ])\\n #very unhappy\\n return random.choice([\\n \\\"sad\\\",\\n \\\"cries\\\",\\n \\\"roar\\\",\\n \\\":_(\\\",\\n \\\">:(\\\",\\n \\\"mad\\\",\\n \\\"angry\\\",\\n \\\"I'M FINE.\\\",\\n \\\"bleh\\\",\\n \\\"no\\\",\\n ])\",\n \"def getAction(self, state):\\n # Pick Action\\n legalActions = self.getLegalActions(state)\\n action = None\\n \\\"*** YOUR CODE HERE ***\\\"\\n # util.raiseNotDefined()\\n if random.random() < self.epsilon:\\n action = random.choice(legalActions)\\n else:\\n action = self.getPolicy(state)\\n return action\",\n \"def rand(self):\\n return self.State.rand()\",\n \"def random_die():\\n return randrange(1, 6)\",\n \"def crit_ai(crit):\\n if crit['type'] == 'crawler':\\n # Crawlers move at random.\\n return random.choice(['left','right','up','down'])\\n #if crit['type'] == 'bullet':\\n # return crit['dir']\\n return None\",\n \"def maybe(self):\\n return random.getrandbits(1)\",\n \"def get_lucky(self):\\n lucky_animal = random.choice(self.adoption_pool)\\n return self.finish_successful_adoption(lucky_animal)\",\n \"def getRandom(self):\\n return random.choice(self.data)\",\n \"def __call__(self, state):\\n if random.random() > self._epsilon:\\n return self._max_policy(state)\\n return random.choice(np.arange(self._action_size))\",\n \"def testrandom(self):\\n for i in range(100):\\n AmuletAbility()\",\n \"def decision():\\n return random.random() > 0.5\",\n \"def _get_random_returns(self): \\n return self.asset_process.distrib.random()\",\n \"def attack(self):\\n \\n half_max_damage = int(self.max_damage) // 2\\n random_value = randint(half_max_damage, int(self.max_damage))\\n\\n return random_value\",\n \"def choose_random_action(env):\\n return env.action_space.sample()\",\n \"def DoRandomAction(self, gameState: TekkenGameState):\\n actionRNG = random.randint(1, 100)\\n # Anything generated above this number, the bot chooses to poke\\n POKE_CAP = 50\\n DASH_CAP = 35\\n DUCK_CAP = 20\\n SIDESTEP_CAP = 10\\n WALK_CAP = 5\\n\\n TARGET_DISTANCE = 2000.0 # 2.00\\n\\n # Ensure we dont do nothing for twice in a row\\n if self.last_rand_action_was_nth:\\n actionRNG += SIDESTEP_CAP\\n self.last_rand_action_was_nth = False\\n\\n # Try to poke if the last action was spent getting\\n # into range for pokes\\n if self.last_asked_poke:\\n actionRNG += POKE_CAP\\n\\n if actionRNG >= POKE_CAP:\\n # Not in range, dash towards\\n if TARGET_DISTANCE < gameState.GetDist():\\n self.DashTowardsTargetDist(TARGET_DISTANCE, gameState)\\n self.last_asked_poke = not self.last_asked_poke\\n else:\\n self.RandomPoke()\\n self.last_asked_poke = False\\n elif actionRNG >= DASH_CAP:\\n self.DashTowardsTargetDist(TARGET_DISTANCE, gameState)\\n elif actionRNG >= DUCK_CAP:\\n # duck for a few frames\\n self.botCommands.BlockLowFull(random.randint(8, 12))\\n elif actionRNG >= SIDESTEP_CAP:\\n # Pick between SS up or down\\n if (random.randint(0, 1) == 0):\\n self.botCommands.SidestepUp()\\n else:\\n self.botCommands.SidestepDown()\\n elif actionRNG >= WALK_CAP:\\n self.WalkTowardsTargetDist(TARGET_DISTANCE, gameState)\\n else:\\n self.last_rand_action_was_nth = True\\n\\n self.tick_till_next_rand = 0\",\n \"def should_pay_attention(self):\\n return random.randint(1,100) > self.wander\",\n \"def computer_random():\\r\\n ci = random.sample(range(1,43),5)\\r\\n return ci\",\n \"def create_challenge():\\n\\treturn os.urandom(12)\",\n \"def p_banner():\\n return random.choice([banner, banner_two, banner_three, banner_four, banner_five])\",\n \"def base_pick():\\n\\n rnd = generate_random(2, 15)\\n return rnd\",\n \"def get_random(self):\\n return random.choice(self.proxies)\",\n \"def get_action(self, state):\\n return random.choice(state.get_legal_actions(self.index))\",\n \"def get_random_word(self):\\n pass\",\n \"def decision():\\n return random.choice(['GoToNormal','GoToSleep'])\",\n \"def get_random_phrase():\\n return random.choices(PHRASES, WEIGHTS, k=1)[0]\",\n \"def sample(self, s):\\n rng = np.random.default_rng()\\n return rng.choice(np.arange(self.n_actions), p=self.eval(s))\",\n \"def getRandomEvent(p = 0.5):\\n if random.random() < p: return 1\\n else: return 0\",\n \"def get_random_gestures(_):\\n random_seed = random.getrandbits(32)\\n gesture = 'monkey,%s' % str(random_seed)\\n return [gesture]\",\n \"def get_advice():\\n json_response = random_adviceslip()\\n advice = parse_advice(json_response=json_response)\\n return advice\",\n \"def act(self):\\n return np.random.randint(self.k)\",\n \"def pickSecretNumber(): \\n return random.randrange(1, 11)\",\n \"def get_randomness(request, election):\\n return {\\n \\\"randomness\\\" : base64.b64encode(os.urandom(32)).decode('utf-8')\\n }\",\n \"def single_introduction(end):\\n return [random.randint(0,end)]\",\n \"def Thunder(robot):\\n robot_return = Random_Actuation.myopic(\\\"Thunder\\\",robot,0.5,20) # with a %20 chance myopic will be triggered\\n robot_return = Random_Actuation.hobbler(\\\"Thunder\\\",robot,0.5,20) # with a %20 change hobbler will be triggered\\n return robot_return\",\n \"def chooseAction(self, gameState):\\n actions = gameState.getLegalActions(self.index)\\n\\n '''\\n You should change this in your own agent.\\n '''\\n\\n return random.choice(actions)\",\n \"def chooseAction(self, gameState):\\n actions = gameState.getLegalActions(self.index)\\n\\n '''\\n You should change this in your own agent.\\n '''\\n\\n return random.choice(actions)\",\n \"def goals():\\n rand_nmr = random.random()\\n if rand_nmr < 0.5:\\n return 1\\n elif rand_nmr < 0.8:\\n return 2\\n elif rand_nmr < 0.97:\\n return 3\\n else:\\n return 4\",\n \"def chooseAction(self,state):\\r\\n #generate float btwn 0-1\\r\\n choice = random.random()\\r\\n feat = self.feat_funct(state)\\r\\n #choose according to that number\\r\\n if choice > self.epsilon:\\r\\n return(self.maxQ(feat)[1])\\r\\n else:\\r\\n #choose randomly\\r\\n return(self.actions[random.randrange(0,len(self.actions))])\",\n \"def __get_function(self):\\n return random.choice(self.FUNCTIONS)\",\n \"def random_operation():\\r\\n operation = random.choice([\\\"add\\\",\\\"subtract\\\",\\\"multiply\\\",\\\"divide\\\"])\\r\\n return operation\",\n \"def random(self, random_mode):\\n resp = yield from self.command('random {}'.format(random_mode))\\n return True\",\n \"def choose_random_action(all_actions: int) -> int:\\n return np.random.randint(all_actions)\",\n \"def acquisition_function_random(gp_reward_model: BasicGPRewardModel) -> int:\\n return np.random.randint(0, len(gp_reward_model.candidate_queries))\",\n \"def totem_random():\\n random_head()\\n random_head()\\n random_head()\",\n \"def random_gene(self):\\n size = random.randint(1,50)\\n gene = \\\"\\\"\\n for i in range(0,size,1):\\n gene+=random.choice(self.instructions)\\n return gene\",\n \"async def tapir(self):\\n tapir_list = self.config.get('tapirs', [])\\n tapir = tapir_list[random.randrange(len(tapir_list))]\\n try:\\n await self.bot.say(tapir)\\n except:\\n await self.bot.whisper(tapir)\",\n \"def make_rand_task():\\n rand_type = all_tasks.keys()[random.randint(0, len(all_tasks.keys()) - 1)]\\n rand_hit = all_tasks[rand_type][random.randint(0, len(all_tasks[rand_type]) - 1)]\\n\\n if rand_hit['type'] == 'img':\\n rand_hit['img_src'] = get_rand_img()\\n\\n return rand_hit\",\n \"def randomLeggings():\\n return random.choice(LEGGINGS)\",\n \"def random_lottery():\\n\\treturn 0\",\n \"def get_word():\\n index = random.randrange(3)\\n print(index)\\n if index == 0:\\n return 'HAPPIE'\\n elif index == 1:\\n return 'PYTHON'\\n else:\\n return 'COMPUTER'\",\n \"def random_head():\\n x = random.randint(1,3)\\n if x==1: \\n head_hearteyes()\\n elif x==2:\\n head_surprised()\\n else:\\n head_plain()\",\n \"def confused(self, rand):\\n return rand > 0\",\n \"def get_random_inspirational_quote(self):\\n return random.choice(self.inspirational_quotes)\",\n \"def get_user_input(self, game, hand, message, allowed_actions):\\n if random.random() < 0.5:\\n return 'hit'\\n else:\\n return 'stand'\",\n \"def randomly_pick_recipe(cls):\\n return random.choice(cls._recipes)\",\n \"def get_random(self):\\n return self._get_random()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6780925","0.6780925","0.6756225","0.6611887","0.64579284","0.64579284","0.64425486","0.6346136","0.63369906","0.6270907","0.6244317","0.6233644","0.62298036","0.62264895","0.62022316","0.61940515","0.61672014","0.6140617","0.6140617","0.61395633","0.61287326","0.6111001","0.60833454","0.60795355","0.6076063","0.6073966","0.607255","0.60573465","0.60570806","0.6050439","0.6049905","0.60170907","0.6006969","0.5995281","0.5971646","0.59666306","0.5961411","0.59316427","0.5928812","0.59197086","0.5917468","0.591478","0.5909711","0.5909381","0.59013295","0.5900607","0.5896345","0.5893421","0.5886767","0.5885439","0.58799106","0.58747303","0.5872891","0.5872331","0.5841132","0.583517","0.58308166","0.5809392","0.5801915","0.5798515","0.5796681","0.579209","0.57859665","0.5777145","0.5776623","0.57714915","0.5757649","0.57571447","0.5755131","0.57549566","0.57507867","0.57507825","0.57484335","0.5747945","0.57425934","0.5738104","0.57346517","0.5734595","0.5723883","0.5723883","0.5716112","0.57148105","0.5695101","0.56833345","0.5667762","0.5664153","0.56573236","0.5644668","0.5642467","0.5641373","0.5640784","0.56377935","0.5629599","0.56262517","0.56237566","0.56151474","0.56145793","0.56137925","0.5612879","0.5611213"],"string":"[\n \"0.6780925\",\n \"0.6780925\",\n \"0.6756225\",\n \"0.6611887\",\n \"0.64579284\",\n \"0.64579284\",\n \"0.64425486\",\n \"0.6346136\",\n \"0.63369906\",\n \"0.6270907\",\n \"0.6244317\",\n \"0.6233644\",\n \"0.62298036\",\n \"0.62264895\",\n \"0.62022316\",\n \"0.61940515\",\n \"0.61672014\",\n \"0.6140617\",\n \"0.6140617\",\n \"0.61395633\",\n \"0.61287326\",\n \"0.6111001\",\n \"0.60833454\",\n \"0.60795355\",\n \"0.6076063\",\n \"0.6073966\",\n \"0.607255\",\n \"0.60573465\",\n \"0.60570806\",\n \"0.6050439\",\n \"0.6049905\",\n \"0.60170907\",\n \"0.6006969\",\n \"0.5995281\",\n \"0.5971646\",\n \"0.59666306\",\n \"0.5961411\",\n \"0.59316427\",\n \"0.5928812\",\n \"0.59197086\",\n \"0.5917468\",\n \"0.591478\",\n \"0.5909711\",\n \"0.5909381\",\n \"0.59013295\",\n \"0.5900607\",\n \"0.5896345\",\n \"0.5893421\",\n \"0.5886767\",\n \"0.5885439\",\n \"0.58799106\",\n \"0.58747303\",\n \"0.5872891\",\n \"0.5872331\",\n \"0.5841132\",\n \"0.583517\",\n \"0.58308166\",\n \"0.5809392\",\n \"0.5801915\",\n \"0.5798515\",\n \"0.5796681\",\n \"0.579209\",\n \"0.57859665\",\n \"0.5777145\",\n \"0.5776623\",\n \"0.57714915\",\n \"0.5757649\",\n \"0.57571447\",\n \"0.5755131\",\n \"0.57549566\",\n \"0.57507867\",\n \"0.57507825\",\n \"0.57484335\",\n \"0.5747945\",\n \"0.57425934\",\n \"0.5738104\",\n \"0.57346517\",\n \"0.5734595\",\n \"0.5723883\",\n \"0.5723883\",\n \"0.5716112\",\n \"0.57148105\",\n \"0.5695101\",\n \"0.56833345\",\n \"0.5667762\",\n \"0.5664153\",\n \"0.56573236\",\n \"0.5644668\",\n \"0.5642467\",\n \"0.5641373\",\n \"0.5640784\",\n \"0.56377935\",\n \"0.5629599\",\n \"0.56262517\",\n \"0.56237566\",\n \"0.56151474\",\n \"0.56145793\",\n \"0.56137925\",\n \"0.5612879\",\n \"0.5611213\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6908676"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76083,"cells":{"query":{"kind":"string","value":"Return the lyrics of the song submitted."},"document":{"kind":"string","value":"def song_lyrics(message):\n spaceless_message = message.partition(' ')[2]\n if \":\" in spaceless_message:\n # Try and find the lyrics.\n band_name = spaceless_message[0]\n song_title = spaceless_message[2]\n\n response = requests.get(\"https://api.lyrics.ovh/v1/{}/{}\".format(band_name, song_title))\n\n if response.status_code == 404:\n return response.json()['error']\n return response.json()['lyrics']\n else:\n return (\"Message not formatted correctly. Please try again using this format:\\nlyrics band name:song title\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def lyrics(self):\n return get_lyrics(self.artist, self.title,'')","def get_lyrics(self):\n\t\treturn self._lyrics_list","def get_lyrics(self):\n url = 'http://api.lyricsnmusic.com/songs?api_key=[5358b25688164e6c2f771954f17460&q]=' + self.artist + '%20' + self.name\n r = requests.get(url)\n r_text = r.text\n for (old, new) in [('false', 'False'), ('true', 'True'), ('null', 'None')]:\n r_text = r_text.replace(old, new)\n r_text_as_data = eval(r_text)\n if len(r_text_as_data) != 0:\n r_text_dict = r_text_as_data[0]\n return r_text_dict['snippet']\n else:\n return ''","def lyrics(self) -> str:\n if self._lyrics == None:\n response = self._web_session.request(\"GET\", self.path)\n soup = BeautifulSoup(response.content, \"html.parser\")\n lyrics_div = soup.find(\"div\", class_=re.compile(\"^lyrics$|Lyrics__Root\"))\n if lyrics_div:\n self._lyrics = lyrics_div.get_text(separator=\"\\n\")\n else:\n self._lyrics = \"\"\n\n return self._lyrics","def song_lyrics(ans):\r\n albums = simple_album_list()\r\n for album in albums:\r\n songs = simple_songs_list(album)\r\n for song in songs:\r\n if ans == song:\r\n words = dbase()[album][0][song]\r\n words = words[2]\r\n return words","def get_lyrics(artist, song, language='', linesep='\\n', timeout=None):\n return get_all_lyrics(artist, song, language, linesep, timeout)[0]","def get_lyrics(self, artist, song):\n\n # Disable lyrics display\n self.status_bar.hide()\n self.lyrics_view.hide()\n self.scroll.hide()\n\n lyrics = None\n in_database = False\n\n if self.database.status: # Testing connection to database\n lyrics = self.database.retrieve_lyrics(artist, song)\n if lyrics: # False if not found in database\n in_database = True\n\n if not lyrics: # Try next to retrieve from web\n url = self.make_url(artist, song)\n try:\n lyrics = self.fetch_lyrics(url)\n except:\n self.display_message('Internet Connection Problem') # Could not connect to internet\n return\n\n if not lyrics: # Not available in database or on web\n self.display_message('Lyrics Not Available')\n else:\n # Set the display\n lyrics_buffer = self.lyrics_view.get_buffer()\n lyrics_buffer.set_text(lyrics)\n\n if not in_database: # Save if not in database\n self.database.save(artist, song, lyrics)\n\n # Re-enable lyrics display\n self.scroll.show()\n self.lyrics_view.show()\n self.display_message('Lyrics Extracted Successfully')","async def _lyrics(self, ctx: commands.Context):\n if not ctx.voice_state.is_playing:\n raise commands.CommandError('Nothing being played at the moment.')\n\n # Get song name listed on youtube\n song_title = ctx.voice_state.current.source.track\n if not song_title:\n return await ctx.send(\"Couldn't find lyrics for this track!\")\n\n song_title = re.sub(\"[(\\[].*?[)\\]]\", \"\", song_title).strip() # Remove parenthesis from song title\n # Get artist name listed on youtube\n artist_name = ctx.voice_state.current.source.artist\n # Instance of GeniusSong class using the Genius API\n genius_song = GeniusSong(song_title, artist_name)\n # Try getting the lyrics using the lyricsgenius library\n lyrics = genius_song.fastlyrics()\n\n # In case of no lyrics found. Use the other (slower) method\n if not lyrics:\n res = genius_song.get_response() # Generate a response using the Genius API to get the songs\n if res:\n # Find the most similar artist comparing the artist on YouTube and Genius\n artist_name = genius_song.return_similar_artist(res)\n # Artist didn't match\n if not artist_name:\n await ctx.send(\"Couldn't find similar artists. The lyrics might not be the expected.\")\n\n # Get the lyrics using the lyricsgenius library with the new artist\n lyrics = genius_song.fastlyrics(artist_name)\n\n else:\n return await ctx.send(\n \"**Error!**\\nThere is a problem with Genius.\\nTry again in a few minutes. \"\n \"\\nYou can also try the command `fastlyrics`.\")\n\n if lyrics:\n # Split lyrics into fields\n fields = genius_song.split_lyrics(lyrics)\n # Create an embed message\n embed = embed_msg(\n title=song_title.capitalize() + \"\\n{}\".format(artist_name),\n description=\"\",\n footer=\"Lyrics provided by Genius.\",\n field_values=fields,\n inline=False\n )\n return await ctx.send(embed=embed)\n\n return await ctx.send(\"Lyrics couldn't be found.\")","def get_lyrics(self) -> Optional[str]:\n return self.lyrics","async def lyrics(\n self, ctx: commands.Context, query: str = None\n ) -> Optional[Tuple[str, str, str]]:\n\n query = await self.now_playing(ctx) if query is None else query\n if not query:\n return\n\n url = f\"https://some-random-api.ml/lyrics?title={query}\"\n\n async with aiohttp.ClientSession() as session:\n request = await session.get(url)\n request_json = await request.json(content_type=None)\n\n authors = request_json.get(\"author\")\n title = request_json.get(\"title\")\n lyrics = request_json.get(\"lyrics\")\n\n return (title, authors, lyrics) if lyrics else None","def lyrics_plaintext(song):\n output = \"\"\n\n song = validate_song(song)\n\n output += song.default_arrangement\n output += \"\\n\\n\\n\\n\"\n output += song.composer\n output += \"\\n\"\n output += song.copyright\n output += \"\\n\\n\"\n\n for section, lyrics in song.lyrics.items():\n output += section\n output += \"\\n\"\n output += lyrics\n output += \"\\n\\n\"\n return output","def get_lyrics(self, html):\n #gets lyricks trough a css selector\n raw_lyrics = html.select('div[class*=\"Lyrics__Container\"]')\n if len(raw_lyrics) == 0:\n raw_lyrics = html.select('div[class=\"lyrics\"]')\n\n lyrics = [] \n for lyric in raw_lyrics:\n temp_lyrics = re.sub(r'[\\(\\[].*?[\\)\\]]', '', lyric.get_text()).strip()\n temp_lyrics = re.sub('\\n+', '', temp_lyrics)\n lyrics.append(re.findall('[A-Z][^A-Z]*', temp_lyrics))\n\n all_words = ''\n # Format lyrics \n for section in lyrics:\n if len(section) == 0:\n continue\n\n for verse in section:\n all_words += verse.strip() + \"[*]\"\n \n return all_words","def get_single_lyrics(self, url):\n r = requests.get(url)\n soup = BeautifulSoup(r.text, 'html.parser')\n lyrics = ''\n \n all_divs = soup.findAll('div')\n filtered_divs = [x for x in all_divs if x.has_attr('class') and ('Lyrics__Container-sc' in x['class'][0] or x['class'] == ['lyrics'])]\n filtered_divs_classes = [x['class'] for x in filtered_divs if x.has_attr('class')]\n \n if len(filtered_divs) == 0:\n lyrics = ''\n elif len(filtered_divs) == 1 and filtered_divs_classes[0][0] == 'lyrics':\n lyrics = filtered_divs[0].text\n else:\n for part in filtered_divs:\n for e in part.descendants:\n if isinstance(e, str):\n lyrics += e.strip()\n elif e.name == 'br' or e.name == 'p':\n lyrics += '\\n'\n \n return lyrics","def get_all_lyrics(artist, song, language='', linesep=' \\n ', timeout=None):\n url = create_url(artist, song, language)\n response = _requests.get(url, timeout=timeout)\n soup = _BeautifulSoup(response.content, \"html.parser\")\n lyricboxes = soup.findAll('div', {'class': 'lyricbox'})\n\n if not lyricboxes:\n raise LyricsNotFound('Cannot download lyrics')\n\n for lyricbox in lyricboxes:\n for br in lyricbox.findAll('br'):\n br.replace_with(linesep)\n\n return [lyricbox.text.strip() for lyricbox in lyricboxes]","def getLyricsFromSong(songLink):\n try:\n html = urllib.request.urlopen(songLink).read()\n soup = bs4.BeautifulSoup(html, 'html.parser')\n soup = soup.find(\"pre\")\n text = soup.contents[0].strip().split(\"\\n\")[5:]\n except:\n return \".\\n.\"\n\n clean_text = \"\"\n lyrics_list=[]\n for line in text:\n lyrics_list.append(line)\n clean_text += line + \"\\n\"\n return clean_text","def get_existing_lyrics(self, song_id):\n\t\tlyrics = self.db.lyrics.find_one({'song_id': song_id})['lyrics']\n\t\treturn lyrics","def fetch_lyrics(self) -> None:\n if self.artist is None or self.title is None:\n return\n Logger.Logger.log('Looking for song lyrics...')\n finder = LyricsFinder.LyricsFinder(self)\n finder.fetch()\n self.lyrics = finder.get_lyrics()\n self.lyrics_writer = finder.get_lyrics_writer()\n if not self.lyrics:\n Logger.Logger.log('No lyrics found for this song.')","def get_lyrics(self, name: str, artists: List[str], **_) -> Optional[str]:\n\n # Join every artist by comma in artists\n artist_str = \", \".join(artist for artist in artists if artist)\n\n song_name = name.replace(\" \", \"+\").lower()\n song_artists = artist_str.replace(\" \", \"+\").lower()\n song_artists = song_artists.replace(\",\", \"%2C\")\n\n url = f\"https://search.azlyrics.com/search.php?q={song_name}+{artists}\"\n\n response = requests.get(url, headers=self.headers)\n soup = BeautifulSoup(response.content, \"html.parser\")\n\n td_tags = soup.find_all(\"td\")\n if len(td_tags) == 0:\n return None\n\n result = td_tags[0]\n\n a_tags = result.find_all(\"a\", href=True)\n if len(a_tags) != 0:\n lyrics_url = a_tags[0][\"href\"]\n else:\n return None\n\n if lyrics_url.strip() == \"\":\n return None\n\n response = requests.get(lyrics_url, headers=self.headers)\n soup = BeautifulSoup(response.content, \"html.parser\")\n\n # Find all divs that don't have a class\n div_tags = soup.find_all(\"div\", class_=False, id_=False)\n\n # Find the div with the longest text\n lyrics_div = sorted(div_tags, key=lambda x: len(x.text))[-1]\n\n lyrics = lyrics_div.get_text()\n\n # Remove the 3 first new lines\n lyrics = lyrics[3:]\n\n return lyrics","def print_lyrics(self):\n\t\tprint(self._lyrics_list)","def scrape_song(url):\n soup = scrapekit.handle_url(url)\n\n contents = scrape_id_to_div(soup, \"Lyrics\")\n if not contents:\n return None\n\n filetext = ''.join(c.text for c in contents)\n\n # Check if there is a reprise\n REPRISE = 'Reprise'\n\n reprise = soup.find(id=REPRISE)\n if reprise:\n filetext += '\\n\\n'\n filetext += REPRISE + ':\\n\\n'\n\n contents = scrape_id_to_div(soup, REPRISE)\n filetext += ''.join(c.text for c in contents)\n\n # Get song title, fix blank spaces for file name\n songtitle = soup.title.text.split('|')[0]\n\n song_text = ''\n song_text += 'Song: {}\\n'.format(songtitle)\n song_text += get_infobox_info(soup)\n song_text += '\\n\\n'\n song_text += filetext\n\n return song_text","def add_lyrics(self):\n\n conn = self.conn\n conn.text_factory = str\n c = conn.cursor()\n\n c.execute(\"SELECT songs.id, artist, title, url FROM songs LEFT JOIN lyrics ON songs.id = lyrics.song_id WHERE lyrics.song_id IS NULL\")\n all_songs_to_scrape = c.fetchall()\n for song in all_songs_to_scrape:\n song_id = song[0]\n song_artist = song[1]\n song_title = song[2]\n song_url = song[3]\n print(\"Looking for lyrics for \" + song_title + \" by \" + song_artist)\n try:\n lyrics = pygenius_songs.searchURL(song_url, 'lyrics')\n for lyric in lyrics:\n for line in lyric.split('\\n'):\n c.execute('INSERT INTO lyrics(song_id, line) VALUES (?,?)', (song_id, line))\n conn.commit()\n except Exception as e:\n print(e)\n print song_url\n print(\"Exception caught! ... continuing.\")\n pass","def record_lyrics_result(self, track_id, songdata):\n self.lyrics.insert_one(\n {\n \"_id\": track_id,\n \"response_artist\": songdata.artist,\n \"response_title\": songdata.title,\n \"lyrics\": songdata.lyrics,\n }\n )","def get_lyrics_text(lyrics_url):\n\n headers = {\n 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',\n 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',\n 'Accept-Encoding': 'none',\n 'Accept-Language': 'en-US,en;q=0.8',\n 'Connection': 'keep-alive'\n }\n\n page_html = utils.get_request(lyrics_url, headers=headers)\n if page_html:\n bsoup = BeautifulSoup(page_html, \"lxml\")\n lyrics_text = bsoup.find('div', {'class': 'lyrics'}).text\n return utils.ascii_string(lyrics_text)\n else:\n return None","def get_song_list(self):\n return self.song_list","def get_existing_lyrics_of_artist(self, artist_name=None, artist_id=None):\n\t\tif artist_name:\n\t\t\tsongs = self.db.artists.find_one({'name': str(artist_name).lower()})\n\t\t\tlyrics = []\n\t\t\tfor song in songs:\n\t\t\t\tlyrics.append((song, self.get_existing_lyrics(song)))\n\t\t\treturn lyrics\n\t\tif artist_id:\n\t\t\tsongs = self.db.artists.find_one({'id': artist_id})['songs']\n\t\t\tprint(len(songs))\n\t\t\tlyrics = []\n\t\t\tfor song in songs:\n\t\t\t\ttry:\n\t\t\t\t\tlyrics.append((song, self.get_existing_lyrics(song)))\n\t\t\t\texcept:\n\t\t\t\t\tcontinue\n\t\t\treturn lyrics","def get_lyrics(request: request, exclude_id: int=None):\n # Defensive programming checks\n if exclude_id:\n assert isinstance(exclude_id, int)\n\n # Get lyrics\n lyr = Lyrics()\n for k, v in request.form.items():\n if \"section-\" in k:\n idx = int(k.split(\"-\")[-1])\n if idx is not exclude_id:\n # First, convert to traditional.\n lyrics = convert(request.form[f\"lyrics-{idx}\"])\n\n section = request.form[k]\n lyr.add_section(section=section, lyrics=lyrics)\n return lyr","def fetch_lyrics(self, url):\n # data=requests.get(url,proxies=proxyDict) # will be used when internet is accessed via proxy server\n page = requests.get(url) # for accessing internet without proxy server\n # Regex out the lyrics from the html content\n lyrics = re.search(b'<!-- start of lyrics -->(?:\\r\\n)+(.+)(?:\\r\\n)+<!-- end of lyrics -->', page.content, re.DOTALL)\n if lyrics:\n # Strip html tags from decoded lyrics\n return re.sub(r'<.+>', '', lyrics.group(1).decode('utf8'))\n else:\n return None","def lyrics_by_word(ans):\r\n songs_list = \"\"\r\n ans = ans.lower()\r\n albums = simple_album_list()\r\n for album in albums:\r\n songs = simple_songs_list(album)\r\n for song in songs:\r\n x = song_lyrics(song)\r\n song = str(song)\r\n if ans in x:\r\n songs_list += song + \", \"\r\n return songs_list[:-2]","def songs(self):\n return Html.find_song_names(self.content)","def get_lyrics_for_all_languages(artist, song, linesep='\\n', timeout=None):\n url = create_url(artist, song, '')\n response = _requests.get(url, timeout=timeout)\n soup = _BeautifulSoup(response.content, \"html.parser\")\n lyricboxes = soup.find('table', {'class': 'banner banner-song'})\n result = dict()\n result['default'] = get_lyrics_by_language(artist, song, '', linesep='\\n', timeout=None)\n \n for a in lyricboxes.findAll('a', href=True):\n result[a.getText()] = get_lyrics_by_language(artist, song, a['href'].split('/')[-1], linesep='\\n', timeout=None)\n \n return result","def get_lyrics_by_language(artist, song, language, linesep='\\n', timeout=None):\n return get_all_lyrics(artist, song, language, linesep, timeout)[0]","def song(song_id):\n return process_input(song_id) #jsonify(recomendations)","def song_has_lyrics():\n pass","def get_all_lyrics(self):\n if len(self.track_urls) == 0:\n raise ValueError('URLs have not be retrieved yet. Call get_track_list() first.')\n \n if len(self.track_urls) == 0:\n return\n\n for url in self.track_urls:\n lyrics = self.get_single_lyrics(url)\n self.lyrics.append(lyrics)","def parse_pretty_midi_lyrics(midi: PrettyMIDI) -> List[Lyric]:\n return [Lyric(lyric.time, lyric.text) for lyric in midi.lyrics]","def getSongTextInfo():\n sids = []\n documents = []\n sFile = open('../txt/two__Lastfm_song_Docs.txt')\n lines = sFile.readlines()\n index = 0\n for line in lines:\n line.strip('\\n')\n line.strip('\\r\\n')\n items = line.split('>>')\n sid = int(items[0])\n text = items[1]\n documents.append(text)\n sids.append(sid)\n sFile.close()\n print 'len = ',len(sids)\n print 'len = ',len(documents)\n return sids,documents","def add_lyrics(self, songs, genius_api, nthreads=0):\n\t\tif isinstance(songs, list):\n\t\t\tprint(f'{len(songs)} songs to get their lyrics')\n\t\t\tif nthreads <2:\n\t\t\t\tfor song_id in songs:\n\t\t\t\t\tsong = genius_api.search(song_id, 'song')\n\t\t\t\t\tself.__add_lyric(song, genius_api)\n\t\t\telif nthreads >1:\n\t\t\t\tassert len(songs) > 0\n\t\t\t\tthreads=[]\n\t\t\t\tscrapping_batch_size = len(songs) // nthreads\n\t\t\t\tprint(f'thread list size = {scrapping_batch_size}')\n\t\t\t\tfor i in range(nthreads):\n\t\t\t\t\tthreads.append(Thread(target=self.add_lyrics, \n\t\t\t\t\t\targs=(songs[scrapping_batch_size * i : scrapping_batch_size * (i + 1)], genius_api,)))\n\t\t\t\t\tif i == threads - 1:\n\t\t\t\t\t\tthreads[i] = Thread(self.add_lyrics, (songs[scrapping_batch_size * i:], genius_api,))\n\t\t\t\t\tthreads[i].start()\n\t\t\t\t\tprint('thread {} activated'.format(i+1))\n\t\telse:\n\t\t\tsong = genius_api.search(songs, 'song')\n\t\t\tself.__add_lyric(song, genius_api)\n\t\t\tprint(' lyrics of {} added with success'.format(song['title']))","def approve_lyrics():\n pass","def get(self):\n mb = MusicbrainzClient()\n query = self.get_argument('q')\n artists, tracks = yield [mb.search_artists(query),\n mb.search_tracks(query)]\n data = {\n 'artists': [\n {\n 'id': artist['id'],\n 'artist': artist['name'],\n 'note': artist.get('disambiguation', '')\n }\n for artist in artists['artist-list']\n ],\n 'tracks': [\n {\n 'id': track['id'],\n 'title': track['title'],\n 'artist': track['artist-credit-phrase']\n }\n for track in tracks['recording-list']\n ]\n }\n self.finish(data)","def get_song_list(self, artist: str) -> List[str]:\n artist = self.just_replace_strings_with_nothing(artist)\n\n url = self.list_url + artist + '/songs'\n\n resp = requests.get(url)\n\n content = bs4.BeautifulSoup(resp.content)\n\n song_list = content.text[content.text.index(\n 'MP3s') + 5:content.text.index('About Song List')]\n\n song_list = re.sub('\\n', ',', song_list)\n song_list = re.sub(',+', ',', song_list)\n song_list = re.sub(', ,', ', ', song_list)\n\n song_list = re.split(',', song_list)\n for i in range(len(song_list)):\n song_list[i] = song_list[i].lstrip(' ')\n song_list[i] = re.sub(\"[.,']\", '', song_list[i])\n song_list[i] = re.sub(\"&\", 'and', song_list[i])\n song_list[i] = re.sub('\\s+', ' ', song_list[i])\n\n song_list = [i for i in song_list if i != '']\n\n return song_list","def get_lyrics_or_chords(url):\n html = ''\n\n if 'cifraclub' in url:\n if url.startswith('https://m.'):\n url = 'https://www.' + url[10:] # So we don't have to deal with mobile URLs\n url += 'imprimir.html#columns=false' # Printer Friendly page (it's cleaner)\n soup = getsoup(url)\n sections = soup.find_all('pre')\n for s in sections:\n html += str(s)\n\n if 'letras.mus.br' in url:\n if url.startswith('https://m.'):\n url = 'https://www.' + url[10:] # So we don't have to deal with mobile URLs\n soup = getsoup(url)\n article = soup.find('article')\n html = str(article)\n\n if 'e-chords' in url:\n soup = getsoup(url)\n pre = soup.find('pre', id='core')\n # Remove Tab Div, keep raw tab\n div = pre.find('div')\n if div is not None:\n tab = div.find('div', class_='tab')\n html = '<pre>' + tab.text + '</pre>'\n div.extract()\n html += str(pre)\n\n if 'freak' in url:\n soup = getsoup(url)\n content = soup.find('div', id='content_h')\n html = str(content)\n\n return html","def get_lyrics_mouritz(artist, song_title, use_spotify_api, rapidapi_key):\n\n # \"featuring\" makes the string messy and Spotify API can find the song\n # without this info\n artist = artist.lower().split(\"feat\", 1)[0].strip()\n song_title = song_title.lower().strip()\n\n url = \"https://mourits-lyrics.p.rapidapi.com\"\n\n headers = {\n \"x-rapidapi-host\": \"mourits-lyrics.p.rapidapi.com\",\n \"x-rapidapi-key\": rapidapi_key,\n }\n\n if use_spotify_api:\n payload = {\"q\": artist + \" \" + song_title}\n else:\n payload = {\"a\": artist, \"s\": song_title}\n try:\n r = requests.get(url, params=payload, headers=headers)\n lyric = r.json()[\"result\"][\"lyrics\"]\n\n return lyric, \"mourits\"\n\n except Exception:\n return None, None","async def genius(self, ctx, *args):\n args = argsmachine(args)\n async with ctx.channel.typing():\n if len(args) > 0:\n headers = {'Authorization': 'Bearer ' + token}\n search_url = f'https://api.genius.com/search?q={args}'\n response = requests.get(search_url, headers=headers)\n response = response.json()\n allitems = []\n for item in response['response']['hits']:\n new = item['result']\n newsong = Song(new['full_title'], new['url'], new)\n allitems.append(newsong)\n embed = Embed()\n embed.description = concatenator(allitems)\n await ctx.channel.send('Here are some results of the songs that you wanted. Type in the # of which result you want the lyrics to, or \"no\" to back out!', embed=embed)\n while True:\n try:\n message = await self.bot.wait_for('message', check = check, timeout=30)\n message = message.content.strip()\n if message == 'no':\n break\n else:\n message = int(message)-1\n break\n except asyncio.TimeoutError:\n await ctx.send(\"You didn't reply in time! Enter the #.\")\n continue\n except:\n await ctx.send(f\"Try entering the # again, or enter 'no' to exit the search command.\")\n continue\n\n try:\n chosensong = allitems[message]\n site = requests.get(chosensong.url)\n site = bs4.BeautifulSoup(site.text, features='html.parser')\n chosensong.lyrics = site.find(\"div\", class_=\"lyrics\").get_text()\n \n #Discord supports only 2048 characters in each embed message so this is used to break it up into multiple messages\n messages_needed = math.ceil(len(chosensong.lyrics) / 2048)\n lyricsembed=Embed()\n counter = 1\n currentchar = 0\n nextchar = 2048\n while messages_needed >= counter:\n lyrics = chosensong.lyrics[currentchar:nextchar]\n lyricsembed.description = lyrics\n await ctx.send(f'Here are the lyrics for `{chosensong.title}`, `{counter}`/`{messages_needed}`!', embed=lyricsembed)\n currentchar += 2048\n nextchar += 2048\n counter += 1\n except:\n await ctx.send(f\"Stopping the genius command.\")\n else:\n await ctx.send(f\"Can't really search for lyrics if there are none provided, right? Try again with words, song titles, or artist names.\")","def combine_genre(songs):\r\n combined = \"\"\r\n for song in songs:\r\n combined += song[\"lyrics\"]\r\n return combined","def azlyrics(song, artist):\n song = song.replace(\" \", \"\")\n artist = artist.replace(\" \", \"\")\n url = 'http://www.azlyrics.com/lyrics/' + artist + '/' + song + '.html'\n html_text = urllib.urlopen(url).read()\n soup = BeautifulSoup(html_text, \"lxml\")\n find_lyrics = soup.find_all(\"div\")\n div = [x for x in find_lyrics if str(x).find(\"class=\") == -1]\n if(len(div) > 1):\n return div[1]\n else:\n return -1","def get_all_songs(self):\n to_send = self.db.get_all_songs()\n to_send = '$'.join(to_send)\n self.send_message(to_send)","def get_all_artists_lyrics(self, artist: str) -> List[Dict]:\n artist = artist.lower()\n song_list = self.get_song_list(artist)\n\n lyric_dict = {}\n for i in song_list:\n lyrics = self.get_genius_page(artist, i)\n lyric_dict[i] = lyrics\n\n return lyric_dict","def get_songs(self):\n search_object = {\"size\":25000,\n 'query': {'term': {FIELD_FINGERPRINTED: True}}, \"fields\": [FIELD_SONGNAME, FIELD_FILE_SHA1,\n FIELD_TOTAL_HASHES]}\n response = self.cursor.search(index = SONGS_INDEXNAME, body=search_object)\n #print(\"get_songs response: \",response)\n arr = []\n for hit in response[\"hits\"][\"hits\"]:\n dct = {\"song_name\":hit['_source'][FIELD_SONGNAME],\"total_hashes\":hit['_source'][FIELD_TOTAL_HASHES],\n \"file_sha1\":hit['_source'][FIELD_FILE_SHA1]}\n arr.append(dct)\n return arr","def read( self, song_file_name ):\n song_file = open( song_file_name )\n content = song_file.read()\n return self.split( content )","def get_genius_page(self, artist: str, song: str) -> str:\n\n artist = self.just_replace_strings_with_dashes(artist)\n song = self.just_replace_strings_with_dashes(song)\n\n url = self.gen_url + artist + '-' + song + '-lyrics'\n\n resp = requests.get(url)\n\n if resp.status_code == 200:\n try:\n content = bs4.BeautifulSoup(resp.content)\n lyrics = content.text[content.text.rindex(\n '[Verse 1]'):content.text.index('Embed')]\n lyrics = self.clean_lyrics_response(lyrics)\n return lyrics\n\n except (ValueError, IndexError) as e:\n print('Lyrics not found {}, due to error {}'.format(song, e))\n\n try:\n lyrics = content.text[content.text.rindex(\n '[Verse]'):content.text.index('Embed')]\n lyrics = self.clean_lyrics_response(lyrics)\n return lyrics\n\n except ValueError as e:\n print(\n 'Lyrics not found {}, due to error {}, single verse song'.format(song, e))","def set_lyrics(self, lyrics: str) -> None:\n self.lyrics = lyrics","async def yt_info(self, song):\n API_KEY = 'API_KEY'\n youtube = build('youtube', 'v3', developerKey=API_KEY)\n song_data = youtube.search().list(part='snippet').execute()\n return song_data[0]","def get_lyrics_url(non_lyrics_url, driver=None):\n if not driver:\n driver = get_browser()\n driver.get(non_lyrics_url)\n song_name = get_current_song_name(driver)\n search_url = \"https://www.youtube.com/results?search_query=\" + song_name + \" lyrics lyrical words\"\n driver.get(search_url)\n driver.find_element_by_id(\"video-title\").click()\n return driver.current_url","def is_lyrics_approved():","def get_user_input(self, widget, data = None):\n # Parse user input\n artist = self.clean_user_input(self.artist_name.get_text())\n song = self.clean_user_input(self.song_name.get_text())\n self.get_lyrics(artist, song)","def song_view(song_id):\r\n querystring = apiurl_musixmatch + \"track.lyrics.get?track_id=\" + urllib2.quote(\r\n song_id) + \"&apikey=\" + apikey_musixmatch + \"&format=plain\"\r\n try:\r\n request = urllib2.Request(querystring)\r\n # timeout set to 4 seconds; automatically retries\r\n response = urllib2.urlopen(request, timeout=4)\r\n # raw = response.read()\r\n print colored.green(\"Starting\", bold=12)\r\n all_data = ''\r\n while True:\r\n do_task()\r\n print '\\b.'\r\n sys.stdout.flush()\r\n data = response.read(2048)\r\n if not data:\r\n break\r\n all_data += data\r\n time.sleep(0.4)\r\n print \"\\n\"\r\n json_obj = json.loads(all_data.decode(\"utf-8\"))\r\n body = len(json_obj[\"message\"][\"body\"])\r\n if body == 0:\r\n print colored.red(\"No lyrics found\", bold=12)\r\n else:\r\n print colored.cyan(json_obj[\"message\"][\"body\"][\"lyrics\"][\"lyrics_body\"], bold=12)\r\n except socket.timeout:\r\n print \"Timeout raised and caught\"","def songInfo():\n \n global songFile, currentRadio\n \n lines = songFile.readlines()\n if len(lines) > 0:\n\n songFile.seek(0)\n title = formatSong(lines[0]).strip()\n \n with canvas(device) as draw:\n invert(draw, 0, 0, names[currentRadio][0], True)\n if len(title)<19:\n draw.text((72-4*(len(title)), 20), title , fill=\"white\")\n else:\n lineNum = len(title)\n if lineNum > 72:\n lineNum = 72\n thelist = [title[i:i+19] for i in range(0, lineNum, 19)]\n for i in range(len(thelist)): \n draw.text((81-4*(len(thelist[i].strip())), 19+10*i), thelist[i] , fill=\"white\")","def rhymeindex(self, lyrics):\n rhyme_master_list = []\n print(\"Building list of rhymes:\")\n for line in lyrics:\n rhymescheme = self.line_rhymescheme(line)\n rhyme_master_list.append(rhymescheme)\n\n rhyme_master_list = list(set(rhyme_master_list))\n reverselist = [x[::-1] for x in rhyme_master_list]\n reverselist = sorted(reverselist)\n rhymelist = [x[::-1] for x in reverselist]\n\n print(\"List of Sorted 2-Letter Rhyme Ends:\")\n print(rhymelist)\n f = open(self.rhyme_filename, \"w\", encoding='utf-8')\n f.write(\"\\n\".join(rhymelist))\n f.close()\n return rhymelist","def readSong(filename = None):\n if filename == None: return []\n songFile = open(filename, \"r\")\n song = []\n lineNumber = 1\n for line in songFile:\n notes = line.split(\";\")\n for n in notes:\n _parseSongLine(song, n, lineNumber, filename)\n lineNumber += 1\n songFile.close()\n return song","def get_liked_songs(self, station_id):\n\n feedbacks = self.get_station_feedbacks(station_id)\n songs = []\n for feedback in feedbacks:\n songs.append({\n \"name\": feedback[\"songTitle\"],\n \"album\": feedback[\"albumTitle\"],\n \"artist\": feedback[\"artistName\"]\n })\n return songs","def getAllSongs(self):\n return self.__songDictionary","def generate_list(self):\n with open(self.index_file, \"r\") as fh:\n original_songs = [line.rstrip() for line in fh.readlines()]\n \n if self.search_terms:\n # refine using search terms\n self.songs = []\n for st in self.search_terms:\n refined_songs = original_songs\n for s in st:\n refined_songs = [song for song in refined_songs \n if s.lower() in song.lower()]\n self.songs += sorted(refined_songs)\n else:\n self.songs = original_songs\n \n # If we've specified a num_songs, slice out this much\n if self.num_songs: \n self.songs[:] = self.songs[:self.num_songs] \n else:\n self.num_songs = len(self.songs)","def track_similar(req):\n\n artist = req.get('result').get('parameters').get('artist')\n track = req.get('result').get('parameters').get('track')\n logger.info('received {0} request for artist=\"{1}\", track=\"{2}\"'.format('track_similar', artist, track))\n sim_tracks = cached_result('get_similar_tracks', [artist, track], {})\n speech = 'Unable to locate similar tracks for song {track} by {artist}'.format(\n track=track, artist=artist)\n\n if sim_tracks and len(sim_tracks) > 0:\n speech = 'The following songs are similar to {track} by {artist}'.format(\n track=track, artist=artist)\n for track in sim_tracks:\n speech += '. ' + track[0] + ' by ' + track[1]\n\n return jsonify(\n {'speech': speech,\n 'displayText': speech,\n 'source': 'last-assist'}\n )","def song2text(song):\n text = \"\"\n for tup in song:\n if len(tup) == 2:\n f, d = tup\n text += \"%s %s; \" % (_getNoteFromFrequency(f), d)\n elif len(tup) == 3:\n f1, f2, d = tup\n text += \"%s %s %s; \" % (_getNoteFromFrequency(f1),\n _getNoteFromFrequency(f2), d)\n return text","def search_song(self, name):\n self.logger.debug('Searched for Song: {}'.format(name))\n results = self.sp.search(q='track:' + name, type='track')\n songs = [song for song in results['tracks']['items']]\n i = 1\n songs_ls = []\n table_ls = []\n for song in songs:\n table_ls.append([i,\n song['name'][0:20].strip(),\n song['album']['name'][0:20].strip(),\n \"%0.2f\" % (song['duration_ms'] / 60000),\n song['popularity']])\n songs_ls.append(song['uri'])\n i = i + 1\n return songs_ls, table_ls","def loadLyrics(dirName):\n lyricsDir = os.path.dirname(os.path.abspath(__file__)) + \"/lyrics/\"\n artistDir = os.path.join(lyricsDir, dirName) + \"/\"\n\n if not os.path.isdir(artistDir):\n print \"No artist named\", artistDir, \"in directory\", lyricsDir\n return None\n\n lyrics = []\n\n songs = os.listdir(artistDir)\n for song in songs:\n with open(artistDir + song, 'r') as songFile:\n songLines = songFile.readlines()\n\n # clean each line in each song and add if not empty\n for line in songLines:\n line = line.translate(None, string.punctuation)\n line = line.lower().strip()\n if line:\n lyrics.append(line.split())\n return lyrics","def listSongNameAndArtists(self, resultList, initIndex=0):\n stringToReturn = '' \n for r in range(len(resultList)):\n stringToReturn += f\"{r + initIndex + 1}) {resultList[r]['name']} by {self.listAllArtistsInResult(resultList[r])}\\n\"\n\n return stringToReturn","def _run_lyrics_gui(self):\n self._log.info(\"Searching for lyrics\")\n\n self.save_lyrics(find=True)\n Action(\"load\", load=True)\n\n self._log.info(\"Done\")","def get_songs_by_artist(artist, linesep=' \\n ', timeout=None):\n df = pd.DataFrame(columns=['Artist', 'Title'])\n url = \"https://lyrics.fandom.com/wiki/Category:Songs_by_\"+urlize(artist)\n df = parse_page_now(url,df)\n return df","def get_song_info(self, song_id):\n return self.__get('song', song_id)","def first_words_func():\n return_list = []\n for lyric in lyrics:\n for line in lyric.split(\"\\n\"):\n return_list.append(line.split(\" \")[0])\n return (return_list)","def list(ctx):\n\tfor songName in songs:\n\t\tyield from bot.send_message(ctx.message.author,songName)","def fetch_song_data(url):\r\n response = requests.get(url)\r\n return response.text","def get_texts(self) -> List[str]:\n return self.texts","def getnotes():","def lyrics2words(lyrics):\r\n words = word_tokenize(lyrics.decode('utf8'))\r\n words = clean(words)\r\n return words","def last_50_played_songs_to_txt(username,scope,redirect_uri,client_id,client_secret):\r\n sp = spotipy.Spotify(auth_manager=SpotifyOAuth(scope=scope, \r\n client_id=CLIENT_ID,\r\n client_secret=CLIENT_SECRET,\r\n redirect_uri=redirect_uri,\r\n username = username\r\n ))\r\n \r\n with open('last_50_played_songs.txt','w',encoding=\"utf-8\") as txt:\r\n txt.write('Listing the last ({}) played songs:'.format(len(sp.current_user_recently_played()['items']))+'\\n')\r\n txt.write('-------------------------------------------------------'+'\\n')\r\n txt.write('-------------------------------------------------------'+'\\n')\r\n for i in range(len(sp.current_user_recently_played()['items'])): \r\n txt.write('artist(s): '+str(sp.current_user_recently_played()['items'][i]['track']['artists'][0]['name'])+'\\n')\r\n txt.write('song title: '+str(sp.current_user_recently_played()['items'][i]['track']['name'])+'\\n')\r\n txt.write('album: '+str(sp.current_user_recently_played()['items'][i]['track']['album']['name'])+'\\n')\r\n txt.write('popularity: '+str(sp.current_user_recently_played()['items'][i]['track']['popularity'])+'\\n')\r\n txt.write('href: '+str(sp.current_user_recently_played()['items'][i]['track']['href'])+'\\n')\r\n txt.write('-------------------------------------------------------'+'\\n')\r\n txt.write(str(sp.current_user_recently_played()['items'][i]['played_at'])+'\\n')\r\n txt.write('-------------------------------------------------------'+'\\n')\r\n txt.write(str(sp.current_user_recently_played()['items'][i]['context'])+'\\n')\r\n txt.write('-------------------------------------------------------'+'\\n')\r\n \r\n \r\n return None","def song_by_word(ans):\r\n songs_list = \"\"\r\n ans = ans.lower()\r\n albums = simple_album_list()\r\n for album in albums:\r\n songs = simple_songs_list(album)\r\n for song in songs:\r\n song = str(song)\r\n if ans in song.lower():\r\n songs_list += song + \", \"\r\n return songs_list[:-2]","def getOrderedSongList(self):\n judgesExcelLogger.info(\"getOrderedSongList: Attempting to get ordered song list \"\n \"of set '%s'\", self.setName)\n try:\n os.chdir(self.path) # Change to set's directory context\n with open(self.notesFiles[0], encoding=\"utf-8-sig\") as judgeFile:\n for line in judgeFile:\n if line.startswith('['):\n self.getSongWithStepartist(line)\n judgeFile.close()\n except:\n judgesExcelLogger.warning(\"getOrderedSongList: {0}: {1}\".format(sys.exc_info()[0].__name__,\n str(sys.exc_info()[1])))","def api_getmessage():\n message = receive_lyrics()\n if message != \"\":\n return jsonify(ready=True, msg=message)\n else:\n return jsonify(ready=False)","def tag_lyrics(data):\r\n\r\n # Initialize list to store tagged lyrics\r\n tagged_documents = []\r\n\r\n # Tag lyrics for all the lyrics in the list\r\n for i, doc in enumerate(data):\r\n\r\n # Tag lyrics\r\n tagged = TaggedDocument(doc, [i])\r\n\r\n # Append tagged lyrics to\r\n tagged_documents.append(tagged)\r\n\r\n return tagged_documents","def get_playlist_songs(self, playlist_id):\n url = get_playlist_url(playlist_id)\n result = self.get_request(url)\n return result['result']['tracks'], result['result']['name']","def query_get_song_recommendation(songtitle, artist, root):\n for child in root:\n if (song_information.get_songtitle(child) == songtitle\n and song_information.get_artist(child) == artist):\n song = child\n else:\n answer = (\"Sorry, '\" + songtitle + \"' by \" + artist\n + \"could not be found in this corpus\")\n similar_songs = find_similar_songs(song, root)\n if len(similar_songs) > 0:\n answer = (\"If you like '\" + songtitle + \"' by \" + artist\n + \", you might like \" + \", \".join(similar_songs))\n else:\n answer = (\"Sorry, there is no similar song to '\" + songtitle + \"' by \"\n + artist + \" in this corpus\")\n return answer","def get_all_song_names(self):\n try:\n # Auto-close\n with closing(self.connection) as con:\n # Auto-commit\n with con:\n # Auto-close\n with closing(con.cursor()) as cursor:\n cursor.execute(\"\"\"\n SELECT name\n FROM nodes\n WHERE type = \"song\";\n \"\"\")\n return [x[0] for x in cursor.fetchall()]\n except sqlite3.OperationalError as e:\n print(\"ERROR: Could not retrieve songs: {}\".format(str(e)))\n return []","def get(self, request, *args, **kwargs):\n return super(LongestArtistSongView, self).get(request, query=app.LONGEST_ARTIST_SONG, *args, **kwargs)","def get_songs_of_artist(self, artist_id: int):\n\t\tartist = self.db.artists.find_one({'id': artist_id})\n\t\treturn artist['songs']","def get_text(self) -> List[str]:\n return self.__texts","def search_song(title, artist):\n\ttitle = quote(title, safe='')\n\tartist = quote(artist, safe='')\n\tbase_url = SPOTIFY_API_HOST + 'search/' + '?q=track:{0}+artist:{1}&type=track&limit=1'\n\turl = base_url.format(title, artist)\n\tresults = requests.get(url).json()\n\n\ttry:\n\t\tif results['tracks']['total'] == 0:\n\t\t\tlogging.debug('Found no results for song {0}'.format(title))\n\t\t\treturn ''\n\texcept KeyError as e:\n\t\tlogging.warning('Invalid result from spotify on key {0}:\\n{1}'.format(e, results))\n\turi_string = results['tracks']['items'][0]['uri']\n\tlogging.debug('Found uri {0} for song {1}'.format(\n\t\turi_string[uri_string.rfind(':')+1:], title))\n\treturn uri_string[uri_string.rfind(':')+1:] # Strip off the 'spotify:track:' tag.","def scrape_all_songs():\n print('Scraping all songs from {}'.format(URL))\n\n soup = scrapekit.handle_url(URL)\n song_elements = []\n tables = soup.findAll('table')\n\n for t in tables:\n field_index = scrapekit.get_col_index(t, field_name=\"Song\")\n\n if field_index:\n song_elements.extend(scrapekit.scrape_table_col(t, field_index))\n\n links = []\n for element in song_elements:\n l = element.find('a')\n if l:\n links.append(PREFIX + l.attrs.get('href', ''))\n return links","def artist_song_first_pass(self):\n log.debug(\"Called artist_song_first_pass for %s.\" % self.name)\n self.success = False\n song_potentials = []\n potential_count = 0\n _min = 20\n\n def generate_potentials(count):\n results = self.sp.search(q= 'artist: ' + self.artist + ' track: ' + self.song, type='track', limit=2)\n if results['tracks']['total'] >= 1:\n for items in results['tracks']['items']:\n song_potentials.append([items['name'], items['uri']])\n for artist in items['artists']:\n song_potentials[count].append(artist['name'])\n song_potentials[count].append(artist['uri'])\n count += 1\n\n for splitter in splitters:\n if self.name_clean.count(splitter) == 1:\n self.artist, self.song = self.name_clean.split(splitter)\n generate_potentials(potential_count)\n elif self.name_clean.count(splitter) > 1:\n for x in range(0, self.name_clean.count(splitter)):\n self.artist, self.song = split(self.name_clean, splitter, x)\n generate_potentials(potential_count)\n\n cutoff = matching(self.name_clean)\n log.debug(\"%s potential matches found for %d\" % (len(song_potentials), id(self)))\n log.debug(\"Potentials: %s\" % song_potentials)\n for potential in song_potentials:\n log.debug(potential)\n log.debug(self.name_clean)\n log.debug(str(potential[2]) + \" \" + str(potential[0]))\n lev = levenshtein(self.name_clean, str.lower(str(potential[2])) + \" \" + str.lower(str(potential[0])))\n log.debug(lev)\n if lev < _min:\n _min = lev\n self.artist = potential[2]\n self.artist_uri = potential[3]\n self.song = potential[0]\n self.song_uri = potential[1]\n\n if self.artist_uri and self.song_uri is not None:\n log.debug(\"Cutoff point for %s : %d\" % (id(self), cutoff))\n log.debug(\"Current Min: {}\".format(_min))\n log.debug(\"Levenshtein distance between {} and {} : {}\"\n .format(self.name_clean, self.artist + self.song,\n levenshtein(self.name, self.artist + \" \" + self.song)))\n if int(_min) > cutoff:\n log.debug(\"Method artist_song_first_pass failed for %s.\" % self.name)\n self.success = False\n self.artist = None\n self.song = None\n else:\n log.debug(\"Method artist_song_first_pass succeeded for %s.\" % self.name)\n self.success = True\n else:\n log.debug(\"Method artist_song_first_pass failed for %s.\" % self.name)\n self.success = False\n self.artist = None\n self.song = None","def getWords(speech):\r\n return speech.split()","def getSong(self):\n queue = self.instantiate_queue()\n song_data = queue.pop(0)\n\n history = self.instantiate_history()\n history_song_data = deepcopy(song_data)\n history_song_data['time_played'] = time() + 5\n history.append(history_song_data)\n\n if len(queue) < 5:\n self.addImplicit(queue, history)\n \n self.ageSongs(queue)\n self.calculateScore(queue)\n queue = self.sortSongs(queue)\n\n self.cache.set('queue', queue)\n self.cache.set('history', history)\n\n keys = ['name', 'track_id', 'artist', 'album_uri', 'album_name', 'duration', 'explicit', 'valence', 'energy']\n args = [song_data[key] for key in keys]\n return Song(*args)","def songs_list(name_of_album):\r\n songs = \"\"\r\n data = dbase()\r\n data = data[name_of_album][0]\r\n for song in data.keys():\r\n songs += song\r\n songs += \", \"\r\n return songs[:-2]","def get_artist_songs(self,genre = \"[Not Provided]\"):\n # Search for the artist and get their id\n search_artist = self.search(self.artist_name)\n\n #Prevents the stoppage in case of an Artist having zero lyrics on Genius\n if len(search_artist['response']['hits']) == 0:\n return False\n \n artist_id = str(search_artist['response']['hits'][0]['result']['primary_artist']['id'])\n print(\"ID: \" + artist_id)\n # Initialize DataFrame\n df = pd.DataFrame(columns=['title', 'url'])\n # Iterate through all the pages of the artist's songs\n more_pages = True\n page = 1\n i = 0\n while more_pages:\n # Make a request to get the songs of an artist on a given page\n request_url = self.base_url + 'artists/' + artist_id + '/songs' + '?per_page=50&page=' + str(page)\n response = requests.get(request_url, headers=self.headers).json()\n\n # For each song which the given artist is the primary_artist of the song, add the song title and\n # Genius URL to the DataFrame\n for song in response['response']['songs']:\n if str(song['primary_artist']['id']) == artist_id:\n title = song['title']\n url = song['url']\n df.loc[i] = [title, url]\n i += 1\n page += 1\n\n if response['response']['next_page'] is None:\n more_pages = False\n\n \n # Get the HTML and Song Lyrics from helper methods in the class\n df['artist'] = self.artist_name\n df['html'] = df['url'].apply(self.get_song_html)\n df['lyrics'] = df.apply(lambda row: self.get_lyrics(row.html), axis=1)\n #Uncomment to use the genre method otherwise\n #df['genre'] = df.apply(lambda row: self.get_genre(row.html), axis=1)\n df['genre'] = genre\n \n del df['url']\n del df['html']\n\n self.artist_songs = df\n\n return self.artist_songs","def read_ams(self):\n current = time.time()\n try:\n if current - self.start > 3:\n self.track_artist = not self.track_artist\n self.start = time.time()\n if self.track_artist:\n data = self.ams.artist\n if not self.track_artist:\n data = self.ams.title\n except (RuntimeError, UnicodeError):\n data = None\n\n if data:\n data = data[:16] + (data[16:] and '..')\n\n return data","def print_songs(self):\n\t\tfor i,s in enumerate(self._songs):\n\t\t\tprint('{0}. {1}'.format(i, s.print_info()))","def get_songs(self, offset=None):\n return self.__get('songs')","def description(self):\n return f\"{self.name} has {len(self.playlist)} songs.\"","async def search(self, ctx: commands.Context, *, query: t.Optional[str]) -> None:\n if query is None:\n # Maybe the user didn't know to pass in a query?\n embed = discord.Embed(colour=Colours.regular, timestamp=Embeds.now())\n embed.description = (\n \"No query passed in. Try passing in something: `$search arabic music`\"\n )\n embed.set_footer(\n text=\"See $help voice for more commands.\", icon_url=Icons.info\n )\n return await ctx.send(embed=embed)\n\n if (results := await self.get_tracks(query, True, False)) is not None:\n # Ensure that we're connected before playing.\n await ctx.invoke(self.connect, channel=None)\n player = self.get_player(ctx.guild)\n if not player.is_connected:\n return\n\n embed = discord.Embed(colour=Colours.regular, timestamp=Embeds.now())\n embed.set_footer(\n text=f\"Showing 5/{len(results)} results.\",\n icon_url=ctx.author.avatar_url,\n )\n embed.description = \"\"\n results = results[:5]\n\n for index, track in enumerate(results, 1):\n m, s = self.get_formatted_length(track.length, True)\n embed.description += (\n f\"**{index}**. [{track.title}]({track.uri}) ({m}:{s})\\n\"\n )\n\n # Get a integer selection using Choice.prompt().\n if (\n choice := await Choices.prompt(\n ctx=ctx, embed=embed, n=5, author_only=True\n )\n ) is None:\n if player.queue.empty:\n await ctx.invoke(self.disconnect)\n return\n\n embed = discord.Embed(\n title=\"Now queued.\" if player.is_playing else \"Now playing.\",\n description=f\"[{results[choice].title}]({results[choice].uri})\",\n colour=Colours.regular,\n timestamp=Embeds.now(),\n )\n\n m, s = self.get_formatted_length(results[choice].length, False)\n embed.set_footer(\n text=f\"Track goes for {m} minutes and {s} seconds.\",\n icon_url=ctx.author.avatar_url,\n )\n if results[choice].thumb is not None:\n embed.set_thumbnail(url=results[choice].thumb)\n await ctx.send(embed=embed)\n\n player.queue.add_tracks(results[choice])\n if not player.is_playing:\n await player.playback()\n else:\n fail = Embeds.status(success=False, desc=\"Failed to find any results.\")\n await ctx.send(embed=fail)","def get_songs_via_title():\n\n title = request.args.get('title')\n\n songs_detail = mod.get_songs_details_via_title(title)\n\n return jsonify(songs_detail)"],"string":"[\n \"def lyrics(self):\\n return get_lyrics(self.artist, self.title,'')\",\n \"def get_lyrics(self):\\n\\t\\treturn self._lyrics_list\",\n \"def get_lyrics(self):\\n url = 'http://api.lyricsnmusic.com/songs?api_key=[5358b25688164e6c2f771954f17460&q]=' + self.artist + '%20' + self.name\\n r = requests.get(url)\\n r_text = r.text\\n for (old, new) in [('false', 'False'), ('true', 'True'), ('null', 'None')]:\\n r_text = r_text.replace(old, new)\\n r_text_as_data = eval(r_text)\\n if len(r_text_as_data) != 0:\\n r_text_dict = r_text_as_data[0]\\n return r_text_dict['snippet']\\n else:\\n return ''\",\n \"def lyrics(self) -> str:\\n if self._lyrics == None:\\n response = self._web_session.request(\\\"GET\\\", self.path)\\n soup = BeautifulSoup(response.content, \\\"html.parser\\\")\\n lyrics_div = soup.find(\\\"div\\\", class_=re.compile(\\\"^lyrics$|Lyrics__Root\\\"))\\n if lyrics_div:\\n self._lyrics = lyrics_div.get_text(separator=\\\"\\\\n\\\")\\n else:\\n self._lyrics = \\\"\\\"\\n\\n return self._lyrics\",\n \"def song_lyrics(ans):\\r\\n albums = simple_album_list()\\r\\n for album in albums:\\r\\n songs = simple_songs_list(album)\\r\\n for song in songs:\\r\\n if ans == song:\\r\\n words = dbase()[album][0][song]\\r\\n words = words[2]\\r\\n return words\",\n \"def get_lyrics(artist, song, language='', linesep='\\\\n', timeout=None):\\n return get_all_lyrics(artist, song, language, linesep, timeout)[0]\",\n \"def get_lyrics(self, artist, song):\\n\\n # Disable lyrics display\\n self.status_bar.hide()\\n self.lyrics_view.hide()\\n self.scroll.hide()\\n\\n lyrics = None\\n in_database = False\\n\\n if self.database.status: # Testing connection to database\\n lyrics = self.database.retrieve_lyrics(artist, song)\\n if lyrics: # False if not found in database\\n in_database = True\\n\\n if not lyrics: # Try next to retrieve from web\\n url = self.make_url(artist, song)\\n try:\\n lyrics = self.fetch_lyrics(url)\\n except:\\n self.display_message('Internet Connection Problem') # Could not connect to internet\\n return\\n\\n if not lyrics: # Not available in database or on web\\n self.display_message('Lyrics Not Available')\\n else:\\n # Set the display\\n lyrics_buffer = self.lyrics_view.get_buffer()\\n lyrics_buffer.set_text(lyrics)\\n\\n if not in_database: # Save if not in database\\n self.database.save(artist, song, lyrics)\\n\\n # Re-enable lyrics display\\n self.scroll.show()\\n self.lyrics_view.show()\\n self.display_message('Lyrics Extracted Successfully')\",\n \"async def _lyrics(self, ctx: commands.Context):\\n if not ctx.voice_state.is_playing:\\n raise commands.CommandError('Nothing being played at the moment.')\\n\\n # Get song name listed on youtube\\n song_title = ctx.voice_state.current.source.track\\n if not song_title:\\n return await ctx.send(\\\"Couldn't find lyrics for this track!\\\")\\n\\n song_title = re.sub(\\\"[(\\\\[].*?[)\\\\]]\\\", \\\"\\\", song_title).strip() # Remove parenthesis from song title\\n # Get artist name listed on youtube\\n artist_name = ctx.voice_state.current.source.artist\\n # Instance of GeniusSong class using the Genius API\\n genius_song = GeniusSong(song_title, artist_name)\\n # Try getting the lyrics using the lyricsgenius library\\n lyrics = genius_song.fastlyrics()\\n\\n # In case of no lyrics found. Use the other (slower) method\\n if not lyrics:\\n res = genius_song.get_response() # Generate a response using the Genius API to get the songs\\n if res:\\n # Find the most similar artist comparing the artist on YouTube and Genius\\n artist_name = genius_song.return_similar_artist(res)\\n # Artist didn't match\\n if not artist_name:\\n await ctx.send(\\\"Couldn't find similar artists. The lyrics might not be the expected.\\\")\\n\\n # Get the lyrics using the lyricsgenius library with the new artist\\n lyrics = genius_song.fastlyrics(artist_name)\\n\\n else:\\n return await ctx.send(\\n \\\"**Error!**\\\\nThere is a problem with Genius.\\\\nTry again in a few minutes. \\\"\\n \\\"\\\\nYou can also try the command `fastlyrics`.\\\")\\n\\n if lyrics:\\n # Split lyrics into fields\\n fields = genius_song.split_lyrics(lyrics)\\n # Create an embed message\\n embed = embed_msg(\\n title=song_title.capitalize() + \\\"\\\\n{}\\\".format(artist_name),\\n description=\\\"\\\",\\n footer=\\\"Lyrics provided by Genius.\\\",\\n field_values=fields,\\n inline=False\\n )\\n return await ctx.send(embed=embed)\\n\\n return await ctx.send(\\\"Lyrics couldn't be found.\\\")\",\n \"def get_lyrics(self) -> Optional[str]:\\n return self.lyrics\",\n \"async def lyrics(\\n self, ctx: commands.Context, query: str = None\\n ) -> Optional[Tuple[str, str, str]]:\\n\\n query = await self.now_playing(ctx) if query is None else query\\n if not query:\\n return\\n\\n url = f\\\"https://some-random-api.ml/lyrics?title={query}\\\"\\n\\n async with aiohttp.ClientSession() as session:\\n request = await session.get(url)\\n request_json = await request.json(content_type=None)\\n\\n authors = request_json.get(\\\"author\\\")\\n title = request_json.get(\\\"title\\\")\\n lyrics = request_json.get(\\\"lyrics\\\")\\n\\n return (title, authors, lyrics) if lyrics else None\",\n \"def lyrics_plaintext(song):\\n output = \\\"\\\"\\n\\n song = validate_song(song)\\n\\n output += song.default_arrangement\\n output += \\\"\\\\n\\\\n\\\\n\\\\n\\\"\\n output += song.composer\\n output += \\\"\\\\n\\\"\\n output += song.copyright\\n output += \\\"\\\\n\\\\n\\\"\\n\\n for section, lyrics in song.lyrics.items():\\n output += section\\n output += \\\"\\\\n\\\"\\n output += lyrics\\n output += \\\"\\\\n\\\\n\\\"\\n return output\",\n \"def get_lyrics(self, html):\\n #gets lyricks trough a css selector\\n raw_lyrics = html.select('div[class*=\\\"Lyrics__Container\\\"]')\\n if len(raw_lyrics) == 0:\\n raw_lyrics = html.select('div[class=\\\"lyrics\\\"]')\\n\\n lyrics = [] \\n for lyric in raw_lyrics:\\n temp_lyrics = re.sub(r'[\\\\(\\\\[].*?[\\\\)\\\\]]', '', lyric.get_text()).strip()\\n temp_lyrics = re.sub('\\\\n+', '', temp_lyrics)\\n lyrics.append(re.findall('[A-Z][^A-Z]*', temp_lyrics))\\n\\n all_words = ''\\n # Format lyrics \\n for section in lyrics:\\n if len(section) == 0:\\n continue\\n\\n for verse in section:\\n all_words += verse.strip() + \\\"[*]\\\"\\n \\n return all_words\",\n \"def get_single_lyrics(self, url):\\n r = requests.get(url)\\n soup = BeautifulSoup(r.text, 'html.parser')\\n lyrics = ''\\n \\n all_divs = soup.findAll('div')\\n filtered_divs = [x for x in all_divs if x.has_attr('class') and ('Lyrics__Container-sc' in x['class'][0] or x['class'] == ['lyrics'])]\\n filtered_divs_classes = [x['class'] for x in filtered_divs if x.has_attr('class')]\\n \\n if len(filtered_divs) == 0:\\n lyrics = ''\\n elif len(filtered_divs) == 1 and filtered_divs_classes[0][0] == 'lyrics':\\n lyrics = filtered_divs[0].text\\n else:\\n for part in filtered_divs:\\n for e in part.descendants:\\n if isinstance(e, str):\\n lyrics += e.strip()\\n elif e.name == 'br' or e.name == 'p':\\n lyrics += '\\\\n'\\n \\n return lyrics\",\n \"def get_all_lyrics(artist, song, language='', linesep=' \\\\n ', timeout=None):\\n url = create_url(artist, song, language)\\n response = _requests.get(url, timeout=timeout)\\n soup = _BeautifulSoup(response.content, \\\"html.parser\\\")\\n lyricboxes = soup.findAll('div', {'class': 'lyricbox'})\\n\\n if not lyricboxes:\\n raise LyricsNotFound('Cannot download lyrics')\\n\\n for lyricbox in lyricboxes:\\n for br in lyricbox.findAll('br'):\\n br.replace_with(linesep)\\n\\n return [lyricbox.text.strip() for lyricbox in lyricboxes]\",\n \"def getLyricsFromSong(songLink):\\n try:\\n html = urllib.request.urlopen(songLink).read()\\n soup = bs4.BeautifulSoup(html, 'html.parser')\\n soup = soup.find(\\\"pre\\\")\\n text = soup.contents[0].strip().split(\\\"\\\\n\\\")[5:]\\n except:\\n return \\\".\\\\n.\\\"\\n\\n clean_text = \\\"\\\"\\n lyrics_list=[]\\n for line in text:\\n lyrics_list.append(line)\\n clean_text += line + \\\"\\\\n\\\"\\n return clean_text\",\n \"def get_existing_lyrics(self, song_id):\\n\\t\\tlyrics = self.db.lyrics.find_one({'song_id': song_id})['lyrics']\\n\\t\\treturn lyrics\",\n \"def fetch_lyrics(self) -> None:\\n if self.artist is None or self.title is None:\\n return\\n Logger.Logger.log('Looking for song lyrics...')\\n finder = LyricsFinder.LyricsFinder(self)\\n finder.fetch()\\n self.lyrics = finder.get_lyrics()\\n self.lyrics_writer = finder.get_lyrics_writer()\\n if not self.lyrics:\\n Logger.Logger.log('No lyrics found for this song.')\",\n \"def get_lyrics(self, name: str, artists: List[str], **_) -> Optional[str]:\\n\\n # Join every artist by comma in artists\\n artist_str = \\\", \\\".join(artist for artist in artists if artist)\\n\\n song_name = name.replace(\\\" \\\", \\\"+\\\").lower()\\n song_artists = artist_str.replace(\\\" \\\", \\\"+\\\").lower()\\n song_artists = song_artists.replace(\\\",\\\", \\\"%2C\\\")\\n\\n url = f\\\"https://search.azlyrics.com/search.php?q={song_name}+{artists}\\\"\\n\\n response = requests.get(url, headers=self.headers)\\n soup = BeautifulSoup(response.content, \\\"html.parser\\\")\\n\\n td_tags = soup.find_all(\\\"td\\\")\\n if len(td_tags) == 0:\\n return None\\n\\n result = td_tags[0]\\n\\n a_tags = result.find_all(\\\"a\\\", href=True)\\n if len(a_tags) != 0:\\n lyrics_url = a_tags[0][\\\"href\\\"]\\n else:\\n return None\\n\\n if lyrics_url.strip() == \\\"\\\":\\n return None\\n\\n response = requests.get(lyrics_url, headers=self.headers)\\n soup = BeautifulSoup(response.content, \\\"html.parser\\\")\\n\\n # Find all divs that don't have a class\\n div_tags = soup.find_all(\\\"div\\\", class_=False, id_=False)\\n\\n # Find the div with the longest text\\n lyrics_div = sorted(div_tags, key=lambda x: len(x.text))[-1]\\n\\n lyrics = lyrics_div.get_text()\\n\\n # Remove the 3 first new lines\\n lyrics = lyrics[3:]\\n\\n return lyrics\",\n \"def print_lyrics(self):\\n\\t\\tprint(self._lyrics_list)\",\n \"def scrape_song(url):\\n soup = scrapekit.handle_url(url)\\n\\n contents = scrape_id_to_div(soup, \\\"Lyrics\\\")\\n if not contents:\\n return None\\n\\n filetext = ''.join(c.text for c in contents)\\n\\n # Check if there is a reprise\\n REPRISE = 'Reprise'\\n\\n reprise = soup.find(id=REPRISE)\\n if reprise:\\n filetext += '\\\\n\\\\n'\\n filetext += REPRISE + ':\\\\n\\\\n'\\n\\n contents = scrape_id_to_div(soup, REPRISE)\\n filetext += ''.join(c.text for c in contents)\\n\\n # Get song title, fix blank spaces for file name\\n songtitle = soup.title.text.split('|')[0]\\n\\n song_text = ''\\n song_text += 'Song: {}\\\\n'.format(songtitle)\\n song_text += get_infobox_info(soup)\\n song_text += '\\\\n\\\\n'\\n song_text += filetext\\n\\n return song_text\",\n \"def add_lyrics(self):\\n\\n conn = self.conn\\n conn.text_factory = str\\n c = conn.cursor()\\n\\n c.execute(\\\"SELECT songs.id, artist, title, url FROM songs LEFT JOIN lyrics ON songs.id = lyrics.song_id WHERE lyrics.song_id IS NULL\\\")\\n all_songs_to_scrape = c.fetchall()\\n for song in all_songs_to_scrape:\\n song_id = song[0]\\n song_artist = song[1]\\n song_title = song[2]\\n song_url = song[3]\\n print(\\\"Looking for lyrics for \\\" + song_title + \\\" by \\\" + song_artist)\\n try:\\n lyrics = pygenius_songs.searchURL(song_url, 'lyrics')\\n for lyric in lyrics:\\n for line in lyric.split('\\\\n'):\\n c.execute('INSERT INTO lyrics(song_id, line) VALUES (?,?)', (song_id, line))\\n conn.commit()\\n except Exception as e:\\n print(e)\\n print song_url\\n print(\\\"Exception caught! ... continuing.\\\")\\n pass\",\n \"def record_lyrics_result(self, track_id, songdata):\\n self.lyrics.insert_one(\\n {\\n \\\"_id\\\": track_id,\\n \\\"response_artist\\\": songdata.artist,\\n \\\"response_title\\\": songdata.title,\\n \\\"lyrics\\\": songdata.lyrics,\\n }\\n )\",\n \"def get_lyrics_text(lyrics_url):\\n\\n headers = {\\n 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',\\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',\\n 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',\\n 'Accept-Encoding': 'none',\\n 'Accept-Language': 'en-US,en;q=0.8',\\n 'Connection': 'keep-alive'\\n }\\n\\n page_html = utils.get_request(lyrics_url, headers=headers)\\n if page_html:\\n bsoup = BeautifulSoup(page_html, \\\"lxml\\\")\\n lyrics_text = bsoup.find('div', {'class': 'lyrics'}).text\\n return utils.ascii_string(lyrics_text)\\n else:\\n return None\",\n \"def get_song_list(self):\\n return self.song_list\",\n \"def get_existing_lyrics_of_artist(self, artist_name=None, artist_id=None):\\n\\t\\tif artist_name:\\n\\t\\t\\tsongs = self.db.artists.find_one({'name': str(artist_name).lower()})\\n\\t\\t\\tlyrics = []\\n\\t\\t\\tfor song in songs:\\n\\t\\t\\t\\tlyrics.append((song, self.get_existing_lyrics(song)))\\n\\t\\t\\treturn lyrics\\n\\t\\tif artist_id:\\n\\t\\t\\tsongs = self.db.artists.find_one({'id': artist_id})['songs']\\n\\t\\t\\tprint(len(songs))\\n\\t\\t\\tlyrics = []\\n\\t\\t\\tfor song in songs:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tlyrics.append((song, self.get_existing_lyrics(song)))\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\treturn lyrics\",\n \"def get_lyrics(request: request, exclude_id: int=None):\\n # Defensive programming checks\\n if exclude_id:\\n assert isinstance(exclude_id, int)\\n\\n # Get lyrics\\n lyr = Lyrics()\\n for k, v in request.form.items():\\n if \\\"section-\\\" in k:\\n idx = int(k.split(\\\"-\\\")[-1])\\n if idx is not exclude_id:\\n # First, convert to traditional.\\n lyrics = convert(request.form[f\\\"lyrics-{idx}\\\"])\\n\\n section = request.form[k]\\n lyr.add_section(section=section, lyrics=lyrics)\\n return lyr\",\n \"def fetch_lyrics(self, url):\\n # data=requests.get(url,proxies=proxyDict) # will be used when internet is accessed via proxy server\\n page = requests.get(url) # for accessing internet without proxy server\\n # Regex out the lyrics from the html content\\n lyrics = re.search(b'<!-- start of lyrics -->(?:\\\\r\\\\n)+(.+)(?:\\\\r\\\\n)+<!-- end of lyrics -->', page.content, re.DOTALL)\\n if lyrics:\\n # Strip html tags from decoded lyrics\\n return re.sub(r'<.+>', '', lyrics.group(1).decode('utf8'))\\n else:\\n return None\",\n \"def lyrics_by_word(ans):\\r\\n songs_list = \\\"\\\"\\r\\n ans = ans.lower()\\r\\n albums = simple_album_list()\\r\\n for album in albums:\\r\\n songs = simple_songs_list(album)\\r\\n for song in songs:\\r\\n x = song_lyrics(song)\\r\\n song = str(song)\\r\\n if ans in x:\\r\\n songs_list += song + \\\", \\\"\\r\\n return songs_list[:-2]\",\n \"def songs(self):\\n return Html.find_song_names(self.content)\",\n \"def get_lyrics_for_all_languages(artist, song, linesep='\\\\n', timeout=None):\\n url = create_url(artist, song, '')\\n response = _requests.get(url, timeout=timeout)\\n soup = _BeautifulSoup(response.content, \\\"html.parser\\\")\\n lyricboxes = soup.find('table', {'class': 'banner banner-song'})\\n result = dict()\\n result['default'] = get_lyrics_by_language(artist, song, '', linesep='\\\\n', timeout=None)\\n \\n for a in lyricboxes.findAll('a', href=True):\\n result[a.getText()] = get_lyrics_by_language(artist, song, a['href'].split('/')[-1], linesep='\\\\n', timeout=None)\\n \\n return result\",\n \"def get_lyrics_by_language(artist, song, language, linesep='\\\\n', timeout=None):\\n return get_all_lyrics(artist, song, language, linesep, timeout)[0]\",\n \"def song(song_id):\\n return process_input(song_id) #jsonify(recomendations)\",\n \"def song_has_lyrics():\\n pass\",\n \"def get_all_lyrics(self):\\n if len(self.track_urls) == 0:\\n raise ValueError('URLs have not be retrieved yet. Call get_track_list() first.')\\n \\n if len(self.track_urls) == 0:\\n return\\n\\n for url in self.track_urls:\\n lyrics = self.get_single_lyrics(url)\\n self.lyrics.append(lyrics)\",\n \"def parse_pretty_midi_lyrics(midi: PrettyMIDI) -> List[Lyric]:\\n return [Lyric(lyric.time, lyric.text) for lyric in midi.lyrics]\",\n \"def getSongTextInfo():\\n sids = []\\n documents = []\\n sFile = open('../txt/two__Lastfm_song_Docs.txt')\\n lines = sFile.readlines()\\n index = 0\\n for line in lines:\\n line.strip('\\\\n')\\n line.strip('\\\\r\\\\n')\\n items = line.split('>>')\\n sid = int(items[0])\\n text = items[1]\\n documents.append(text)\\n sids.append(sid)\\n sFile.close()\\n print 'len = ',len(sids)\\n print 'len = ',len(documents)\\n return sids,documents\",\n \"def add_lyrics(self, songs, genius_api, nthreads=0):\\n\\t\\tif isinstance(songs, list):\\n\\t\\t\\tprint(f'{len(songs)} songs to get their lyrics')\\n\\t\\t\\tif nthreads <2:\\n\\t\\t\\t\\tfor song_id in songs:\\n\\t\\t\\t\\t\\tsong = genius_api.search(song_id, 'song')\\n\\t\\t\\t\\t\\tself.__add_lyric(song, genius_api)\\n\\t\\t\\telif nthreads >1:\\n\\t\\t\\t\\tassert len(songs) > 0\\n\\t\\t\\t\\tthreads=[]\\n\\t\\t\\t\\tscrapping_batch_size = len(songs) // nthreads\\n\\t\\t\\t\\tprint(f'thread list size = {scrapping_batch_size}')\\n\\t\\t\\t\\tfor i in range(nthreads):\\n\\t\\t\\t\\t\\tthreads.append(Thread(target=self.add_lyrics, \\n\\t\\t\\t\\t\\t\\targs=(songs[scrapping_batch_size * i : scrapping_batch_size * (i + 1)], genius_api,)))\\n\\t\\t\\t\\t\\tif i == threads - 1:\\n\\t\\t\\t\\t\\t\\tthreads[i] = Thread(self.add_lyrics, (songs[scrapping_batch_size * i:], genius_api,))\\n\\t\\t\\t\\t\\tthreads[i].start()\\n\\t\\t\\t\\t\\tprint('thread {} activated'.format(i+1))\\n\\t\\telse:\\n\\t\\t\\tsong = genius_api.search(songs, 'song')\\n\\t\\t\\tself.__add_lyric(song, genius_api)\\n\\t\\t\\tprint(' lyrics of {} added with success'.format(song['title']))\",\n \"def approve_lyrics():\\n pass\",\n \"def get(self):\\n mb = MusicbrainzClient()\\n query = self.get_argument('q')\\n artists, tracks = yield [mb.search_artists(query),\\n mb.search_tracks(query)]\\n data = {\\n 'artists': [\\n {\\n 'id': artist['id'],\\n 'artist': artist['name'],\\n 'note': artist.get('disambiguation', '')\\n }\\n for artist in artists['artist-list']\\n ],\\n 'tracks': [\\n {\\n 'id': track['id'],\\n 'title': track['title'],\\n 'artist': track['artist-credit-phrase']\\n }\\n for track in tracks['recording-list']\\n ]\\n }\\n self.finish(data)\",\n \"def get_song_list(self, artist: str) -> List[str]:\\n artist = self.just_replace_strings_with_nothing(artist)\\n\\n url = self.list_url + artist + '/songs'\\n\\n resp = requests.get(url)\\n\\n content = bs4.BeautifulSoup(resp.content)\\n\\n song_list = content.text[content.text.index(\\n 'MP3s') + 5:content.text.index('About Song List')]\\n\\n song_list = re.sub('\\\\n', ',', song_list)\\n song_list = re.sub(',+', ',', song_list)\\n song_list = re.sub(', ,', ', ', song_list)\\n\\n song_list = re.split(',', song_list)\\n for i in range(len(song_list)):\\n song_list[i] = song_list[i].lstrip(' ')\\n song_list[i] = re.sub(\\\"[.,']\\\", '', song_list[i])\\n song_list[i] = re.sub(\\\"&\\\", 'and', song_list[i])\\n song_list[i] = re.sub('\\\\s+', ' ', song_list[i])\\n\\n song_list = [i for i in song_list if i != '']\\n\\n return song_list\",\n \"def get_lyrics_or_chords(url):\\n html = ''\\n\\n if 'cifraclub' in url:\\n if url.startswith('https://m.'):\\n url = 'https://www.' + url[10:] # So we don't have to deal with mobile URLs\\n url += 'imprimir.html#columns=false' # Printer Friendly page (it's cleaner)\\n soup = getsoup(url)\\n sections = soup.find_all('pre')\\n for s in sections:\\n html += str(s)\\n\\n if 'letras.mus.br' in url:\\n if url.startswith('https://m.'):\\n url = 'https://www.' + url[10:] # So we don't have to deal with mobile URLs\\n soup = getsoup(url)\\n article = soup.find('article')\\n html = str(article)\\n\\n if 'e-chords' in url:\\n soup = getsoup(url)\\n pre = soup.find('pre', id='core')\\n # Remove Tab Div, keep raw tab\\n div = pre.find('div')\\n if div is not None:\\n tab = div.find('div', class_='tab')\\n html = '<pre>' + tab.text + '</pre>'\\n div.extract()\\n html += str(pre)\\n\\n if 'freak' in url:\\n soup = getsoup(url)\\n content = soup.find('div', id='content_h')\\n html = str(content)\\n\\n return html\",\n \"def get_lyrics_mouritz(artist, song_title, use_spotify_api, rapidapi_key):\\n\\n # \\\"featuring\\\" makes the string messy and Spotify API can find the song\\n # without this info\\n artist = artist.lower().split(\\\"feat\\\", 1)[0].strip()\\n song_title = song_title.lower().strip()\\n\\n url = \\\"https://mourits-lyrics.p.rapidapi.com\\\"\\n\\n headers = {\\n \\\"x-rapidapi-host\\\": \\\"mourits-lyrics.p.rapidapi.com\\\",\\n \\\"x-rapidapi-key\\\": rapidapi_key,\\n }\\n\\n if use_spotify_api:\\n payload = {\\\"q\\\": artist + \\\" \\\" + song_title}\\n else:\\n payload = {\\\"a\\\": artist, \\\"s\\\": song_title}\\n try:\\n r = requests.get(url, params=payload, headers=headers)\\n lyric = r.json()[\\\"result\\\"][\\\"lyrics\\\"]\\n\\n return lyric, \\\"mourits\\\"\\n\\n except Exception:\\n return None, None\",\n \"async def genius(self, ctx, *args):\\n args = argsmachine(args)\\n async with ctx.channel.typing():\\n if len(args) > 0:\\n headers = {'Authorization': 'Bearer ' + token}\\n search_url = f'https://api.genius.com/search?q={args}'\\n response = requests.get(search_url, headers=headers)\\n response = response.json()\\n allitems = []\\n for item in response['response']['hits']:\\n new = item['result']\\n newsong = Song(new['full_title'], new['url'], new)\\n allitems.append(newsong)\\n embed = Embed()\\n embed.description = concatenator(allitems)\\n await ctx.channel.send('Here are some results of the songs that you wanted. Type in the # of which result you want the lyrics to, or \\\"no\\\" to back out!', embed=embed)\\n while True:\\n try:\\n message = await self.bot.wait_for('message', check = check, timeout=30)\\n message = message.content.strip()\\n if message == 'no':\\n break\\n else:\\n message = int(message)-1\\n break\\n except asyncio.TimeoutError:\\n await ctx.send(\\\"You didn't reply in time! Enter the #.\\\")\\n continue\\n except:\\n await ctx.send(f\\\"Try entering the # again, or enter 'no' to exit the search command.\\\")\\n continue\\n\\n try:\\n chosensong = allitems[message]\\n site = requests.get(chosensong.url)\\n site = bs4.BeautifulSoup(site.text, features='html.parser')\\n chosensong.lyrics = site.find(\\\"div\\\", class_=\\\"lyrics\\\").get_text()\\n \\n #Discord supports only 2048 characters in each embed message so this is used to break it up into multiple messages\\n messages_needed = math.ceil(len(chosensong.lyrics) / 2048)\\n lyricsembed=Embed()\\n counter = 1\\n currentchar = 0\\n nextchar = 2048\\n while messages_needed >= counter:\\n lyrics = chosensong.lyrics[currentchar:nextchar]\\n lyricsembed.description = lyrics\\n await ctx.send(f'Here are the lyrics for `{chosensong.title}`, `{counter}`/`{messages_needed}`!', embed=lyricsembed)\\n currentchar += 2048\\n nextchar += 2048\\n counter += 1\\n except:\\n await ctx.send(f\\\"Stopping the genius command.\\\")\\n else:\\n await ctx.send(f\\\"Can't really search for lyrics if there are none provided, right? Try again with words, song titles, or artist names.\\\")\",\n \"def combine_genre(songs):\\r\\n combined = \\\"\\\"\\r\\n for song in songs:\\r\\n combined += song[\\\"lyrics\\\"]\\r\\n return combined\",\n \"def azlyrics(song, artist):\\n song = song.replace(\\\" \\\", \\\"\\\")\\n artist = artist.replace(\\\" \\\", \\\"\\\")\\n url = 'http://www.azlyrics.com/lyrics/' + artist + '/' + song + '.html'\\n html_text = urllib.urlopen(url).read()\\n soup = BeautifulSoup(html_text, \\\"lxml\\\")\\n find_lyrics = soup.find_all(\\\"div\\\")\\n div = [x for x in find_lyrics if str(x).find(\\\"class=\\\") == -1]\\n if(len(div) > 1):\\n return div[1]\\n else:\\n return -1\",\n \"def get_all_songs(self):\\n to_send = self.db.get_all_songs()\\n to_send = '$'.join(to_send)\\n self.send_message(to_send)\",\n \"def get_all_artists_lyrics(self, artist: str) -> List[Dict]:\\n artist = artist.lower()\\n song_list = self.get_song_list(artist)\\n\\n lyric_dict = {}\\n for i in song_list:\\n lyrics = self.get_genius_page(artist, i)\\n lyric_dict[i] = lyrics\\n\\n return lyric_dict\",\n \"def get_songs(self):\\n search_object = {\\\"size\\\":25000,\\n 'query': {'term': {FIELD_FINGERPRINTED: True}}, \\\"fields\\\": [FIELD_SONGNAME, FIELD_FILE_SHA1,\\n FIELD_TOTAL_HASHES]}\\n response = self.cursor.search(index = SONGS_INDEXNAME, body=search_object)\\n #print(\\\"get_songs response: \\\",response)\\n arr = []\\n for hit in response[\\\"hits\\\"][\\\"hits\\\"]:\\n dct = {\\\"song_name\\\":hit['_source'][FIELD_SONGNAME],\\\"total_hashes\\\":hit['_source'][FIELD_TOTAL_HASHES],\\n \\\"file_sha1\\\":hit['_source'][FIELD_FILE_SHA1]}\\n arr.append(dct)\\n return arr\",\n \"def read( self, song_file_name ):\\n song_file = open( song_file_name )\\n content = song_file.read()\\n return self.split( content )\",\n \"def get_genius_page(self, artist: str, song: str) -> str:\\n\\n artist = self.just_replace_strings_with_dashes(artist)\\n song = self.just_replace_strings_with_dashes(song)\\n\\n url = self.gen_url + artist + '-' + song + '-lyrics'\\n\\n resp = requests.get(url)\\n\\n if resp.status_code == 200:\\n try:\\n content = bs4.BeautifulSoup(resp.content)\\n lyrics = content.text[content.text.rindex(\\n '[Verse 1]'):content.text.index('Embed')]\\n lyrics = self.clean_lyrics_response(lyrics)\\n return lyrics\\n\\n except (ValueError, IndexError) as e:\\n print('Lyrics not found {}, due to error {}'.format(song, e))\\n\\n try:\\n lyrics = content.text[content.text.rindex(\\n '[Verse]'):content.text.index('Embed')]\\n lyrics = self.clean_lyrics_response(lyrics)\\n return lyrics\\n\\n except ValueError as e:\\n print(\\n 'Lyrics not found {}, due to error {}, single verse song'.format(song, e))\",\n \"def set_lyrics(self, lyrics: str) -> None:\\n self.lyrics = lyrics\",\n \"async def yt_info(self, song):\\n API_KEY = 'API_KEY'\\n youtube = build('youtube', 'v3', developerKey=API_KEY)\\n song_data = youtube.search().list(part='snippet').execute()\\n return song_data[0]\",\n \"def get_lyrics_url(non_lyrics_url, driver=None):\\n if not driver:\\n driver = get_browser()\\n driver.get(non_lyrics_url)\\n song_name = get_current_song_name(driver)\\n search_url = \\\"https://www.youtube.com/results?search_query=\\\" + song_name + \\\" lyrics lyrical words\\\"\\n driver.get(search_url)\\n driver.find_element_by_id(\\\"video-title\\\").click()\\n return driver.current_url\",\n \"def is_lyrics_approved():\",\n \"def get_user_input(self, widget, data = None):\\n # Parse user input\\n artist = self.clean_user_input(self.artist_name.get_text())\\n song = self.clean_user_input(self.song_name.get_text())\\n self.get_lyrics(artist, song)\",\n \"def song_view(song_id):\\r\\n querystring = apiurl_musixmatch + \\\"track.lyrics.get?track_id=\\\" + urllib2.quote(\\r\\n song_id) + \\\"&apikey=\\\" + apikey_musixmatch + \\\"&format=plain\\\"\\r\\n try:\\r\\n request = urllib2.Request(querystring)\\r\\n # timeout set to 4 seconds; automatically retries\\r\\n response = urllib2.urlopen(request, timeout=4)\\r\\n # raw = response.read()\\r\\n print colored.green(\\\"Starting\\\", bold=12)\\r\\n all_data = ''\\r\\n while True:\\r\\n do_task()\\r\\n print '\\\\b.'\\r\\n sys.stdout.flush()\\r\\n data = response.read(2048)\\r\\n if not data:\\r\\n break\\r\\n all_data += data\\r\\n time.sleep(0.4)\\r\\n print \\\"\\\\n\\\"\\r\\n json_obj = json.loads(all_data.decode(\\\"utf-8\\\"))\\r\\n body = len(json_obj[\\\"message\\\"][\\\"body\\\"])\\r\\n if body == 0:\\r\\n print colored.red(\\\"No lyrics found\\\", bold=12)\\r\\n else:\\r\\n print colored.cyan(json_obj[\\\"message\\\"][\\\"body\\\"][\\\"lyrics\\\"][\\\"lyrics_body\\\"], bold=12)\\r\\n except socket.timeout:\\r\\n print \\\"Timeout raised and caught\\\"\",\n \"def songInfo():\\n \\n global songFile, currentRadio\\n \\n lines = songFile.readlines()\\n if len(lines) > 0:\\n\\n songFile.seek(0)\\n title = formatSong(lines[0]).strip()\\n \\n with canvas(device) as draw:\\n invert(draw, 0, 0, names[currentRadio][0], True)\\n if len(title)<19:\\n draw.text((72-4*(len(title)), 20), title , fill=\\\"white\\\")\\n else:\\n lineNum = len(title)\\n if lineNum > 72:\\n lineNum = 72\\n thelist = [title[i:i+19] for i in range(0, lineNum, 19)]\\n for i in range(len(thelist)): \\n draw.text((81-4*(len(thelist[i].strip())), 19+10*i), thelist[i] , fill=\\\"white\\\")\",\n \"def rhymeindex(self, lyrics):\\n rhyme_master_list = []\\n print(\\\"Building list of rhymes:\\\")\\n for line in lyrics:\\n rhymescheme = self.line_rhymescheme(line)\\n rhyme_master_list.append(rhymescheme)\\n\\n rhyme_master_list = list(set(rhyme_master_list))\\n reverselist = [x[::-1] for x in rhyme_master_list]\\n reverselist = sorted(reverselist)\\n rhymelist = [x[::-1] for x in reverselist]\\n\\n print(\\\"List of Sorted 2-Letter Rhyme Ends:\\\")\\n print(rhymelist)\\n f = open(self.rhyme_filename, \\\"w\\\", encoding='utf-8')\\n f.write(\\\"\\\\n\\\".join(rhymelist))\\n f.close()\\n return rhymelist\",\n \"def readSong(filename = None):\\n if filename == None: return []\\n songFile = open(filename, \\\"r\\\")\\n song = []\\n lineNumber = 1\\n for line in songFile:\\n notes = line.split(\\\";\\\")\\n for n in notes:\\n _parseSongLine(song, n, lineNumber, filename)\\n lineNumber += 1\\n songFile.close()\\n return song\",\n \"def get_liked_songs(self, station_id):\\n\\n feedbacks = self.get_station_feedbacks(station_id)\\n songs = []\\n for feedback in feedbacks:\\n songs.append({\\n \\\"name\\\": feedback[\\\"songTitle\\\"],\\n \\\"album\\\": feedback[\\\"albumTitle\\\"],\\n \\\"artist\\\": feedback[\\\"artistName\\\"]\\n })\\n return songs\",\n \"def getAllSongs(self):\\n return self.__songDictionary\",\n \"def generate_list(self):\\n with open(self.index_file, \\\"r\\\") as fh:\\n original_songs = [line.rstrip() for line in fh.readlines()]\\n \\n if self.search_terms:\\n # refine using search terms\\n self.songs = []\\n for st in self.search_terms:\\n refined_songs = original_songs\\n for s in st:\\n refined_songs = [song for song in refined_songs \\n if s.lower() in song.lower()]\\n self.songs += sorted(refined_songs)\\n else:\\n self.songs = original_songs\\n \\n # If we've specified a num_songs, slice out this much\\n if self.num_songs: \\n self.songs[:] = self.songs[:self.num_songs] \\n else:\\n self.num_songs = len(self.songs)\",\n \"def track_similar(req):\\n\\n artist = req.get('result').get('parameters').get('artist')\\n track = req.get('result').get('parameters').get('track')\\n logger.info('received {0} request for artist=\\\"{1}\\\", track=\\\"{2}\\\"'.format('track_similar', artist, track))\\n sim_tracks = cached_result('get_similar_tracks', [artist, track], {})\\n speech = 'Unable to locate similar tracks for song {track} by {artist}'.format(\\n track=track, artist=artist)\\n\\n if sim_tracks and len(sim_tracks) > 0:\\n speech = 'The following songs are similar to {track} by {artist}'.format(\\n track=track, artist=artist)\\n for track in sim_tracks:\\n speech += '. ' + track[0] + ' by ' + track[1]\\n\\n return jsonify(\\n {'speech': speech,\\n 'displayText': speech,\\n 'source': 'last-assist'}\\n )\",\n \"def song2text(song):\\n text = \\\"\\\"\\n for tup in song:\\n if len(tup) == 2:\\n f, d = tup\\n text += \\\"%s %s; \\\" % (_getNoteFromFrequency(f), d)\\n elif len(tup) == 3:\\n f1, f2, d = tup\\n text += \\\"%s %s %s; \\\" % (_getNoteFromFrequency(f1),\\n _getNoteFromFrequency(f2), d)\\n return text\",\n \"def search_song(self, name):\\n self.logger.debug('Searched for Song: {}'.format(name))\\n results = self.sp.search(q='track:' + name, type='track')\\n songs = [song for song in results['tracks']['items']]\\n i = 1\\n songs_ls = []\\n table_ls = []\\n for song in songs:\\n table_ls.append([i,\\n song['name'][0:20].strip(),\\n song['album']['name'][0:20].strip(),\\n \\\"%0.2f\\\" % (song['duration_ms'] / 60000),\\n song['popularity']])\\n songs_ls.append(song['uri'])\\n i = i + 1\\n return songs_ls, table_ls\",\n \"def loadLyrics(dirName):\\n lyricsDir = os.path.dirname(os.path.abspath(__file__)) + \\\"/lyrics/\\\"\\n artistDir = os.path.join(lyricsDir, dirName) + \\\"/\\\"\\n\\n if not os.path.isdir(artistDir):\\n print \\\"No artist named\\\", artistDir, \\\"in directory\\\", lyricsDir\\n return None\\n\\n lyrics = []\\n\\n songs = os.listdir(artistDir)\\n for song in songs:\\n with open(artistDir + song, 'r') as songFile:\\n songLines = songFile.readlines()\\n\\n # clean each line in each song and add if not empty\\n for line in songLines:\\n line = line.translate(None, string.punctuation)\\n line = line.lower().strip()\\n if line:\\n lyrics.append(line.split())\\n return lyrics\",\n \"def listSongNameAndArtists(self, resultList, initIndex=0):\\n stringToReturn = '' \\n for r in range(len(resultList)):\\n stringToReturn += f\\\"{r + initIndex + 1}) {resultList[r]['name']} by {self.listAllArtistsInResult(resultList[r])}\\\\n\\\"\\n\\n return stringToReturn\",\n \"def _run_lyrics_gui(self):\\n self._log.info(\\\"Searching for lyrics\\\")\\n\\n self.save_lyrics(find=True)\\n Action(\\\"load\\\", load=True)\\n\\n self._log.info(\\\"Done\\\")\",\n \"def get_songs_by_artist(artist, linesep=' \\\\n ', timeout=None):\\n df = pd.DataFrame(columns=['Artist', 'Title'])\\n url = \\\"https://lyrics.fandom.com/wiki/Category:Songs_by_\\\"+urlize(artist)\\n df = parse_page_now(url,df)\\n return df\",\n \"def get_song_info(self, song_id):\\n return self.__get('song', song_id)\",\n \"def first_words_func():\\n return_list = []\\n for lyric in lyrics:\\n for line in lyric.split(\\\"\\\\n\\\"):\\n return_list.append(line.split(\\\" \\\")[0])\\n return (return_list)\",\n \"def list(ctx):\\n\\tfor songName in songs:\\n\\t\\tyield from bot.send_message(ctx.message.author,songName)\",\n \"def fetch_song_data(url):\\r\\n response = requests.get(url)\\r\\n return response.text\",\n \"def get_texts(self) -> List[str]:\\n return self.texts\",\n \"def getnotes():\",\n \"def lyrics2words(lyrics):\\r\\n words = word_tokenize(lyrics.decode('utf8'))\\r\\n words = clean(words)\\r\\n return words\",\n \"def last_50_played_songs_to_txt(username,scope,redirect_uri,client_id,client_secret):\\r\\n sp = spotipy.Spotify(auth_manager=SpotifyOAuth(scope=scope, \\r\\n client_id=CLIENT_ID,\\r\\n client_secret=CLIENT_SECRET,\\r\\n redirect_uri=redirect_uri,\\r\\n username = username\\r\\n ))\\r\\n \\r\\n with open('last_50_played_songs.txt','w',encoding=\\\"utf-8\\\") as txt:\\r\\n txt.write('Listing the last ({}) played songs:'.format(len(sp.current_user_recently_played()['items']))+'\\\\n')\\r\\n txt.write('-------------------------------------------------------'+'\\\\n')\\r\\n txt.write('-------------------------------------------------------'+'\\\\n')\\r\\n for i in range(len(sp.current_user_recently_played()['items'])): \\r\\n txt.write('artist(s): '+str(sp.current_user_recently_played()['items'][i]['track']['artists'][0]['name'])+'\\\\n')\\r\\n txt.write('song title: '+str(sp.current_user_recently_played()['items'][i]['track']['name'])+'\\\\n')\\r\\n txt.write('album: '+str(sp.current_user_recently_played()['items'][i]['track']['album']['name'])+'\\\\n')\\r\\n txt.write('popularity: '+str(sp.current_user_recently_played()['items'][i]['track']['popularity'])+'\\\\n')\\r\\n txt.write('href: '+str(sp.current_user_recently_played()['items'][i]['track']['href'])+'\\\\n')\\r\\n txt.write('-------------------------------------------------------'+'\\\\n')\\r\\n txt.write(str(sp.current_user_recently_played()['items'][i]['played_at'])+'\\\\n')\\r\\n txt.write('-------------------------------------------------------'+'\\\\n')\\r\\n txt.write(str(sp.current_user_recently_played()['items'][i]['context'])+'\\\\n')\\r\\n txt.write('-------------------------------------------------------'+'\\\\n')\\r\\n \\r\\n \\r\\n return None\",\n \"def song_by_word(ans):\\r\\n songs_list = \\\"\\\"\\r\\n ans = ans.lower()\\r\\n albums = simple_album_list()\\r\\n for album in albums:\\r\\n songs = simple_songs_list(album)\\r\\n for song in songs:\\r\\n song = str(song)\\r\\n if ans in song.lower():\\r\\n songs_list += song + \\\", \\\"\\r\\n return songs_list[:-2]\",\n \"def getOrderedSongList(self):\\n judgesExcelLogger.info(\\\"getOrderedSongList: Attempting to get ordered song list \\\"\\n \\\"of set '%s'\\\", self.setName)\\n try:\\n os.chdir(self.path) # Change to set's directory context\\n with open(self.notesFiles[0], encoding=\\\"utf-8-sig\\\") as judgeFile:\\n for line in judgeFile:\\n if line.startswith('['):\\n self.getSongWithStepartist(line)\\n judgeFile.close()\\n except:\\n judgesExcelLogger.warning(\\\"getOrderedSongList: {0}: {1}\\\".format(sys.exc_info()[0].__name__,\\n str(sys.exc_info()[1])))\",\n \"def api_getmessage():\\n message = receive_lyrics()\\n if message != \\\"\\\":\\n return jsonify(ready=True, msg=message)\\n else:\\n return jsonify(ready=False)\",\n \"def tag_lyrics(data):\\r\\n\\r\\n # Initialize list to store tagged lyrics\\r\\n tagged_documents = []\\r\\n\\r\\n # Tag lyrics for all the lyrics in the list\\r\\n for i, doc in enumerate(data):\\r\\n\\r\\n # Tag lyrics\\r\\n tagged = TaggedDocument(doc, [i])\\r\\n\\r\\n # Append tagged lyrics to\\r\\n tagged_documents.append(tagged)\\r\\n\\r\\n return tagged_documents\",\n \"def get_playlist_songs(self, playlist_id):\\n url = get_playlist_url(playlist_id)\\n result = self.get_request(url)\\n return result['result']['tracks'], result['result']['name']\",\n \"def query_get_song_recommendation(songtitle, artist, root):\\n for child in root:\\n if (song_information.get_songtitle(child) == songtitle\\n and song_information.get_artist(child) == artist):\\n song = child\\n else:\\n answer = (\\\"Sorry, '\\\" + songtitle + \\\"' by \\\" + artist\\n + \\\"could not be found in this corpus\\\")\\n similar_songs = find_similar_songs(song, root)\\n if len(similar_songs) > 0:\\n answer = (\\\"If you like '\\\" + songtitle + \\\"' by \\\" + artist\\n + \\\", you might like \\\" + \\\", \\\".join(similar_songs))\\n else:\\n answer = (\\\"Sorry, there is no similar song to '\\\" + songtitle + \\\"' by \\\"\\n + artist + \\\" in this corpus\\\")\\n return answer\",\n \"def get_all_song_names(self):\\n try:\\n # Auto-close\\n with closing(self.connection) as con:\\n # Auto-commit\\n with con:\\n # Auto-close\\n with closing(con.cursor()) as cursor:\\n cursor.execute(\\\"\\\"\\\"\\n SELECT name\\n FROM nodes\\n WHERE type = \\\"song\\\";\\n \\\"\\\"\\\")\\n return [x[0] for x in cursor.fetchall()]\\n except sqlite3.OperationalError as e:\\n print(\\\"ERROR: Could not retrieve songs: {}\\\".format(str(e)))\\n return []\",\n \"def get(self, request, *args, **kwargs):\\n return super(LongestArtistSongView, self).get(request, query=app.LONGEST_ARTIST_SONG, *args, **kwargs)\",\n \"def get_songs_of_artist(self, artist_id: int):\\n\\t\\tartist = self.db.artists.find_one({'id': artist_id})\\n\\t\\treturn artist['songs']\",\n \"def get_text(self) -> List[str]:\\n return self.__texts\",\n \"def search_song(title, artist):\\n\\ttitle = quote(title, safe='')\\n\\tartist = quote(artist, safe='')\\n\\tbase_url = SPOTIFY_API_HOST + 'search/' + '?q=track:{0}+artist:{1}&type=track&limit=1'\\n\\turl = base_url.format(title, artist)\\n\\tresults = requests.get(url).json()\\n\\n\\ttry:\\n\\t\\tif results['tracks']['total'] == 0:\\n\\t\\t\\tlogging.debug('Found no results for song {0}'.format(title))\\n\\t\\t\\treturn ''\\n\\texcept KeyError as e:\\n\\t\\tlogging.warning('Invalid result from spotify on key {0}:\\\\n{1}'.format(e, results))\\n\\turi_string = results['tracks']['items'][0]['uri']\\n\\tlogging.debug('Found uri {0} for song {1}'.format(\\n\\t\\turi_string[uri_string.rfind(':')+1:], title))\\n\\treturn uri_string[uri_string.rfind(':')+1:] # Strip off the 'spotify:track:' tag.\",\n \"def scrape_all_songs():\\n print('Scraping all songs from {}'.format(URL))\\n\\n soup = scrapekit.handle_url(URL)\\n song_elements = []\\n tables = soup.findAll('table')\\n\\n for t in tables:\\n field_index = scrapekit.get_col_index(t, field_name=\\\"Song\\\")\\n\\n if field_index:\\n song_elements.extend(scrapekit.scrape_table_col(t, field_index))\\n\\n links = []\\n for element in song_elements:\\n l = element.find('a')\\n if l:\\n links.append(PREFIX + l.attrs.get('href', ''))\\n return links\",\n \"def artist_song_first_pass(self):\\n log.debug(\\\"Called artist_song_first_pass for %s.\\\" % self.name)\\n self.success = False\\n song_potentials = []\\n potential_count = 0\\n _min = 20\\n\\n def generate_potentials(count):\\n results = self.sp.search(q= 'artist: ' + self.artist + ' track: ' + self.song, type='track', limit=2)\\n if results['tracks']['total'] >= 1:\\n for items in results['tracks']['items']:\\n song_potentials.append([items['name'], items['uri']])\\n for artist in items['artists']:\\n song_potentials[count].append(artist['name'])\\n song_potentials[count].append(artist['uri'])\\n count += 1\\n\\n for splitter in splitters:\\n if self.name_clean.count(splitter) == 1:\\n self.artist, self.song = self.name_clean.split(splitter)\\n generate_potentials(potential_count)\\n elif self.name_clean.count(splitter) > 1:\\n for x in range(0, self.name_clean.count(splitter)):\\n self.artist, self.song = split(self.name_clean, splitter, x)\\n generate_potentials(potential_count)\\n\\n cutoff = matching(self.name_clean)\\n log.debug(\\\"%s potential matches found for %d\\\" % (len(song_potentials), id(self)))\\n log.debug(\\\"Potentials: %s\\\" % song_potentials)\\n for potential in song_potentials:\\n log.debug(potential)\\n log.debug(self.name_clean)\\n log.debug(str(potential[2]) + \\\" \\\" + str(potential[0]))\\n lev = levenshtein(self.name_clean, str.lower(str(potential[2])) + \\\" \\\" + str.lower(str(potential[0])))\\n log.debug(lev)\\n if lev < _min:\\n _min = lev\\n self.artist = potential[2]\\n self.artist_uri = potential[3]\\n self.song = potential[0]\\n self.song_uri = potential[1]\\n\\n if self.artist_uri and self.song_uri is not None:\\n log.debug(\\\"Cutoff point for %s : %d\\\" % (id(self), cutoff))\\n log.debug(\\\"Current Min: {}\\\".format(_min))\\n log.debug(\\\"Levenshtein distance between {} and {} : {}\\\"\\n .format(self.name_clean, self.artist + self.song,\\n levenshtein(self.name, self.artist + \\\" \\\" + self.song)))\\n if int(_min) > cutoff:\\n log.debug(\\\"Method artist_song_first_pass failed for %s.\\\" % self.name)\\n self.success = False\\n self.artist = None\\n self.song = None\\n else:\\n log.debug(\\\"Method artist_song_first_pass succeeded for %s.\\\" % self.name)\\n self.success = True\\n else:\\n log.debug(\\\"Method artist_song_first_pass failed for %s.\\\" % self.name)\\n self.success = False\\n self.artist = None\\n self.song = None\",\n \"def getWords(speech):\\r\\n return speech.split()\",\n \"def getSong(self):\\n queue = self.instantiate_queue()\\n song_data = queue.pop(0)\\n\\n history = self.instantiate_history()\\n history_song_data = deepcopy(song_data)\\n history_song_data['time_played'] = time() + 5\\n history.append(history_song_data)\\n\\n if len(queue) < 5:\\n self.addImplicit(queue, history)\\n \\n self.ageSongs(queue)\\n self.calculateScore(queue)\\n queue = self.sortSongs(queue)\\n\\n self.cache.set('queue', queue)\\n self.cache.set('history', history)\\n\\n keys = ['name', 'track_id', 'artist', 'album_uri', 'album_name', 'duration', 'explicit', 'valence', 'energy']\\n args = [song_data[key] for key in keys]\\n return Song(*args)\",\n \"def songs_list(name_of_album):\\r\\n songs = \\\"\\\"\\r\\n data = dbase()\\r\\n data = data[name_of_album][0]\\r\\n for song in data.keys():\\r\\n songs += song\\r\\n songs += \\\", \\\"\\r\\n return songs[:-2]\",\n \"def get_artist_songs(self,genre = \\\"[Not Provided]\\\"):\\n # Search for the artist and get their id\\n search_artist = self.search(self.artist_name)\\n\\n #Prevents the stoppage in case of an Artist having zero lyrics on Genius\\n if len(search_artist['response']['hits']) == 0:\\n return False\\n \\n artist_id = str(search_artist['response']['hits'][0]['result']['primary_artist']['id'])\\n print(\\\"ID: \\\" + artist_id)\\n # Initialize DataFrame\\n df = pd.DataFrame(columns=['title', 'url'])\\n # Iterate through all the pages of the artist's songs\\n more_pages = True\\n page = 1\\n i = 0\\n while more_pages:\\n # Make a request to get the songs of an artist on a given page\\n request_url = self.base_url + 'artists/' + artist_id + '/songs' + '?per_page=50&page=' + str(page)\\n response = requests.get(request_url, headers=self.headers).json()\\n\\n # For each song which the given artist is the primary_artist of the song, add the song title and\\n # Genius URL to the DataFrame\\n for song in response['response']['songs']:\\n if str(song['primary_artist']['id']) == artist_id:\\n title = song['title']\\n url = song['url']\\n df.loc[i] = [title, url]\\n i += 1\\n page += 1\\n\\n if response['response']['next_page'] is None:\\n more_pages = False\\n\\n \\n # Get the HTML and Song Lyrics from helper methods in the class\\n df['artist'] = self.artist_name\\n df['html'] = df['url'].apply(self.get_song_html)\\n df['lyrics'] = df.apply(lambda row: self.get_lyrics(row.html), axis=1)\\n #Uncomment to use the genre method otherwise\\n #df['genre'] = df.apply(lambda row: self.get_genre(row.html), axis=1)\\n df['genre'] = genre\\n \\n del df['url']\\n del df['html']\\n\\n self.artist_songs = df\\n\\n return self.artist_songs\",\n \"def read_ams(self):\\n current = time.time()\\n try:\\n if current - self.start > 3:\\n self.track_artist = not self.track_artist\\n self.start = time.time()\\n if self.track_artist:\\n data = self.ams.artist\\n if not self.track_artist:\\n data = self.ams.title\\n except (RuntimeError, UnicodeError):\\n data = None\\n\\n if data:\\n data = data[:16] + (data[16:] and '..')\\n\\n return data\",\n \"def print_songs(self):\\n\\t\\tfor i,s in enumerate(self._songs):\\n\\t\\t\\tprint('{0}. {1}'.format(i, s.print_info()))\",\n \"def get_songs(self, offset=None):\\n return self.__get('songs')\",\n \"def description(self):\\n return f\\\"{self.name} has {len(self.playlist)} songs.\\\"\",\n \"async def search(self, ctx: commands.Context, *, query: t.Optional[str]) -> None:\\n if query is None:\\n # Maybe the user didn't know to pass in a query?\\n embed = discord.Embed(colour=Colours.regular, timestamp=Embeds.now())\\n embed.description = (\\n \\\"No query passed in. Try passing in something: `$search arabic music`\\\"\\n )\\n embed.set_footer(\\n text=\\\"See $help voice for more commands.\\\", icon_url=Icons.info\\n )\\n return await ctx.send(embed=embed)\\n\\n if (results := await self.get_tracks(query, True, False)) is not None:\\n # Ensure that we're connected before playing.\\n await ctx.invoke(self.connect, channel=None)\\n player = self.get_player(ctx.guild)\\n if not player.is_connected:\\n return\\n\\n embed = discord.Embed(colour=Colours.regular, timestamp=Embeds.now())\\n embed.set_footer(\\n text=f\\\"Showing 5/{len(results)} results.\\\",\\n icon_url=ctx.author.avatar_url,\\n )\\n embed.description = \\\"\\\"\\n results = results[:5]\\n\\n for index, track in enumerate(results, 1):\\n m, s = self.get_formatted_length(track.length, True)\\n embed.description += (\\n f\\\"**{index}**. [{track.title}]({track.uri}) ({m}:{s})\\\\n\\\"\\n )\\n\\n # Get a integer selection using Choice.prompt().\\n if (\\n choice := await Choices.prompt(\\n ctx=ctx, embed=embed, n=5, author_only=True\\n )\\n ) is None:\\n if player.queue.empty:\\n await ctx.invoke(self.disconnect)\\n return\\n\\n embed = discord.Embed(\\n title=\\\"Now queued.\\\" if player.is_playing else \\\"Now playing.\\\",\\n description=f\\\"[{results[choice].title}]({results[choice].uri})\\\",\\n colour=Colours.regular,\\n timestamp=Embeds.now(),\\n )\\n\\n m, s = self.get_formatted_length(results[choice].length, False)\\n embed.set_footer(\\n text=f\\\"Track goes for {m} minutes and {s} seconds.\\\",\\n icon_url=ctx.author.avatar_url,\\n )\\n if results[choice].thumb is not None:\\n embed.set_thumbnail(url=results[choice].thumb)\\n await ctx.send(embed=embed)\\n\\n player.queue.add_tracks(results[choice])\\n if not player.is_playing:\\n await player.playback()\\n else:\\n fail = Embeds.status(success=False, desc=\\\"Failed to find any results.\\\")\\n await ctx.send(embed=fail)\",\n \"def get_songs_via_title():\\n\\n title = request.args.get('title')\\n\\n songs_detail = mod.get_songs_details_via_title(title)\\n\\n return jsonify(songs_detail)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7824739","0.723227","0.7111751","0.70720786","0.6978943","0.6744991","0.66379493","0.6558411","0.65524745","0.6528179","0.6459133","0.64329433","0.6395972","0.6361504","0.6232909","0.61920947","0.61873704","0.61732334","0.6150045","0.61318433","0.59900963","0.5921584","0.59114563","0.5894568","0.5836322","0.5804758","0.5798994","0.5763357","0.57265013","0.5703082","0.5698428","0.56899196","0.56584257","0.56563884","0.5604061","0.55718905","0.55708253","0.5526583","0.5491","0.5478433","0.5458476","0.5443362","0.5420462","0.5401311","0.53360295","0.531869","0.53174543","0.5316214","0.5263173","0.52592593","0.5223739","0.52025455","0.51952714","0.5189451","0.5171229","0.5170836","0.51451993","0.5105793","0.5073621","0.50732434","0.50455785","0.50008667","0.4996784","0.49891922","0.49695882","0.49605086","0.49526766","0.49431416","0.49417138","0.49364018","0.4919111","0.4911811","0.4909039","0.49042585","0.48964405","0.4894672","0.48891443","0.48811808","0.48610038","0.48601708","0.48594293","0.48591593","0.48586315","0.48516995","0.48439538","0.48409545","0.48393995","0.48376977","0.4836095","0.48326737","0.48304275","0.4822994","0.4817712","0.48157763","0.4808729","0.48044953","0.47915784","0.4791219","0.4778419","0.4768603"],"string":"[\n \"0.7824739\",\n \"0.723227\",\n \"0.7111751\",\n \"0.70720786\",\n \"0.6978943\",\n \"0.6744991\",\n \"0.66379493\",\n \"0.6558411\",\n \"0.65524745\",\n \"0.6528179\",\n \"0.6459133\",\n \"0.64329433\",\n \"0.6395972\",\n \"0.6361504\",\n \"0.6232909\",\n \"0.61920947\",\n \"0.61873704\",\n \"0.61732334\",\n \"0.6150045\",\n \"0.61318433\",\n \"0.59900963\",\n \"0.5921584\",\n \"0.59114563\",\n \"0.5894568\",\n \"0.5836322\",\n \"0.5804758\",\n \"0.5798994\",\n \"0.5763357\",\n \"0.57265013\",\n \"0.5703082\",\n \"0.5698428\",\n \"0.56899196\",\n \"0.56584257\",\n \"0.56563884\",\n \"0.5604061\",\n \"0.55718905\",\n \"0.55708253\",\n \"0.5526583\",\n \"0.5491\",\n \"0.5478433\",\n \"0.5458476\",\n \"0.5443362\",\n \"0.5420462\",\n \"0.5401311\",\n \"0.53360295\",\n \"0.531869\",\n \"0.53174543\",\n \"0.5316214\",\n \"0.5263173\",\n \"0.52592593\",\n \"0.5223739\",\n \"0.52025455\",\n \"0.51952714\",\n \"0.5189451\",\n \"0.5171229\",\n \"0.5170836\",\n \"0.51451993\",\n \"0.5105793\",\n \"0.5073621\",\n \"0.50732434\",\n \"0.50455785\",\n \"0.50008667\",\n \"0.4996784\",\n \"0.49891922\",\n \"0.49695882\",\n \"0.49605086\",\n \"0.49526766\",\n \"0.49431416\",\n \"0.49417138\",\n \"0.49364018\",\n \"0.4919111\",\n \"0.4911811\",\n \"0.4909039\",\n \"0.49042585\",\n \"0.48964405\",\n \"0.4894672\",\n \"0.48891443\",\n \"0.48811808\",\n \"0.48610038\",\n \"0.48601708\",\n \"0.48594293\",\n \"0.48591593\",\n \"0.48586315\",\n \"0.48516995\",\n \"0.48439538\",\n \"0.48409545\",\n \"0.48393995\",\n \"0.48376977\",\n \"0.4836095\",\n \"0.48326737\",\n \"0.48304275\",\n \"0.4822994\",\n \"0.4817712\",\n \"0.48157763\",\n \"0.4808729\",\n \"0.48044953\",\n \"0.47915784\",\n \"0.4791219\",\n \"0.4778419\",\n \"0.4768603\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6255102"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":76084,"cells":{"query":{"kind":"string","value":"Test that the package provides customization_data that defines the function"},"document":{"kind":"string","value":"def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_confirm_customization_details(self):\n pass","def pytest_funcarg__generate_golden_data(request):\r\n return request.config.option.generate_golden_data","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func","def test_function(self):\n data = (\n os.path.join(\n _CURRENT_DIRECTORY,\n \"fake_project\",\n \"_modules\",\n \"fake_project\",\n \"basic.html\",\n ),\n \"set_function_thing\",\n )\n content = self._get_fake_project_function()\n\n expected = textwrap.dedent(\n '''\\\n def set_function_thing(value, another):\n \"\"\"Do something here.\"\"\"\n # Do something with these values\n # and more comment text, here.\n #\n if value:\n return 2\n\n # Another comment\n return 1'''\n )\n\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter","def test():\r\n\tassert calcolatrice.__author__ == \"help@castellanidavide.it\", \"sanity test failed\"\r\n\t#assert calcolatrice.<function>(<values>) == <the result(s) you would like to have>, \"<the fail message>\"\r","def test_datatransformationsetups_get(self):\n pass","def test_extra():\n return {\n 'conversion': functools.partial(\n conversion, is_train=False, is_extrapolation=True),\n }","def check_from_function(self):\n context = TestContext(session_context=ducktape_mock.session_context(),\n cls=DummyTest, function=DummyTest.test_function_description)\n assert context.description == \"function description\"","def test_contribute(self):\n pass","def test_function(self):\n data = (\n os.path.join(\n _CURRENT_DIRECTORY,\n \"fake_project\",\n \"_modules\",\n \"fake_project\",\n \"nested_folder\",\n \"another.html\",\n ),\n \"set_function_thing\",\n )\n content = self._get_fake_project_nested_function()\n\n expected = textwrap.dedent(\n '''\\\n def set_function_thing(value, another):\n \"\"\"Do something here.\"\"\"\n # Do something with these values\n # and more comment text, here.\n #\n if value:\n return 2\n\n # Another comment\n return 1'''\n )\n\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter","def test(self,*args,**kwargs):\n print(\"[TEMPLATE ENGINE] 'testing' function not implemented\")\n pass","def test_meta_spec(self):\n spec = self.ci.meta_spec()\n self.assertIn('roc_data', spec)\n self.assertIsInstance(spec['roc_data'], lit_types.CurveDataPoints)\n self.assertIn('pr_data', spec)\n self.assertIsInstance(spec['pr_data'], lit_types.CurveDataPoints)","def test_prodcode_4(self):\n self.assertEqual(prodcode.functio(), \"production value\")","def c_test_mutate_function(self, function):\r\n return 1","def test_RandomFunction_getter(self):\r\n self.assertEqual(self.cs_overview.RandomFunction, permutation)","def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)","def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)","def test_arguments(self):\n\n h.test_function_arguments(\n func=BaseTransformer.__init__,\n expected_arguments=[\"self\", \"columns\", \"copy\", \"verbose\"],\n expected_default_values=(None, True, False),\n )","def test(self):\n raise NotImplementedError","def test_func():\n pass","def test_function(eso_from_data:callable):\n print('Testing of eso_from_data with hardcoded data')\n # for context, relation, concepts_source in SEQUENCE:\n eso_from_data(0, 'site', 'contains', 'animal')","def test_process_data(self):\n pass","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def runTest(self):\n super().runTest()\n self = funcs_utils.set_up(self)\n db_user = self.server[\"username\"]\n data = {\n \"acl\": [\n {\n \"grantee\": db_user,\n \"grantor\": db_user,\n \"privileges\":\n [\n {\n \"privilege_type\": \"X\",\n \"privilege\": True,\n \"with_grant\": True\n }\n ]\n }\n ],\n \"arguments\": [],\n \"funcowner\": db_user,\n \"lanname\": \"sql\",\n \"name\": \"test_function\",\n \"options\": [],\n \"proleakproof\": True,\n \"pronamespace\": 2200,\n \"prorettypename\": \"integer\",\n \"prosecdef\": True,\n \"prosrc\": \"SELECT 1;\",\n \"probin\": \"$libdir/\",\n \"provolatile\": \"s\",\n \"seclabels\": [],\n \"variables\": [{\n \"name\": \"search_path\",\n \"value\": \"public, pg_temp\"\n }]\n }\n\n data[\"name\"] = \"test_function_add_%s\" % str(uuid.uuid4())[1:8]\n if self.schema_id:\n data['pronamespace'] = self.schema_id\n else:\n self.schema_id = data['pronamespace']\n\n if self.server_version >= 120000:\n support_function_name = 'supportfunc_%s' % str(uuid.uuid4())[1:8]\n funcs_utils.create_support_internal_function(\n self.server,\n self.db_name,\n self.schema_name,\n support_function_name\n )\n\n data['prosupportfuc'] = support_function_name\n\n if self.is_positive_test:\n response = self.create_function(data)\n else:\n if hasattr(self, 'is_mock_function'):\n def _get_sql(self, **kwargs):\n return False, ''\n with patch.object(FunctionView,\n self.mock_data[\"function_name\"],\n new=_get_sql):\n response = self.create_function(data)\n\n else:\n with patch(self.mock_data[\"function_name\"],\n return_value=eval(self.mock_data[\"return_value\"])):\n response = self.create_function(data)\n\n self.assertEqual(response.status_code,\n self.expected_data['status_code'])\n # Disconnect the database\n database_utils.disconnect_database(self, self.server_id, self.db_id)","def test_function(my_data):\n return my_data == 42","def test_schema():\n return 'test_schema'","def test_datatransformationsetups_post(self):\n pass","def test_something():","def test_function_callparams(self):\n\n @Configurable(conf=category('', Parameter('test', value=True)))\n def twist(test=None):\n return test\n\n value = twist()\n\n self.assertTrue(value)\n\n value = twist(False)\n\n self.assertFalse(value)\n\n Configurable.get_annotations(twist)[0].conf['']['test'].value = 1\n\n value = twist()\n\n self.assertEqual(value, 1)","def setup_function(test_function):\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'symbol-list.dat',\n TEST_LOCATION + 'symbol-list.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model.dat',\n TEST_LOCATION + 'nn-model.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model_test.dat',\n TEST_LOCATION + 'nn-model_test.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model_test2.dat',\n TEST_LOCATION + 'nn-model_test2.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER +\n 'distance-tolerance_test.dat',\n TEST_LOCATION + 'distance-tolerance_test.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER +\n 'distance-tolerance_test2.dat',\n TEST_LOCATION + 'distance-tolerance_test2.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'training-set_test.dat',\n TEST_LOCATION + 'training-set_test.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'training-set_test2.dat',\n TEST_LOCATION + 'training-set_test2.dat')","def test_check_detail_code_returns_true():\n plugin_instance = PluginVipCustomisation()\n assert plugin_instance._check_detail_code('replace me with real xml') == True","def example_function():","def codegen_reload_data():\n return {\n \"package\": u\"fn_utilities\",\n \"message_destinations\": [u\"fn_utilities\"],\n \"functions\": [u\"utilities_artifact_hash\", u\"utilities_attachment_hash\", u\"utilities_attachment_to_base64\", u\"utilities_attachment_zip_extract\", u\"utilities_attachment_zip_list\", u\"utilities_base64_to_artifact\", u\"utilities_base64_to_attachment\", u\"utilities_call_rest_api\", u\"utilities_domain_distance\", u\"utilities_email_parse\", u\"utilities_excel_query\", u\"utilities_expand_url\", u\"utilities_extract_ssl_cert_from_url\", u\"utilities_get_contact_info\", u\"utilities_json2html\", u\"utilities_parse_ssl_certificate\", u\"utilities_pdfid\", u\"utilities_resilient_search\", u\"utilities_shell_command\", u\"utilities_string_to_attachment\", u\"utilities_timer\", u\"utilities_xml_transformation\"],\n \"workflows\": [u\"example_artifact_attachment_to_base64\", u\"example_artifact_hash\", u\"example_attachment_hash\", u\"example_attachment_to_base64\", u\"example_call_rest_api\", u\"example_create_artifacts_from_excel_data\", u\"example_domain_distance\", u\"example_email_parsing_artifact\", u\"example_email_parsing_attachment\", u\"example_extract_ssl_cert_from_url\", u\"example_get_incident_contact_info\", u\"example_get_task_contact_info\", u\"example_json2html\", u\"example_parse_ssl_certificate\", u\"example_pdfid\", u\"example_resilient_search\", u\"example_shell_command\", u\"example_string_to_attachment\", u\"example_timer\", u\"example_timer_parallel\", u\"example_xml_transformation\", u\"example_zip_list\", u\"example_zip_to_artifact\", u\"utilities_expand_url\"],\n \"actions\": [u\"Example: (Artifact) Attachment to Base64\", u\"Example: Artifact Hash\", u\"Example: Attachment Hash\", u\"Example: Attachment to Base64\", u\"Example: Call REST API\", u\"Example: Domain Distance\", u\"Example: Email Parsing (Artifact)\", u\"Example: Email Parsing (Attachment)\", u\"Example: Expand URL\", u\"Example: Extract SSL Certificate\", u\"Example: Get Incident Contact Info\", u\"Example: Get Task Contact Info\", u\"Example: JSON2HTML\", u\"Example: Parse SSL Certificate\", u\"Example: PDFiD\", u\"Example: Resilient Search\", u\"Example: Shell Command\", u\"Example: String to Attachment\", u\"Example: Timer Epoch\", u\"Example: Timers in Parallel\", u\"Example: Use Excel Data\", u\"Example: XML Transformation\", u\"Example: Zip Extract\", u\"Example: Zip List\"],\n \"incident_fields\": [],\n \"incident_artifact_types\": [],\n \"incident_types\": [],\n \"datatables\": [],\n \"automatic_tasks\": [],\n \"scripts\": [u\"Convert JSON to rich text v1.0\"],\n \"playbooks\": []\n }","def test_checkCustoms(self):\n self.failUnlessEqual(self.nice.opts['myflag'], \"PONY!\")\n self.failUnlessEqual(self.nice.opts['myparam'], \"Tofu WITH A PONY!\")","def test_data_in_param(self):","def test():\n pass","def test_methods_with_arguments(self):\n self.assertContains(self.response, \"<h3>Methods with arguments</h3>\")\n self.assertContains(self.response, \"<td>rename_company</td>\")\n self.assertContains(self.response, \"<td>dummy_function</td>\")\n self.assertContains(self.response, \"<td>suffix_company_name</td>\")","def dataproduct() -> None:\n pass","def customization_data(client=None):\n\n # This import data contains:\n # Function inputs:\n # user_agent_string\n # Message Destinations:\n # useragentanalysis_fn\n # Functions:\n # fn_useragentanalysis\n # Workflows:\n # user_agent_workflow\n # Rules:\n # Example: User Agent Analysis\n\n\n yield ImportDefinition(u\"\"\"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\nMzk3MjUxNDN9\n\"\"\"\n )","def test_package(self):\n pass","def test_that_original_func_saved():\n\n assert callable(custom_sum.__original_func)","def test_doc():\n pass","def spec_tests():\n pass","def test_alien_data(self):","def test_example(decorated_example):\n import visual_coding_2p_analysis","def tests():","def unitary_test():","def test_data_object_vaporise(self):\n pass","def test_visualisations_get_visualisation_render_data(self):\n pass","def test():","def test():","def test_preprocessor(self, _get_page_preprocessor, _get_source_code_from_object):\n def _remove_comments_and_docstrings(node):\n for tag in node.find_all(\"span\", {\"class\": [\"c1\", \"sd\"]}):\n tag.decompose()\n\n _get_page_preprocessor.return_value = _remove_comments_and_docstrings\n _get_source_code_from_object.return_value = \"\"\n\n data = (\n os.path.join(\n _CURRENT_DIRECTORY,\n \"fake_project\",\n \"_modules\",\n \"fake_project\",\n \"basic.html\",\n ),\n \"set_function_thing\",\n )\n content = self._get_fake_project_function()\n\n expected = '''\\\ndef set_function_thing(value, another):\n \n \n \n \n if value:\n return 2\n\n \n return 1'''\n\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter","def pytest_generate_tests(metafunc):\n if \"maptype\" in metafunc.fixturenames:\n metafunc.parametrize(\"maptype\", ALL_ATTMAPS)","def test(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def test_mapper_func(data, schema):\n pass","def customization_data(client=None):\n\n # This import data contains:\n # Function inputs:\n # execution_arn\n # lambda_function_name\n # lambda_payload\n # msg_body\n # phone_numbers\n # state_machine_async\n # state_machine_name\n # state_machine_payload\n # Message Destinations:\n # fn_aws_utilities\n # Functions:\n # fn_get_step_function_execution\n # fn_invoke_lambda\n # fn_invoke_step_function\n # fn_send_sms_via_sns\n # Workflows:\n # example_invoke_aws_lambda_python_addition\n # example_invoke_step_function_asynchronous\n # example_invoke_step_function_synchronous\n # example_send_sms_incident\n # Rules:\n # Example: Invoke AWS Lambda: Python Addition\n # Example: Invoke Step Function: Asynchronous\n # Example: Invoke Step Function: Synchronous\n # Example: Send SMS: Incident\n # Example: Send SMS: Incident [Menu Item]\n\n\n yield ImportDefinition(u\"\"\"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\nCg==\n\"\"\"\n )","def pytest_generate_tests(metafunc):\n if (\"solver\" in metafunc.fixturenames\n and \"coefficients\" in metafunc.fixturenames):\n _parametrize_solver_coefficients(metafunc)","def test_setup(funct):\n\n def decorated_setup():\n \"\"\"Decorated test setup.\"\"\"\n testdb.reload_db()\n funct()\n return decorated_setup","def test_cont_larvaemutattion(): \n pass","def test_T01():","def test_arguments(self):\n\n h.test_function_arguments(\n func=ScalingTransformer.__init__,\n expected_arguments=[\"self\", \"columns\", \"scaler\", \"scaler_kwargs\"],\n expected_default_values=({},),\n )","def template_for_test_functions():\r\n\r\n expected = \"\"\r\n actual = \"\"\r\n print_test_results(func, expected, actual)","def test_get_larvaemutation_function():\n \n f = get_larvaemutation_function('bin')\n assert 'function bin_larvaemutation' in str(f)\n f = get_larvaemutation_function('disc')\n assert 'function disc_larvaemutation' in str(f)","def before_test(self, func, *args, **kwargs):\n pass","def test_arguments(self):\n\n h.test_function_arguments(\n func=ScalingTransformer.fit,\n expected_arguments=[\"self\", \"X\", \"y\"],\n expected_default_values=(None,),\n )","def test_function(arg_1):\n return arg_1 * 2","def test_preprocessed_data(self):\n self.assertEqual(self.tester.preprocessed_data, [1, 2])","def before_call_used_args_add_description(self, args_values, code_reference, function_info, args_code):\n description = None\n if function_info == ('pandas.io.parsers', 'read_csv'):\n filename = args_values[0].split(os.path.sep)[-1]\n description = \"{}\".format(filename) # TODO: Add loaded columns as well\n elif function_info == ('pandas.core.frame', 'dropna'):\n description = \"dropna\"\n elif function_info == ('pandas.core.frame', '__getitem__'):\n # TODO: Can this also be a select?\n if isinstance(args_values, MlinspectSeries):\n self.code_reference_to_set_item_op[code_reference] = 'Selection'\n description = \"Select by series\" # TODO: prettier representation\n elif isinstance(args_values, str):\n self.code_reference_to_set_item_op[code_reference] = 'Projection'\n key_arg = args_values\n description = \"to {}\".format([key_arg])\n elif isinstance(args_values, list):\n self.code_reference_to_set_item_op[code_reference] = 'Projection'\n description = \"to {}\".format(args_values)\n elif function_info == ('pandas.core.frame', '__setitem__'):\n key_arg = args_values\n description = \"Sets columns {}\".format([key_arg])\n SetKeyInfo = namedtuple(\"SetKeyInfo\", [\"code_reference\", \"function_info\", \"args_code\"])\n self.set_key_info = SetKeyInfo(code_reference, function_info, args_code)\n elif function_info == ('pandas.core.frame', 'groupby'):\n description = \"Group by {}, \".format(args_values)\n self.code_reference_to_description[code_reference] = description\n if description:\n self.code_reference_to_description[code_reference] = description","def test_extended(self, monkeypatch, script_runner):\n monkeypatch.setattr(\"builtins.input\", lambda _: \"n\")\n ret = script_runner.run(\n \"spectrafit\",\n \"spectrafit/test/test_data.txt\",\n \"-i\",\n \"spectrafit/test/test_input_2.json\",\n )\n assert ret.success\n assert ret.stderr == \"\"","def test_wraps():\n print('func')","def test_visualisations_get_visualisation(self):\n pass","def test_predictor():","def testFunctionName(self):\n with self.assertRaises(AttributeError):\n Manager.Properties.Version.Set(get_object(TOP_OBJECT), {})","def test_doc_fun(self):\n for fun in self.functions:\n self.assertTrue(len(fun.__doc__) > 0)","def test(self, dataset) -> None:\n raise NotImplementedError()","def test_T1():","def test_T1():","def test_visualize_recipe_taste(self):\n pass","def test_click_common_options(self) -> None:\n args = ['--debug', '--verbose']\n\n @click.command('test_func')\n @click_common_options\n def test_func(**kwargs: Dict[str, Any]) -> None:\n \"\"\"Function for testing options.\"\"\"\n click.echo(json.dumps(kwargs))\n\n result = json.loads(\n self.runner.invoke(test_func, args).output.replace('\\n', '')\n )\n\n self.assertEqual(result, {'debug': True, 'verbose': True})","def test(self) -> Any:\n pass","def test_load_from_function(self):\n self.test_table.load_from_function(create_small_test_odml)\n self.assertEqual(self.test_table._odmldict, self.expected_odmldict)","def test_arguments(self):\n\n h.test_function_arguments(\n func=BaseTransformer.fit,\n expected_arguments=[\"self\", \"X\", \"y\"],\n expected_default_values=(None,),\n )","def test_base_opt_validate():\n opt = scheme._BaseOpt()\n with pytest.raises(NotImplementedError):\n opt.validate('foo', 'test-data')"],"string":"[\n \"def test_confirm_customization_details(self):\\n pass\",\n \"def pytest_funcarg__generate_golden_data(request):\\r\\n return request.config.option.generate_golden_data\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func\",\n \"def test_function(self):\\n data = (\\n os.path.join(\\n _CURRENT_DIRECTORY,\\n \\\"fake_project\\\",\\n \\\"_modules\\\",\\n \\\"fake_project\\\",\\n \\\"basic.html\\\",\\n ),\\n \\\"set_function_thing\\\",\\n )\\n content = self._get_fake_project_function()\\n\\n expected = textwrap.dedent(\\n '''\\\\\\n def set_function_thing(value, another):\\n \\\"\\\"\\\"Do something here.\\\"\\\"\\\"\\n # Do something with these values\\n # and more comment text, here.\\n #\\n if value:\\n return 2\\n\\n # Another comment\\n return 1'''\\n )\\n\\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter\",\n \"def test():\\r\\n\\tassert calcolatrice.__author__ == \\\"help@castellanidavide.it\\\", \\\"sanity test failed\\\"\\r\\n\\t#assert calcolatrice.<function>(<values>) == <the result(s) you would like to have>, \\\"<the fail message>\\\"\\r\",\n \"def test_datatransformationsetups_get(self):\\n pass\",\n \"def test_extra():\\n return {\\n 'conversion': functools.partial(\\n conversion, is_train=False, is_extrapolation=True),\\n }\",\n \"def check_from_function(self):\\n context = TestContext(session_context=ducktape_mock.session_context(),\\n cls=DummyTest, function=DummyTest.test_function_description)\\n assert context.description == \\\"function description\\\"\",\n \"def test_contribute(self):\\n pass\",\n \"def test_function(self):\\n data = (\\n os.path.join(\\n _CURRENT_DIRECTORY,\\n \\\"fake_project\\\",\\n \\\"_modules\\\",\\n \\\"fake_project\\\",\\n \\\"nested_folder\\\",\\n \\\"another.html\\\",\\n ),\\n \\\"set_function_thing\\\",\\n )\\n content = self._get_fake_project_nested_function()\\n\\n expected = textwrap.dedent(\\n '''\\\\\\n def set_function_thing(value, another):\\n \\\"\\\"\\\"Do something here.\\\"\\\"\\\"\\n # Do something with these values\\n # and more comment text, here.\\n #\\n if value:\\n return 2\\n\\n # Another comment\\n return 1'''\\n )\\n\\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter\",\n \"def test(self,*args,**kwargs):\\n print(\\\"[TEMPLATE ENGINE] 'testing' function not implemented\\\")\\n pass\",\n \"def test_meta_spec(self):\\n spec = self.ci.meta_spec()\\n self.assertIn('roc_data', spec)\\n self.assertIsInstance(spec['roc_data'], lit_types.CurveDataPoints)\\n self.assertIn('pr_data', spec)\\n self.assertIsInstance(spec['pr_data'], lit_types.CurveDataPoints)\",\n \"def test_prodcode_4(self):\\n self.assertEqual(prodcode.functio(), \\\"production value\\\")\",\n \"def c_test_mutate_function(self, function):\\r\\n return 1\",\n \"def test_RandomFunction_getter(self):\\r\\n self.assertEqual(self.cs_overview.RandomFunction, permutation)\",\n \"def test_customization_template_crud():\\n template_crud = pxe.CustomizationTemplate(\\n name=generate_random_string(size=8),\\n description=generate_random_string(size=16),\\n image_type='RHEL-6',\\n script_type='Kickstart',\\n script_data='Testing the script')\\n\\n template_crud.create()\\n with update(template_crud):\\n template_crud.name = template_crud.name + \\\"_update\\\"\\n template_crud.delete(cancel=False)\",\n \"def test_customization_template_crud():\\n template_crud = pxe.CustomizationTemplate(\\n name=generate_random_string(size=8),\\n description=generate_random_string(size=16),\\n image_type='RHEL-6',\\n script_type='Kickstart',\\n script_data='Testing the script')\\n\\n template_crud.create()\\n with update(template_crud):\\n template_crud.name = template_crud.name + \\\"_update\\\"\\n template_crud.delete(cancel=False)\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=BaseTransformer.__init__,\\n expected_arguments=[\\\"self\\\", \\\"columns\\\", \\\"copy\\\", \\\"verbose\\\"],\\n expected_default_values=(None, True, False),\\n )\",\n \"def test(self):\\n raise NotImplementedError\",\n \"def test_func():\\n pass\",\n \"def test_function(eso_from_data:callable):\\n print('Testing of eso_from_data with hardcoded data')\\n # for context, relation, concepts_source in SEQUENCE:\\n eso_from_data(0, 'site', 'contains', 'animal')\",\n \"def test_process_data(self):\\n pass\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def runTest(self):\\n super().runTest()\\n self = funcs_utils.set_up(self)\\n db_user = self.server[\\\"username\\\"]\\n data = {\\n \\\"acl\\\": [\\n {\\n \\\"grantee\\\": db_user,\\n \\\"grantor\\\": db_user,\\n \\\"privileges\\\":\\n [\\n {\\n \\\"privilege_type\\\": \\\"X\\\",\\n \\\"privilege\\\": True,\\n \\\"with_grant\\\": True\\n }\\n ]\\n }\\n ],\\n \\\"arguments\\\": [],\\n \\\"funcowner\\\": db_user,\\n \\\"lanname\\\": \\\"sql\\\",\\n \\\"name\\\": \\\"test_function\\\",\\n \\\"options\\\": [],\\n \\\"proleakproof\\\": True,\\n \\\"pronamespace\\\": 2200,\\n \\\"prorettypename\\\": \\\"integer\\\",\\n \\\"prosecdef\\\": True,\\n \\\"prosrc\\\": \\\"SELECT 1;\\\",\\n \\\"probin\\\": \\\"$libdir/\\\",\\n \\\"provolatile\\\": \\\"s\\\",\\n \\\"seclabels\\\": [],\\n \\\"variables\\\": [{\\n \\\"name\\\": \\\"search_path\\\",\\n \\\"value\\\": \\\"public, pg_temp\\\"\\n }]\\n }\\n\\n data[\\\"name\\\"] = \\\"test_function_add_%s\\\" % str(uuid.uuid4())[1:8]\\n if self.schema_id:\\n data['pronamespace'] = self.schema_id\\n else:\\n self.schema_id = data['pronamespace']\\n\\n if self.server_version >= 120000:\\n support_function_name = 'supportfunc_%s' % str(uuid.uuid4())[1:8]\\n funcs_utils.create_support_internal_function(\\n self.server,\\n self.db_name,\\n self.schema_name,\\n support_function_name\\n )\\n\\n data['prosupportfuc'] = support_function_name\\n\\n if self.is_positive_test:\\n response = self.create_function(data)\\n else:\\n if hasattr(self, 'is_mock_function'):\\n def _get_sql(self, **kwargs):\\n return False, ''\\n with patch.object(FunctionView,\\n self.mock_data[\\\"function_name\\\"],\\n new=_get_sql):\\n response = self.create_function(data)\\n\\n else:\\n with patch(self.mock_data[\\\"function_name\\\"],\\n return_value=eval(self.mock_data[\\\"return_value\\\"])):\\n response = self.create_function(data)\\n\\n self.assertEqual(response.status_code,\\n self.expected_data['status_code'])\\n # Disconnect the database\\n database_utils.disconnect_database(self, self.server_id, self.db_id)\",\n \"def test_function(my_data):\\n return my_data == 42\",\n \"def test_schema():\\n return 'test_schema'\",\n \"def test_datatransformationsetups_post(self):\\n pass\",\n \"def test_something():\",\n \"def test_function_callparams(self):\\n\\n @Configurable(conf=category('', Parameter('test', value=True)))\\n def twist(test=None):\\n return test\\n\\n value = twist()\\n\\n self.assertTrue(value)\\n\\n value = twist(False)\\n\\n self.assertFalse(value)\\n\\n Configurable.get_annotations(twist)[0].conf['']['test'].value = 1\\n\\n value = twist()\\n\\n self.assertEqual(value, 1)\",\n \"def setup_function(test_function):\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'symbol-list.dat',\\n TEST_LOCATION + 'symbol-list.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model.dat',\\n TEST_LOCATION + 'nn-model.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model_test.dat',\\n TEST_LOCATION + 'nn-model_test.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model_test2.dat',\\n TEST_LOCATION + 'nn-model_test2.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER +\\n 'distance-tolerance_test.dat',\\n TEST_LOCATION + 'distance-tolerance_test.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER +\\n 'distance-tolerance_test2.dat',\\n TEST_LOCATION + 'distance-tolerance_test2.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'training-set_test.dat',\\n TEST_LOCATION + 'training-set_test.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'training-set_test2.dat',\\n TEST_LOCATION + 'training-set_test2.dat')\",\n \"def test_check_detail_code_returns_true():\\n plugin_instance = PluginVipCustomisation()\\n assert plugin_instance._check_detail_code('replace me with real xml') == True\",\n \"def example_function():\",\n \"def codegen_reload_data():\\n return {\\n \\\"package\\\": u\\\"fn_utilities\\\",\\n \\\"message_destinations\\\": [u\\\"fn_utilities\\\"],\\n \\\"functions\\\": [u\\\"utilities_artifact_hash\\\", u\\\"utilities_attachment_hash\\\", u\\\"utilities_attachment_to_base64\\\", u\\\"utilities_attachment_zip_extract\\\", u\\\"utilities_attachment_zip_list\\\", u\\\"utilities_base64_to_artifact\\\", u\\\"utilities_base64_to_attachment\\\", u\\\"utilities_call_rest_api\\\", u\\\"utilities_domain_distance\\\", u\\\"utilities_email_parse\\\", u\\\"utilities_excel_query\\\", u\\\"utilities_expand_url\\\", u\\\"utilities_extract_ssl_cert_from_url\\\", u\\\"utilities_get_contact_info\\\", u\\\"utilities_json2html\\\", u\\\"utilities_parse_ssl_certificate\\\", u\\\"utilities_pdfid\\\", u\\\"utilities_resilient_search\\\", u\\\"utilities_shell_command\\\", u\\\"utilities_string_to_attachment\\\", u\\\"utilities_timer\\\", u\\\"utilities_xml_transformation\\\"],\\n \\\"workflows\\\": [u\\\"example_artifact_attachment_to_base64\\\", u\\\"example_artifact_hash\\\", u\\\"example_attachment_hash\\\", u\\\"example_attachment_to_base64\\\", u\\\"example_call_rest_api\\\", u\\\"example_create_artifacts_from_excel_data\\\", u\\\"example_domain_distance\\\", u\\\"example_email_parsing_artifact\\\", u\\\"example_email_parsing_attachment\\\", u\\\"example_extract_ssl_cert_from_url\\\", u\\\"example_get_incident_contact_info\\\", u\\\"example_get_task_contact_info\\\", u\\\"example_json2html\\\", u\\\"example_parse_ssl_certificate\\\", u\\\"example_pdfid\\\", u\\\"example_resilient_search\\\", u\\\"example_shell_command\\\", u\\\"example_string_to_attachment\\\", u\\\"example_timer\\\", u\\\"example_timer_parallel\\\", u\\\"example_xml_transformation\\\", u\\\"example_zip_list\\\", u\\\"example_zip_to_artifact\\\", u\\\"utilities_expand_url\\\"],\\n \\\"actions\\\": [u\\\"Example: (Artifact) Attachment to Base64\\\", u\\\"Example: Artifact Hash\\\", u\\\"Example: Attachment Hash\\\", u\\\"Example: Attachment to Base64\\\", u\\\"Example: Call REST API\\\", u\\\"Example: Domain Distance\\\", u\\\"Example: Email Parsing (Artifact)\\\", u\\\"Example: Email Parsing (Attachment)\\\", u\\\"Example: Expand URL\\\", u\\\"Example: Extract SSL Certificate\\\", u\\\"Example: Get Incident Contact Info\\\", u\\\"Example: Get Task Contact Info\\\", u\\\"Example: JSON2HTML\\\", u\\\"Example: Parse SSL Certificate\\\", u\\\"Example: PDFiD\\\", u\\\"Example: Resilient Search\\\", u\\\"Example: Shell Command\\\", u\\\"Example: String to Attachment\\\", u\\\"Example: Timer Epoch\\\", u\\\"Example: Timers in Parallel\\\", u\\\"Example: Use Excel Data\\\", u\\\"Example: XML Transformation\\\", u\\\"Example: Zip Extract\\\", u\\\"Example: Zip List\\\"],\\n \\\"incident_fields\\\": [],\\n \\\"incident_artifact_types\\\": [],\\n \\\"incident_types\\\": [],\\n \\\"datatables\\\": [],\\n \\\"automatic_tasks\\\": [],\\n \\\"scripts\\\": [u\\\"Convert JSON to rich text v1.0\\\"],\\n \\\"playbooks\\\": []\\n }\",\n \"def test_checkCustoms(self):\\n self.failUnlessEqual(self.nice.opts['myflag'], \\\"PONY!\\\")\\n self.failUnlessEqual(self.nice.opts['myparam'], \\\"Tofu WITH A PONY!\\\")\",\n \"def test_data_in_param(self):\",\n \"def test():\\n pass\",\n \"def test_methods_with_arguments(self):\\n self.assertContains(self.response, \\\"<h3>Methods with arguments</h3>\\\")\\n self.assertContains(self.response, \\\"<td>rename_company</td>\\\")\\n self.assertContains(self.response, \\\"<td>dummy_function</td>\\\")\\n self.assertContains(self.response, \\\"<td>suffix_company_name</td>\\\")\",\n \"def dataproduct() -> None:\\n pass\",\n \"def customization_data(client=None):\\n\\n # This import data contains:\\n # Function inputs:\\n # user_agent_string\\n # Message Destinations:\\n # useragentanalysis_fn\\n # Functions:\\n # fn_useragentanalysis\\n # Workflows:\\n # user_agent_workflow\\n # Rules:\\n # Example: User Agent Analysis\\n\\n\\n yield ImportDefinition(u\\\"\\\"\\\"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\\nMzk3MjUxNDN9\\n\\\"\\\"\\\"\\n )\",\n \"def test_package(self):\\n pass\",\n \"def test_that_original_func_saved():\\n\\n assert callable(custom_sum.__original_func)\",\n \"def test_doc():\\n pass\",\n \"def spec_tests():\\n pass\",\n \"def test_alien_data(self):\",\n \"def test_example(decorated_example):\\n import visual_coding_2p_analysis\",\n \"def tests():\",\n \"def unitary_test():\",\n \"def test_data_object_vaporise(self):\\n pass\",\n \"def test_visualisations_get_visualisation_render_data(self):\\n pass\",\n \"def test():\",\n \"def test():\",\n \"def test_preprocessor(self, _get_page_preprocessor, _get_source_code_from_object):\\n def _remove_comments_and_docstrings(node):\\n for tag in node.find_all(\\\"span\\\", {\\\"class\\\": [\\\"c1\\\", \\\"sd\\\"]}):\\n tag.decompose()\\n\\n _get_page_preprocessor.return_value = _remove_comments_and_docstrings\\n _get_source_code_from_object.return_value = \\\"\\\"\\n\\n data = (\\n os.path.join(\\n _CURRENT_DIRECTORY,\\n \\\"fake_project\\\",\\n \\\"_modules\\\",\\n \\\"fake_project\\\",\\n \\\"basic.html\\\",\\n ),\\n \\\"set_function_thing\\\",\\n )\\n content = self._get_fake_project_function()\\n\\n expected = '''\\\\\\ndef set_function_thing(value, another):\\n \\n \\n \\n \\n if value:\\n return 2\\n\\n \\n return 1'''\\n\\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter\",\n \"def pytest_generate_tests(metafunc):\\n if \\\"maptype\\\" in metafunc.fixturenames:\\n metafunc.parametrize(\\\"maptype\\\", ALL_ATTMAPS)\",\n \"def test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def test_mapper_func(data, schema):\\n pass\",\n \"def customization_data(client=None):\\n\\n # This import data contains:\\n # Function inputs:\\n # execution_arn\\n # lambda_function_name\\n # lambda_payload\\n # msg_body\\n # phone_numbers\\n # state_machine_async\\n # state_machine_name\\n # state_machine_payload\\n # Message Destinations:\\n # fn_aws_utilities\\n # Functions:\\n # fn_get_step_function_execution\\n # fn_invoke_lambda\\n # fn_invoke_step_function\\n # fn_send_sms_via_sns\\n # Workflows:\\n # example_invoke_aws_lambda_python_addition\\n # example_invoke_step_function_asynchronous\\n # example_invoke_step_function_synchronous\\n # example_send_sms_incident\\n # Rules:\\n # Example: Invoke AWS Lambda: Python Addition\\n # Example: Invoke Step Function: Asynchronous\\n # Example: Invoke Step Function: Synchronous\\n # Example: Send SMS: Incident\\n # Example: Send SMS: Incident [Menu Item]\\n\\n\\n yield ImportDefinition(u\\\"\\\"\\\"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\\nCg==\\n\\\"\\\"\\\"\\n )\",\n \"def pytest_generate_tests(metafunc):\\n if (\\\"solver\\\" in metafunc.fixturenames\\n and \\\"coefficients\\\" in metafunc.fixturenames):\\n _parametrize_solver_coefficients(metafunc)\",\n \"def test_setup(funct):\\n\\n def decorated_setup():\\n \\\"\\\"\\\"Decorated test setup.\\\"\\\"\\\"\\n testdb.reload_db()\\n funct()\\n return decorated_setup\",\n \"def test_cont_larvaemutattion(): \\n pass\",\n \"def test_T01():\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=ScalingTransformer.__init__,\\n expected_arguments=[\\\"self\\\", \\\"columns\\\", \\\"scaler\\\", \\\"scaler_kwargs\\\"],\\n expected_default_values=({},),\\n )\",\n \"def template_for_test_functions():\\r\\n\\r\\n expected = \\\"\\\"\\r\\n actual = \\\"\\\"\\r\\n print_test_results(func, expected, actual)\",\n \"def test_get_larvaemutation_function():\\n \\n f = get_larvaemutation_function('bin')\\n assert 'function bin_larvaemutation' in str(f)\\n f = get_larvaemutation_function('disc')\\n assert 'function disc_larvaemutation' in str(f)\",\n \"def before_test(self, func, *args, **kwargs):\\n pass\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=ScalingTransformer.fit,\\n expected_arguments=[\\\"self\\\", \\\"X\\\", \\\"y\\\"],\\n expected_default_values=(None,),\\n )\",\n \"def test_function(arg_1):\\n return arg_1 * 2\",\n \"def test_preprocessed_data(self):\\n self.assertEqual(self.tester.preprocessed_data, [1, 2])\",\n \"def before_call_used_args_add_description(self, args_values, code_reference, function_info, args_code):\\n description = None\\n if function_info == ('pandas.io.parsers', 'read_csv'):\\n filename = args_values[0].split(os.path.sep)[-1]\\n description = \\\"{}\\\".format(filename) # TODO: Add loaded columns as well\\n elif function_info == ('pandas.core.frame', 'dropna'):\\n description = \\\"dropna\\\"\\n elif function_info == ('pandas.core.frame', '__getitem__'):\\n # TODO: Can this also be a select?\\n if isinstance(args_values, MlinspectSeries):\\n self.code_reference_to_set_item_op[code_reference] = 'Selection'\\n description = \\\"Select by series\\\" # TODO: prettier representation\\n elif isinstance(args_values, str):\\n self.code_reference_to_set_item_op[code_reference] = 'Projection'\\n key_arg = args_values\\n description = \\\"to {}\\\".format([key_arg])\\n elif isinstance(args_values, list):\\n self.code_reference_to_set_item_op[code_reference] = 'Projection'\\n description = \\\"to {}\\\".format(args_values)\\n elif function_info == ('pandas.core.frame', '__setitem__'):\\n key_arg = args_values\\n description = \\\"Sets columns {}\\\".format([key_arg])\\n SetKeyInfo = namedtuple(\\\"SetKeyInfo\\\", [\\\"code_reference\\\", \\\"function_info\\\", \\\"args_code\\\"])\\n self.set_key_info = SetKeyInfo(code_reference, function_info, args_code)\\n elif function_info == ('pandas.core.frame', 'groupby'):\\n description = \\\"Group by {}, \\\".format(args_values)\\n self.code_reference_to_description[code_reference] = description\\n if description:\\n self.code_reference_to_description[code_reference] = description\",\n \"def test_extended(self, monkeypatch, script_runner):\\n monkeypatch.setattr(\\\"builtins.input\\\", lambda _: \\\"n\\\")\\n ret = script_runner.run(\\n \\\"spectrafit\\\",\\n \\\"spectrafit/test/test_data.txt\\\",\\n \\\"-i\\\",\\n \\\"spectrafit/test/test_input_2.json\\\",\\n )\\n assert ret.success\\n assert ret.stderr == \\\"\\\"\",\n \"def test_wraps():\\n print('func')\",\n \"def test_visualisations_get_visualisation(self):\\n pass\",\n \"def test_predictor():\",\n \"def testFunctionName(self):\\n with self.assertRaises(AttributeError):\\n Manager.Properties.Version.Set(get_object(TOP_OBJECT), {})\",\n \"def test_doc_fun(self):\\n for fun in self.functions:\\n self.assertTrue(len(fun.__doc__) > 0)\",\n \"def test(self, dataset) -> None:\\n raise NotImplementedError()\",\n \"def test_T1():\",\n \"def test_T1():\",\n \"def test_visualize_recipe_taste(self):\\n pass\",\n \"def test_click_common_options(self) -> None:\\n args = ['--debug', '--verbose']\\n\\n @click.command('test_func')\\n @click_common_options\\n def test_func(**kwargs: Dict[str, Any]) -> None:\\n \\\"\\\"\\\"Function for testing options.\\\"\\\"\\\"\\n click.echo(json.dumps(kwargs))\\n\\n result = json.loads(\\n self.runner.invoke(test_func, args).output.replace('\\\\n', '')\\n )\\n\\n self.assertEqual(result, {'debug': True, 'verbose': True})\",\n \"def test(self) -> Any:\\n pass\",\n \"def test_load_from_function(self):\\n self.test_table.load_from_function(create_small_test_odml)\\n self.assertEqual(self.test_table._odmldict, self.expected_odmldict)\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=BaseTransformer.fit,\\n expected_arguments=[\\\"self\\\", \\\"X\\\", \\\"y\\\"],\\n expected_default_values=(None,),\\n )\",\n \"def test_base_opt_validate():\\n opt = scheme._BaseOpt()\\n with pytest.raises(NotImplementedError):\\n opt.validate('foo', 'test-data')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6495841","0.62949693","0.622999","0.622999","0.6012674","0.5847949","0.5794979","0.5786388","0.56368995","0.5633291","0.5617154","0.55914575","0.5590488","0.55788755","0.55642676","0.55561197","0.5555672","0.5555672","0.5554121","0.5550097","0.55453503","0.5534051","0.5515985","0.55138695","0.55138695","0.55138695","0.55138695","0.55138695","0.5507298","0.5497894","0.5494825","0.5489732","0.54699016","0.54664373","0.5458682","0.54519415","0.54484135","0.5447443","0.5439451","0.54295284","0.5417875","0.54169786","0.5411795","0.5407779","0.54050934","0.5402325","0.5400565","0.53956616","0.5381733","0.53809017","0.5355493","0.535064","0.5346466","0.53408694","0.5336917","0.5336917","0.5332366","0.5314452","0.53095704","0.5308937","0.5308937","0.5308937","0.5304576","0.52950305","0.5291324","0.5279261","0.5278213","0.52769655","0.5276557","0.52734154","0.5272548","0.5267395","0.52619016","0.52601767","0.5248991","0.5247191","0.5225638","0.5224507","0.52188027","0.52071387","0.5205958","0.5205746","0.5205348","0.52008617","0.52008617","0.5200601","0.51996636","0.5197743","0.51813304","0.5172513","0.51719946"],"string":"[\n \"0.6495841\",\n \"0.62949693\",\n \"0.622999\",\n \"0.622999\",\n \"0.6012674\",\n \"0.5847949\",\n \"0.5794979\",\n \"0.5786388\",\n \"0.56368995\",\n \"0.5633291\",\n \"0.5617154\",\n \"0.55914575\",\n \"0.5590488\",\n \"0.55788755\",\n \"0.55642676\",\n \"0.55561197\",\n \"0.5555672\",\n \"0.5555672\",\n \"0.5554121\",\n \"0.5550097\",\n \"0.55453503\",\n \"0.5534051\",\n \"0.5515985\",\n \"0.55138695\",\n \"0.55138695\",\n \"0.55138695\",\n \"0.55138695\",\n \"0.55138695\",\n \"0.5507298\",\n \"0.5497894\",\n \"0.5494825\",\n \"0.5489732\",\n \"0.54699016\",\n \"0.54664373\",\n \"0.5458682\",\n \"0.54519415\",\n \"0.54484135\",\n \"0.5447443\",\n \"0.5439451\",\n \"0.54295284\",\n \"0.5417875\",\n \"0.54169786\",\n \"0.5411795\",\n \"0.5407779\",\n \"0.54050934\",\n \"0.5402325\",\n \"0.5400565\",\n \"0.53956616\",\n \"0.5381733\",\n \"0.53809017\",\n \"0.5355493\",\n \"0.535064\",\n \"0.5346466\",\n \"0.53408694\",\n \"0.5336917\",\n \"0.5336917\",\n \"0.5332366\",\n \"0.5314452\",\n \"0.53095704\",\n \"0.5308937\",\n \"0.5308937\",\n \"0.5308937\",\n \"0.5304576\",\n \"0.52950305\",\n \"0.5291324\",\n \"0.5279261\",\n \"0.5278213\",\n \"0.52769655\",\n \"0.5276557\",\n \"0.52734154\",\n \"0.5272548\",\n \"0.5267395\",\n \"0.52619016\",\n \"0.52601767\",\n \"0.5248991\",\n \"0.5247191\",\n \"0.5225638\",\n \"0.5224507\",\n \"0.52188027\",\n \"0.52071387\",\n \"0.5205958\",\n \"0.5205746\",\n \"0.5205348\",\n \"0.52008617\",\n \"0.52008617\",\n \"0.5200601\",\n \"0.51996636\",\n \"0.5197743\",\n \"0.51813304\",\n \"0.5172513\",\n \"0.51719946\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.602669"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":76085,"cells":{"query":{"kind":"string","value":"Test pattern_search using mocked response."},"document":{"kind":"string","value":"def test_pattern_search(self, mock_get, circuits_app, umbinv_regex, umbinv_start_epoch, umbinv_start_relative, umbinv_limit, umbinv_include_category):\n\n keys_outer = [\"matches\", \"limit\", \"totalResults\", \"expression\", \"moreDataAvailable\"]\n keys_match = [\"name\", \"securityCategories\", \"firstSeen\", \"name\", \"firstSeenISO\"]\n function_params = {\n \"umbinv_regex\": umbinv_regex,\n \"umbinv_start_epoch\": umbinv_start_epoch,\n \"umbinv_start_relative\": umbinv_start_relative,\n \"umbinv_limit\": umbinv_limit,\n \"umbinv_include_category\": umbinv_include_category\n }\n results = call_umbrella_pattern_search_function(circuits_app, function_params)\n search_matches = results[\"search_matches\"]\n assert_keys_in(search_matches, *keys_outer)\n match = search_matches[\"matches\"].pop(0)\n assert_keys_in(match, *keys_match)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def mock_reddit_search_response(\n ) -> Dict:\n with open(\n \"util/reddit_search_response.json\"\n ) as static_response:\n mock_response = json.load(static_response)\n\n return(mock_response)","def test_search(self):\n d = self._search()\n self._response([2, 5, 10])\n self.assertEqual(self.successResultOf(d), [2, 5, 10])","def test_search_content(self):\n tester = app.test_client(self)\n response = tester.post('/search')\n self.assertEqual(response.content_type,'application/json')","def test_search_content(self, mock_search):\r\n mock_search().search.side_effect = self._return_attr\r\n self.testapp.get('/results/bookie')\r\n\r\n self.assertTrue(mock_search.called)\r\n self.assertEqual(self.attr[0][0],\r\n 'bookie',\r\n 'search term should be bookie')\r\n self.assertTrue(self.attr[1]['content'])","def test_products_get_pattern_no_match(data, mocker):\n mocker.patch(\"sps.request.fetch\", autospec=True)\n request.fetch.return_value = data\n assert products.get(\"foo-bar-search\", \"fake-file-name\", False, False) == []","def test_api_response_data(self):","def test_response(self):\n\n from rubber import settings, resource\n settings.RUBBER_MOCK_HTTP_RESPONSE = \"\"\"{\"took\":2,\"timed_out\":false,\"_shards\":{\"total\":5,\"successful\":5,\"failed\":0},\"hits\":{\"total\":2,\"max_score\":1.0,\"hits\":[{\"_index\":\"auth\",\"_type\":\"user\",\"_id\":\"6\",\"_score\":1.0, \"_source\" : {\"username\": \"guillaume\", \"first_name\": \"\", \"last_name\": \"\", \"is_active\": true, \"is_superuser\": false, \"is_staff\": false, \"last_login\": \"2012-08-02T08:30:11\", \"groups\": [], \"user_permissions\": [], \"password\": \"pbkdf2_sha256$10000$M1nRKJfbvdQf$ouX5u9FOUF/MKhhwuwYbiuoVidFITsBrEstGBB4mzZA=\", \"email\": \"somemail@test.com\", \"date_joined\": \"2012-08-02T08:30:11\"}},{\"_index\":\"auth\",\"_type\":\"user\",\"_id\":\"8\",\"_score\":1.0, \"_source\" : {\"username\": \"stephane\", \"first_name\": \"\", \"last_name\": \"\", \"is_active\": true, \"is_superuser\": false, \"is_staff\": false, \"last_login\": \"2012-08-02T09:14:38\", \"groups\": [], \"user_permissions\": [], \"password\": \"pbkdf2_sha256$10000$ORDHZAnNqTwF$UGmkUCyH0/uh1ruP93ZSTyog9Wi5g2qc+m/fxowigFs=\", \"email\": \"othermail@test.com\", \"date_joined\": \"2012-08-02T09:14:38\"}}]}}\"\"\"\n\n requestmock = RequestMock()\n resource.requests = requestmock\n\n response = self.Article.elasticsearch.search({})\n \n self.assertEquals(2, response.json['took'])\n\n from rubber.response import Response\n self.assertTrue(isinstance(response, Response))","def test_search_question(self): \n data = {'searchTerm':'title'}\n res = self.client().post('/search', \n data=json.dumps(data),\n content_type='application/json')\n self.data = json.loads(res.data)\n self.assertEqual(res.status_code, 200)\n json_res = json.loads(res.get_data(as_text=True))","def test_search(self):\n pass","def test_search(self):\n pass","def test_search(self):\n pass","def test_search(self):\n tester = app.test_client(self)\n response = tester.post('/search')\n self.assertEqual(response.status_code,200)","def test_process_searchbox_with_mock(self):\n\n result = self.client.get('/process_searchbox', data={'zipcode': '94043', 'cuisine': 'indian'})\n self.assertIn(b\"Dosa Paratha\", result.data)","def __init__(self, pattern, response_dict):\r\n self._pattern = pattern\r\n self._response_dict = response_dict","def test_search_view(client):\n\n with patch('search.helpers.search_with_activitystream') as search:\n mock_results = json.dumps(\n {\n 'took': 17,\n 'timed_out': False,\n '_shards': {'total': 4, 'successful': 4, 'skipped': 0, 'failed': 0},\n 'hits': {\n 'total': {\n 'value': 5,\n 'relation': 'eq',\n # This is an ActivityStream-V2-style/ES7-style 'total' field -\n # AS-V1/ES6 returned an int not a dict\n },\n 'max_score': 0.2876821,\n 'hits': [\n {\n '_index': 'objects__feed_id_first_feed__date_2019',\n '_type': '_doc',\n '_id': 'dit:exportOpportunities:Opportunity:2',\n '_score': 0.2876821,\n '_source': {\n 'type': ['Document', 'dit:Opportunity'],\n 'title': 'France - Data analysis services',\n 'content': 'The purpose of this contract is to analyze...',\n 'url': 'www.great.gov.uk/opportunities/1',\n },\n },\n {\n '_index': 'objects__feed_id_first_feed__date_2019',\n '_type': '_doc',\n '_id': 'dit:exportOpportunities:Opportunity:2',\n '_score': 0.18232156,\n '_source': {\n 'type': ['Document', 'dit:Opportunity'],\n 'title': 'Germany - snow clearing',\n 'content': 'Winter services for the properties1) Former...',\n 'url': 'www.great.gov.uk/opportunities/2',\n },\n },\n ],\n },\n }\n )\n search.return_value = Mock(status_code=200, content=mock_results)\n\n response = client.get(reverse('search:search'), data={'q': 'services'})\n context = response.context_data\n\n assert response.status_code == 200\n assert context['results'] == [\n {\n 'type': 'Export opportunity',\n 'title': 'France - Data analysis services',\n 'content': 'The purpose of this contract is to analyze...',\n 'url': 'www.great.gov.uk/opportunities/1',\n },\n {\n 'type': 'Export opportunity',\n 'title': 'Germany - snow clearing',\n 'content': 'Winter services for the properties1) Former...',\n 'url': 'www.great.gov.uk/opportunities/2',\n },\n ]\n\n \"\"\" What if there are no results? \"\"\"\n search.return_value = Mock(\n status_code=200,\n content=json.dumps(\n {\n 'took': 17,\n 'timed_out': False,\n '_shards': {'total': 4, 'successful': 4, 'skipped': 0, 'failed': 0},\n 'hits': {\n 'total': {\n 'value': 0,\n 'relation': 'eq',\n },\n 'hits': [],\n },\n }\n ),\n )\n\n response = client.get(reverse('search:search'), data={'q': 'services'})\n context = response.context_data\n\n assert response.status_code == 200\n assert context['results'] == []\n\n \"\"\" What if ActivitySteam sends an error? \"\"\"\n search.return_value = Mock(status_code=500, content='[service overloaded]')\n\n response = client.get(reverse('search:search'), data={'q': 'services'})\n context = response.context_data\n\n assert response.status_code == 200\n # This can be handled on the front end as we wish\n assert context['error_message'] == '[service overloaded]'\n assert context['error_status_code'] == 500\n\n \"\"\" What if ActivitySteam is down? \"\"\"\n search.side_effect = requests.exceptions.ConnectionError\n\n response = client.get(reverse('search:search'), data={'q': 'services'})\n context = response.context_data\n\n assert response.status_code == 200\n # This can be handled on the front end as we wish\n assert context['error_message'] == 'Activity Stream connection failed'\n assert context['error_status_code'] == 500","def test_no_search_string(self):\n resp = SearchTest.client.get('/api/search/',{'token':SearchTest.valid_token})\n self.assertEqual(json.loads(resp.content),\"You give your input in wrong format. Please check the API documentation for the appropriate input format!!\",\"No Search String Test Error\")","def test_search_data(self):\n tester = app.test_client(self)\n response = tester.post('/search')\n data = response.get_json()\n self.assertTrue('data' in data)","def test_search_metadata_unit(integrated_ff, url):\n with mock.patch.object(ff_utils, \"authorized_request\", make_mocked_search()):\n check_search_metadata(integrated_ff, url)","def test_get_data_success(monkeypatch):\n\n class MockResponse(object):\n def __init__(self):\n self.status_code = 200\n\n def json(self):\n return {\n \"continue\": {\"excontinue\": 1, \"continue\": \"||info\"},\n \"query\": {\n \"pages\": {\n \"151688\": {\n \"pageid\": 151688,\n \"ns\": 0,\n \"title\": \"Naantali\",\n \"index\": -1,\n \"extract\": \"Naantali (en suédois Nådendal, en latin Vallis Gratiae - la vallée de grâce) est une ville du sud-ouest de la Finlande. Cette petite ville, qui compte une population de 19 000 habitants, se situe dans la province de Finlande occidentale et la région de Finlande du Sud-Ouest, à 15 km à l'ouest de Turku, la capitale provinciale.\", # noqa: E501\n \"contentmodel\": \"wikitext\",\n \"pagelanguage\": \"fr\",\n \"pagelanguagehtmlcode\": \"fr\",\n \"pagelanguagedir\": \"ltr\",\n \"touched\": \"2020-10-08T00:35:54Z\",\n \"lastrevid\": 169716755,\n \"length\": 14393,\n \"fullurl\": \"https://fr.wikipedia.org/wiki/Naantali\", # noqa: E501\n \"editurl\": \"https://fr.wikipedia.org/w/index.php?title=Naantali&action=edit\", # noqa: E501\n \"canonicalurl\": \"https://fr.wikipedia.org/wiki/Naantali\", # noqa: E501\n },\n \"2709037\": {\n \"pageid\": 2709037,\n \"ns\": 0,\n \"title\": \"Muumimaailma\",\n \"index\": 0,\n \"contentmodel\": \"wikitext\",\n \"pagelanguage\": \"fr\",\n \"pagelanguagehtmlcode\": \"fr\",\n \"pagelanguagedir\": \"ltr\",\n \"touched\": \"2020-10-04T16:19:49Z\",\n \"lastrevid\": 168229306,\n \"length\": 1447,\n \"fullurl\": \"https://fr.wikipedia.org/wiki/Muumimaailma\", # noqa: E501\n \"editurl\": \"https://fr.wikipedia.org/w/index.php?title=Muumimaailma&action=edit\", # noqa: E501\n \"canonicalurl\": \"https://fr.wikipedia.org/wiki/Muumimaailma\", # noqa: E501\n },\n \"5751499\": {\n \"pageid\": 5751499,\n \"ns\": 0,\n \"title\": \"Kultaranta\",\n \"index\": 1,\n \"contentmodel\": \"wikitext\",\n \"pagelanguage\": \"fr\",\n \"pagelanguagehtmlcode\": \"fr\",\n \"pagelanguagedir\": \"ltr\",\n \"touched\": \"2020-10-08T00:43:32Z\",\n \"lastrevid\": 164009230,\n \"length\": 11889,\n \"fullurl\": \"https://fr.wikipedia.org/wiki/Kultaranta\", # noqa: E501\n \"editurl\": \"https://fr.wikipedia.org/w/index.php?title=Kultaranta&action=edit\", # noqa: E501\n \"canonicalurl\": \"https://fr.wikipedia.org/wiki/Kultaranta\", # noqa: E501\n },\n \"7700543\": {\n \"pageid\": 7700543,\n \"ns\": 0,\n \"title\": \"Port de Naantali\",\n \"index\": 2,\n \"contentmodel\": \"wikitext\",\n \"pagelanguage\": \"fr\",\n \"pagelanguagehtmlcode\": \"fr\",\n \"pagelanguagedir\": \"ltr\",\n \"touched\": \"2020-10-04T16:25:50Z\",\n \"lastrevid\": 162923416,\n \"length\": 2675,\n \"fullurl\": \"https://fr.wikipedia.org/wiki/Port_de_Naantali\", # noqa: E501\n \"editurl\": \"https://fr.wikipedia.org/w/index.php?title=Port_de_Naantali&action=edit\", # noqa: E501\n \"canonicalurl\": \"https://fr.wikipedia.org/wiki/Port_de_Naantali\", # noqa: E501\n },\n }\n },\n }\n\n parameters = {\n \"action\": \"query\",\n \"prop\": \"extracts|info\",\n \"inprop\": \"url\",\n \"explaintext\": True,\n \"exsentences\": 2,\n \"exlimit\": 1,\n \"generator\": \"geosearch\",\n \"ggsradius\": 10000,\n \"ggscoord\": f\"{00000}|{00000}\",\n \"format\": \"json\",\n }\n\n headers = {\n \"date\": \"10/10/2020\",\n \"user-agent\": '\"MoominPappaBot/fake_version',\n }\n\n def mock_get(url, params=parameters, headers=headers, timeout=10):\n return MockResponse()\n\n monkeypatch.setattr(requests, \"get\", mock_get)\n\n request = MediawikiApi(\"user_input1\", \"user_input2\")\n result = request.get_data()\n expected_result = {\n \"title\": \"Naantali\",\n \"extract\": \"Naantali (en suédois Nådendal, en latin Vallis Gratiae - la vallée de grâce) est une ville du sud-ouest de la Finlande. Cette petite ville, qui compte une population de 19 000 habitants, se situe dans la province de Finlande occidentale et la région de Finlande du Sud-Ouest, à 15 km à l'ouest de Turku, la capitale provinciale.\", # noqa: E501\n \"fullurl\": \"https://fr.wikipedia.org/wiki/Naantali\",\n }\n assert result == expected_result","def test_products_get_pattern_single_match(data, mocker):\n mocker.patch(\"sps.request.fetch\", autospec=True)\n request.fetch.return_value = data\n assert products.get(\"Manager\", \"fake-file-name\", False, False) == [data[\"data\"][0]]\n assert products.get(\"Desktop\", \"fake-file-name\", False, False) == [data[\"data\"][1]]","def test_search_page_item_in_database(self, mock_search):\n mock_search.return_value = {\"result\": \"result\", \"products\": \"products\"}\n response = self.client.post(\"/search/\", {\"query\": \"test\"})\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, \"search/base.html\")\n self.assertTemplateUsed(response, \"search/search_form.html\")\n self.assertTemplateUsed(response, \"search/results_page.html\")\n self.assertTemplateUsed(response, \"search/result.html\")\n self.assertEqual(response.context[\"result\"], \"result\")\n self.assertEqual(response.context[\"products\"], \"products\")","def test_404_search_results_unprocesssable(self):\n data = {'searchTerm':'wxyz'}\n res = self.client().post('/search', \n data=json.dumps(data),\n content_type='application/json')\n self.data = json.loads(res.data)\n self.assertEqual(res.status_code, 404)\n json_res = json.loads(res.get_data(as_text=False))","def test_success_search_result(self):\n search_org_api = '/api/org/?search=test'\n auth_client = self.create_auth_client()\n filter_result = ListOrgSerializer(Org.objects.filter(name__startswith='test'), many=True) \n response = auth_client.get(search_org_api)\n self.assertEqual(response.data, filter_result.data)","def test_01_search(self):\r\n res = self.app.get('/search')\r\n err_msg = \"Search page should be accessible\"\r\n assert \"Search\" in res.data, err_msg","def test_search_page_no_API_results(self, mock_api, mock_search):\n mock_search.side_effect = [LookupError, ValueError]\n response = self.client.post(\"/search/\", {\"query\": \"test\"})\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, \"search/base.html\")\n self.assertTemplateUsed(response, \"search/search_form.html\")\n self.assertTemplateUsed(response, \"search/results_page.html\")\n self.assertTemplateNotUsed(response, \"search/result.html\")\n self.assertEqual(response.context[\"error\"],\n \"Votre recherche n'a donné aucun résultats\")","def test_response_json(self):\n response = self.client.search()\n self.assertTrue(isinstance(response.json, dict))\n\n\n # with invalid json\n from rubber import settings\n settings.RUBBER_MOCK_HTTP_RESPONSE = \"\"\";;;\"\"\"\n \n response = self.client.search()\n self.assertIsNone(response.json)","def test_search_endpoint(self, mock_request):\n cli = REST(TestAlphaVantage._API_KEY_TEST)\n url = \"https://www.alphavantage.co/query?function=SYMBOL_SEARCH&keywords=BA&datatype=json&apikey=test\"\n path_file = self.get_file_from_url(\"symbol_search\")\n with open(path_file) as f:\n mock_request.get(url, text=f.read())\n data = cli.search_endpoint(\"BA\")\n self.assertIsInstance(\n data, dict, 'Result Data must be a dict')","def test_search(self):\n with unittest.mock.patch('builtins.input', return_value='a'):\n good = self.ec.search()\n self.assertTrue(good)\n with unittest.mock.patch('builtins.input', return_value='b'):\n good = self.ec.search()\n self.assertTrue(good)\n with unittest.mock.patch('builtins.input', return_value='c'):\n good = self.ec.search()\n self.assertTrue(good)\n with unittest.mock.patch('builtins.input', return_value='d'):\n good = self.ec.search()\n self.assertTrue(good)\n with unittest.mock.patch('builtins.input', return_value='e'):\n good = self.ec.search()\n self.assertTrue(good)\n with unittest.mock.patch('builtins.input', return_value='q'):\n good = self.ec.search()\n self.assertFalse(good)","def test_hit_class(self):\n class MyHit(object):\n def __init__(self, d):\n self.data = d\n\n self.Article.elasticsearch.hit_class = MyHit\n\n from rubber import settings, resource\n settings.RUBBER_MOCK_HTTP_RESPONSE = \"\"\"{\"took\":2,\"timed_out\":false,\"_shards\":{\"total\":5,\"successful\":5,\"failed\":0},\"hits\":{\"total\":2,\"max_score\":1.0,\"hits\":[{\"_index\":\"auth\",\"_type\":\"user\",\"_id\":\"6\",\"_score\":1.0, \"_source\" : {\"username\": \"guillaume\", \"first_name\": \"\", \"last_name\": \"\", \"is_active\": true, \"is_superuser\": false, \"is_staff\": false, \"last_login\": \"2012-08-02T08:30:11\", \"groups\": [], \"user_permissions\": [], \"password\": \"pbkdf2_sha256$10000$M1nRKJfbvdQf$ouX5u9FOUF/MKhhwuwYbiuoVidFITsBrEstGBB4mzZA=\", \"email\": \"somemail@test.com\", \"date_joined\": \"2012-08-02T08:30:11\"}},{\"_index\":\"auth\",\"_type\":\"user\",\"_id\":\"8\",\"_score\":1.0, \"_source\" : {\"username\": \"stephane\", \"first_name\": \"\", \"last_name\": \"\", \"is_active\": true, \"is_superuser\": false, \"is_staff\": false, \"last_login\": \"2012-08-02T09:14:38\", \"groups\": [], \"user_permissions\": [], \"password\": \"pbkdf2_sha256$10000$ORDHZAnNqTwF$UGmkUCyH0/uh1ruP93ZSTyog9Wi5g2qc+m/fxowigFs=\", \"email\": \"othermail@test.com\", \"date_joined\": \"2012-08-02T09:14:38\"}}]}}\"\"\"\n \n requestmock = RequestMock()\n resource.requests = requestmock\n\n response = self.Article.elasticsearch.search({})\n\n # This should be a SearchResponse\n from rubber.response import SearchResponse\n self.assertTrue(isinstance(response, SearchResponse))\n\n # It should have a 'results' attribute\n self.assertTrue(hasattr(response, 'results'))\n\n # Hits should be MyHit objects\n self.assertTrue(isinstance(response.results.hits[0], MyHit))","def test_get_results(self):\n pass","def test_get_search_results(self, mock_get):\n\n search_url = self.test_data[\"search_url\"]\n search_response = self.test_data[\"search_response\"]\n image_page_urls = self.test_data[\"image_page_urls\"]\n next_page_exists = self.test_data[\"next_page_exists\"]\n \n mock_get.return_value = self._build_mock_response(text = search_response)\n\n (actual_image_page_urls, actual_next_page_exists) = self.retriever._get_search_results(search_url)\n\n self.assertEqual(list(actual_image_page_urls), \\\n image_page_urls, msg = \"Unable to extract image tags from the search page\")\n\n self.assertEqual(actual_next_page_exists, \\\n next_page_exists, msg = \"Incorrect next-page-exists indicator detected\")","def test_successful_search(self, mock_spotify_api_class, valid_request):\n\n with patch('bpm.spotify.requests.get') as mock_requests:\n mock_requests.return_value = valid_request\n result = mock_spotify_api_class.search(query={\"track\": \"mock_track_name\"},\n search_type=\"track\",\n market_type=\"GB\")\n assert result == valid_request.json.return_value","def test_hits_should_be_correctly_sorted_on_title(\n self, client: Flask, docker_service, api, wait_for_information_models\n ):\n search_str = \"di\"\n body = {\"q\": search_str, \"size\": 300}\n result = client.post(informationmodel_url, json=body)\n assert result.status_code == 200\n result_json = result.json\n last_was_exact_match = True\n last_was_partial_match_in_title = False\n for hit in result_json[\"hits\"]:\n if has_exact_match_in_title(hit, search_str):\n assert last_was_exact_match\n last_was_exact_match = True\n elif has_partial_match_in_title(hit, search_str):\n assert last_was_exact_match or last_was_partial_match_in_title\n last_was_exact_match = False\n last_was_partial_match_in_title = True\n else:\n last_was_exact_match = False\n last_was_partial_match_in_title = False","def test_search_template(self):\n self.assertTemplateUsed(self.response, 'rango/search.html', f\"{FAILURE_HEADER}Your search() view does not use the expected template.{FAILURE_FOOTER}\")","def test_search_page_no_DB_results(self, mock_api, mock_search):\n mock_search.side_effect = [LookupError, LookupError]\n response = self.client.post(\"/search/\", {\"query\": \"test\"})\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, \"search/base.html\")\n self.assertTemplateUsed(response, \"search/search_form.html\")\n self.assertTemplateUsed(response, \"search/results_page.html\")\n self.assertTemplateNotUsed(response, \"search/result.html\")\n self.assertEqual(response.context[\"error\"],\n \"Votre recherche n'a donné aucun résultats\")","def test_search_page(self):\n result = self.client.get(\"/search\")\n self.assertIn(b\"Search\", result.data)","def test_all_tweets(self):\n\n response1 = {'meta': {'result_count': 500, 'next_token': 1}}\n response2 = {'meta': {'result_count': 500, 'next_token': 2}}\n response3 = {'meta': {'result_count': 500, 'next_token': 3}}\n response4 = {'meta': {'result_count': 500}}\n\n wk = os.path.dirname(os.path.abspath(__file__))\n f = os.path.join(wk, \"search_tweets.config\")\n thing = SearchTweets(self.db, f)\n with patch.object(thing, '_SearchTweets__twitter_n_results', new_callable=PropertyMock(return_value=10)):\n with patch.object(thing, '_SearchTweets__twitter_all_tweets', new_callable=PropertyMock(return_value=True)):\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\n with patch.object(thing, '_SearchTweets__multi_user',\n new_callable=PropertyMock(return_value=False)):\n with patch.object(thing, '_SearchTweets__twitter_users',\n new_callable=PropertyMock(return_value=[])):\n with patch.object(thing, '_SearchTweets__twitter_keyword',\n new_callable=PropertyMock(return_value=\"Eurovision\")):\n with self.assertLogs('SEARCH', level='DEBUG') as cm:\n with patch.object(thing, '_SearchTweets__save'):\n\n mock_method.side_effect = [response1, response2, response3, response4]\n thing.search()\n\n self.assertEqual(mock_method.call_count, 4)\n self.assertTrue(\"DEBUG:SEARCH:ASKING FOR NEXT PAGE\" in cm.output)\n self.assertTrue(\"DEBUG:SEARCH:THERE ARE NO OTHER PAGE AVAILABLE. ALL TWEETS REACHED\" in cm.output)\n self.assertTrue(\"DEBUG:SEARCH:NO NEXT TOKEN IN RESPONSE:INTERRUPTING\" in cm.output)","def test_no_next_token(self):\n\n response1 = {'meta': {'result_count': 500}}\n wk = os.path.dirname(os.path.abspath(__file__))\n f = os.path.join(wk, \"search_tweets.config\")\n thing = SearchTweets(self.db, f)\n with patch.object(thing, '_SearchTweets__twitter_n_results', new_callable=PropertyMock(return_value=520)):\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\n with patch.object(thing, '_SearchTweets__multi_user', new_callable=PropertyMock(return_value=False)):\n with patch.object(thing, '_SearchTweets__twitter_users',\n new_callable=PropertyMock(return_value=[])):\n with patch.object(thing, '_SearchTweets__twitter_keyword',\n new_callable=PropertyMock(return_value=\"Eurovision\")):\n with self.assertLogs('SEARCH', level='DEBUG') as cm:\n with patch.object(thing, '_SearchTweets__save'):\n mock_method.side_effect = [response1]\n thing.search()\n\n self.assertEqual(mock_method.call_count, 1)\n self.assertTrue(\"DEBUG:SEARCH:THERE ARE NO OTHER PAGE AVAILABLE. ALL TWEETS REACHED\" in cm.output)\n self.assertTrue(\"DEBUG:SEARCH:NO NEXT TOKEN IN RESPONSE:INTERRUPTING\" in cm.output)","def test_all_tweets2(self):\n\n response1 = {'meta': {'result_count': 500, 'next_token': 1}}\n response2 = {'meta': {'result_count': 500, 'next_token': 2}}\n response3 = {'meta': {'result_count': 500, 'next_token': 3}}\n response4 = {'meta': {'result_count': 500}}\n\n wk = os.path.dirname(os.path.abspath(__file__))\n f = os.path.join(wk, \"search_tweets.config\")\n thing = SearchTweets(self.db, f)\n with patch.object(thing, '_SearchTweets__twitter_all_tweets', new_callable=PropertyMock(return_value=True)):\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\n with patch.object(thing, '_SearchTweets__multi_user', new_callable=PropertyMock(return_value=False)):\n with patch.object(thing, '_SearchTweets__twitter_users',\n new_callable=PropertyMock(return_value=[])):\n with patch.object(thing, '_SearchTweets__twitter_keyword',\n new_callable=PropertyMock(return_value=\"Eurovision\")):\n with self.assertLogs('SEARCH', level='DEBUG') as cm:\n with patch.object(thing, '_SearchTweets__save'):\n mock_method.side_effect = [response1, response2, response3, response4]\n thing.search()\n\n self.assertEqual(mock_method.call_count, 4)\n self.assertTrue(\"DEBUG:SEARCH:ASKING FOR NEXT PAGE\" in cm.output)\n self.assertTrue(\"DEBUG:SEARCH:THERE ARE NO OTHER PAGE AVAILABLE. ALL TWEETS REACHED\" in cm.output)\n self.assertTrue(\"DEBUG:SEARCH:NO NEXT TOKEN IN RESPONSE:INTERRUPTING\" in cm.output)","def test_search(client, example_records, h, prefix):\n res = client.get(prefix, headers=h)\n assert res.status_code == 200\n assert res.json[\"hits\"][\"total\"] == 2\n assert res.json['sortBy'] == 'title'","def test_load_search(self, mock_get):\n\n c = Client()\n data = {\n 'search_type': self.filter_title,\n 'search_value': self.title\n }\n response = c.post('/taric_books/search/', data=data)\n\n self.assertEqual(response.status_code, 200)","def _mock_requests_get(text):\n return lambda *args, **kwargs: PrometheusClientTest.FakeResponse(\n args[0], text, 200,\n )","def test_search_samples(self):\n self.login()\n\n page_size = 20\n query = 'batch8'\n\n # hit the API endpoint\n data = {'q': query,\n 'page': 1,\n 'page_size': page_size}\n response = self.client.get(reverse('searchsamples'), data, format='json')\n\n expected = Sample.objects.filter(batch__icontains=query).order_by(\"-received\")\n\n # format queryset into json for returning\n serializer = SampleSerializer(expected, many=True)\n\n context = {\n 'data': serializer.data,\n 'more': False\n }\n\n self.assertEqual(response.json(), context)\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def test_full_text_search_results(self):\n with mock.patch('full_text_search.search') as full_text_search_mock:\n full_text_search_mock.return_value = (\n SearcherTests.FULLTEXT_RETURN_VALUE)\n searcher = Searcher(\n SearcherTests.REPO_NAME,\n enable_fulltext_search=True,\n max_results=SearcherTests.MAX_RESULTS)\n assert (\n searcher.search('matt') == SearcherTests.FULLTEXT_RETURN_VALUE)\n assert len(full_text_search_mock.call_args_list) == 1\n call_args, _ = full_text_search_mock.call_args_list[0]\n assert call_args[0] == SearcherTests.REPO_NAME\n assert call_args[1] == {'name': 'matt'}\n assert call_args[2] == SearcherTests.MAX_RESULTS","def test_search(self):\n from rubber import resource\n requestmock = RequestMock()\n resource.requests = requestmock\n\n q = {'query': {'term': {'user': 'kimchy'}}}\n self.Article.elasticsearch.search(q, toto='titi')\n\n self.assertEquals(1, len(requestmock.stack))\n self.assertEquals('http://example.com:9200/tests/article/_search', requestmock.stack[0]['url'])\n self.assertEquals('GET', requestmock.stack[0]['method'])\n self.assertEquals('titi', requestmock.stack[0]['kwargs']['toto'])\n from rubber.instanceutils import data_to_json\n self.assertEquals(data_to_json(q), requestmock.stack[0]['kwargs']['data'])\n\n self.Article.elasticsearch.mapping.put({'some': 'mapping'}, toto='titi')\n\n self.assertEquals(2, len(requestmock.stack))\n self.assertEquals('http://example.com:9200/tests/article/_mapping', requestmock.stack[1]['url'])\n self.assertEquals('PUT', requestmock.stack[1]['method'])\n self.assertEquals('titi', requestmock.stack[1]['kwargs']['toto'])","def test_foodtrucks_searchByKeyword(self):\n\n\t\tprint 'API Test: retrieving foodtruck record by keyword'\n\t\turl = reverse('foodtruck_list')\n\t\tdata0 = {'objectid': 0, 'applicant':'Pizza', 'x': 0.0, 'y': 0.5}\n\t\tdata1 = {'objectid': 1, 'applicant':'Chicago', 'fooditems': 'deep dish pizza and sandwiches', 'x': 1.0, 'y': 1.0}\n\t\tdata2 = {'objectid': 2, 'applicant':'hotdog house', 'x': 1.5, 'y': 1.5}\n\t\tresponse = self.client.post(url, data0, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\n\t\tresponse = self.client.post(url, data1, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\n\t\tresponse = self.client.post(url, data2, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\n\t\t#print response.status_code\n\t\tresponse = self.client.get('/foodtrucks/bykeyword?keyword=pizza', format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(len(response.data), 2)\n\t\tself.assertEqual(response.data[0]['objectid'], 0)\n\t\tself.assertEqual(response.data[1]['objectid'], 1)\n\t\tprint 'pass'","def test_search_content_ajax(self, mock_search):\r\n mock_search().search.side_effect = self._return_attr\r\n self.testapp.get(url='/results/ajax', xhr=True)\r\n\r\n self.assertTrue(mock_search.called)\r\n self.assertEqual(self.attr[0][0],\r\n 'ajax',\r\n 'search term should be ajax')\r\n self.assertTrue(self.attr[1]['content'])","def test_search(self):\n response = Tmdb.search('ozark')\n self.assertTrue(int(response.status_code) == 200)\n data = response.json()\n self.assertTrue(isinstance(data['results'], list))\n # TODO check if all the shows are in the good format (can be from_dict/to_dict)","def test_search(self):\n\n with self.client as c:\n response = c.get(\"/users?q=al\")\n data = str(response.data)\n\n self.assertIn(\"@alice\", data)\n self.assertIn(\"@alvin\", data)\n\n self.assertNotIn(\"@bob\", data)\n self.assertNotIn(\"@carl\", data)","def test_happy_path(self):\n\n self.client.force_authenticate(user=self.user)\n data = {\n \"words\": 100,\n \"response_format\": 'json'\n }\n\n with mock.patch(\"tweety.utils.TweetTextParser.extract_word_cloud\") as mock_cloud_func:\n mock_cloud_func.return_value = self.json_cloud\n response = self.client.post(self.url, data=data)\n\n self.assertIsInstance(response.accepted_renderer, JSONRenderer)\n self.assertEqual(response.data, self.json_cloud)\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n\n data = {\n \"words\": 100,\n \"response_format\": 'csv'\n }\n\n with mock.patch(\"tweety.utils.TweetTextParser.extract_word_cloud\") as mock_cloud_func:\n mock_cloud_func.return_value = self.csv_cloud\n response = self.client.post(self.url, data=data)\n\n self.assertIsInstance(response.accepted_renderer, utils.TweetyCsvRenderer)\n self.assertEqual(response.data, self.csv_cloud)\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def test_semantic_search(self):\n # A name in the database\n search_string = \"football\"\n # Search For Umut\n resp = SearchTest.client.get('/api/search/',{\"token\":SearchTest.valid_token,\"search_string\":search_string})\n search_result = json.loads(resp.content)\n # Umut must be in the results because basketball and football are semanticly related\n self.assertEqual(\"Umut\",search_result[0]['name'],\"Semantic Search functionality doesn't work.\")","def test_load_search_subject(self, mock_get):\n\n c = Client()\n data = {\n 'search_type': self.filter_subject,\n 'search_value': self.subject,\n }\n response = c.post('/taric_books/search/', data=data)\n\n self.assertEqual(response.status_code, 200)","def test_search_recipes(self):\n pass","def test_response_class(self):\n\n response = self.client.search({})\n\n from rubber.response import Response, SearchResponse\n self.assertTrue(isinstance(response, Response))\n self.assertTrue(isinstance(response, SearchResponse))\n\n response = self.client.mapping.get()\n self.assertTrue(isinstance(response, Response))\n self.assertFalse(isinstance(response, SearchResponse))","def test_no_next_token_2calls(self):\n\n response1 = {'meta': {'result_count': 500, 'next_token': 1}}\n response2 = {'meta': {'result_count': 10}}\n\n wk = os.path.dirname(os.path.abspath(__file__))\n f = os.path.join(wk, \"search_tweets.config\")\n thing = SearchTweets(self.db, f)\n with patch.object(thing, '_SearchTweets__twitter_n_results', new_callable=PropertyMock(return_value=520)):\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\n with patch.object(thing, '_SearchTweets__multi_user', new_callable=PropertyMock(return_value=False)):\n with patch.object(thing, '_SearchTweets__twitter_users',\n new_callable=PropertyMock(return_value=[])):\n with patch.object(thing, '_SearchTweets__twitter_keyword',\n new_callable=PropertyMock(return_value=\"Eurovision\")):\n with self.assertLogs('SEARCH', level='DEBUG') as cm:\n with patch.object(thing, '_SearchTweets__save'):\n mock_method.side_effect = [response1, response2]\n thing.search()\n\n self.assertEqual(mock_method.call_count, 2)\n self.assertTrue(\"DEBUG:SEARCH:THERE ARE NO OTHER PAGE AVAILABLE. ALL TWEETS REACHED\" in cm.output)\n self.assertTrue(\"DEBUG:SEARCH:NO NEXT TOKEN IN RESPONSE:INTERRUPTING\" in cm.output)","def test_products_get_pattern_multiple_match(data, mocker):\n mocker.patch(\"sps.request.fetch\", autospec=True)\n request.fetch.return_value = data\n assert products.get(\"1\", \"fake-file-name\", False, False) == data[\"data\"]\n assert products.get(\"SUSE\", \"fake-file-name\", False, False) == data[\"data\"]\n assert products.get(\"x86\", \"fake-file-name\", False, False) == data[\"data\"]","def search(self, pattern):\n raise NotImplementedError()","def test_search_systems_post(self):\n pass","def testMaxResult(self):\n \"\"\" In this case we are asking for 520 tweets, and we return as first result 500 tweets \"\"\"\n \"\"\" we check that er make exactly 2 requests. \"\"\"\n\n response1 = {'meta': {'result_count': 500, 'next_token': 1}}\n response2 = {'meta': {'result_count': 20, 'next_token': 2}}\n wk = os.path.dirname(os.path.abspath(__file__))\n f = os.path.join(wk, \"search_tweets.config\")\n thing = SearchTweets(self.db, f)\n with patch.object(thing, '_SearchTweets__twitter_n_results', new_callable=PropertyMock(return_value=520)):\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\n with patch.object(thing, '_SearchTweets__multi_user', new_callable=PropertyMock(return_value=False)):\n with patch.object(thing, '_SearchTweets__twitter_users',\n new_callable=PropertyMock(return_value=[])):\n with patch.object(thing, '_SearchTweets__twitter_keyword',\n new_callable=PropertyMock(return_value=\"Eurovision\")):\n with patch.object(thing, '_SearchTweets__save'):\n\n mock_method.side_effect = [response1, response2]\n thing.search()\n\n self.assertEqual(mock_method.call_count, 2)","def test_get(self, publish_mock: mock.Mock) -> None:\n\n def side_effect(*args: str, **_: str) -> Any:\n if args[0] == \"registry:search:dict\":\n return [{\"host1\": \"mac1\", \"host2\": \"mac2\"}]\n\n if args[0] == \"app_url\":\n return [\"/registry\"]\n\n if args[0] == \"jinja:render\":\n return [\"\"]\n\n return mock.DEFAULT\n\n publish_mock.side_effect = side_effect\n\n self.request(\"/\")\n\n self.assertEqual(\n helpers.template_var(publish_mock, \"registry_url\"),\n \"/registry\"\n )\n self.assertEqual(\n helpers.template_var(publish_mock, \"hosts\").get(\"host1\"),\n \"mac1\"\n )\n\n self.assertNotIn(\n \"host3\",\n helpers.template_var(publish_mock, \"hosts\")\n )\n\n self.assertFalse(\n helpers.template_var(publish_mock, \"send\")\n )","def test_wrong_token(self):\n wrong_token = \"1\"*64\n expected_result = \"You have to give your token\"\n resp = SearchTest.client.get('/api/search/',{\"token\":wrong_token,\"search_string\":\"Umut\"})\n self.assertEqual(json.loads(resp.content),expected_result,\"Token Control is not True\")","def test_parse_search_result(self):\n datafile = pathlib.Path(__file__).parent.joinpath(\"../data/ol_search.json\")\n search_data = json.loads(datafile.read_bytes())\n result = list(self.connector.parse_search_data(search_data, 0))[0]\n\n self.assertIsInstance(result, SearchResult)\n self.assertEqual(result.title, \"This Is How You Lose the Time War\")\n self.assertEqual(result.key, \"https://openlibrary.org/works/OL20639540W\")\n self.assertEqual(result.author, \"Amal El-Mohtar, Max Gladstone\")\n self.assertEqual(result.year, 2019)\n self.assertEqual(result.connector, self.connector)","def test_GET_Search(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n res = self.client().post('/expenses/', headers=dict(Authorization=\"Bearer \" + access_token), data=self.expense)\n self.assertEqual(res.status_code, 201)\n res = self.client().get('/expenses/?name=snacks', headers=dict(Authorization=\"Bearer \" + access_token))\n self.assertEqual(res.status_code, 200)\n results = json.loads(res.data)\n self.assertEqual(results['items'][0]['name'], self.expense['name'])","def test_get_request_normal_response(self, mock_get):\n\n # Arrange\n # Construct our mock response object, giving it relevant expected behaviours\n mock_resp_instance = MockResponse({\"msg\": \"success\"}, 200, content=\"abc\")\n mock_get.return_value = mock_resp_instance\n\n # Act\n response = get_request_data(self.url, json_resp=False)\n\n # Assert that the request-response cycle completed successfully.\n self.assertEqual(mock_resp_instance.status_code, 200)\n self.assertEqual(response, mock_resp_instance)","def test_no_input(self):\n resp = SearchTest.client.get('/api/search/')\n self.assertEqual(json.loads(resp.content),\"You give your input in wrong format. Please check the API documentation for the appropriate input format!!\",\"No Input Test Error\")","def matchResult(self, method, path):\n pass","def test_search(self):\n req = http.make_request('http://xxx', 'GET', None, None)\n self.assertIsNone(req.data)\n\n req = http.make_request('http://xxx', 'GET', 'ignored', None)\n self.assertIsNone(req.data)\n\n req = http.make_request('http://xxx', 'DELETE', None, None)\n self.assertIsNone(req.data)\n\n req = http.make_request('http://xxx', 'DELETE', 'ignored', None)\n self.assertIsNone(req.data)\n\n req = http.make_request('http://xxx', 'POST', '', None)\n self.assertEqual(0, len(req.data))\n\n req = http.make_request('http://xxx', 'POST', 'abc', None)\n self.assertEqual(3, len(req.data))\n\n req = http.make_request('http://xxx', 'POST', '', [('xxx', 'yyy'),\n ('foo',)])\n\n self.assertEqual('yyy', req.get_header('Xxx'))\n self.assertEqual('1', req.get_header('Foo'))","def test_query_cached(self):\n CreateMatch()\n\n data = {\n \"term1\": \"TESTURL1\",\n \"term2\": \"TESTURL2\"\n }\n response = self.app.post(\n \"/degree\", data=data, follow_redirects=True\n )\n self.assertEqual(response.status_code, 200)\n\n res_txt = response.get_data(as_text=True)\n\n self.assertIn(\"33 degrees\", res_txt)\n self.assertIn(\"YAAAAY!\", res_txt)","def test_service_item_search(self):\n\n flag = \"user\"\n api = \"service.item.editsn\"\n #current_page = 1\n search_info = json.dumps({\n })\n sn_pre = '730300010036664'#'730300010034444'\n sn_after = '730300010036665'#'730300010033333'\n result = self.access_api(flag = flag, api = api, sn_pre=sn_pre, sn_after=sn_after)\n #self.assertTrue('data_list' in result)\n #print(result[\"data_list\"])","def test_get(self, mock_logging):\r\n twitter = client.HashtagClient(mock_logger)\r\n twitter.client.search.tweets = MagicMock()\r\n with pytest.raises(TwitterHTTPError) as e:\r\n twitter.get(\"abc\", 3)\r\n\r\n mock_logging.assert_called_with(\"Searching Hashtag = #abc\")\r\n assert twitter.client.search.tweets.called","def test_view_response(self, mock_mailgun_client, mock_prepare_exec_search):\n email_results = ['a@example.com', 'b@example.com']\n mock_prepare_exec_search.return_value = email_results\n mock_mailgun_client.send_batch.return_value = [\n Mock(spec=Response, status_code=HTTP_200_OK, json=mocked_json()),\n Mock(spec=Response, status_code=HTTP_400_BAD_REQUEST, json=mocked_json()),\n ]\n resp_post = self.client.post(self.mail_url, data=self.request_data, format='json')\n assert resp_post.status_code == HTTP_200_OK\n assert len(resp_post.data.keys()) == 2\n for num in range(2):\n batch = 'batch_{0}'.format(num)\n assert batch in resp_post.data\n assert 'status_code' in resp_post.data[batch]\n assert 'data' in resp_post.data[batch]\n assert resp_post.data['batch_0']['status_code'] == HTTP_200_OK\n assert resp_post.data['batch_1']['status_code'] == HTTP_400_BAD_REQUEST","def test_get(self):\n response = AjaxTemporaryCode.as_view()(self.request)\n p = re.compile(\"^qaa-x-[a-f0-9]{6}$\")\n self.assertIsNotNone(p.match(response.content))","def test_get_School_search(self):\n school_ids = self.create_School(2,200)\n url = '/students'\n data = {'first_name': 'Poompatai', 'last_name': 'Puntitpong','age': 20, 'nationality': 'Thailand', 'school': school_ids[0]}\n response = self.client.post(url, data, format='json')\n data = {'first_name': 'Robert', 'last_name': 'Puntitpong','age': 25, 'nationality': 'Cambodia', 'school': school_ids[0]}\n response = self.client.post(url, data, format='json')\n data = {'first_name': 'Alan', 'last_name': 'Manny','age': 20, 'nationality': 'Cambodia', 'school': school_ids[1]}\n response = self.client.post(url, data, format='json')\n\n \"\"\"by school\"\"\"\n response = self.client.get(url + '?search=triam', format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data['count'], 3)\n\n \"\"\"by school\"\"\"\n response = self.client.get(url + '?search=udom', format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data['count'], 3)\n\n \"\"\"Nationality\"\"\"\n response = self.client.get(url + '?search=odia', format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data['count'], 2)\n\n \"\"\"last_name\"\"\"\n response = self.client.get(url + '?search=titpong', format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data['count'], 2)\n\n \"\"\"first_name and nationality\"\"\"\n response = self.client.get(url + '?search=lan', format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data['count'], 2)","def test_api_search_query(api_client, query):\n response = api_client.get(path='/breweries/search', params={'query': query})\n assert query in response.text","def test_valid_search_query_and_category_return_results(self):\n article = ArticleFactory()\n article.publish()\n request = RequestFactory().get(\"\", {\"q\": article.title[:10]})\n response = Search.as_view()(request, category=\"articles\")\n self.assertIn(\"results\", response.context_data)\n results = response.context_data[\"results\"]\n self.assertEqual(len(results), 1)\n self.assertIn(article, results)","def test_search_history(monkeypatch, records):\n found = [records[1], records[2], records[7]]\n instrument_mock = mock.MagicMock()\n instrument_mock.scan.return_value = found\n monkeypatch.setattr(\"app.search.InstrumentModel\", instrument_mock)\n\n response = search.history({\"body\": ujson.dumps({\"term\": \"Test Name\"})}, {})\n instrument_mock.history.contains.assert_called_with(\"Test Name\")\n\n assert response[\"statusCode\"] == 200\n assert _result_id_set(response[\"body\"]) == _result_id_set(found)","def test_search_title_and_content(self):\r\n response = self.client.post(reverse('questions:search'),\r\n {'search': 'find this'})\r\n self.assertEqual(response.status_code, 200)\r\n results = response.context['question_list']\r\n self.assertEqual(results.count(), 2)","def test_find_categories(self):\n testdoc = \"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<ItemListDocument xmlns=\"http://xml.vidispine.com/schema/vidispine\">\n <hits>1691985</hits>\n <facet>\n <field>gnm_asset_category</field>\n <count fieldValue=\"Rushes\">1165113</count>\n <count fieldValue=\"Completed Project\">169266</count>\n <count fieldValue=\"HoldingImage\">41071</count>\n </facet>\n</ItemListDocument>\"\"\"\n\n with patch('requests.put', return_value=self.MockResponse(200, testdoc)):\n from portal.plugins.gnmplutostats.categoryscanner import find_categories\n result = find_categories()\n self.assertEqual(result, ['Rushes','Completed Project', 'HoldingImage'])","def test_process_response(self):\n t = self.create_request_object()\n response_content = u\"\"\"<ODM FileType=\"Snapshot\" FileOID=\"\" CreationDateTime=\"\" ODMVersion=\"1.3\"\nxmlns:mdsol=\"http://www.mdsol.com/ns/odm/metadata\" xmlns=\"http://www.cdisc.org/ns/odm/v1.3\">\n <Study OID=\"Lab Test\">\n <GlobalVariables>\n <StudyName>Lab Test</StudyName>\n <StudyDescription />\n <ProtocolName>Lab Test</ProtocolName>\n </GlobalVariables>\n </Study>\n <Study OID=\"Mediflex\">\n <GlobalVariables>\n <StudyName>Mediflex</StudyName>\n <StudyDescription />\n <ProtocolName>Mediflex</ProtocolName>\n </GlobalVariables>\n </Study>\n</ODM>\"\"\"\n req = mock.Mock(requests.Request, text=response_content)\n response = t.result(req)\n self.assertTrue(isinstance(response, RWSStudies))\n for study in response:\n self.assertTrue(study.oid in ['Lab Test', 'Mediflex'])","def test_GET_task_search(self):\n\t\tdata = self.GET_data('/api/task/search')\n\t\tself.assertEqual(0, len(data))\n\t\ttask_id = self.POST_task(TEST_TASK_DATA)\n\t\tdata = self.GET_data('/api/task/search')\n\t\tself.assertEqual(1, len(data))\n\t\tself.assertEqual(task_id, data[0]['_id'])\n\t\tself.assertDataMatch(TEST_TASK_DATA, data[0], keys=[k for k in TEST_TASK_DATA.keys()])","def test_search_test_search_returns_correct_menu(self):\n # create some db records\n dataset = self.create_mixed_test_data()\n test_search_string = 'bravo'\n\n with patch('builtins.input', side_effect=test_search_string):\n result = self.menu.search_text_search()\n\n expected_result = self.menu.present_next_result\n\n self.assertEqual(expected_result, result)","def test_response_200_on_get(self):\n pass","def test_all_matches(self):\n match = Match.select()[:]\n with self.client:\n response = self.client.get(f'/all-matches')\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 200)\n self.assertEqual(len(data['data']), len(match))","def test_process_response(self):\n t = self.create_request_object()\n response_content = u\"\"\" <Response ReferenceNumber=\"82e942b0-48e8-4cf4-b299-51e2b6a89a1b\"\n InboundODMFileOID=\"\"\n IsTransactionSuccessful=\"1\"\n SuccessStatistics=\"Rave objects touched: Subjects=0; Folders=0; Forms=0; Fields=0; LogLines=0\" NewRecords=\"\">\n </Response>\n \"\"\"\n req = mock.Mock(requests.Request, text=response_content)\n response = t.result(req)\n self.assertTrue(isinstance(response, RWSResponse))","def test_other_search(url):\n test_clear(url)\n admin_tk = channel_user_create_0(url)[0]\n guest1_tk, guest1_id = channel_user_create_1(url)\n\n test_channels = {\n 'token': admin_tk,\n 'name': 'channel_1',\n 'is_public': True\n }\n requests.post(url + \"channels/create\", json=test_channels)\n \n test_channels = {\n 'token': admin_tk,\n 'name': 'channel_2',\n 'is_public': True\n }\n requests.post(url + \"channels/create\", json=test_channels)\n\n requests.post(url + \"channel/invite\", json={\n 'token': admin_tk,\n 'channel_id': 1,\n 'u_id': guest1_id,\n })\n\n requests.post(url + \"channel/invite\", json={\n 'token': admin_tk,\n 'channel_id': 2,\n 'u_id': guest1_id,\n })\n\n test_admin_message_1 = {\n 'token': admin_tk,\n 'channel_id': 1,\n 'message': 'Hello'\n }\n resp = requests.post(url + \"message/send\", json=test_admin_message_1)\n message_send_resp = resp.json()\n assert message_send_resp['message_id'] == 1\n\n test_guest_message_1 = {\n 'token': guest1_tk,\n 'channel_id': 1,\n 'message': 'A Hello'\n }\n resp = requests.post(url + \"message/send\", json=test_guest_message_1)\n message_send_resp = resp.json()\n assert message_send_resp['message_id'] == 2\n\n test_message_2 = {\n 'token': admin_tk,\n 'channel_id': 2,\n 'message': 'AA Hello'\n }\n resp = requests.post(url + \"message/send\", json=test_message_2)\n message_send_resp = resp.json()\n assert message_send_resp['message_id'] == 3\n\n test_search = {\n 'token': admin_tk,\n 'query_str': 'A'\n }\n resp = requests.get(url + \"search\", params=test_search)\n search_resp = resp.json()\n assert len(search_resp['messages']) == 2\n search_result = [messages['message'] for messages in search_resp['messages']]\n assert search_result == ['A Hello', 'AA Hello']\n\n test_search = {\n 'token': admin_tk,\n 'query_str': 'a'\n }\n resp = requests.get(url + \"search\", params=test_search)\n search_resp = resp.json()\n assert len(search_resp['messages']) == 0\n search_result = [messages['message'] for messages in search_resp['messages']]\n assert search_result == []","def test_validate_search():\n payload = {\"search_input\": \"The input\", \"search_object_types\": []}\n result = validate_search_payload(payload)\n assert result == {}","def test_brands_reply(self):\n # 1. Setup service channel / dispatch channel\n # 2. send a post to brand\n # 3. Reply with custom response\n # 4. Route a reply\n # 5. check there is no extra responses created\n # 6. create a matchable and repeat 1-5\n brand = 'brand'\n channel, dispatch_channel = self.setup_channels(brand)\n user = self._create_db_user(email='su@test.test', password='test', is_superuser=True)\n user.account = self.account\n user.save()\n profiles = set()\n\n def do_test(matchable):\n profile = gen_profile()\n user_name = profile['user_name']\n profiles.add(user_name)\n post = self._create_db_post(\n '@%s I need some carrot' % brand,\n channel=channel,\n user_profile=profile)\n\n response = Response.objects.get(id=id_from_post_id(post.id))\n self.assertIsInstance(response.matchable, matchable.__class__)\n assert response.matchable == matchable\n\n # post custom response\n creative = \"U could find some carrot there\"\n self.login(user.email, 'test')\n data = dict(creative=creative,\n response=str(response.id),\n latest_post=str(response.post.id))\n resp = self.client.post('/commands/custom_response', data=json.dumps(data))\n resp = json.loads(resp.data)\n\n # check responses and conversations\n self.assertEqual(Response.objects(conversation_id=None).count(), 0)\n self.assertEqual(\n Response.objects(channel__in=[channel, channel.inbound_channel, channel.outbound_channel]).count(),\n 0)\n self.assertEqual(Response.objects(conversation_id=response.conversation.id).count(), 1)\n self.assertEqual(Response.objects(channel__in=[dispatch_channel]).count(), len(profiles))\n\n matchable = EmptyMatchable.get()\n do_test(matchable)\n\n matchable = self._create_db_matchable('Here is your carrot',\n intention_topics=['carrot'],\n channels=[channel.inbound_channel])\n do_test(matchable)","def test_match_response(match_response, client):\n file = glob.glob('./**/test_areas.csv', recursive=True)\n with open(file[0], 'r') as fp:\n ds = client.create_dataset(fp)\n resp = ds.match(source_prov_col='Province')\n assert resp.keys() == match_response.keys()","def test_analysis_match(self):\n self.api.observable_add('test.com')\n results = self.api.analysis_match(['test.com', 'unknown.com'])\n known = [o['value'] for o in results['known']]\n self.assertIn('test.com', known)\n self.assertIn('unknown.com', results['unknown'])","def test_google_return(monkeypatch):\n ADD = \"7 Cité Paradis, 75010 Paris, France\"\n LAT = 48.8748465\n LNG = 2.3504873\n NAME = \"openclassrooms\"\n RESULTS = {\n \"candidates\": [\n {\n \"formatted_address\": ADD,\n \"geometry\": {\n \"location\": {\n \"lat\": LAT,\n \"lng\": LNG\n },\n\n },\n \"name\": NAME\n\n }\n ]\n\n }\n\n class MockGet:\n def __init__(self,*args, **kwargs):\n pass\n\n def json(self):\n return RESULTS\n\n monkeypatch.setattr('requests.get', MockGet)\n script = GoogleMapApi()\n response = script.search_about_query(query='openclassrooms', g_key=1).json()\n assert response['candidates'][0]['formatted_address'] == ADD","def test_search_client_by_title(self, mock_get):\n\n response = isbn_utils.search_by(self.filter_title, self.title)\n self.assertEqual(response.data, json.loads(open(UNIT_TEST_RESOURCES_FOLDER +\n FILE_NAME_TITLE_SEARCH_RESPONSE).read())[\"data\"])","def test_maps_response(self):\n response_content = u\"\"\" <ODM FileType=\"Snapshot\"\n FileOID=\"770f1758-db33-4ab2-af72-38db863734aa\"\n CreationDateTime=\"2013-04-08T14:08:06.875-00:00\"\n ODMVersion=\"1.3\">\n\n <ClinicalData StudyOID=\"Fixitol(Dev)\" MetaDataVersionOID=\"1111\">\n <SubjectData SubjectKey=\"000001\">\n <SiteRef LocationOID=\"BP001\"/>\n </SubjectData>\n </ClinicalData>\n\n <ClinicalData StudyOID=\"Fixitol(Dev)\" MetaDataVersionOID=\"1111\">\n <SubjectData SubjectKey=\"1111\">\n <SiteRef LocationOID=\"335566\"/>\n </SubjectData>\n </ClinicalData>\n </ODM>\n\"\"\"\n request = StudySubjectsRequest(\"Fixitol\",\n \"Dev\")\n req = mock.Mock(requests.Request, text=response_content)\n response = request.result(req)\n self.assertTrue(isinstance(response, RWSSubjects))\n for subject in response:\n self.assertTrue(isinstance(subject, RWSSubjectListItem))\n self.assertTrue(subject.subject_name in ['000001', \"1111\"])","def test_restlike_search(self):\r\n # first let's add a bookmark we can search on\r\n self._get_good_request()\r\n\r\n search_res = self.testapp.get(\r\n '/api/v1/admin/bmarks/search/search?search_content=True')\r\n\r\n self.assertTrue(\r\n search_res.status == '200 OK',\r\n \"Status is 200: \" + search_res.status)\r\n self.assertTrue(\r\n 'python' in search_res.body,\r\n \"We should find the python tag in the results: \" + search_res.body)","def test_search_page_item_not_in_database(self, mock_api, mock_search):\n mock_search.side_effect = [LookupError, {\"result\": \"result\",\n \"products\": \"products\"}]\n response = self.client.post(\"/search/\", {\"query\": \"test\"})\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, \"search/base.html\")\n self.assertTemplateUsed(response, \"search/search_form.html\")\n self.assertTemplateUsed(response, \"search/results_page.html\")\n self.assertTemplateUsed(response, \"search/result.html\")\n self.assertEqual(response.context[\"result\"], \"result\")\n self.assertEqual(response.context[\"products\"], \"products\")","def generic_test(self):\n api_params[params_to_api[\"org_id\"]] = str(self.org_id)\n valid_response = [\n entry for entry in self.valid_response\n if all(\n str(entry[k]).lower().find(str(api_params[k]).lower()) != -1\n for k in api_params\n )\n ]\n # Setup the mocked response\n responses.add(\n responses.GET, self.api_url, json=valid_response, status=200, match_querystring=False\n )\n acme = ACMEAccount(client=self.client)\n data = list(acme.find(self.org_id, **params))\n\n # Verify all the query information\n # There should only be one call when \"find\" is called.\n # Due to pagination, this is only guaranteed as long as the number of\n # entries returned is less than the page size\n self.assertEqual(len(responses.calls), 1)\n self.match_url_with_qs(responses.calls[0].request.url, api_params)\n self.assertEqual(data, valid_response)","def test_filter_on_subtype(authenticated_client):\n observable_json = {'value': r'asd[0-4]\\.com'}\n rv = authenticated_client.post('/api/observables/filter/',\n data=json.dumps(observable_json),\n content_type='application/json')\n response = json.loads(rv.data)\n for item in response:\n assert re.match(r'asd[0-4]\\.com', item['value'])\n assert item['type'] == 'domain-name'","def test_get_foods_search(self):\n pass","def mocked_requests_get():\n\n class MockResponse:\n def __init__(self, _content, _status):\n self.content = _content\n self.status_code = _status\n\n def content(self):\n return self.content\n\n return MockResponse","def test_foodtrucks_searchByLocation(self):\n\t\tprint 'API Test: retrieving foodtrucks nearby'\n\t\turl = reverse('foodtruck_list')\n\t\tdata = [{'objectid': 0, 'latitude':37.7841781516735 , 'longitude':-122.394064145441 },\\\n\t\t\t\t{'objectid': 1, 'latitude':37.7862060821039 , 'longitude':-122.402532491346 }, \t#ft2 is closest to ft0\\\n\t\t\t\t{'objectid': 2, 'latitude':37.7800057026855 , 'longitude':-122.390270961311 },\t#ft1 is further to ft0\\\n\t\t\t\t{'objectid': 3, 'latitude':32 , 'longitude': -100}]\t\t\t\t\t\t\t\t#ft3 is far far away\n\t\tfor d in data:\n\t\t\tresponse = self.client.post(url, d, format='json')\n\t\t\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\n\t\t\n\t\tlat = data[0]['latitude'] #given latitude\n\t\tlon = data[0]['longitude']\t#given longitude\n\t\trad = 3 \t\t\t\t\t#given radius of search\n\t\tlim = 2 \t\t\t\t\t#given limit of results\n\t\t\"\"\" test both urls: w/ or w/out limit \"\"\"\n\t\tresponse = self.client.get('/foodtrucks/bylocation?latitude=%f&longitude=%f&radius=%f' % (lat, lon, rad), format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(len(response.data), 3)\n\t\tself.assertEqual(response.data[0]['objectid'], 0)\n\t\tself.assertEqual(response.data[1]['objectid'], 2)\t\t\n\t\tself.assertEqual(response.data[2]['objectid'], 1)\t\t\n\n\t\tresponse = self.client.get('/foodtrucks/bylocation?latitude=%f&longitude=%f' % (lat, lon), format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(len(response.data), 3)\n\n\t\tresponse = self.client.get('/foodtrucks/bylocation?latitude=%f&longitude=%f&radius=%f&limit=%d' % (lat, lon, rad, lim), format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(len(response.data), 2)\n\n\t\t\"\"\" test the radius: shrink the radius such that only ft0 will be found \"\"\"\n\t\trad = 0.01\n\t\tresponse = self.client.get('/foodtrucks/bylocation?latitude=%f&longitude=%f&radius=%f' % (lat, lon, rad), format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(len(response.data), 1)\n\t\tprint 'pass'","def test_post_foods_search(self):\n pass"],"string":"[\n \"def mock_reddit_search_response(\\n ) -> Dict:\\n with open(\\n \\\"util/reddit_search_response.json\\\"\\n ) as static_response:\\n mock_response = json.load(static_response)\\n\\n return(mock_response)\",\n \"def test_search(self):\\n d = self._search()\\n self._response([2, 5, 10])\\n self.assertEqual(self.successResultOf(d), [2, 5, 10])\",\n \"def test_search_content(self):\\n tester = app.test_client(self)\\n response = tester.post('/search')\\n self.assertEqual(response.content_type,'application/json')\",\n \"def test_search_content(self, mock_search):\\r\\n mock_search().search.side_effect = self._return_attr\\r\\n self.testapp.get('/results/bookie')\\r\\n\\r\\n self.assertTrue(mock_search.called)\\r\\n self.assertEqual(self.attr[0][0],\\r\\n 'bookie',\\r\\n 'search term should be bookie')\\r\\n self.assertTrue(self.attr[1]['content'])\",\n \"def test_products_get_pattern_no_match(data, mocker):\\n mocker.patch(\\\"sps.request.fetch\\\", autospec=True)\\n request.fetch.return_value = data\\n assert products.get(\\\"foo-bar-search\\\", \\\"fake-file-name\\\", False, False) == []\",\n \"def test_api_response_data(self):\",\n \"def test_response(self):\\n\\n from rubber import settings, resource\\n settings.RUBBER_MOCK_HTTP_RESPONSE = \\\"\\\"\\\"{\\\"took\\\":2,\\\"timed_out\\\":false,\\\"_shards\\\":{\\\"total\\\":5,\\\"successful\\\":5,\\\"failed\\\":0},\\\"hits\\\":{\\\"total\\\":2,\\\"max_score\\\":1.0,\\\"hits\\\":[{\\\"_index\\\":\\\"auth\\\",\\\"_type\\\":\\\"user\\\",\\\"_id\\\":\\\"6\\\",\\\"_score\\\":1.0, \\\"_source\\\" : {\\\"username\\\": \\\"guillaume\\\", \\\"first_name\\\": \\\"\\\", \\\"last_name\\\": \\\"\\\", \\\"is_active\\\": true, \\\"is_superuser\\\": false, \\\"is_staff\\\": false, \\\"last_login\\\": \\\"2012-08-02T08:30:11\\\", \\\"groups\\\": [], \\\"user_permissions\\\": [], \\\"password\\\": \\\"pbkdf2_sha256$10000$M1nRKJfbvdQf$ouX5u9FOUF/MKhhwuwYbiuoVidFITsBrEstGBB4mzZA=\\\", \\\"email\\\": \\\"somemail@test.com\\\", \\\"date_joined\\\": \\\"2012-08-02T08:30:11\\\"}},{\\\"_index\\\":\\\"auth\\\",\\\"_type\\\":\\\"user\\\",\\\"_id\\\":\\\"8\\\",\\\"_score\\\":1.0, \\\"_source\\\" : {\\\"username\\\": \\\"stephane\\\", \\\"first_name\\\": \\\"\\\", \\\"last_name\\\": \\\"\\\", \\\"is_active\\\": true, \\\"is_superuser\\\": false, \\\"is_staff\\\": false, \\\"last_login\\\": \\\"2012-08-02T09:14:38\\\", \\\"groups\\\": [], \\\"user_permissions\\\": [], \\\"password\\\": \\\"pbkdf2_sha256$10000$ORDHZAnNqTwF$UGmkUCyH0/uh1ruP93ZSTyog9Wi5g2qc+m/fxowigFs=\\\", \\\"email\\\": \\\"othermail@test.com\\\", \\\"date_joined\\\": \\\"2012-08-02T09:14:38\\\"}}]}}\\\"\\\"\\\"\\n\\n requestmock = RequestMock()\\n resource.requests = requestmock\\n\\n response = self.Article.elasticsearch.search({})\\n \\n self.assertEquals(2, response.json['took'])\\n\\n from rubber.response import Response\\n self.assertTrue(isinstance(response, Response))\",\n \"def test_search_question(self): \\n data = {'searchTerm':'title'}\\n res = self.client().post('/search', \\n data=json.dumps(data),\\n content_type='application/json')\\n self.data = json.loads(res.data)\\n self.assertEqual(res.status_code, 200)\\n json_res = json.loads(res.get_data(as_text=True))\",\n \"def test_search(self):\\n pass\",\n \"def test_search(self):\\n pass\",\n \"def test_search(self):\\n pass\",\n \"def test_search(self):\\n tester = app.test_client(self)\\n response = tester.post('/search')\\n self.assertEqual(response.status_code,200)\",\n \"def test_process_searchbox_with_mock(self):\\n\\n result = self.client.get('/process_searchbox', data={'zipcode': '94043', 'cuisine': 'indian'})\\n self.assertIn(b\\\"Dosa Paratha\\\", result.data)\",\n \"def __init__(self, pattern, response_dict):\\r\\n self._pattern = pattern\\r\\n self._response_dict = response_dict\",\n \"def test_search_view(client):\\n\\n with patch('search.helpers.search_with_activitystream') as search:\\n mock_results = json.dumps(\\n {\\n 'took': 17,\\n 'timed_out': False,\\n '_shards': {'total': 4, 'successful': 4, 'skipped': 0, 'failed': 0},\\n 'hits': {\\n 'total': {\\n 'value': 5,\\n 'relation': 'eq',\\n # This is an ActivityStream-V2-style/ES7-style 'total' field -\\n # AS-V1/ES6 returned an int not a dict\\n },\\n 'max_score': 0.2876821,\\n 'hits': [\\n {\\n '_index': 'objects__feed_id_first_feed__date_2019',\\n '_type': '_doc',\\n '_id': 'dit:exportOpportunities:Opportunity:2',\\n '_score': 0.2876821,\\n '_source': {\\n 'type': ['Document', 'dit:Opportunity'],\\n 'title': 'France - Data analysis services',\\n 'content': 'The purpose of this contract is to analyze...',\\n 'url': 'www.great.gov.uk/opportunities/1',\\n },\\n },\\n {\\n '_index': 'objects__feed_id_first_feed__date_2019',\\n '_type': '_doc',\\n '_id': 'dit:exportOpportunities:Opportunity:2',\\n '_score': 0.18232156,\\n '_source': {\\n 'type': ['Document', 'dit:Opportunity'],\\n 'title': 'Germany - snow clearing',\\n 'content': 'Winter services for the properties1) Former...',\\n 'url': 'www.great.gov.uk/opportunities/2',\\n },\\n },\\n ],\\n },\\n }\\n )\\n search.return_value = Mock(status_code=200, content=mock_results)\\n\\n response = client.get(reverse('search:search'), data={'q': 'services'})\\n context = response.context_data\\n\\n assert response.status_code == 200\\n assert context['results'] == [\\n {\\n 'type': 'Export opportunity',\\n 'title': 'France - Data analysis services',\\n 'content': 'The purpose of this contract is to analyze...',\\n 'url': 'www.great.gov.uk/opportunities/1',\\n },\\n {\\n 'type': 'Export opportunity',\\n 'title': 'Germany - snow clearing',\\n 'content': 'Winter services for the properties1) Former...',\\n 'url': 'www.great.gov.uk/opportunities/2',\\n },\\n ]\\n\\n \\\"\\\"\\\" What if there are no results? \\\"\\\"\\\"\\n search.return_value = Mock(\\n status_code=200,\\n content=json.dumps(\\n {\\n 'took': 17,\\n 'timed_out': False,\\n '_shards': {'total': 4, 'successful': 4, 'skipped': 0, 'failed': 0},\\n 'hits': {\\n 'total': {\\n 'value': 0,\\n 'relation': 'eq',\\n },\\n 'hits': [],\\n },\\n }\\n ),\\n )\\n\\n response = client.get(reverse('search:search'), data={'q': 'services'})\\n context = response.context_data\\n\\n assert response.status_code == 200\\n assert context['results'] == []\\n\\n \\\"\\\"\\\" What if ActivitySteam sends an error? \\\"\\\"\\\"\\n search.return_value = Mock(status_code=500, content='[service overloaded]')\\n\\n response = client.get(reverse('search:search'), data={'q': 'services'})\\n context = response.context_data\\n\\n assert response.status_code == 200\\n # This can be handled on the front end as we wish\\n assert context['error_message'] == '[service overloaded]'\\n assert context['error_status_code'] == 500\\n\\n \\\"\\\"\\\" What if ActivitySteam is down? \\\"\\\"\\\"\\n search.side_effect = requests.exceptions.ConnectionError\\n\\n response = client.get(reverse('search:search'), data={'q': 'services'})\\n context = response.context_data\\n\\n assert response.status_code == 200\\n # This can be handled on the front end as we wish\\n assert context['error_message'] == 'Activity Stream connection failed'\\n assert context['error_status_code'] == 500\",\n \"def test_no_search_string(self):\\n resp = SearchTest.client.get('/api/search/',{'token':SearchTest.valid_token})\\n self.assertEqual(json.loads(resp.content),\\\"You give your input in wrong format. Please check the API documentation for the appropriate input format!!\\\",\\\"No Search String Test Error\\\")\",\n \"def test_search_data(self):\\n tester = app.test_client(self)\\n response = tester.post('/search')\\n data = response.get_json()\\n self.assertTrue('data' in data)\",\n \"def test_search_metadata_unit(integrated_ff, url):\\n with mock.patch.object(ff_utils, \\\"authorized_request\\\", make_mocked_search()):\\n check_search_metadata(integrated_ff, url)\",\n \"def test_get_data_success(monkeypatch):\\n\\n class MockResponse(object):\\n def __init__(self):\\n self.status_code = 200\\n\\n def json(self):\\n return {\\n \\\"continue\\\": {\\\"excontinue\\\": 1, \\\"continue\\\": \\\"||info\\\"},\\n \\\"query\\\": {\\n \\\"pages\\\": {\\n \\\"151688\\\": {\\n \\\"pageid\\\": 151688,\\n \\\"ns\\\": 0,\\n \\\"title\\\": \\\"Naantali\\\",\\n \\\"index\\\": -1,\\n \\\"extract\\\": \\\"Naantali (en suédois Nådendal, en latin Vallis Gratiae - la vallée de grâce) est une ville du sud-ouest de la Finlande. Cette petite ville, qui compte une population de 19 000 habitants, se situe dans la province de Finlande occidentale et la région de Finlande du Sud-Ouest, à 15 km à l'ouest de Turku, la capitale provinciale.\\\", # noqa: E501\\n \\\"contentmodel\\\": \\\"wikitext\\\",\\n \\\"pagelanguage\\\": \\\"fr\\\",\\n \\\"pagelanguagehtmlcode\\\": \\\"fr\\\",\\n \\\"pagelanguagedir\\\": \\\"ltr\\\",\\n \\\"touched\\\": \\\"2020-10-08T00:35:54Z\\\",\\n \\\"lastrevid\\\": 169716755,\\n \\\"length\\\": 14393,\\n \\\"fullurl\\\": \\\"https://fr.wikipedia.org/wiki/Naantali\\\", # noqa: E501\\n \\\"editurl\\\": \\\"https://fr.wikipedia.org/w/index.php?title=Naantali&action=edit\\\", # noqa: E501\\n \\\"canonicalurl\\\": \\\"https://fr.wikipedia.org/wiki/Naantali\\\", # noqa: E501\\n },\\n \\\"2709037\\\": {\\n \\\"pageid\\\": 2709037,\\n \\\"ns\\\": 0,\\n \\\"title\\\": \\\"Muumimaailma\\\",\\n \\\"index\\\": 0,\\n \\\"contentmodel\\\": \\\"wikitext\\\",\\n \\\"pagelanguage\\\": \\\"fr\\\",\\n \\\"pagelanguagehtmlcode\\\": \\\"fr\\\",\\n \\\"pagelanguagedir\\\": \\\"ltr\\\",\\n \\\"touched\\\": \\\"2020-10-04T16:19:49Z\\\",\\n \\\"lastrevid\\\": 168229306,\\n \\\"length\\\": 1447,\\n \\\"fullurl\\\": \\\"https://fr.wikipedia.org/wiki/Muumimaailma\\\", # noqa: E501\\n \\\"editurl\\\": \\\"https://fr.wikipedia.org/w/index.php?title=Muumimaailma&action=edit\\\", # noqa: E501\\n \\\"canonicalurl\\\": \\\"https://fr.wikipedia.org/wiki/Muumimaailma\\\", # noqa: E501\\n },\\n \\\"5751499\\\": {\\n \\\"pageid\\\": 5751499,\\n \\\"ns\\\": 0,\\n \\\"title\\\": \\\"Kultaranta\\\",\\n \\\"index\\\": 1,\\n \\\"contentmodel\\\": \\\"wikitext\\\",\\n \\\"pagelanguage\\\": \\\"fr\\\",\\n \\\"pagelanguagehtmlcode\\\": \\\"fr\\\",\\n \\\"pagelanguagedir\\\": \\\"ltr\\\",\\n \\\"touched\\\": \\\"2020-10-08T00:43:32Z\\\",\\n \\\"lastrevid\\\": 164009230,\\n \\\"length\\\": 11889,\\n \\\"fullurl\\\": \\\"https://fr.wikipedia.org/wiki/Kultaranta\\\", # noqa: E501\\n \\\"editurl\\\": \\\"https://fr.wikipedia.org/w/index.php?title=Kultaranta&action=edit\\\", # noqa: E501\\n \\\"canonicalurl\\\": \\\"https://fr.wikipedia.org/wiki/Kultaranta\\\", # noqa: E501\\n },\\n \\\"7700543\\\": {\\n \\\"pageid\\\": 7700543,\\n \\\"ns\\\": 0,\\n \\\"title\\\": \\\"Port de Naantali\\\",\\n \\\"index\\\": 2,\\n \\\"contentmodel\\\": \\\"wikitext\\\",\\n \\\"pagelanguage\\\": \\\"fr\\\",\\n \\\"pagelanguagehtmlcode\\\": \\\"fr\\\",\\n \\\"pagelanguagedir\\\": \\\"ltr\\\",\\n \\\"touched\\\": \\\"2020-10-04T16:25:50Z\\\",\\n \\\"lastrevid\\\": 162923416,\\n \\\"length\\\": 2675,\\n \\\"fullurl\\\": \\\"https://fr.wikipedia.org/wiki/Port_de_Naantali\\\", # noqa: E501\\n \\\"editurl\\\": \\\"https://fr.wikipedia.org/w/index.php?title=Port_de_Naantali&action=edit\\\", # noqa: E501\\n \\\"canonicalurl\\\": \\\"https://fr.wikipedia.org/wiki/Port_de_Naantali\\\", # noqa: E501\\n },\\n }\\n },\\n }\\n\\n parameters = {\\n \\\"action\\\": \\\"query\\\",\\n \\\"prop\\\": \\\"extracts|info\\\",\\n \\\"inprop\\\": \\\"url\\\",\\n \\\"explaintext\\\": True,\\n \\\"exsentences\\\": 2,\\n \\\"exlimit\\\": 1,\\n \\\"generator\\\": \\\"geosearch\\\",\\n \\\"ggsradius\\\": 10000,\\n \\\"ggscoord\\\": f\\\"{00000}|{00000}\\\",\\n \\\"format\\\": \\\"json\\\",\\n }\\n\\n headers = {\\n \\\"date\\\": \\\"10/10/2020\\\",\\n \\\"user-agent\\\": '\\\"MoominPappaBot/fake_version',\\n }\\n\\n def mock_get(url, params=parameters, headers=headers, timeout=10):\\n return MockResponse()\\n\\n monkeypatch.setattr(requests, \\\"get\\\", mock_get)\\n\\n request = MediawikiApi(\\\"user_input1\\\", \\\"user_input2\\\")\\n result = request.get_data()\\n expected_result = {\\n \\\"title\\\": \\\"Naantali\\\",\\n \\\"extract\\\": \\\"Naantali (en suédois Nådendal, en latin Vallis Gratiae - la vallée de grâce) est une ville du sud-ouest de la Finlande. Cette petite ville, qui compte une population de 19 000 habitants, se situe dans la province de Finlande occidentale et la région de Finlande du Sud-Ouest, à 15 km à l'ouest de Turku, la capitale provinciale.\\\", # noqa: E501\\n \\\"fullurl\\\": \\\"https://fr.wikipedia.org/wiki/Naantali\\\",\\n }\\n assert result == expected_result\",\n \"def test_products_get_pattern_single_match(data, mocker):\\n mocker.patch(\\\"sps.request.fetch\\\", autospec=True)\\n request.fetch.return_value = data\\n assert products.get(\\\"Manager\\\", \\\"fake-file-name\\\", False, False) == [data[\\\"data\\\"][0]]\\n assert products.get(\\\"Desktop\\\", \\\"fake-file-name\\\", False, False) == [data[\\\"data\\\"][1]]\",\n \"def test_search_page_item_in_database(self, mock_search):\\n mock_search.return_value = {\\\"result\\\": \\\"result\\\", \\\"products\\\": \\\"products\\\"}\\n response = self.client.post(\\\"/search/\\\", {\\\"query\\\": \\\"test\\\"})\\n self.assertEqual(response.status_code, 200)\\n self.assertTemplateUsed(response, \\\"search/base.html\\\")\\n self.assertTemplateUsed(response, \\\"search/search_form.html\\\")\\n self.assertTemplateUsed(response, \\\"search/results_page.html\\\")\\n self.assertTemplateUsed(response, \\\"search/result.html\\\")\\n self.assertEqual(response.context[\\\"result\\\"], \\\"result\\\")\\n self.assertEqual(response.context[\\\"products\\\"], \\\"products\\\")\",\n \"def test_404_search_results_unprocesssable(self):\\n data = {'searchTerm':'wxyz'}\\n res = self.client().post('/search', \\n data=json.dumps(data),\\n content_type='application/json')\\n self.data = json.loads(res.data)\\n self.assertEqual(res.status_code, 404)\\n json_res = json.loads(res.get_data(as_text=False))\",\n \"def test_success_search_result(self):\\n search_org_api = '/api/org/?search=test'\\n auth_client = self.create_auth_client()\\n filter_result = ListOrgSerializer(Org.objects.filter(name__startswith='test'), many=True) \\n response = auth_client.get(search_org_api)\\n self.assertEqual(response.data, filter_result.data)\",\n \"def test_01_search(self):\\r\\n res = self.app.get('/search')\\r\\n err_msg = \\\"Search page should be accessible\\\"\\r\\n assert \\\"Search\\\" in res.data, err_msg\",\n \"def test_search_page_no_API_results(self, mock_api, mock_search):\\n mock_search.side_effect = [LookupError, ValueError]\\n response = self.client.post(\\\"/search/\\\", {\\\"query\\\": \\\"test\\\"})\\n self.assertEqual(response.status_code, 200)\\n self.assertTemplateUsed(response, \\\"search/base.html\\\")\\n self.assertTemplateUsed(response, \\\"search/search_form.html\\\")\\n self.assertTemplateUsed(response, \\\"search/results_page.html\\\")\\n self.assertTemplateNotUsed(response, \\\"search/result.html\\\")\\n self.assertEqual(response.context[\\\"error\\\"],\\n \\\"Votre recherche n'a donné aucun résultats\\\")\",\n \"def test_response_json(self):\\n response = self.client.search()\\n self.assertTrue(isinstance(response.json, dict))\\n\\n\\n # with invalid json\\n from rubber import settings\\n settings.RUBBER_MOCK_HTTP_RESPONSE = \\\"\\\"\\\";;;\\\"\\\"\\\"\\n \\n response = self.client.search()\\n self.assertIsNone(response.json)\",\n \"def test_search_endpoint(self, mock_request):\\n cli = REST(TestAlphaVantage._API_KEY_TEST)\\n url = \\\"https://www.alphavantage.co/query?function=SYMBOL_SEARCH&keywords=BA&datatype=json&apikey=test\\\"\\n path_file = self.get_file_from_url(\\\"symbol_search\\\")\\n with open(path_file) as f:\\n mock_request.get(url, text=f.read())\\n data = cli.search_endpoint(\\\"BA\\\")\\n self.assertIsInstance(\\n data, dict, 'Result Data must be a dict')\",\n \"def test_search(self):\\n with unittest.mock.patch('builtins.input', return_value='a'):\\n good = self.ec.search()\\n self.assertTrue(good)\\n with unittest.mock.patch('builtins.input', return_value='b'):\\n good = self.ec.search()\\n self.assertTrue(good)\\n with unittest.mock.patch('builtins.input', return_value='c'):\\n good = self.ec.search()\\n self.assertTrue(good)\\n with unittest.mock.patch('builtins.input', return_value='d'):\\n good = self.ec.search()\\n self.assertTrue(good)\\n with unittest.mock.patch('builtins.input', return_value='e'):\\n good = self.ec.search()\\n self.assertTrue(good)\\n with unittest.mock.patch('builtins.input', return_value='q'):\\n good = self.ec.search()\\n self.assertFalse(good)\",\n \"def test_hit_class(self):\\n class MyHit(object):\\n def __init__(self, d):\\n self.data = d\\n\\n self.Article.elasticsearch.hit_class = MyHit\\n\\n from rubber import settings, resource\\n settings.RUBBER_MOCK_HTTP_RESPONSE = \\\"\\\"\\\"{\\\"took\\\":2,\\\"timed_out\\\":false,\\\"_shards\\\":{\\\"total\\\":5,\\\"successful\\\":5,\\\"failed\\\":0},\\\"hits\\\":{\\\"total\\\":2,\\\"max_score\\\":1.0,\\\"hits\\\":[{\\\"_index\\\":\\\"auth\\\",\\\"_type\\\":\\\"user\\\",\\\"_id\\\":\\\"6\\\",\\\"_score\\\":1.0, \\\"_source\\\" : {\\\"username\\\": \\\"guillaume\\\", \\\"first_name\\\": \\\"\\\", \\\"last_name\\\": \\\"\\\", \\\"is_active\\\": true, \\\"is_superuser\\\": false, \\\"is_staff\\\": false, \\\"last_login\\\": \\\"2012-08-02T08:30:11\\\", \\\"groups\\\": [], \\\"user_permissions\\\": [], \\\"password\\\": \\\"pbkdf2_sha256$10000$M1nRKJfbvdQf$ouX5u9FOUF/MKhhwuwYbiuoVidFITsBrEstGBB4mzZA=\\\", \\\"email\\\": \\\"somemail@test.com\\\", \\\"date_joined\\\": \\\"2012-08-02T08:30:11\\\"}},{\\\"_index\\\":\\\"auth\\\",\\\"_type\\\":\\\"user\\\",\\\"_id\\\":\\\"8\\\",\\\"_score\\\":1.0, \\\"_source\\\" : {\\\"username\\\": \\\"stephane\\\", \\\"first_name\\\": \\\"\\\", \\\"last_name\\\": \\\"\\\", \\\"is_active\\\": true, \\\"is_superuser\\\": false, \\\"is_staff\\\": false, \\\"last_login\\\": \\\"2012-08-02T09:14:38\\\", \\\"groups\\\": [], \\\"user_permissions\\\": [], \\\"password\\\": \\\"pbkdf2_sha256$10000$ORDHZAnNqTwF$UGmkUCyH0/uh1ruP93ZSTyog9Wi5g2qc+m/fxowigFs=\\\", \\\"email\\\": \\\"othermail@test.com\\\", \\\"date_joined\\\": \\\"2012-08-02T09:14:38\\\"}}]}}\\\"\\\"\\\"\\n \\n requestmock = RequestMock()\\n resource.requests = requestmock\\n\\n response = self.Article.elasticsearch.search({})\\n\\n # This should be a SearchResponse\\n from rubber.response import SearchResponse\\n self.assertTrue(isinstance(response, SearchResponse))\\n\\n # It should have a 'results' attribute\\n self.assertTrue(hasattr(response, 'results'))\\n\\n # Hits should be MyHit objects\\n self.assertTrue(isinstance(response.results.hits[0], MyHit))\",\n \"def test_get_results(self):\\n pass\",\n \"def test_get_search_results(self, mock_get):\\n\\n search_url = self.test_data[\\\"search_url\\\"]\\n search_response = self.test_data[\\\"search_response\\\"]\\n image_page_urls = self.test_data[\\\"image_page_urls\\\"]\\n next_page_exists = self.test_data[\\\"next_page_exists\\\"]\\n \\n mock_get.return_value = self._build_mock_response(text = search_response)\\n\\n (actual_image_page_urls, actual_next_page_exists) = self.retriever._get_search_results(search_url)\\n\\n self.assertEqual(list(actual_image_page_urls), \\\\\\n image_page_urls, msg = \\\"Unable to extract image tags from the search page\\\")\\n\\n self.assertEqual(actual_next_page_exists, \\\\\\n next_page_exists, msg = \\\"Incorrect next-page-exists indicator detected\\\")\",\n \"def test_successful_search(self, mock_spotify_api_class, valid_request):\\n\\n with patch('bpm.spotify.requests.get') as mock_requests:\\n mock_requests.return_value = valid_request\\n result = mock_spotify_api_class.search(query={\\\"track\\\": \\\"mock_track_name\\\"},\\n search_type=\\\"track\\\",\\n market_type=\\\"GB\\\")\\n assert result == valid_request.json.return_value\",\n \"def test_hits_should_be_correctly_sorted_on_title(\\n self, client: Flask, docker_service, api, wait_for_information_models\\n ):\\n search_str = \\\"di\\\"\\n body = {\\\"q\\\": search_str, \\\"size\\\": 300}\\n result = client.post(informationmodel_url, json=body)\\n assert result.status_code == 200\\n result_json = result.json\\n last_was_exact_match = True\\n last_was_partial_match_in_title = False\\n for hit in result_json[\\\"hits\\\"]:\\n if has_exact_match_in_title(hit, search_str):\\n assert last_was_exact_match\\n last_was_exact_match = True\\n elif has_partial_match_in_title(hit, search_str):\\n assert last_was_exact_match or last_was_partial_match_in_title\\n last_was_exact_match = False\\n last_was_partial_match_in_title = True\\n else:\\n last_was_exact_match = False\\n last_was_partial_match_in_title = False\",\n \"def test_search_template(self):\\n self.assertTemplateUsed(self.response, 'rango/search.html', f\\\"{FAILURE_HEADER}Your search() view does not use the expected template.{FAILURE_FOOTER}\\\")\",\n \"def test_search_page_no_DB_results(self, mock_api, mock_search):\\n mock_search.side_effect = [LookupError, LookupError]\\n response = self.client.post(\\\"/search/\\\", {\\\"query\\\": \\\"test\\\"})\\n self.assertEqual(response.status_code, 200)\\n self.assertTemplateUsed(response, \\\"search/base.html\\\")\\n self.assertTemplateUsed(response, \\\"search/search_form.html\\\")\\n self.assertTemplateUsed(response, \\\"search/results_page.html\\\")\\n self.assertTemplateNotUsed(response, \\\"search/result.html\\\")\\n self.assertEqual(response.context[\\\"error\\\"],\\n \\\"Votre recherche n'a donné aucun résultats\\\")\",\n \"def test_search_page(self):\\n result = self.client.get(\\\"/search\\\")\\n self.assertIn(b\\\"Search\\\", result.data)\",\n \"def test_all_tweets(self):\\n\\n response1 = {'meta': {'result_count': 500, 'next_token': 1}}\\n response2 = {'meta': {'result_count': 500, 'next_token': 2}}\\n response3 = {'meta': {'result_count': 500, 'next_token': 3}}\\n response4 = {'meta': {'result_count': 500}}\\n\\n wk = os.path.dirname(os.path.abspath(__file__))\\n f = os.path.join(wk, \\\"search_tweets.config\\\")\\n thing = SearchTweets(self.db, f)\\n with patch.object(thing, '_SearchTweets__twitter_n_results', new_callable=PropertyMock(return_value=10)):\\n with patch.object(thing, '_SearchTweets__twitter_all_tweets', new_callable=PropertyMock(return_value=True)):\\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\\n with patch.object(thing, '_SearchTweets__multi_user',\\n new_callable=PropertyMock(return_value=False)):\\n with patch.object(thing, '_SearchTweets__twitter_users',\\n new_callable=PropertyMock(return_value=[])):\\n with patch.object(thing, '_SearchTweets__twitter_keyword',\\n new_callable=PropertyMock(return_value=\\\"Eurovision\\\")):\\n with self.assertLogs('SEARCH', level='DEBUG') as cm:\\n with patch.object(thing, '_SearchTweets__save'):\\n\\n mock_method.side_effect = [response1, response2, response3, response4]\\n thing.search()\\n\\n self.assertEqual(mock_method.call_count, 4)\\n self.assertTrue(\\\"DEBUG:SEARCH:ASKING FOR NEXT PAGE\\\" in cm.output)\\n self.assertTrue(\\\"DEBUG:SEARCH:THERE ARE NO OTHER PAGE AVAILABLE. ALL TWEETS REACHED\\\" in cm.output)\\n self.assertTrue(\\\"DEBUG:SEARCH:NO NEXT TOKEN IN RESPONSE:INTERRUPTING\\\" in cm.output)\",\n \"def test_no_next_token(self):\\n\\n response1 = {'meta': {'result_count': 500}}\\n wk = os.path.dirname(os.path.abspath(__file__))\\n f = os.path.join(wk, \\\"search_tweets.config\\\")\\n thing = SearchTweets(self.db, f)\\n with patch.object(thing, '_SearchTweets__twitter_n_results', new_callable=PropertyMock(return_value=520)):\\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\\n with patch.object(thing, '_SearchTweets__multi_user', new_callable=PropertyMock(return_value=False)):\\n with patch.object(thing, '_SearchTweets__twitter_users',\\n new_callable=PropertyMock(return_value=[])):\\n with patch.object(thing, '_SearchTweets__twitter_keyword',\\n new_callable=PropertyMock(return_value=\\\"Eurovision\\\")):\\n with self.assertLogs('SEARCH', level='DEBUG') as cm:\\n with patch.object(thing, '_SearchTweets__save'):\\n mock_method.side_effect = [response1]\\n thing.search()\\n\\n self.assertEqual(mock_method.call_count, 1)\\n self.assertTrue(\\\"DEBUG:SEARCH:THERE ARE NO OTHER PAGE AVAILABLE. ALL TWEETS REACHED\\\" in cm.output)\\n self.assertTrue(\\\"DEBUG:SEARCH:NO NEXT TOKEN IN RESPONSE:INTERRUPTING\\\" in cm.output)\",\n \"def test_all_tweets2(self):\\n\\n response1 = {'meta': {'result_count': 500, 'next_token': 1}}\\n response2 = {'meta': {'result_count': 500, 'next_token': 2}}\\n response3 = {'meta': {'result_count': 500, 'next_token': 3}}\\n response4 = {'meta': {'result_count': 500}}\\n\\n wk = os.path.dirname(os.path.abspath(__file__))\\n f = os.path.join(wk, \\\"search_tweets.config\\\")\\n thing = SearchTweets(self.db, f)\\n with patch.object(thing, '_SearchTweets__twitter_all_tweets', new_callable=PropertyMock(return_value=True)):\\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\\n with patch.object(thing, '_SearchTweets__multi_user', new_callable=PropertyMock(return_value=False)):\\n with patch.object(thing, '_SearchTweets__twitter_users',\\n new_callable=PropertyMock(return_value=[])):\\n with patch.object(thing, '_SearchTweets__twitter_keyword',\\n new_callable=PropertyMock(return_value=\\\"Eurovision\\\")):\\n with self.assertLogs('SEARCH', level='DEBUG') as cm:\\n with patch.object(thing, '_SearchTweets__save'):\\n mock_method.side_effect = [response1, response2, response3, response4]\\n thing.search()\\n\\n self.assertEqual(mock_method.call_count, 4)\\n self.assertTrue(\\\"DEBUG:SEARCH:ASKING FOR NEXT PAGE\\\" in cm.output)\\n self.assertTrue(\\\"DEBUG:SEARCH:THERE ARE NO OTHER PAGE AVAILABLE. ALL TWEETS REACHED\\\" in cm.output)\\n self.assertTrue(\\\"DEBUG:SEARCH:NO NEXT TOKEN IN RESPONSE:INTERRUPTING\\\" in cm.output)\",\n \"def test_search(client, example_records, h, prefix):\\n res = client.get(prefix, headers=h)\\n assert res.status_code == 200\\n assert res.json[\\\"hits\\\"][\\\"total\\\"] == 2\\n assert res.json['sortBy'] == 'title'\",\n \"def test_load_search(self, mock_get):\\n\\n c = Client()\\n data = {\\n 'search_type': self.filter_title,\\n 'search_value': self.title\\n }\\n response = c.post('/taric_books/search/', data=data)\\n\\n self.assertEqual(response.status_code, 200)\",\n \"def _mock_requests_get(text):\\n return lambda *args, **kwargs: PrometheusClientTest.FakeResponse(\\n args[0], text, 200,\\n )\",\n \"def test_search_samples(self):\\n self.login()\\n\\n page_size = 20\\n query = 'batch8'\\n\\n # hit the API endpoint\\n data = {'q': query,\\n 'page': 1,\\n 'page_size': page_size}\\n response = self.client.get(reverse('searchsamples'), data, format='json')\\n\\n expected = Sample.objects.filter(batch__icontains=query).order_by(\\\"-received\\\")\\n\\n # format queryset into json for returning\\n serializer = SampleSerializer(expected, many=True)\\n\\n context = {\\n 'data': serializer.data,\\n 'more': False\\n }\\n\\n self.assertEqual(response.json(), context)\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def test_full_text_search_results(self):\\n with mock.patch('full_text_search.search') as full_text_search_mock:\\n full_text_search_mock.return_value = (\\n SearcherTests.FULLTEXT_RETURN_VALUE)\\n searcher = Searcher(\\n SearcherTests.REPO_NAME,\\n enable_fulltext_search=True,\\n max_results=SearcherTests.MAX_RESULTS)\\n assert (\\n searcher.search('matt') == SearcherTests.FULLTEXT_RETURN_VALUE)\\n assert len(full_text_search_mock.call_args_list) == 1\\n call_args, _ = full_text_search_mock.call_args_list[0]\\n assert call_args[0] == SearcherTests.REPO_NAME\\n assert call_args[1] == {'name': 'matt'}\\n assert call_args[2] == SearcherTests.MAX_RESULTS\",\n \"def test_search(self):\\n from rubber import resource\\n requestmock = RequestMock()\\n resource.requests = requestmock\\n\\n q = {'query': {'term': {'user': 'kimchy'}}}\\n self.Article.elasticsearch.search(q, toto='titi')\\n\\n self.assertEquals(1, len(requestmock.stack))\\n self.assertEquals('http://example.com:9200/tests/article/_search', requestmock.stack[0]['url'])\\n self.assertEquals('GET', requestmock.stack[0]['method'])\\n self.assertEquals('titi', requestmock.stack[0]['kwargs']['toto'])\\n from rubber.instanceutils import data_to_json\\n self.assertEquals(data_to_json(q), requestmock.stack[0]['kwargs']['data'])\\n\\n self.Article.elasticsearch.mapping.put({'some': 'mapping'}, toto='titi')\\n\\n self.assertEquals(2, len(requestmock.stack))\\n self.assertEquals('http://example.com:9200/tests/article/_mapping', requestmock.stack[1]['url'])\\n self.assertEquals('PUT', requestmock.stack[1]['method'])\\n self.assertEquals('titi', requestmock.stack[1]['kwargs']['toto'])\",\n \"def test_foodtrucks_searchByKeyword(self):\\n\\n\\t\\tprint 'API Test: retrieving foodtruck record by keyword'\\n\\t\\turl = reverse('foodtruck_list')\\n\\t\\tdata0 = {'objectid': 0, 'applicant':'Pizza', 'x': 0.0, 'y': 0.5}\\n\\t\\tdata1 = {'objectid': 1, 'applicant':'Chicago', 'fooditems': 'deep dish pizza and sandwiches', 'x': 1.0, 'y': 1.0}\\n\\t\\tdata2 = {'objectid': 2, 'applicant':'hotdog house', 'x': 1.5, 'y': 1.5}\\n\\t\\tresponse = self.client.post(url, data0, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\\n\\t\\tresponse = self.client.post(url, data1, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\\n\\t\\tresponse = self.client.post(url, data2, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\\n\\t\\t#print response.status_code\\n\\t\\tresponse = self.client.get('/foodtrucks/bykeyword?keyword=pizza', format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(len(response.data), 2)\\n\\t\\tself.assertEqual(response.data[0]['objectid'], 0)\\n\\t\\tself.assertEqual(response.data[1]['objectid'], 1)\\n\\t\\tprint 'pass'\",\n \"def test_search_content_ajax(self, mock_search):\\r\\n mock_search().search.side_effect = self._return_attr\\r\\n self.testapp.get(url='/results/ajax', xhr=True)\\r\\n\\r\\n self.assertTrue(mock_search.called)\\r\\n self.assertEqual(self.attr[0][0],\\r\\n 'ajax',\\r\\n 'search term should be ajax')\\r\\n self.assertTrue(self.attr[1]['content'])\",\n \"def test_search(self):\\n response = Tmdb.search('ozark')\\n self.assertTrue(int(response.status_code) == 200)\\n data = response.json()\\n self.assertTrue(isinstance(data['results'], list))\\n # TODO check if all the shows are in the good format (can be from_dict/to_dict)\",\n \"def test_search(self):\\n\\n with self.client as c:\\n response = c.get(\\\"/users?q=al\\\")\\n data = str(response.data)\\n\\n self.assertIn(\\\"@alice\\\", data)\\n self.assertIn(\\\"@alvin\\\", data)\\n\\n self.assertNotIn(\\\"@bob\\\", data)\\n self.assertNotIn(\\\"@carl\\\", data)\",\n \"def test_happy_path(self):\\n\\n self.client.force_authenticate(user=self.user)\\n data = {\\n \\\"words\\\": 100,\\n \\\"response_format\\\": 'json'\\n }\\n\\n with mock.patch(\\\"tweety.utils.TweetTextParser.extract_word_cloud\\\") as mock_cloud_func:\\n mock_cloud_func.return_value = self.json_cloud\\n response = self.client.post(self.url, data=data)\\n\\n self.assertIsInstance(response.accepted_renderer, JSONRenderer)\\n self.assertEqual(response.data, self.json_cloud)\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\n data = {\\n \\\"words\\\": 100,\\n \\\"response_format\\\": 'csv'\\n }\\n\\n with mock.patch(\\\"tweety.utils.TweetTextParser.extract_word_cloud\\\") as mock_cloud_func:\\n mock_cloud_func.return_value = self.csv_cloud\\n response = self.client.post(self.url, data=data)\\n\\n self.assertIsInstance(response.accepted_renderer, utils.TweetyCsvRenderer)\\n self.assertEqual(response.data, self.csv_cloud)\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def test_semantic_search(self):\\n # A name in the database\\n search_string = \\\"football\\\"\\n # Search For Umut\\n resp = SearchTest.client.get('/api/search/',{\\\"token\\\":SearchTest.valid_token,\\\"search_string\\\":search_string})\\n search_result = json.loads(resp.content)\\n # Umut must be in the results because basketball and football are semanticly related\\n self.assertEqual(\\\"Umut\\\",search_result[0]['name'],\\\"Semantic Search functionality doesn't work.\\\")\",\n \"def test_load_search_subject(self, mock_get):\\n\\n c = Client()\\n data = {\\n 'search_type': self.filter_subject,\\n 'search_value': self.subject,\\n }\\n response = c.post('/taric_books/search/', data=data)\\n\\n self.assertEqual(response.status_code, 200)\",\n \"def test_search_recipes(self):\\n pass\",\n \"def test_response_class(self):\\n\\n response = self.client.search({})\\n\\n from rubber.response import Response, SearchResponse\\n self.assertTrue(isinstance(response, Response))\\n self.assertTrue(isinstance(response, SearchResponse))\\n\\n response = self.client.mapping.get()\\n self.assertTrue(isinstance(response, Response))\\n self.assertFalse(isinstance(response, SearchResponse))\",\n \"def test_no_next_token_2calls(self):\\n\\n response1 = {'meta': {'result_count': 500, 'next_token': 1}}\\n response2 = {'meta': {'result_count': 10}}\\n\\n wk = os.path.dirname(os.path.abspath(__file__))\\n f = os.path.join(wk, \\\"search_tweets.config\\\")\\n thing = SearchTweets(self.db, f)\\n with patch.object(thing, '_SearchTweets__twitter_n_results', new_callable=PropertyMock(return_value=520)):\\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\\n with patch.object(thing, '_SearchTweets__multi_user', new_callable=PropertyMock(return_value=False)):\\n with patch.object(thing, '_SearchTweets__twitter_users',\\n new_callable=PropertyMock(return_value=[])):\\n with patch.object(thing, '_SearchTweets__twitter_keyword',\\n new_callable=PropertyMock(return_value=\\\"Eurovision\\\")):\\n with self.assertLogs('SEARCH', level='DEBUG') as cm:\\n with patch.object(thing, '_SearchTweets__save'):\\n mock_method.side_effect = [response1, response2]\\n thing.search()\\n\\n self.assertEqual(mock_method.call_count, 2)\\n self.assertTrue(\\\"DEBUG:SEARCH:THERE ARE NO OTHER PAGE AVAILABLE. ALL TWEETS REACHED\\\" in cm.output)\\n self.assertTrue(\\\"DEBUG:SEARCH:NO NEXT TOKEN IN RESPONSE:INTERRUPTING\\\" in cm.output)\",\n \"def test_products_get_pattern_multiple_match(data, mocker):\\n mocker.patch(\\\"sps.request.fetch\\\", autospec=True)\\n request.fetch.return_value = data\\n assert products.get(\\\"1\\\", \\\"fake-file-name\\\", False, False) == data[\\\"data\\\"]\\n assert products.get(\\\"SUSE\\\", \\\"fake-file-name\\\", False, False) == data[\\\"data\\\"]\\n assert products.get(\\\"x86\\\", \\\"fake-file-name\\\", False, False) == data[\\\"data\\\"]\",\n \"def search(self, pattern):\\n raise NotImplementedError()\",\n \"def test_search_systems_post(self):\\n pass\",\n \"def testMaxResult(self):\\n \\\"\\\"\\\" In this case we are asking for 520 tweets, and we return as first result 500 tweets \\\"\\\"\\\"\\n \\\"\\\"\\\" we check that er make exactly 2 requests. \\\"\\\"\\\"\\n\\n response1 = {'meta': {'result_count': 500, 'next_token': 1}}\\n response2 = {'meta': {'result_count': 20, 'next_token': 2}}\\n wk = os.path.dirname(os.path.abspath(__file__))\\n f = os.path.join(wk, \\\"search_tweets.config\\\")\\n thing = SearchTweets(self.db, f)\\n with patch.object(thing, '_SearchTweets__twitter_n_results', new_callable=PropertyMock(return_value=520)):\\n with patch.object(thing, '_SearchTweets__connect_to_endpoint') as mock_method:\\n with patch.object(thing, '_SearchTweets__multi_user', new_callable=PropertyMock(return_value=False)):\\n with patch.object(thing, '_SearchTweets__twitter_users',\\n new_callable=PropertyMock(return_value=[])):\\n with patch.object(thing, '_SearchTweets__twitter_keyword',\\n new_callable=PropertyMock(return_value=\\\"Eurovision\\\")):\\n with patch.object(thing, '_SearchTweets__save'):\\n\\n mock_method.side_effect = [response1, response2]\\n thing.search()\\n\\n self.assertEqual(mock_method.call_count, 2)\",\n \"def test_get(self, publish_mock: mock.Mock) -> None:\\n\\n def side_effect(*args: str, **_: str) -> Any:\\n if args[0] == \\\"registry:search:dict\\\":\\n return [{\\\"host1\\\": \\\"mac1\\\", \\\"host2\\\": \\\"mac2\\\"}]\\n\\n if args[0] == \\\"app_url\\\":\\n return [\\\"/registry\\\"]\\n\\n if args[0] == \\\"jinja:render\\\":\\n return [\\\"\\\"]\\n\\n return mock.DEFAULT\\n\\n publish_mock.side_effect = side_effect\\n\\n self.request(\\\"/\\\")\\n\\n self.assertEqual(\\n helpers.template_var(publish_mock, \\\"registry_url\\\"),\\n \\\"/registry\\\"\\n )\\n self.assertEqual(\\n helpers.template_var(publish_mock, \\\"hosts\\\").get(\\\"host1\\\"),\\n \\\"mac1\\\"\\n )\\n\\n self.assertNotIn(\\n \\\"host3\\\",\\n helpers.template_var(publish_mock, \\\"hosts\\\")\\n )\\n\\n self.assertFalse(\\n helpers.template_var(publish_mock, \\\"send\\\")\\n )\",\n \"def test_wrong_token(self):\\n wrong_token = \\\"1\\\"*64\\n expected_result = \\\"You have to give your token\\\"\\n resp = SearchTest.client.get('/api/search/',{\\\"token\\\":wrong_token,\\\"search_string\\\":\\\"Umut\\\"})\\n self.assertEqual(json.loads(resp.content),expected_result,\\\"Token Control is not True\\\")\",\n \"def test_parse_search_result(self):\\n datafile = pathlib.Path(__file__).parent.joinpath(\\\"../data/ol_search.json\\\")\\n search_data = json.loads(datafile.read_bytes())\\n result = list(self.connector.parse_search_data(search_data, 0))[0]\\n\\n self.assertIsInstance(result, SearchResult)\\n self.assertEqual(result.title, \\\"This Is How You Lose the Time War\\\")\\n self.assertEqual(result.key, \\\"https://openlibrary.org/works/OL20639540W\\\")\\n self.assertEqual(result.author, \\\"Amal El-Mohtar, Max Gladstone\\\")\\n self.assertEqual(result.year, 2019)\\n self.assertEqual(result.connector, self.connector)\",\n \"def test_GET_Search(self):\\n self.register_user()\\n result = self.login_user()\\n access_token = json.loads(result.data.decode())['access_token']\\n res = self.client().post('/expenses/', headers=dict(Authorization=\\\"Bearer \\\" + access_token), data=self.expense)\\n self.assertEqual(res.status_code, 201)\\n res = self.client().get('/expenses/?name=snacks', headers=dict(Authorization=\\\"Bearer \\\" + access_token))\\n self.assertEqual(res.status_code, 200)\\n results = json.loads(res.data)\\n self.assertEqual(results['items'][0]['name'], self.expense['name'])\",\n \"def test_get_request_normal_response(self, mock_get):\\n\\n # Arrange\\n # Construct our mock response object, giving it relevant expected behaviours\\n mock_resp_instance = MockResponse({\\\"msg\\\": \\\"success\\\"}, 200, content=\\\"abc\\\")\\n mock_get.return_value = mock_resp_instance\\n\\n # Act\\n response = get_request_data(self.url, json_resp=False)\\n\\n # Assert that the request-response cycle completed successfully.\\n self.assertEqual(mock_resp_instance.status_code, 200)\\n self.assertEqual(response, mock_resp_instance)\",\n \"def test_no_input(self):\\n resp = SearchTest.client.get('/api/search/')\\n self.assertEqual(json.loads(resp.content),\\\"You give your input in wrong format. Please check the API documentation for the appropriate input format!!\\\",\\\"No Input Test Error\\\")\",\n \"def matchResult(self, method, path):\\n pass\",\n \"def test_search(self):\\n req = http.make_request('http://xxx', 'GET', None, None)\\n self.assertIsNone(req.data)\\n\\n req = http.make_request('http://xxx', 'GET', 'ignored', None)\\n self.assertIsNone(req.data)\\n\\n req = http.make_request('http://xxx', 'DELETE', None, None)\\n self.assertIsNone(req.data)\\n\\n req = http.make_request('http://xxx', 'DELETE', 'ignored', None)\\n self.assertIsNone(req.data)\\n\\n req = http.make_request('http://xxx', 'POST', '', None)\\n self.assertEqual(0, len(req.data))\\n\\n req = http.make_request('http://xxx', 'POST', 'abc', None)\\n self.assertEqual(3, len(req.data))\\n\\n req = http.make_request('http://xxx', 'POST', '', [('xxx', 'yyy'),\\n ('foo',)])\\n\\n self.assertEqual('yyy', req.get_header('Xxx'))\\n self.assertEqual('1', req.get_header('Foo'))\",\n \"def test_query_cached(self):\\n CreateMatch()\\n\\n data = {\\n \\\"term1\\\": \\\"TESTURL1\\\",\\n \\\"term2\\\": \\\"TESTURL2\\\"\\n }\\n response = self.app.post(\\n \\\"/degree\\\", data=data, follow_redirects=True\\n )\\n self.assertEqual(response.status_code, 200)\\n\\n res_txt = response.get_data(as_text=True)\\n\\n self.assertIn(\\\"33 degrees\\\", res_txt)\\n self.assertIn(\\\"YAAAAY!\\\", res_txt)\",\n \"def test_service_item_search(self):\\n\\n flag = \\\"user\\\"\\n api = \\\"service.item.editsn\\\"\\n #current_page = 1\\n search_info = json.dumps({\\n })\\n sn_pre = '730300010036664'#'730300010034444'\\n sn_after = '730300010036665'#'730300010033333'\\n result = self.access_api(flag = flag, api = api, sn_pre=sn_pre, sn_after=sn_after)\\n #self.assertTrue('data_list' in result)\\n #print(result[\\\"data_list\\\"])\",\n \"def test_get(self, mock_logging):\\r\\n twitter = client.HashtagClient(mock_logger)\\r\\n twitter.client.search.tweets = MagicMock()\\r\\n with pytest.raises(TwitterHTTPError) as e:\\r\\n twitter.get(\\\"abc\\\", 3)\\r\\n\\r\\n mock_logging.assert_called_with(\\\"Searching Hashtag = #abc\\\")\\r\\n assert twitter.client.search.tweets.called\",\n \"def test_view_response(self, mock_mailgun_client, mock_prepare_exec_search):\\n email_results = ['a@example.com', 'b@example.com']\\n mock_prepare_exec_search.return_value = email_results\\n mock_mailgun_client.send_batch.return_value = [\\n Mock(spec=Response, status_code=HTTP_200_OK, json=mocked_json()),\\n Mock(spec=Response, status_code=HTTP_400_BAD_REQUEST, json=mocked_json()),\\n ]\\n resp_post = self.client.post(self.mail_url, data=self.request_data, format='json')\\n assert resp_post.status_code == HTTP_200_OK\\n assert len(resp_post.data.keys()) == 2\\n for num in range(2):\\n batch = 'batch_{0}'.format(num)\\n assert batch in resp_post.data\\n assert 'status_code' in resp_post.data[batch]\\n assert 'data' in resp_post.data[batch]\\n assert resp_post.data['batch_0']['status_code'] == HTTP_200_OK\\n assert resp_post.data['batch_1']['status_code'] == HTTP_400_BAD_REQUEST\",\n \"def test_get(self):\\n response = AjaxTemporaryCode.as_view()(self.request)\\n p = re.compile(\\\"^qaa-x-[a-f0-9]{6}$\\\")\\n self.assertIsNotNone(p.match(response.content))\",\n \"def test_get_School_search(self):\\n school_ids = self.create_School(2,200)\\n url = '/students'\\n data = {'first_name': 'Poompatai', 'last_name': 'Puntitpong','age': 20, 'nationality': 'Thailand', 'school': school_ids[0]}\\n response = self.client.post(url, data, format='json')\\n data = {'first_name': 'Robert', 'last_name': 'Puntitpong','age': 25, 'nationality': 'Cambodia', 'school': school_ids[0]}\\n response = self.client.post(url, data, format='json')\\n data = {'first_name': 'Alan', 'last_name': 'Manny','age': 20, 'nationality': 'Cambodia', 'school': school_ids[1]}\\n response = self.client.post(url, data, format='json')\\n\\n \\\"\\\"\\\"by school\\\"\\\"\\\"\\n response = self.client.get(url + '?search=triam', format='json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data['count'], 3)\\n\\n \\\"\\\"\\\"by school\\\"\\\"\\\"\\n response = self.client.get(url + '?search=udom', format='json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data['count'], 3)\\n\\n \\\"\\\"\\\"Nationality\\\"\\\"\\\"\\n response = self.client.get(url + '?search=odia', format='json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data['count'], 2)\\n\\n \\\"\\\"\\\"last_name\\\"\\\"\\\"\\n response = self.client.get(url + '?search=titpong', format='json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data['count'], 2)\\n\\n \\\"\\\"\\\"first_name and nationality\\\"\\\"\\\"\\n response = self.client.get(url + '?search=lan', format='json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data['count'], 2)\",\n \"def test_api_search_query(api_client, query):\\n response = api_client.get(path='/breweries/search', params={'query': query})\\n assert query in response.text\",\n \"def test_valid_search_query_and_category_return_results(self):\\n article = ArticleFactory()\\n article.publish()\\n request = RequestFactory().get(\\\"\\\", {\\\"q\\\": article.title[:10]})\\n response = Search.as_view()(request, category=\\\"articles\\\")\\n self.assertIn(\\\"results\\\", response.context_data)\\n results = response.context_data[\\\"results\\\"]\\n self.assertEqual(len(results), 1)\\n self.assertIn(article, results)\",\n \"def test_search_history(monkeypatch, records):\\n found = [records[1], records[2], records[7]]\\n instrument_mock = mock.MagicMock()\\n instrument_mock.scan.return_value = found\\n monkeypatch.setattr(\\\"app.search.InstrumentModel\\\", instrument_mock)\\n\\n response = search.history({\\\"body\\\": ujson.dumps({\\\"term\\\": \\\"Test Name\\\"})}, {})\\n instrument_mock.history.contains.assert_called_with(\\\"Test Name\\\")\\n\\n assert response[\\\"statusCode\\\"] == 200\\n assert _result_id_set(response[\\\"body\\\"]) == _result_id_set(found)\",\n \"def test_search_title_and_content(self):\\r\\n response = self.client.post(reverse('questions:search'),\\r\\n {'search': 'find this'})\\r\\n self.assertEqual(response.status_code, 200)\\r\\n results = response.context['question_list']\\r\\n self.assertEqual(results.count(), 2)\",\n \"def test_find_categories(self):\\n testdoc = \\\"\\\"\\\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\" standalone=\\\"yes\\\"?>\\n<ItemListDocument xmlns=\\\"http://xml.vidispine.com/schema/vidispine\\\">\\n <hits>1691985</hits>\\n <facet>\\n <field>gnm_asset_category</field>\\n <count fieldValue=\\\"Rushes\\\">1165113</count>\\n <count fieldValue=\\\"Completed Project\\\">169266</count>\\n <count fieldValue=\\\"HoldingImage\\\">41071</count>\\n </facet>\\n</ItemListDocument>\\\"\\\"\\\"\\n\\n with patch('requests.put', return_value=self.MockResponse(200, testdoc)):\\n from portal.plugins.gnmplutostats.categoryscanner import find_categories\\n result = find_categories()\\n self.assertEqual(result, ['Rushes','Completed Project', 'HoldingImage'])\",\n \"def test_process_response(self):\\n t = self.create_request_object()\\n response_content = u\\\"\\\"\\\"<ODM FileType=\\\"Snapshot\\\" FileOID=\\\"\\\" CreationDateTime=\\\"\\\" ODMVersion=\\\"1.3\\\"\\nxmlns:mdsol=\\\"http://www.mdsol.com/ns/odm/metadata\\\" xmlns=\\\"http://www.cdisc.org/ns/odm/v1.3\\\">\\n <Study OID=\\\"Lab Test\\\">\\n <GlobalVariables>\\n <StudyName>Lab Test</StudyName>\\n <StudyDescription />\\n <ProtocolName>Lab Test</ProtocolName>\\n </GlobalVariables>\\n </Study>\\n <Study OID=\\\"Mediflex\\\">\\n <GlobalVariables>\\n <StudyName>Mediflex</StudyName>\\n <StudyDescription />\\n <ProtocolName>Mediflex</ProtocolName>\\n </GlobalVariables>\\n </Study>\\n</ODM>\\\"\\\"\\\"\\n req = mock.Mock(requests.Request, text=response_content)\\n response = t.result(req)\\n self.assertTrue(isinstance(response, RWSStudies))\\n for study in response:\\n self.assertTrue(study.oid in ['Lab Test', 'Mediflex'])\",\n \"def test_GET_task_search(self):\\n\\t\\tdata = self.GET_data('/api/task/search')\\n\\t\\tself.assertEqual(0, len(data))\\n\\t\\ttask_id = self.POST_task(TEST_TASK_DATA)\\n\\t\\tdata = self.GET_data('/api/task/search')\\n\\t\\tself.assertEqual(1, len(data))\\n\\t\\tself.assertEqual(task_id, data[0]['_id'])\\n\\t\\tself.assertDataMatch(TEST_TASK_DATA, data[0], keys=[k for k in TEST_TASK_DATA.keys()])\",\n \"def test_search_test_search_returns_correct_menu(self):\\n # create some db records\\n dataset = self.create_mixed_test_data()\\n test_search_string = 'bravo'\\n\\n with patch('builtins.input', side_effect=test_search_string):\\n result = self.menu.search_text_search()\\n\\n expected_result = self.menu.present_next_result\\n\\n self.assertEqual(expected_result, result)\",\n \"def test_response_200_on_get(self):\\n pass\",\n \"def test_all_matches(self):\\n match = Match.select()[:]\\n with self.client:\\n response = self.client.get(f'/all-matches')\\n data = json.loads(response.data.decode())\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(len(data['data']), len(match))\",\n \"def test_process_response(self):\\n t = self.create_request_object()\\n response_content = u\\\"\\\"\\\" <Response ReferenceNumber=\\\"82e942b0-48e8-4cf4-b299-51e2b6a89a1b\\\"\\n InboundODMFileOID=\\\"\\\"\\n IsTransactionSuccessful=\\\"1\\\"\\n SuccessStatistics=\\\"Rave objects touched: Subjects=0; Folders=0; Forms=0; Fields=0; LogLines=0\\\" NewRecords=\\\"\\\">\\n </Response>\\n \\\"\\\"\\\"\\n req = mock.Mock(requests.Request, text=response_content)\\n response = t.result(req)\\n self.assertTrue(isinstance(response, RWSResponse))\",\n \"def test_other_search(url):\\n test_clear(url)\\n admin_tk = channel_user_create_0(url)[0]\\n guest1_tk, guest1_id = channel_user_create_1(url)\\n\\n test_channels = {\\n 'token': admin_tk,\\n 'name': 'channel_1',\\n 'is_public': True\\n }\\n requests.post(url + \\\"channels/create\\\", json=test_channels)\\n \\n test_channels = {\\n 'token': admin_tk,\\n 'name': 'channel_2',\\n 'is_public': True\\n }\\n requests.post(url + \\\"channels/create\\\", json=test_channels)\\n\\n requests.post(url + \\\"channel/invite\\\", json={\\n 'token': admin_tk,\\n 'channel_id': 1,\\n 'u_id': guest1_id,\\n })\\n\\n requests.post(url + \\\"channel/invite\\\", json={\\n 'token': admin_tk,\\n 'channel_id': 2,\\n 'u_id': guest1_id,\\n })\\n\\n test_admin_message_1 = {\\n 'token': admin_tk,\\n 'channel_id': 1,\\n 'message': 'Hello'\\n }\\n resp = requests.post(url + \\\"message/send\\\", json=test_admin_message_1)\\n message_send_resp = resp.json()\\n assert message_send_resp['message_id'] == 1\\n\\n test_guest_message_1 = {\\n 'token': guest1_tk,\\n 'channel_id': 1,\\n 'message': 'A Hello'\\n }\\n resp = requests.post(url + \\\"message/send\\\", json=test_guest_message_1)\\n message_send_resp = resp.json()\\n assert message_send_resp['message_id'] == 2\\n\\n test_message_2 = {\\n 'token': admin_tk,\\n 'channel_id': 2,\\n 'message': 'AA Hello'\\n }\\n resp = requests.post(url + \\\"message/send\\\", json=test_message_2)\\n message_send_resp = resp.json()\\n assert message_send_resp['message_id'] == 3\\n\\n test_search = {\\n 'token': admin_tk,\\n 'query_str': 'A'\\n }\\n resp = requests.get(url + \\\"search\\\", params=test_search)\\n search_resp = resp.json()\\n assert len(search_resp['messages']) == 2\\n search_result = [messages['message'] for messages in search_resp['messages']]\\n assert search_result == ['A Hello', 'AA Hello']\\n\\n test_search = {\\n 'token': admin_tk,\\n 'query_str': 'a'\\n }\\n resp = requests.get(url + \\\"search\\\", params=test_search)\\n search_resp = resp.json()\\n assert len(search_resp['messages']) == 0\\n search_result = [messages['message'] for messages in search_resp['messages']]\\n assert search_result == []\",\n \"def test_validate_search():\\n payload = {\\\"search_input\\\": \\\"The input\\\", \\\"search_object_types\\\": []}\\n result = validate_search_payload(payload)\\n assert result == {}\",\n \"def test_brands_reply(self):\\n # 1. Setup service channel / dispatch channel\\n # 2. send a post to brand\\n # 3. Reply with custom response\\n # 4. Route a reply\\n # 5. check there is no extra responses created\\n # 6. create a matchable and repeat 1-5\\n brand = 'brand'\\n channel, dispatch_channel = self.setup_channels(brand)\\n user = self._create_db_user(email='su@test.test', password='test', is_superuser=True)\\n user.account = self.account\\n user.save()\\n profiles = set()\\n\\n def do_test(matchable):\\n profile = gen_profile()\\n user_name = profile['user_name']\\n profiles.add(user_name)\\n post = self._create_db_post(\\n '@%s I need some carrot' % brand,\\n channel=channel,\\n user_profile=profile)\\n\\n response = Response.objects.get(id=id_from_post_id(post.id))\\n self.assertIsInstance(response.matchable, matchable.__class__)\\n assert response.matchable == matchable\\n\\n # post custom response\\n creative = \\\"U could find some carrot there\\\"\\n self.login(user.email, 'test')\\n data = dict(creative=creative,\\n response=str(response.id),\\n latest_post=str(response.post.id))\\n resp = self.client.post('/commands/custom_response', data=json.dumps(data))\\n resp = json.loads(resp.data)\\n\\n # check responses and conversations\\n self.assertEqual(Response.objects(conversation_id=None).count(), 0)\\n self.assertEqual(\\n Response.objects(channel__in=[channel, channel.inbound_channel, channel.outbound_channel]).count(),\\n 0)\\n self.assertEqual(Response.objects(conversation_id=response.conversation.id).count(), 1)\\n self.assertEqual(Response.objects(channel__in=[dispatch_channel]).count(), len(profiles))\\n\\n matchable = EmptyMatchable.get()\\n do_test(matchable)\\n\\n matchable = self._create_db_matchable('Here is your carrot',\\n intention_topics=['carrot'],\\n channels=[channel.inbound_channel])\\n do_test(matchable)\",\n \"def test_match_response(match_response, client):\\n file = glob.glob('./**/test_areas.csv', recursive=True)\\n with open(file[0], 'r') as fp:\\n ds = client.create_dataset(fp)\\n resp = ds.match(source_prov_col='Province')\\n assert resp.keys() == match_response.keys()\",\n \"def test_analysis_match(self):\\n self.api.observable_add('test.com')\\n results = self.api.analysis_match(['test.com', 'unknown.com'])\\n known = [o['value'] for o in results['known']]\\n self.assertIn('test.com', known)\\n self.assertIn('unknown.com', results['unknown'])\",\n \"def test_google_return(monkeypatch):\\n ADD = \\\"7 Cité Paradis, 75010 Paris, France\\\"\\n LAT = 48.8748465\\n LNG = 2.3504873\\n NAME = \\\"openclassrooms\\\"\\n RESULTS = {\\n \\\"candidates\\\": [\\n {\\n \\\"formatted_address\\\": ADD,\\n \\\"geometry\\\": {\\n \\\"location\\\": {\\n \\\"lat\\\": LAT,\\n \\\"lng\\\": LNG\\n },\\n\\n },\\n \\\"name\\\": NAME\\n\\n }\\n ]\\n\\n }\\n\\n class MockGet:\\n def __init__(self,*args, **kwargs):\\n pass\\n\\n def json(self):\\n return RESULTS\\n\\n monkeypatch.setattr('requests.get', MockGet)\\n script = GoogleMapApi()\\n response = script.search_about_query(query='openclassrooms', g_key=1).json()\\n assert response['candidates'][0]['formatted_address'] == ADD\",\n \"def test_search_client_by_title(self, mock_get):\\n\\n response = isbn_utils.search_by(self.filter_title, self.title)\\n self.assertEqual(response.data, json.loads(open(UNIT_TEST_RESOURCES_FOLDER +\\n FILE_NAME_TITLE_SEARCH_RESPONSE).read())[\\\"data\\\"])\",\n \"def test_maps_response(self):\\n response_content = u\\\"\\\"\\\" <ODM FileType=\\\"Snapshot\\\"\\n FileOID=\\\"770f1758-db33-4ab2-af72-38db863734aa\\\"\\n CreationDateTime=\\\"2013-04-08T14:08:06.875-00:00\\\"\\n ODMVersion=\\\"1.3\\\">\\n\\n <ClinicalData StudyOID=\\\"Fixitol(Dev)\\\" MetaDataVersionOID=\\\"1111\\\">\\n <SubjectData SubjectKey=\\\"000001\\\">\\n <SiteRef LocationOID=\\\"BP001\\\"/>\\n </SubjectData>\\n </ClinicalData>\\n\\n <ClinicalData StudyOID=\\\"Fixitol(Dev)\\\" MetaDataVersionOID=\\\"1111\\\">\\n <SubjectData SubjectKey=\\\"1111\\\">\\n <SiteRef LocationOID=\\\"335566\\\"/>\\n </SubjectData>\\n </ClinicalData>\\n </ODM>\\n\\\"\\\"\\\"\\n request = StudySubjectsRequest(\\\"Fixitol\\\",\\n \\\"Dev\\\")\\n req = mock.Mock(requests.Request, text=response_content)\\n response = request.result(req)\\n self.assertTrue(isinstance(response, RWSSubjects))\\n for subject in response:\\n self.assertTrue(isinstance(subject, RWSSubjectListItem))\\n self.assertTrue(subject.subject_name in ['000001', \\\"1111\\\"])\",\n \"def test_restlike_search(self):\\r\\n # first let's add a bookmark we can search on\\r\\n self._get_good_request()\\r\\n\\r\\n search_res = self.testapp.get(\\r\\n '/api/v1/admin/bmarks/search/search?search_content=True')\\r\\n\\r\\n self.assertTrue(\\r\\n search_res.status == '200 OK',\\r\\n \\\"Status is 200: \\\" + search_res.status)\\r\\n self.assertTrue(\\r\\n 'python' in search_res.body,\\r\\n \\\"We should find the python tag in the results: \\\" + search_res.body)\",\n \"def test_search_page_item_not_in_database(self, mock_api, mock_search):\\n mock_search.side_effect = [LookupError, {\\\"result\\\": \\\"result\\\",\\n \\\"products\\\": \\\"products\\\"}]\\n response = self.client.post(\\\"/search/\\\", {\\\"query\\\": \\\"test\\\"})\\n self.assertEqual(response.status_code, 200)\\n self.assertTemplateUsed(response, \\\"search/base.html\\\")\\n self.assertTemplateUsed(response, \\\"search/search_form.html\\\")\\n self.assertTemplateUsed(response, \\\"search/results_page.html\\\")\\n self.assertTemplateUsed(response, \\\"search/result.html\\\")\\n self.assertEqual(response.context[\\\"result\\\"], \\\"result\\\")\\n self.assertEqual(response.context[\\\"products\\\"], \\\"products\\\")\",\n \"def generic_test(self):\\n api_params[params_to_api[\\\"org_id\\\"]] = str(self.org_id)\\n valid_response = [\\n entry for entry in self.valid_response\\n if all(\\n str(entry[k]).lower().find(str(api_params[k]).lower()) != -1\\n for k in api_params\\n )\\n ]\\n # Setup the mocked response\\n responses.add(\\n responses.GET, self.api_url, json=valid_response, status=200, match_querystring=False\\n )\\n acme = ACMEAccount(client=self.client)\\n data = list(acme.find(self.org_id, **params))\\n\\n # Verify all the query information\\n # There should only be one call when \\\"find\\\" is called.\\n # Due to pagination, this is only guaranteed as long as the number of\\n # entries returned is less than the page size\\n self.assertEqual(len(responses.calls), 1)\\n self.match_url_with_qs(responses.calls[0].request.url, api_params)\\n self.assertEqual(data, valid_response)\",\n \"def test_filter_on_subtype(authenticated_client):\\n observable_json = {'value': r'asd[0-4]\\\\.com'}\\n rv = authenticated_client.post('/api/observables/filter/',\\n data=json.dumps(observable_json),\\n content_type='application/json')\\n response = json.loads(rv.data)\\n for item in response:\\n assert re.match(r'asd[0-4]\\\\.com', item['value'])\\n assert item['type'] == 'domain-name'\",\n \"def test_get_foods_search(self):\\n pass\",\n \"def mocked_requests_get():\\n\\n class MockResponse:\\n def __init__(self, _content, _status):\\n self.content = _content\\n self.status_code = _status\\n\\n def content(self):\\n return self.content\\n\\n return MockResponse\",\n \"def test_foodtrucks_searchByLocation(self):\\n\\t\\tprint 'API Test: retrieving foodtrucks nearby'\\n\\t\\turl = reverse('foodtruck_list')\\n\\t\\tdata = [{'objectid': 0, 'latitude':37.7841781516735 , 'longitude':-122.394064145441 },\\\\\\n\\t\\t\\t\\t{'objectid': 1, 'latitude':37.7862060821039 , 'longitude':-122.402532491346 }, \\t#ft2 is closest to ft0\\\\\\n\\t\\t\\t\\t{'objectid': 2, 'latitude':37.7800057026855 , 'longitude':-122.390270961311 },\\t#ft1 is further to ft0\\\\\\n\\t\\t\\t\\t{'objectid': 3, 'latitude':32 , 'longitude': -100}]\\t\\t\\t\\t\\t\\t\\t\\t#ft3 is far far away\\n\\t\\tfor d in data:\\n\\t\\t\\tresponse = self.client.post(url, d, format='json')\\n\\t\\t\\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\\n\\t\\t\\n\\t\\tlat = data[0]['latitude'] #given latitude\\n\\t\\tlon = data[0]['longitude']\\t#given longitude\\n\\t\\trad = 3 \\t\\t\\t\\t\\t#given radius of search\\n\\t\\tlim = 2 \\t\\t\\t\\t\\t#given limit of results\\n\\t\\t\\\"\\\"\\\" test both urls: w/ or w/out limit \\\"\\\"\\\"\\n\\t\\tresponse = self.client.get('/foodtrucks/bylocation?latitude=%f&longitude=%f&radius=%f' % (lat, lon, rad), format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(len(response.data), 3)\\n\\t\\tself.assertEqual(response.data[0]['objectid'], 0)\\n\\t\\tself.assertEqual(response.data[1]['objectid'], 2)\\t\\t\\n\\t\\tself.assertEqual(response.data[2]['objectid'], 1)\\t\\t\\n\\n\\t\\tresponse = self.client.get('/foodtrucks/bylocation?latitude=%f&longitude=%f' % (lat, lon), format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(len(response.data), 3)\\n\\n\\t\\tresponse = self.client.get('/foodtrucks/bylocation?latitude=%f&longitude=%f&radius=%f&limit=%d' % (lat, lon, rad, lim), format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(len(response.data), 2)\\n\\n\\t\\t\\\"\\\"\\\" test the radius: shrink the radius such that only ft0 will be found \\\"\\\"\\\"\\n\\t\\trad = 0.01\\n\\t\\tresponse = self.client.get('/foodtrucks/bylocation?latitude=%f&longitude=%f&radius=%f' % (lat, lon, rad), format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(len(response.data), 1)\\n\\t\\tprint 'pass'\",\n \"def test_post_foods_search(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6732833","0.66641694","0.63938046","0.6325752","0.62485534","0.6154589","0.6144737","0.6090113","0.60500705","0.60500705","0.60500705","0.60223466","0.60047615","0.60046566","0.59748423","0.58795416","0.587042","0.5864914","0.58384216","0.58313507","0.58142287","0.5786833","0.57843506","0.57641536","0.5754322","0.57447785","0.5743555","0.5725241","0.5723999","0.57013494","0.56827855","0.5680299","0.5664954","0.56634426","0.56454504","0.56453544","0.56245255","0.5613756","0.56056017","0.55914956","0.5580507","0.5576364","0.55741984","0.5566042","0.5562587","0.55620784","0.5558166","0.55575275","0.5553547","0.555203","0.5541465","0.5541039","0.55171156","0.55090487","0.55060697","0.55055475","0.55026275","0.5501357","0.5491043","0.5488634","0.5474808","0.54692626","0.5463369","0.54620695","0.5461929","0.54606175","0.54586804","0.5451829","0.544801","0.5435726","0.54261583","0.5421674","0.5400717","0.5390895","0.53832555","0.53813255","0.5364433","0.5358482","0.53483844","0.5347671","0.5346682","0.53274226","0.5324084","0.53154653","0.5314682","0.5304034","0.5303369","0.53004044","0.5299275","0.5291279","0.5289072","0.5283724","0.52831465","0.5272515","0.5265816","0.5263484","0.526138","0.5254835","0.5253275","0.5249594"],"string":"[\n \"0.6732833\",\n \"0.66641694\",\n \"0.63938046\",\n \"0.6325752\",\n \"0.62485534\",\n \"0.6154589\",\n \"0.6144737\",\n \"0.6090113\",\n \"0.60500705\",\n \"0.60500705\",\n \"0.60500705\",\n \"0.60223466\",\n \"0.60047615\",\n \"0.60046566\",\n \"0.59748423\",\n \"0.58795416\",\n \"0.587042\",\n \"0.5864914\",\n \"0.58384216\",\n \"0.58313507\",\n \"0.58142287\",\n \"0.5786833\",\n \"0.57843506\",\n \"0.57641536\",\n \"0.5754322\",\n \"0.57447785\",\n \"0.5743555\",\n \"0.5725241\",\n \"0.5723999\",\n \"0.57013494\",\n \"0.56827855\",\n \"0.5680299\",\n \"0.5664954\",\n \"0.56634426\",\n \"0.56454504\",\n \"0.56453544\",\n \"0.56245255\",\n \"0.5613756\",\n \"0.56056017\",\n \"0.55914956\",\n \"0.5580507\",\n \"0.5576364\",\n \"0.55741984\",\n \"0.5566042\",\n \"0.5562587\",\n \"0.55620784\",\n \"0.5558166\",\n \"0.55575275\",\n \"0.5553547\",\n \"0.555203\",\n \"0.5541465\",\n \"0.5541039\",\n \"0.55171156\",\n \"0.55090487\",\n \"0.55060697\",\n \"0.55055475\",\n \"0.55026275\",\n \"0.5501357\",\n \"0.5491043\",\n \"0.5488634\",\n \"0.5474808\",\n \"0.54692626\",\n \"0.5463369\",\n \"0.54620695\",\n \"0.5461929\",\n \"0.54606175\",\n \"0.54586804\",\n \"0.5451829\",\n \"0.544801\",\n \"0.5435726\",\n \"0.54261583\",\n \"0.5421674\",\n \"0.5400717\",\n \"0.5390895\",\n \"0.53832555\",\n \"0.53813255\",\n \"0.5364433\",\n \"0.5358482\",\n \"0.53483844\",\n \"0.5347671\",\n \"0.5346682\",\n \"0.53274226\",\n \"0.5324084\",\n \"0.53154653\",\n \"0.5314682\",\n \"0.5304034\",\n \"0.5303369\",\n \"0.53004044\",\n \"0.5299275\",\n \"0.5291279\",\n \"0.5289072\",\n \"0.5283724\",\n \"0.52831465\",\n \"0.5272515\",\n \"0.5265816\",\n \"0.5263484\",\n \"0.526138\",\n \"0.5254835\",\n \"0.5253275\",\n \"0.5249594\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70248115"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76086,"cells":{"query":{"kind":"string","value":"convert name to number"},"document":{"kind":"string","value":"def name_to_number(name):\n if name == \"rock\":\n number = 0\n elif name == \"Spock\":\n number = 1\n elif name == \"paper\":\n number = 2\n elif name == \"lizard\":\n number = 3\n elif name == \"scissors\":\n number = 4\n else:\n print \"Name is invalid!\"\n return 1\n return number"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def name_to_number(self, name):\r\n try:\r\n return self._numbers[name]\r\n except KeyError:\r\n raise KeyError(\"No field named %s in %r\" % (name, self._numbers.keys()))","def name_to_number(name):\r\n \r\n if name == \"rock\":\r\n return 0\r\n elif name == \"Spock\":\r\n return 1\r\n elif name == \"paper\":\r\n return 2\r\n elif name == \"lizard\":\r\n return 3\r\n elif name == \"scissors\":\r\n return 4\r\n else:\r\n return \"Invalid!Enter any one of the following: rock,Spock,paper,lizard,scissors\"","def name_to_number(name):\n if (name == 'rock' or name == 'Rock'):\n return 0\n elif (name == 'Spock' or name == 'spock'):\n return 1\n elif (name == 'paper' or name == 'Paper'):\n return 2\n elif (name == 'lizard' or name == 'Lizard'):\n return 3\n elif (name == 'scissors' or name == 'Scissors'):\n return 4\n else:\n return -1","def name_to_number(name):\n\n # A simple if/elif/else game...\n\n if name == \"rock\":\n number = 0\n elif name == \"Spock\":\n number = 1\n elif name == \"paper\":\n number = 2\n elif name == \"lizard\":\n number = 3\n else:\n number = 4\n return number","def getNameNum(name):\n dicto = {'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':10,'k':11,'l':12,'m':13,'n':14,'o':15,'p':16,'q':17,'r':18,'s':19,'t':20,'u':21,'v':22,'w':23,'x':24,'y':25,'z':26}\n summ = 0\n for letter in name:\n summ += dicto.get(letter.lower())\n return summ","def atomic_number(name):\n try:\n return symbols.index(name.capitalize()) + 1\n except ValueError:\n return lower_names.index(name.lower()) + 1","def getNumberFromName(self, idx):\n\t\tfile = self.all_file_names[idx]\n\t\tnumber = file[4]\n\t\tif file[5].isdigit(): \n\t\t\tnumber += file[5]\n\t\treturn int(number)","def name2digits(name):\n \n name = name.lower()\n \n if len(name)>25:\n name = name[0:25]\n \n primenumbers = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]\n \n n = len(name)\n \n s = 0.0\n \n for i in range(n):\n s += primenumbers[i]*ord(name[i])*2.0**(i+1)\n\n import scipy.io.matlab\n Data = scipy.io.matlab.loadmat('hash.mat',struct_as_record=True)\n x = Data['x']\n t = int(np.mod(s,x.shape[0]))\n\n return np.sort(x[t,:])","def value(name):\r\n return sum(alpha.index(str(l)) + 1 for l in name)","def to_number(self, id):\r\n if isinstance(id, int):\r\n return id\r\n else:\r\n return self.name_to_number(id)","def parse_num(path):\n nbasename = path.basename.lower()\n if nbasename.startswith(nprefix):\n try:\n return int(nbasename[len(nprefix) :])\n except ValueError:\n pass","def to_ordinal(self):\n return mod(self.number - 1 + 39 * (self.number - self.name), 260)","def increment_name(name: str) -> str:\n\n match = _number_suffix.search(name)\n if match:\n number_str = match.group(1)\n next_number = int(number_str) + 1\n return f'{name[:-len(number_str)]}{next_number}'\n else:\n return f'{name}-1'","def getNameIndex(name):\n try:\n location = len(name) - \"\".join(reversed(name)).index(\".\")\n index = int(name[location:])\n except Exception:\n index = 0\n return index","def number_to_name(self, number):\r\n return self._names[number]","def get_int(self, name):\n return self.field(name).toInt()[0]","def _compress_name(name):\n n = 0\n for c in name:\n n = (n * _P1 + ord(c)) % _P2 \n return '%09d' % n","def number_to_name(number):\n if number == 0:\n name = \"rock\"\n elif number == 1:\n name = \"Spock\"\n elif number == 2:\n name = \"paper\"\n elif number == 3:\n name = \"lizard\"\n elif number == 4:\n name = \"scissors\"\n else:\n print \"Number is invalid!\"\n return 1\n return name","def _name2idx(name):\n match = re.search(r\"eth(\\d+)\", name, re.I)\n if not match:\n raise exception.CloudbaseInitException(\n \"invalid NetworkDetails name {!r}\"\n .format(name)\n )\n return int(match.group(1))","def numerify_iso_label(lab):\n from sage.databases.cremona import class_to_int\n if 'CM' in lab:\n return -1 - class_to_int(lab[2:])\n else:\n return class_to_int(lab.lower())","def get_value(self):\n if self.name in ['1','2','3','4','5','6','7','8', '9', '10']:\n return int(self.name)\n if self.name in ['J','Q','K']:\n return 10\n if self.name == 'A':\n return 1","def number_to_name(number):\n for name, value in item_dict.items():\n if number == value:\n return name","def port(name):\n\n words = name.upper().split('-', 1)\n\n if len(words) == 1:\n words.append(words[0][1])\n\n return int(f\"{ord(words[0][0])}{ord(words[1][0])}\")","def calculateValue(name):\n\tscore = 0\n\tfor c in name:\n\t\tscore += ord(c) - ord('A') + 1\n\treturn score","def order(name: str):\n if name.startswith('pred'):\n split = name.split('_')\n if len(str(split[-2])) > 10: # New file format, -2 is hash\n return int(split[-3])\n return int(split[-2])\n split = name.split('_')\n x = split[-1].split('.')[0]\n return int(x)","def number(self):\n return re.match(r'^.*?([0-9]+)$', self._alias).groups()[0]","def updateName(g):\n try:\n n = int(g.group(2))\n except TypeError:\n n = 0\n\n return \"%s-%d\" % (g.group(1), n + 1)","def MonthNum(name):\n return _MONTH_DICT.get(name.capitalize(), 0)","def numerize():\n pass","def word_to_number(nb_word):\n return {\n \"Zero\": 0,\n \"One\": 1,\n \"Two\": 2,\n \"Three\": 3,\n \"Four\": 4,\n \"Five\": 5,\n }[nb_word]","def get_int(num, name='Number'):\n try:\n num = int(num)\n except ValueError:\n raise ValueError('{} must be an integer'.format(name))\n\n return num","def get_number(atomname):\n switch = False\n number = ''\n for char in atomname:\n if char == ')':\n switch = False\n if switch:\n number += char\n if char == '(':\n switch = True\n return number","def legislature_to_number(leg):\n groups = re.match(r'^(\\d\\d)\\w+-(\\d\\d?)\\w+-(regular|special)', leg)\n if groups:\n return '%sLeg/%s%s' % (groups.group(1), groups.group(2), groups.group(3)[0])","def to_int(name, default=0):\n try:\n return int(get(name))\n except (TypeError, ValueError):\n return default","def name_to_id(self, name, add_if_missing=False):\n if isinstance(name, basestring):\n # lookup name or assign new\n if name not in self.names:\n if not add_if_missing:\n raise ValueError(\"name \" + name + \" not found\")\n # Use an empty slot in the list if one exists.\n try:\n id_ = self.names.index(None)\n self.names[id_] = name\n self.hashesperid[id_] = 0\n except ValueError:\n self.names.append(name)\n self.hashesperid = np.append(self.hashesperid, [0])\n id_ = self.names.index(name)\n else:\n # we were passed in a numerical id\n id_ = name\n return id_","def extract_journal(name):\n match = re.search(\"\\d+\", name)\n if match != None: \n return name[:match.start()], int(name[match.start(): match.end()])\n else: \n return \"\", 0","def convert_charref(self, name):\r\n try:\r\n n = int(name)\r\n except ValueError:\r\n return\r\n if not 0 <= n <= 127 : # ASCII ends at 127, not 255\r\n return\r\n return self.convert_codepoint(n)","def get_number(word):\n return int(re.match(NUMBER, word).group(1))","def string_to_number(col_name):\n \n return ( pl.col(col_name).str.replace_all('[\\$MBK]', '').cast(pl.Float64)\n * pl.when(pl.col(col_name).str.ends_with('K'))\n .then(pl.lit(1000))\n .when(pl.col(col_name).str.ends_with('M'))\n .then(pl.lit(1_000_000))\n .when(pl.col(col_name).str.ends_with('B'))\n .then(pl.lit(1_000_000_000))\n .otherwise(pl.lit(1))\n )","def name_number(n):\n num = str(n)\n last_digits = [\"\", \"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\", \"eight\", \"nine\", \"ten\", \"eleven\",\n \"twelve\", \"thirteen\", \"fourteen\", \"fifteen\", \"sixteen\", \"seventeen\", \"eighteen\", \"nineteen\"]\n tens = [\"twenty\", \"thirty\", \"forty\", \"fifty\", \"sixty\", \"seventy\", \"eighty\", \"ninety\"]\n if n <= 19: # name numbers from 1 to 19 directly\n c = last_digits[int(num[-2:])]\n elif 19 < n < 100: # name numbers from 20 to 99 by concatenating name for tens digit with name for ones digit\n c = tens[int(num[-2]) - 2] + last_digits[int(num[-1])]\n elif n % 100 == 0 and n < 1000:\n # name numbers from 100 to 900 that are divisible by 100 by taking number in hundreds place and concatenating\n # with \"hundred\"\n c = last_digits[int(num[0])] + \"hundred\"\n elif n != 1000:\n # name numbers from 100 to 999 excluding those divisible by 100 by taking number in hundreds place, adding\n # \"hundredand\", then naming the other 2 decimal places recursively\n c = last_digits[int(num[0])] + \"hundredand\" + name_number(n % 100)\n else: # name 1000\n c = \"onethousand\"\n return c","def onlynumbers(name):\n return re.sub(\"[a-zA-Z:]\\(\\)\\:\",\"\",name)","def number(self, label, component, config, name, default=None):\n\n value = self.text(label, component, config, name, default)\n return int(value) if value else None","def getNumber():","def get_amount_of_digits(self, name: str):\n x = -1\n while name[x - 1].isdigit():\n x -= 1\n if name[:x].endswith(\"/streaming/p\"):\n return x","def get_following_name(self, name: Name):\n name = str(name)\n amount_of_digits = self.get_amount_of_digits(name)\n number = int(name[amount_of_digits:])\n number += 1\n following_name = name[:amount_of_digits]\n following_name += str(number)\n return following_name","def WeekdayNum(name):\n return _WEEKDAY_DICT.get(name.capitalize(), 0)","def getMangledNum(self):\n return (\"X\" * (len(self.num)-4)) + self.num[-4:]","def clean_numeric_column(name : float) -> float:\n if name > -1 and name < 1:\n name = 0\n return name","def key_to_numeric(x):\n reg = re.compile(r'\\[(\\d+\\_?(\\d+)?)[a-z]?\\]')\n inspect = reg.search(x).groups(0)[0]\n if '_' in inspect:\n left, right = inspect.split('_')\n return int(left), int(right)\n else:\n return int(inspect), 0","def convert_label_string2num(label, num_types):\n dictionary = empty_label_dictionary(num_types)\n all_labels = list(dictionary.keys())\n if num_types==4:\n label = label.replace('Implicit_', '')\n label = label.replace('Explicit_', '')\n return all_labels.index(label)","def number(cls, tileName):\n return TILENAMEMAP[tileName]['Number'] if tileName in TILENAMEMAP else None","def regToInt(name):\n match = re.match(r\"r([0-9]+)\", name)\n if match:\n index = int(match.group(1))\n if 0 <= index <= 15:\n return index\n raise AsmException(\"incorrect register %s\" % name)","def get_num_from_file(file_name):\n basename = file_name.partition('.')[0]\n first, second = basename.split('_')\n num = second.replace(\"genome\", '')\n num = num[1:]\n return int(num)","def letter_to_num(self, string, dict_):\n #dict_= {'A': '0', 'C': '1', 'D': '2', 'E': '3', 'F': '4', 'G': '5', 'H': '6', 'I': '7', 'K': '8', 'L': '9', 'M': '10', 'N': '11', 'P': '12', 'Q': '13', 'R': '14', 'S': '15', 'T': '16', 'V': '17', 'W': '18', 'Y': '19'}\n patt = re.compile('[' + ''.join(dict_.keys()) + ']')\n num_string = patt.sub(lambda m: dict_[m.group(0)] + ' ', string)\n #print(num_string)\n #print(type(num_string))\n num = [int(i) for i in num_string.split()]\n return num","def name_to_id(player_name):\n # This is fairly unsophisticated, just does a CRC32 on the name. Can be\n # optimized both for compute requirements and collision frequency using\n # another hashing algorithm.\n return binascii.crc32(player_name) & 0xFFFFFFFF","def return_episode_num(name):\n return int(name.split(\".\")[0].split(\"ep_\")[1]) # Use split to return only the episode number needed to sort the files in increasing order","def _weight_name(self, name):\n return name.split('/')[-1]","def error_num_to_name(num):\r\n for t in ERROR_CODES:\r\n if t[0] == num:\r\n return t[1]","def _name_increment_revision(name):\n revre = r\"^(.*?)([0-9]+)$\"\n m = re.search(revre, name)\n if m:\n name = m.group(1) + str(int(m.group(2)) + 1)\n else:\n name = name + \" (copy)\"\n return name","def _excel2num(x: str) -> int:\n index = 0\n\n for c in x.upper().strip():\n cp = ord(c)\n\n if cp < ord(\"A\") or cp > ord(\"Z\"):\n raise ValueError(f\"Invalid column name: {x}\")\n\n index = index * 26 + cp - ord(\"A\") + 1\n\n return index - 1","def typeToName(type: int) -> unicode:\n ...","def lvl_name2num(name):\n try:\n levelno = log_levels[name]\n except KeyError:\n logger.error(\"Log level not set: '%s' is not a valid level\", name)\n logger.error(\"Fix the log level configuration\")\n return logging.NOTSET\n else:\n return levelno","def number_to_name(number):\n \n # A simple if/elif/else game...\n\n if number == 0:\n name = \"rock\"\n elif number == 1:\n name = \"Spock\"\n elif number == 2:\n name = \"paper\"\n elif number == 3:\n name = \"lizard\"\n else:\n name = \"scissors\"\n return name","def translate_number(number):\n return NUMBER_TRANSLATOR[number]","def number_to_name(number):\n if (number == 0):\n name = 'rock'\n return name\n if (number == 1):\n name = 'Spock'\n return name\n if (number == 2):\n name = 'paper'\n return name\n if (number == 3):\n name = 'lizard'\n return name\n if (number == 4):\n name = 'scissors'\n return name\n else:\n print \"ERROR: The choice of number is out of range!\"","def w2n(word):\n word = re.sub('[^A-Z0-9]', '', word)\n return ''.join([letter_to_number_mapping[x] for x in word])","def number_to_name(number):\r\n\r\n if number == 0:\r\n return \"rock\"\r\n elif number == 1:\r\n return \"Spock\"\r\n elif number == 2:\r\n return \"paper\"\r\n elif number == 3:\r\n return \"lizard\"\r\n elif number == 4:\r\n return \"scissors\"\r\n else:\r\n \"Invalid ! Enter a number from 0 to 4\"","def letter_to_num(string, dict_):\n patt = re.compile('[' + ''.join(dict_.keys()) + ']')\n num_string = patt.sub(lambda m: dict_[m.group(0)] + ' ', string)\n num = [int(i) for i in num_string.split()]\n return num","def pname(name):\n ranks = list(reversed(name.split(';')))\n for i, rank in enumerate(ranks):\n if rank in ['Others', 'Unassigned']:\n return rank\n if rank == '__':\n continue\n if rank.split('__')[1] is '':\n return ranks[i+1] + ';' + rank\n return rank","def __rank_from_str_to_int(rank: str) -> int:\n return int(rank) - 1","def _convert_name(self, name):\n if not self.re_name.match(name):\n org_name = name\n name = self.re_white.sub('_', name)\n name = self.re_alpha.sub('_', name)\n if not self.re_name.match(name):\n name = 'x_' + name2\n self.warn('Converting name <' + org_name + '> to <' + name + '>.')\n return name","def dot_name(number):\n\tif number > 0:\n\t\treturn \"P {}\".format(number)\n\telse:\n\t\treturn \"O {}\".format(-number)","def encode_label(label: str) -> int:\n\tif not label:\n\t\treturn 0\n\t# part after letter if it has a number, otherwise 1\n\tindex = int(label[1:]) if len(label) > 1 else 1\n\t# A = 1, B = 2, ... E = 5\n\toffset = ord(label[0]) - ord(\"A\") + 1\n\t# compute label number\n\treturn (index - 1) * 5 + offset","def _to_db_identifier(name):\n return name.replace('-', '_')","def _sanitize_to_identifer(name):\n n = name.strip()\n n = re.sub('/', ' ', n)\n n = re.sub('-', ' ', n)\n n = re.sub(' +', '_', n)\n n = re.sub('[\\W]+', '', n)\n return n","def _get_freq(name):\n try:\n counts = int(name.split(\"_x\")[1])\n except:\n return 0\n return counts","def get_num_with_ordinal(num):\n num_with_ordinal = str(num) + ordinal(num)\n return num_with_ordinal","def parse_quantity(quantity):\n try:\n code = int(quantity)\n name = lookup(code)\n except:\n name = quantity\n code = lookup(name)\n return code, name","def get_id(f):\n name = f.split('/')[-1][-10:-4]\n\n score = int(''.join(filter(str.isdigit, f.split('/')[-1][2:]))) * 3 + 1\n if name == 'real_A':\n score += 1\n if name == 'real_B':\n score -= 1\n\n return score","def meses_to_num(palabra):\n \n palabra = str(palabra)\n meses_dict = {'Jan' : '01', 'Feb' : '02', 'Mar' : '03', 'Apr' : '04', 'May' : '05', 'Jun' : '06', 'Jul' : '07',\n 'Aug' : '08', 'Sep' : '09', 'Oct' : '10', 'Nov' : '11', 'Dec' : '12',}\n \n palabra = palabra.strip()\n for key, value in meses_dict.items():\n if key in palabra:\n palabra = palabra.replace(key, value)\n \n palabra = palabra.replace('-', '/')\n return palabra","def file_name_to_radar_num(saliency_file_name):\n\n error_checking.assert_is_string(saliency_file_name)\n\n pathless_file_name = os.path.split(saliency_file_name)[-1]\n extensionless_file_name = os.path.splitext(pathless_file_name)[0]\n radar_word = extensionless_file_name.split('_')[-1]\n\n assert radar_word.startswith('radar')\n\n radar_number = int(radar_word.replace('radar', ''))\n error_checking.assert_is_geq(radar_number, 0)\n\n return radar_number","def __to_key(name: str) -> str:\n return name.replace(\" \", \"-\")","def alpha_number(alpha):\r\n if alpha.isupper() == False:\r\n num = ord(alpha) - 96\r\n return num\r\n elif alpha.isupper() == True:\r\n num = ord(alpha) - 64\r\n return num","def f_translate_key(self, key):\n if isinstance(key, int):\n if key == 0:\n key = self.v_name\n else:\n key = self.v_name + \"_%d\" % key\n return key","def transform(s):\r\n return 'digit ' + str(s)","def numerical_hue(hue):\n if isinstance(hue, str):\n match = hue_regex.match(hue)\n if match:\n return float(match[1]) + HUE_NAMES_TO_NUMBERS[match[3]]\n else:\n return float(hue)\n return hue","def visit_NumberNode(self, node: NumberNode, symbol_table: SymbolTable) -> String:\n return Number(node.tok.value)","def numeral(number):\n return ROMAN_NUMERALS[number]","def dec2int(r: str) -> int:","def get_num(self, data):\n data = NUM_PATTERN.findall(data)\n if data:\n return int(data[0])\n return 0","def transform(s):\n return 'digit ' + str(s)","def sortValue(self, data):\n storedText = data.get(self.name, '')\n try:\n return GenNumber(storedText).num\n except GenNumberError:\n return ''","def name_to_taxid(name):\n name = name.replace(' ', '+').strip()\n search = Entrez.esearch(term=name, db='taxonomy', retmode='xml')\n return Entrez.read(search)['IdList'][0]","def output_name_to_id(self, name):\n for i, o in list(r.outputs.items()):\n if o.name == name:\n return i","def __file_from_str_to_int(rank: str) -> int:\n # Warning, my own, not very well tested implementation of base26 converter\n values = []\n for letter in rank:\n values.append(ascii_lowercase.index(letter.lower()))\n index_value = 0\n counter = 0\n for value in reversed(values):\n if counter < 1:\n index_value += value\n else:\n index_value += (value * 26) ** counter\n counter += 1\n return index_value","def pitch_name_to_base40(name):\n validate_pitch_name(name)\n base40 = letter_to_base40(name[0])\n base40 += name.count('#') - name.count('b')\n base40 += int(name.replace('#', '').replace('b', '')[1:]) * 40\n return base40","def numbers2words():\n\tmy_num = None\n\twhile my_num != \"0\":\n\t\tmy_num = input(\"Please enter a number greater than 0 and less than 1 trillion: \")\n\t\tprint(name_num(int(my_num.replace(\",\",\"\"))))","def symb_to_num(symbolic):\n\n if len(symbolic) == 9:\n group = (symbolic[:-6], symbolic[3:-3], symbolic[6:])\n try:\n numeric = notation[group[0]] + notation[group[1]] + notation[group[2]]\n except:\n numeric = \"Invalid Symbolic Representation!\"\n else:\n numeric = \"Symbolic input should be of lengh 9!\"\n\n return numeric","def spelled_num_to_digits(spelled_num):\n words = re.split(r\",?\\s+|-\", spelled_num.lower())\n major = 0\n units = 0\n for w in words:\n x = SMALL.get(w, None)\n if x is not None:\n units += x\n elif w == \"hundred\":\n units *= 100\n elif w == \"and\":\n continue\n else:\n x = MAGNITUDE.get(w, None)\n if x is not None:\n major += units * x\n units = 0\n else:\n raise NumberException(\"Unknown number: %s\" % w)\n return major + units","def get_image_index(name: str):\n base_name = os.path.basename(name)\n nums = pattern.findall(base_name)\n if len(nums) != num_count:\n raise BaseException(f\"can't exact index from the string: {name}\")\n return float(nums[num_sort_index])"],"string":"[\n \"def name_to_number(self, name):\\r\\n try:\\r\\n return self._numbers[name]\\r\\n except KeyError:\\r\\n raise KeyError(\\\"No field named %s in %r\\\" % (name, self._numbers.keys()))\",\n \"def name_to_number(name):\\r\\n \\r\\n if name == \\\"rock\\\":\\r\\n return 0\\r\\n elif name == \\\"Spock\\\":\\r\\n return 1\\r\\n elif name == \\\"paper\\\":\\r\\n return 2\\r\\n elif name == \\\"lizard\\\":\\r\\n return 3\\r\\n elif name == \\\"scissors\\\":\\r\\n return 4\\r\\n else:\\r\\n return \\\"Invalid!Enter any one of the following: rock,Spock,paper,lizard,scissors\\\"\",\n \"def name_to_number(name):\\n if (name == 'rock' or name == 'Rock'):\\n return 0\\n elif (name == 'Spock' or name == 'spock'):\\n return 1\\n elif (name == 'paper' or name == 'Paper'):\\n return 2\\n elif (name == 'lizard' or name == 'Lizard'):\\n return 3\\n elif (name == 'scissors' or name == 'Scissors'):\\n return 4\\n else:\\n return -1\",\n \"def name_to_number(name):\\n\\n # A simple if/elif/else game...\\n\\n if name == \\\"rock\\\":\\n number = 0\\n elif name == \\\"Spock\\\":\\n number = 1\\n elif name == \\\"paper\\\":\\n number = 2\\n elif name == \\\"lizard\\\":\\n number = 3\\n else:\\n number = 4\\n return number\",\n \"def getNameNum(name):\\n dicto = {'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':10,'k':11,'l':12,'m':13,'n':14,'o':15,'p':16,'q':17,'r':18,'s':19,'t':20,'u':21,'v':22,'w':23,'x':24,'y':25,'z':26}\\n summ = 0\\n for letter in name:\\n summ += dicto.get(letter.lower())\\n return summ\",\n \"def atomic_number(name):\\n try:\\n return symbols.index(name.capitalize()) + 1\\n except ValueError:\\n return lower_names.index(name.lower()) + 1\",\n \"def getNumberFromName(self, idx):\\n\\t\\tfile = self.all_file_names[idx]\\n\\t\\tnumber = file[4]\\n\\t\\tif file[5].isdigit(): \\n\\t\\t\\tnumber += file[5]\\n\\t\\treturn int(number)\",\n \"def name2digits(name):\\n \\n name = name.lower()\\n \\n if len(name)>25:\\n name = name[0:25]\\n \\n primenumbers = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]\\n \\n n = len(name)\\n \\n s = 0.0\\n \\n for i in range(n):\\n s += primenumbers[i]*ord(name[i])*2.0**(i+1)\\n\\n import scipy.io.matlab\\n Data = scipy.io.matlab.loadmat('hash.mat',struct_as_record=True)\\n x = Data['x']\\n t = int(np.mod(s,x.shape[0]))\\n\\n return np.sort(x[t,:])\",\n \"def value(name):\\r\\n return sum(alpha.index(str(l)) + 1 for l in name)\",\n \"def to_number(self, id):\\r\\n if isinstance(id, int):\\r\\n return id\\r\\n else:\\r\\n return self.name_to_number(id)\",\n \"def parse_num(path):\\n nbasename = path.basename.lower()\\n if nbasename.startswith(nprefix):\\n try:\\n return int(nbasename[len(nprefix) :])\\n except ValueError:\\n pass\",\n \"def to_ordinal(self):\\n return mod(self.number - 1 + 39 * (self.number - self.name), 260)\",\n \"def increment_name(name: str) -> str:\\n\\n match = _number_suffix.search(name)\\n if match:\\n number_str = match.group(1)\\n next_number = int(number_str) + 1\\n return f'{name[:-len(number_str)]}{next_number}'\\n else:\\n return f'{name}-1'\",\n \"def getNameIndex(name):\\n try:\\n location = len(name) - \\\"\\\".join(reversed(name)).index(\\\".\\\")\\n index = int(name[location:])\\n except Exception:\\n index = 0\\n return index\",\n \"def number_to_name(self, number):\\r\\n return self._names[number]\",\n \"def get_int(self, name):\\n return self.field(name).toInt()[0]\",\n \"def _compress_name(name):\\n n = 0\\n for c in name:\\n n = (n * _P1 + ord(c)) % _P2 \\n return '%09d' % n\",\n \"def number_to_name(number):\\n if number == 0:\\n name = \\\"rock\\\"\\n elif number == 1:\\n name = \\\"Spock\\\"\\n elif number == 2:\\n name = \\\"paper\\\"\\n elif number == 3:\\n name = \\\"lizard\\\"\\n elif number == 4:\\n name = \\\"scissors\\\"\\n else:\\n print \\\"Number is invalid!\\\"\\n return 1\\n return name\",\n \"def _name2idx(name):\\n match = re.search(r\\\"eth(\\\\d+)\\\", name, re.I)\\n if not match:\\n raise exception.CloudbaseInitException(\\n \\\"invalid NetworkDetails name {!r}\\\"\\n .format(name)\\n )\\n return int(match.group(1))\",\n \"def numerify_iso_label(lab):\\n from sage.databases.cremona import class_to_int\\n if 'CM' in lab:\\n return -1 - class_to_int(lab[2:])\\n else:\\n return class_to_int(lab.lower())\",\n \"def get_value(self):\\n if self.name in ['1','2','3','4','5','6','7','8', '9', '10']:\\n return int(self.name)\\n if self.name in ['J','Q','K']:\\n return 10\\n if self.name == 'A':\\n return 1\",\n \"def number_to_name(number):\\n for name, value in item_dict.items():\\n if number == value:\\n return name\",\n \"def port(name):\\n\\n words = name.upper().split('-', 1)\\n\\n if len(words) == 1:\\n words.append(words[0][1])\\n\\n return int(f\\\"{ord(words[0][0])}{ord(words[1][0])}\\\")\",\n \"def calculateValue(name):\\n\\tscore = 0\\n\\tfor c in name:\\n\\t\\tscore += ord(c) - ord('A') + 1\\n\\treturn score\",\n \"def order(name: str):\\n if name.startswith('pred'):\\n split = name.split('_')\\n if len(str(split[-2])) > 10: # New file format, -2 is hash\\n return int(split[-3])\\n return int(split[-2])\\n split = name.split('_')\\n x = split[-1].split('.')[0]\\n return int(x)\",\n \"def number(self):\\n return re.match(r'^.*?([0-9]+)$', self._alias).groups()[0]\",\n \"def updateName(g):\\n try:\\n n = int(g.group(2))\\n except TypeError:\\n n = 0\\n\\n return \\\"%s-%d\\\" % (g.group(1), n + 1)\",\n \"def MonthNum(name):\\n return _MONTH_DICT.get(name.capitalize(), 0)\",\n \"def numerize():\\n pass\",\n \"def word_to_number(nb_word):\\n return {\\n \\\"Zero\\\": 0,\\n \\\"One\\\": 1,\\n \\\"Two\\\": 2,\\n \\\"Three\\\": 3,\\n \\\"Four\\\": 4,\\n \\\"Five\\\": 5,\\n }[nb_word]\",\n \"def get_int(num, name='Number'):\\n try:\\n num = int(num)\\n except ValueError:\\n raise ValueError('{} must be an integer'.format(name))\\n\\n return num\",\n \"def get_number(atomname):\\n switch = False\\n number = ''\\n for char in atomname:\\n if char == ')':\\n switch = False\\n if switch:\\n number += char\\n if char == '(':\\n switch = True\\n return number\",\n \"def legislature_to_number(leg):\\n groups = re.match(r'^(\\\\d\\\\d)\\\\w+-(\\\\d\\\\d?)\\\\w+-(regular|special)', leg)\\n if groups:\\n return '%sLeg/%s%s' % (groups.group(1), groups.group(2), groups.group(3)[0])\",\n \"def to_int(name, default=0):\\n try:\\n return int(get(name))\\n except (TypeError, ValueError):\\n return default\",\n \"def name_to_id(self, name, add_if_missing=False):\\n if isinstance(name, basestring):\\n # lookup name or assign new\\n if name not in self.names:\\n if not add_if_missing:\\n raise ValueError(\\\"name \\\" + name + \\\" not found\\\")\\n # Use an empty slot in the list if one exists.\\n try:\\n id_ = self.names.index(None)\\n self.names[id_] = name\\n self.hashesperid[id_] = 0\\n except ValueError:\\n self.names.append(name)\\n self.hashesperid = np.append(self.hashesperid, [0])\\n id_ = self.names.index(name)\\n else:\\n # we were passed in a numerical id\\n id_ = name\\n return id_\",\n \"def extract_journal(name):\\n match = re.search(\\\"\\\\d+\\\", name)\\n if match != None: \\n return name[:match.start()], int(name[match.start(): match.end()])\\n else: \\n return \\\"\\\", 0\",\n \"def convert_charref(self, name):\\r\\n try:\\r\\n n = int(name)\\r\\n except ValueError:\\r\\n return\\r\\n if not 0 <= n <= 127 : # ASCII ends at 127, not 255\\r\\n return\\r\\n return self.convert_codepoint(n)\",\n \"def get_number(word):\\n return int(re.match(NUMBER, word).group(1))\",\n \"def string_to_number(col_name):\\n \\n return ( pl.col(col_name).str.replace_all('[\\\\$MBK]', '').cast(pl.Float64)\\n * pl.when(pl.col(col_name).str.ends_with('K'))\\n .then(pl.lit(1000))\\n .when(pl.col(col_name).str.ends_with('M'))\\n .then(pl.lit(1_000_000))\\n .when(pl.col(col_name).str.ends_with('B'))\\n .then(pl.lit(1_000_000_000))\\n .otherwise(pl.lit(1))\\n )\",\n \"def name_number(n):\\n num = str(n)\\n last_digits = [\\\"\\\", \\\"one\\\", \\\"two\\\", \\\"three\\\", \\\"four\\\", \\\"five\\\", \\\"six\\\", \\\"seven\\\", \\\"eight\\\", \\\"nine\\\", \\\"ten\\\", \\\"eleven\\\",\\n \\\"twelve\\\", \\\"thirteen\\\", \\\"fourteen\\\", \\\"fifteen\\\", \\\"sixteen\\\", \\\"seventeen\\\", \\\"eighteen\\\", \\\"nineteen\\\"]\\n tens = [\\\"twenty\\\", \\\"thirty\\\", \\\"forty\\\", \\\"fifty\\\", \\\"sixty\\\", \\\"seventy\\\", \\\"eighty\\\", \\\"ninety\\\"]\\n if n <= 19: # name numbers from 1 to 19 directly\\n c = last_digits[int(num[-2:])]\\n elif 19 < n < 100: # name numbers from 20 to 99 by concatenating name for tens digit with name for ones digit\\n c = tens[int(num[-2]) - 2] + last_digits[int(num[-1])]\\n elif n % 100 == 0 and n < 1000:\\n # name numbers from 100 to 900 that are divisible by 100 by taking number in hundreds place and concatenating\\n # with \\\"hundred\\\"\\n c = last_digits[int(num[0])] + \\\"hundred\\\"\\n elif n != 1000:\\n # name numbers from 100 to 999 excluding those divisible by 100 by taking number in hundreds place, adding\\n # \\\"hundredand\\\", then naming the other 2 decimal places recursively\\n c = last_digits[int(num[0])] + \\\"hundredand\\\" + name_number(n % 100)\\n else: # name 1000\\n c = \\\"onethousand\\\"\\n return c\",\n \"def onlynumbers(name):\\n return re.sub(\\\"[a-zA-Z:]\\\\(\\\\)\\\\:\\\",\\\"\\\",name)\",\n \"def number(self, label, component, config, name, default=None):\\n\\n value = self.text(label, component, config, name, default)\\n return int(value) if value else None\",\n \"def getNumber():\",\n \"def get_amount_of_digits(self, name: str):\\n x = -1\\n while name[x - 1].isdigit():\\n x -= 1\\n if name[:x].endswith(\\\"/streaming/p\\\"):\\n return x\",\n \"def get_following_name(self, name: Name):\\n name = str(name)\\n amount_of_digits = self.get_amount_of_digits(name)\\n number = int(name[amount_of_digits:])\\n number += 1\\n following_name = name[:amount_of_digits]\\n following_name += str(number)\\n return following_name\",\n \"def WeekdayNum(name):\\n return _WEEKDAY_DICT.get(name.capitalize(), 0)\",\n \"def getMangledNum(self):\\n return (\\\"X\\\" * (len(self.num)-4)) + self.num[-4:]\",\n \"def clean_numeric_column(name : float) -> float:\\n if name > -1 and name < 1:\\n name = 0\\n return name\",\n \"def key_to_numeric(x):\\n reg = re.compile(r'\\\\[(\\\\d+\\\\_?(\\\\d+)?)[a-z]?\\\\]')\\n inspect = reg.search(x).groups(0)[0]\\n if '_' in inspect:\\n left, right = inspect.split('_')\\n return int(left), int(right)\\n else:\\n return int(inspect), 0\",\n \"def convert_label_string2num(label, num_types):\\n dictionary = empty_label_dictionary(num_types)\\n all_labels = list(dictionary.keys())\\n if num_types==4:\\n label = label.replace('Implicit_', '')\\n label = label.replace('Explicit_', '')\\n return all_labels.index(label)\",\n \"def number(cls, tileName):\\n return TILENAMEMAP[tileName]['Number'] if tileName in TILENAMEMAP else None\",\n \"def regToInt(name):\\n match = re.match(r\\\"r([0-9]+)\\\", name)\\n if match:\\n index = int(match.group(1))\\n if 0 <= index <= 15:\\n return index\\n raise AsmException(\\\"incorrect register %s\\\" % name)\",\n \"def get_num_from_file(file_name):\\n basename = file_name.partition('.')[0]\\n first, second = basename.split('_')\\n num = second.replace(\\\"genome\\\", '')\\n num = num[1:]\\n return int(num)\",\n \"def letter_to_num(self, string, dict_):\\n #dict_= {'A': '0', 'C': '1', 'D': '2', 'E': '3', 'F': '4', 'G': '5', 'H': '6', 'I': '7', 'K': '8', 'L': '9', 'M': '10', 'N': '11', 'P': '12', 'Q': '13', 'R': '14', 'S': '15', 'T': '16', 'V': '17', 'W': '18', 'Y': '19'}\\n patt = re.compile('[' + ''.join(dict_.keys()) + ']')\\n num_string = patt.sub(lambda m: dict_[m.group(0)] + ' ', string)\\n #print(num_string)\\n #print(type(num_string))\\n num = [int(i) for i in num_string.split()]\\n return num\",\n \"def name_to_id(player_name):\\n # This is fairly unsophisticated, just does a CRC32 on the name. Can be\\n # optimized both for compute requirements and collision frequency using\\n # another hashing algorithm.\\n return binascii.crc32(player_name) & 0xFFFFFFFF\",\n \"def return_episode_num(name):\\n return int(name.split(\\\".\\\")[0].split(\\\"ep_\\\")[1]) # Use split to return only the episode number needed to sort the files in increasing order\",\n \"def _weight_name(self, name):\\n return name.split('/')[-1]\",\n \"def error_num_to_name(num):\\r\\n for t in ERROR_CODES:\\r\\n if t[0] == num:\\r\\n return t[1]\",\n \"def _name_increment_revision(name):\\n revre = r\\\"^(.*?)([0-9]+)$\\\"\\n m = re.search(revre, name)\\n if m:\\n name = m.group(1) + str(int(m.group(2)) + 1)\\n else:\\n name = name + \\\" (copy)\\\"\\n return name\",\n \"def _excel2num(x: str) -> int:\\n index = 0\\n\\n for c in x.upper().strip():\\n cp = ord(c)\\n\\n if cp < ord(\\\"A\\\") or cp > ord(\\\"Z\\\"):\\n raise ValueError(f\\\"Invalid column name: {x}\\\")\\n\\n index = index * 26 + cp - ord(\\\"A\\\") + 1\\n\\n return index - 1\",\n \"def typeToName(type: int) -> unicode:\\n ...\",\n \"def lvl_name2num(name):\\n try:\\n levelno = log_levels[name]\\n except KeyError:\\n logger.error(\\\"Log level not set: '%s' is not a valid level\\\", name)\\n logger.error(\\\"Fix the log level configuration\\\")\\n return logging.NOTSET\\n else:\\n return levelno\",\n \"def number_to_name(number):\\n \\n # A simple if/elif/else game...\\n\\n if number == 0:\\n name = \\\"rock\\\"\\n elif number == 1:\\n name = \\\"Spock\\\"\\n elif number == 2:\\n name = \\\"paper\\\"\\n elif number == 3:\\n name = \\\"lizard\\\"\\n else:\\n name = \\\"scissors\\\"\\n return name\",\n \"def translate_number(number):\\n return NUMBER_TRANSLATOR[number]\",\n \"def number_to_name(number):\\n if (number == 0):\\n name = 'rock'\\n return name\\n if (number == 1):\\n name = 'Spock'\\n return name\\n if (number == 2):\\n name = 'paper'\\n return name\\n if (number == 3):\\n name = 'lizard'\\n return name\\n if (number == 4):\\n name = 'scissors'\\n return name\\n else:\\n print \\\"ERROR: The choice of number is out of range!\\\"\",\n \"def w2n(word):\\n word = re.sub('[^A-Z0-9]', '', word)\\n return ''.join([letter_to_number_mapping[x] for x in word])\",\n \"def number_to_name(number):\\r\\n\\r\\n if number == 0:\\r\\n return \\\"rock\\\"\\r\\n elif number == 1:\\r\\n return \\\"Spock\\\"\\r\\n elif number == 2:\\r\\n return \\\"paper\\\"\\r\\n elif number == 3:\\r\\n return \\\"lizard\\\"\\r\\n elif number == 4:\\r\\n return \\\"scissors\\\"\\r\\n else:\\r\\n \\\"Invalid ! Enter a number from 0 to 4\\\"\",\n \"def letter_to_num(string, dict_):\\n patt = re.compile('[' + ''.join(dict_.keys()) + ']')\\n num_string = patt.sub(lambda m: dict_[m.group(0)] + ' ', string)\\n num = [int(i) for i in num_string.split()]\\n return num\",\n \"def pname(name):\\n ranks = list(reversed(name.split(';')))\\n for i, rank in enumerate(ranks):\\n if rank in ['Others', 'Unassigned']:\\n return rank\\n if rank == '__':\\n continue\\n if rank.split('__')[1] is '':\\n return ranks[i+1] + ';' + rank\\n return rank\",\n \"def __rank_from_str_to_int(rank: str) -> int:\\n return int(rank) - 1\",\n \"def _convert_name(self, name):\\n if not self.re_name.match(name):\\n org_name = name\\n name = self.re_white.sub('_', name)\\n name = self.re_alpha.sub('_', name)\\n if not self.re_name.match(name):\\n name = 'x_' + name2\\n self.warn('Converting name <' + org_name + '> to <' + name + '>.')\\n return name\",\n \"def dot_name(number):\\n\\tif number > 0:\\n\\t\\treturn \\\"P {}\\\".format(number)\\n\\telse:\\n\\t\\treturn \\\"O {}\\\".format(-number)\",\n \"def encode_label(label: str) -> int:\\n\\tif not label:\\n\\t\\treturn 0\\n\\t# part after letter if it has a number, otherwise 1\\n\\tindex = int(label[1:]) if len(label) > 1 else 1\\n\\t# A = 1, B = 2, ... E = 5\\n\\toffset = ord(label[0]) - ord(\\\"A\\\") + 1\\n\\t# compute label number\\n\\treturn (index - 1) * 5 + offset\",\n \"def _to_db_identifier(name):\\n return name.replace('-', '_')\",\n \"def _sanitize_to_identifer(name):\\n n = name.strip()\\n n = re.sub('/', ' ', n)\\n n = re.sub('-', ' ', n)\\n n = re.sub(' +', '_', n)\\n n = re.sub('[\\\\W]+', '', n)\\n return n\",\n \"def _get_freq(name):\\n try:\\n counts = int(name.split(\\\"_x\\\")[1])\\n except:\\n return 0\\n return counts\",\n \"def get_num_with_ordinal(num):\\n num_with_ordinal = str(num) + ordinal(num)\\n return num_with_ordinal\",\n \"def parse_quantity(quantity):\\n try:\\n code = int(quantity)\\n name = lookup(code)\\n except:\\n name = quantity\\n code = lookup(name)\\n return code, name\",\n \"def get_id(f):\\n name = f.split('/')[-1][-10:-4]\\n\\n score = int(''.join(filter(str.isdigit, f.split('/')[-1][2:]))) * 3 + 1\\n if name == 'real_A':\\n score += 1\\n if name == 'real_B':\\n score -= 1\\n\\n return score\",\n \"def meses_to_num(palabra):\\n \\n palabra = str(palabra)\\n meses_dict = {'Jan' : '01', 'Feb' : '02', 'Mar' : '03', 'Apr' : '04', 'May' : '05', 'Jun' : '06', 'Jul' : '07',\\n 'Aug' : '08', 'Sep' : '09', 'Oct' : '10', 'Nov' : '11', 'Dec' : '12',}\\n \\n palabra = palabra.strip()\\n for key, value in meses_dict.items():\\n if key in palabra:\\n palabra = palabra.replace(key, value)\\n \\n palabra = palabra.replace('-', '/')\\n return palabra\",\n \"def file_name_to_radar_num(saliency_file_name):\\n\\n error_checking.assert_is_string(saliency_file_name)\\n\\n pathless_file_name = os.path.split(saliency_file_name)[-1]\\n extensionless_file_name = os.path.splitext(pathless_file_name)[0]\\n radar_word = extensionless_file_name.split('_')[-1]\\n\\n assert radar_word.startswith('radar')\\n\\n radar_number = int(radar_word.replace('radar', ''))\\n error_checking.assert_is_geq(radar_number, 0)\\n\\n return radar_number\",\n \"def __to_key(name: str) -> str:\\n return name.replace(\\\" \\\", \\\"-\\\")\",\n \"def alpha_number(alpha):\\r\\n if alpha.isupper() == False:\\r\\n num = ord(alpha) - 96\\r\\n return num\\r\\n elif alpha.isupper() == True:\\r\\n num = ord(alpha) - 64\\r\\n return num\",\n \"def f_translate_key(self, key):\\n if isinstance(key, int):\\n if key == 0:\\n key = self.v_name\\n else:\\n key = self.v_name + \\\"_%d\\\" % key\\n return key\",\n \"def transform(s):\\r\\n return 'digit ' + str(s)\",\n \"def numerical_hue(hue):\\n if isinstance(hue, str):\\n match = hue_regex.match(hue)\\n if match:\\n return float(match[1]) + HUE_NAMES_TO_NUMBERS[match[3]]\\n else:\\n return float(hue)\\n return hue\",\n \"def visit_NumberNode(self, node: NumberNode, symbol_table: SymbolTable) -> String:\\n return Number(node.tok.value)\",\n \"def numeral(number):\\n return ROMAN_NUMERALS[number]\",\n \"def dec2int(r: str) -> int:\",\n \"def get_num(self, data):\\n data = NUM_PATTERN.findall(data)\\n if data:\\n return int(data[0])\\n return 0\",\n \"def transform(s):\\n return 'digit ' + str(s)\",\n \"def sortValue(self, data):\\n storedText = data.get(self.name, '')\\n try:\\n return GenNumber(storedText).num\\n except GenNumberError:\\n return ''\",\n \"def name_to_taxid(name):\\n name = name.replace(' ', '+').strip()\\n search = Entrez.esearch(term=name, db='taxonomy', retmode='xml')\\n return Entrez.read(search)['IdList'][0]\",\n \"def output_name_to_id(self, name):\\n for i, o in list(r.outputs.items()):\\n if o.name == name:\\n return i\",\n \"def __file_from_str_to_int(rank: str) -> int:\\n # Warning, my own, not very well tested implementation of base26 converter\\n values = []\\n for letter in rank:\\n values.append(ascii_lowercase.index(letter.lower()))\\n index_value = 0\\n counter = 0\\n for value in reversed(values):\\n if counter < 1:\\n index_value += value\\n else:\\n index_value += (value * 26) ** counter\\n counter += 1\\n return index_value\",\n \"def pitch_name_to_base40(name):\\n validate_pitch_name(name)\\n base40 = letter_to_base40(name[0])\\n base40 += name.count('#') - name.count('b')\\n base40 += int(name.replace('#', '').replace('b', '')[1:]) * 40\\n return base40\",\n \"def numbers2words():\\n\\tmy_num = None\\n\\twhile my_num != \\\"0\\\":\\n\\t\\tmy_num = input(\\\"Please enter a number greater than 0 and less than 1 trillion: \\\")\\n\\t\\tprint(name_num(int(my_num.replace(\\\",\\\",\\\"\\\"))))\",\n \"def symb_to_num(symbolic):\\n\\n if len(symbolic) == 9:\\n group = (symbolic[:-6], symbolic[3:-3], symbolic[6:])\\n try:\\n numeric = notation[group[0]] + notation[group[1]] + notation[group[2]]\\n except:\\n numeric = \\\"Invalid Symbolic Representation!\\\"\\n else:\\n numeric = \\\"Symbolic input should be of lengh 9!\\\"\\n\\n return numeric\",\n \"def spelled_num_to_digits(spelled_num):\\n words = re.split(r\\\",?\\\\s+|-\\\", spelled_num.lower())\\n major = 0\\n units = 0\\n for w in words:\\n x = SMALL.get(w, None)\\n if x is not None:\\n units += x\\n elif w == \\\"hundred\\\":\\n units *= 100\\n elif w == \\\"and\\\":\\n continue\\n else:\\n x = MAGNITUDE.get(w, None)\\n if x is not None:\\n major += units * x\\n units = 0\\n else:\\n raise NumberException(\\\"Unknown number: %s\\\" % w)\\n return major + units\",\n \"def get_image_index(name: str):\\n base_name = os.path.basename(name)\\n nums = pattern.findall(base_name)\\n if len(nums) != num_count:\\n raise BaseException(f\\\"can't exact index from the string: {name}\\\")\\n return float(nums[num_sort_index])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7741844","0.7352965","0.7345282","0.7291842","0.72166365","0.6983042","0.6895514","0.67996234","0.67324436","0.66536355","0.65847605","0.6520935","0.6479899","0.6476801","0.64197266","0.64054585","0.6389672","0.6386971","0.63465","0.6332023","0.6235999","0.6227278","0.6225469","0.62196875","0.6218752","0.6209326","0.62035465","0.6184146","0.6180978","0.6160741","0.6159615","0.61428046","0.61172926","0.61134636","0.61078805","0.60610926","0.60574037","0.6049775","0.60336256","0.6027566","0.60075885","0.60070235","0.5993981","0.59919524","0.59770393","0.59757036","0.5973215","0.59724975","0.5964511","0.59482986","0.5946346","0.58945936","0.5892323","0.5869831","0.5835476","0.5821037","0.5788647","0.57885504","0.57776874","0.577248","0.576712","0.5755153","0.5751252","0.57491064","0.57476705","0.5737786","0.5733744","0.5726474","0.57142335","0.5692023","0.56918204","0.56853694","0.5678457","0.5672859","0.5672273","0.56670374","0.56611156","0.5659979","0.56586564","0.5653218","0.5646388","0.56381017","0.56379884","0.56308216","0.5625985","0.56040376","0.560342","0.55997765","0.5575809","0.5575722","0.55680573","0.5565189","0.55597705","0.5554684","0.5546855","0.55343145","0.5534254","0.5521073","0.5500746","0.5494947"],"string":"[\n \"0.7741844\",\n \"0.7352965\",\n \"0.7345282\",\n \"0.7291842\",\n \"0.72166365\",\n \"0.6983042\",\n \"0.6895514\",\n \"0.67996234\",\n \"0.67324436\",\n \"0.66536355\",\n \"0.65847605\",\n \"0.6520935\",\n \"0.6479899\",\n \"0.6476801\",\n \"0.64197266\",\n \"0.64054585\",\n \"0.6389672\",\n \"0.6386971\",\n \"0.63465\",\n \"0.6332023\",\n \"0.6235999\",\n \"0.6227278\",\n \"0.6225469\",\n \"0.62196875\",\n \"0.6218752\",\n \"0.6209326\",\n \"0.62035465\",\n \"0.6184146\",\n \"0.6180978\",\n \"0.6160741\",\n \"0.6159615\",\n \"0.61428046\",\n \"0.61172926\",\n \"0.61134636\",\n \"0.61078805\",\n \"0.60610926\",\n \"0.60574037\",\n \"0.6049775\",\n \"0.60336256\",\n \"0.6027566\",\n \"0.60075885\",\n \"0.60070235\",\n \"0.5993981\",\n \"0.59919524\",\n \"0.59770393\",\n \"0.59757036\",\n \"0.5973215\",\n \"0.59724975\",\n \"0.5964511\",\n \"0.59482986\",\n \"0.5946346\",\n \"0.58945936\",\n \"0.5892323\",\n \"0.5869831\",\n \"0.5835476\",\n \"0.5821037\",\n \"0.5788647\",\n \"0.57885504\",\n \"0.57776874\",\n \"0.577248\",\n \"0.576712\",\n \"0.5755153\",\n \"0.5751252\",\n \"0.57491064\",\n \"0.57476705\",\n \"0.5737786\",\n \"0.5733744\",\n \"0.5726474\",\n \"0.57142335\",\n \"0.5692023\",\n \"0.56918204\",\n \"0.56853694\",\n \"0.5678457\",\n \"0.5672859\",\n \"0.5672273\",\n \"0.56670374\",\n \"0.56611156\",\n \"0.5659979\",\n \"0.56586564\",\n \"0.5653218\",\n \"0.5646388\",\n \"0.56381017\",\n \"0.56379884\",\n \"0.56308216\",\n \"0.5625985\",\n \"0.56040376\",\n \"0.560342\",\n \"0.55997765\",\n \"0.5575809\",\n \"0.5575722\",\n \"0.55680573\",\n \"0.5565189\",\n \"0.55597705\",\n \"0.5554684\",\n \"0.5546855\",\n \"0.55343145\",\n \"0.5534254\",\n \"0.5521073\",\n \"0.5500746\",\n \"0.5494947\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7410772"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":76087,"cells":{"query":{"kind":"string","value":"convert number to name"},"document":{"kind":"string","value":"def number_to_name(number):\n if number == 0:\n name = \"rock\"\n elif number == 1:\n name = \"Spock\"\n elif number == 2:\n name = \"paper\"\n elif number == 3:\n name = \"lizard\"\n elif number == 4:\n name = \"scissors\"\n else:\n print \"Number is invalid!\"\n return 1\n return name"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def number_to_name(self, number):\r\n return self._names[number]","def number_to_name(number):\r\n\r\n if number == 0:\r\n return \"rock\"\r\n elif number == 1:\r\n return \"Spock\"\r\n elif number == 2:\r\n return \"paper\"\r\n elif number == 3:\r\n return \"lizard\"\r\n elif number == 4:\r\n return \"scissors\"\r\n else:\r\n \"Invalid ! Enter a number from 0 to 4\"","def name_number(n):\n num = str(n)\n last_digits = [\"\", \"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\", \"eight\", \"nine\", \"ten\", \"eleven\",\n \"twelve\", \"thirteen\", \"fourteen\", \"fifteen\", \"sixteen\", \"seventeen\", \"eighteen\", \"nineteen\"]\n tens = [\"twenty\", \"thirty\", \"forty\", \"fifty\", \"sixty\", \"seventy\", \"eighty\", \"ninety\"]\n if n <= 19: # name numbers from 1 to 19 directly\n c = last_digits[int(num[-2:])]\n elif 19 < n < 100: # name numbers from 20 to 99 by concatenating name for tens digit with name for ones digit\n c = tens[int(num[-2]) - 2] + last_digits[int(num[-1])]\n elif n % 100 == 0 and n < 1000:\n # name numbers from 100 to 900 that are divisible by 100 by taking number in hundreds place and concatenating\n # with \"hundred\"\n c = last_digits[int(num[0])] + \"hundred\"\n elif n != 1000:\n # name numbers from 100 to 999 excluding those divisible by 100 by taking number in hundreds place, adding\n # \"hundredand\", then naming the other 2 decimal places recursively\n c = last_digits[int(num[0])] + \"hundredand\" + name_number(n % 100)\n else: # name 1000\n c = \"onethousand\"\n return c","def number_to_name(number):\n \n # A simple if/elif/else game...\n\n if number == 0:\n name = \"rock\"\n elif number == 1:\n name = \"Spock\"\n elif number == 2:\n name = \"paper\"\n elif number == 3:\n name = \"lizard\"\n else:\n name = \"scissors\"\n return name","def number_to_name(number):\n for name, value in item_dict.items():\n if number == value:\n return name","def number_to_name(number):\n if (number == 0):\n name = 'rock'\n return name\n if (number == 1):\n name = 'Spock'\n return name\n if (number == 2):\n name = 'paper'\n return name\n if (number == 3):\n name = 'lizard'\n return name\n if (number == 4):\n name = 'scissors'\n return name\n else:\n print \"ERROR: The choice of number is out of range!\"","def _num2str(self, num):\n q, mod = divmod(num, 10)\n suffix = \"th\" if q == 1 else self.SUFFIX_DICT[mod]\n return f\"{num}{suffix}\"","def typeToName(type: int) -> unicode:\n ...","def dot_name(number):\n\tif number > 0:\n\t\treturn \"P {}\".format(number)\n\telse:\n\t\treturn \"O {}\".format(-number)","def error_num_to_name(num):\r\n for t in ERROR_CODES:\r\n if t[0] == num:\r\n return t[1]","def getHubName(num):\n baseNum = num % 1000\n if baseNum > 0 and baseNum < 100:\n return \"%02d\" % baseNum\n if baseNum > 200 and baseNum < 220:\n return \"%02dt\" % (baseNum - 200)\n return \"?%d?\" % baseNum","def _build_name(name_id):\n return \"xp_%08d\" % name_id","def translate_number(number):\n return NUMBER_TRANSLATOR[number]","def spell_number(num):\n tens, units = num / 10, num % 10\n tens_str = NUMBERS_10[tens]\n units_str = NUMBERS_1[units]\n if tens == 1:\n return NUMBERS_TEEN[units]\n elif tens:\n if units:\n return \"{t} {u}\".format(t=tens_str, u=units_str)\n return \"{t}\".format(t=tens_str)\n else:\n return units_str","def name(self):\n return '#{}'.format(self.number)","def build_track_name(track, number = ''):\n\n name = ''\n if number:\n name += number\n name += ' - '\n name += track\n return name","def network_id_to_name(network_id: int) -> str:\n return {\n 1: \"main\",\n 3: \"ropsten\",\n 4: \"rinkeby\",\n 5: \"goerli\",\n 42: \"kovan\",\n 100: \"xdai\",\n 56: \"bsc-main\",\n }[network_id]","def convert(number):\n out = \"\"\n if number % 3 == 0:\n out = \"Pling\"\n if number % 5 == 0:\n out = out + \"Plang\"\n if number % 7 == 0:\n out = out + \"Plong\"\n if out == \"\":\n out = str(number)\n return out","def num(number: int) -> str:\n numbers = {1: \"one\", 2: \"two\", 3: \"three\", 4: \"four\", 5: \"five\",\n 6: \"six\", 7: \"seven\", 8: \"eight\", 9: \"nine\", 10: \"ten\"}\n if number in numbers:\n return numbers[number]\n else:\n return f\"{number:,}\"","def convert_label_num2string(number, num_types):\n dictionary = empty_label_dictionary(num_types)\n all_labels = list(dictionary.keys())\n return all_labels[number]","def get_name(self, suffix_number: int = 0) -> str:\n if suffix_number:\n return f\"{self.name}_{suffix_number}\"\n return cast(str, self.name)","def get_name(self):\n names = (\n None,\n 'January', 'February', 'March',\n 'April', 'May', 'June',\n 'Juli', 'August', 'September',\n 'October', 'November', 'December',\n )\n return names[self.number]","def div_to_name(a):\r\n div_dict = {'1':\"Men\", '2':\"Women\", '3':\"Men_45-49\", '4':\"Women_45-49\", \r\n '5':\"Men_50-54\", '6':\"Women_50-54\", '7':\"Men_55-59\",\r\n '8':\"Women_55-59\", '9':\"Men_60+\", '10':\"Women_60+\",\r\n '11':\"Team\", '12':\"Men_40-44\", '13':\"Women_40-44\",\r\n '14':\"Boys_14-15\", '15':\"Girls_14-15\", '16':\"Boys_16-17\",\r\n '17':\"Girls_16-17\", '18':\"Men_35-39\", '19':\"Women_35-39\"}\r\n return div_dict[str(a)]","def convert_number(number):\n return ' ' + ' '.join(list(int_to_roman(number))) + ' '","def name(self):\n return '{:.2f}_{:d}_{:s}_{:d}'.format(self.A, self.Z,\n self.species, self.C)","def monthName(self, num):\n \n monthNames = {\n '1': 'January',\n '2': 'February',\n '3': 'March',\n '4': 'April',\n '5': 'May',\n '6': 'June',\n '7': 'July',\n '8': 'August',\n '9': 'September',\n '10': 'October',\n '11': 'November',\n '12': 'December'}\n \n return monthNames[num.lstrip('0')]","def f_translate_key(self, key):\n if isinstance(key, int):\n if key == 0:\n key = self.v_name\n else:\n key = self.v_name + \"_%d\" % key\n return key","def get_num_with_ordinal(num):\n num_with_ordinal = str(num) + ordinal(num)\n return num_with_ordinal","def getMangledNum(self):\n return (\"X\" * (len(self.num)-4)) + self.num[-4:]","def class_num_to_name(class_num):\n all_hues = cfg.ALL_HUE_VALUES.keys()\n all_hues.sort()\n hue = all_hues[class_num]\n color_name = cfg.ALL_HUE_VALUES[hue]\n return color_name","def transforme(n):\n if n<10 :\n return '0'+str(n)\n else :\n return str(n)","def increment_name(name: str) -> str:\n\n match = _number_suffix.search(name)\n if match:\n number_str = match.group(1)\n next_number = int(number_str) + 1\n return f'{name[:-len(number_str)]}{next_number}'\n else:\n return f'{name}-1'","def ordinal_label(n):\n n = int(n)\n return \"%d%s\" % (n,\"tsnrhtdd\"[(n/10%10!=1)*(n%10<4)*n%10::4])","def scaled_to_name(a):\r\n wt_list = ['Rx','Sc']\r\n return wt_list[a]","def transform(s):\r\n return 'digit ' + str(s)","def number_as_string(x):\n \n numnames = {1 : \"one\", 2 : \"two\", 3 : \"three\", 4 : \"four\", 5 : \"five\", 6 : \"six\", 7 : \"seven\", 8 : \"eight\", 9 : \"nine\",\n 10 : \"ten\", 11 : \"eleven\", 12 : \"twelve\", 13 : \"thirteen\", 14 : \"fourteen\", 15 : \"fifteen\", 16 : \"sixteen\",\n 17 : \"seventeen\", 18 : \"eighteen\", 19 : \"nineteen\", 20 : \"twenty\", 30 : \"thirty\", 40 : \"forty\", 50 : \"fifty\", \n 60 : \"sixty\", 70 : \"seventy\", 80 : \"eighty\", 90 : \"ninety\"}\n \n numparts = []\n needAnd = (x > 100) and (x % 100)\n if x >= 1000:\n numparts.append(numnames[x/1000])\n numparts.append(\"thousand\")\n x %= 1000\n \n if x >= 100:\n numparts.append(numnames[x/100])\n numparts.append(\"hundred\")\n x %= 100\n \n if needAnd:\n numparts.append(\"and\")\n \n if 11 <= x <= 19:\n numparts.append(numnames[x])\n else:\n if x >= 10:\n numparts.append(numnames[(x/10)*10])\n x %= 10\n\n if x > 0:\n numparts.append(numnames[x])\n \n return \" \".join(numparts)","def numbers2words():\n\tmy_num = None\n\twhile my_num != \"0\":\n\t\tmy_num = input(\"Please enter a number greater than 0 and less than 1 trillion: \")\n\t\tprint(name_num(int(my_num.replace(\",\",\"\"))))","def transform(s):\n return 'digit ' + str(s)","def MAKE_NAME(name):\n name = name.replace('$', 'DOLLAR')\n name = name.replace('.', 'DOT')\n if name.startswith('__'):\n return '_X' + name\n elif name[0] in '01234567879':\n return '_' + name\n return name","def type_number(number: float):\n # TODO: Allow leading zeros\n for char in str(number):\n actions.key(char)","def convert_numtoletter(n):\r\n L = seats[0][n-1] #letter\r\n return L","def translateNumber(n):\r\n if type(n) != str:\r\n return None\r\n else:\r\n translation = \"\"\r\n word = \"\"\r\n for c in n:\r\n if c != ' ':\r\n word += c\r\n elif word in Numbers:\r\n translation += Numbers[word] + \" \"\r\n else:\r\n translation += word + \" \"\r\n return translation","def updateName(g):\n try:\n n = int(g.group(2))\n except TypeError:\n n = 0\n\n return \"%s-%d\" % (g.group(1), n + 1)","def GetUniqueName( name, elems ):\n digits = []\n for c in reversed( name ):\n if c.isdigit():\n digits.append( c )\n else:\n break\n \n stem = name[0:len( name ) - len( digits )]\n val = ''.join( digits )[::-1] or 0\n i = int( val )\n \n while True:\n i += 1\n newName = ''.join( [stem, str( i )] )\n if newName not in elems:\n break\n \n return newName","def number_route(n):\n return \"{:d} is a number\".format(n)","def hbnb_number_route(num):\n return '{} is a number'.format(num)","def numToStrLabel(self, value):\n zero_count = 3 - len(str(value))\n return zero_count * \"0\" + str(value)","def name_func(func, num, params):\n return \"%s_%s_%s\" % (\n func.__name__, int(num),\n parameterized.to_safe_name('_'.join((params.args[0].__name__, params.args[1].__name__)))\n )","def WWRomanNumber(number):\r\n\t\r\n\tif number>4999 or number<1:\r\n\t\traise OverflowError(\"The should be between 1 and 4999, here it is \"+str(number))\r\n\tnumerals = { 1 : \"I\", 4 : \"IV\", 5 : \"V\", 9 : \"IX\", 10 : \"X\", 40 : \"XL\",\r\n\t\t\t\t50 : \"L\", 90 : \"XC\", 100 : \"C\", 400 : \"CD\", 500 : \"D\", 900 : \"CM\", 1000 : \"M\" }\r\n\tresult = \"\"\r\n\tfor value, numeral in sorted(numerals.items(), reverse=True):\r\n\t\twhile number >= value:\r\n\t\t\tresult += numeral\r\n\t\t\tnumber -= value\r\n\treturn result","def convNumToCard(cardNum):\n\n\tcardDict = {14:\"A\", 13:\"K\", 12:\"Q\", 11:\"J\"}\n\n\tif cardNum > 10:\n\t\treturn cardDict[cardNum]\n\telse: return str(cardNum)","def format_resname(row,num):\n resid = row['resid'+num].split(':')[-1]\n gennum = row['resid'+num+'_gennum']\n return(\"%s (%s)\"%(resid,gennum))","def numeral(number):\n return ROMAN_NUMERALS[number]","def english(number):\r\n if number == 0:\r\n return 'zero'\r\n word = ''\r\n for step in itertools.count():\r\n number, rest = divmod(number, 1000)\r\n word = format_num(en3(rest), step) + word\r\n if number == 0:\r\n return word.strip()","def name_id(self, fn:str='Jane',ln:str='Dear',sec:int=5):\n code = '[0-9]{4:%s}'% int(sec)\n return f\"{fn[0].capitalize()}{ln[0].capitalize()}{StringGenerator(str(code)).render(unique=True)}\"","def make_frame_name(frame_num):\n return str(frame_num).zfill(3) + '.jpg'","def _compress_name(name):\n n = 0\n for c in name:\n n = (n * _P1 + ord(c)) % _P2 \n return '%09d' % n","def apnumber(value):\r\n try:\r\n value = int(value)\r\n except (TypeError, ValueError):\r\n return value\r\n if not 0 < value < 10:\r\n return str(value)\r\n return (_('one'), _('two'), _('three'), _('four'), _('five'), _('six'),\r\n _('seven'), _('eight'), _('nine'))[value - 1]","def ordinal(number: int):\n if type(number) != int:\n raise TypeError\n else:\n if 11 <= number <= 20 or number % 10 == 0:\n return str(number) + 'th'\n elif number % 10 == 1:\n return str(number) + 'st'\n elif number % 10 == 2:\n return str(number) + 'nd'\n elif number % 10 == 3:\n return str(number) + 'rd'\n else:\n return str(number) + 'th'","def errorNumToName(self, errorCode):\n for t in self.ERROR_CODES:\n if t[0] == errorCode:\n return t[1]","def only_ordinal(number):\n _ordinal = lambda n: \"%s\" % (\"tsnrhtdd\"[(n/10%10!=1)*(n%10<4)*n%10::4]) # some black magic.\n return _ordinal(number)","def serialize_number(n):\n return str(n)","def _gennames(prefix, base, number):\n for index in xrange(number):\n yield \"%s%d\" % (prefix, base + index)","def dump_with_name(self, id_to_name):\n return str(id_to_name[self.player]) + str(self._num)","def internal_id_to_display_id(i_id: int) -> str:\n i_id = str(i_id).zfill(9)\n return ''.join(i_id[x - 1] for x in [1, 5, 9, 6, 3, 8, 2, 4, 7])","def tranfer_unit(number):\n count = 0\n unit_name = \"\"\n if 2 ** 20 > number > 2 ** 10:\n unit_name = \"Kb\"\n count = 1\n elif 2 ** 30 > number > 2 ** 20:\n unit_name = \"Mb\"\n count = 2\n elif number > 2 ** 30:\n unit_name = \"Gb\"\n count = 3\n else:\n unit_name = \"b\"\n if count != 0:\n unit_number = round(number / ((2 ** 10) ** count), 2)\n else:\n unit_number = round(number, 2)\n unit_str = \"{num}{name}\".format(num=unit_number, name=unit_name)\n return unit_str","def _name(self, upcase = True):\n s = ''\n if self.Z >= 0:\n if upcase:\n s = Elements[self.Z]\n else:\n s = elements[self.Z]\n if self.F & self.F_GROUP_MASK == self.F_ISOBAR:\n s = 'A:'\n if self.F & self.F_GROUP_MASK == self.F_ISOTONE:\n s = 'N:'\n if self.A != 0 or (self.F & self.F_GROUP_MASK == self.F_ISOTONE):\n s += \"{:d}\".format(self.A)\n if self.A == 1 and self.Z == 0 and (self.F & self.F_GROUP_MASK == self.F_ISOTOPE):\n s = 'n'\n if self.F & self.F_GROUP_MASK == self.F_ISOMER:\n if self.A == 0 and self.Z == 0:\n if self.E == 1:\n s = 'g'\n else:\n s = 'g{:d}'.format(self.E)\n else:\n s += self.isomer_name(self.E)\n if self.F & self.F_GROUP_MASK == self.F_BOSON:\n if self.A == 0 and self.Z == 0:\n if self.E == 1:\n s = 'g'\n else:\n s = 'g{:d}'.format(self.E)\n else:\n raise NotImplementedError()\n s = self._SPECIAL.get(self.idx, s)\n return s","def name(self, obj, index=0):\n if hasattr(obj, 'id'):\n uid = obj.id.replace('material', 'm')\n else:\n self._namecount += 1\n uid = 'Untitled.' + str(self._namecount)\n base = '%s-%d' % (uid, index)\n if base not in self._names:\n self._namecount += 1\n self._names[base] = '%s-%.4d' % (base[:MAX_NAME_LENGTH], self._namecount)\n return self._names[base]","def ordinal(number):\n _ordinal = lambda n: \"%d%s\" % (n,\"tsnrhtdd\"[(n/10%10!=1)*(n%10<4)*n%10::4]) # some black magic.\n return _ordinal(number)","def _format(self, id_num: int) -> typing.Union[int, str]:\n return id_num","def number_to_name(scheme: ColorScheme | ColorSchemeShort, n: int) -> str:\n mod = get_palette_module(scheme)\n names = mod.__all__\n if n > len(names):\n raise ValueError(\n f\"There are only '{n}' palettes of type {scheme}. \"\n f\"You requested palette no. {n}\"\n )\n return names[n - 1]","def _convert_name(self, name):\n if not self.re_name.match(name):\n org_name = name\n name = self.re_white.sub('_', name)\n name = self.re_alpha.sub('_', name)\n if not self.re_name.match(name):\n name = 'x_' + name2\n self.warn('Converting name <' + org_name + '> to <' + name + '>.')\n return name","def shorten_number(self, number):\n if number < 1000:\n return number\n elif number >= 1000 and number < 1000000:\n num = self.rounded_number(number, 1000)\n val = \"1M\" if num == \"1000\" else num + \"K\"\n return val\n elif number >= 1000000 and number < 1000000000:\n num = self.rounded_number(number, 1000000)\n val = \"1B\" if num==\"1000\" else num + \"M\"\n return val\n elif number >= 1000000000 and number < 1000000000000:\n num = self.rounded_number(number, 1000000000)\n val = \"1T\" if num==\"1000\" else num + \"B\"\n return val\n else:\n num = self.rounded_number(number, 1000000000000)\n return num + \"T\"","def _build_name(name_idx):\n return \"explored%s.set_%05d.xa_%08d\" % (\n ArrayParameter.IDENTIFIER,\n name_idx // 1000,\n name_idx,\n )","def number_conversion(number):\n units = ['', 'K', 'M', 'G', 'T', 'P']\n k = 1000.0\n magnitude = int(floor(log(number, k)))\n return '%.2f%s' % (number / k**magnitude, units[magnitude])","def MakeHumanReadable(num):\n i = 0\n while i+1 < len(EXP_STRINGS) and num >= (2 ** EXP_STRINGS[i+1][0]):\n i += 1\n rounded_val = round(float(num) / 2 ** EXP_STRINGS[i][0], 2)\n return '%s %s' % (rounded_val, EXP_STRINGS[i][1])","def generate_name(self, name):\n return \"{}/{}.{}\".format(self.name, self._layer_counter, name)","def to_ordinal(self):\n return mod(self.number - 1 + 39 * (self.number - self.name), 260)","def get_following_name(self, name: Name):\n name = str(name)\n amount_of_digits = self.get_amount_of_digits(name)\n number = int(name[amount_of_digits:])\n number += 1\n following_name = name[:amount_of_digits]\n following_name += str(number)\n return following_name","def makeNonStereoName(molType, name, n=None):\n\n match = re.match('(\\w+)(\\d|\\'+)(\\D*)', name)\n \n if not match:\n #print molType, name, n\n return \n \n \n letters = match.group(1)\n number = match.group(2)\n prime = ''\n \n if number == '\\'':\n number = 1\n prime = '\\''\n elif number == '\\'\\'':\n number = 2\n prime = '\\''\n \n if n is None:\n n = int(number) - 1\n\n name = letters + prime + chr(ord('a')+n)+ match.group(3)\n \n return name","def generate_resource_name(id_num):\n return 'sweeper{0}i{1}'.format(id_num, str(uuid.uuid4())[0:8])","def getName(self):\n\n if self.vel == 0:\n return \"Rest\"\n\n order = self.nbr % 12 # Position in octave (Ex: 0 - C, 1 - C#,...)\n return ['C', 'C#/Db', 'D', 'D#/Eb',\n 'E', 'F', 'F#/Gb', 'G',\n 'G#/Ab', 'A', 'A#/Bb', 'B'][order]","def convert_number_to_excel_colname(n):\n\n assert 0 < n <= 256\n\n alphabet = [chr(x) for x in xrange(65, 91)]\n\n if n > 26:\n return '{0}{1}'.format(alphabet[(n/26) - 1], alphabet[(n%26) - 1])\n else:\n return alphabet[(n%26) - 1]","def cvt_to_readable(num):\n\n # Find the degree of the number like if it is in thousands or millions, etc.\n index = int(math.log(num) / math.log(1000))\n\n # Converts the number to the human readable format and returns it.\n newNum = round(num / (1000 ** index), 3)\n degree = UNITS[index]\n\n return (newNum, degree)","def name_to_number(name):\n if name == \"rock\":\n number = 0\n elif name == \"Spock\":\n number = 1\n elif name == \"paper\":\n number = 2\n elif name == \"lizard\":\n number = 3\n elif name == \"scissors\":\n number = 4\n else:\n print \"Name is invalid!\"\n return 1\n return number","def seq_name(seq):\n if len(seq) == 1:\n return cp_name(seq[0])\n return 'u' + '_'.join('%04X' % cp for cp in seq)","def textualize(num):\n if isinstance(num, float):\n num = int(num)\n # special case\n if num == 0:\n return 'zero'\n\n # if the number is negative, we put the word\n # 'negative' in front of it.\n is_negative = False\n if num < 0:\n is_negative = True\n num = -1 * num\n\n num = str(num)\n # pad with zeroes\n while len(num) % 3 != 0:\n num = ''.join([ '0', num ])\n\n # as groups are textualized, their strings will be\n # appended to this list\n num_string = []\n group_counter = 0\n while len(num) > 0:\n group = num[-3:]\n num = num[:-3]\n text = _textualize_group(group)\n\n # thousand, million, etc.\n if group_counter > 0 and text:\n group_name = group_names[group_counter]\n text = ' '.join([ text, group_name ])\n\n if text:\n num_string.insert(0, text)\n\n group_counter += 1\n\n if is_negative:\n num_string.insert(0, 'negative')\n\n return ' '.join(num_string)","def pname(name):\n ranks = list(reversed(name.split(';')))\n for i, rank in enumerate(ranks):\n if rank in ['Others', 'Unassigned']:\n return rank\n if rank == '__':\n continue\n if rank.split('__')[1] is '':\n return ranks[i+1] + ';' + rank\n return rank","def name(self):\n return 'D07 Indice de calidad de vida por manzanas'","def get_name() -> str:","def convert(num):\r\n if len(str(num))==1:\r\n return \"000%i\"%num\r\n elif len(str(num)) == 2:\r\n return \"00%i\"%num\r\n elif len(str(num)) == 3:\r\n return \"0%i\"%num\r\n elif len(str(num)) == 4:\r\n return \"%i\"%num","def base2str(self, int_number):\r\n return self.format_base % (float(int_number) / self.mult_base)","def _cardinal2word(strNumber):\n return Number.convertNumberIntoLetters(strNumber)","def guess_nic_name(self, nic_number):\n if nic_number == 1:\n return \"mgmt0\"\n else:\n return (\"Ethernet{0}/{1}\".format((nic_number - 2) // 48 + 2,\n (nic_number - 2) % 48 + 1))","def numbers(n):\n if n == 0:\n return 'zero'\n elif n == 1:\n return 'one'\n elif n == 2:\n return 'two'\n else:\n return 'unknown number'","def _transformed_name(key: Text) -> Text:\n return key + \"_xf\"","def numerify_iso_label(lab):\n from sage.databases.cremona import class_to_int\n if 'CM' in lab:\n return -1 - class_to_int(lab[2:])\n else:\n return class_to_int(lab.lower())","def get_name():","def getName(self):\n l = []\n for wt in self.weights:\n l.append(chr( int( 97 + (sum(map(sum,wt)) * 10) % 26 ) ))\n for bs in self.bias:\n #print(\"BS: \"+str(bs[0]))\n l.append(chr( int( 97 + (sum(bs) * 10) % 26 ) ))\n l[0] = chr(ord(l[0]) - 32)\n self.name = ''.join(l)\n return self.name","def ordinal(num):\n if num > 9:\n secondToLastDigit = str(num)[-2]\n if secondToLastDigit == '1':\n return 'th'\n lastDigit = num % 10\n if (lastDigit == 1):\n return 'st'\n elif (lastDigit == 2):\n return 'nd'\n elif (lastDigit == 3):\n return 'rd'\n else:\n return 'th'","def get_model_name(ind: int) -> str:\n return f'{fizz_name}-{fizz_type.model_name}{ind:02}'"],"string":"[\n \"def number_to_name(self, number):\\r\\n return self._names[number]\",\n \"def number_to_name(number):\\r\\n\\r\\n if number == 0:\\r\\n return \\\"rock\\\"\\r\\n elif number == 1:\\r\\n return \\\"Spock\\\"\\r\\n elif number == 2:\\r\\n return \\\"paper\\\"\\r\\n elif number == 3:\\r\\n return \\\"lizard\\\"\\r\\n elif number == 4:\\r\\n return \\\"scissors\\\"\\r\\n else:\\r\\n \\\"Invalid ! Enter a number from 0 to 4\\\"\",\n \"def name_number(n):\\n num = str(n)\\n last_digits = [\\\"\\\", \\\"one\\\", \\\"two\\\", \\\"three\\\", \\\"four\\\", \\\"five\\\", \\\"six\\\", \\\"seven\\\", \\\"eight\\\", \\\"nine\\\", \\\"ten\\\", \\\"eleven\\\",\\n \\\"twelve\\\", \\\"thirteen\\\", \\\"fourteen\\\", \\\"fifteen\\\", \\\"sixteen\\\", \\\"seventeen\\\", \\\"eighteen\\\", \\\"nineteen\\\"]\\n tens = [\\\"twenty\\\", \\\"thirty\\\", \\\"forty\\\", \\\"fifty\\\", \\\"sixty\\\", \\\"seventy\\\", \\\"eighty\\\", \\\"ninety\\\"]\\n if n <= 19: # name numbers from 1 to 19 directly\\n c = last_digits[int(num[-2:])]\\n elif 19 < n < 100: # name numbers from 20 to 99 by concatenating name for tens digit with name for ones digit\\n c = tens[int(num[-2]) - 2] + last_digits[int(num[-1])]\\n elif n % 100 == 0 and n < 1000:\\n # name numbers from 100 to 900 that are divisible by 100 by taking number in hundreds place and concatenating\\n # with \\\"hundred\\\"\\n c = last_digits[int(num[0])] + \\\"hundred\\\"\\n elif n != 1000:\\n # name numbers from 100 to 999 excluding those divisible by 100 by taking number in hundreds place, adding\\n # \\\"hundredand\\\", then naming the other 2 decimal places recursively\\n c = last_digits[int(num[0])] + \\\"hundredand\\\" + name_number(n % 100)\\n else: # name 1000\\n c = \\\"onethousand\\\"\\n return c\",\n \"def number_to_name(number):\\n \\n # A simple if/elif/else game...\\n\\n if number == 0:\\n name = \\\"rock\\\"\\n elif number == 1:\\n name = \\\"Spock\\\"\\n elif number == 2:\\n name = \\\"paper\\\"\\n elif number == 3:\\n name = \\\"lizard\\\"\\n else:\\n name = \\\"scissors\\\"\\n return name\",\n \"def number_to_name(number):\\n for name, value in item_dict.items():\\n if number == value:\\n return name\",\n \"def number_to_name(number):\\n if (number == 0):\\n name = 'rock'\\n return name\\n if (number == 1):\\n name = 'Spock'\\n return name\\n if (number == 2):\\n name = 'paper'\\n return name\\n if (number == 3):\\n name = 'lizard'\\n return name\\n if (number == 4):\\n name = 'scissors'\\n return name\\n else:\\n print \\\"ERROR: The choice of number is out of range!\\\"\",\n \"def _num2str(self, num):\\n q, mod = divmod(num, 10)\\n suffix = \\\"th\\\" if q == 1 else self.SUFFIX_DICT[mod]\\n return f\\\"{num}{suffix}\\\"\",\n \"def typeToName(type: int) -> unicode:\\n ...\",\n \"def dot_name(number):\\n\\tif number > 0:\\n\\t\\treturn \\\"P {}\\\".format(number)\\n\\telse:\\n\\t\\treturn \\\"O {}\\\".format(-number)\",\n \"def error_num_to_name(num):\\r\\n for t in ERROR_CODES:\\r\\n if t[0] == num:\\r\\n return t[1]\",\n \"def getHubName(num):\\n baseNum = num % 1000\\n if baseNum > 0 and baseNum < 100:\\n return \\\"%02d\\\" % baseNum\\n if baseNum > 200 and baseNum < 220:\\n return \\\"%02dt\\\" % (baseNum - 200)\\n return \\\"?%d?\\\" % baseNum\",\n \"def _build_name(name_id):\\n return \\\"xp_%08d\\\" % name_id\",\n \"def translate_number(number):\\n return NUMBER_TRANSLATOR[number]\",\n \"def spell_number(num):\\n tens, units = num / 10, num % 10\\n tens_str = NUMBERS_10[tens]\\n units_str = NUMBERS_1[units]\\n if tens == 1:\\n return NUMBERS_TEEN[units]\\n elif tens:\\n if units:\\n return \\\"{t} {u}\\\".format(t=tens_str, u=units_str)\\n return \\\"{t}\\\".format(t=tens_str)\\n else:\\n return units_str\",\n \"def name(self):\\n return '#{}'.format(self.number)\",\n \"def build_track_name(track, number = ''):\\n\\n name = ''\\n if number:\\n name += number\\n name += ' - '\\n name += track\\n return name\",\n \"def network_id_to_name(network_id: int) -> str:\\n return {\\n 1: \\\"main\\\",\\n 3: \\\"ropsten\\\",\\n 4: \\\"rinkeby\\\",\\n 5: \\\"goerli\\\",\\n 42: \\\"kovan\\\",\\n 100: \\\"xdai\\\",\\n 56: \\\"bsc-main\\\",\\n }[network_id]\",\n \"def convert(number):\\n out = \\\"\\\"\\n if number % 3 == 0:\\n out = \\\"Pling\\\"\\n if number % 5 == 0:\\n out = out + \\\"Plang\\\"\\n if number % 7 == 0:\\n out = out + \\\"Plong\\\"\\n if out == \\\"\\\":\\n out = str(number)\\n return out\",\n \"def num(number: int) -> str:\\n numbers = {1: \\\"one\\\", 2: \\\"two\\\", 3: \\\"three\\\", 4: \\\"four\\\", 5: \\\"five\\\",\\n 6: \\\"six\\\", 7: \\\"seven\\\", 8: \\\"eight\\\", 9: \\\"nine\\\", 10: \\\"ten\\\"}\\n if number in numbers:\\n return numbers[number]\\n else:\\n return f\\\"{number:,}\\\"\",\n \"def convert_label_num2string(number, num_types):\\n dictionary = empty_label_dictionary(num_types)\\n all_labels = list(dictionary.keys())\\n return all_labels[number]\",\n \"def get_name(self, suffix_number: int = 0) -> str:\\n if suffix_number:\\n return f\\\"{self.name}_{suffix_number}\\\"\\n return cast(str, self.name)\",\n \"def get_name(self):\\n names = (\\n None,\\n 'January', 'February', 'March',\\n 'April', 'May', 'June',\\n 'Juli', 'August', 'September',\\n 'October', 'November', 'December',\\n )\\n return names[self.number]\",\n \"def div_to_name(a):\\r\\n div_dict = {'1':\\\"Men\\\", '2':\\\"Women\\\", '3':\\\"Men_45-49\\\", '4':\\\"Women_45-49\\\", \\r\\n '5':\\\"Men_50-54\\\", '6':\\\"Women_50-54\\\", '7':\\\"Men_55-59\\\",\\r\\n '8':\\\"Women_55-59\\\", '9':\\\"Men_60+\\\", '10':\\\"Women_60+\\\",\\r\\n '11':\\\"Team\\\", '12':\\\"Men_40-44\\\", '13':\\\"Women_40-44\\\",\\r\\n '14':\\\"Boys_14-15\\\", '15':\\\"Girls_14-15\\\", '16':\\\"Boys_16-17\\\",\\r\\n '17':\\\"Girls_16-17\\\", '18':\\\"Men_35-39\\\", '19':\\\"Women_35-39\\\"}\\r\\n return div_dict[str(a)]\",\n \"def convert_number(number):\\n return ' ' + ' '.join(list(int_to_roman(number))) + ' '\",\n \"def name(self):\\n return '{:.2f}_{:d}_{:s}_{:d}'.format(self.A, self.Z,\\n self.species, self.C)\",\n \"def monthName(self, num):\\n \\n monthNames = {\\n '1': 'January',\\n '2': 'February',\\n '3': 'March',\\n '4': 'April',\\n '5': 'May',\\n '6': 'June',\\n '7': 'July',\\n '8': 'August',\\n '9': 'September',\\n '10': 'October',\\n '11': 'November',\\n '12': 'December'}\\n \\n return monthNames[num.lstrip('0')]\",\n \"def f_translate_key(self, key):\\n if isinstance(key, int):\\n if key == 0:\\n key = self.v_name\\n else:\\n key = self.v_name + \\\"_%d\\\" % key\\n return key\",\n \"def get_num_with_ordinal(num):\\n num_with_ordinal = str(num) + ordinal(num)\\n return num_with_ordinal\",\n \"def getMangledNum(self):\\n return (\\\"X\\\" * (len(self.num)-4)) + self.num[-4:]\",\n \"def class_num_to_name(class_num):\\n all_hues = cfg.ALL_HUE_VALUES.keys()\\n all_hues.sort()\\n hue = all_hues[class_num]\\n color_name = cfg.ALL_HUE_VALUES[hue]\\n return color_name\",\n \"def transforme(n):\\n if n<10 :\\n return '0'+str(n)\\n else :\\n return str(n)\",\n \"def increment_name(name: str) -> str:\\n\\n match = _number_suffix.search(name)\\n if match:\\n number_str = match.group(1)\\n next_number = int(number_str) + 1\\n return f'{name[:-len(number_str)]}{next_number}'\\n else:\\n return f'{name}-1'\",\n \"def ordinal_label(n):\\n n = int(n)\\n return \\\"%d%s\\\" % (n,\\\"tsnrhtdd\\\"[(n/10%10!=1)*(n%10<4)*n%10::4])\",\n \"def scaled_to_name(a):\\r\\n wt_list = ['Rx','Sc']\\r\\n return wt_list[a]\",\n \"def transform(s):\\r\\n return 'digit ' + str(s)\",\n \"def number_as_string(x):\\n \\n numnames = {1 : \\\"one\\\", 2 : \\\"two\\\", 3 : \\\"three\\\", 4 : \\\"four\\\", 5 : \\\"five\\\", 6 : \\\"six\\\", 7 : \\\"seven\\\", 8 : \\\"eight\\\", 9 : \\\"nine\\\",\\n 10 : \\\"ten\\\", 11 : \\\"eleven\\\", 12 : \\\"twelve\\\", 13 : \\\"thirteen\\\", 14 : \\\"fourteen\\\", 15 : \\\"fifteen\\\", 16 : \\\"sixteen\\\",\\n 17 : \\\"seventeen\\\", 18 : \\\"eighteen\\\", 19 : \\\"nineteen\\\", 20 : \\\"twenty\\\", 30 : \\\"thirty\\\", 40 : \\\"forty\\\", 50 : \\\"fifty\\\", \\n 60 : \\\"sixty\\\", 70 : \\\"seventy\\\", 80 : \\\"eighty\\\", 90 : \\\"ninety\\\"}\\n \\n numparts = []\\n needAnd = (x > 100) and (x % 100)\\n if x >= 1000:\\n numparts.append(numnames[x/1000])\\n numparts.append(\\\"thousand\\\")\\n x %= 1000\\n \\n if x >= 100:\\n numparts.append(numnames[x/100])\\n numparts.append(\\\"hundred\\\")\\n x %= 100\\n \\n if needAnd:\\n numparts.append(\\\"and\\\")\\n \\n if 11 <= x <= 19:\\n numparts.append(numnames[x])\\n else:\\n if x >= 10:\\n numparts.append(numnames[(x/10)*10])\\n x %= 10\\n\\n if x > 0:\\n numparts.append(numnames[x])\\n \\n return \\\" \\\".join(numparts)\",\n \"def numbers2words():\\n\\tmy_num = None\\n\\twhile my_num != \\\"0\\\":\\n\\t\\tmy_num = input(\\\"Please enter a number greater than 0 and less than 1 trillion: \\\")\\n\\t\\tprint(name_num(int(my_num.replace(\\\",\\\",\\\"\\\"))))\",\n \"def transform(s):\\n return 'digit ' + str(s)\",\n \"def MAKE_NAME(name):\\n name = name.replace('$', 'DOLLAR')\\n name = name.replace('.', 'DOT')\\n if name.startswith('__'):\\n return '_X' + name\\n elif name[0] in '01234567879':\\n return '_' + name\\n return name\",\n \"def type_number(number: float):\\n # TODO: Allow leading zeros\\n for char in str(number):\\n actions.key(char)\",\n \"def convert_numtoletter(n):\\r\\n L = seats[0][n-1] #letter\\r\\n return L\",\n \"def translateNumber(n):\\r\\n if type(n) != str:\\r\\n return None\\r\\n else:\\r\\n translation = \\\"\\\"\\r\\n word = \\\"\\\"\\r\\n for c in n:\\r\\n if c != ' ':\\r\\n word += c\\r\\n elif word in Numbers:\\r\\n translation += Numbers[word] + \\\" \\\"\\r\\n else:\\r\\n translation += word + \\\" \\\"\\r\\n return translation\",\n \"def updateName(g):\\n try:\\n n = int(g.group(2))\\n except TypeError:\\n n = 0\\n\\n return \\\"%s-%d\\\" % (g.group(1), n + 1)\",\n \"def GetUniqueName( name, elems ):\\n digits = []\\n for c in reversed( name ):\\n if c.isdigit():\\n digits.append( c )\\n else:\\n break\\n \\n stem = name[0:len( name ) - len( digits )]\\n val = ''.join( digits )[::-1] or 0\\n i = int( val )\\n \\n while True:\\n i += 1\\n newName = ''.join( [stem, str( i )] )\\n if newName not in elems:\\n break\\n \\n return newName\",\n \"def number_route(n):\\n return \\\"{:d} is a number\\\".format(n)\",\n \"def hbnb_number_route(num):\\n return '{} is a number'.format(num)\",\n \"def numToStrLabel(self, value):\\n zero_count = 3 - len(str(value))\\n return zero_count * \\\"0\\\" + str(value)\",\n \"def name_func(func, num, params):\\n return \\\"%s_%s_%s\\\" % (\\n func.__name__, int(num),\\n parameterized.to_safe_name('_'.join((params.args[0].__name__, params.args[1].__name__)))\\n )\",\n \"def WWRomanNumber(number):\\r\\n\\t\\r\\n\\tif number>4999 or number<1:\\r\\n\\t\\traise OverflowError(\\\"The should be between 1 and 4999, here it is \\\"+str(number))\\r\\n\\tnumerals = { 1 : \\\"I\\\", 4 : \\\"IV\\\", 5 : \\\"V\\\", 9 : \\\"IX\\\", 10 : \\\"X\\\", 40 : \\\"XL\\\",\\r\\n\\t\\t\\t\\t50 : \\\"L\\\", 90 : \\\"XC\\\", 100 : \\\"C\\\", 400 : \\\"CD\\\", 500 : \\\"D\\\", 900 : \\\"CM\\\", 1000 : \\\"M\\\" }\\r\\n\\tresult = \\\"\\\"\\r\\n\\tfor value, numeral in sorted(numerals.items(), reverse=True):\\r\\n\\t\\twhile number >= value:\\r\\n\\t\\t\\tresult += numeral\\r\\n\\t\\t\\tnumber -= value\\r\\n\\treturn result\",\n \"def convNumToCard(cardNum):\\n\\n\\tcardDict = {14:\\\"A\\\", 13:\\\"K\\\", 12:\\\"Q\\\", 11:\\\"J\\\"}\\n\\n\\tif cardNum > 10:\\n\\t\\treturn cardDict[cardNum]\\n\\telse: return str(cardNum)\",\n \"def format_resname(row,num):\\n resid = row['resid'+num].split(':')[-1]\\n gennum = row['resid'+num+'_gennum']\\n return(\\\"%s (%s)\\\"%(resid,gennum))\",\n \"def numeral(number):\\n return ROMAN_NUMERALS[number]\",\n \"def english(number):\\r\\n if number == 0:\\r\\n return 'zero'\\r\\n word = ''\\r\\n for step in itertools.count():\\r\\n number, rest = divmod(number, 1000)\\r\\n word = format_num(en3(rest), step) + word\\r\\n if number == 0:\\r\\n return word.strip()\",\n \"def name_id(self, fn:str='Jane',ln:str='Dear',sec:int=5):\\n code = '[0-9]{4:%s}'% int(sec)\\n return f\\\"{fn[0].capitalize()}{ln[0].capitalize()}{StringGenerator(str(code)).render(unique=True)}\\\"\",\n \"def make_frame_name(frame_num):\\n return str(frame_num).zfill(3) + '.jpg'\",\n \"def _compress_name(name):\\n n = 0\\n for c in name:\\n n = (n * _P1 + ord(c)) % _P2 \\n return '%09d' % n\",\n \"def apnumber(value):\\r\\n try:\\r\\n value = int(value)\\r\\n except (TypeError, ValueError):\\r\\n return value\\r\\n if not 0 < value < 10:\\r\\n return str(value)\\r\\n return (_('one'), _('two'), _('three'), _('four'), _('five'), _('six'),\\r\\n _('seven'), _('eight'), _('nine'))[value - 1]\",\n \"def ordinal(number: int):\\n if type(number) != int:\\n raise TypeError\\n else:\\n if 11 <= number <= 20 or number % 10 == 0:\\n return str(number) + 'th'\\n elif number % 10 == 1:\\n return str(number) + 'st'\\n elif number % 10 == 2:\\n return str(number) + 'nd'\\n elif number % 10 == 3:\\n return str(number) + 'rd'\\n else:\\n return str(number) + 'th'\",\n \"def errorNumToName(self, errorCode):\\n for t in self.ERROR_CODES:\\n if t[0] == errorCode:\\n return t[1]\",\n \"def only_ordinal(number):\\n _ordinal = lambda n: \\\"%s\\\" % (\\\"tsnrhtdd\\\"[(n/10%10!=1)*(n%10<4)*n%10::4]) # some black magic.\\n return _ordinal(number)\",\n \"def serialize_number(n):\\n return str(n)\",\n \"def _gennames(prefix, base, number):\\n for index in xrange(number):\\n yield \\\"%s%d\\\" % (prefix, base + index)\",\n \"def dump_with_name(self, id_to_name):\\n return str(id_to_name[self.player]) + str(self._num)\",\n \"def internal_id_to_display_id(i_id: int) -> str:\\n i_id = str(i_id).zfill(9)\\n return ''.join(i_id[x - 1] for x in [1, 5, 9, 6, 3, 8, 2, 4, 7])\",\n \"def tranfer_unit(number):\\n count = 0\\n unit_name = \\\"\\\"\\n if 2 ** 20 > number > 2 ** 10:\\n unit_name = \\\"Kb\\\"\\n count = 1\\n elif 2 ** 30 > number > 2 ** 20:\\n unit_name = \\\"Mb\\\"\\n count = 2\\n elif number > 2 ** 30:\\n unit_name = \\\"Gb\\\"\\n count = 3\\n else:\\n unit_name = \\\"b\\\"\\n if count != 0:\\n unit_number = round(number / ((2 ** 10) ** count), 2)\\n else:\\n unit_number = round(number, 2)\\n unit_str = \\\"{num}{name}\\\".format(num=unit_number, name=unit_name)\\n return unit_str\",\n \"def _name(self, upcase = True):\\n s = ''\\n if self.Z >= 0:\\n if upcase:\\n s = Elements[self.Z]\\n else:\\n s = elements[self.Z]\\n if self.F & self.F_GROUP_MASK == self.F_ISOBAR:\\n s = 'A:'\\n if self.F & self.F_GROUP_MASK == self.F_ISOTONE:\\n s = 'N:'\\n if self.A != 0 or (self.F & self.F_GROUP_MASK == self.F_ISOTONE):\\n s += \\\"{:d}\\\".format(self.A)\\n if self.A == 1 and self.Z == 0 and (self.F & self.F_GROUP_MASK == self.F_ISOTOPE):\\n s = 'n'\\n if self.F & self.F_GROUP_MASK == self.F_ISOMER:\\n if self.A == 0 and self.Z == 0:\\n if self.E == 1:\\n s = 'g'\\n else:\\n s = 'g{:d}'.format(self.E)\\n else:\\n s += self.isomer_name(self.E)\\n if self.F & self.F_GROUP_MASK == self.F_BOSON:\\n if self.A == 0 and self.Z == 0:\\n if self.E == 1:\\n s = 'g'\\n else:\\n s = 'g{:d}'.format(self.E)\\n else:\\n raise NotImplementedError()\\n s = self._SPECIAL.get(self.idx, s)\\n return s\",\n \"def name(self, obj, index=0):\\n if hasattr(obj, 'id'):\\n uid = obj.id.replace('material', 'm')\\n else:\\n self._namecount += 1\\n uid = 'Untitled.' + str(self._namecount)\\n base = '%s-%d' % (uid, index)\\n if base not in self._names:\\n self._namecount += 1\\n self._names[base] = '%s-%.4d' % (base[:MAX_NAME_LENGTH], self._namecount)\\n return self._names[base]\",\n \"def ordinal(number):\\n _ordinal = lambda n: \\\"%d%s\\\" % (n,\\\"tsnrhtdd\\\"[(n/10%10!=1)*(n%10<4)*n%10::4]) # some black magic.\\n return _ordinal(number)\",\n \"def _format(self, id_num: int) -> typing.Union[int, str]:\\n return id_num\",\n \"def number_to_name(scheme: ColorScheme | ColorSchemeShort, n: int) -> str:\\n mod = get_palette_module(scheme)\\n names = mod.__all__\\n if n > len(names):\\n raise ValueError(\\n f\\\"There are only '{n}' palettes of type {scheme}. \\\"\\n f\\\"You requested palette no. {n}\\\"\\n )\\n return names[n - 1]\",\n \"def _convert_name(self, name):\\n if not self.re_name.match(name):\\n org_name = name\\n name = self.re_white.sub('_', name)\\n name = self.re_alpha.sub('_', name)\\n if not self.re_name.match(name):\\n name = 'x_' + name2\\n self.warn('Converting name <' + org_name + '> to <' + name + '>.')\\n return name\",\n \"def shorten_number(self, number):\\n if number < 1000:\\n return number\\n elif number >= 1000 and number < 1000000:\\n num = self.rounded_number(number, 1000)\\n val = \\\"1M\\\" if num == \\\"1000\\\" else num + \\\"K\\\"\\n return val\\n elif number >= 1000000 and number < 1000000000:\\n num = self.rounded_number(number, 1000000)\\n val = \\\"1B\\\" if num==\\\"1000\\\" else num + \\\"M\\\"\\n return val\\n elif number >= 1000000000 and number < 1000000000000:\\n num = self.rounded_number(number, 1000000000)\\n val = \\\"1T\\\" if num==\\\"1000\\\" else num + \\\"B\\\"\\n return val\\n else:\\n num = self.rounded_number(number, 1000000000000)\\n return num + \\\"T\\\"\",\n \"def _build_name(name_idx):\\n return \\\"explored%s.set_%05d.xa_%08d\\\" % (\\n ArrayParameter.IDENTIFIER,\\n name_idx // 1000,\\n name_idx,\\n )\",\n \"def number_conversion(number):\\n units = ['', 'K', 'M', 'G', 'T', 'P']\\n k = 1000.0\\n magnitude = int(floor(log(number, k)))\\n return '%.2f%s' % (number / k**magnitude, units[magnitude])\",\n \"def MakeHumanReadable(num):\\n i = 0\\n while i+1 < len(EXP_STRINGS) and num >= (2 ** EXP_STRINGS[i+1][0]):\\n i += 1\\n rounded_val = round(float(num) / 2 ** EXP_STRINGS[i][0], 2)\\n return '%s %s' % (rounded_val, EXP_STRINGS[i][1])\",\n \"def generate_name(self, name):\\n return \\\"{}/{}.{}\\\".format(self.name, self._layer_counter, name)\",\n \"def to_ordinal(self):\\n return mod(self.number - 1 + 39 * (self.number - self.name), 260)\",\n \"def get_following_name(self, name: Name):\\n name = str(name)\\n amount_of_digits = self.get_amount_of_digits(name)\\n number = int(name[amount_of_digits:])\\n number += 1\\n following_name = name[:amount_of_digits]\\n following_name += str(number)\\n return following_name\",\n \"def makeNonStereoName(molType, name, n=None):\\n\\n match = re.match('(\\\\w+)(\\\\d|\\\\'+)(\\\\D*)', name)\\n \\n if not match:\\n #print molType, name, n\\n return \\n \\n \\n letters = match.group(1)\\n number = match.group(2)\\n prime = ''\\n \\n if number == '\\\\'':\\n number = 1\\n prime = '\\\\''\\n elif number == '\\\\'\\\\'':\\n number = 2\\n prime = '\\\\''\\n \\n if n is None:\\n n = int(number) - 1\\n\\n name = letters + prime + chr(ord('a')+n)+ match.group(3)\\n \\n return name\",\n \"def generate_resource_name(id_num):\\n return 'sweeper{0}i{1}'.format(id_num, str(uuid.uuid4())[0:8])\",\n \"def getName(self):\\n\\n if self.vel == 0:\\n return \\\"Rest\\\"\\n\\n order = self.nbr % 12 # Position in octave (Ex: 0 - C, 1 - C#,...)\\n return ['C', 'C#/Db', 'D', 'D#/Eb',\\n 'E', 'F', 'F#/Gb', 'G',\\n 'G#/Ab', 'A', 'A#/Bb', 'B'][order]\",\n \"def convert_number_to_excel_colname(n):\\n\\n assert 0 < n <= 256\\n\\n alphabet = [chr(x) for x in xrange(65, 91)]\\n\\n if n > 26:\\n return '{0}{1}'.format(alphabet[(n/26) - 1], alphabet[(n%26) - 1])\\n else:\\n return alphabet[(n%26) - 1]\",\n \"def cvt_to_readable(num):\\n\\n # Find the degree of the number like if it is in thousands or millions, etc.\\n index = int(math.log(num) / math.log(1000))\\n\\n # Converts the number to the human readable format and returns it.\\n newNum = round(num / (1000 ** index), 3)\\n degree = UNITS[index]\\n\\n return (newNum, degree)\",\n \"def name_to_number(name):\\n if name == \\\"rock\\\":\\n number = 0\\n elif name == \\\"Spock\\\":\\n number = 1\\n elif name == \\\"paper\\\":\\n number = 2\\n elif name == \\\"lizard\\\":\\n number = 3\\n elif name == \\\"scissors\\\":\\n number = 4\\n else:\\n print \\\"Name is invalid!\\\"\\n return 1\\n return number\",\n \"def seq_name(seq):\\n if len(seq) == 1:\\n return cp_name(seq[0])\\n return 'u' + '_'.join('%04X' % cp for cp in seq)\",\n \"def textualize(num):\\n if isinstance(num, float):\\n num = int(num)\\n # special case\\n if num == 0:\\n return 'zero'\\n\\n # if the number is negative, we put the word\\n # 'negative' in front of it.\\n is_negative = False\\n if num < 0:\\n is_negative = True\\n num = -1 * num\\n\\n num = str(num)\\n # pad with zeroes\\n while len(num) % 3 != 0:\\n num = ''.join([ '0', num ])\\n\\n # as groups are textualized, their strings will be\\n # appended to this list\\n num_string = []\\n group_counter = 0\\n while len(num) > 0:\\n group = num[-3:]\\n num = num[:-3]\\n text = _textualize_group(group)\\n\\n # thousand, million, etc.\\n if group_counter > 0 and text:\\n group_name = group_names[group_counter]\\n text = ' '.join([ text, group_name ])\\n\\n if text:\\n num_string.insert(0, text)\\n\\n group_counter += 1\\n\\n if is_negative:\\n num_string.insert(0, 'negative')\\n\\n return ' '.join(num_string)\",\n \"def pname(name):\\n ranks = list(reversed(name.split(';')))\\n for i, rank in enumerate(ranks):\\n if rank in ['Others', 'Unassigned']:\\n return rank\\n if rank == '__':\\n continue\\n if rank.split('__')[1] is '':\\n return ranks[i+1] + ';' + rank\\n return rank\",\n \"def name(self):\\n return 'D07 Indice de calidad de vida por manzanas'\",\n \"def get_name() -> str:\",\n \"def convert(num):\\r\\n if len(str(num))==1:\\r\\n return \\\"000%i\\\"%num\\r\\n elif len(str(num)) == 2:\\r\\n return \\\"00%i\\\"%num\\r\\n elif len(str(num)) == 3:\\r\\n return \\\"0%i\\\"%num\\r\\n elif len(str(num)) == 4:\\r\\n return \\\"%i\\\"%num\",\n \"def base2str(self, int_number):\\r\\n return self.format_base % (float(int_number) / self.mult_base)\",\n \"def _cardinal2word(strNumber):\\n return Number.convertNumberIntoLetters(strNumber)\",\n \"def guess_nic_name(self, nic_number):\\n if nic_number == 1:\\n return \\\"mgmt0\\\"\\n else:\\n return (\\\"Ethernet{0}/{1}\\\".format((nic_number - 2) // 48 + 2,\\n (nic_number - 2) % 48 + 1))\",\n \"def numbers(n):\\n if n == 0:\\n return 'zero'\\n elif n == 1:\\n return 'one'\\n elif n == 2:\\n return 'two'\\n else:\\n return 'unknown number'\",\n \"def _transformed_name(key: Text) -> Text:\\n return key + \\\"_xf\\\"\",\n \"def numerify_iso_label(lab):\\n from sage.databases.cremona import class_to_int\\n if 'CM' in lab:\\n return -1 - class_to_int(lab[2:])\\n else:\\n return class_to_int(lab.lower())\",\n \"def get_name():\",\n \"def getName(self):\\n l = []\\n for wt in self.weights:\\n l.append(chr( int( 97 + (sum(map(sum,wt)) * 10) % 26 ) ))\\n for bs in self.bias:\\n #print(\\\"BS: \\\"+str(bs[0]))\\n l.append(chr( int( 97 + (sum(bs) * 10) % 26 ) ))\\n l[0] = chr(ord(l[0]) - 32)\\n self.name = ''.join(l)\\n return self.name\",\n \"def ordinal(num):\\n if num > 9:\\n secondToLastDigit = str(num)[-2]\\n if secondToLastDigit == '1':\\n return 'th'\\n lastDigit = num % 10\\n if (lastDigit == 1):\\n return 'st'\\n elif (lastDigit == 2):\\n return 'nd'\\n elif (lastDigit == 3):\\n return 'rd'\\n else:\\n return 'th'\",\n \"def get_model_name(ind: int) -> str:\\n return f'{fizz_name}-{fizz_type.model_name}{ind:02}'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8246705","0.7550283","0.7530132","0.74987745","0.7460435","0.7435132","0.7311404","0.7058323","0.68847036","0.6775639","0.67526454","0.67350024","0.6674833","0.66491246","0.6633272","0.658147","0.64966327","0.6492684","0.64624995","0.6456531","0.6436228","0.64018965","0.63919675","0.63363504","0.6332663","0.62869275","0.6286414","0.62671083","0.6226742","0.6226096","0.6224722","0.62091357","0.6208926","0.620666","0.61889243","0.61837757","0.616896","0.61282766","0.61229926","0.6118147","0.6114484","0.61078894","0.6097917","0.60569745","0.6033762","0.6033508","0.60102797","0.5994196","0.59936714","0.59526485","0.59435624","0.59375757","0.5937303","0.59311444","0.59181696","0.5910123","0.5910051","0.5897109","0.5888654","0.58549285","0.5854397","0.5854094","0.5850993","0.5849019","0.58446324","0.58444446","0.5835404","0.5834254","0.5827378","0.58194447","0.581911","0.58173925","0.58170724","0.5811926","0.5804331","0.5802339","0.5794683","0.5791273","0.5783436","0.5783391","0.57765836","0.5773371","0.5770145","0.5765849","0.57655925","0.5754282","0.574789","0.57435817","0.57416606","0.57393163","0.57347006","0.5728976","0.5728437","0.5727733","0.5727668","0.5727499","0.5723754","0.5723714","0.5721804","0.57204926"],"string":"[\n \"0.8246705\",\n \"0.7550283\",\n \"0.7530132\",\n \"0.74987745\",\n \"0.7460435\",\n \"0.7435132\",\n \"0.7311404\",\n \"0.7058323\",\n \"0.68847036\",\n \"0.6775639\",\n \"0.67526454\",\n \"0.67350024\",\n \"0.6674833\",\n \"0.66491246\",\n \"0.6633272\",\n \"0.658147\",\n \"0.64966327\",\n \"0.6492684\",\n \"0.64624995\",\n \"0.6456531\",\n \"0.6436228\",\n \"0.64018965\",\n \"0.63919675\",\n \"0.63363504\",\n \"0.6332663\",\n \"0.62869275\",\n \"0.6286414\",\n \"0.62671083\",\n \"0.6226742\",\n \"0.6226096\",\n \"0.6224722\",\n \"0.62091357\",\n \"0.6208926\",\n \"0.620666\",\n \"0.61889243\",\n \"0.61837757\",\n \"0.616896\",\n \"0.61282766\",\n \"0.61229926\",\n \"0.6118147\",\n \"0.6114484\",\n \"0.61078894\",\n \"0.6097917\",\n \"0.60569745\",\n \"0.6033762\",\n \"0.6033508\",\n \"0.60102797\",\n \"0.5994196\",\n \"0.59936714\",\n \"0.59526485\",\n \"0.59435624\",\n \"0.59375757\",\n \"0.5937303\",\n \"0.59311444\",\n \"0.59181696\",\n \"0.5910123\",\n \"0.5910051\",\n \"0.5897109\",\n \"0.5888654\",\n \"0.58549285\",\n \"0.5854397\",\n \"0.5854094\",\n \"0.5850993\",\n \"0.5849019\",\n \"0.58446324\",\n \"0.58444446\",\n \"0.5835404\",\n \"0.5834254\",\n \"0.5827378\",\n \"0.58194447\",\n \"0.581911\",\n \"0.58173925\",\n \"0.58170724\",\n \"0.5811926\",\n \"0.5804331\",\n \"0.5802339\",\n \"0.5794683\",\n \"0.5791273\",\n \"0.5783436\",\n \"0.5783391\",\n \"0.57765836\",\n \"0.5773371\",\n \"0.5770145\",\n \"0.5765849\",\n \"0.57655925\",\n \"0.5754282\",\n \"0.574789\",\n \"0.57435817\",\n \"0.57416606\",\n \"0.57393163\",\n \"0.57347006\",\n \"0.5728976\",\n \"0.5728437\",\n \"0.5727733\",\n \"0.5727668\",\n \"0.5727499\",\n \"0.5723754\",\n \"0.5723714\",\n \"0.5721804\",\n \"0.57204926\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77541053"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":76088,"cells":{"query":{"kind":"string","value":"get choices and print out the results(main function)"},"document":{"kind":"string","value":"def rpsls(player_choice):\n print \n\n print \"Player chooses \" + player_choice\n\n player_number = name_to_number(player_choice)\n\n comp_number = random.randrange(0, 5)\n\n comp_choice = number_to_name(comp_number)\n\n print \"Computer chooses \" + comp_choice\n\n\n if 0 < (player_number - comp_number) % 5 <= 2:\n print \"Player wins!\"\n \n elif (player_number - comp_number) % 5 > 2:\n print \"Computer wins!\"\n \n elif (player_number - comp_number) % 5 == 0:\n print \"Player and computer tie!\"\n \n else:\n print \"Error!!!\"\n return 1\n\n return 0"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def display(self):\n\n print('\\n')\n for key, val in self.option.items():\n print(key, val, '\\n') # make it more confortable to read\n self.get_choice() # launch automaticly the choice method after display","def print_choice_msg(self) -> None:\n pass","def get_options():\n print(\"1: Compute the sum of 1..n\")\n print(\"2: Compute the product of 1..n\")\n print(\"9: Quit\") \n\n return input(\"Choice: \")","def display_choices(choices):\n for choice in enumerate(choices):\n print(\"\\n\", str(choice[0] + 1) + \": \" + choice[1])","def display(self):\n while (True):\n self.print()\n choice = self.get_choice()\n if (choice == len(self.options)):\n break\n else:\n self.options[choice].function()","def print_options(val, cur_matches):\n print val\n\n #skip one to print none at end\n for i,v in enumerate(cur_matches[1:]):\n print \"[%i] %s : %s \"%(i+1, v[0], v[1])\n print \"[%i] %s : %s \" % (0, cur_matches[0][0], cur_matches[0][1])\n\n print \n print 'Choice?'","def subChoose():\n\n print \"Please Choose Subject:\\n\\n1, Carms\\n2, Runes\\n3, Defence Against Dark Arts\\n4, Astronomy\\n5, Bonus\"","def print_next_choices(self) -> None:\n print(f'Now you are in Room #{self._id}')\n print('You have the following choices:')\n for option in range(1, len(self._choices)):\n print(f'Option {option}:')\n self._choices[option].print_choice_msg()","def main():\n args = get_args()\n guess = args.guess.upper()\n choice = args.choice\n \n dict = {1: 'Arcosanti', 2: 'Intercept', 3: 'Positions', 4: 'Collected', 5: 'Gemstones', 6: 'Cellulose', 7: 'Mastodons', 8: 'Meteorite', 9: 'Phoenixes', 10: 'Fireflies'} \n \n if choice > 10 or choice < 1: \n die('The choice number must be between 1 and 10') \n base = dict[choice].upper()\n if len(guess) < len(base) or len(guess) > len(base):\n die('The guess must be the same length as the word: {}'.format(len(base)))\n \n for i,j in zip(guess, base): \n if i == j:\n print('{}'.format(i),end='') \n else:\n print('_', end='')\n print('\\n')","def algo_selection(algos: tuple):\n print_header()\n print_list_algos(algos)\n print(\"Your choice: \", end='')\n return get_num_algo(algos)","def choose_option():\n print(\"1. title of most played game\"\n \"\\n2. how many copies have been sold in total\"\n \"\\n3. average selling\"\n \"\\n4. how many characters long is the longest title\"\n \"\\n5. average of the release dates\"\n \"\\n6. properties of the game\"\n \"\\n7. how many games are grouped by genre\"\n \"\\n8. ordered titles of games by date and alphabet\"\n \"\\n9. Exit\")\n\n option = input(\"\\nDisplay: \")\n return option","def selector(possibilities, names):\n # Print all possibilities\n for i in range(len(possibilities)):\n print(f'({i +1}) {possibilities[i]}')\n names.append(str(i + 1))\n skip_lines(1)\n # Ask a user for a choice\n choice = str(input(\"Select a category by using its index or by spelling it: \"))\n choice = choice.upper()\n # Verify that the choice is possible\n while choice not in names:\n choice = str(input(\"Select a category by using its index or by spelling it: \"))\n choice = choice.upper()\n return choice","def user_choices() -> True:\n message_box(\"EasyGUI examples.\\n\\nThis is a message box.\\n\\t\\t\\tAuthor: XX\")\n\n # This is a 'clever' technique!\n # Define the strings you need to use in a dictionaty,\n # and associate each string to a function name\n all_choices = {'Run my\\nfunction': my_function,\n 'Select a\\nfile': select_file,\n 'Show the demo': eg.egdemo}\n\n # Use Gui to select a choice\n choice = eg.buttonbox(msg=\"Select and action\",\n title=EG_TITLE+': choice',\n choices=list(all_choices.keys()),\n image=os.path.join('Images', 'qm.png'))\n\n # This is the clever bit!! Run the choice as a function\n all_choices[choice]()\n return True","def pick_place(choices_arg, question='Where to next?',inv=True):\r\n \r\n choices_alt = []\r\n \r\n if isinstance(choices_arg,list):\r\n choices = list(choices_arg)\r\n if inv:\r\n choices += ['inventory','map']\r\n \r\n elif isinstance(choices_arg,tuple):\r\n choices = choices_arg[0]\r\n choices_alt = choices_arg[1]\r\n if inv:\r\n choices += ['inventory','map']\r\n choices_alt += ['inventory','map']\r\n\r\n staying = True\r\n \r\n while staying:\r\n\r\n print question + '\\n'\r\n\r\n if choices_alt:\r\n for index in range(len(choices_alt)): #print alternate choices in menu form\r\n if str(choices[index]) == 'inventory':\r\n print\r\n print(str(index+1) + ': ' + str(choices_alt[index]))\r\n\r\n else:\r\n for index in range(len(choices)): #print choices in menu form\r\n if str(choices[index]) == 'inventory':\r\n print\r\n print(str(index+1) + ': ' + str(choices[index]))\r\n\r\n print('') #get some blank line in here yo\r\n chosen = raw_input('').lower()\r\n \r\n try:\r\n final = ''\r\n for index in range(len(choices)): #check if they typed a number\r\n item = choices[index]\r\n if index == int(chosen)-1:\r\n final = item\r\n staying = False\r\n if final == '':\r\n print 'Nice Try.\\n' #if they type a number not in range\r\n question = 'Try again, foo.'\r\n except:\r\n final = ''\r\n if choices_alt:\r\n for index in range(len(choices_alt)): #check if they typed letters\r\n item = choices_alt[index]\r\n if chosen == str(item).lower():\r\n final = choices[index]\r\n staying = False\r\n\r\n else:\r\n for index in range(len(choices)): #check if they typed letters\r\n item = choices[index]\r\n if chosen == str(item).lower():\r\n final = item\r\n staying = False\r\n if final == '':\r\n print 'Nice Try.\\n' #if they misspelled\r\n question = 'Try again, foo.'\r\n\r\n if final == 'map':\r\n inspect_map()\r\n question = 'Where to?'\r\n staying = True\r\n if final == 'inventory':\r\n inspect_inventory()\r\n question = 'Where to?'\r\n staying = True\r\n\r\n return final","def print_selection(self):\n #get the index of the selected item\n value = self.my_listbox.curselection()[0]\n\n #retrieve the corresponding value from dictionary using index\n s = self.my_listbox.get(value)\n\n #differentiate response based on score:\n #if score is around 2 ~ 3:\n if float(sorted_dict[s]) >= 2.853 and float(sorted_dict[s]) <= 3.836:\n result = \"\"\"Unfortunately, based on world happiness report(2019), \\nyour country scored very low.\\n\"\"\"\n prediction = \"\\nYour have a minimum chance at being happy.\"\n \n #if score is around 3 ~ 4:\n if float(sorted_dict[s]) > 3.835 and float(sorted_dict[s]) <= 4.819:\n result = \"\"\"Unfortunately, based on world happiness report(2019), \\nyour country scored relatively low. \\n\"\"\"\n prediction = \"\\nYou have a scarce chance at being happy.\"\n \n #if score is around 4 ~ 5:\n if float(sorted_dict[s]) > 4.819 and float(sorted_dict[s]) <= 5.802:\n result = \"\"\"Congratulation! Based on world happiness report(2019), \\nyour country scored in the middle.\\n\"\"\"\n prediction = \"\\nYou have a chance at being happy.\"\n \n #if score is around 5 ~ 6:\n if float(sorted_dict[s]) > 5.802 and float(sorted_dict[s]) <= 6.785:\n result = \"\"\"Congratulation! Based on world happiness report(2019), \\nyour country scored relatively high.\\n\"\"\"\n prediction = \"\\nYou have many chances at being happy.\"\n \n #if score is around 6 ~ 7:\n if float(sorted_dict[s]) > 6.785 and float(sorted_dict[s]) <= 7.769:\n result = \"\"\"Congratulation! Based on world happiness report(2019), \\nyour country scored very high.\\n\"\"\"\n prediction = \"\\nYou have an abundance of chances at being happy.\"\n\n #finalize response\n response = result + prediction+ \"\\n\" + s + \"\"\"'s score: \"\"\" + str(sorted_dict[s])\n\n self.var1.set(response)","def display_menu():\n print(\"\"\"\\nChoose option:\n (1) List statistics\n (2) Display 3 cities with longest names\n (3) Display county's name with the largest number of communities\n (4) Display locations, that belong to more than one category\n (5) Advanced search\n (0) Exit program\"\"\")","async def cmd_choose(self, args: Args, **_):\n response = \"From what you gave me, I believe `{}` is the best choice\".format(\n args[randint(0, len(args) - 1)]\n )\n return response","def show_main_screen():\n option = algo_selection(algos)\n if option == 1:\n print_factorial()\n show_main_screen()\n if option == 2:\n print_gcd()\n show_main_screen()\n if option == 3:\n print_pow()\n show_main_screen()\n if option == 4:\n print_towers()\n show_main_screen()\n if option == 5:\n print_permutations()\n show_main_screen()\n if option == 6:\n raise SystemExit(0)","def selection_input(\n self,\n prompt,\n choices,\n default=None,\n error_message=\"Invalid Selection\",\n transform=None\n ):\n while True:\n result = self.text_input(prompt, default)\n\n if transform is not None and result is not None:\n result = transform(result)\n\n if result in choices:\n return result\n\n print()\n print(error_message)","def test_choice(self):\n merged = reduce_choice(\n [\n map_choice(\n \"hello\",\n 1,\n token=0,\n token_logprob=0,\n top_logprobs={},\n text_offset=0,\n finish_reason=None,\n ),\n map_choice(\n \" world\",\n 1,\n token=1,\n token_logprob=0,\n top_logprobs={},\n text_offset=5,\n finish_reason=\"stop\",\n ),\n ]\n )\n\n assert merged[\"text\"] == \"hello world\"\n assert merged[\"index\"] == 1\n assert merged[\"finish_reason\"] == \"stop\"\n assert len(merged[\"logprobs\"][\"tokens\"]) == 2","def main():\n splitted_file = convert_input_to_list()\n encyclopedia_of_pizza = parse_pizza_info(splitted_file)\n pizza_winner = choose_pizza(encyclopedia_of_pizza)\n print_winner(pizza_winner)","def main_menu_input(self):\n if self.choice_menu == \"1\":\n self.category_choice()\n elif self.choice_menu == \"2\":\n print(fr.FR[9])\n for element in self.substitution_table.get_substitution():\n for substitution in element:\n sub_prod = self.product_table.get_product(substitution)\n print(sub_prod[0][1] + \" - \"\n + sub_prod[0][2] + \" - \"\n + sub_prod[0][3] + \" - \"\n + sub_prod[0][4])\n print(\"\\n\")\n elif self.choice_menu == \"3\":\n self.initialise_bdd()\n self.save_product_bdd()\n elif self.choice_menu == \"4\":\n self.leave_main_menu -= 1","async def choices(self, ctx, *, options):\n choices = options.split('-')\n choice = random.choice(choices)\n await ctx.send(f'My choice is\\\"{choice}\\\"')","def InputMenuChoice():\r\n choice = str(input(\"Which option would you like to perform? [1 to 4] - \")).strip()\r\n print() # Add an extra line for looks\r\n return choice","def _print_enum_opt(self, option, choices):\n for key in choices:\n if key == self.conf[option]:\n print(\"* %s\" % key)\n else:\n print(\" %s\" % key)","def henhouseDisplayMenu () :\r\n print('1.Predict egg production')\r\n print('2.Display needs')\r\n print('0.Exit henhouse management')\r\n print()\r\n print('Please choose an option from the above menu')","def main():\n\n # Initialize Selection Value\n selection = -1\n # Square and Cube program\n while selection:\n # Display Menu\n print('Welcome to the Square and Cube Program')\n print('Main Menu')\n print('1.Display Square and Cube Values')\n print('2.Display the Union of Square and Cube sets')\n print('3. Display intersection of Square and Cube sets')\n print('4. Display Difference of Square and Cube sets ')\n print('5.Search for individual intergers')\n print('6.Quit Application')\n\n # Program takes in input\n print(\"Enter selection: \")\n selection = int(input())\n\n if selection == 1:\n print(sorted(square()))\n print(sorted(cube()))\n\n elif selection == 2:\n print(square_cube_union())\n\n elif selection == 3:\n print(inter_of_sets())\n\n elif selection == 4:\n print(difference_of_sets())\n\n elif selection == 5:\n print(search_int())\n\n elif selection == 6:\n end_program()\n\n else:\n print('Invalid entry')","def print_menu():\r\n print(\"==============================================\")\r\n print(\"What do you want to do now? \")\r\n print(\"==============================================\")\r\n print(\"Available options:\")\r\n i = 1\r\n for a in available_actions:\r\n if current_state in a[\"valid_states\"]:\r\n # Only hint about the action if the current state allows it\r\n print(\" %i) %s\" % (i, a[\"description\"]))\r\n i += 1\r\n print()","def display_user_options():\r\n print(\"Please choose an option [e/d/a/q]:\")\r\n print(\" e) Encrypt some text\")\r\n print(\" d) Decrypt some text\")\r\n print(\" a) Automatically decrypt English text\")\r\n print(\" q) Quit\")","def search_method_menu(self):\n\n print()\n options = {'1': 'Employee Name', '2': 'Keyword', '3': 'Time Spent',\n '4': 'Date', '5': 'Date Range', '6': 'Exit to main menu'}\n\n while True:\n\n for k, v in options.items():\n print(k + \". \" + v)\n\n user_choice = input('\\nPlease enter the number of choice: ').lower().strip()\n\n if user_choice in options.keys():\n return options.get(user_choice)\n else:\n print('\\nInvalid choice! Please try again.\\n')","def main():\n raw_input()\n factors = map(int, raw_input().split(' '))\n elements = map(int, raw_input().split(' '))\n print between_two_sets(factors, elements)","async def randomChoice(self, ctx: commands.Context, *choices: str):\n if not choices:\n await ctx.reply(f\"Command failed - no arguments given.\\nEnter a sequence of arguments to choose from (you can use quotes for grouping).\", mention_author=False)\n elif len(choices)==1:\n await ctx.reply(f\"After some extremely randomized choosing from the one singular option that was given to choose from, the surprising result is:\\n{choices[0]}\", mention_author=False)\n else:\n await ctx.reply(f\"Randomly chosen result:\\n{random.choice(choices)}\", mention_author=False)","def handle_selection_main(self):\n choice = self.get_input()\n if choice == '1':\n self.display_cust()\n elif choice == '2':\n self.is_user = False\n self.display_eng()","def basic_menu(dict_of_options, back=False):\n choose = True\n dict_of_options = final_option(dict_of_options, back)\n list_of_options = list(dict_of_options.keys())\n\n while choose:\n print('The following options are available:\\n')\n for option in enumerate(list_of_options):\n print('\\t{} - {}'.format(option[0], option[1]))\n pick = input('\\nType the numeric code you wish to run\\n\\n')\n if pick in [str(i) for i in range((len(dict_of_options)))]:\n choose = dict_of_options[list_of_options[int(pick)]]()\n else:\n print('{} is not currently an option!\\n'.format(pick))","def display_choices(self, word_group, selection_list):\n code = 1\n print(f'Primary word: {word_group[0]}')\n selection_list.append(word_group[1])\n\n # randomize it\n random.shuffle(selection_list)\n for choice in enumerate(selection_list):\n print(f'{choice[0]} ---> {choice[1]}')\n if word_group[1] == choice[1]:\n code = choice[0]\n return code","def quiz_selection():\n\n verbs = crud.get_verbs()\n tenses = crud.get_tenses()\n\n return render_template(\"verb-conjugation.html\", verbs=verbs, tenses=tenses)","def run(self):\n # Gets the number of habits that exist in the habits table\n number_of_habits = len(self.analytics.habits_table())\n # Gets the number of trackings that exist in the trackings table\n number_of_trackings = len(self.analytics.trackings_table())\n\n while True:\n # Display a menu depending on the number of habits and trackings\n self.display_menu()\n choice = pyip.inputNum(\"Enter an number: \")\n if (number_of_habits == 0) and (choice in [0, 1]):\n action = self.menu_options.get(str(choice))\n action()\n elif (number_of_habits == 1) and (choice in [0, 1, 2, 3, 4]):\n action = self.menu_options.get(str(choice))\n action()\n elif (number_of_habits > 1) and (choice in [0, 1, 2, 3, 4, 5, 6]):\n action = self.menu_options.get(str(choice))\n action()\n elif number_of_trackings > 0 and (choice in [0, 1, 2, 3, 4, 5, 6, 7]):\n action = self.menu_options.get(str(choice))\n action() \n else:\n print('Choose a number from the list')","def main():\n answers_style = drink_style_input()\n drink = drink_make(answers_style)\n print \"\"\n print \"Your drink includes:\"\n for ingredient in drink:\n print \"A {}\".format(ingredient)","def main():\n seq = [48, 11, 45, 92, 32, 61, 65, 57, 29, 96]\n print(selection_sort(seq))","async def choose(self, ctx):\r\n if len(str(ctx.message.content)) < 9:\r\n await self.bot.say('{}, the usage is **!choose Option 1; Option 2; Option 3**, until you run out of options.'.format(ctx.message.author.mention))\r\n else:\r\n choices = str(ctx.message.content[8:])\r\n if '; ' not in choices:\r\n await self.bot.say('{}, the usage is **!choose Option 1; Option 2; Option 3**, ntil you run out of options.'.format(ctx.message.author.mention))\r\n else:\r\n options = choices.split('; ')\r\n await self.bot.say('{}, I choose: **{}**.'.format(ctx.message.author.mention,random.choice(options)))","def main():\n num_of_tests = int(input())\n\n # iterate over test cases\n for test_case in range(1, num_of_tests + 1):\n result = handle_case()\n printable_result = handle_result(result)\n print(\"Case #{}: {}\".format(test_case, printable_result))","def main(models_str, choices_str, trace_strings):\n packed_models = json.loads(models_str)\n models = []\n for i, obj in enumerate(packed_models):\n try:\n models.append(unpack(obj, player.PlayerModel))\n except Exception as e:\n raise ValueError(\n \"Failed to unpack player model #{}\".format(i)\n ) from e\n\n packed_choices = json.loads(choices_str)\n choices = []\n for i, obj in enumerate(packed_choices):\n try:\n choices.append(unpack(obj, choice.Choice))\n except Exception as e:\n raise ValueError(\n \"Failed to unpack choice #{}\".format(i)\n ) from e\n\n traces = { fn: json.loads(trace_strings[fn]) for fn in trace_strings }\n\n results = {\n tr: analyze_trace(models, choices, traces[tr]) for tr in traces\n }\n\n all_decisions = {}\n for ch in choices:\n cn = ch.name\n if cn not in all_decisions:\n all_decisions[cn] = {}\n for tr in traces:\n for tch in traces[tr]:\n add_to = all_decisions[tch[0]]\n if tch[1] in add_to:\n add_to[tch[1]] += 1\n else:\n add_to[tch[1]] = 1\n\n overall_per_choice = combine_per_choice(*[res[2] for res in results.values()])\n\n # TODO: More formatting here\n for tn in results:\n res = results[tn]\n print(\"Averages for {}:\".format(tn))\n for model in models:\n pmn = model.name\n print(\" {:.3g} {}\".format(res[0][pmn], pmn))\n print('-'*80)\n\n for cn in overall_per_choice:\n times, agreements = overall_per_choice[cn]\n print(\"Choice: '{}' (seen {} times)\".format(cn, times))\n print(\"Decisions:\")\n for dc in all_decisions[cn]:\n print(\" {}: {}\".format(dc, all_decisions[cn][dc]))\n print(\"Model agreement:\")\n for pmn in agreements:\n print(\" {}: {:.3g}\".format(pmn, agreements[pmn]))\n print('-'*80)","def get_answer(option_list):\n # Print the options\n print(\"Options:\")\n for i in range(len(option_list)):\n print(f\"{i + 1}. {option_list[i]}\")\n\n # Return the selected option from the user\n while True:\n try:\n selection = int(input(\">>>\"))\n if 1 <= selection <= len(option_list):\n print()\n return selection\n else:\n raise ValueError\n except ValueError:\n print(f\"Invalid option: Must be a number between 1 and {len(option_list)}\")","def main():\n\t# GET THE DIALOG CONTENT\n\tpolicyFlag = int(sys.argv[3])\n\tif policyFlag == 0:\n\t\texistedIterNum = 15000\n\t\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05'\n\telif policyFlag == 1:\n\t\texistedIterNum = 10000\n\t\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05Retroflex'\n\n\tqLearnOpts = {'gamma': 1.0, \n\t\t\t\t 'alpha': 0.0, \n\t\t\t\t 'epsilon': 0.0}\n\tnumOfTurn = util.returnConvertedIndexListCount('b','cycle_tree')\n\tnumofgauss = 5\n\tvar = 0.0625\n\tlamda = 0.05\n\tunitNum = 101\n\ta = qlearningAgents.FittedQLearningAgent(numOfTurn,numofgauss,var,lamda,unitNum, **qLearnOpts)\t\t\n\ta.openThetaFile(existedThetaFileName,existedIterNum)\n\n\tturnNum = int(sys.argv[1])\n\tuserUnitScore = []\n\tuserUnitScoreVector = sys.argv[2].split(',')\n\tfor i in userUnitScoreVector:\n\t\t\tuserUnitScore.append(float(i)/100.0)\n\n\tstate = State.State(turnNum, userUnitScore)\n\tprint a.getAction(state)","def menu():\n print('Selecciona el tipo de problema',end='\\n') \n print('-----------------------------------------')\n print('1) Conduccion de calor estacionaria, conductividad constante ',end='\\n')\n print('2) Conduccion de calor, ecuacion de Poisson condicion tipo Dirichlet ',end='\\n')\n print('3) Conduccion de calor, ecuacion de Poisson condicion tipo Neumman',end='\\n')\n print('4) Conduccion de calor, ecuacion de Poisson conductividad no constante',end='\\n')\n try:\n seleccion=int(input())\n except:\n print(\"No seas ñero\")\n sys.exit()\n return seleccion","def display_choose(self, text, choices):\n cur_index = 0\n key = None\n while key != 'KEY_NEWLINE':\n if key == 'KEY_UP':\n cur_index = max(cur_index - 1, 0)\n elif key == 'KEY_DOWN':\n cur_index = min(cur_index + 1, len(choices) - 1)\n self.stdscr.erase()\n for line in text:\n self.stdscr.addstr(f'{PADCHAR}{line}\\n')\n for index, value in enumerate(choices):\n self.stdscr.addstr('\\n')\n self.stdscr.addstr(PADCHAR)\n self.stdscr.addstr(value, color_pair(7 if index == cur_index else 1))\n self.stdscr.addstr(f'\\n\\n{PADCHAR}') \n key = self.get_key() \n return cur_index","def main_menu(): \r\n \r\n print(\"Please enter in the major for the class you need to study for: \")\r\n print(\"1. for Electrical Engineering\")\r\n print(\"2. for Bioengineering\")\r\n print(\"3. for Chemcial Engineering\")\r\n print(\"4. for Mechanical Engineering\")\r\n print(\"5. for Civil Engineering\")\r\n print(\"6. for Biology\")\r\n print(\"7. for Data Analytics\")\r\n print(\"8. for Chemistry\")\r\n choice = input()\r\n return choice","def _choice_a_filter(self, possibles):\n print(\"Avaliable Filters:\")\n for i, filter in enumerate(possibles):\n print(f\"{i+1} - {filter.name}\")\n\n option = 0\n while option <= 0 or option > len(possibles):\n try:\n option = int(input(\"\\nType the selected filter number: \"))\n except ValueError:\n continue\n\n return possibles[option - 1]","def menu():\n\tprint (\"\\n\\tSeleccionar una opcion\")\n\n\tprint (\"\\t1.- Resistencia en un Alambre \")\n\n\tprint (\"\\t2.- Voltaje\")\n\n\tprint (\"\\t3.- Corriente\")\n\n print (\"\\t4.- Resistencia\")\n\n\tprint (\"\\t5.- salir\")","def basic_menu_non_functional(list_of_options):\n choose = True\n list_of_options.append('back')\n\n while choose:\n print('The following options are available:\\n')\n for option in enumerate(list_of_options):\n print('\\t{} - {}'.format(option[0], option[1]))\n picks = input('\\nType the numeric codes you wish to run\\n\\n').split(',')\n choice = []\n if str(len(list_of_options)) in picks:\n return True\n for pick in picks:\n if pick in [str(i) for i in range((len(list_of_options)))]:\n choice.append(list_of_options[int(pick)])\n else:\n print('{} is not currently an option!\\n'.format(pick))\n if len(choice) > 0:\n return choice","def get_user_input(choice_list,data_name):\r\n # ref https://stackoverflow.com/questions/58449700/how-to-create-a-sub-program-that-takes-user-input\r\n\r\n input_num = 0\r\n\r\n while True:\r\n # print out the options\r\n for i in range(len(choice_list)):\r\n print(str(i+1)+\":\", choice_list[i])\r\n # try to get the user to select an option\r\n try:\r\n input_num = int(input(\"Enter the number that represents the {0}:\".format(data_name)))\r\n if input_num in range(1, len(choice_list)+1):\r\n return_value = choice_list[input_num-1]\r\n print('Great, you have choosen the ' + data_name + \": \" + return_value + '\\n')\r\n return return_value\r\n else:\r\n print(\"invalid choice, please try again\")\r\n except ValueError:\r\n print('Thats not a valid number please try again')\r\n continue","def printOptions(opts,subject_ids,session_ids,task_list, run_list, acq, rec):\n uname = os.popen('uname -s -n -r').read()\n print \"\\n\"\n print \"* Pipeline started at \"+time.strftime(\"%c\")+\"on \"+uname\n print \"* Command line is : \\n \"+str(sys.argv)+\"\\n\"\n print \"* The source directory is : \"+opts.sourceDir\n print \"* The target directory is : \"+opts.targetDir+\"\\n\"\n print \"* Data-set Subject ID(s) is/are : \"+str(', '.join(subject_ids))+\"\\n\"\n # print \"* PET conditions : \"+ ','.join(opts.condiList)+\"\\n\"\n print \"* Sessions : \", session_ids, \"\\n\"\n print \"* Tasks : \" , task_list , \"\\n\"\n print \"* Runs : \" , run_list , \"\\n\"\n print \"* Acquisition : \" , acq , \"\\n\"\n print \"* Reconstruction : \" , rec , \"\\n\"","def choose_display():\n\n choices = [\"d\",\"theta\",\"both\"]\n\n temp_choice = \"false\"\n\n while temp_choice not in choices:\n temp_choice = input(\"Please choose the scale to display.\\nd, theta, both\\n\")\n if temp_choice not in choices:\n print(\"incorrect choice\\n\")\n\n return temp_choice","def get_choice(list_of_games, num_games, num_pages=None, current_page=None):\n\tif current_page == 0:\n\t\ttext = Fore.WHITE + 'Options: Display (' + Fore.GREEN + 'N' + Fore.WHITE + ')ext page, (' + Fore.MAGENTA + \\\n\t\t 'C' + Fore.WHITE + ')urrent page, (' + Fore.RED + 'Q' + Fore.WHITE + ')uit or enter the ' + Fore.CYAN + \\\n\t\t 'Number' + Fore.WHITE + ' of the game to play'\n\telse:\n\t\ttext = Fore.WHITE + 'Options: Display (' + Fore.BLUE + 'P' + Fore.WHITE + ')revious page, (' + Fore.GREEN + \\\n\t\t 'N' + Fore.WHITE + ')ext page, (' + Fore.MAGENTA + 'C' + Fore.WHITE + ')urrent page, (' + \\\n\t\t Fore.RED + 'Q' + Fore.WHITE + ')uit or enter the ' + Fore.CYAN + 'Number' + Fore.WHITE + ' of the game to play'\n\n\tprint '\\n' + text\n\tindex = raw_input(Fore.WHITE + Style.BRIGHT + 'What would you like to do?: ').lower()\n\twhile index != 'p' or index != 'n' or index != 'd' or index.isdigit():\n\t\tif index == 'c':\n\t\t\tos.system('clear')\n\t\t\tif num_pages:\n\t\t\t\tlist_columns(list_of_games)\n\t\t\t\tprint '\\nDisplaying page {} of {}'.format(current_page, num_pages)\n\t\t\telse:\n\t\t\t\tlist_columns(list_of_games)\n\t\t\tprint text\n\t\telif index == 'p':\n\t\t\tbreak\n\t\telif index == 'n':\n\t\t\tbreak\n\t\telif index == 'q':\n\t\t\tsys.exit()\n\t\telif index.isdigit():\n\t\t\tif 0 < int(index) < num_games:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tprint Fore.RED + '\\nSorry that is not a valid choice!'\n\t\t\tprint text\n\t\tindex = raw_input(Fore.WHITE + Style.BRIGHT + 'What would you like to do?: ')\n\n\treturn index","def main():\n print(\"Select from menu:\")\n print(\"1. Add\")\n print(\"2. Minus\")\n print(\"3. Multiple\")\n print(\"4. Divide\")\n\n choice = int(input(\"Enter your choice: \"))\n a = int(input(\"Enter first value: \"))\n b = int(input(\"Enter second value: \"))\n\n input_dict = {1: sum(a, b), 2: subtract(a, b), 3: multiply(a, b), 4: divide(a, b)}\n answer_dict = {1: \"sum\", 2: \"difference\", 3: \"product\", 4:\"quotient\"}\n print(\"The {0} of {1} and {2} is {3}.\".format(answer_dict.get(choice),\n a,\n b,\n input_dict.get(choice, \"Invalid input. Select from menu.\")))","def prompt(text, choices):\n text += \" [\" + \"/\".join(choices) + \"] \"\n while True:\n inp = input(text)\n if inp in choices:\n return inp","def play():\n display_starting_message()\n print(\"\")\n print(\"*\"*10)\n for question_number, question in enumerate(list_of_questions):\n print(question)\n print(\"\")\n for responses in list_of_questions[question]:\n print(responses)\n pick_one = input(\"pick one: \")\n check_murder_sauce(question, pick_one)\n\n murder_sauce_result(murder_sauce)","async def choose(self, ctx, *args):\n query = \" \".join(args)\n choices = query.split(\" or \")\n if len(choices) < 2:\n await ctx.send(\"Give me at least 2 options to choose from! (separate options with `or`)\")\n self.logger.warning(misolog.format_log(ctx, f\"1 option\"))\n return\n choice = rd.choice(choices).strip()\n await ctx.send(f\"I choose **{choice}**\")\n self.logger.info(misolog.format_log(ctx, f\"{choice}\"))","def question():\n print('Enter 1 to search database by habitat with detailed information\\nEnter 2 to search database by coordinates \\nEnter 3 to search by habitat in csv file for a quick overview without detail')\n print('habitat search options so far:\\n Alpenvorland, Niederrheinisches Tiefland, Oberrheinisches Tiefland')\n src = int(input('Enter here:'))\n\n if src == 1:\n habitat = input('Enter name of habitat\\n')\n query = \"habitat = '\" + habitat + \"'\"\n search_db_via_query(query)\n elif src == 2:\n search_by_coordinates()\n elif src == 3:\n search_by_habitat()\n else:\n print('no data')","async def choose(self, ctx, *, choices: str):\n await ctx.send(\n self.bot.bot_prefix + 'I choose: ``{}``'.format(random.choice(choices.split(\"|\"))))","def main():\n is_program_working = True\n while is_program_working:\n display.print_program_menu(MAIN_MENU)\n try:\n choose_option()\n except ValueError as err:\n display.print_command_result(str(err))","def __ui_choose_statistics(self):\n print(\"Please choose one statistic from below:\\n\"\n \" 1. Find all activities for a given date, in the order of their start time\\n\"\n \" 2. Check the availability of the upcoming days\\n\"\n \" 3. Find all the activities performed together with a certain person\\n\")\n user_choice = input(\"Type your option: \").strip()\n print(\"\")\n if user_choice == \"1\":\n self.__ui_search_activities_by_date()\n elif user_choice == \"2\":\n self.__ui_find_busiest_days()\n elif user_choice == \"3\":\n self.__ui_find_activities_by_participant()\n else:\n print(\"Invalid option!\\n\")\n return","def get_user_choice(options: list, prompt: str) -> str:\n choice = False\n while not validate_user_choice(choice, options):\n print(prompt)\n for num, option in enumerate(options, 1):\n print(f\"{num} - {option}\")\n choice = input('\\nPlease enter the number corresponding to your choice here: ')\n return choice","def print_solution():\n pass","def print_menu():\n print()\n print(\"Main Menu\")\n print(\"---------\")\n print(\"1 - Process a new data file\")\n print(\"2 - Choose units\")\n print(\"3 - Edit room filter\")\n print(\"4 - Show summary statistics\")\n print(\"5 - Show temperature by date and time\")\n print(\"6 - Show histogram of temperatures\")\n print(\"7 - Quit\")\n print()","def menu(self, prompt, choices):\n menu = [prompt] + [\n \"{0}. {1}\".format(*choice) for choice in enumerate(choices, start=1)\n ]\n command = 'inputlist({})'.format(repr(menu))\n choice = int(self._vim.eval(command))\n\n # Vim returns weird stuff if user clicks outside choices with mouse\n if not 0 < choice < len(menu):\n return\n\n return choices[choice - 1]","def bonus_main():\n\n if len(sys.argv) != 3 or sys.argv[2] != \"-f\": \n raise error.Usage(extra=\" [-f]\")\n get_data()\n courses = Features.titles[6:]\n Courses.courses = courses\n get_courses()\n\n found = find_perfect_fit()\n c = found[\"combo\"]\n print(found, f\"\\nCourses:\\n{c[0]} - {courses[c[0]]}\",\n f\"\\n{c[1]} - {courses[c[1]]}\\n{c[2]} - {courses[c[2]]}\",\n f\"\\n{c[3]} - {courses[c[3]]}\\n{c[4]} - {courses[c[4]]}\")","def choose_from_list(query_category, query_list):\n print('Choose the {cat} you want from the below list:'.format(\n cat=query_category))\n for counter, value in enumerate(query_list):\n print('{counter}: {value}'.format(counter=counter, value=value))\n selection = input('Choice: ')\n return query_list[int(selection)]","def select_option(options, choice):\n choices = []\n txt = \"\"\n last = len(options) - 1\n for opt in options:\n if options.index(opt) == 0:\n txt += \"'\" + str(opt) + \"'\"\n elif options.index(opt) == last:\n txt += \" and '\" + str(opt) + \"'\"\n else:\n txt += \", '\" + str(opt) + \"'\"\n choices.append({'name': opt})\n\n question = [\n {\n 'type': 'list',\n 'message': 'The similarities between \\'' + choice + '\\' with ' + txt + ' are equal. Choose the one to consider.',\n 'name': 'option',\n 'choices': choices\n }\n ]\n\n answer = prompt(question, style=style)\n return answer.get(\"option\")","def project_visibility_menu():\n projects = [i.split('.')[0] for i in os.listdir('HousingPriceScraper/HousingPriceScraper/spiders/SpiderGroups')[:-1]]\n print('Available projects are:\\n')\n for project in enumerate(projects):\n print('\\t{} - {}'.format(project[0], project[1]))\n print('\\t{} - back'.format(len(projects)))\n choices = input('\\nType the options you wish to select.\\nFor multiple, comma separate\\n\\n').split(',')\n if str(len(projects)) in choices:\n return True\n else:\n choice_list = []\n for choice in choices:\n if choice.isdigit() and int(choice) in range(len(projects)):\n choice_list.append(projects[int(choice)])\n print('You have selected to display the following spider groupings:\\n\\t{}\\n'.format(choice_list))\n save_list_to_txt(choice_list, 'HousingPriceScraper/HousingPriceScraper/configs/visible_projects_to_scrape.txt')\n return True","def build_dataset_prompt():\n\n print(\"\")\n print(\"Let's start by choosing what features you'd like to look at/explore!\")","async def choose(*choices : str):\n await bot.say(random.choice(choices))","def select_program(self):\r\n\r\n path_data = self.json_data # Deserialize json\r\n print(' '+path_data['title'] + '\\n\\n ' + path_data['desc'] + '\\n\\n' +\r\n path_data['path']['desc']) # Print title\r\n for option in path_data['path']['options']: # Print list of functions\r\n print(str(option['num'])+'. '+option['desc'])\r\n scenario = input()\r\n if scenario == '0':\r\n self.install_vk_api_for_python()\r\n elif scenario == '1':\r\n self.vk_sign_in()\r\n self.download_pics_from_dialogs()\r\n elif scenario == '2':\r\n self.vk_sign_in()\r\n self.tag = input('По какому тегу будем искать людей? (0 для отмены)\\n')\r\n if self.tag != '0':\r\n self.get_users_pool()\r\n self.get_friends_numbers()\r\n else:\r\n self.tag = None\r\n elif scenario == '3':\r\n counter = self.count_ffn()\r\n self.check_for_build_plot(counter)\r\n elif scenario == '4':\r\n self.vk_token_sing_in()\r\n self.find_most_popular()\r\n else:\r\n print('Ошибка ввода, попробуйте еще раз')\r\n time.sleep(0.5)\r\n self.select_program()\r\n print('Возвращаемся в главное меню...')\r\n time.sleep(1)\r\n self.select_program()","def mainMenuChoice():\r\n print(\"What would you like to do?\")\r\n print(\" n) Add a class\")\r\n print(\" d) Delete a class\")\r\n print(\" e) Edit a class\")\r\n print(\" s) Show ongoing list of classes\")\r\n print(\" p) Print Schedule to Terminal\")\r\n print(\" g) Generate schedule in csv and print to Terminal\")\r\n print(\" q) Save and Exit program\\n\")\r\n \r\n choice = input(\"Input choice here: \")\r\n \r\n if choice.lower() in [\"n\",\"d\",\"e\",\"s\",\"g\",\"q\", \"p\"]:\r\n return choice\r\n else:\r\n print(\"\\nPlease enter a valid menu choice\")\r\n return None","def select_spiders(spiders_dict):\n print('Available spiders include:\\n')\n enumerated_keys = list(enumerate(spiders_dict.keys()))\n for key_group in enumerated_keys:\n print('{} - {}'.format(key_group[0], key_group[1]))\n for spider in zip(alphabet_list_length(len(key_group[1])), spiders_dict[key_group[1]]):\n print('\\t{}{} - {}'.format(key_group[0], spider[0], spider[1].name))\n print('{} - run all'.format(len(spiders_dict.keys())))\n print('{} - back'.format(len(spiders_dict.keys())+1))\n choices = input('\\nfor multiple, comma separate. To remove, use \"-\" prefix\\ni.e.: 0,-0a to run all of group 0 except the first\\n').replace(' ', '').split(',')\n if str(len(spiders_dict.keys())+1) in choices:\n return False\n if str(len(spiders_dict.keys())) in choices:\n chosen_spiders = list(spiders_dict.values())\n else:\n chosen_spiders = []\n for choice in choices:\n if choice.isdigit():\n if choice in [str(i[0]) for i in enumerated_keys]:\n chosen_spiders.append(spiders_dict[enumerated_keys[int(choice)][1]])\n else:\n print('{} is not an option!'.format(choice))\n elif '-' not in choice:\n numeric = re.findall(r'\\d+', choice)\n if len(numeric) == 1:\n alpha = choice.split(numeric[0])[1]\n alpha = len(alphabet_list_length(0, index=alpha))-1\n try:\n chosen_spiders.append(spiders_dict[enumerated_keys[int(numeric[0])][1]][alpha])\n except IndexError:\n print('{} is not an option!'.format(choice))\n else:\n print('{} is not an option!'.format(choice))\n if any(isinstance(el, list) for el in chosen_spiders):\n chosen_spiders = flatten_list_of_lists(chosen_spiders, make_set=True)\n else:\n chosen_spiders = list(set(chosen_spiders))\n to_remove = [choice for choice in choices if '-' in choice]\n if len(to_remove) > 0:\n for removee in to_remove:\n if removee.replace('-', '').isdigit():\n if removee.replace('-', '') in [str(i[0]) for i in enumerated_keys]:\n for spider in spiders_dict[enumerated_keys[int(removee.replace('-', ''))][1]]:\n chosen_spiders.remove(spider)\n else:\n print('{} is not an option!'.format(removee))\n else:\n numeric = re.findall(r'\\d+', removee)\n if len(numeric) == 1:\n alpha = removee.split(numeric[0])[1]\n alpha = len(alphabet_list_length(0, index=alpha)) - 1\n try:\n chosen_spiders.remove(spiders_dict[enumerated_keys[int(numeric[0])][1]][alpha])\n except IndexError:\n print('{} is not an option!'.format(removee))\n else:\n print('{} is not an option!'.format(removee))\n if len(chosen_spiders) > 0:\n return chosen_spiders\n else:\n print(\"You haven't selected any spiders!\")\n return False","def visualizeChosenOptions(self):\n \n # Visualising the results\n plt.hist(self.opt_selected)\n plt.title('Histogram of ads selections')\n plt.xlabel('Ads')\n plt.ylabel('Number of times each ad was selected')\n plt.show()","def select(self, options, prompt='Your choice? '):\n local_opts = options\n if isinstance(options, string_types):\n local_opts = list(zip(options.split(), options.split()))\n fulloptions = []\n for opt in local_opts:\n if isinstance(opt, string_types):\n fulloptions.append((opt, opt))\n else:\n try:\n fulloptions.append((opt[0], opt[1]))\n except IndexError:\n fulloptions.append((opt[0], opt[0]))\n for (idx, (value, text)) in enumerate(fulloptions):\n self.poutput(' %2d. %s\\n' % (idx + 1, text))\n while True:\n response = sm.input(prompt)\n try:\n response = int(response)\n result = fulloptions[response - 1][0]\n break\n except (ValueError, IndexError):\n self.stdout.write(\"{!r} isn't a valid choice. Pick a number \"\n \"between 1 and {}:\\n\".format(\n response, len(fulloptions)))\n return result","def main():\n data = []\n\n menu_text = \"\"\"\n 1. Display all records\n 2. Add new record\n 3. Edit existing record\n 4. Delete record \n 5. Quit\n \"\"\"\n\n while True:\n print(menu_text)\n choice = input('Enter your choice: ')\n if choice == '1':\n display_all_records()\n elif choice == '2':\n add_new_record(data)\n elif choice == '3':\n results = find_player()\n\n if results:\n edit_existing_record(results)\n else:\n print(f'Player is not on our records\\n')\n elif choice == '4':\n delete_record()\n elif choice == '5':\n break\n else:\n print('Not a valid selection, please try again')","def speakers_choice(self):\n while self.choice != \"q\":\n self.choice = input(\"\\033[35m(c) for create \\n(d) for delete \\n(s) for see \\n(r) for return start page \\n(q) for exit:\\033[0m\")\n os.system('cls' if os.name == 'nt' else 'clear')\n time.sleep(1)\n if self.choice == \"c\":\n name = input(\"\\033[32menter name:\\033[0m\")\n lastname = input(\"\\033[32menter lastname:\\033[0m\")\n description = input(\"\\033[32menter decription:\\033[0m\")\n job = input(\"\\033[32menter job:\\033[0M\")\n os.system('cls' if os.name == 'nt' else 'clear')\n time.sleep(1)\n self.user.create_speakers(name, lastname, description, job)\n\n if self.choice == \"d\":\n id = input(\"\\033[32menter speakers ID :\\033[0m\")\n os.system('cls' if os.name == 'nt' else 'clear')\n time.sleep(1)\n self.user.delete_speakers(id)\n\n if self.choice == \"s\":\n datta = self.speakers.show_speakers()\n if datta:\n for elem in datta:\n print(elem)\n if self.choice == \"r\":\n os.system('cls' if os.name == 'nt' else 'clear')\n time.sleep(1)\n return\n\n if self.choice == \"q\":\n exit()","def menu():\n print\n print \"(1) Enter the size and values of an array\"\n print \"(2) Print the array\"\n print \"(3) Multiply an array row by a constant\"\n print \"(4) Add one row into another\"\n print \"(5) Add a multiple of one row to another\"\n print \"(6) Solve\"\n print \"(9) Quit\"\n\n print \"Which choice would you like?\"","def main():\n songs = []\n first_line = sys.stdin.readline().split(' ', 1)\n songs_on_album, songs_to_select = int(first_line[0]), int(first_line[1])\n for i in range(songs_on_album):\n line = sys.stdin.readline().split(' ', 1)\n song = Song(line[1], int(line[0]), i+1)\n songs.append(song)\n\n print_quality_songs(songs, songs_to_select)","async def watdo(self, ctx, *args):\n choicelist = []\n for choice in args:\n choicelist.append(choice)\n result = random.choice(choicelist)\n await ctx.bot.send_message(ctx.message.channel, \"I pick {}!\".format(result))","def get_choose():\n global result, choose, win_update_concurrence, output1, confirmation, win_create_update_str, number_str\n number_str = choose.get()\n result = result[int(number_str) - 1]\n output1.delete(1.0, END)\n for i in result:\n output1.insert(END, str(i) + '\\n')\n confirmation.destroy()\n confirmation = Label(win_create_update_str, text='Измените строку и нажмите \"Редактировать\"')\n confirmation.place(x=15, y=40)\n win_update_concurrence.destroy()","def print_choice_menu():\n month1 = input(\"Give the month as 4, 5, 6, 7, 8, or 9: \")\n print()\n day1 = input(\"Give the day as 1, 2, ..., 29, 30, or 31: \")\n print()\n\n try:\n month1 = int(month1)\n day1 = int(day1)\n\n if month1 in [4, 5, 6, 7, 8, 9]:\n if day1 in list(range(1, 32)):\n if day1 == 31 and month1 in [4, 6, 9]:\n print(\"Invalid Date!\")\n sleep(2)\n return 0, 0\n elif month1 > datetime.now().month or (month1 == datetime.now().month and day1 > datetime.now().day):\n print(\"Date out of bounds\")\n sleep(2)\n return 0, 0\n else:\n sleep(2)\n return month1, day1\n else:\n print(\"Date out of bounds\")\n sleep(2)\n return 0, 0\n else:\n print(\"Date out of bounds\")\n sleep(2)\n return 0, 0\n\n except ValueError:\n print(\"User Error\")\n sleep(2)\n return 0, 0","def displaymenu(option):\n DebugMessage(f\"\"\"def:displaymenu | option={option}\"\"\")\n print(question)\n print(\"Options:\" + str(option))\n response = input(\"$> \")\n\n for opt in option:\n if response.lower() == opt.lower():\n DebugMessage(f\"User selected a valid option:{opt}\")\n if opt == 'Quit':\n exit(0)\n return opt\n print(f\"{response}, is not a valid option\")\n print(gui_bar)\n displaymenu(option)","def get_choice(choices, conversation):\n user_choice = None\n while user_choice is None:\n try:\n user_input = input(\"\\nChoice: \")\n if user_input == 'debug' or user_input == 'd':\n print(\"\\n\", conversation.getDebugInfo())\n else:\n user_choice = int(user_input)\n if choices.__len__() < user_choice or user_choice < 1:\n print('Error, try again')\n user_choice = None\n else:\n print(\"\\nYou: \" + choices[user_choice - 1])\n except ValueError:\n print('Error, try again')\n return user_choice","def prompt():\r\n inpt = -1\r\n valid_choices = ['1','2','3','4','5']\r\n while inpt not in valid_choices:\r\n inpt = input(\"\\nPlease select the number of the operation you wish \"\r\n \"to complete:\\n\" +\r\n \"1. Run file mover\\n2. Add directories\"\r\n \"\\n3. Remove directory\\n4. View saved directories\\n5. Quit\\n\").strip()\r\n if inpt not in valid_choices:\r\n print(\"\\n*** Invalid choice ***\")\r\n return inpt","def menu():\n menu_options = [enter_long_run_data, enter_data_for_pace_calc, enter_data_for_time_calc,\n enter_into_running_index_mode, close_program]\n while True:\n cls()\n print(MENU_TEXT)\n choose = int(input(\"What do you want to calculate?\\n>> \"))\n cls()\n\n if 1 <= choose <= 5:\n menu_options[choose-1]()\n else:\n print(\"That option doesnt exist. Try again.\")\n pause_end()","def _choose_best_option(self):","async def choose(self, ctx, *args):\n choicelist = []\n for choice in args:\n choicelist.append(choice)\n result = random.choice(choicelist)\n await ctx.send(\"Like it or not, I choose {}!\".format(result))","def run():\n table = hr.get_hr_table_from_file()\n title_list = [\"ID\", \"Name\", \"BirthYear\"]\n options = [\"View records\",\n \"Add record\",\n \"Remove record\",\n \"Update record\",\n \"Which person is the oldest?\",\n \"Which person is the closet to average age?\"]\n\n\n choice = None\n while choice != \"0\":\n choice = terminal_view.get_choice_inner_menu(options, \"HR manager\")\n if choice == \"1\":\n terminal_view.print_table(table, title_list)\n elif choice == \"2\":\n record = terminal_view.get_inputs(title_list[1::],\"Please provide new item data\")\n table = hr.add(table, record)\n elif choice == \"3\":\n id_to_delete_table = terminal_view.get_inputs([\"ID\"],\"Item to delete\")\n id_to_delete = id_to_delete_table[0]\n table = hr.remove(table, id_to_delete)\n elif choice == \"4\":\n records = terminal_view.get_inputs(title_list,\"Edit item\")\n record_id = records[0]\n table = hr.update(table, record_id, records)\n elif choice == \"5\":\n oldest_person = hr.get_oldest_person(table)\n terminal_view.print_result(oldest_person, \"The oldest person: \")\n elif choice == \"6\":\n closest_to_average = hr.get_persons_closest_to_average(table)\n terminal_view.print_result(closest_to_average,\"The closest to average is: \")\n elif choice != \"0\":\n terminal_view.print_error_message(\"There is no such choice.\")","def choice(prompt, choices=('y', 'n')):\n while True:\n choice = input(prompt).lower().strip()\n if choice == '0':\n raise SystemExit\n elif ',' not in choice:\n if choice in choices:\n break\n elif ',' in choice:\n choice = [i.strip().lower() for i in choice.split(',')]\n if list(filter(lambda x: x in choices, choice)) == choice:\n break\n prompt = (\"\\n!!!OOOPS !!!Please be sure to enter a valid option!!! /n\")\n return choice","def main():\n \n #///////////////////////////////////////////////////////////\n \n #\"\"\"#for the commad prompt usage\n parser = argparse.ArgumentParser(\"Week 2 Project: Search Algorithms\")\n parser.add_argument(\"method\", help=\"Searching Algorithm Name\", type=str)\n parser.add_argument(\"board\", help=\"Initial State of the board\")\n\n args = parser.parse_args()\n solver = solve()\n try:\n initial_state = [int(i) for i in args.board.split(\",\")]\n s = state(initial_state, None)\n except:\n print(\"An error with input has been occured .\")\n exit()\n\n g = state([i for i in range(len(initial_state))], None)\n\n if args.method == \"bfs\":\n print(solver.bfs(s, g))\n elif args.method == \"dfs\":\n print(solver.dfs(s, g))\n elif args.method == \"ast\":\n print(solver.ast(s, g))\n else:\n print(solver.ida(s, g))\n\n #\"\"\"\n\n return","def _prompt_choice(options: list) -> int:\n for i, x in enumerate(options):\n print(str(i).rjust(3, ' '), x)\n return int(input('Selection: '))","def display_results(results):\n winners = results[0]\n losers = results[1]\n pushers = results[2]\n blackjack_winners = results[3]\n print(generate_results_string(winners, \" wins\", \" win\"))\n print(generate_results_string(losers, \" loses\", \" lose\"))\n print(generate_results_string(pushers, \" pushes\", \" push\"))\n print(generate_results_string(blackjack_winners, \" wins with blackjack\", \" win with blackjack\"))","def run(self):\n while True:\n self.display_menu()\n choice = input(\"¿Qué deseas realizar?: \")\n action = self.choices.get(choice)\n if action:\n action()\n else:\n print(\"{0} is not a valid choice\".format(choice))","def handle_selection_cust(self):\n choice = self.get_input()\n if choice == '1':\n self.display_cust_unlock()\n elif choice == '2':\n self.display_return_car()\n elif choice == '3':\n self.display_main()","def mainMenu(options):\n while True:\n print(\"Welcome to SportsBook - A sports analysis tool.\")\n print(\"Please select from one of the following sports:\")\n # Display all options\n for option in options:\n print(str(option[0]) + \" \" + str(option[1]))\n # Take user selection\n while True:\n print(\"Enter option: \")\n selected = input()\n # Quit option\n if selected.lower() == \"q\":\n exit()\n # If a number has been entered, convert the string to an integer\n if isNumber(selected):\n selected = int(selected)\n # If the selection is in the list break out of the infinite loop\n if selected in range(len(options)) and selected != 0:\n break\n # Having broken out of the loop, run the selected function\n if selected == options[0][0]:\n leagueData={}\n footballMenu(leagueData)\n if selected == options[1][0]:\n tennis()","def browse(self):\n\t\tos.system(\"clear\")\n\t\tself._show_menu()\n\t\twhile True:\n\t\t\tchoice = input(\"Enter the according number above:\")\n\n\t\t\tif choice == \"1\":\n\t\t\t\tself._show_all_goods()\n\t\t\telif choice == \"2\":\n\t\t\t\tself._show_cate()\n\t\t\telif choice == \"3\":\n\t\t\t\tself._show_brand()\n\t\t\telif choice == \"4\":\n\t\t\t\tself._order()\n\t\t\t\tos.system('clear')\n\t\t\telse:\n\t\t\t\tcontinue\n\t\t\tself._show_menu()","def main():\n printfunc(calc(menu()))","def main():\n data = read_data()\n print('Part one solution: {}'.format(part_one(data)))\n print('Part two solution: {}'.format(part_two(data)))"],"string":"[\n \"def display(self):\\n\\n print('\\\\n')\\n for key, val in self.option.items():\\n print(key, val, '\\\\n') # make it more confortable to read\\n self.get_choice() # launch automaticly the choice method after display\",\n \"def print_choice_msg(self) -> None:\\n pass\",\n \"def get_options():\\n print(\\\"1: Compute the sum of 1..n\\\")\\n print(\\\"2: Compute the product of 1..n\\\")\\n print(\\\"9: Quit\\\") \\n\\n return input(\\\"Choice: \\\")\",\n \"def display_choices(choices):\\n for choice in enumerate(choices):\\n print(\\\"\\\\n\\\", str(choice[0] + 1) + \\\": \\\" + choice[1])\",\n \"def display(self):\\n while (True):\\n self.print()\\n choice = self.get_choice()\\n if (choice == len(self.options)):\\n break\\n else:\\n self.options[choice].function()\",\n \"def print_options(val, cur_matches):\\n print val\\n\\n #skip one to print none at end\\n for i,v in enumerate(cur_matches[1:]):\\n print \\\"[%i] %s : %s \\\"%(i+1, v[0], v[1])\\n print \\\"[%i] %s : %s \\\" % (0, cur_matches[0][0], cur_matches[0][1])\\n\\n print \\n print 'Choice?'\",\n \"def subChoose():\\n\\n print \\\"Please Choose Subject:\\\\n\\\\n1, Carms\\\\n2, Runes\\\\n3, Defence Against Dark Arts\\\\n4, Astronomy\\\\n5, Bonus\\\"\",\n \"def print_next_choices(self) -> None:\\n print(f'Now you are in Room #{self._id}')\\n print('You have the following choices:')\\n for option in range(1, len(self._choices)):\\n print(f'Option {option}:')\\n self._choices[option].print_choice_msg()\",\n \"def main():\\n args = get_args()\\n guess = args.guess.upper()\\n choice = args.choice\\n \\n dict = {1: 'Arcosanti', 2: 'Intercept', 3: 'Positions', 4: 'Collected', 5: 'Gemstones', 6: 'Cellulose', 7: 'Mastodons', 8: 'Meteorite', 9: 'Phoenixes', 10: 'Fireflies'} \\n \\n if choice > 10 or choice < 1: \\n die('The choice number must be between 1 and 10') \\n base = dict[choice].upper()\\n if len(guess) < len(base) or len(guess) > len(base):\\n die('The guess must be the same length as the word: {}'.format(len(base)))\\n \\n for i,j in zip(guess, base): \\n if i == j:\\n print('{}'.format(i),end='') \\n else:\\n print('_', end='')\\n print('\\\\n')\",\n \"def algo_selection(algos: tuple):\\n print_header()\\n print_list_algos(algos)\\n print(\\\"Your choice: \\\", end='')\\n return get_num_algo(algos)\",\n \"def choose_option():\\n print(\\\"1. title of most played game\\\"\\n \\\"\\\\n2. how many copies have been sold in total\\\"\\n \\\"\\\\n3. average selling\\\"\\n \\\"\\\\n4. how many characters long is the longest title\\\"\\n \\\"\\\\n5. average of the release dates\\\"\\n \\\"\\\\n6. properties of the game\\\"\\n \\\"\\\\n7. how many games are grouped by genre\\\"\\n \\\"\\\\n8. ordered titles of games by date and alphabet\\\"\\n \\\"\\\\n9. Exit\\\")\\n\\n option = input(\\\"\\\\nDisplay: \\\")\\n return option\",\n \"def selector(possibilities, names):\\n # Print all possibilities\\n for i in range(len(possibilities)):\\n print(f'({i +1}) {possibilities[i]}')\\n names.append(str(i + 1))\\n skip_lines(1)\\n # Ask a user for a choice\\n choice = str(input(\\\"Select a category by using its index or by spelling it: \\\"))\\n choice = choice.upper()\\n # Verify that the choice is possible\\n while choice not in names:\\n choice = str(input(\\\"Select a category by using its index or by spelling it: \\\"))\\n choice = choice.upper()\\n return choice\",\n \"def user_choices() -> True:\\n message_box(\\\"EasyGUI examples.\\\\n\\\\nThis is a message box.\\\\n\\\\t\\\\t\\\\tAuthor: XX\\\")\\n\\n # This is a 'clever' technique!\\n # Define the strings you need to use in a dictionaty,\\n # and associate each string to a function name\\n all_choices = {'Run my\\\\nfunction': my_function,\\n 'Select a\\\\nfile': select_file,\\n 'Show the demo': eg.egdemo}\\n\\n # Use Gui to select a choice\\n choice = eg.buttonbox(msg=\\\"Select and action\\\",\\n title=EG_TITLE+': choice',\\n choices=list(all_choices.keys()),\\n image=os.path.join('Images', 'qm.png'))\\n\\n # This is the clever bit!! Run the choice as a function\\n all_choices[choice]()\\n return True\",\n \"def pick_place(choices_arg, question='Where to next?',inv=True):\\r\\n \\r\\n choices_alt = []\\r\\n \\r\\n if isinstance(choices_arg,list):\\r\\n choices = list(choices_arg)\\r\\n if inv:\\r\\n choices += ['inventory','map']\\r\\n \\r\\n elif isinstance(choices_arg,tuple):\\r\\n choices = choices_arg[0]\\r\\n choices_alt = choices_arg[1]\\r\\n if inv:\\r\\n choices += ['inventory','map']\\r\\n choices_alt += ['inventory','map']\\r\\n\\r\\n staying = True\\r\\n \\r\\n while staying:\\r\\n\\r\\n print question + '\\\\n'\\r\\n\\r\\n if choices_alt:\\r\\n for index in range(len(choices_alt)): #print alternate choices in menu form\\r\\n if str(choices[index]) == 'inventory':\\r\\n print\\r\\n print(str(index+1) + ': ' + str(choices_alt[index]))\\r\\n\\r\\n else:\\r\\n for index in range(len(choices)): #print choices in menu form\\r\\n if str(choices[index]) == 'inventory':\\r\\n print\\r\\n print(str(index+1) + ': ' + str(choices[index]))\\r\\n\\r\\n print('') #get some blank line in here yo\\r\\n chosen = raw_input('').lower()\\r\\n \\r\\n try:\\r\\n final = ''\\r\\n for index in range(len(choices)): #check if they typed a number\\r\\n item = choices[index]\\r\\n if index == int(chosen)-1:\\r\\n final = item\\r\\n staying = False\\r\\n if final == '':\\r\\n print 'Nice Try.\\\\n' #if they type a number not in range\\r\\n question = 'Try again, foo.'\\r\\n except:\\r\\n final = ''\\r\\n if choices_alt:\\r\\n for index in range(len(choices_alt)): #check if they typed letters\\r\\n item = choices_alt[index]\\r\\n if chosen == str(item).lower():\\r\\n final = choices[index]\\r\\n staying = False\\r\\n\\r\\n else:\\r\\n for index in range(len(choices)): #check if they typed letters\\r\\n item = choices[index]\\r\\n if chosen == str(item).lower():\\r\\n final = item\\r\\n staying = False\\r\\n if final == '':\\r\\n print 'Nice Try.\\\\n' #if they misspelled\\r\\n question = 'Try again, foo.'\\r\\n\\r\\n if final == 'map':\\r\\n inspect_map()\\r\\n question = 'Where to?'\\r\\n staying = True\\r\\n if final == 'inventory':\\r\\n inspect_inventory()\\r\\n question = 'Where to?'\\r\\n staying = True\\r\\n\\r\\n return final\",\n \"def print_selection(self):\\n #get the index of the selected item\\n value = self.my_listbox.curselection()[0]\\n\\n #retrieve the corresponding value from dictionary using index\\n s = self.my_listbox.get(value)\\n\\n #differentiate response based on score:\\n #if score is around 2 ~ 3:\\n if float(sorted_dict[s]) >= 2.853 and float(sorted_dict[s]) <= 3.836:\\n result = \\\"\\\"\\\"Unfortunately, based on world happiness report(2019), \\\\nyour country scored very low.\\\\n\\\"\\\"\\\"\\n prediction = \\\"\\\\nYour have a minimum chance at being happy.\\\"\\n \\n #if score is around 3 ~ 4:\\n if float(sorted_dict[s]) > 3.835 and float(sorted_dict[s]) <= 4.819:\\n result = \\\"\\\"\\\"Unfortunately, based on world happiness report(2019), \\\\nyour country scored relatively low. \\\\n\\\"\\\"\\\"\\n prediction = \\\"\\\\nYou have a scarce chance at being happy.\\\"\\n \\n #if score is around 4 ~ 5:\\n if float(sorted_dict[s]) > 4.819 and float(sorted_dict[s]) <= 5.802:\\n result = \\\"\\\"\\\"Congratulation! Based on world happiness report(2019), \\\\nyour country scored in the middle.\\\\n\\\"\\\"\\\"\\n prediction = \\\"\\\\nYou have a chance at being happy.\\\"\\n \\n #if score is around 5 ~ 6:\\n if float(sorted_dict[s]) > 5.802 and float(sorted_dict[s]) <= 6.785:\\n result = \\\"\\\"\\\"Congratulation! Based on world happiness report(2019), \\\\nyour country scored relatively high.\\\\n\\\"\\\"\\\"\\n prediction = \\\"\\\\nYou have many chances at being happy.\\\"\\n \\n #if score is around 6 ~ 7:\\n if float(sorted_dict[s]) > 6.785 and float(sorted_dict[s]) <= 7.769:\\n result = \\\"\\\"\\\"Congratulation! Based on world happiness report(2019), \\\\nyour country scored very high.\\\\n\\\"\\\"\\\"\\n prediction = \\\"\\\\nYou have an abundance of chances at being happy.\\\"\\n\\n #finalize response\\n response = result + prediction+ \\\"\\\\n\\\" + s + \\\"\\\"\\\"'s score: \\\"\\\"\\\" + str(sorted_dict[s])\\n\\n self.var1.set(response)\",\n \"def display_menu():\\n print(\\\"\\\"\\\"\\\\nChoose option:\\n (1) List statistics\\n (2) Display 3 cities with longest names\\n (3) Display county's name with the largest number of communities\\n (4) Display locations, that belong to more than one category\\n (5) Advanced search\\n (0) Exit program\\\"\\\"\\\")\",\n \"async def cmd_choose(self, args: Args, **_):\\n response = \\\"From what you gave me, I believe `{}` is the best choice\\\".format(\\n args[randint(0, len(args) - 1)]\\n )\\n return response\",\n \"def show_main_screen():\\n option = algo_selection(algos)\\n if option == 1:\\n print_factorial()\\n show_main_screen()\\n if option == 2:\\n print_gcd()\\n show_main_screen()\\n if option == 3:\\n print_pow()\\n show_main_screen()\\n if option == 4:\\n print_towers()\\n show_main_screen()\\n if option == 5:\\n print_permutations()\\n show_main_screen()\\n if option == 6:\\n raise SystemExit(0)\",\n \"def selection_input(\\n self,\\n prompt,\\n choices,\\n default=None,\\n error_message=\\\"Invalid Selection\\\",\\n transform=None\\n ):\\n while True:\\n result = self.text_input(prompt, default)\\n\\n if transform is not None and result is not None:\\n result = transform(result)\\n\\n if result in choices:\\n return result\\n\\n print()\\n print(error_message)\",\n \"def test_choice(self):\\n merged = reduce_choice(\\n [\\n map_choice(\\n \\\"hello\\\",\\n 1,\\n token=0,\\n token_logprob=0,\\n top_logprobs={},\\n text_offset=0,\\n finish_reason=None,\\n ),\\n map_choice(\\n \\\" world\\\",\\n 1,\\n token=1,\\n token_logprob=0,\\n top_logprobs={},\\n text_offset=5,\\n finish_reason=\\\"stop\\\",\\n ),\\n ]\\n )\\n\\n assert merged[\\\"text\\\"] == \\\"hello world\\\"\\n assert merged[\\\"index\\\"] == 1\\n assert merged[\\\"finish_reason\\\"] == \\\"stop\\\"\\n assert len(merged[\\\"logprobs\\\"][\\\"tokens\\\"]) == 2\",\n \"def main():\\n splitted_file = convert_input_to_list()\\n encyclopedia_of_pizza = parse_pizza_info(splitted_file)\\n pizza_winner = choose_pizza(encyclopedia_of_pizza)\\n print_winner(pizza_winner)\",\n \"def main_menu_input(self):\\n if self.choice_menu == \\\"1\\\":\\n self.category_choice()\\n elif self.choice_menu == \\\"2\\\":\\n print(fr.FR[9])\\n for element in self.substitution_table.get_substitution():\\n for substitution in element:\\n sub_prod = self.product_table.get_product(substitution)\\n print(sub_prod[0][1] + \\\" - \\\"\\n + sub_prod[0][2] + \\\" - \\\"\\n + sub_prod[0][3] + \\\" - \\\"\\n + sub_prod[0][4])\\n print(\\\"\\\\n\\\")\\n elif self.choice_menu == \\\"3\\\":\\n self.initialise_bdd()\\n self.save_product_bdd()\\n elif self.choice_menu == \\\"4\\\":\\n self.leave_main_menu -= 1\",\n \"async def choices(self, ctx, *, options):\\n choices = options.split('-')\\n choice = random.choice(choices)\\n await ctx.send(f'My choice is\\\\\\\"{choice}\\\\\\\"')\",\n \"def InputMenuChoice():\\r\\n choice = str(input(\\\"Which option would you like to perform? [1 to 4] - \\\")).strip()\\r\\n print() # Add an extra line for looks\\r\\n return choice\",\n \"def _print_enum_opt(self, option, choices):\\n for key in choices:\\n if key == self.conf[option]:\\n print(\\\"* %s\\\" % key)\\n else:\\n print(\\\" %s\\\" % key)\",\n \"def henhouseDisplayMenu () :\\r\\n print('1.Predict egg production')\\r\\n print('2.Display needs')\\r\\n print('0.Exit henhouse management')\\r\\n print()\\r\\n print('Please choose an option from the above menu')\",\n \"def main():\\n\\n # Initialize Selection Value\\n selection = -1\\n # Square and Cube program\\n while selection:\\n # Display Menu\\n print('Welcome to the Square and Cube Program')\\n print('Main Menu')\\n print('1.Display Square and Cube Values')\\n print('2.Display the Union of Square and Cube sets')\\n print('3. Display intersection of Square and Cube sets')\\n print('4. Display Difference of Square and Cube sets ')\\n print('5.Search for individual intergers')\\n print('6.Quit Application')\\n\\n # Program takes in input\\n print(\\\"Enter selection: \\\")\\n selection = int(input())\\n\\n if selection == 1:\\n print(sorted(square()))\\n print(sorted(cube()))\\n\\n elif selection == 2:\\n print(square_cube_union())\\n\\n elif selection == 3:\\n print(inter_of_sets())\\n\\n elif selection == 4:\\n print(difference_of_sets())\\n\\n elif selection == 5:\\n print(search_int())\\n\\n elif selection == 6:\\n end_program()\\n\\n else:\\n print('Invalid entry')\",\n \"def print_menu():\\r\\n print(\\\"==============================================\\\")\\r\\n print(\\\"What do you want to do now? \\\")\\r\\n print(\\\"==============================================\\\")\\r\\n print(\\\"Available options:\\\")\\r\\n i = 1\\r\\n for a in available_actions:\\r\\n if current_state in a[\\\"valid_states\\\"]:\\r\\n # Only hint about the action if the current state allows it\\r\\n print(\\\" %i) %s\\\" % (i, a[\\\"description\\\"]))\\r\\n i += 1\\r\\n print()\",\n \"def display_user_options():\\r\\n print(\\\"Please choose an option [e/d/a/q]:\\\")\\r\\n print(\\\" e) Encrypt some text\\\")\\r\\n print(\\\" d) Decrypt some text\\\")\\r\\n print(\\\" a) Automatically decrypt English text\\\")\\r\\n print(\\\" q) Quit\\\")\",\n \"def search_method_menu(self):\\n\\n print()\\n options = {'1': 'Employee Name', '2': 'Keyword', '3': 'Time Spent',\\n '4': 'Date', '5': 'Date Range', '6': 'Exit to main menu'}\\n\\n while True:\\n\\n for k, v in options.items():\\n print(k + \\\". \\\" + v)\\n\\n user_choice = input('\\\\nPlease enter the number of choice: ').lower().strip()\\n\\n if user_choice in options.keys():\\n return options.get(user_choice)\\n else:\\n print('\\\\nInvalid choice! Please try again.\\\\n')\",\n \"def main():\\n raw_input()\\n factors = map(int, raw_input().split(' '))\\n elements = map(int, raw_input().split(' '))\\n print between_two_sets(factors, elements)\",\n \"async def randomChoice(self, ctx: commands.Context, *choices: str):\\n if not choices:\\n await ctx.reply(f\\\"Command failed - no arguments given.\\\\nEnter a sequence of arguments to choose from (you can use quotes for grouping).\\\", mention_author=False)\\n elif len(choices)==1:\\n await ctx.reply(f\\\"After some extremely randomized choosing from the one singular option that was given to choose from, the surprising result is:\\\\n{choices[0]}\\\", mention_author=False)\\n else:\\n await ctx.reply(f\\\"Randomly chosen result:\\\\n{random.choice(choices)}\\\", mention_author=False)\",\n \"def handle_selection_main(self):\\n choice = self.get_input()\\n if choice == '1':\\n self.display_cust()\\n elif choice == '2':\\n self.is_user = False\\n self.display_eng()\",\n \"def basic_menu(dict_of_options, back=False):\\n choose = True\\n dict_of_options = final_option(dict_of_options, back)\\n list_of_options = list(dict_of_options.keys())\\n\\n while choose:\\n print('The following options are available:\\\\n')\\n for option in enumerate(list_of_options):\\n print('\\\\t{} - {}'.format(option[0], option[1]))\\n pick = input('\\\\nType the numeric code you wish to run\\\\n\\\\n')\\n if pick in [str(i) for i in range((len(dict_of_options)))]:\\n choose = dict_of_options[list_of_options[int(pick)]]()\\n else:\\n print('{} is not currently an option!\\\\n'.format(pick))\",\n \"def display_choices(self, word_group, selection_list):\\n code = 1\\n print(f'Primary word: {word_group[0]}')\\n selection_list.append(word_group[1])\\n\\n # randomize it\\n random.shuffle(selection_list)\\n for choice in enumerate(selection_list):\\n print(f'{choice[0]} ---> {choice[1]}')\\n if word_group[1] == choice[1]:\\n code = choice[0]\\n return code\",\n \"def quiz_selection():\\n\\n verbs = crud.get_verbs()\\n tenses = crud.get_tenses()\\n\\n return render_template(\\\"verb-conjugation.html\\\", verbs=verbs, tenses=tenses)\",\n \"def run(self):\\n # Gets the number of habits that exist in the habits table\\n number_of_habits = len(self.analytics.habits_table())\\n # Gets the number of trackings that exist in the trackings table\\n number_of_trackings = len(self.analytics.trackings_table())\\n\\n while True:\\n # Display a menu depending on the number of habits and trackings\\n self.display_menu()\\n choice = pyip.inputNum(\\\"Enter an number: \\\")\\n if (number_of_habits == 0) and (choice in [0, 1]):\\n action = self.menu_options.get(str(choice))\\n action()\\n elif (number_of_habits == 1) and (choice in [0, 1, 2, 3, 4]):\\n action = self.menu_options.get(str(choice))\\n action()\\n elif (number_of_habits > 1) and (choice in [0, 1, 2, 3, 4, 5, 6]):\\n action = self.menu_options.get(str(choice))\\n action()\\n elif number_of_trackings > 0 and (choice in [0, 1, 2, 3, 4, 5, 6, 7]):\\n action = self.menu_options.get(str(choice))\\n action() \\n else:\\n print('Choose a number from the list')\",\n \"def main():\\n answers_style = drink_style_input()\\n drink = drink_make(answers_style)\\n print \\\"\\\"\\n print \\\"Your drink includes:\\\"\\n for ingredient in drink:\\n print \\\"A {}\\\".format(ingredient)\",\n \"def main():\\n seq = [48, 11, 45, 92, 32, 61, 65, 57, 29, 96]\\n print(selection_sort(seq))\",\n \"async def choose(self, ctx):\\r\\n if len(str(ctx.message.content)) < 9:\\r\\n await self.bot.say('{}, the usage is **!choose Option 1; Option 2; Option 3**, until you run out of options.'.format(ctx.message.author.mention))\\r\\n else:\\r\\n choices = str(ctx.message.content[8:])\\r\\n if '; ' not in choices:\\r\\n await self.bot.say('{}, the usage is **!choose Option 1; Option 2; Option 3**, ntil you run out of options.'.format(ctx.message.author.mention))\\r\\n else:\\r\\n options = choices.split('; ')\\r\\n await self.bot.say('{}, I choose: **{}**.'.format(ctx.message.author.mention,random.choice(options)))\",\n \"def main():\\n num_of_tests = int(input())\\n\\n # iterate over test cases\\n for test_case in range(1, num_of_tests + 1):\\n result = handle_case()\\n printable_result = handle_result(result)\\n print(\\\"Case #{}: {}\\\".format(test_case, printable_result))\",\n \"def main(models_str, choices_str, trace_strings):\\n packed_models = json.loads(models_str)\\n models = []\\n for i, obj in enumerate(packed_models):\\n try:\\n models.append(unpack(obj, player.PlayerModel))\\n except Exception as e:\\n raise ValueError(\\n \\\"Failed to unpack player model #{}\\\".format(i)\\n ) from e\\n\\n packed_choices = json.loads(choices_str)\\n choices = []\\n for i, obj in enumerate(packed_choices):\\n try:\\n choices.append(unpack(obj, choice.Choice))\\n except Exception as e:\\n raise ValueError(\\n \\\"Failed to unpack choice #{}\\\".format(i)\\n ) from e\\n\\n traces = { fn: json.loads(trace_strings[fn]) for fn in trace_strings }\\n\\n results = {\\n tr: analyze_trace(models, choices, traces[tr]) for tr in traces\\n }\\n\\n all_decisions = {}\\n for ch in choices:\\n cn = ch.name\\n if cn not in all_decisions:\\n all_decisions[cn] = {}\\n for tr in traces:\\n for tch in traces[tr]:\\n add_to = all_decisions[tch[0]]\\n if tch[1] in add_to:\\n add_to[tch[1]] += 1\\n else:\\n add_to[tch[1]] = 1\\n\\n overall_per_choice = combine_per_choice(*[res[2] for res in results.values()])\\n\\n # TODO: More formatting here\\n for tn in results:\\n res = results[tn]\\n print(\\\"Averages for {}:\\\".format(tn))\\n for model in models:\\n pmn = model.name\\n print(\\\" {:.3g} {}\\\".format(res[0][pmn], pmn))\\n print('-'*80)\\n\\n for cn in overall_per_choice:\\n times, agreements = overall_per_choice[cn]\\n print(\\\"Choice: '{}' (seen {} times)\\\".format(cn, times))\\n print(\\\"Decisions:\\\")\\n for dc in all_decisions[cn]:\\n print(\\\" {}: {}\\\".format(dc, all_decisions[cn][dc]))\\n print(\\\"Model agreement:\\\")\\n for pmn in agreements:\\n print(\\\" {}: {:.3g}\\\".format(pmn, agreements[pmn]))\\n print('-'*80)\",\n \"def get_answer(option_list):\\n # Print the options\\n print(\\\"Options:\\\")\\n for i in range(len(option_list)):\\n print(f\\\"{i + 1}. {option_list[i]}\\\")\\n\\n # Return the selected option from the user\\n while True:\\n try:\\n selection = int(input(\\\">>>\\\"))\\n if 1 <= selection <= len(option_list):\\n print()\\n return selection\\n else:\\n raise ValueError\\n except ValueError:\\n print(f\\\"Invalid option: Must be a number between 1 and {len(option_list)}\\\")\",\n \"def main():\\n\\t# GET THE DIALOG CONTENT\\n\\tpolicyFlag = int(sys.argv[3])\\n\\tif policyFlag == 0:\\n\\t\\texistedIterNum = 15000\\n\\t\\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05'\\n\\telif policyFlag == 1:\\n\\t\\texistedIterNum = 10000\\n\\t\\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05Retroflex'\\n\\n\\tqLearnOpts = {'gamma': 1.0, \\n\\t\\t\\t\\t 'alpha': 0.0, \\n\\t\\t\\t\\t 'epsilon': 0.0}\\n\\tnumOfTurn = util.returnConvertedIndexListCount('b','cycle_tree')\\n\\tnumofgauss = 5\\n\\tvar = 0.0625\\n\\tlamda = 0.05\\n\\tunitNum = 101\\n\\ta = qlearningAgents.FittedQLearningAgent(numOfTurn,numofgauss,var,lamda,unitNum, **qLearnOpts)\\t\\t\\n\\ta.openThetaFile(existedThetaFileName,existedIterNum)\\n\\n\\tturnNum = int(sys.argv[1])\\n\\tuserUnitScore = []\\n\\tuserUnitScoreVector = sys.argv[2].split(',')\\n\\tfor i in userUnitScoreVector:\\n\\t\\t\\tuserUnitScore.append(float(i)/100.0)\\n\\n\\tstate = State.State(turnNum, userUnitScore)\\n\\tprint a.getAction(state)\",\n \"def menu():\\n print('Selecciona el tipo de problema',end='\\\\n') \\n print('-----------------------------------------')\\n print('1) Conduccion de calor estacionaria, conductividad constante ',end='\\\\n')\\n print('2) Conduccion de calor, ecuacion de Poisson condicion tipo Dirichlet ',end='\\\\n')\\n print('3) Conduccion de calor, ecuacion de Poisson condicion tipo Neumman',end='\\\\n')\\n print('4) Conduccion de calor, ecuacion de Poisson conductividad no constante',end='\\\\n')\\n try:\\n seleccion=int(input())\\n except:\\n print(\\\"No seas ñero\\\")\\n sys.exit()\\n return seleccion\",\n \"def display_choose(self, text, choices):\\n cur_index = 0\\n key = None\\n while key != 'KEY_NEWLINE':\\n if key == 'KEY_UP':\\n cur_index = max(cur_index - 1, 0)\\n elif key == 'KEY_DOWN':\\n cur_index = min(cur_index + 1, len(choices) - 1)\\n self.stdscr.erase()\\n for line in text:\\n self.stdscr.addstr(f'{PADCHAR}{line}\\\\n')\\n for index, value in enumerate(choices):\\n self.stdscr.addstr('\\\\n')\\n self.stdscr.addstr(PADCHAR)\\n self.stdscr.addstr(value, color_pair(7 if index == cur_index else 1))\\n self.stdscr.addstr(f'\\\\n\\\\n{PADCHAR}') \\n key = self.get_key() \\n return cur_index\",\n \"def main_menu(): \\r\\n \\r\\n print(\\\"Please enter in the major for the class you need to study for: \\\")\\r\\n print(\\\"1. for Electrical Engineering\\\")\\r\\n print(\\\"2. for Bioengineering\\\")\\r\\n print(\\\"3. for Chemcial Engineering\\\")\\r\\n print(\\\"4. for Mechanical Engineering\\\")\\r\\n print(\\\"5. for Civil Engineering\\\")\\r\\n print(\\\"6. for Biology\\\")\\r\\n print(\\\"7. for Data Analytics\\\")\\r\\n print(\\\"8. for Chemistry\\\")\\r\\n choice = input()\\r\\n return choice\",\n \"def _choice_a_filter(self, possibles):\\n print(\\\"Avaliable Filters:\\\")\\n for i, filter in enumerate(possibles):\\n print(f\\\"{i+1} - {filter.name}\\\")\\n\\n option = 0\\n while option <= 0 or option > len(possibles):\\n try:\\n option = int(input(\\\"\\\\nType the selected filter number: \\\"))\\n except ValueError:\\n continue\\n\\n return possibles[option - 1]\",\n \"def menu():\\n\\tprint (\\\"\\\\n\\\\tSeleccionar una opcion\\\")\\n\\n\\tprint (\\\"\\\\t1.- Resistencia en un Alambre \\\")\\n\\n\\tprint (\\\"\\\\t2.- Voltaje\\\")\\n\\n\\tprint (\\\"\\\\t3.- Corriente\\\")\\n\\n print (\\\"\\\\t4.- Resistencia\\\")\\n\\n\\tprint (\\\"\\\\t5.- salir\\\")\",\n \"def basic_menu_non_functional(list_of_options):\\n choose = True\\n list_of_options.append('back')\\n\\n while choose:\\n print('The following options are available:\\\\n')\\n for option in enumerate(list_of_options):\\n print('\\\\t{} - {}'.format(option[0], option[1]))\\n picks = input('\\\\nType the numeric codes you wish to run\\\\n\\\\n').split(',')\\n choice = []\\n if str(len(list_of_options)) in picks:\\n return True\\n for pick in picks:\\n if pick in [str(i) for i in range((len(list_of_options)))]:\\n choice.append(list_of_options[int(pick)])\\n else:\\n print('{} is not currently an option!\\\\n'.format(pick))\\n if len(choice) > 0:\\n return choice\",\n \"def get_user_input(choice_list,data_name):\\r\\n # ref https://stackoverflow.com/questions/58449700/how-to-create-a-sub-program-that-takes-user-input\\r\\n\\r\\n input_num = 0\\r\\n\\r\\n while True:\\r\\n # print out the options\\r\\n for i in range(len(choice_list)):\\r\\n print(str(i+1)+\\\":\\\", choice_list[i])\\r\\n # try to get the user to select an option\\r\\n try:\\r\\n input_num = int(input(\\\"Enter the number that represents the {0}:\\\".format(data_name)))\\r\\n if input_num in range(1, len(choice_list)+1):\\r\\n return_value = choice_list[input_num-1]\\r\\n print('Great, you have choosen the ' + data_name + \\\": \\\" + return_value + '\\\\n')\\r\\n return return_value\\r\\n else:\\r\\n print(\\\"invalid choice, please try again\\\")\\r\\n except ValueError:\\r\\n print('Thats not a valid number please try again')\\r\\n continue\",\n \"def printOptions(opts,subject_ids,session_ids,task_list, run_list, acq, rec):\\n uname = os.popen('uname -s -n -r').read()\\n print \\\"\\\\n\\\"\\n print \\\"* Pipeline started at \\\"+time.strftime(\\\"%c\\\")+\\\"on \\\"+uname\\n print \\\"* Command line is : \\\\n \\\"+str(sys.argv)+\\\"\\\\n\\\"\\n print \\\"* The source directory is : \\\"+opts.sourceDir\\n print \\\"* The target directory is : \\\"+opts.targetDir+\\\"\\\\n\\\"\\n print \\\"* Data-set Subject ID(s) is/are : \\\"+str(', '.join(subject_ids))+\\\"\\\\n\\\"\\n # print \\\"* PET conditions : \\\"+ ','.join(opts.condiList)+\\\"\\\\n\\\"\\n print \\\"* Sessions : \\\", session_ids, \\\"\\\\n\\\"\\n print \\\"* Tasks : \\\" , task_list , \\\"\\\\n\\\"\\n print \\\"* Runs : \\\" , run_list , \\\"\\\\n\\\"\\n print \\\"* Acquisition : \\\" , acq , \\\"\\\\n\\\"\\n print \\\"* Reconstruction : \\\" , rec , \\\"\\\\n\\\"\",\n \"def choose_display():\\n\\n choices = [\\\"d\\\",\\\"theta\\\",\\\"both\\\"]\\n\\n temp_choice = \\\"false\\\"\\n\\n while temp_choice not in choices:\\n temp_choice = input(\\\"Please choose the scale to display.\\\\nd, theta, both\\\\n\\\")\\n if temp_choice not in choices:\\n print(\\\"incorrect choice\\\\n\\\")\\n\\n return temp_choice\",\n \"def get_choice(list_of_games, num_games, num_pages=None, current_page=None):\\n\\tif current_page == 0:\\n\\t\\ttext = Fore.WHITE + 'Options: Display (' + Fore.GREEN + 'N' + Fore.WHITE + ')ext page, (' + Fore.MAGENTA + \\\\\\n\\t\\t 'C' + Fore.WHITE + ')urrent page, (' + Fore.RED + 'Q' + Fore.WHITE + ')uit or enter the ' + Fore.CYAN + \\\\\\n\\t\\t 'Number' + Fore.WHITE + ' of the game to play'\\n\\telse:\\n\\t\\ttext = Fore.WHITE + 'Options: Display (' + Fore.BLUE + 'P' + Fore.WHITE + ')revious page, (' + Fore.GREEN + \\\\\\n\\t\\t 'N' + Fore.WHITE + ')ext page, (' + Fore.MAGENTA + 'C' + Fore.WHITE + ')urrent page, (' + \\\\\\n\\t\\t Fore.RED + 'Q' + Fore.WHITE + ')uit or enter the ' + Fore.CYAN + 'Number' + Fore.WHITE + ' of the game to play'\\n\\n\\tprint '\\\\n' + text\\n\\tindex = raw_input(Fore.WHITE + Style.BRIGHT + 'What would you like to do?: ').lower()\\n\\twhile index != 'p' or index != 'n' or index != 'd' or index.isdigit():\\n\\t\\tif index == 'c':\\n\\t\\t\\tos.system('clear')\\n\\t\\t\\tif num_pages:\\n\\t\\t\\t\\tlist_columns(list_of_games)\\n\\t\\t\\t\\tprint '\\\\nDisplaying page {} of {}'.format(current_page, num_pages)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tlist_columns(list_of_games)\\n\\t\\t\\tprint text\\n\\t\\telif index == 'p':\\n\\t\\t\\tbreak\\n\\t\\telif index == 'n':\\n\\t\\t\\tbreak\\n\\t\\telif index == 'q':\\n\\t\\t\\tsys.exit()\\n\\t\\telif index.isdigit():\\n\\t\\t\\tif 0 < int(index) < num_games:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint Fore.RED + '\\\\nSorry that is not a valid choice!'\\n\\t\\t\\tprint text\\n\\t\\tindex = raw_input(Fore.WHITE + Style.BRIGHT + 'What would you like to do?: ')\\n\\n\\treturn index\",\n \"def main():\\n print(\\\"Select from menu:\\\")\\n print(\\\"1. Add\\\")\\n print(\\\"2. Minus\\\")\\n print(\\\"3. Multiple\\\")\\n print(\\\"4. Divide\\\")\\n\\n choice = int(input(\\\"Enter your choice: \\\"))\\n a = int(input(\\\"Enter first value: \\\"))\\n b = int(input(\\\"Enter second value: \\\"))\\n\\n input_dict = {1: sum(a, b), 2: subtract(a, b), 3: multiply(a, b), 4: divide(a, b)}\\n answer_dict = {1: \\\"sum\\\", 2: \\\"difference\\\", 3: \\\"product\\\", 4:\\\"quotient\\\"}\\n print(\\\"The {0} of {1} and {2} is {3}.\\\".format(answer_dict.get(choice),\\n a,\\n b,\\n input_dict.get(choice, \\\"Invalid input. Select from menu.\\\")))\",\n \"def prompt(text, choices):\\n text += \\\" [\\\" + \\\"/\\\".join(choices) + \\\"] \\\"\\n while True:\\n inp = input(text)\\n if inp in choices:\\n return inp\",\n \"def play():\\n display_starting_message()\\n print(\\\"\\\")\\n print(\\\"*\\\"*10)\\n for question_number, question in enumerate(list_of_questions):\\n print(question)\\n print(\\\"\\\")\\n for responses in list_of_questions[question]:\\n print(responses)\\n pick_one = input(\\\"pick one: \\\")\\n check_murder_sauce(question, pick_one)\\n\\n murder_sauce_result(murder_sauce)\",\n \"async def choose(self, ctx, *args):\\n query = \\\" \\\".join(args)\\n choices = query.split(\\\" or \\\")\\n if len(choices) < 2:\\n await ctx.send(\\\"Give me at least 2 options to choose from! (separate options with `or`)\\\")\\n self.logger.warning(misolog.format_log(ctx, f\\\"1 option\\\"))\\n return\\n choice = rd.choice(choices).strip()\\n await ctx.send(f\\\"I choose **{choice}**\\\")\\n self.logger.info(misolog.format_log(ctx, f\\\"{choice}\\\"))\",\n \"def question():\\n print('Enter 1 to search database by habitat with detailed information\\\\nEnter 2 to search database by coordinates \\\\nEnter 3 to search by habitat in csv file for a quick overview without detail')\\n print('habitat search options so far:\\\\n Alpenvorland, Niederrheinisches Tiefland, Oberrheinisches Tiefland')\\n src = int(input('Enter here:'))\\n\\n if src == 1:\\n habitat = input('Enter name of habitat\\\\n')\\n query = \\\"habitat = '\\\" + habitat + \\\"'\\\"\\n search_db_via_query(query)\\n elif src == 2:\\n search_by_coordinates()\\n elif src == 3:\\n search_by_habitat()\\n else:\\n print('no data')\",\n \"async def choose(self, ctx, *, choices: str):\\n await ctx.send(\\n self.bot.bot_prefix + 'I choose: ``{}``'.format(random.choice(choices.split(\\\"|\\\"))))\",\n \"def main():\\n is_program_working = True\\n while is_program_working:\\n display.print_program_menu(MAIN_MENU)\\n try:\\n choose_option()\\n except ValueError as err:\\n display.print_command_result(str(err))\",\n \"def __ui_choose_statistics(self):\\n print(\\\"Please choose one statistic from below:\\\\n\\\"\\n \\\" 1. Find all activities for a given date, in the order of their start time\\\\n\\\"\\n \\\" 2. Check the availability of the upcoming days\\\\n\\\"\\n \\\" 3. Find all the activities performed together with a certain person\\\\n\\\")\\n user_choice = input(\\\"Type your option: \\\").strip()\\n print(\\\"\\\")\\n if user_choice == \\\"1\\\":\\n self.__ui_search_activities_by_date()\\n elif user_choice == \\\"2\\\":\\n self.__ui_find_busiest_days()\\n elif user_choice == \\\"3\\\":\\n self.__ui_find_activities_by_participant()\\n else:\\n print(\\\"Invalid option!\\\\n\\\")\\n return\",\n \"def get_user_choice(options: list, prompt: str) -> str:\\n choice = False\\n while not validate_user_choice(choice, options):\\n print(prompt)\\n for num, option in enumerate(options, 1):\\n print(f\\\"{num} - {option}\\\")\\n choice = input('\\\\nPlease enter the number corresponding to your choice here: ')\\n return choice\",\n \"def print_solution():\\n pass\",\n \"def print_menu():\\n print()\\n print(\\\"Main Menu\\\")\\n print(\\\"---------\\\")\\n print(\\\"1 - Process a new data file\\\")\\n print(\\\"2 - Choose units\\\")\\n print(\\\"3 - Edit room filter\\\")\\n print(\\\"4 - Show summary statistics\\\")\\n print(\\\"5 - Show temperature by date and time\\\")\\n print(\\\"6 - Show histogram of temperatures\\\")\\n print(\\\"7 - Quit\\\")\\n print()\",\n \"def menu(self, prompt, choices):\\n menu = [prompt] + [\\n \\\"{0}. {1}\\\".format(*choice) for choice in enumerate(choices, start=1)\\n ]\\n command = 'inputlist({})'.format(repr(menu))\\n choice = int(self._vim.eval(command))\\n\\n # Vim returns weird stuff if user clicks outside choices with mouse\\n if not 0 < choice < len(menu):\\n return\\n\\n return choices[choice - 1]\",\n \"def bonus_main():\\n\\n if len(sys.argv) != 3 or sys.argv[2] != \\\"-f\\\": \\n raise error.Usage(extra=\\\" [-f]\\\")\\n get_data()\\n courses = Features.titles[6:]\\n Courses.courses = courses\\n get_courses()\\n\\n found = find_perfect_fit()\\n c = found[\\\"combo\\\"]\\n print(found, f\\\"\\\\nCourses:\\\\n{c[0]} - {courses[c[0]]}\\\",\\n f\\\"\\\\n{c[1]} - {courses[c[1]]}\\\\n{c[2]} - {courses[c[2]]}\\\",\\n f\\\"\\\\n{c[3]} - {courses[c[3]]}\\\\n{c[4]} - {courses[c[4]]}\\\")\",\n \"def choose_from_list(query_category, query_list):\\n print('Choose the {cat} you want from the below list:'.format(\\n cat=query_category))\\n for counter, value in enumerate(query_list):\\n print('{counter}: {value}'.format(counter=counter, value=value))\\n selection = input('Choice: ')\\n return query_list[int(selection)]\",\n \"def select_option(options, choice):\\n choices = []\\n txt = \\\"\\\"\\n last = len(options) - 1\\n for opt in options:\\n if options.index(opt) == 0:\\n txt += \\\"'\\\" + str(opt) + \\\"'\\\"\\n elif options.index(opt) == last:\\n txt += \\\" and '\\\" + str(opt) + \\\"'\\\"\\n else:\\n txt += \\\", '\\\" + str(opt) + \\\"'\\\"\\n choices.append({'name': opt})\\n\\n question = [\\n {\\n 'type': 'list',\\n 'message': 'The similarities between \\\\'' + choice + '\\\\' with ' + txt + ' are equal. Choose the one to consider.',\\n 'name': 'option',\\n 'choices': choices\\n }\\n ]\\n\\n answer = prompt(question, style=style)\\n return answer.get(\\\"option\\\")\",\n \"def project_visibility_menu():\\n projects = [i.split('.')[0] for i in os.listdir('HousingPriceScraper/HousingPriceScraper/spiders/SpiderGroups')[:-1]]\\n print('Available projects are:\\\\n')\\n for project in enumerate(projects):\\n print('\\\\t{} - {}'.format(project[0], project[1]))\\n print('\\\\t{} - back'.format(len(projects)))\\n choices = input('\\\\nType the options you wish to select.\\\\nFor multiple, comma separate\\\\n\\\\n').split(',')\\n if str(len(projects)) in choices:\\n return True\\n else:\\n choice_list = []\\n for choice in choices:\\n if choice.isdigit() and int(choice) in range(len(projects)):\\n choice_list.append(projects[int(choice)])\\n print('You have selected to display the following spider groupings:\\\\n\\\\t{}\\\\n'.format(choice_list))\\n save_list_to_txt(choice_list, 'HousingPriceScraper/HousingPriceScraper/configs/visible_projects_to_scrape.txt')\\n return True\",\n \"def build_dataset_prompt():\\n\\n print(\\\"\\\")\\n print(\\\"Let's start by choosing what features you'd like to look at/explore!\\\")\",\n \"async def choose(*choices : str):\\n await bot.say(random.choice(choices))\",\n \"def select_program(self):\\r\\n\\r\\n path_data = self.json_data # Deserialize json\\r\\n print(' '+path_data['title'] + '\\\\n\\\\n ' + path_data['desc'] + '\\\\n\\\\n' +\\r\\n path_data['path']['desc']) # Print title\\r\\n for option in path_data['path']['options']: # Print list of functions\\r\\n print(str(option['num'])+'. '+option['desc'])\\r\\n scenario = input()\\r\\n if scenario == '0':\\r\\n self.install_vk_api_for_python()\\r\\n elif scenario == '1':\\r\\n self.vk_sign_in()\\r\\n self.download_pics_from_dialogs()\\r\\n elif scenario == '2':\\r\\n self.vk_sign_in()\\r\\n self.tag = input('По какому тегу будем искать людей? (0 для отмены)\\\\n')\\r\\n if self.tag != '0':\\r\\n self.get_users_pool()\\r\\n self.get_friends_numbers()\\r\\n else:\\r\\n self.tag = None\\r\\n elif scenario == '3':\\r\\n counter = self.count_ffn()\\r\\n self.check_for_build_plot(counter)\\r\\n elif scenario == '4':\\r\\n self.vk_token_sing_in()\\r\\n self.find_most_popular()\\r\\n else:\\r\\n print('Ошибка ввода, попробуйте еще раз')\\r\\n time.sleep(0.5)\\r\\n self.select_program()\\r\\n print('Возвращаемся в главное меню...')\\r\\n time.sleep(1)\\r\\n self.select_program()\",\n \"def mainMenuChoice():\\r\\n print(\\\"What would you like to do?\\\")\\r\\n print(\\\" n) Add a class\\\")\\r\\n print(\\\" d) Delete a class\\\")\\r\\n print(\\\" e) Edit a class\\\")\\r\\n print(\\\" s) Show ongoing list of classes\\\")\\r\\n print(\\\" p) Print Schedule to Terminal\\\")\\r\\n print(\\\" g) Generate schedule in csv and print to Terminal\\\")\\r\\n print(\\\" q) Save and Exit program\\\\n\\\")\\r\\n \\r\\n choice = input(\\\"Input choice here: \\\")\\r\\n \\r\\n if choice.lower() in [\\\"n\\\",\\\"d\\\",\\\"e\\\",\\\"s\\\",\\\"g\\\",\\\"q\\\", \\\"p\\\"]:\\r\\n return choice\\r\\n else:\\r\\n print(\\\"\\\\nPlease enter a valid menu choice\\\")\\r\\n return None\",\n \"def select_spiders(spiders_dict):\\n print('Available spiders include:\\\\n')\\n enumerated_keys = list(enumerate(spiders_dict.keys()))\\n for key_group in enumerated_keys:\\n print('{} - {}'.format(key_group[0], key_group[1]))\\n for spider in zip(alphabet_list_length(len(key_group[1])), spiders_dict[key_group[1]]):\\n print('\\\\t{}{} - {}'.format(key_group[0], spider[0], spider[1].name))\\n print('{} - run all'.format(len(spiders_dict.keys())))\\n print('{} - back'.format(len(spiders_dict.keys())+1))\\n choices = input('\\\\nfor multiple, comma separate. To remove, use \\\"-\\\" prefix\\\\ni.e.: 0,-0a to run all of group 0 except the first\\\\n').replace(' ', '').split(',')\\n if str(len(spiders_dict.keys())+1) in choices:\\n return False\\n if str(len(spiders_dict.keys())) in choices:\\n chosen_spiders = list(spiders_dict.values())\\n else:\\n chosen_spiders = []\\n for choice in choices:\\n if choice.isdigit():\\n if choice in [str(i[0]) for i in enumerated_keys]:\\n chosen_spiders.append(spiders_dict[enumerated_keys[int(choice)][1]])\\n else:\\n print('{} is not an option!'.format(choice))\\n elif '-' not in choice:\\n numeric = re.findall(r'\\\\d+', choice)\\n if len(numeric) == 1:\\n alpha = choice.split(numeric[0])[1]\\n alpha = len(alphabet_list_length(0, index=alpha))-1\\n try:\\n chosen_spiders.append(spiders_dict[enumerated_keys[int(numeric[0])][1]][alpha])\\n except IndexError:\\n print('{} is not an option!'.format(choice))\\n else:\\n print('{} is not an option!'.format(choice))\\n if any(isinstance(el, list) for el in chosen_spiders):\\n chosen_spiders = flatten_list_of_lists(chosen_spiders, make_set=True)\\n else:\\n chosen_spiders = list(set(chosen_spiders))\\n to_remove = [choice for choice in choices if '-' in choice]\\n if len(to_remove) > 0:\\n for removee in to_remove:\\n if removee.replace('-', '').isdigit():\\n if removee.replace('-', '') in [str(i[0]) for i in enumerated_keys]:\\n for spider in spiders_dict[enumerated_keys[int(removee.replace('-', ''))][1]]:\\n chosen_spiders.remove(spider)\\n else:\\n print('{} is not an option!'.format(removee))\\n else:\\n numeric = re.findall(r'\\\\d+', removee)\\n if len(numeric) == 1:\\n alpha = removee.split(numeric[0])[1]\\n alpha = len(alphabet_list_length(0, index=alpha)) - 1\\n try:\\n chosen_spiders.remove(spiders_dict[enumerated_keys[int(numeric[0])][1]][alpha])\\n except IndexError:\\n print('{} is not an option!'.format(removee))\\n else:\\n print('{} is not an option!'.format(removee))\\n if len(chosen_spiders) > 0:\\n return chosen_spiders\\n else:\\n print(\\\"You haven't selected any spiders!\\\")\\n return False\",\n \"def visualizeChosenOptions(self):\\n \\n # Visualising the results\\n plt.hist(self.opt_selected)\\n plt.title('Histogram of ads selections')\\n plt.xlabel('Ads')\\n plt.ylabel('Number of times each ad was selected')\\n plt.show()\",\n \"def select(self, options, prompt='Your choice? '):\\n local_opts = options\\n if isinstance(options, string_types):\\n local_opts = list(zip(options.split(), options.split()))\\n fulloptions = []\\n for opt in local_opts:\\n if isinstance(opt, string_types):\\n fulloptions.append((opt, opt))\\n else:\\n try:\\n fulloptions.append((opt[0], opt[1]))\\n except IndexError:\\n fulloptions.append((opt[0], opt[0]))\\n for (idx, (value, text)) in enumerate(fulloptions):\\n self.poutput(' %2d. %s\\\\n' % (idx + 1, text))\\n while True:\\n response = sm.input(prompt)\\n try:\\n response = int(response)\\n result = fulloptions[response - 1][0]\\n break\\n except (ValueError, IndexError):\\n self.stdout.write(\\\"{!r} isn't a valid choice. Pick a number \\\"\\n \\\"between 1 and {}:\\\\n\\\".format(\\n response, len(fulloptions)))\\n return result\",\n \"def main():\\n data = []\\n\\n menu_text = \\\"\\\"\\\"\\n 1. Display all records\\n 2. Add new record\\n 3. Edit existing record\\n 4. Delete record \\n 5. Quit\\n \\\"\\\"\\\"\\n\\n while True:\\n print(menu_text)\\n choice = input('Enter your choice: ')\\n if choice == '1':\\n display_all_records()\\n elif choice == '2':\\n add_new_record(data)\\n elif choice == '3':\\n results = find_player()\\n\\n if results:\\n edit_existing_record(results)\\n else:\\n print(f'Player is not on our records\\\\n')\\n elif choice == '4':\\n delete_record()\\n elif choice == '5':\\n break\\n else:\\n print('Not a valid selection, please try again')\",\n \"def speakers_choice(self):\\n while self.choice != \\\"q\\\":\\n self.choice = input(\\\"\\\\033[35m(c) for create \\\\n(d) for delete \\\\n(s) for see \\\\n(r) for return start page \\\\n(q) for exit:\\\\033[0m\\\")\\n os.system('cls' if os.name == 'nt' else 'clear')\\n time.sleep(1)\\n if self.choice == \\\"c\\\":\\n name = input(\\\"\\\\033[32menter name:\\\\033[0m\\\")\\n lastname = input(\\\"\\\\033[32menter lastname:\\\\033[0m\\\")\\n description = input(\\\"\\\\033[32menter decription:\\\\033[0m\\\")\\n job = input(\\\"\\\\033[32menter job:\\\\033[0M\\\")\\n os.system('cls' if os.name == 'nt' else 'clear')\\n time.sleep(1)\\n self.user.create_speakers(name, lastname, description, job)\\n\\n if self.choice == \\\"d\\\":\\n id = input(\\\"\\\\033[32menter speakers ID :\\\\033[0m\\\")\\n os.system('cls' if os.name == 'nt' else 'clear')\\n time.sleep(1)\\n self.user.delete_speakers(id)\\n\\n if self.choice == \\\"s\\\":\\n datta = self.speakers.show_speakers()\\n if datta:\\n for elem in datta:\\n print(elem)\\n if self.choice == \\\"r\\\":\\n os.system('cls' if os.name == 'nt' else 'clear')\\n time.sleep(1)\\n return\\n\\n if self.choice == \\\"q\\\":\\n exit()\",\n \"def menu():\\n print\\n print \\\"(1) Enter the size and values of an array\\\"\\n print \\\"(2) Print the array\\\"\\n print \\\"(3) Multiply an array row by a constant\\\"\\n print \\\"(4) Add one row into another\\\"\\n print \\\"(5) Add a multiple of one row to another\\\"\\n print \\\"(6) Solve\\\"\\n print \\\"(9) Quit\\\"\\n\\n print \\\"Which choice would you like?\\\"\",\n \"def main():\\n songs = []\\n first_line = sys.stdin.readline().split(' ', 1)\\n songs_on_album, songs_to_select = int(first_line[0]), int(first_line[1])\\n for i in range(songs_on_album):\\n line = sys.stdin.readline().split(' ', 1)\\n song = Song(line[1], int(line[0]), i+1)\\n songs.append(song)\\n\\n print_quality_songs(songs, songs_to_select)\",\n \"async def watdo(self, ctx, *args):\\n choicelist = []\\n for choice in args:\\n choicelist.append(choice)\\n result = random.choice(choicelist)\\n await ctx.bot.send_message(ctx.message.channel, \\\"I pick {}!\\\".format(result))\",\n \"def get_choose():\\n global result, choose, win_update_concurrence, output1, confirmation, win_create_update_str, number_str\\n number_str = choose.get()\\n result = result[int(number_str) - 1]\\n output1.delete(1.0, END)\\n for i in result:\\n output1.insert(END, str(i) + '\\\\n')\\n confirmation.destroy()\\n confirmation = Label(win_create_update_str, text='Измените строку и нажмите \\\"Редактировать\\\"')\\n confirmation.place(x=15, y=40)\\n win_update_concurrence.destroy()\",\n \"def print_choice_menu():\\n month1 = input(\\\"Give the month as 4, 5, 6, 7, 8, or 9: \\\")\\n print()\\n day1 = input(\\\"Give the day as 1, 2, ..., 29, 30, or 31: \\\")\\n print()\\n\\n try:\\n month1 = int(month1)\\n day1 = int(day1)\\n\\n if month1 in [4, 5, 6, 7, 8, 9]:\\n if day1 in list(range(1, 32)):\\n if day1 == 31 and month1 in [4, 6, 9]:\\n print(\\\"Invalid Date!\\\")\\n sleep(2)\\n return 0, 0\\n elif month1 > datetime.now().month or (month1 == datetime.now().month and day1 > datetime.now().day):\\n print(\\\"Date out of bounds\\\")\\n sleep(2)\\n return 0, 0\\n else:\\n sleep(2)\\n return month1, day1\\n else:\\n print(\\\"Date out of bounds\\\")\\n sleep(2)\\n return 0, 0\\n else:\\n print(\\\"Date out of bounds\\\")\\n sleep(2)\\n return 0, 0\\n\\n except ValueError:\\n print(\\\"User Error\\\")\\n sleep(2)\\n return 0, 0\",\n \"def displaymenu(option):\\n DebugMessage(f\\\"\\\"\\\"def:displaymenu | option={option}\\\"\\\"\\\")\\n print(question)\\n print(\\\"Options:\\\" + str(option))\\n response = input(\\\"$> \\\")\\n\\n for opt in option:\\n if response.lower() == opt.lower():\\n DebugMessage(f\\\"User selected a valid option:{opt}\\\")\\n if opt == 'Quit':\\n exit(0)\\n return opt\\n print(f\\\"{response}, is not a valid option\\\")\\n print(gui_bar)\\n displaymenu(option)\",\n \"def get_choice(choices, conversation):\\n user_choice = None\\n while user_choice is None:\\n try:\\n user_input = input(\\\"\\\\nChoice: \\\")\\n if user_input == 'debug' or user_input == 'd':\\n print(\\\"\\\\n\\\", conversation.getDebugInfo())\\n else:\\n user_choice = int(user_input)\\n if choices.__len__() < user_choice or user_choice < 1:\\n print('Error, try again')\\n user_choice = None\\n else:\\n print(\\\"\\\\nYou: \\\" + choices[user_choice - 1])\\n except ValueError:\\n print('Error, try again')\\n return user_choice\",\n \"def prompt():\\r\\n inpt = -1\\r\\n valid_choices = ['1','2','3','4','5']\\r\\n while inpt not in valid_choices:\\r\\n inpt = input(\\\"\\\\nPlease select the number of the operation you wish \\\"\\r\\n \\\"to complete:\\\\n\\\" +\\r\\n \\\"1. Run file mover\\\\n2. Add directories\\\"\\r\\n \\\"\\\\n3. Remove directory\\\\n4. View saved directories\\\\n5. Quit\\\\n\\\").strip()\\r\\n if inpt not in valid_choices:\\r\\n print(\\\"\\\\n*** Invalid choice ***\\\")\\r\\n return inpt\",\n \"def menu():\\n menu_options = [enter_long_run_data, enter_data_for_pace_calc, enter_data_for_time_calc,\\n enter_into_running_index_mode, close_program]\\n while True:\\n cls()\\n print(MENU_TEXT)\\n choose = int(input(\\\"What do you want to calculate?\\\\n>> \\\"))\\n cls()\\n\\n if 1 <= choose <= 5:\\n menu_options[choose-1]()\\n else:\\n print(\\\"That option doesnt exist. Try again.\\\")\\n pause_end()\",\n \"def _choose_best_option(self):\",\n \"async def choose(self, ctx, *args):\\n choicelist = []\\n for choice in args:\\n choicelist.append(choice)\\n result = random.choice(choicelist)\\n await ctx.send(\\\"Like it or not, I choose {}!\\\".format(result))\",\n \"def run():\\n table = hr.get_hr_table_from_file()\\n title_list = [\\\"ID\\\", \\\"Name\\\", \\\"BirthYear\\\"]\\n options = [\\\"View records\\\",\\n \\\"Add record\\\",\\n \\\"Remove record\\\",\\n \\\"Update record\\\",\\n \\\"Which person is the oldest?\\\",\\n \\\"Which person is the closet to average age?\\\"]\\n\\n\\n choice = None\\n while choice != \\\"0\\\":\\n choice = terminal_view.get_choice_inner_menu(options, \\\"HR manager\\\")\\n if choice == \\\"1\\\":\\n terminal_view.print_table(table, title_list)\\n elif choice == \\\"2\\\":\\n record = terminal_view.get_inputs(title_list[1::],\\\"Please provide new item data\\\")\\n table = hr.add(table, record)\\n elif choice == \\\"3\\\":\\n id_to_delete_table = terminal_view.get_inputs([\\\"ID\\\"],\\\"Item to delete\\\")\\n id_to_delete = id_to_delete_table[0]\\n table = hr.remove(table, id_to_delete)\\n elif choice == \\\"4\\\":\\n records = terminal_view.get_inputs(title_list,\\\"Edit item\\\")\\n record_id = records[0]\\n table = hr.update(table, record_id, records)\\n elif choice == \\\"5\\\":\\n oldest_person = hr.get_oldest_person(table)\\n terminal_view.print_result(oldest_person, \\\"The oldest person: \\\")\\n elif choice == \\\"6\\\":\\n closest_to_average = hr.get_persons_closest_to_average(table)\\n terminal_view.print_result(closest_to_average,\\\"The closest to average is: \\\")\\n elif choice != \\\"0\\\":\\n terminal_view.print_error_message(\\\"There is no such choice.\\\")\",\n \"def choice(prompt, choices=('y', 'n')):\\n while True:\\n choice = input(prompt).lower().strip()\\n if choice == '0':\\n raise SystemExit\\n elif ',' not in choice:\\n if choice in choices:\\n break\\n elif ',' in choice:\\n choice = [i.strip().lower() for i in choice.split(',')]\\n if list(filter(lambda x: x in choices, choice)) == choice:\\n break\\n prompt = (\\\"\\\\n!!!OOOPS !!!Please be sure to enter a valid option!!! /n\\\")\\n return choice\",\n \"def main():\\n \\n #///////////////////////////////////////////////////////////\\n \\n #\\\"\\\"\\\"#for the commad prompt usage\\n parser = argparse.ArgumentParser(\\\"Week 2 Project: Search Algorithms\\\")\\n parser.add_argument(\\\"method\\\", help=\\\"Searching Algorithm Name\\\", type=str)\\n parser.add_argument(\\\"board\\\", help=\\\"Initial State of the board\\\")\\n\\n args = parser.parse_args()\\n solver = solve()\\n try:\\n initial_state = [int(i) for i in args.board.split(\\\",\\\")]\\n s = state(initial_state, None)\\n except:\\n print(\\\"An error with input has been occured .\\\")\\n exit()\\n\\n g = state([i for i in range(len(initial_state))], None)\\n\\n if args.method == \\\"bfs\\\":\\n print(solver.bfs(s, g))\\n elif args.method == \\\"dfs\\\":\\n print(solver.dfs(s, g))\\n elif args.method == \\\"ast\\\":\\n print(solver.ast(s, g))\\n else:\\n print(solver.ida(s, g))\\n\\n #\\\"\\\"\\\"\\n\\n return\",\n \"def _prompt_choice(options: list) -> int:\\n for i, x in enumerate(options):\\n print(str(i).rjust(3, ' '), x)\\n return int(input('Selection: '))\",\n \"def display_results(results):\\n winners = results[0]\\n losers = results[1]\\n pushers = results[2]\\n blackjack_winners = results[3]\\n print(generate_results_string(winners, \\\" wins\\\", \\\" win\\\"))\\n print(generate_results_string(losers, \\\" loses\\\", \\\" lose\\\"))\\n print(generate_results_string(pushers, \\\" pushes\\\", \\\" push\\\"))\\n print(generate_results_string(blackjack_winners, \\\" wins with blackjack\\\", \\\" win with blackjack\\\"))\",\n \"def run(self):\\n while True:\\n self.display_menu()\\n choice = input(\\\"¿Qué deseas realizar?: \\\")\\n action = self.choices.get(choice)\\n if action:\\n action()\\n else:\\n print(\\\"{0} is not a valid choice\\\".format(choice))\",\n \"def handle_selection_cust(self):\\n choice = self.get_input()\\n if choice == '1':\\n self.display_cust_unlock()\\n elif choice == '2':\\n self.display_return_car()\\n elif choice == '3':\\n self.display_main()\",\n \"def mainMenu(options):\\n while True:\\n print(\\\"Welcome to SportsBook - A sports analysis tool.\\\")\\n print(\\\"Please select from one of the following sports:\\\")\\n # Display all options\\n for option in options:\\n print(str(option[0]) + \\\" \\\" + str(option[1]))\\n # Take user selection\\n while True:\\n print(\\\"Enter option: \\\")\\n selected = input()\\n # Quit option\\n if selected.lower() == \\\"q\\\":\\n exit()\\n # If a number has been entered, convert the string to an integer\\n if isNumber(selected):\\n selected = int(selected)\\n # If the selection is in the list break out of the infinite loop\\n if selected in range(len(options)) and selected != 0:\\n break\\n # Having broken out of the loop, run the selected function\\n if selected == options[0][0]:\\n leagueData={}\\n footballMenu(leagueData)\\n if selected == options[1][0]:\\n tennis()\",\n \"def browse(self):\\n\\t\\tos.system(\\\"clear\\\")\\n\\t\\tself._show_menu()\\n\\t\\twhile True:\\n\\t\\t\\tchoice = input(\\\"Enter the according number above:\\\")\\n\\n\\t\\t\\tif choice == \\\"1\\\":\\n\\t\\t\\t\\tself._show_all_goods()\\n\\t\\t\\telif choice == \\\"2\\\":\\n\\t\\t\\t\\tself._show_cate()\\n\\t\\t\\telif choice == \\\"3\\\":\\n\\t\\t\\t\\tself._show_brand()\\n\\t\\t\\telif choice == \\\"4\\\":\\n\\t\\t\\t\\tself._order()\\n\\t\\t\\t\\tos.system('clear')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tself._show_menu()\",\n \"def main():\\n printfunc(calc(menu()))\",\n \"def main():\\n data = read_data()\\n print('Part one solution: {}'.format(part_one(data)))\\n print('Part two solution: {}'.format(part_two(data)))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69602454","0.6944757","0.68645734","0.6550031","0.6543791","0.6523811","0.6480258","0.6450604","0.64299273","0.6420929","0.6349661","0.62972635","0.6249721","0.62495476","0.624387","0.6237897","0.6218892","0.62085146","0.61473715","0.6147141","0.61348397","0.6108373","0.6084621","0.6078738","0.607712","0.6068604","0.6043592","0.604069","0.6014114","0.6011287","0.601116","0.6010783","0.59971917","0.5982616","0.5981331","0.5980824","0.59703636","0.5968249","0.5966871","0.59665716","0.5958496","0.59457487","0.5940784","0.59388334","0.59216374","0.5920349","0.5913057","0.59082294","0.5903502","0.5890779","0.58809644","0.58805984","0.58762574","0.58712286","0.58689666","0.5864167","0.5849692","0.58491623","0.584022","0.58397585","0.5831524","0.5825967","0.58030874","0.5784338","0.5783534","0.5781968","0.5775016","0.5773014","0.5760257","0.5751315","0.57451385","0.5737754","0.57346123","0.5733438","0.57314986","0.5728574","0.5726411","0.5704105","0.5703482","0.57020444","0.56987697","0.5696487","0.5693252","0.56869435","0.5686572","0.56859845","0.5684647","0.56809676","0.5679652","0.5678347","0.56766343","0.56745803","0.5671791","0.56714594","0.56666034","0.56640303","0.56569195","0.5651066","0.5650043","0.5647668","0.5644295"],"string":"[\n \"0.69602454\",\n \"0.6944757\",\n \"0.68645734\",\n \"0.6550031\",\n \"0.6543791\",\n \"0.6523811\",\n \"0.6480258\",\n \"0.6450604\",\n \"0.64299273\",\n \"0.6420929\",\n \"0.6349661\",\n \"0.62972635\",\n \"0.6249721\",\n \"0.62495476\",\n \"0.624387\",\n \"0.6237897\",\n \"0.6218892\",\n \"0.62085146\",\n \"0.61473715\",\n \"0.6147141\",\n \"0.61348397\",\n \"0.6108373\",\n \"0.6084621\",\n \"0.6078738\",\n \"0.607712\",\n \"0.6068604\",\n \"0.6043592\",\n \"0.604069\",\n \"0.6014114\",\n \"0.6011287\",\n \"0.601116\",\n \"0.6010783\",\n \"0.59971917\",\n \"0.5982616\",\n \"0.5981331\",\n \"0.5980824\",\n \"0.59703636\",\n \"0.5968249\",\n \"0.5966871\",\n \"0.59665716\",\n \"0.5958496\",\n \"0.59457487\",\n \"0.5940784\",\n \"0.59388334\",\n \"0.59216374\",\n \"0.5920349\",\n \"0.5913057\",\n \"0.59082294\",\n \"0.5903502\",\n \"0.5890779\",\n \"0.58809644\",\n \"0.58805984\",\n \"0.58762574\",\n \"0.58712286\",\n \"0.58689666\",\n \"0.5864167\",\n \"0.5849692\",\n \"0.58491623\",\n \"0.584022\",\n \"0.58397585\",\n \"0.5831524\",\n \"0.5825967\",\n \"0.58030874\",\n \"0.5784338\",\n \"0.5783534\",\n \"0.5781968\",\n \"0.5775016\",\n \"0.5773014\",\n \"0.5760257\",\n \"0.5751315\",\n \"0.57451385\",\n \"0.5737754\",\n \"0.57346123\",\n \"0.5733438\",\n \"0.57314986\",\n \"0.5728574\",\n \"0.5726411\",\n \"0.5704105\",\n \"0.5703482\",\n \"0.57020444\",\n \"0.56987697\",\n \"0.5696487\",\n \"0.5693252\",\n \"0.56869435\",\n \"0.5686572\",\n \"0.56859845\",\n \"0.5684647\",\n \"0.56809676\",\n \"0.5679652\",\n \"0.5678347\",\n \"0.56766343\",\n \"0.56745803\",\n \"0.5671791\",\n \"0.56714594\",\n \"0.56666034\",\n \"0.56640303\",\n \"0.56569195\",\n \"0.5651066\",\n \"0.5650043\",\n \"0.5647668\",\n \"0.5644295\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76089,"cells":{"query":{"kind":"string","value":"Returns a dictionary that maps attribute name to a tuple of (type, description)."},"document":{"kind":"string","value":"def get_class_attributes(cls) -> Dict[str, Tuple[Any, str]]:\n try:\n source = inspect.getsource(cls.__init__) or \"\"\n if not source:\n return {}\n except TypeError:\n return {}\n source = utils.join(source.split(\"\\n\"))\n node = ast.parse(source)\n\n attr_list: List[Tuple] = []\n module = importlib.import_module(cls.__module__)\n globals = dict(inspect.getmembers(module))\n for x in ast.walk(node):\n if isinstance(x, _ast.AnnAssign):\n attr, lineno, type_str = parse_annotation_assign(x)\n type = eval(type_str, globals)\n attr_list.append((attr, lineno, type))\n if isinstance(x, _ast.Attribute) and isinstance(x.ctx, _ast.Store):\n attr_list.append(parse_attribute_with_lineno(x))\n attr_list = sorted(attr_list, key=lambda x: x[1])\n\n attrs: Dict[str, Tuple[Any, str]] = {}\n lines = source.split(\"\\n\")\n for name, lineno, *type in attr_list:\n if name.startswith(\"self.\"):\n name = name[5:]\n desc = get_description(lines, lineno)\n if type:\n attrs[name] = type[0], desc # Assignment with type annotation wins.\n elif name not in attrs:\n attrs[name] = None, desc\n return attrs"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}","def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a","def get_attributes(self) -> Dict[str, str]:\n pass","def map_field_name_to_attribute() -> typing.Dict:\n return {\n \"tag\": \"tag\",\n \"contact\": \"contact\",\n }","def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs","def attributes_metadata(self):\n\n attribute_meta = collections.defaultdict(dict)\n\n for attribute in self.attributes:\n attribute_meta[attribute.name]['valuemap'] = attribute.valuemap\n attribute_meta[attribute.name]['qualifiers'] = attribute.qualifiers\n\n return dict(attribute_meta)","def get_attributes(self):\n \n retdict = {}\n retdict['s'] = str(self.s)\n if self.t != None:\n retdict['t'] = str(self.t)\n retdict['a'] = str(self.a)\n retdict['b'] = str(self.b)\n retdict['c'] = str(self.c)\n retdict['d'] = str(self.d)\n return retdict","def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic","def meta(cls):\n if getattr(cls, '__from_class__', None) is not None:\n cls = cls.__from_class__\n attribute_info = {}\n for name, value in cls.__table__.columns.items():\n attribute_info[name] = str(value.type).lower()\n\n return {cls.__name__: attribute_info}","def attributeType(self) -> unicode:\n ...","def description(self):\n desc = self.title\n ops = []\n for attribute in self.attributes.all():\n value = attribute.value\n if isinstance(value, list):\n ops.append(\n \"%s = '%s'\" % (attribute.type, (\", \".join([str(v) for v in value])))\n )\n else:\n ops.append(\"%s = '%s'\" % (attribute.type, value))\n if ops:\n desc = \"%s (%s)\" % (desc, \", \".join(ops))\n return desc","def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}","def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass","def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_","def get_attrs_dict(self, root_element):\n attr_elements = root_element.findall(\"attribute\")\n attrs_dict = {}\n for el in attr_elements:\n attrs_dict[el.attrib[\"name\"]] = {\n \"value\": el.attrib[\"value\"],\n \"type\": el.attrib.get(\"type\", None)\n }\n return attrs_dict","def to_dict(\n self,\n attributes: Iterable[str] = (\"xyz\", \"viewdir\", \"imgsz\", \"f\", \"c\", \"k\", \"p\"),\n ) -> Dict[str, tuple]:\n return {key: helpers.numpy_to_native(getattr(self, key)) for key in attributes}","def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:\n fields = cls.__dataclass_fields__.values()\n attrs = {}\n for field in fields:\n if field.type != InitVar:\n attrs[field.name] = field.type, \"\"\n return attrs","def dict(self) -> dict():\n\n dict_reg_hive = {}\n\n for _attribute in self.attributes.__dict__.items():\n if isinstance(_attribute[1], str):\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\n _attribute_value = getattr(self, _attribute[1])\n dict_reg_hive.update({_attribute[1]: _attribute_value})\n\n return dict_reg_hive","def get_attrib_dict(self, attribs: Tuple[str]) -> Dict[str, str]:\n attrs = self.get_attribs(attribs)\n attrs = tuple(map(lambda a: (a[0][1:], a[1]), attrs))\n return dict(attrs)","def attribute_metadata(attr: Attr, parent_namespace: Optional[str]) -> Dict:\n metadata = dict(\n name=None\n if attr.is_nameless or attr.local_name == attribute_name(attr.name)\n else attr.local_name,\n type=attr.xml_type,\n namespace=attr.namespace\n if parent_namespace != attr.namespace or attr.is_attribute\n else None,\n **attr.restrictions.asdict(),\n )\n\n return {\n key: value\n for key, value in metadata.items()\n if value is not None and value is not False\n }","def get_attribute_data(self):\n ret = {}\n\n for attribute in Attribute.objects.all().prefetch_related(\"value_choices\"):\n deserialized_value = None\n\n if attribute.value_type == Attribute.TYPE_GEOMETRY:\n geometry = ProjectAttributeMultipolygonGeometry.objects.filter(\n attribute=attribute, project=self\n ).first()\n if not geometry:\n continue\n deserialized_value = geometry.geometry\n elif attribute.value_type in [Attribute.TYPE_IMAGE, Attribute.TYPE_FILE]:\n try:\n deserialized_value = ProjectAttributeFile.objects.filter(\n attribute=attribute, project=self\n ).order_by(\"-created_at\").first().file\n except AttributeError:\n deserialized_value = None\n elif attribute.identifier in self.attribute_data:\n deserialized_value = attribute.deserialize_value(\n self.attribute_data[attribute.identifier]\n )\n\n ret[attribute.identifier] = deserialized_value\n return ret","def read_attr_type_file():\n with open(args.attr_type_file_path, 'r') as f:\n content = f.readlines()\n\n # Strip lines of newline/return characters in csv file\n content = [x.strip(' \\t\\n\\r') for x in content]\n\n # Generate dictionary of types and their count\n attribute_type_dict = {}\n for item in content:\n key, value = item.split('|')\n attribute_type_dict[key.strip()] = value.strip()\n \n return attribute_type_dict","def __getAttributeInfo(self, atName):\n cifDataType = self.__dApi.getTypeCode(self.getName(), atName)\n cifPrimitiveType = self.__dApi.getTypePrimitive(self.getName(), atName)\n isMandatory = self.__dApi.getMandatoryCode(self.getName(), atName) in [\"yes\", \"implicit\", \"implicit-ordinal\"]\n dataType = \"integer\" if \"int\" in cifDataType else \"float\" if cifPrimitiveType == \"numb\" else \"string\"\n return dataType, isMandatory","def attributeInfo(*args, allAttributes: bool=True, bool: bool=True, enumerated: bool=True,\n hidden: bool=True, inherited: bool=True, internal: bool=True, leaf: bool=True,\n logicalAnd: bool=True, multi: bool=True, short: bool=True, userInterface:\n bool=True, writable: bool=True, type: AnyStr=\"\", **kwargs)->List[AnyStr]:\n pass","def get_module_attributes(module) -> Dict[str, Tuple[Any, str]]:\n try:\n source = inspect.getsource(module) or \"\"\n if not source:\n return {}\n except (OSError, TypeError):\n return {}\n node = ast.parse(source)\n\n attr_list: List[Tuple] = []\n globals = dict(inspect.getmembers(module))\n for x in ast.iter_child_nodes(node):\n if isinstance(x, _ast.AnnAssign):\n attr, lineno, type_str = parse_annotation_assign(x)\n type = eval(type_str, globals)\n attr_list.append((attr, lineno, type))\n if isinstance(x, _ast.Assign):\n attr_list.append(parse_attribute_with_lineno(x))\n attr_list = sorted(attr_list, key=lambda x: x[1])\n\n attrs: Dict[str, Tuple[Any, str]] = {}\n lines = source.split(\"\\n\")\n for name, lineno, *type in attr_list:\n desc = get_description(lines, lineno)\n if type:\n attrs[name] = type[0], desc # Assignment with type annotation wins.\n elif name not in attrs:\n attrs[name] = None, desc\n return attrs","def get_attributes(cls):\r\n return [Attribute('size', '20'),\r\n Attribute('label', ''), ]","def get_attributes(self):\n\n endpoint = self._get_api_endpoint() + '/attributes'\n results = self.tq.get(endpoint, withp='attribute')\n if 'data' not in results:\n return {}\n\n return results['data']\n # tr = {}\n # for attribute in results['data']:\n # tr[attribute['attribute']['name']] = attribute['value']\n # return tr","def to_dict(\n self, attributes: Sequence[str] = (\n 'demand_instruments', 'supply_instruments', 'inverse_covariance_matrix',\n 'expected_xi_by_theta_jacobian', 'expected_omega_by_theta_jacobian', 'expected_prices',\n 'expected_shares', 'computation_time', 'draws', 'fp_converged', 'fp_iterations',\n 'contraction_evaluations'\n )) -> dict:\n return {k: getattr(self, k) for k in attributes}","def getDict(self):\n res = {}\n for attr, value in self.__dict__.iteritems():\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\n res[attr] = value\n elif isinstance(attr, datetime.datetime):\n res[attr] = value.isoformat('-')\n \n return res","def category_attributes_types(categories, db_info, connection):\n attributes = {}\n for cat in categories:\n attributes[cat] = {}\n category_info = api_category_info(cat, db_info, connection)\n\n attr = {}\n for a in category_info.get(\"attributes\"):\n for key in a:\n attr[key] = a[key]\n\n attributes[cat][\"attributes\"] = {k: d for d, k in attr.items()}\n\n types = category_info.get(\"types\")\n attributes[cat][\"types\"] = {\n attr.get(a): types.get(a) for a in types}\n\n attributes[cat][\"dialogs\"] = category_info.get(\"dialogs\")\n\n return attributes","def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs","def attributes(self):\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }","def attributes(self, *args):\n kwargs = {}\n if args:\n kwargs[\"attributenames\"] = args\n\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\n\n # parse contennt looking for all attributes\n attributes = []\n for line in r.text.splitlines():\n r = re.match(\"(userdetails\\.attribute\\.name)=(.*)\", line)\n if r:\n name = r.groups()[1]\n attributes.append([name, None])\n continue # next line\n\n r = re.match(\"(userdetails\\.attribute\\.value)=(.*)\", line)\n if r:\n value = r.groups()[1]\n # last name parsed is where it has to\n # be stacked\n if attributes[-1][1] == None:\n attributes[-1][1] = value\n if isinstance(attributes[-1][1], list):\n attributes[-1][1].append(value)\n else:\n # cast to list\n attributes[-1].append([attributes[-1][1], value])\n\n return dict([(item[0], item[1]) for item in attributes])","def describe(self):\r\n return dict((field.name, dict(\r\n id=field.name,\r\n name=field.label,\r\n validators=ValidatorSerializer(\r\n field.requires if isSequenceType(field.requires) else [field.requires])(),\r\n comment=field.comment,\r\n readable=field.readable,\r\n writable=field.writable,\r\n type=getattr(field, 'wtype',\r\n field.type.type if isinstance(field.type, SQLCustomType) else field.type.split('(')[0]),\r\n # w2pwidget=field.widget,\r\n )) for field in self.descibe_columns)","def attributes(self):\n return dict(self.__attributes)","def get_attributes(obj) -> Dict[str, Tuple[Any, str]]:\n if is_dataclass(obj):\n return get_dataclass_attributes(obj)\n elif inspect.isclass(obj):\n return get_class_attributes(obj)\n elif inspect.ismodule(obj):\n return get_module_attributes(obj)\n return {}","def attribute_to_dict(attr: onnx.AttributeProto) -> Dict:\n ret = {}\n for a in attr:\n value = get_attribute_value(a)\n if isinstance(value, bytes):\n value = str(value, 'utf-8')\n ret[a.name] = value\n return ret","def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict","def _get_attribute_dict(self, attributes, classname=None):\n if attributes and isinstance(attributes, six.string_types):\n return {\n 'class': attributes\n }\n if not attributes:\n attributes = {}\n if not classname:\n classname = self.DEFAULT_CLASS_NAME\n attributes.setdefault('class', classname)\n return attributes","def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs","def attributes(self):\n _attrs = []\n if self.name:\n _attrs.append(\"name\")\n if self.label:\n _attrs.append(\"label\")\n if self.confidence:\n _attrs.append(\"confidence\")\n if self.index:\n _attrs.append(\"index\")\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs + [\"points\"]","def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}","def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"","def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }","def capability_attributes(self) -> Mapping[str, Any] | None:\n if state_class := self.state_class:\n return {ATTR_STATE_CLASS: state_class}\n\n if options := self.options:\n return {ATTR_OPTIONS: options}\n\n return None","def attributes(self) -> Optional[Mapping[str, Sequence[str]]]:\n return pulumi.get(self, \"attributes\")","def _describe(self) -> Dict[str, Any]:","def state_attributes(self) -> dict[str, StateType]:\n attributes: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}\n\n if self.gps is not None:\n attributes[ATTR_LATITUDE] = self.gps[0]\n attributes[ATTR_LONGITUDE] = self.gps[1]\n attributes[ATTR_GPS_ACCURACY] = self.gps_accuracy\n\n if self.battery is not None:\n attributes[ATTR_BATTERY] = self.battery\n\n return attributes","def to_dict(self):\n d = {}\n i = 0\n for entry in self.entries:\n d[i] = {}\n attributes = self.get_attribute_list()\n print (attributes)\n for data in attributes:\n d[i][data] = entry.__getattribute__(data)\n i = i + 1\n return d","def device_state_attributes(self):\n attrs = {}\n\n attrs[ATTR_ATTRIBUTION] = ATTRIBUTION\n attrs[\"brand\"] = DEFAULT_BRAND\n attrs[ATTR_CAMERA_TYPE] = self._camera_type\n attrs[\"friendly_name\"] = self._name\n\n return attrs","def types(self) -> Dict[str, str]:\n return {name: self.hyperparams[name][0] for name in self.names()}","def thrift_type_to_dict(obj: Any) -> Dict[str, Any]:\n return {\n camel_to_snake_case(attr): getattr(obj, attr)\n for attr in thrift_attrs(obj)\n }","def get_attributes(cls):\r\n return [\r\n Attribute('size', '20'),\r\n Attribute('inline', False),\r\n Attribute('label', ''),\r\n ]","def get_question_name_to_answer_attribute_table(cls):\n return {\n value.question_name: attr_name\n for attr_name, value in cls.__dict__.items()\n if isinstance(value, answer.BaseAnswer)\n }","def create_descr(self, attr_name):","def get_attributes_of_node(core, node):\n attributes = {}\n for attribute in core.get_attribute_names(node):\n attributes[attribute] = core.get_attribute(node,attribute)\n return attributes","def get_attributes(self, shape):\n attributes = {}\n identifier_names = [i.name for i in self.identifiers]\n\n for name, member in shape.members.items():\n snake_cased = xform_name(name)\n if snake_cased in identifier_names:\n # Skip identifiers, these are set through other means\n continue\n snake_cased = self._get_name(\n 'attribute', snake_cased, snake_case=False\n )\n attributes[snake_cased] = (name, member)\n\n return attributes","def info(self):\n return (self.kind, self.value)","def get_attributes(self):\n\t\treturn dict(list(self.__element.items()))","def attributes(self):\n return {'op_type': self.__class__.__name__, 'arguments': {}}","def getAttributeDict(self):\n result = {}\n dict = self.getDict()\n for key in dict.keys():\n value = dict.get(key)\n if value.__class__.__name__ != 'SpecialDict':\n result[key] = value\n return result","def as_dict(self):\n result = {}\n for attr in self.__attr:\n result[attr] = getattr(self, attr)\n return result","def dict_by_attr(collection, attrname, value_attrname=None):\n mapping = {}\n for item in collection:\n if callable(attrname):\n key = attrname(item)\n else:\n key = extended_getattr(item, attrname)\n if value_attrname:\n item = extended_getattr(item, value_attrname)\n mapping[key] = mapping.get(key, []) + [item]\n return mapping","def _process_attrs(attrs):\n new_attrs = OrderedDict()\n for attr in attrs:\n col = attr\n if isinstance(attr, tuple):\n col, attr = attr\n # special cases\n if attr == 'class_name':\n attr = '__class__.__name__'\n if attr == 'repr':\n attr = repr\n new_attrs[col] = attr\n\n return new_attrs","def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format","def get_attributes(cls):\r\n return [\r\n Attribute('height', None),\r\n Attribute('width', None),\r\n Attribute('parts', None),\r\n Attribute('analyses', None),\r\n Attribute('initial_value', None),\r\n Attribute('submit_analyses', None),\r\n Attribute('label', ''),\r\n ]","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n if issubclass(UserAttributeInfo, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def expected_types_and_attributes(self):\n return {self.configs[\"entry_type\"]: set()}","def attribute_dict(self):\n return self.__attribute_dict","def to_dict(cls):\n result = {}\n for attr_name in _.reject(set(dir(cls)), lambda x: x.startswith('_')):\n attr = getattr(cls, attr_name)\n if _.is_list(attr) or _.is_string(attr):\n result[attr_name] = attr\n return result","def get_attributes(cls):\r\n return [\r\n Attribute(\"show_correctness\", \"always\"),\r\n Attribute(\"submitted_message\", \"Answer received.\"),\r\n Attribute(\"label\", \"\"),\r\n ]","def as_dict(self):\n return {c.key: getattr(self, c.key)\n for c in inspect(self).mapper.column_attrs}","def readTypes(self):\r\n types = {}\r\n for m in re.finditer(\"TYPE (.*) = (.*);\", self.data):\r\n typename, typetype = m.groups() \r\n if typetype in self.SIMPLETYPES:\r\n types[typename] = typetype\r\n else:\r\n types[typename] = \"#\" + typetype\r\n \r\n return types","def GetAttributes(self, type):\n if type == ArrayAssociation.FIELD:\n return DataSetAttributes(self.VTKObject.GetFieldData(), self, type)\n return DataSetAttributes(self.VTKObject.GetAttributes(type), self, type)","def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict","def tags_dict(self):\n return ({'name': 'tag', 'attrs': {'k': k, 'v': v}} for k, v in self.tags.items())","def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes","def attrs(self):\n return [name for name in self.traits() if self.trait_metadata(name, \"attr\")]","def attrs(self):\n return [name for name in self.traits() if self.trait_metadata(name, \"attr\")]","def get_attribute_counts(self):\n counts = defaultdict(int)\n for attr in self:\n counts[attr.name] += 1\n\n return dict(counts)","def record_dict(self):\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}","def attributes(self):\n return [self._ELE_ATTR]","def parse_attributes(self, attr):\n result = {}\n annotations = []\n # Sanitize and split attributes up\n split_attr = attr.strip(' \\t\\n;').split(';')\n for pair in split_attr:\n splitpair = pair.split('=')\n if len(splitpair) != 2:\n continue\n if splitpair[0] == \"ID\":\n result['identifier'] = splitpair[1]\n elif splitpair[0] == \"Name\":\n result['name'] = splitpair[1]\n elif splitpair[0] == \"Parent\":\n result['parent_id'] = splitpair[1]\n elif splitpair[0] == \"Dbxref\" or splitpair[0] == \"Ontology_term\":\n annotations.append(splitpair)\n # Make sure we found an ID\n if \"identifier\" not in result:\n return {}\n # Add annotations if we found any\n if annotations:\n result[\"annotations\"] = annotations\n return result","def device_state_attributes(self):\n if self.airly.data_available:\n if self.type == ATTR_CAQI_DESCRIPTION:\n self._attrs[ATTR_CAQI_ADVICE] = (self.airly.data\n [ATTR_CAQI_ADVICE])\n if self.type == ATTR_CAQI:\n self._attrs[ATTR_CAQI_LEVEL] = self.airly.data[ATTR_CAQI_LEVEL]\n if self.type == ATTR_PM25:\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM25_LIMIT]\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\n [ATTR_PM25_PERCENT]))\n if self.type == ATTR_PM10:\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM10_LIMIT]\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\n [ATTR_PM10_PERCENT]))\n return self._attrs","def whoAreYou(self):\n tempDict = {}\n tempDict['Class'] = '{0:15}'.format(self.__class__.__name__) +' from '+' '.join([str(base) for base in self.__class__.__bases__])\n tempDict['Type' ] = self.type\n tempDict['Name' ] = self.name\n return tempDict","def values(self):\n return {n: getattr(self, n) for n in self._hparam_types.keys()}","def _metadata_map():\n return {\n 'date_added': 'dateAdded',\n 'dns_active': 'dnsActive',\n 'last_modified': 'lastModified',\n 'private_flag': 'privateFlag',\n 'whois_active': 'whoisActive',\n 'key_name': 'Key Name',\n 'value_type': 'Value Type',\n 'value_name': 'Value Name',\n 'block': 'Block',\n 'mutex': 'Mutex',\n 'as_number': 'AS Number',\n 'hostname': 'hostName',\n }","def getDataAttributes(self):\n asRet = [];\n asAttrs = dir(self);\n for sAttr in asAttrs:\n if sAttr[0] == '_' or sAttr[0] == 'k':\n continue;\n if sAttr in self.kasInternalAttributes:\n continue;\n oValue = getattr(self, sAttr);\n if callable(oValue):\n continue;\n asRet.append(sAttr);\n return asRet;","def get_attributes(self):\n _attributes = {\n 'function_id': self.function_id,\n 'hardware_id': self.hardware_id,\n 'mode_id': self.mode_id,\n 'critical_item': self.critical_item,\n 'description': self.description,\n 'design_provisions': self.design_provisions,\n 'detection_method': self.detection_method,\n 'effect_end': self.effect_end,\n 'effect_local': self.effect_local,\n 'effect_next': self.effect_next,\n 'effect_probability': self.effect_probability,\n 'hazard_rate_source': self.hazard_rate_source,\n 'isolation_method': self.isolation_method,\n 'mission': self.mission,\n 'mission_phase': self.mission_phase,\n 'mode_criticality': self.mode_criticality,\n 'mode_hazard_rate': self.mode_hazard_rate,\n 'mode_op_time': self.mode_op_time,\n 'mode_probability': self.mode_probability,\n 'mode_ratio': self.mode_ratio,\n 'operator_actions': self.operator_actions,\n 'other_indications': self.other_indications,\n 'remarks': self.remarks,\n 'rpn_severity': self.rpn_severity,\n 'rpn_severity_new': self.rpn_severity_new,\n 'severity_class': self.severity_class,\n 'single_point': self.single_point,\n 'type_id': self.type_id\n }\n\n return _attributes","def getAttributeInfo(self, atName):\n try:\n dataType, mandatoryCode = self.__getAttributeInfo(atName)\n return dataType, mandatoryCode\n except Exception:\n return None, None","def as_attrdict(self) -> AttributeDict:\n return AttributeDict(\n {\n x: Configuration(v).as_attrdict() if isinstance(v, Mapping) else v\n for x, v in self.items(levels=1)\n }\n )","def to_dict(self):\n dct = dict(zip(self._fields, self))\n dct['type'] = type(self).__name__\n return dct","def attributes(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\n return pulumi.get(self, \"attributes\")","def keys(self):\n return list(s.name.lower() for s in self.attributes)","def get_attributes(self):\n _attributes = {\n 'measurement_id': self.measurement_id,\n 'code': self.code,\n 'description': self.description,\n 'measurement_type': self.measurement_type\n }\n\n return _attributes","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def arm_to_dict(arm: Arm) -> Dict[str, Any]:\n return {\n \"__type\": arm.__class__.__name__,\n \"parameters\": arm.parameters,\n \"name\": arm._name,\n }","def to_dictionary(self):\n attributes = [\"id\", \"size\", \"x\", \"y\"]\n return {key: getattr(self, key) for key in attributes}","def dict_to_label_attr_map(input_dict):\n return {key+':': [key, type(val)] for key, val in input_dict.items()}"],"string":"[\n \"def _attrs_map(self) -> \\\"dict[int, str]\\\":\\n return {i: attr.name for i, attr in enumerate(self._attrs())}\",\n \"def _attribs(self, name=None, description=None):\\n a = {}\\n if name:\\n a['name'] = name\\n if description:\\n a['description'] = description\\n return a\",\n \"def get_attributes(self) -> Dict[str, str]:\\n pass\",\n \"def map_field_name_to_attribute() -> typing.Dict:\\n return {\\n \\\"tag\\\": \\\"tag\\\",\\n \\\"contact\\\": \\\"contact\\\",\\n }\",\n \"def attributes(self):\\n _attrs = [\\\"type\\\", \\\"name\\\", \\\"value\\\"]\\n if self.confidence is not None:\\n _attrs.append(\\\"confidence\\\")\\n if self.constant:\\n _attrs.append(\\\"constant\\\")\\n if self.tags:\\n _attrs.append(\\\"tags\\\")\\n\\n return _attrs\",\n \"def attributes_metadata(self):\\n\\n attribute_meta = collections.defaultdict(dict)\\n\\n for attribute in self.attributes:\\n attribute_meta[attribute.name]['valuemap'] = attribute.valuemap\\n attribute_meta[attribute.name]['qualifiers'] = attribute.qualifiers\\n\\n return dict(attribute_meta)\",\n \"def get_attributes(self):\\n \\n retdict = {}\\n retdict['s'] = str(self.s)\\n if self.t != None:\\n retdict['t'] = str(self.t)\\n retdict['a'] = str(self.a)\\n retdict['b'] = str(self.b)\\n retdict['c'] = str(self.c)\\n retdict['d'] = str(self.d)\\n return retdict\",\n \"def _get_attribute_dic(self, attrs):\\n attr_dic = {}\\n for attr_pair in attrs:\\n attr_dic[attr_pair[0]] = attr_pair[1]\\n return attr_dic\",\n \"def meta(cls):\\n if getattr(cls, '__from_class__', None) is not None:\\n cls = cls.__from_class__\\n attribute_info = {}\\n for name, value in cls.__table__.columns.items():\\n attribute_info[name] = str(value.type).lower()\\n\\n return {cls.__name__: attribute_info}\",\n \"def attributeType(self) -> unicode:\\n ...\",\n \"def description(self):\\n desc = self.title\\n ops = []\\n for attribute in self.attributes.all():\\n value = attribute.value\\n if isinstance(value, list):\\n ops.append(\\n \\\"%s = '%s'\\\" % (attribute.type, (\\\", \\\".join([str(v) for v in value])))\\n )\\n else:\\n ops.append(\\\"%s = '%s'\\\" % (attribute.type, value))\\n if ops:\\n desc = \\\"%s (%s)\\\" % (desc, \\\", \\\".join(ops))\\n return desc\",\n \"def getAttributeInfoDictionary(attr, format=None):\\n format = format or _getDocFormat(attr)\\n return {'name': attr.getName(),\\n 'doc': renderText(attr.getDoc() or '', format=format)}\",\n \"def proc_attr(inp):\\n dic = {}\\n for att in inp.attrs.keys():\\n if getattr(inp.attrs[att], \\\"dtype\\\", None) is None:\\n dic[att] = inp.attrs[att]\\n elif inp.attrs[att].dtype.char == 'S':\\n dic[att] = [\\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\\n ]\\n else:\\n dic[att] = (\\n inp.attrs[att][0]\\n if isinstance(inp.attrs[att],np.ndarray) and\\n inp.attrs[att].size==1\\n else inp.attrs[att]\\n )\\n return dic\\n pass\",\n \"def attributes(self):\\n attrs_ = [\\\"name\\\", \\\"type\\\"]\\n if self.exclusive:\\n attrs_.append(\\\"exclusive\\\")\\n if self.default is not None:\\n attrs_.append(\\\"default\\\")\\n\\n return attrs_\",\n \"def get_attrs_dict(self, root_element):\\n attr_elements = root_element.findall(\\\"attribute\\\")\\n attrs_dict = {}\\n for el in attr_elements:\\n attrs_dict[el.attrib[\\\"name\\\"]] = {\\n \\\"value\\\": el.attrib[\\\"value\\\"],\\n \\\"type\\\": el.attrib.get(\\\"type\\\", None)\\n }\\n return attrs_dict\",\n \"def to_dict(\\n self,\\n attributes: Iterable[str] = (\\\"xyz\\\", \\\"viewdir\\\", \\\"imgsz\\\", \\\"f\\\", \\\"c\\\", \\\"k\\\", \\\"p\\\"),\\n ) -> Dict[str, tuple]:\\n return {key: helpers.numpy_to_native(getattr(self, key)) for key in attributes}\",\n \"def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:\\n fields = cls.__dataclass_fields__.values()\\n attrs = {}\\n for field in fields:\\n if field.type != InitVar:\\n attrs[field.name] = field.type, \\\"\\\"\\n return attrs\",\n \"def dict(self) -> dict():\\n\\n dict_reg_hive = {}\\n\\n for _attribute in self.attributes.__dict__.items():\\n if isinstance(_attribute[1], str):\\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\\n _attribute_value = getattr(self, _attribute[1])\\n dict_reg_hive.update({_attribute[1]: _attribute_value})\\n\\n return dict_reg_hive\",\n \"def get_attrib_dict(self, attribs: Tuple[str]) -> Dict[str, str]:\\n attrs = self.get_attribs(attribs)\\n attrs = tuple(map(lambda a: (a[0][1:], a[1]), attrs))\\n return dict(attrs)\",\n \"def attribute_metadata(attr: Attr, parent_namespace: Optional[str]) -> Dict:\\n metadata = dict(\\n name=None\\n if attr.is_nameless or attr.local_name == attribute_name(attr.name)\\n else attr.local_name,\\n type=attr.xml_type,\\n namespace=attr.namespace\\n if parent_namespace != attr.namespace or attr.is_attribute\\n else None,\\n **attr.restrictions.asdict(),\\n )\\n\\n return {\\n key: value\\n for key, value in metadata.items()\\n if value is not None and value is not False\\n }\",\n \"def get_attribute_data(self):\\n ret = {}\\n\\n for attribute in Attribute.objects.all().prefetch_related(\\\"value_choices\\\"):\\n deserialized_value = None\\n\\n if attribute.value_type == Attribute.TYPE_GEOMETRY:\\n geometry = ProjectAttributeMultipolygonGeometry.objects.filter(\\n attribute=attribute, project=self\\n ).first()\\n if not geometry:\\n continue\\n deserialized_value = geometry.geometry\\n elif attribute.value_type in [Attribute.TYPE_IMAGE, Attribute.TYPE_FILE]:\\n try:\\n deserialized_value = ProjectAttributeFile.objects.filter(\\n attribute=attribute, project=self\\n ).order_by(\\\"-created_at\\\").first().file\\n except AttributeError:\\n deserialized_value = None\\n elif attribute.identifier in self.attribute_data:\\n deserialized_value = attribute.deserialize_value(\\n self.attribute_data[attribute.identifier]\\n )\\n\\n ret[attribute.identifier] = deserialized_value\\n return ret\",\n \"def read_attr_type_file():\\n with open(args.attr_type_file_path, 'r') as f:\\n content = f.readlines()\\n\\n # Strip lines of newline/return characters in csv file\\n content = [x.strip(' \\\\t\\\\n\\\\r') for x in content]\\n\\n # Generate dictionary of types and their count\\n attribute_type_dict = {}\\n for item in content:\\n key, value = item.split('|')\\n attribute_type_dict[key.strip()] = value.strip()\\n \\n return attribute_type_dict\",\n \"def __getAttributeInfo(self, atName):\\n cifDataType = self.__dApi.getTypeCode(self.getName(), atName)\\n cifPrimitiveType = self.__dApi.getTypePrimitive(self.getName(), atName)\\n isMandatory = self.__dApi.getMandatoryCode(self.getName(), atName) in [\\\"yes\\\", \\\"implicit\\\", \\\"implicit-ordinal\\\"]\\n dataType = \\\"integer\\\" if \\\"int\\\" in cifDataType else \\\"float\\\" if cifPrimitiveType == \\\"numb\\\" else \\\"string\\\"\\n return dataType, isMandatory\",\n \"def attributeInfo(*args, allAttributes: bool=True, bool: bool=True, enumerated: bool=True,\\n hidden: bool=True, inherited: bool=True, internal: bool=True, leaf: bool=True,\\n logicalAnd: bool=True, multi: bool=True, short: bool=True, userInterface:\\n bool=True, writable: bool=True, type: AnyStr=\\\"\\\", **kwargs)->List[AnyStr]:\\n pass\",\n \"def get_module_attributes(module) -> Dict[str, Tuple[Any, str]]:\\n try:\\n source = inspect.getsource(module) or \\\"\\\"\\n if not source:\\n return {}\\n except (OSError, TypeError):\\n return {}\\n node = ast.parse(source)\\n\\n attr_list: List[Tuple] = []\\n globals = dict(inspect.getmembers(module))\\n for x in ast.iter_child_nodes(node):\\n if isinstance(x, _ast.AnnAssign):\\n attr, lineno, type_str = parse_annotation_assign(x)\\n type = eval(type_str, globals)\\n attr_list.append((attr, lineno, type))\\n if isinstance(x, _ast.Assign):\\n attr_list.append(parse_attribute_with_lineno(x))\\n attr_list = sorted(attr_list, key=lambda x: x[1])\\n\\n attrs: Dict[str, Tuple[Any, str]] = {}\\n lines = source.split(\\\"\\\\n\\\")\\n for name, lineno, *type in attr_list:\\n desc = get_description(lines, lineno)\\n if type:\\n attrs[name] = type[0], desc # Assignment with type annotation wins.\\n elif name not in attrs:\\n attrs[name] = None, desc\\n return attrs\",\n \"def get_attributes(cls):\\r\\n return [Attribute('size', '20'),\\r\\n Attribute('label', ''), ]\",\n \"def get_attributes(self):\\n\\n endpoint = self._get_api_endpoint() + '/attributes'\\n results = self.tq.get(endpoint, withp='attribute')\\n if 'data' not in results:\\n return {}\\n\\n return results['data']\\n # tr = {}\\n # for attribute in results['data']:\\n # tr[attribute['attribute']['name']] = attribute['value']\\n # return tr\",\n \"def to_dict(\\n self, attributes: Sequence[str] = (\\n 'demand_instruments', 'supply_instruments', 'inverse_covariance_matrix',\\n 'expected_xi_by_theta_jacobian', 'expected_omega_by_theta_jacobian', 'expected_prices',\\n 'expected_shares', 'computation_time', 'draws', 'fp_converged', 'fp_iterations',\\n 'contraction_evaluations'\\n )) -> dict:\\n return {k: getattr(self, k) for k in attributes}\",\n \"def getDict(self):\\n res = {}\\n for attr, value in self.__dict__.iteritems():\\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\\n res[attr] = value\\n elif isinstance(attr, datetime.datetime):\\n res[attr] = value.isoformat('-')\\n \\n return res\",\n \"def category_attributes_types(categories, db_info, connection):\\n attributes = {}\\n for cat in categories:\\n attributes[cat] = {}\\n category_info = api_category_info(cat, db_info, connection)\\n\\n attr = {}\\n for a in category_info.get(\\\"attributes\\\"):\\n for key in a:\\n attr[key] = a[key]\\n\\n attributes[cat][\\\"attributes\\\"] = {k: d for d, k in attr.items()}\\n\\n types = category_info.get(\\\"types\\\")\\n attributes[cat][\\\"types\\\"] = {\\n attr.get(a): types.get(a) for a in types}\\n\\n attributes[cat][\\\"dialogs\\\"] = category_info.get(\\\"dialogs\\\")\\n\\n return attributes\",\n \"def attributes(self):\\n _attrs = [\\\"label\\\"]\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs\",\n \"def attributes(self):\\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }\",\n \"def attributes(self, *args):\\n kwargs = {}\\n if args:\\n kwargs[\\\"attributenames\\\"] = args\\n\\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\\n\\n # parse contennt looking for all attributes\\n attributes = []\\n for line in r.text.splitlines():\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.name)=(.*)\\\", line)\\n if r:\\n name = r.groups()[1]\\n attributes.append([name, None])\\n continue # next line\\n\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.value)=(.*)\\\", line)\\n if r:\\n value = r.groups()[1]\\n # last name parsed is where it has to\\n # be stacked\\n if attributes[-1][1] == None:\\n attributes[-1][1] = value\\n if isinstance(attributes[-1][1], list):\\n attributes[-1][1].append(value)\\n else:\\n # cast to list\\n attributes[-1].append([attributes[-1][1], value])\\n\\n return dict([(item[0], item[1]) for item in attributes])\",\n \"def describe(self):\\r\\n return dict((field.name, dict(\\r\\n id=field.name,\\r\\n name=field.label,\\r\\n validators=ValidatorSerializer(\\r\\n field.requires if isSequenceType(field.requires) else [field.requires])(),\\r\\n comment=field.comment,\\r\\n readable=field.readable,\\r\\n writable=field.writable,\\r\\n type=getattr(field, 'wtype',\\r\\n field.type.type if isinstance(field.type, SQLCustomType) else field.type.split('(')[0]),\\r\\n # w2pwidget=field.widget,\\r\\n )) for field in self.descibe_columns)\",\n \"def attributes(self):\\n return dict(self.__attributes)\",\n \"def get_attributes(obj) -> Dict[str, Tuple[Any, str]]:\\n if is_dataclass(obj):\\n return get_dataclass_attributes(obj)\\n elif inspect.isclass(obj):\\n return get_class_attributes(obj)\\n elif inspect.ismodule(obj):\\n return get_module_attributes(obj)\\n return {}\",\n \"def attribute_to_dict(attr: onnx.AttributeProto) -> Dict:\\n ret = {}\\n for a in attr:\\n value = get_attribute_value(a)\\n if isinstance(value, bytes):\\n value = str(value, 'utf-8')\\n ret[a.name] = value\\n return ret\",\n \"def process_attrs(attrs):\\n if attrs.getLength() == 0:\\n return {}\\n tmp_dict = {}\\n for name in attrs.getNames():\\n tmp_dict[name] = attrs.getValue(name)\\n return tmp_dict\",\n \"def _get_attribute_dict(self, attributes, classname=None):\\n if attributes and isinstance(attributes, six.string_types):\\n return {\\n 'class': attributes\\n }\\n if not attributes:\\n attributes = {}\\n if not classname:\\n classname = self.DEFAULT_CLASS_NAME\\n attributes.setdefault('class', classname)\\n return attributes\",\n \"def _parse_attr(self, attr_proto):\\n attrs = {}\\n for a in attr_proto:\\n for f in ['f', 'i', 's']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['floats', 'ints', 'strings']:\\n if list(getattr(a, f)):\\n assert a.name not in attrs, \\\"Only one type of attr is allowed\\\"\\n attrs[a.name] = tuple(getattr(a, f))\\n for f in ['t', 'g']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['tensors', 'graphs']:\\n if list(getattr(a, f)):\\n raise NotImplementedError(\\\"Filed {} is not supported in mxnet.\\\".format(f))\\n if a.name not in attrs:\\n raise ValueError(\\\"Cannot parse attribute: \\\\n{}\\\\n.\\\".format(a))\\n return attrs\",\n \"def attributes(self):\\n _attrs = []\\n if self.name:\\n _attrs.append(\\\"name\\\")\\n if self.label:\\n _attrs.append(\\\"label\\\")\\n if self.confidence:\\n _attrs.append(\\\"confidence\\\")\\n if self.index:\\n _attrs.append(\\\"index\\\")\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs + [\\\"points\\\"]\",\n \"def attrs_to_dict(self, attrs):\\n return {k: v for k, v in attrs}\",\n \"def ATTRIBUTE():\\n return \\\"author\\\", \\\"title\\\", \\\"publisher\\\", \\\"shelf\\\", \\\"category\\\", \\\"subject\\\"\",\n \"def _get_attrs_symbols():\\n return {\\n 'True', 'False', 'None', # those are identifiers in Python 2.7\\n 'self',\\n 'parent',\\n 'id',\\n 'uid',\\n 'context',\\n 'context_today',\\n 'active_id',\\n 'active_ids',\\n 'allowed_company_ids',\\n 'current_company_id',\\n 'active_model',\\n 'time',\\n 'datetime',\\n 'relativedelta',\\n 'current_date',\\n 'abs',\\n 'len',\\n 'bool',\\n 'float',\\n 'str',\\n 'unicode',\\n }\",\n \"def capability_attributes(self) -> Mapping[str, Any] | None:\\n if state_class := self.state_class:\\n return {ATTR_STATE_CLASS: state_class}\\n\\n if options := self.options:\\n return {ATTR_OPTIONS: options}\\n\\n return None\",\n \"def attributes(self) -> Optional[Mapping[str, Sequence[str]]]:\\n return pulumi.get(self, \\\"attributes\\\")\",\n \"def _describe(self) -> Dict[str, Any]:\",\n \"def state_attributes(self) -> dict[str, StateType]:\\n attributes: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}\\n\\n if self.gps is not None:\\n attributes[ATTR_LATITUDE] = self.gps[0]\\n attributes[ATTR_LONGITUDE] = self.gps[1]\\n attributes[ATTR_GPS_ACCURACY] = self.gps_accuracy\\n\\n if self.battery is not None:\\n attributes[ATTR_BATTERY] = self.battery\\n\\n return attributes\",\n \"def to_dict(self):\\n d = {}\\n i = 0\\n for entry in self.entries:\\n d[i] = {}\\n attributes = self.get_attribute_list()\\n print (attributes)\\n for data in attributes:\\n d[i][data] = entry.__getattribute__(data)\\n i = i + 1\\n return d\",\n \"def device_state_attributes(self):\\n attrs = {}\\n\\n attrs[ATTR_ATTRIBUTION] = ATTRIBUTION\\n attrs[\\\"brand\\\"] = DEFAULT_BRAND\\n attrs[ATTR_CAMERA_TYPE] = self._camera_type\\n attrs[\\\"friendly_name\\\"] = self._name\\n\\n return attrs\",\n \"def types(self) -> Dict[str, str]:\\n return {name: self.hyperparams[name][0] for name in self.names()}\",\n \"def thrift_type_to_dict(obj: Any) -> Dict[str, Any]:\\n return {\\n camel_to_snake_case(attr): getattr(obj, attr)\\n for attr in thrift_attrs(obj)\\n }\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute('size', '20'),\\r\\n Attribute('inline', False),\\r\\n Attribute('label', ''),\\r\\n ]\",\n \"def get_question_name_to_answer_attribute_table(cls):\\n return {\\n value.question_name: attr_name\\n for attr_name, value in cls.__dict__.items()\\n if isinstance(value, answer.BaseAnswer)\\n }\",\n \"def create_descr(self, attr_name):\",\n \"def get_attributes_of_node(core, node):\\n attributes = {}\\n for attribute in core.get_attribute_names(node):\\n attributes[attribute] = core.get_attribute(node,attribute)\\n return attributes\",\n \"def get_attributes(self, shape):\\n attributes = {}\\n identifier_names = [i.name for i in self.identifiers]\\n\\n for name, member in shape.members.items():\\n snake_cased = xform_name(name)\\n if snake_cased in identifier_names:\\n # Skip identifiers, these are set through other means\\n continue\\n snake_cased = self._get_name(\\n 'attribute', snake_cased, snake_case=False\\n )\\n attributes[snake_cased] = (name, member)\\n\\n return attributes\",\n \"def info(self):\\n return (self.kind, self.value)\",\n \"def get_attributes(self):\\n\\t\\treturn dict(list(self.__element.items()))\",\n \"def attributes(self):\\n return {'op_type': self.__class__.__name__, 'arguments': {}}\",\n \"def getAttributeDict(self):\\n result = {}\\n dict = self.getDict()\\n for key in dict.keys():\\n value = dict.get(key)\\n if value.__class__.__name__ != 'SpecialDict':\\n result[key] = value\\n return result\",\n \"def as_dict(self):\\n result = {}\\n for attr in self.__attr:\\n result[attr] = getattr(self, attr)\\n return result\",\n \"def dict_by_attr(collection, attrname, value_attrname=None):\\n mapping = {}\\n for item in collection:\\n if callable(attrname):\\n key = attrname(item)\\n else:\\n key = extended_getattr(item, attrname)\\n if value_attrname:\\n item = extended_getattr(item, value_attrname)\\n mapping[key] = mapping.get(key, []) + [item]\\n return mapping\",\n \"def _process_attrs(attrs):\\n new_attrs = OrderedDict()\\n for attr in attrs:\\n col = attr\\n if isinstance(attr, tuple):\\n col, attr = attr\\n # special cases\\n if attr == 'class_name':\\n attr = '__class__.__name__'\\n if attr == 'repr':\\n attr = repr\\n new_attrs[col] = attr\\n\\n return new_attrs\",\n \"def __get_attr_format (self, attrs):\\r\\n format = { \\r\\n 'editor': None,\\r\\n 'min': None,\\r\\n 'max': None,\\r\\n 'step': None,\\r\\n 'subtype': None,\\r\\n 'flags': None,\\r\\n 'enums': None\\r\\n }\\r\\n\\r\\n for attr in attrs: \\r\\n attr_type = attr[\\\"type\\\"]\\r\\n if \\\"editor\\\" == attr_type:\\r\\n format['editor'] = attr[\\\"value\\\"] \\r\\n if \\\"min\\\" == attr_type:\\r\\n format['min'] = attr[\\\"value\\\"] \\r\\n if \\\"max\\\" == attr_type:\\r\\n format['max'] = attr[\\\"value\\\"] \\r\\n if \\\"default\\\" == attr_type:\\r\\n format['default'] = attr[\\\"value\\\"] \\r\\n if \\\"step\\\" == attr_type:\\r\\n format['step'] = attr[\\\"value\\\"]\\r\\n if \\\"subtype\\\" == attr_type:\\r\\n format['subtype'] = attr[\\\"value\\\"]\\r\\n if \\\"flags\\\" == attr_type:\\r\\n format['flags'] = attr['value']\\r\\n if \\\"enums\\\" == attr_type:\\r\\n format['enums'] = attr['value']\\r\\n\\r\\n return format\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute('height', None),\\r\\n Attribute('width', None),\\r\\n Attribute('parts', None),\\r\\n Attribute('analyses', None),\\r\\n Attribute('initial_value', None),\\r\\n Attribute('submit_analyses', None),\\r\\n Attribute('label', ''),\\r\\n ]\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(map(\\n lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x,\\n value\\n ))\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\") else item,\\n value.items()\\n ))\\n else:\\n result[attr] = value\\n if issubclass(UserAttributeInfo, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def expected_types_and_attributes(self):\\n return {self.configs[\\\"entry_type\\\"]: set()}\",\n \"def attribute_dict(self):\\n return self.__attribute_dict\",\n \"def to_dict(cls):\\n result = {}\\n for attr_name in _.reject(set(dir(cls)), lambda x: x.startswith('_')):\\n attr = getattr(cls, attr_name)\\n if _.is_list(attr) or _.is_string(attr):\\n result[attr_name] = attr\\n return result\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute(\\\"show_correctness\\\", \\\"always\\\"),\\r\\n Attribute(\\\"submitted_message\\\", \\\"Answer received.\\\"),\\r\\n Attribute(\\\"label\\\", \\\"\\\"),\\r\\n ]\",\n \"def as_dict(self):\\n return {c.key: getattr(self, c.key)\\n for c in inspect(self).mapper.column_attrs}\",\n \"def readTypes(self):\\r\\n types = {}\\r\\n for m in re.finditer(\\\"TYPE (.*) = (.*);\\\", self.data):\\r\\n typename, typetype = m.groups() \\r\\n if typetype in self.SIMPLETYPES:\\r\\n types[typename] = typetype\\r\\n else:\\r\\n types[typename] = \\\"#\\\" + typetype\\r\\n \\r\\n return types\",\n \"def GetAttributes(self, type):\\n if type == ArrayAssociation.FIELD:\\n return DataSetAttributes(self.VTKObject.GetFieldData(), self, type)\\n return DataSetAttributes(self.VTKObject.GetAttributes(type), self, type)\",\n \"def _get_var_attrs(var):\\n\\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\\n 'missing_value': -9999, 'height': '',\\n 'standard_name': '', 'group_name': '',\\n 'serial_number': ''}\\n\\n generic_dict.update(attrs_dict[var])\\n return generic_dict\",\n \"def tags_dict(self):\\n return ({'name': 'tag', 'attrs': {'k': k, 'v': v}} for k, v in self.tags.items())\",\n \"def extract_attrs(attr_string):\\n attributes = {}\\n for name, val in FIND_ATTRS.findall(attr_string):\\n val = (\\n val.replace(\\\"<\\\", \\\"<\\\")\\n .replace(\\\">\\\", \\\">\\\")\\n .replace(\\\""\\\", '\\\"')\\n .replace(\\\"&\\\", \\\"&\\\")\\n )\\n attributes[name] = val\\n return attributes\",\n \"def attrs(self):\\n return [name for name in self.traits() if self.trait_metadata(name, \\\"attr\\\")]\",\n \"def attrs(self):\\n return [name for name in self.traits() if self.trait_metadata(name, \\\"attr\\\")]\",\n \"def get_attribute_counts(self):\\n counts = defaultdict(int)\\n for attr in self:\\n counts[attr.name] += 1\\n\\n return dict(counts)\",\n \"def record_dict(self):\\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}\",\n \"def attributes(self):\\n return [self._ELE_ATTR]\",\n \"def parse_attributes(self, attr):\\n result = {}\\n annotations = []\\n # Sanitize and split attributes up\\n split_attr = attr.strip(' \\\\t\\\\n;').split(';')\\n for pair in split_attr:\\n splitpair = pair.split('=')\\n if len(splitpair) != 2:\\n continue\\n if splitpair[0] == \\\"ID\\\":\\n result['identifier'] = splitpair[1]\\n elif splitpair[0] == \\\"Name\\\":\\n result['name'] = splitpair[1]\\n elif splitpair[0] == \\\"Parent\\\":\\n result['parent_id'] = splitpair[1]\\n elif splitpair[0] == \\\"Dbxref\\\" or splitpair[0] == \\\"Ontology_term\\\":\\n annotations.append(splitpair)\\n # Make sure we found an ID\\n if \\\"identifier\\\" not in result:\\n return {}\\n # Add annotations if we found any\\n if annotations:\\n result[\\\"annotations\\\"] = annotations\\n return result\",\n \"def device_state_attributes(self):\\n if self.airly.data_available:\\n if self.type == ATTR_CAQI_DESCRIPTION:\\n self._attrs[ATTR_CAQI_ADVICE] = (self.airly.data\\n [ATTR_CAQI_ADVICE])\\n if self.type == ATTR_CAQI:\\n self._attrs[ATTR_CAQI_LEVEL] = self.airly.data[ATTR_CAQI_LEVEL]\\n if self.type == ATTR_PM25:\\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM25_LIMIT]\\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\\n [ATTR_PM25_PERCENT]))\\n if self.type == ATTR_PM10:\\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM10_LIMIT]\\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\\n [ATTR_PM10_PERCENT]))\\n return self._attrs\",\n \"def whoAreYou(self):\\n tempDict = {}\\n tempDict['Class'] = '{0:15}'.format(self.__class__.__name__) +' from '+' '.join([str(base) for base in self.__class__.__bases__])\\n tempDict['Type' ] = self.type\\n tempDict['Name' ] = self.name\\n return tempDict\",\n \"def values(self):\\n return {n: getattr(self, n) for n in self._hparam_types.keys()}\",\n \"def _metadata_map():\\n return {\\n 'date_added': 'dateAdded',\\n 'dns_active': 'dnsActive',\\n 'last_modified': 'lastModified',\\n 'private_flag': 'privateFlag',\\n 'whois_active': 'whoisActive',\\n 'key_name': 'Key Name',\\n 'value_type': 'Value Type',\\n 'value_name': 'Value Name',\\n 'block': 'Block',\\n 'mutex': 'Mutex',\\n 'as_number': 'AS Number',\\n 'hostname': 'hostName',\\n }\",\n \"def getDataAttributes(self):\\n asRet = [];\\n asAttrs = dir(self);\\n for sAttr in asAttrs:\\n if sAttr[0] == '_' or sAttr[0] == 'k':\\n continue;\\n if sAttr in self.kasInternalAttributes:\\n continue;\\n oValue = getattr(self, sAttr);\\n if callable(oValue):\\n continue;\\n asRet.append(sAttr);\\n return asRet;\",\n \"def get_attributes(self):\\n _attributes = {\\n 'function_id': self.function_id,\\n 'hardware_id': self.hardware_id,\\n 'mode_id': self.mode_id,\\n 'critical_item': self.critical_item,\\n 'description': self.description,\\n 'design_provisions': self.design_provisions,\\n 'detection_method': self.detection_method,\\n 'effect_end': self.effect_end,\\n 'effect_local': self.effect_local,\\n 'effect_next': self.effect_next,\\n 'effect_probability': self.effect_probability,\\n 'hazard_rate_source': self.hazard_rate_source,\\n 'isolation_method': self.isolation_method,\\n 'mission': self.mission,\\n 'mission_phase': self.mission_phase,\\n 'mode_criticality': self.mode_criticality,\\n 'mode_hazard_rate': self.mode_hazard_rate,\\n 'mode_op_time': self.mode_op_time,\\n 'mode_probability': self.mode_probability,\\n 'mode_ratio': self.mode_ratio,\\n 'operator_actions': self.operator_actions,\\n 'other_indications': self.other_indications,\\n 'remarks': self.remarks,\\n 'rpn_severity': self.rpn_severity,\\n 'rpn_severity_new': self.rpn_severity_new,\\n 'severity_class': self.severity_class,\\n 'single_point': self.single_point,\\n 'type_id': self.type_id\\n }\\n\\n return _attributes\",\n \"def getAttributeInfo(self, atName):\\n try:\\n dataType, mandatoryCode = self.__getAttributeInfo(atName)\\n return dataType, mandatoryCode\\n except Exception:\\n return None, None\",\n \"def as_attrdict(self) -> AttributeDict:\\n return AttributeDict(\\n {\\n x: Configuration(v).as_attrdict() if isinstance(v, Mapping) else v\\n for x, v in self.items(levels=1)\\n }\\n )\",\n \"def to_dict(self):\\n dct = dict(zip(self._fields, self))\\n dct['type'] = type(self).__name__\\n return dct\",\n \"def attributes(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"attributes\\\")\",\n \"def keys(self):\\n return list(s.name.lower() for s in self.attributes)\",\n \"def get_attributes(self):\\n _attributes = {\\n 'measurement_id': self.measurement_id,\\n 'code': self.code,\\n 'description': self.description,\\n 'measurement_type': self.measurement_type\\n }\\n\\n return _attributes\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def arm_to_dict(arm: Arm) -> Dict[str, Any]:\\n return {\\n \\\"__type\\\": arm.__class__.__name__,\\n \\\"parameters\\\": arm.parameters,\\n \\\"name\\\": arm._name,\\n }\",\n \"def to_dictionary(self):\\n attributes = [\\\"id\\\", \\\"size\\\", \\\"x\\\", \\\"y\\\"]\\n return {key: getattr(self, key) for key in attributes}\",\n \"def dict_to_label_attr_map(input_dict):\\n return {key+':': [key, type(val)] for key, val in input_dict.items()}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6793609","0.6674305","0.6664413","0.6616096","0.64803094","0.64548177","0.64188623","0.63728285","0.63316894","0.62979114","0.6276313","0.62762487","0.6258179","0.62334234","0.62087464","0.6139291","0.61141795","0.6099927","0.6081081","0.6017317","0.59891033","0.59812504","0.5979476","0.5950849","0.59350693","0.59120417","0.58949643","0.58688116","0.58687997","0.5835244","0.5803443","0.5801994","0.57980466","0.57622504","0.57506835","0.57452977","0.573632","0.5721086","0.57088363","0.5701109","0.5699161","0.5698955","0.56718576","0.56560326","0.5646675","0.5644275","0.5622441","0.56010985","0.55815053","0.5581215","0.5575585","0.5572098","0.55694664","0.55685365","0.55563986","0.5554785","0.5552076","0.5544977","0.5544627","0.55417","0.5539493","0.5539029","0.55349696","0.5523133","0.55177563","0.55088794","0.5501874","0.5494877","0.5489911","0.5488944","0.54736656","0.5472781","0.54719675","0.5456656","0.54562825","0.54514486","0.54402345","0.5435867","0.5435867","0.543066","0.54294395","0.54255444","0.5422349","0.54203343","0.54193854","0.54160106","0.54154223","0.5413171","0.5411299","0.5409558","0.5408751","0.5407834","0.5405463","0.53973424","0.5389468","0.53761625","0.53761625","0.5370725","0.5364506","0.5361778"],"string":"[\n \"0.6793609\",\n \"0.6674305\",\n \"0.6664413\",\n \"0.6616096\",\n \"0.64803094\",\n \"0.64548177\",\n \"0.64188623\",\n \"0.63728285\",\n \"0.63316894\",\n \"0.62979114\",\n \"0.6276313\",\n \"0.62762487\",\n \"0.6258179\",\n \"0.62334234\",\n \"0.62087464\",\n \"0.6139291\",\n \"0.61141795\",\n \"0.6099927\",\n \"0.6081081\",\n \"0.6017317\",\n \"0.59891033\",\n \"0.59812504\",\n \"0.5979476\",\n \"0.5950849\",\n \"0.59350693\",\n \"0.59120417\",\n \"0.58949643\",\n \"0.58688116\",\n \"0.58687997\",\n \"0.5835244\",\n \"0.5803443\",\n \"0.5801994\",\n \"0.57980466\",\n \"0.57622504\",\n \"0.57506835\",\n \"0.57452977\",\n \"0.573632\",\n \"0.5721086\",\n \"0.57088363\",\n \"0.5701109\",\n \"0.5699161\",\n \"0.5698955\",\n \"0.56718576\",\n \"0.56560326\",\n \"0.5646675\",\n \"0.5644275\",\n \"0.5622441\",\n \"0.56010985\",\n \"0.55815053\",\n \"0.5581215\",\n \"0.5575585\",\n \"0.5572098\",\n \"0.55694664\",\n \"0.55685365\",\n \"0.55563986\",\n \"0.5554785\",\n \"0.5552076\",\n \"0.5544977\",\n \"0.5544627\",\n \"0.55417\",\n \"0.5539493\",\n \"0.5539029\",\n \"0.55349696\",\n \"0.5523133\",\n \"0.55177563\",\n \"0.55088794\",\n \"0.5501874\",\n \"0.5494877\",\n \"0.5489911\",\n \"0.5488944\",\n \"0.54736656\",\n \"0.5472781\",\n \"0.54719675\",\n \"0.5456656\",\n \"0.54562825\",\n \"0.54514486\",\n \"0.54402345\",\n \"0.5435867\",\n \"0.5435867\",\n \"0.543066\",\n \"0.54294395\",\n \"0.54255444\",\n \"0.5422349\",\n \"0.54203343\",\n \"0.54193854\",\n \"0.54160106\",\n \"0.54154223\",\n \"0.5413171\",\n \"0.5411299\",\n \"0.5409558\",\n \"0.5408751\",\n \"0.5407834\",\n \"0.5405463\",\n \"0.53973424\",\n \"0.5389468\",\n \"0.53761625\",\n \"0.53761625\",\n \"0.5370725\",\n \"0.5364506\",\n \"0.5361778\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56027544"},"document_rank":{"kind":"string","value":"47"}}},{"rowIdx":76090,"cells":{"query":{"kind":"string","value":"Returns a dictionary that maps attribute name to a tuple of (type, description)."},"document":{"kind":"string","value":"def get_module_attributes(module) -> Dict[str, Tuple[Any, str]]:\n try:\n source = inspect.getsource(module) or \"\"\n if not source:\n return {}\n except (OSError, TypeError):\n return {}\n node = ast.parse(source)\n\n attr_list: List[Tuple] = []\n globals = dict(inspect.getmembers(module))\n for x in ast.iter_child_nodes(node):\n if isinstance(x, _ast.AnnAssign):\n attr, lineno, type_str = parse_annotation_assign(x)\n type = eval(type_str, globals)\n attr_list.append((attr, lineno, type))\n if isinstance(x, _ast.Assign):\n attr_list.append(parse_attribute_with_lineno(x))\n attr_list = sorted(attr_list, key=lambda x: x[1])\n\n attrs: Dict[str, Tuple[Any, str]] = {}\n lines = source.split(\"\\n\")\n for name, lineno, *type in attr_list:\n desc = get_description(lines, lineno)\n if type:\n attrs[name] = type[0], desc # Assignment with type annotation wins.\n elif name not in attrs:\n attrs[name] = None, desc\n return attrs"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}","def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a","def get_attributes(self) -> Dict[str, str]:\n pass","def map_field_name_to_attribute() -> typing.Dict:\n return {\n \"tag\": \"tag\",\n \"contact\": \"contact\",\n }","def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs","def attributes_metadata(self):\n\n attribute_meta = collections.defaultdict(dict)\n\n for attribute in self.attributes:\n attribute_meta[attribute.name]['valuemap'] = attribute.valuemap\n attribute_meta[attribute.name]['qualifiers'] = attribute.qualifiers\n\n return dict(attribute_meta)","def get_attributes(self):\n \n retdict = {}\n retdict['s'] = str(self.s)\n if self.t != None:\n retdict['t'] = str(self.t)\n retdict['a'] = str(self.a)\n retdict['b'] = str(self.b)\n retdict['c'] = str(self.c)\n retdict['d'] = str(self.d)\n return retdict","def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic","def meta(cls):\n if getattr(cls, '__from_class__', None) is not None:\n cls = cls.__from_class__\n attribute_info = {}\n for name, value in cls.__table__.columns.items():\n attribute_info[name] = str(value.type).lower()\n\n return {cls.__name__: attribute_info}","def attributeType(self) -> unicode:\n ...","def description(self):\n desc = self.title\n ops = []\n for attribute in self.attributes.all():\n value = attribute.value\n if isinstance(value, list):\n ops.append(\n \"%s = '%s'\" % (attribute.type, (\", \".join([str(v) for v in value])))\n )\n else:\n ops.append(\"%s = '%s'\" % (attribute.type, value))\n if ops:\n desc = \"%s (%s)\" % (desc, \", \".join(ops))\n return desc","def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}","def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass","def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_","def get_attrs_dict(self, root_element):\n attr_elements = root_element.findall(\"attribute\")\n attrs_dict = {}\n for el in attr_elements:\n attrs_dict[el.attrib[\"name\"]] = {\n \"value\": el.attrib[\"value\"],\n \"type\": el.attrib.get(\"type\", None)\n }\n return attrs_dict","def to_dict(\n self,\n attributes: Iterable[str] = (\"xyz\", \"viewdir\", \"imgsz\", \"f\", \"c\", \"k\", \"p\"),\n ) -> Dict[str, tuple]:\n return {key: helpers.numpy_to_native(getattr(self, key)) for key in attributes}","def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:\n fields = cls.__dataclass_fields__.values()\n attrs = {}\n for field in fields:\n if field.type != InitVar:\n attrs[field.name] = field.type, \"\"\n return attrs","def dict(self) -> dict():\n\n dict_reg_hive = {}\n\n for _attribute in self.attributes.__dict__.items():\n if isinstance(_attribute[1], str):\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\n _attribute_value = getattr(self, _attribute[1])\n dict_reg_hive.update({_attribute[1]: _attribute_value})\n\n return dict_reg_hive","def get_attrib_dict(self, attribs: Tuple[str]) -> Dict[str, str]:\n attrs = self.get_attribs(attribs)\n attrs = tuple(map(lambda a: (a[0][1:], a[1]), attrs))\n return dict(attrs)","def attribute_metadata(attr: Attr, parent_namespace: Optional[str]) -> Dict:\n metadata = dict(\n name=None\n if attr.is_nameless or attr.local_name == attribute_name(attr.name)\n else attr.local_name,\n type=attr.xml_type,\n namespace=attr.namespace\n if parent_namespace != attr.namespace or attr.is_attribute\n else None,\n **attr.restrictions.asdict(),\n )\n\n return {\n key: value\n for key, value in metadata.items()\n if value is not None and value is not False\n }","def get_attribute_data(self):\n ret = {}\n\n for attribute in Attribute.objects.all().prefetch_related(\"value_choices\"):\n deserialized_value = None\n\n if attribute.value_type == Attribute.TYPE_GEOMETRY:\n geometry = ProjectAttributeMultipolygonGeometry.objects.filter(\n attribute=attribute, project=self\n ).first()\n if not geometry:\n continue\n deserialized_value = geometry.geometry\n elif attribute.value_type in [Attribute.TYPE_IMAGE, Attribute.TYPE_FILE]:\n try:\n deserialized_value = ProjectAttributeFile.objects.filter(\n attribute=attribute, project=self\n ).order_by(\"-created_at\").first().file\n except AttributeError:\n deserialized_value = None\n elif attribute.identifier in self.attribute_data:\n deserialized_value = attribute.deserialize_value(\n self.attribute_data[attribute.identifier]\n )\n\n ret[attribute.identifier] = deserialized_value\n return ret","def read_attr_type_file():\n with open(args.attr_type_file_path, 'r') as f:\n content = f.readlines()\n\n # Strip lines of newline/return characters in csv file\n content = [x.strip(' \\t\\n\\r') for x in content]\n\n # Generate dictionary of types and their count\n attribute_type_dict = {}\n for item in content:\n key, value = item.split('|')\n attribute_type_dict[key.strip()] = value.strip()\n \n return attribute_type_dict","def __getAttributeInfo(self, atName):\n cifDataType = self.__dApi.getTypeCode(self.getName(), atName)\n cifPrimitiveType = self.__dApi.getTypePrimitive(self.getName(), atName)\n isMandatory = self.__dApi.getMandatoryCode(self.getName(), atName) in [\"yes\", \"implicit\", \"implicit-ordinal\"]\n dataType = \"integer\" if \"int\" in cifDataType else \"float\" if cifPrimitiveType == \"numb\" else \"string\"\n return dataType, isMandatory","def attributeInfo(*args, allAttributes: bool=True, bool: bool=True, enumerated: bool=True,\n hidden: bool=True, inherited: bool=True, internal: bool=True, leaf: bool=True,\n logicalAnd: bool=True, multi: bool=True, short: bool=True, userInterface:\n bool=True, writable: bool=True, type: AnyStr=\"\", **kwargs)->List[AnyStr]:\n pass","def get_attributes(cls):\r\n return [Attribute('size', '20'),\r\n Attribute('label', ''), ]","def get_attributes(self):\n\n endpoint = self._get_api_endpoint() + '/attributes'\n results = self.tq.get(endpoint, withp='attribute')\n if 'data' not in results:\n return {}\n\n return results['data']\n # tr = {}\n # for attribute in results['data']:\n # tr[attribute['attribute']['name']] = attribute['value']\n # return tr","def getDict(self):\n res = {}\n for attr, value in self.__dict__.iteritems():\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\n res[attr] = value\n elif isinstance(attr, datetime.datetime):\n res[attr] = value.isoformat('-')\n \n return res","def to_dict(\n self, attributes: Sequence[str] = (\n 'demand_instruments', 'supply_instruments', 'inverse_covariance_matrix',\n 'expected_xi_by_theta_jacobian', 'expected_omega_by_theta_jacobian', 'expected_prices',\n 'expected_shares', 'computation_time', 'draws', 'fp_converged', 'fp_iterations',\n 'contraction_evaluations'\n )) -> dict:\n return {k: getattr(self, k) for k in attributes}","def category_attributes_types(categories, db_info, connection):\n attributes = {}\n for cat in categories:\n attributes[cat] = {}\n category_info = api_category_info(cat, db_info, connection)\n\n attr = {}\n for a in category_info.get(\"attributes\"):\n for key in a:\n attr[key] = a[key]\n\n attributes[cat][\"attributes\"] = {k: d for d, k in attr.items()}\n\n types = category_info.get(\"types\")\n attributes[cat][\"types\"] = {\n attr.get(a): types.get(a) for a in types}\n\n attributes[cat][\"dialogs\"] = category_info.get(\"dialogs\")\n\n return attributes","def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs","def attributes(self):\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }","def attributes(self, *args):\n kwargs = {}\n if args:\n kwargs[\"attributenames\"] = args\n\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\n\n # parse contennt looking for all attributes\n attributes = []\n for line in r.text.splitlines():\n r = re.match(\"(userdetails\\.attribute\\.name)=(.*)\", line)\n if r:\n name = r.groups()[1]\n attributes.append([name, None])\n continue # next line\n\n r = re.match(\"(userdetails\\.attribute\\.value)=(.*)\", line)\n if r:\n value = r.groups()[1]\n # last name parsed is where it has to\n # be stacked\n if attributes[-1][1] == None:\n attributes[-1][1] = value\n if isinstance(attributes[-1][1], list):\n attributes[-1][1].append(value)\n else:\n # cast to list\n attributes[-1].append([attributes[-1][1], value])\n\n return dict([(item[0], item[1]) for item in attributes])","def describe(self):\r\n return dict((field.name, dict(\r\n id=field.name,\r\n name=field.label,\r\n validators=ValidatorSerializer(\r\n field.requires if isSequenceType(field.requires) else [field.requires])(),\r\n comment=field.comment,\r\n readable=field.readable,\r\n writable=field.writable,\r\n type=getattr(field, 'wtype',\r\n field.type.type if isinstance(field.type, SQLCustomType) else field.type.split('(')[0]),\r\n # w2pwidget=field.widget,\r\n )) for field in self.descibe_columns)","def attributes(self):\n return dict(self.__attributes)","def get_attributes(obj) -> Dict[str, Tuple[Any, str]]:\n if is_dataclass(obj):\n return get_dataclass_attributes(obj)\n elif inspect.isclass(obj):\n return get_class_attributes(obj)\n elif inspect.ismodule(obj):\n return get_module_attributes(obj)\n return {}","def attribute_to_dict(attr: onnx.AttributeProto) -> Dict:\n ret = {}\n for a in attr:\n value = get_attribute_value(a)\n if isinstance(value, bytes):\n value = str(value, 'utf-8')\n ret[a.name] = value\n return ret","def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict","def _get_attribute_dict(self, attributes, classname=None):\n if attributes and isinstance(attributes, six.string_types):\n return {\n 'class': attributes\n }\n if not attributes:\n attributes = {}\n if not classname:\n classname = self.DEFAULT_CLASS_NAME\n attributes.setdefault('class', classname)\n return attributes","def attributes(self):\n _attrs = []\n if self.name:\n _attrs.append(\"name\")\n if self.label:\n _attrs.append(\"label\")\n if self.confidence:\n _attrs.append(\"confidence\")\n if self.index:\n _attrs.append(\"index\")\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs + [\"points\"]","def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs","def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}","def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"","def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }","def capability_attributes(self) -> Mapping[str, Any] | None:\n if state_class := self.state_class:\n return {ATTR_STATE_CLASS: state_class}\n\n if options := self.options:\n return {ATTR_OPTIONS: options}\n\n return None","def attributes(self) -> Optional[Mapping[str, Sequence[str]]]:\n return pulumi.get(self, \"attributes\")","def _describe(self) -> Dict[str, Any]:","def get_class_attributes(cls) -> Dict[str, Tuple[Any, str]]:\n try:\n source = inspect.getsource(cls.__init__) or \"\"\n if not source:\n return {}\n except TypeError:\n return {}\n source = utils.join(source.split(\"\\n\"))\n node = ast.parse(source)\n\n attr_list: List[Tuple] = []\n module = importlib.import_module(cls.__module__)\n globals = dict(inspect.getmembers(module))\n for x in ast.walk(node):\n if isinstance(x, _ast.AnnAssign):\n attr, lineno, type_str = parse_annotation_assign(x)\n type = eval(type_str, globals)\n attr_list.append((attr, lineno, type))\n if isinstance(x, _ast.Attribute) and isinstance(x.ctx, _ast.Store):\n attr_list.append(parse_attribute_with_lineno(x))\n attr_list = sorted(attr_list, key=lambda x: x[1])\n\n attrs: Dict[str, Tuple[Any, str]] = {}\n lines = source.split(\"\\n\")\n for name, lineno, *type in attr_list:\n if name.startswith(\"self.\"):\n name = name[5:]\n desc = get_description(lines, lineno)\n if type:\n attrs[name] = type[0], desc # Assignment with type annotation wins.\n elif name not in attrs:\n attrs[name] = None, desc\n return attrs","def state_attributes(self) -> dict[str, StateType]:\n attributes: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}\n\n if self.gps is not None:\n attributes[ATTR_LATITUDE] = self.gps[0]\n attributes[ATTR_LONGITUDE] = self.gps[1]\n attributes[ATTR_GPS_ACCURACY] = self.gps_accuracy\n\n if self.battery is not None:\n attributes[ATTR_BATTERY] = self.battery\n\n return attributes","def to_dict(self):\n d = {}\n i = 0\n for entry in self.entries:\n d[i] = {}\n attributes = self.get_attribute_list()\n print (attributes)\n for data in attributes:\n d[i][data] = entry.__getattribute__(data)\n i = i + 1\n return d","def device_state_attributes(self):\n attrs = {}\n\n attrs[ATTR_ATTRIBUTION] = ATTRIBUTION\n attrs[\"brand\"] = DEFAULT_BRAND\n attrs[ATTR_CAMERA_TYPE] = self._camera_type\n attrs[\"friendly_name\"] = self._name\n\n return attrs","def types(self) -> Dict[str, str]:\n return {name: self.hyperparams[name][0] for name in self.names()}","def thrift_type_to_dict(obj: Any) -> Dict[str, Any]:\n return {\n camel_to_snake_case(attr): getattr(obj, attr)\n for attr in thrift_attrs(obj)\n }","def get_attributes(cls):\r\n return [\r\n Attribute('size', '20'),\r\n Attribute('inline', False),\r\n Attribute('label', ''),\r\n ]","def get_question_name_to_answer_attribute_table(cls):\n return {\n value.question_name: attr_name\n for attr_name, value in cls.__dict__.items()\n if isinstance(value, answer.BaseAnswer)\n }","def create_descr(self, attr_name):","def get_attributes_of_node(core, node):\n attributes = {}\n for attribute in core.get_attribute_names(node):\n attributes[attribute] = core.get_attribute(node,attribute)\n return attributes","def get_attributes(self, shape):\n attributes = {}\n identifier_names = [i.name for i in self.identifiers]\n\n for name, member in shape.members.items():\n snake_cased = xform_name(name)\n if snake_cased in identifier_names:\n # Skip identifiers, these are set through other means\n continue\n snake_cased = self._get_name(\n 'attribute', snake_cased, snake_case=False\n )\n attributes[snake_cased] = (name, member)\n\n return attributes","def info(self):\n return (self.kind, self.value)","def get_attributes(self):\n\t\treturn dict(list(self.__element.items()))","def attributes(self):\n return {'op_type': self.__class__.__name__, 'arguments': {}}","def getAttributeDict(self):\n result = {}\n dict = self.getDict()\n for key in dict.keys():\n value = dict.get(key)\n if value.__class__.__name__ != 'SpecialDict':\n result[key] = value\n return result","def as_dict(self):\n result = {}\n for attr in self.__attr:\n result[attr] = getattr(self, attr)\n return result","def dict_by_attr(collection, attrname, value_attrname=None):\n mapping = {}\n for item in collection:\n if callable(attrname):\n key = attrname(item)\n else:\n key = extended_getattr(item, attrname)\n if value_attrname:\n item = extended_getattr(item, value_attrname)\n mapping[key] = mapping.get(key, []) + [item]\n return mapping","def _process_attrs(attrs):\n new_attrs = OrderedDict()\n for attr in attrs:\n col = attr\n if isinstance(attr, tuple):\n col, attr = attr\n # special cases\n if attr == 'class_name':\n attr = '__class__.__name__'\n if attr == 'repr':\n attr = repr\n new_attrs[col] = attr\n\n return new_attrs","def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format","def get_attributes(cls):\r\n return [\r\n Attribute('height', None),\r\n Attribute('width', None),\r\n Attribute('parts', None),\r\n Attribute('analyses', None),\r\n Attribute('initial_value', None),\r\n Attribute('submit_analyses', None),\r\n Attribute('label', ''),\r\n ]","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n if issubclass(UserAttributeInfo, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def expected_types_and_attributes(self):\n return {self.configs[\"entry_type\"]: set()}","def attribute_dict(self):\n return self.__attribute_dict","def to_dict(cls):\n result = {}\n for attr_name in _.reject(set(dir(cls)), lambda x: x.startswith('_')):\n attr = getattr(cls, attr_name)\n if _.is_list(attr) or _.is_string(attr):\n result[attr_name] = attr\n return result","def get_attributes(cls):\r\n return [\r\n Attribute(\"show_correctness\", \"always\"),\r\n Attribute(\"submitted_message\", \"Answer received.\"),\r\n Attribute(\"label\", \"\"),\r\n ]","def as_dict(self):\n return {c.key: getattr(self, c.key)\n for c in inspect(self).mapper.column_attrs}","def readTypes(self):\r\n types = {}\r\n for m in re.finditer(\"TYPE (.*) = (.*);\", self.data):\r\n typename, typetype = m.groups() \r\n if typetype in self.SIMPLETYPES:\r\n types[typename] = typetype\r\n else:\r\n types[typename] = \"#\" + typetype\r\n \r\n return types","def GetAttributes(self, type):\n if type == ArrayAssociation.FIELD:\n return DataSetAttributes(self.VTKObject.GetFieldData(), self, type)\n return DataSetAttributes(self.VTKObject.GetAttributes(type), self, type)","def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict","def tags_dict(self):\n return ({'name': 'tag', 'attrs': {'k': k, 'v': v}} for k, v in self.tags.items())","def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes","def attrs(self):\n return [name for name in self.traits() if self.trait_metadata(name, \"attr\")]","def attrs(self):\n return [name for name in self.traits() if self.trait_metadata(name, \"attr\")]","def record_dict(self):\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}","def get_attribute_counts(self):\n counts = defaultdict(int)\n for attr in self:\n counts[attr.name] += 1\n\n return dict(counts)","def attributes(self):\n return [self._ELE_ATTR]","def parse_attributes(self, attr):\n result = {}\n annotations = []\n # Sanitize and split attributes up\n split_attr = attr.strip(' \\t\\n;').split(';')\n for pair in split_attr:\n splitpair = pair.split('=')\n if len(splitpair) != 2:\n continue\n if splitpair[0] == \"ID\":\n result['identifier'] = splitpair[1]\n elif splitpair[0] == \"Name\":\n result['name'] = splitpair[1]\n elif splitpair[0] == \"Parent\":\n result['parent_id'] = splitpair[1]\n elif splitpair[0] == \"Dbxref\" or splitpair[0] == \"Ontology_term\":\n annotations.append(splitpair)\n # Make sure we found an ID\n if \"identifier\" not in result:\n return {}\n # Add annotations if we found any\n if annotations:\n result[\"annotations\"] = annotations\n return result","def device_state_attributes(self):\n if self.airly.data_available:\n if self.type == ATTR_CAQI_DESCRIPTION:\n self._attrs[ATTR_CAQI_ADVICE] = (self.airly.data\n [ATTR_CAQI_ADVICE])\n if self.type == ATTR_CAQI:\n self._attrs[ATTR_CAQI_LEVEL] = self.airly.data[ATTR_CAQI_LEVEL]\n if self.type == ATTR_PM25:\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM25_LIMIT]\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\n [ATTR_PM25_PERCENT]))\n if self.type == ATTR_PM10:\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM10_LIMIT]\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\n [ATTR_PM10_PERCENT]))\n return self._attrs","def whoAreYou(self):\n tempDict = {}\n tempDict['Class'] = '{0:15}'.format(self.__class__.__name__) +' from '+' '.join([str(base) for base in self.__class__.__bases__])\n tempDict['Type' ] = self.type\n tempDict['Name' ] = self.name\n return tempDict","def values(self):\n return {n: getattr(self, n) for n in self._hparam_types.keys()}","def _metadata_map():\n return {\n 'date_added': 'dateAdded',\n 'dns_active': 'dnsActive',\n 'last_modified': 'lastModified',\n 'private_flag': 'privateFlag',\n 'whois_active': 'whoisActive',\n 'key_name': 'Key Name',\n 'value_type': 'Value Type',\n 'value_name': 'Value Name',\n 'block': 'Block',\n 'mutex': 'Mutex',\n 'as_number': 'AS Number',\n 'hostname': 'hostName',\n }","def getDataAttributes(self):\n asRet = [];\n asAttrs = dir(self);\n for sAttr in asAttrs:\n if sAttr[0] == '_' or sAttr[0] == 'k':\n continue;\n if sAttr in self.kasInternalAttributes:\n continue;\n oValue = getattr(self, sAttr);\n if callable(oValue):\n continue;\n asRet.append(sAttr);\n return asRet;","def get_attributes(self):\n _attributes = {\n 'function_id': self.function_id,\n 'hardware_id': self.hardware_id,\n 'mode_id': self.mode_id,\n 'critical_item': self.critical_item,\n 'description': self.description,\n 'design_provisions': self.design_provisions,\n 'detection_method': self.detection_method,\n 'effect_end': self.effect_end,\n 'effect_local': self.effect_local,\n 'effect_next': self.effect_next,\n 'effect_probability': self.effect_probability,\n 'hazard_rate_source': self.hazard_rate_source,\n 'isolation_method': self.isolation_method,\n 'mission': self.mission,\n 'mission_phase': self.mission_phase,\n 'mode_criticality': self.mode_criticality,\n 'mode_hazard_rate': self.mode_hazard_rate,\n 'mode_op_time': self.mode_op_time,\n 'mode_probability': self.mode_probability,\n 'mode_ratio': self.mode_ratio,\n 'operator_actions': self.operator_actions,\n 'other_indications': self.other_indications,\n 'remarks': self.remarks,\n 'rpn_severity': self.rpn_severity,\n 'rpn_severity_new': self.rpn_severity_new,\n 'severity_class': self.severity_class,\n 'single_point': self.single_point,\n 'type_id': self.type_id\n }\n\n return _attributes","def as_attrdict(self) -> AttributeDict:\n return AttributeDict(\n {\n x: Configuration(v).as_attrdict() if isinstance(v, Mapping) else v\n for x, v in self.items(levels=1)\n }\n )","def getAttributeInfo(self, atName):\n try:\n dataType, mandatoryCode = self.__getAttributeInfo(atName)\n return dataType, mandatoryCode\n except Exception:\n return None, None","def to_dict(self):\n dct = dict(zip(self._fields, self))\n dct['type'] = type(self).__name__\n return dct","def attributes(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\n return pulumi.get(self, \"attributes\")","def keys(self):\n return list(s.name.lower() for s in self.attributes)","def get_attributes(self):\n _attributes = {\n 'measurement_id': self.measurement_id,\n 'code': self.code,\n 'description': self.description,\n 'measurement_type': self.measurement_type\n }\n\n return _attributes","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def arm_to_dict(arm: Arm) -> Dict[str, Any]:\n return {\n \"__type\": arm.__class__.__name__,\n \"parameters\": arm.parameters,\n \"name\": arm._name,\n }","def to_dictionary(self):\n attributes = [\"id\", \"size\", \"x\", \"y\"]\n return {key: getattr(self, key) for key in attributes}","def dict_to_label_attr_map(input_dict):\n return {key+':': [key, type(val)] for key, val in input_dict.items()}"],"string":"[\n \"def _attrs_map(self) -> \\\"dict[int, str]\\\":\\n return {i: attr.name for i, attr in enumerate(self._attrs())}\",\n \"def _attribs(self, name=None, description=None):\\n a = {}\\n if name:\\n a['name'] = name\\n if description:\\n a['description'] = description\\n return a\",\n \"def get_attributes(self) -> Dict[str, str]:\\n pass\",\n \"def map_field_name_to_attribute() -> typing.Dict:\\n return {\\n \\\"tag\\\": \\\"tag\\\",\\n \\\"contact\\\": \\\"contact\\\",\\n }\",\n \"def attributes(self):\\n _attrs = [\\\"type\\\", \\\"name\\\", \\\"value\\\"]\\n if self.confidence is not None:\\n _attrs.append(\\\"confidence\\\")\\n if self.constant:\\n _attrs.append(\\\"constant\\\")\\n if self.tags:\\n _attrs.append(\\\"tags\\\")\\n\\n return _attrs\",\n \"def attributes_metadata(self):\\n\\n attribute_meta = collections.defaultdict(dict)\\n\\n for attribute in self.attributes:\\n attribute_meta[attribute.name]['valuemap'] = attribute.valuemap\\n attribute_meta[attribute.name]['qualifiers'] = attribute.qualifiers\\n\\n return dict(attribute_meta)\",\n \"def get_attributes(self):\\n \\n retdict = {}\\n retdict['s'] = str(self.s)\\n if self.t != None:\\n retdict['t'] = str(self.t)\\n retdict['a'] = str(self.a)\\n retdict['b'] = str(self.b)\\n retdict['c'] = str(self.c)\\n retdict['d'] = str(self.d)\\n return retdict\",\n \"def _get_attribute_dic(self, attrs):\\n attr_dic = {}\\n for attr_pair in attrs:\\n attr_dic[attr_pair[0]] = attr_pair[1]\\n return attr_dic\",\n \"def meta(cls):\\n if getattr(cls, '__from_class__', None) is not None:\\n cls = cls.__from_class__\\n attribute_info = {}\\n for name, value in cls.__table__.columns.items():\\n attribute_info[name] = str(value.type).lower()\\n\\n return {cls.__name__: attribute_info}\",\n \"def attributeType(self) -> unicode:\\n ...\",\n \"def description(self):\\n desc = self.title\\n ops = []\\n for attribute in self.attributes.all():\\n value = attribute.value\\n if isinstance(value, list):\\n ops.append(\\n \\\"%s = '%s'\\\" % (attribute.type, (\\\", \\\".join([str(v) for v in value])))\\n )\\n else:\\n ops.append(\\\"%s = '%s'\\\" % (attribute.type, value))\\n if ops:\\n desc = \\\"%s (%s)\\\" % (desc, \\\", \\\".join(ops))\\n return desc\",\n \"def getAttributeInfoDictionary(attr, format=None):\\n format = format or _getDocFormat(attr)\\n return {'name': attr.getName(),\\n 'doc': renderText(attr.getDoc() or '', format=format)}\",\n \"def proc_attr(inp):\\n dic = {}\\n for att in inp.attrs.keys():\\n if getattr(inp.attrs[att], \\\"dtype\\\", None) is None:\\n dic[att] = inp.attrs[att]\\n elif inp.attrs[att].dtype.char == 'S':\\n dic[att] = [\\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\\n ]\\n else:\\n dic[att] = (\\n inp.attrs[att][0]\\n if isinstance(inp.attrs[att],np.ndarray) and\\n inp.attrs[att].size==1\\n else inp.attrs[att]\\n )\\n return dic\\n pass\",\n \"def attributes(self):\\n attrs_ = [\\\"name\\\", \\\"type\\\"]\\n if self.exclusive:\\n attrs_.append(\\\"exclusive\\\")\\n if self.default is not None:\\n attrs_.append(\\\"default\\\")\\n\\n return attrs_\",\n \"def get_attrs_dict(self, root_element):\\n attr_elements = root_element.findall(\\\"attribute\\\")\\n attrs_dict = {}\\n for el in attr_elements:\\n attrs_dict[el.attrib[\\\"name\\\"]] = {\\n \\\"value\\\": el.attrib[\\\"value\\\"],\\n \\\"type\\\": el.attrib.get(\\\"type\\\", None)\\n }\\n return attrs_dict\",\n \"def to_dict(\\n self,\\n attributes: Iterable[str] = (\\\"xyz\\\", \\\"viewdir\\\", \\\"imgsz\\\", \\\"f\\\", \\\"c\\\", \\\"k\\\", \\\"p\\\"),\\n ) -> Dict[str, tuple]:\\n return {key: helpers.numpy_to_native(getattr(self, key)) for key in attributes}\",\n \"def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:\\n fields = cls.__dataclass_fields__.values()\\n attrs = {}\\n for field in fields:\\n if field.type != InitVar:\\n attrs[field.name] = field.type, \\\"\\\"\\n return attrs\",\n \"def dict(self) -> dict():\\n\\n dict_reg_hive = {}\\n\\n for _attribute in self.attributes.__dict__.items():\\n if isinstance(_attribute[1], str):\\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\\n _attribute_value = getattr(self, _attribute[1])\\n dict_reg_hive.update({_attribute[1]: _attribute_value})\\n\\n return dict_reg_hive\",\n \"def get_attrib_dict(self, attribs: Tuple[str]) -> Dict[str, str]:\\n attrs = self.get_attribs(attribs)\\n attrs = tuple(map(lambda a: (a[0][1:], a[1]), attrs))\\n return dict(attrs)\",\n \"def attribute_metadata(attr: Attr, parent_namespace: Optional[str]) -> Dict:\\n metadata = dict(\\n name=None\\n if attr.is_nameless or attr.local_name == attribute_name(attr.name)\\n else attr.local_name,\\n type=attr.xml_type,\\n namespace=attr.namespace\\n if parent_namespace != attr.namespace or attr.is_attribute\\n else None,\\n **attr.restrictions.asdict(),\\n )\\n\\n return {\\n key: value\\n for key, value in metadata.items()\\n if value is not None and value is not False\\n }\",\n \"def get_attribute_data(self):\\n ret = {}\\n\\n for attribute in Attribute.objects.all().prefetch_related(\\\"value_choices\\\"):\\n deserialized_value = None\\n\\n if attribute.value_type == Attribute.TYPE_GEOMETRY:\\n geometry = ProjectAttributeMultipolygonGeometry.objects.filter(\\n attribute=attribute, project=self\\n ).first()\\n if not geometry:\\n continue\\n deserialized_value = geometry.geometry\\n elif attribute.value_type in [Attribute.TYPE_IMAGE, Attribute.TYPE_FILE]:\\n try:\\n deserialized_value = ProjectAttributeFile.objects.filter(\\n attribute=attribute, project=self\\n ).order_by(\\\"-created_at\\\").first().file\\n except AttributeError:\\n deserialized_value = None\\n elif attribute.identifier in self.attribute_data:\\n deserialized_value = attribute.deserialize_value(\\n self.attribute_data[attribute.identifier]\\n )\\n\\n ret[attribute.identifier] = deserialized_value\\n return ret\",\n \"def read_attr_type_file():\\n with open(args.attr_type_file_path, 'r') as f:\\n content = f.readlines()\\n\\n # Strip lines of newline/return characters in csv file\\n content = [x.strip(' \\\\t\\\\n\\\\r') for x in content]\\n\\n # Generate dictionary of types and their count\\n attribute_type_dict = {}\\n for item in content:\\n key, value = item.split('|')\\n attribute_type_dict[key.strip()] = value.strip()\\n \\n return attribute_type_dict\",\n \"def __getAttributeInfo(self, atName):\\n cifDataType = self.__dApi.getTypeCode(self.getName(), atName)\\n cifPrimitiveType = self.__dApi.getTypePrimitive(self.getName(), atName)\\n isMandatory = self.__dApi.getMandatoryCode(self.getName(), atName) in [\\\"yes\\\", \\\"implicit\\\", \\\"implicit-ordinal\\\"]\\n dataType = \\\"integer\\\" if \\\"int\\\" in cifDataType else \\\"float\\\" if cifPrimitiveType == \\\"numb\\\" else \\\"string\\\"\\n return dataType, isMandatory\",\n \"def attributeInfo(*args, allAttributes: bool=True, bool: bool=True, enumerated: bool=True,\\n hidden: bool=True, inherited: bool=True, internal: bool=True, leaf: bool=True,\\n logicalAnd: bool=True, multi: bool=True, short: bool=True, userInterface:\\n bool=True, writable: bool=True, type: AnyStr=\\\"\\\", **kwargs)->List[AnyStr]:\\n pass\",\n \"def get_attributes(cls):\\r\\n return [Attribute('size', '20'),\\r\\n Attribute('label', ''), ]\",\n \"def get_attributes(self):\\n\\n endpoint = self._get_api_endpoint() + '/attributes'\\n results = self.tq.get(endpoint, withp='attribute')\\n if 'data' not in results:\\n return {}\\n\\n return results['data']\\n # tr = {}\\n # for attribute in results['data']:\\n # tr[attribute['attribute']['name']] = attribute['value']\\n # return tr\",\n \"def getDict(self):\\n res = {}\\n for attr, value in self.__dict__.iteritems():\\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\\n res[attr] = value\\n elif isinstance(attr, datetime.datetime):\\n res[attr] = value.isoformat('-')\\n \\n return res\",\n \"def to_dict(\\n self, attributes: Sequence[str] = (\\n 'demand_instruments', 'supply_instruments', 'inverse_covariance_matrix',\\n 'expected_xi_by_theta_jacobian', 'expected_omega_by_theta_jacobian', 'expected_prices',\\n 'expected_shares', 'computation_time', 'draws', 'fp_converged', 'fp_iterations',\\n 'contraction_evaluations'\\n )) -> dict:\\n return {k: getattr(self, k) for k in attributes}\",\n \"def category_attributes_types(categories, db_info, connection):\\n attributes = {}\\n for cat in categories:\\n attributes[cat] = {}\\n category_info = api_category_info(cat, db_info, connection)\\n\\n attr = {}\\n for a in category_info.get(\\\"attributes\\\"):\\n for key in a:\\n attr[key] = a[key]\\n\\n attributes[cat][\\\"attributes\\\"] = {k: d for d, k in attr.items()}\\n\\n types = category_info.get(\\\"types\\\")\\n attributes[cat][\\\"types\\\"] = {\\n attr.get(a): types.get(a) for a in types}\\n\\n attributes[cat][\\\"dialogs\\\"] = category_info.get(\\\"dialogs\\\")\\n\\n return attributes\",\n \"def attributes(self):\\n _attrs = [\\\"label\\\"]\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs\",\n \"def attributes(self):\\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }\",\n \"def attributes(self, *args):\\n kwargs = {}\\n if args:\\n kwargs[\\\"attributenames\\\"] = args\\n\\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\\n\\n # parse contennt looking for all attributes\\n attributes = []\\n for line in r.text.splitlines():\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.name)=(.*)\\\", line)\\n if r:\\n name = r.groups()[1]\\n attributes.append([name, None])\\n continue # next line\\n\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.value)=(.*)\\\", line)\\n if r:\\n value = r.groups()[1]\\n # last name parsed is where it has to\\n # be stacked\\n if attributes[-1][1] == None:\\n attributes[-1][1] = value\\n if isinstance(attributes[-1][1], list):\\n attributes[-1][1].append(value)\\n else:\\n # cast to list\\n attributes[-1].append([attributes[-1][1], value])\\n\\n return dict([(item[0], item[1]) for item in attributes])\",\n \"def describe(self):\\r\\n return dict((field.name, dict(\\r\\n id=field.name,\\r\\n name=field.label,\\r\\n validators=ValidatorSerializer(\\r\\n field.requires if isSequenceType(field.requires) else [field.requires])(),\\r\\n comment=field.comment,\\r\\n readable=field.readable,\\r\\n writable=field.writable,\\r\\n type=getattr(field, 'wtype',\\r\\n field.type.type if isinstance(field.type, SQLCustomType) else field.type.split('(')[0]),\\r\\n # w2pwidget=field.widget,\\r\\n )) for field in self.descibe_columns)\",\n \"def attributes(self):\\n return dict(self.__attributes)\",\n \"def get_attributes(obj) -> Dict[str, Tuple[Any, str]]:\\n if is_dataclass(obj):\\n return get_dataclass_attributes(obj)\\n elif inspect.isclass(obj):\\n return get_class_attributes(obj)\\n elif inspect.ismodule(obj):\\n return get_module_attributes(obj)\\n return {}\",\n \"def attribute_to_dict(attr: onnx.AttributeProto) -> Dict:\\n ret = {}\\n for a in attr:\\n value = get_attribute_value(a)\\n if isinstance(value, bytes):\\n value = str(value, 'utf-8')\\n ret[a.name] = value\\n return ret\",\n \"def process_attrs(attrs):\\n if attrs.getLength() == 0:\\n return {}\\n tmp_dict = {}\\n for name in attrs.getNames():\\n tmp_dict[name] = attrs.getValue(name)\\n return tmp_dict\",\n \"def _get_attribute_dict(self, attributes, classname=None):\\n if attributes and isinstance(attributes, six.string_types):\\n return {\\n 'class': attributes\\n }\\n if not attributes:\\n attributes = {}\\n if not classname:\\n classname = self.DEFAULT_CLASS_NAME\\n attributes.setdefault('class', classname)\\n return attributes\",\n \"def attributes(self):\\n _attrs = []\\n if self.name:\\n _attrs.append(\\\"name\\\")\\n if self.label:\\n _attrs.append(\\\"label\\\")\\n if self.confidence:\\n _attrs.append(\\\"confidence\\\")\\n if self.index:\\n _attrs.append(\\\"index\\\")\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs + [\\\"points\\\"]\",\n \"def _parse_attr(self, attr_proto):\\n attrs = {}\\n for a in attr_proto:\\n for f in ['f', 'i', 's']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['floats', 'ints', 'strings']:\\n if list(getattr(a, f)):\\n assert a.name not in attrs, \\\"Only one type of attr is allowed\\\"\\n attrs[a.name] = tuple(getattr(a, f))\\n for f in ['t', 'g']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['tensors', 'graphs']:\\n if list(getattr(a, f)):\\n raise NotImplementedError(\\\"Filed {} is not supported in mxnet.\\\".format(f))\\n if a.name not in attrs:\\n raise ValueError(\\\"Cannot parse attribute: \\\\n{}\\\\n.\\\".format(a))\\n return attrs\",\n \"def attrs_to_dict(self, attrs):\\n return {k: v for k, v in attrs}\",\n \"def ATTRIBUTE():\\n return \\\"author\\\", \\\"title\\\", \\\"publisher\\\", \\\"shelf\\\", \\\"category\\\", \\\"subject\\\"\",\n \"def _get_attrs_symbols():\\n return {\\n 'True', 'False', 'None', # those are identifiers in Python 2.7\\n 'self',\\n 'parent',\\n 'id',\\n 'uid',\\n 'context',\\n 'context_today',\\n 'active_id',\\n 'active_ids',\\n 'allowed_company_ids',\\n 'current_company_id',\\n 'active_model',\\n 'time',\\n 'datetime',\\n 'relativedelta',\\n 'current_date',\\n 'abs',\\n 'len',\\n 'bool',\\n 'float',\\n 'str',\\n 'unicode',\\n }\",\n \"def capability_attributes(self) -> Mapping[str, Any] | None:\\n if state_class := self.state_class:\\n return {ATTR_STATE_CLASS: state_class}\\n\\n if options := self.options:\\n return {ATTR_OPTIONS: options}\\n\\n return None\",\n \"def attributes(self) -> Optional[Mapping[str, Sequence[str]]]:\\n return pulumi.get(self, \\\"attributes\\\")\",\n \"def _describe(self) -> Dict[str, Any]:\",\n \"def get_class_attributes(cls) -> Dict[str, Tuple[Any, str]]:\\n try:\\n source = inspect.getsource(cls.__init__) or \\\"\\\"\\n if not source:\\n return {}\\n except TypeError:\\n return {}\\n source = utils.join(source.split(\\\"\\\\n\\\"))\\n node = ast.parse(source)\\n\\n attr_list: List[Tuple] = []\\n module = importlib.import_module(cls.__module__)\\n globals = dict(inspect.getmembers(module))\\n for x in ast.walk(node):\\n if isinstance(x, _ast.AnnAssign):\\n attr, lineno, type_str = parse_annotation_assign(x)\\n type = eval(type_str, globals)\\n attr_list.append((attr, lineno, type))\\n if isinstance(x, _ast.Attribute) and isinstance(x.ctx, _ast.Store):\\n attr_list.append(parse_attribute_with_lineno(x))\\n attr_list = sorted(attr_list, key=lambda x: x[1])\\n\\n attrs: Dict[str, Tuple[Any, str]] = {}\\n lines = source.split(\\\"\\\\n\\\")\\n for name, lineno, *type in attr_list:\\n if name.startswith(\\\"self.\\\"):\\n name = name[5:]\\n desc = get_description(lines, lineno)\\n if type:\\n attrs[name] = type[0], desc # Assignment with type annotation wins.\\n elif name not in attrs:\\n attrs[name] = None, desc\\n return attrs\",\n \"def state_attributes(self) -> dict[str, StateType]:\\n attributes: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}\\n\\n if self.gps is not None:\\n attributes[ATTR_LATITUDE] = self.gps[0]\\n attributes[ATTR_LONGITUDE] = self.gps[1]\\n attributes[ATTR_GPS_ACCURACY] = self.gps_accuracy\\n\\n if self.battery is not None:\\n attributes[ATTR_BATTERY] = self.battery\\n\\n return attributes\",\n \"def to_dict(self):\\n d = {}\\n i = 0\\n for entry in self.entries:\\n d[i] = {}\\n attributes = self.get_attribute_list()\\n print (attributes)\\n for data in attributes:\\n d[i][data] = entry.__getattribute__(data)\\n i = i + 1\\n return d\",\n \"def device_state_attributes(self):\\n attrs = {}\\n\\n attrs[ATTR_ATTRIBUTION] = ATTRIBUTION\\n attrs[\\\"brand\\\"] = DEFAULT_BRAND\\n attrs[ATTR_CAMERA_TYPE] = self._camera_type\\n attrs[\\\"friendly_name\\\"] = self._name\\n\\n return attrs\",\n \"def types(self) -> Dict[str, str]:\\n return {name: self.hyperparams[name][0] for name in self.names()}\",\n \"def thrift_type_to_dict(obj: Any) -> Dict[str, Any]:\\n return {\\n camel_to_snake_case(attr): getattr(obj, attr)\\n for attr in thrift_attrs(obj)\\n }\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute('size', '20'),\\r\\n Attribute('inline', False),\\r\\n Attribute('label', ''),\\r\\n ]\",\n \"def get_question_name_to_answer_attribute_table(cls):\\n return {\\n value.question_name: attr_name\\n for attr_name, value in cls.__dict__.items()\\n if isinstance(value, answer.BaseAnswer)\\n }\",\n \"def create_descr(self, attr_name):\",\n \"def get_attributes_of_node(core, node):\\n attributes = {}\\n for attribute in core.get_attribute_names(node):\\n attributes[attribute] = core.get_attribute(node,attribute)\\n return attributes\",\n \"def get_attributes(self, shape):\\n attributes = {}\\n identifier_names = [i.name for i in self.identifiers]\\n\\n for name, member in shape.members.items():\\n snake_cased = xform_name(name)\\n if snake_cased in identifier_names:\\n # Skip identifiers, these are set through other means\\n continue\\n snake_cased = self._get_name(\\n 'attribute', snake_cased, snake_case=False\\n )\\n attributes[snake_cased] = (name, member)\\n\\n return attributes\",\n \"def info(self):\\n return (self.kind, self.value)\",\n \"def get_attributes(self):\\n\\t\\treturn dict(list(self.__element.items()))\",\n \"def attributes(self):\\n return {'op_type': self.__class__.__name__, 'arguments': {}}\",\n \"def getAttributeDict(self):\\n result = {}\\n dict = self.getDict()\\n for key in dict.keys():\\n value = dict.get(key)\\n if value.__class__.__name__ != 'SpecialDict':\\n result[key] = value\\n return result\",\n \"def as_dict(self):\\n result = {}\\n for attr in self.__attr:\\n result[attr] = getattr(self, attr)\\n return result\",\n \"def dict_by_attr(collection, attrname, value_attrname=None):\\n mapping = {}\\n for item in collection:\\n if callable(attrname):\\n key = attrname(item)\\n else:\\n key = extended_getattr(item, attrname)\\n if value_attrname:\\n item = extended_getattr(item, value_attrname)\\n mapping[key] = mapping.get(key, []) + [item]\\n return mapping\",\n \"def _process_attrs(attrs):\\n new_attrs = OrderedDict()\\n for attr in attrs:\\n col = attr\\n if isinstance(attr, tuple):\\n col, attr = attr\\n # special cases\\n if attr == 'class_name':\\n attr = '__class__.__name__'\\n if attr == 'repr':\\n attr = repr\\n new_attrs[col] = attr\\n\\n return new_attrs\",\n \"def __get_attr_format (self, attrs):\\r\\n format = { \\r\\n 'editor': None,\\r\\n 'min': None,\\r\\n 'max': None,\\r\\n 'step': None,\\r\\n 'subtype': None,\\r\\n 'flags': None,\\r\\n 'enums': None\\r\\n }\\r\\n\\r\\n for attr in attrs: \\r\\n attr_type = attr[\\\"type\\\"]\\r\\n if \\\"editor\\\" == attr_type:\\r\\n format['editor'] = attr[\\\"value\\\"] \\r\\n if \\\"min\\\" == attr_type:\\r\\n format['min'] = attr[\\\"value\\\"] \\r\\n if \\\"max\\\" == attr_type:\\r\\n format['max'] = attr[\\\"value\\\"] \\r\\n if \\\"default\\\" == attr_type:\\r\\n format['default'] = attr[\\\"value\\\"] \\r\\n if \\\"step\\\" == attr_type:\\r\\n format['step'] = attr[\\\"value\\\"]\\r\\n if \\\"subtype\\\" == attr_type:\\r\\n format['subtype'] = attr[\\\"value\\\"]\\r\\n if \\\"flags\\\" == attr_type:\\r\\n format['flags'] = attr['value']\\r\\n if \\\"enums\\\" == attr_type:\\r\\n format['enums'] = attr['value']\\r\\n\\r\\n return format\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute('height', None),\\r\\n Attribute('width', None),\\r\\n Attribute('parts', None),\\r\\n Attribute('analyses', None),\\r\\n Attribute('initial_value', None),\\r\\n Attribute('submit_analyses', None),\\r\\n Attribute('label', ''),\\r\\n ]\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(map(\\n lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x,\\n value\\n ))\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\") else item,\\n value.items()\\n ))\\n else:\\n result[attr] = value\\n if issubclass(UserAttributeInfo, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def expected_types_and_attributes(self):\\n return {self.configs[\\\"entry_type\\\"]: set()}\",\n \"def attribute_dict(self):\\n return self.__attribute_dict\",\n \"def to_dict(cls):\\n result = {}\\n for attr_name in _.reject(set(dir(cls)), lambda x: x.startswith('_')):\\n attr = getattr(cls, attr_name)\\n if _.is_list(attr) or _.is_string(attr):\\n result[attr_name] = attr\\n return result\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute(\\\"show_correctness\\\", \\\"always\\\"),\\r\\n Attribute(\\\"submitted_message\\\", \\\"Answer received.\\\"),\\r\\n Attribute(\\\"label\\\", \\\"\\\"),\\r\\n ]\",\n \"def as_dict(self):\\n return {c.key: getattr(self, c.key)\\n for c in inspect(self).mapper.column_attrs}\",\n \"def readTypes(self):\\r\\n types = {}\\r\\n for m in re.finditer(\\\"TYPE (.*) = (.*);\\\", self.data):\\r\\n typename, typetype = m.groups() \\r\\n if typetype in self.SIMPLETYPES:\\r\\n types[typename] = typetype\\r\\n else:\\r\\n types[typename] = \\\"#\\\" + typetype\\r\\n \\r\\n return types\",\n \"def GetAttributes(self, type):\\n if type == ArrayAssociation.FIELD:\\n return DataSetAttributes(self.VTKObject.GetFieldData(), self, type)\\n return DataSetAttributes(self.VTKObject.GetAttributes(type), self, type)\",\n \"def _get_var_attrs(var):\\n\\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\\n 'missing_value': -9999, 'height': '',\\n 'standard_name': '', 'group_name': '',\\n 'serial_number': ''}\\n\\n generic_dict.update(attrs_dict[var])\\n return generic_dict\",\n \"def tags_dict(self):\\n return ({'name': 'tag', 'attrs': {'k': k, 'v': v}} for k, v in self.tags.items())\",\n \"def extract_attrs(attr_string):\\n attributes = {}\\n for name, val in FIND_ATTRS.findall(attr_string):\\n val = (\\n val.replace(\\\"<\\\", \\\"<\\\")\\n .replace(\\\">\\\", \\\">\\\")\\n .replace(\\\""\\\", '\\\"')\\n .replace(\\\"&\\\", \\\"&\\\")\\n )\\n attributes[name] = val\\n return attributes\",\n \"def attrs(self):\\n return [name for name in self.traits() if self.trait_metadata(name, \\\"attr\\\")]\",\n \"def attrs(self):\\n return [name for name in self.traits() if self.trait_metadata(name, \\\"attr\\\")]\",\n \"def record_dict(self):\\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}\",\n \"def get_attribute_counts(self):\\n counts = defaultdict(int)\\n for attr in self:\\n counts[attr.name] += 1\\n\\n return dict(counts)\",\n \"def attributes(self):\\n return [self._ELE_ATTR]\",\n \"def parse_attributes(self, attr):\\n result = {}\\n annotations = []\\n # Sanitize and split attributes up\\n split_attr = attr.strip(' \\\\t\\\\n;').split(';')\\n for pair in split_attr:\\n splitpair = pair.split('=')\\n if len(splitpair) != 2:\\n continue\\n if splitpair[0] == \\\"ID\\\":\\n result['identifier'] = splitpair[1]\\n elif splitpair[0] == \\\"Name\\\":\\n result['name'] = splitpair[1]\\n elif splitpair[0] == \\\"Parent\\\":\\n result['parent_id'] = splitpair[1]\\n elif splitpair[0] == \\\"Dbxref\\\" or splitpair[0] == \\\"Ontology_term\\\":\\n annotations.append(splitpair)\\n # Make sure we found an ID\\n if \\\"identifier\\\" not in result:\\n return {}\\n # Add annotations if we found any\\n if annotations:\\n result[\\\"annotations\\\"] = annotations\\n return result\",\n \"def device_state_attributes(self):\\n if self.airly.data_available:\\n if self.type == ATTR_CAQI_DESCRIPTION:\\n self._attrs[ATTR_CAQI_ADVICE] = (self.airly.data\\n [ATTR_CAQI_ADVICE])\\n if self.type == ATTR_CAQI:\\n self._attrs[ATTR_CAQI_LEVEL] = self.airly.data[ATTR_CAQI_LEVEL]\\n if self.type == ATTR_PM25:\\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM25_LIMIT]\\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\\n [ATTR_PM25_PERCENT]))\\n if self.type == ATTR_PM10:\\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM10_LIMIT]\\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\\n [ATTR_PM10_PERCENT]))\\n return self._attrs\",\n \"def whoAreYou(self):\\n tempDict = {}\\n tempDict['Class'] = '{0:15}'.format(self.__class__.__name__) +' from '+' '.join([str(base) for base in self.__class__.__bases__])\\n tempDict['Type' ] = self.type\\n tempDict['Name' ] = self.name\\n return tempDict\",\n \"def values(self):\\n return {n: getattr(self, n) for n in self._hparam_types.keys()}\",\n \"def _metadata_map():\\n return {\\n 'date_added': 'dateAdded',\\n 'dns_active': 'dnsActive',\\n 'last_modified': 'lastModified',\\n 'private_flag': 'privateFlag',\\n 'whois_active': 'whoisActive',\\n 'key_name': 'Key Name',\\n 'value_type': 'Value Type',\\n 'value_name': 'Value Name',\\n 'block': 'Block',\\n 'mutex': 'Mutex',\\n 'as_number': 'AS Number',\\n 'hostname': 'hostName',\\n }\",\n \"def getDataAttributes(self):\\n asRet = [];\\n asAttrs = dir(self);\\n for sAttr in asAttrs:\\n if sAttr[0] == '_' or sAttr[0] == 'k':\\n continue;\\n if sAttr in self.kasInternalAttributes:\\n continue;\\n oValue = getattr(self, sAttr);\\n if callable(oValue):\\n continue;\\n asRet.append(sAttr);\\n return asRet;\",\n \"def get_attributes(self):\\n _attributes = {\\n 'function_id': self.function_id,\\n 'hardware_id': self.hardware_id,\\n 'mode_id': self.mode_id,\\n 'critical_item': self.critical_item,\\n 'description': self.description,\\n 'design_provisions': self.design_provisions,\\n 'detection_method': self.detection_method,\\n 'effect_end': self.effect_end,\\n 'effect_local': self.effect_local,\\n 'effect_next': self.effect_next,\\n 'effect_probability': self.effect_probability,\\n 'hazard_rate_source': self.hazard_rate_source,\\n 'isolation_method': self.isolation_method,\\n 'mission': self.mission,\\n 'mission_phase': self.mission_phase,\\n 'mode_criticality': self.mode_criticality,\\n 'mode_hazard_rate': self.mode_hazard_rate,\\n 'mode_op_time': self.mode_op_time,\\n 'mode_probability': self.mode_probability,\\n 'mode_ratio': self.mode_ratio,\\n 'operator_actions': self.operator_actions,\\n 'other_indications': self.other_indications,\\n 'remarks': self.remarks,\\n 'rpn_severity': self.rpn_severity,\\n 'rpn_severity_new': self.rpn_severity_new,\\n 'severity_class': self.severity_class,\\n 'single_point': self.single_point,\\n 'type_id': self.type_id\\n }\\n\\n return _attributes\",\n \"def as_attrdict(self) -> AttributeDict:\\n return AttributeDict(\\n {\\n x: Configuration(v).as_attrdict() if isinstance(v, Mapping) else v\\n for x, v in self.items(levels=1)\\n }\\n )\",\n \"def getAttributeInfo(self, atName):\\n try:\\n dataType, mandatoryCode = self.__getAttributeInfo(atName)\\n return dataType, mandatoryCode\\n except Exception:\\n return None, None\",\n \"def to_dict(self):\\n dct = dict(zip(self._fields, self))\\n dct['type'] = type(self).__name__\\n return dct\",\n \"def attributes(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"attributes\\\")\",\n \"def keys(self):\\n return list(s.name.lower() for s in self.attributes)\",\n \"def get_attributes(self):\\n _attributes = {\\n 'measurement_id': self.measurement_id,\\n 'code': self.code,\\n 'description': self.description,\\n 'measurement_type': self.measurement_type\\n }\\n\\n return _attributes\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def arm_to_dict(arm: Arm) -> Dict[str, Any]:\\n return {\\n \\\"__type\\\": arm.__class__.__name__,\\n \\\"parameters\\\": arm.parameters,\\n \\\"name\\\": arm._name,\\n }\",\n \"def to_dictionary(self):\\n attributes = [\\\"id\\\", \\\"size\\\", \\\"x\\\", \\\"y\\\"]\\n return {key: getattr(self, key) for key in attributes}\",\n \"def dict_to_label_attr_map(input_dict):\\n return {key+':': [key, type(val)] for key, val in input_dict.items()}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67931277","0.6674969","0.6665792","0.6615514","0.6481953","0.64552104","0.6419755","0.6372921","0.63325536","0.63000596","0.6278388","0.6277224","0.62586933","0.62347186","0.6207894","0.61394423","0.6115364","0.61008304","0.6080403","0.6016657","0.5989625","0.59809417","0.59797674","0.5950794","0.59137654","0.58953065","0.5870135","0.5869189","0.58349276","0.58050656","0.5802968","0.57969046","0.57646376","0.5752503","0.5745853","0.5735608","0.5720549","0.57088107","0.5700824","0.5700529","0.5699166","0.5673668","0.56561637","0.5647824","0.56455743","0.56246185","0.5602673","0.56012","0.5581613","0.55815995","0.55763423","0.5572145","0.5570991","0.55679834","0.55584943","0.5553794","0.55519086","0.5546716","0.5545437","0.554385","0.55400395","0.55398947","0.5535428","0.5522347","0.55187744","0.5510408","0.5503056","0.549645","0.5491176","0.54899526","0.5474596","0.54738015","0.54717964","0.54588765","0.54562217","0.54524374","0.5439527","0.54367363","0.54367363","0.5430862","0.54307","0.5426497","0.54217255","0.54208827","0.54203457","0.5416983","0.5415495","0.54142123","0.5412631","0.540959","0.5409422","0.54093593","0.54069597","0.5398128","0.5391711","0.53765357","0.53765357","0.5370013","0.53658307","0.53606075"],"string":"[\n \"0.67931277\",\n \"0.6674969\",\n \"0.6665792\",\n \"0.6615514\",\n \"0.6481953\",\n \"0.64552104\",\n \"0.6419755\",\n \"0.6372921\",\n \"0.63325536\",\n \"0.63000596\",\n \"0.6278388\",\n \"0.6277224\",\n \"0.62586933\",\n \"0.62347186\",\n \"0.6207894\",\n \"0.61394423\",\n \"0.6115364\",\n \"0.61008304\",\n \"0.6080403\",\n \"0.6016657\",\n \"0.5989625\",\n \"0.59809417\",\n \"0.59797674\",\n \"0.5950794\",\n \"0.59137654\",\n \"0.58953065\",\n \"0.5870135\",\n \"0.5869189\",\n \"0.58349276\",\n \"0.58050656\",\n \"0.5802968\",\n \"0.57969046\",\n \"0.57646376\",\n \"0.5752503\",\n \"0.5745853\",\n \"0.5735608\",\n \"0.5720549\",\n \"0.57088107\",\n \"0.5700824\",\n \"0.5700529\",\n \"0.5699166\",\n \"0.5673668\",\n \"0.56561637\",\n \"0.5647824\",\n \"0.56455743\",\n \"0.56246185\",\n \"0.5602673\",\n \"0.56012\",\n \"0.5581613\",\n \"0.55815995\",\n \"0.55763423\",\n \"0.5572145\",\n \"0.5570991\",\n \"0.55679834\",\n \"0.55584943\",\n \"0.5553794\",\n \"0.55519086\",\n \"0.5546716\",\n \"0.5545437\",\n \"0.554385\",\n \"0.55400395\",\n \"0.55398947\",\n \"0.5535428\",\n \"0.5522347\",\n \"0.55187744\",\n \"0.5510408\",\n \"0.5503056\",\n \"0.549645\",\n \"0.5491176\",\n \"0.54899526\",\n \"0.5474596\",\n \"0.54738015\",\n \"0.54717964\",\n \"0.54588765\",\n \"0.54562217\",\n \"0.54524374\",\n \"0.5439527\",\n \"0.54367363\",\n \"0.54367363\",\n \"0.5430862\",\n \"0.54307\",\n \"0.5426497\",\n \"0.54217255\",\n \"0.54208827\",\n \"0.54203457\",\n \"0.5416983\",\n \"0.5415495\",\n \"0.54142123\",\n \"0.5412631\",\n \"0.540959\",\n \"0.5409422\",\n \"0.54093593\",\n \"0.54069597\",\n \"0.5398128\",\n \"0.5391711\",\n \"0.53765357\",\n \"0.53765357\",\n \"0.5370013\",\n \"0.53658307\",\n \"0.53606075\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5934517"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":76091,"cells":{"query":{"kind":"string","value":"Returns a dictionary that maps attribute name to a tuple of (type, description)."},"document":{"kind":"string","value":"def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:\n fields = cls.__dataclass_fields__.values()\n attrs = {}\n for field in fields:\n if field.type != InitVar:\n attrs[field.name] = field.type, \"\"\n return attrs"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}","def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a","def get_attributes(self) -> Dict[str, str]:\n pass","def map_field_name_to_attribute() -> typing.Dict:\n return {\n \"tag\": \"tag\",\n \"contact\": \"contact\",\n }","def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs","def attributes_metadata(self):\n\n attribute_meta = collections.defaultdict(dict)\n\n for attribute in self.attributes:\n attribute_meta[attribute.name]['valuemap'] = attribute.valuemap\n attribute_meta[attribute.name]['qualifiers'] = attribute.qualifiers\n\n return dict(attribute_meta)","def get_attributes(self):\n \n retdict = {}\n retdict['s'] = str(self.s)\n if self.t != None:\n retdict['t'] = str(self.t)\n retdict['a'] = str(self.a)\n retdict['b'] = str(self.b)\n retdict['c'] = str(self.c)\n retdict['d'] = str(self.d)\n return retdict","def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic","def meta(cls):\n if getattr(cls, '__from_class__', None) is not None:\n cls = cls.__from_class__\n attribute_info = {}\n for name, value in cls.__table__.columns.items():\n attribute_info[name] = str(value.type).lower()\n\n return {cls.__name__: attribute_info}","def attributeType(self) -> unicode:\n ...","def description(self):\n desc = self.title\n ops = []\n for attribute in self.attributes.all():\n value = attribute.value\n if isinstance(value, list):\n ops.append(\n \"%s = '%s'\" % (attribute.type, (\", \".join([str(v) for v in value])))\n )\n else:\n ops.append(\"%s = '%s'\" % (attribute.type, value))\n if ops:\n desc = \"%s (%s)\" % (desc, \", \".join(ops))\n return desc","def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}","def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass","def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_","def get_attrs_dict(self, root_element):\n attr_elements = root_element.findall(\"attribute\")\n attrs_dict = {}\n for el in attr_elements:\n attrs_dict[el.attrib[\"name\"]] = {\n \"value\": el.attrib[\"value\"],\n \"type\": el.attrib.get(\"type\", None)\n }\n return attrs_dict","def to_dict(\n self,\n attributes: Iterable[str] = (\"xyz\", \"viewdir\", \"imgsz\", \"f\", \"c\", \"k\", \"p\"),\n ) -> Dict[str, tuple]:\n return {key: helpers.numpy_to_native(getattr(self, key)) for key in attributes}","def dict(self) -> dict():\n\n dict_reg_hive = {}\n\n for _attribute in self.attributes.__dict__.items():\n if isinstance(_attribute[1], str):\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\n _attribute_value = getattr(self, _attribute[1])\n dict_reg_hive.update({_attribute[1]: _attribute_value})\n\n return dict_reg_hive","def get_attrib_dict(self, attribs: Tuple[str]) -> Dict[str, str]:\n attrs = self.get_attribs(attribs)\n attrs = tuple(map(lambda a: (a[0][1:], a[1]), attrs))\n return dict(attrs)","def attribute_metadata(attr: Attr, parent_namespace: Optional[str]) -> Dict:\n metadata = dict(\n name=None\n if attr.is_nameless or attr.local_name == attribute_name(attr.name)\n else attr.local_name,\n type=attr.xml_type,\n namespace=attr.namespace\n if parent_namespace != attr.namespace or attr.is_attribute\n else None,\n **attr.restrictions.asdict(),\n )\n\n return {\n key: value\n for key, value in metadata.items()\n if value is not None and value is not False\n }","def get_attribute_data(self):\n ret = {}\n\n for attribute in Attribute.objects.all().prefetch_related(\"value_choices\"):\n deserialized_value = None\n\n if attribute.value_type == Attribute.TYPE_GEOMETRY:\n geometry = ProjectAttributeMultipolygonGeometry.objects.filter(\n attribute=attribute, project=self\n ).first()\n if not geometry:\n continue\n deserialized_value = geometry.geometry\n elif attribute.value_type in [Attribute.TYPE_IMAGE, Attribute.TYPE_FILE]:\n try:\n deserialized_value = ProjectAttributeFile.objects.filter(\n attribute=attribute, project=self\n ).order_by(\"-created_at\").first().file\n except AttributeError:\n deserialized_value = None\n elif attribute.identifier in self.attribute_data:\n deserialized_value = attribute.deserialize_value(\n self.attribute_data[attribute.identifier]\n )\n\n ret[attribute.identifier] = deserialized_value\n return ret","def read_attr_type_file():\n with open(args.attr_type_file_path, 'r') as f:\n content = f.readlines()\n\n # Strip lines of newline/return characters in csv file\n content = [x.strip(' \\t\\n\\r') for x in content]\n\n # Generate dictionary of types and their count\n attribute_type_dict = {}\n for item in content:\n key, value = item.split('|')\n attribute_type_dict[key.strip()] = value.strip()\n \n return attribute_type_dict","def __getAttributeInfo(self, atName):\n cifDataType = self.__dApi.getTypeCode(self.getName(), atName)\n cifPrimitiveType = self.__dApi.getTypePrimitive(self.getName(), atName)\n isMandatory = self.__dApi.getMandatoryCode(self.getName(), atName) in [\"yes\", \"implicit\", \"implicit-ordinal\"]\n dataType = \"integer\" if \"int\" in cifDataType else \"float\" if cifPrimitiveType == \"numb\" else \"string\"\n return dataType, isMandatory","def attributeInfo(*args, allAttributes: bool=True, bool: bool=True, enumerated: bool=True,\n hidden: bool=True, inherited: bool=True, internal: bool=True, leaf: bool=True,\n logicalAnd: bool=True, multi: bool=True, short: bool=True, userInterface:\n bool=True, writable: bool=True, type: AnyStr=\"\", **kwargs)->List[AnyStr]:\n pass","def get_module_attributes(module) -> Dict[str, Tuple[Any, str]]:\n try:\n source = inspect.getsource(module) or \"\"\n if not source:\n return {}\n except (OSError, TypeError):\n return {}\n node = ast.parse(source)\n\n attr_list: List[Tuple] = []\n globals = dict(inspect.getmembers(module))\n for x in ast.iter_child_nodes(node):\n if isinstance(x, _ast.AnnAssign):\n attr, lineno, type_str = parse_annotation_assign(x)\n type = eval(type_str, globals)\n attr_list.append((attr, lineno, type))\n if isinstance(x, _ast.Assign):\n attr_list.append(parse_attribute_with_lineno(x))\n attr_list = sorted(attr_list, key=lambda x: x[1])\n\n attrs: Dict[str, Tuple[Any, str]] = {}\n lines = source.split(\"\\n\")\n for name, lineno, *type in attr_list:\n desc = get_description(lines, lineno)\n if type:\n attrs[name] = type[0], desc # Assignment with type annotation wins.\n elif name not in attrs:\n attrs[name] = None, desc\n return attrs","def get_attributes(cls):\r\n return [Attribute('size', '20'),\r\n Attribute('label', ''), ]","def get_attributes(self):\n\n endpoint = self._get_api_endpoint() + '/attributes'\n results = self.tq.get(endpoint, withp='attribute')\n if 'data' not in results:\n return {}\n\n return results['data']\n # tr = {}\n # for attribute in results['data']:\n # tr[attribute['attribute']['name']] = attribute['value']\n # return tr","def to_dict(\n self, attributes: Sequence[str] = (\n 'demand_instruments', 'supply_instruments', 'inverse_covariance_matrix',\n 'expected_xi_by_theta_jacobian', 'expected_omega_by_theta_jacobian', 'expected_prices',\n 'expected_shares', 'computation_time', 'draws', 'fp_converged', 'fp_iterations',\n 'contraction_evaluations'\n )) -> dict:\n return {k: getattr(self, k) for k in attributes}","def getDict(self):\n res = {}\n for attr, value in self.__dict__.iteritems():\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\n res[attr] = value\n elif isinstance(attr, datetime.datetime):\n res[attr] = value.isoformat('-')\n \n return res","def category_attributes_types(categories, db_info, connection):\n attributes = {}\n for cat in categories:\n attributes[cat] = {}\n category_info = api_category_info(cat, db_info, connection)\n\n attr = {}\n for a in category_info.get(\"attributes\"):\n for key in a:\n attr[key] = a[key]\n\n attributes[cat][\"attributes\"] = {k: d for d, k in attr.items()}\n\n types = category_info.get(\"types\")\n attributes[cat][\"types\"] = {\n attr.get(a): types.get(a) for a in types}\n\n attributes[cat][\"dialogs\"] = category_info.get(\"dialogs\")\n\n return attributes","def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs","def attributes(self):\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }","def attributes(self, *args):\n kwargs = {}\n if args:\n kwargs[\"attributenames\"] = args\n\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\n\n # parse contennt looking for all attributes\n attributes = []\n for line in r.text.splitlines():\n r = re.match(\"(userdetails\\.attribute\\.name)=(.*)\", line)\n if r:\n name = r.groups()[1]\n attributes.append([name, None])\n continue # next line\n\n r = re.match(\"(userdetails\\.attribute\\.value)=(.*)\", line)\n if r:\n value = r.groups()[1]\n # last name parsed is where it has to\n # be stacked\n if attributes[-1][1] == None:\n attributes[-1][1] = value\n if isinstance(attributes[-1][1], list):\n attributes[-1][1].append(value)\n else:\n # cast to list\n attributes[-1].append([attributes[-1][1], value])\n\n return dict([(item[0], item[1]) for item in attributes])","def describe(self):\r\n return dict((field.name, dict(\r\n id=field.name,\r\n name=field.label,\r\n validators=ValidatorSerializer(\r\n field.requires if isSequenceType(field.requires) else [field.requires])(),\r\n comment=field.comment,\r\n readable=field.readable,\r\n writable=field.writable,\r\n type=getattr(field, 'wtype',\r\n field.type.type if isinstance(field.type, SQLCustomType) else field.type.split('(')[0]),\r\n # w2pwidget=field.widget,\r\n )) for field in self.descibe_columns)","def attributes(self):\n return dict(self.__attributes)","def get_attributes(obj) -> Dict[str, Tuple[Any, str]]:\n if is_dataclass(obj):\n return get_dataclass_attributes(obj)\n elif inspect.isclass(obj):\n return get_class_attributes(obj)\n elif inspect.ismodule(obj):\n return get_module_attributes(obj)\n return {}","def attribute_to_dict(attr: onnx.AttributeProto) -> Dict:\n ret = {}\n for a in attr:\n value = get_attribute_value(a)\n if isinstance(value, bytes):\n value = str(value, 'utf-8')\n ret[a.name] = value\n return ret","def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict","def _get_attribute_dict(self, attributes, classname=None):\n if attributes and isinstance(attributes, six.string_types):\n return {\n 'class': attributes\n }\n if not attributes:\n attributes = {}\n if not classname:\n classname = self.DEFAULT_CLASS_NAME\n attributes.setdefault('class', classname)\n return attributes","def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs","def attributes(self):\n _attrs = []\n if self.name:\n _attrs.append(\"name\")\n if self.label:\n _attrs.append(\"label\")\n if self.confidence:\n _attrs.append(\"confidence\")\n if self.index:\n _attrs.append(\"index\")\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs + [\"points\"]","def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}","def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"","def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }","def capability_attributes(self) -> Mapping[str, Any] | None:\n if state_class := self.state_class:\n return {ATTR_STATE_CLASS: state_class}\n\n if options := self.options:\n return {ATTR_OPTIONS: options}\n\n return None","def attributes(self) -> Optional[Mapping[str, Sequence[str]]]:\n return pulumi.get(self, \"attributes\")","def _describe(self) -> Dict[str, Any]:","def get_class_attributes(cls) -> Dict[str, Tuple[Any, str]]:\n try:\n source = inspect.getsource(cls.__init__) or \"\"\n if not source:\n return {}\n except TypeError:\n return {}\n source = utils.join(source.split(\"\\n\"))\n node = ast.parse(source)\n\n attr_list: List[Tuple] = []\n module = importlib.import_module(cls.__module__)\n globals = dict(inspect.getmembers(module))\n for x in ast.walk(node):\n if isinstance(x, _ast.AnnAssign):\n attr, lineno, type_str = parse_annotation_assign(x)\n type = eval(type_str, globals)\n attr_list.append((attr, lineno, type))\n if isinstance(x, _ast.Attribute) and isinstance(x.ctx, _ast.Store):\n attr_list.append(parse_attribute_with_lineno(x))\n attr_list = sorted(attr_list, key=lambda x: x[1])\n\n attrs: Dict[str, Tuple[Any, str]] = {}\n lines = source.split(\"\\n\")\n for name, lineno, *type in attr_list:\n if name.startswith(\"self.\"):\n name = name[5:]\n desc = get_description(lines, lineno)\n if type:\n attrs[name] = type[0], desc # Assignment with type annotation wins.\n elif name not in attrs:\n attrs[name] = None, desc\n return attrs","def state_attributes(self) -> dict[str, StateType]:\n attributes: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}\n\n if self.gps is not None:\n attributes[ATTR_LATITUDE] = self.gps[0]\n attributes[ATTR_LONGITUDE] = self.gps[1]\n attributes[ATTR_GPS_ACCURACY] = self.gps_accuracy\n\n if self.battery is not None:\n attributes[ATTR_BATTERY] = self.battery\n\n return attributes","def to_dict(self):\n d = {}\n i = 0\n for entry in self.entries:\n d[i] = {}\n attributes = self.get_attribute_list()\n print (attributes)\n for data in attributes:\n d[i][data] = entry.__getattribute__(data)\n i = i + 1\n return d","def device_state_attributes(self):\n attrs = {}\n\n attrs[ATTR_ATTRIBUTION] = ATTRIBUTION\n attrs[\"brand\"] = DEFAULT_BRAND\n attrs[ATTR_CAMERA_TYPE] = self._camera_type\n attrs[\"friendly_name\"] = self._name\n\n return attrs","def types(self) -> Dict[str, str]:\n return {name: self.hyperparams[name][0] for name in self.names()}","def thrift_type_to_dict(obj: Any) -> Dict[str, Any]:\n return {\n camel_to_snake_case(attr): getattr(obj, attr)\n for attr in thrift_attrs(obj)\n }","def get_attributes(cls):\r\n return [\r\n Attribute('size', '20'),\r\n Attribute('inline', False),\r\n Attribute('label', ''),\r\n ]","def get_question_name_to_answer_attribute_table(cls):\n return {\n value.question_name: attr_name\n for attr_name, value in cls.__dict__.items()\n if isinstance(value, answer.BaseAnswer)\n }","def create_descr(self, attr_name):","def get_attributes_of_node(core, node):\n attributes = {}\n for attribute in core.get_attribute_names(node):\n attributes[attribute] = core.get_attribute(node,attribute)\n return attributes","def get_attributes(self, shape):\n attributes = {}\n identifier_names = [i.name for i in self.identifiers]\n\n for name, member in shape.members.items():\n snake_cased = xform_name(name)\n if snake_cased in identifier_names:\n # Skip identifiers, these are set through other means\n continue\n snake_cased = self._get_name(\n 'attribute', snake_cased, snake_case=False\n )\n attributes[snake_cased] = (name, member)\n\n return attributes","def info(self):\n return (self.kind, self.value)","def get_attributes(self):\n\t\treturn dict(list(self.__element.items()))","def attributes(self):\n return {'op_type': self.__class__.__name__, 'arguments': {}}","def getAttributeDict(self):\n result = {}\n dict = self.getDict()\n for key in dict.keys():\n value = dict.get(key)\n if value.__class__.__name__ != 'SpecialDict':\n result[key] = value\n return result","def as_dict(self):\n result = {}\n for attr in self.__attr:\n result[attr] = getattr(self, attr)\n return result","def dict_by_attr(collection, attrname, value_attrname=None):\n mapping = {}\n for item in collection:\n if callable(attrname):\n key = attrname(item)\n else:\n key = extended_getattr(item, attrname)\n if value_attrname:\n item = extended_getattr(item, value_attrname)\n mapping[key] = mapping.get(key, []) + [item]\n return mapping","def _process_attrs(attrs):\n new_attrs = OrderedDict()\n for attr in attrs:\n col = attr\n if isinstance(attr, tuple):\n col, attr = attr\n # special cases\n if attr == 'class_name':\n attr = '__class__.__name__'\n if attr == 'repr':\n attr = repr\n new_attrs[col] = attr\n\n return new_attrs","def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format","def get_attributes(cls):\r\n return [\r\n Attribute('height', None),\r\n Attribute('width', None),\r\n Attribute('parts', None),\r\n Attribute('analyses', None),\r\n Attribute('initial_value', None),\r\n Attribute('submit_analyses', None),\r\n Attribute('label', ''),\r\n ]","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n if issubclass(UserAttributeInfo, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def expected_types_and_attributes(self):\n return {self.configs[\"entry_type\"]: set()}","def attribute_dict(self):\n return self.__attribute_dict","def to_dict(cls):\n result = {}\n for attr_name in _.reject(set(dir(cls)), lambda x: x.startswith('_')):\n attr = getattr(cls, attr_name)\n if _.is_list(attr) or _.is_string(attr):\n result[attr_name] = attr\n return result","def get_attributes(cls):\r\n return [\r\n Attribute(\"show_correctness\", \"always\"),\r\n Attribute(\"submitted_message\", \"Answer received.\"),\r\n Attribute(\"label\", \"\"),\r\n ]","def as_dict(self):\n return {c.key: getattr(self, c.key)\n for c in inspect(self).mapper.column_attrs}","def readTypes(self):\r\n types = {}\r\n for m in re.finditer(\"TYPE (.*) = (.*);\", self.data):\r\n typename, typetype = m.groups() \r\n if typetype in self.SIMPLETYPES:\r\n types[typename] = typetype\r\n else:\r\n types[typename] = \"#\" + typetype\r\n \r\n return types","def GetAttributes(self, type):\n if type == ArrayAssociation.FIELD:\n return DataSetAttributes(self.VTKObject.GetFieldData(), self, type)\n return DataSetAttributes(self.VTKObject.GetAttributes(type), self, type)","def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict","def tags_dict(self):\n return ({'name': 'tag', 'attrs': {'k': k, 'v': v}} for k, v in self.tags.items())","def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes","def attrs(self):\n return [name for name in self.traits() if self.trait_metadata(name, \"attr\")]","def attrs(self):\n return [name for name in self.traits() if self.trait_metadata(name, \"attr\")]","def get_attribute_counts(self):\n counts = defaultdict(int)\n for attr in self:\n counts[attr.name] += 1\n\n return dict(counts)","def record_dict(self):\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}","def attributes(self):\n return [self._ELE_ATTR]","def parse_attributes(self, attr):\n result = {}\n annotations = []\n # Sanitize and split attributes up\n split_attr = attr.strip(' \\t\\n;').split(';')\n for pair in split_attr:\n splitpair = pair.split('=')\n if len(splitpair) != 2:\n continue\n if splitpair[0] == \"ID\":\n result['identifier'] = splitpair[1]\n elif splitpair[0] == \"Name\":\n result['name'] = splitpair[1]\n elif splitpair[0] == \"Parent\":\n result['parent_id'] = splitpair[1]\n elif splitpair[0] == \"Dbxref\" or splitpair[0] == \"Ontology_term\":\n annotations.append(splitpair)\n # Make sure we found an ID\n if \"identifier\" not in result:\n return {}\n # Add annotations if we found any\n if annotations:\n result[\"annotations\"] = annotations\n return result","def device_state_attributes(self):\n if self.airly.data_available:\n if self.type == ATTR_CAQI_DESCRIPTION:\n self._attrs[ATTR_CAQI_ADVICE] = (self.airly.data\n [ATTR_CAQI_ADVICE])\n if self.type == ATTR_CAQI:\n self._attrs[ATTR_CAQI_LEVEL] = self.airly.data[ATTR_CAQI_LEVEL]\n if self.type == ATTR_PM25:\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM25_LIMIT]\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\n [ATTR_PM25_PERCENT]))\n if self.type == ATTR_PM10:\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM10_LIMIT]\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\n [ATTR_PM10_PERCENT]))\n return self._attrs","def whoAreYou(self):\n tempDict = {}\n tempDict['Class'] = '{0:15}'.format(self.__class__.__name__) +' from '+' '.join([str(base) for base in self.__class__.__bases__])\n tempDict['Type' ] = self.type\n tempDict['Name' ] = self.name\n return tempDict","def values(self):\n return {n: getattr(self, n) for n in self._hparam_types.keys()}","def _metadata_map():\n return {\n 'date_added': 'dateAdded',\n 'dns_active': 'dnsActive',\n 'last_modified': 'lastModified',\n 'private_flag': 'privateFlag',\n 'whois_active': 'whoisActive',\n 'key_name': 'Key Name',\n 'value_type': 'Value Type',\n 'value_name': 'Value Name',\n 'block': 'Block',\n 'mutex': 'Mutex',\n 'as_number': 'AS Number',\n 'hostname': 'hostName',\n }","def getDataAttributes(self):\n asRet = [];\n asAttrs = dir(self);\n for sAttr in asAttrs:\n if sAttr[0] == '_' or sAttr[0] == 'k':\n continue;\n if sAttr in self.kasInternalAttributes:\n continue;\n oValue = getattr(self, sAttr);\n if callable(oValue):\n continue;\n asRet.append(sAttr);\n return asRet;","def get_attributes(self):\n _attributes = {\n 'function_id': self.function_id,\n 'hardware_id': self.hardware_id,\n 'mode_id': self.mode_id,\n 'critical_item': self.critical_item,\n 'description': self.description,\n 'design_provisions': self.design_provisions,\n 'detection_method': self.detection_method,\n 'effect_end': self.effect_end,\n 'effect_local': self.effect_local,\n 'effect_next': self.effect_next,\n 'effect_probability': self.effect_probability,\n 'hazard_rate_source': self.hazard_rate_source,\n 'isolation_method': self.isolation_method,\n 'mission': self.mission,\n 'mission_phase': self.mission_phase,\n 'mode_criticality': self.mode_criticality,\n 'mode_hazard_rate': self.mode_hazard_rate,\n 'mode_op_time': self.mode_op_time,\n 'mode_probability': self.mode_probability,\n 'mode_ratio': self.mode_ratio,\n 'operator_actions': self.operator_actions,\n 'other_indications': self.other_indications,\n 'remarks': self.remarks,\n 'rpn_severity': self.rpn_severity,\n 'rpn_severity_new': self.rpn_severity_new,\n 'severity_class': self.severity_class,\n 'single_point': self.single_point,\n 'type_id': self.type_id\n }\n\n return _attributes","def getAttributeInfo(self, atName):\n try:\n dataType, mandatoryCode = self.__getAttributeInfo(atName)\n return dataType, mandatoryCode\n except Exception:\n return None, None","def as_attrdict(self) -> AttributeDict:\n return AttributeDict(\n {\n x: Configuration(v).as_attrdict() if isinstance(v, Mapping) else v\n for x, v in self.items(levels=1)\n }\n )","def to_dict(self):\n dct = dict(zip(self._fields, self))\n dct['type'] = type(self).__name__\n return dct","def attributes(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\n return pulumi.get(self, \"attributes\")","def keys(self):\n return list(s.name.lower() for s in self.attributes)","def get_attributes(self):\n _attributes = {\n 'measurement_id': self.measurement_id,\n 'code': self.code,\n 'description': self.description,\n 'measurement_type': self.measurement_type\n }\n\n return _attributes","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def arm_to_dict(arm: Arm) -> Dict[str, Any]:\n return {\n \"__type\": arm.__class__.__name__,\n \"parameters\": arm.parameters,\n \"name\": arm._name,\n }","def to_dictionary(self):\n attributes = [\"id\", \"size\", \"x\", \"y\"]\n return {key: getattr(self, key) for key in attributes}","def dict_to_label_attr_map(input_dict):\n return {key+':': [key, type(val)] for key, val in input_dict.items()}"],"string":"[\n \"def _attrs_map(self) -> \\\"dict[int, str]\\\":\\n return {i: attr.name for i, attr in enumerate(self._attrs())}\",\n \"def _attribs(self, name=None, description=None):\\n a = {}\\n if name:\\n a['name'] = name\\n if description:\\n a['description'] = description\\n return a\",\n \"def get_attributes(self) -> Dict[str, str]:\\n pass\",\n \"def map_field_name_to_attribute() -> typing.Dict:\\n return {\\n \\\"tag\\\": \\\"tag\\\",\\n \\\"contact\\\": \\\"contact\\\",\\n }\",\n \"def attributes(self):\\n _attrs = [\\\"type\\\", \\\"name\\\", \\\"value\\\"]\\n if self.confidence is not None:\\n _attrs.append(\\\"confidence\\\")\\n if self.constant:\\n _attrs.append(\\\"constant\\\")\\n if self.tags:\\n _attrs.append(\\\"tags\\\")\\n\\n return _attrs\",\n \"def attributes_metadata(self):\\n\\n attribute_meta = collections.defaultdict(dict)\\n\\n for attribute in self.attributes:\\n attribute_meta[attribute.name]['valuemap'] = attribute.valuemap\\n attribute_meta[attribute.name]['qualifiers'] = attribute.qualifiers\\n\\n return dict(attribute_meta)\",\n \"def get_attributes(self):\\n \\n retdict = {}\\n retdict['s'] = str(self.s)\\n if self.t != None:\\n retdict['t'] = str(self.t)\\n retdict['a'] = str(self.a)\\n retdict['b'] = str(self.b)\\n retdict['c'] = str(self.c)\\n retdict['d'] = str(self.d)\\n return retdict\",\n \"def _get_attribute_dic(self, attrs):\\n attr_dic = {}\\n for attr_pair in attrs:\\n attr_dic[attr_pair[0]] = attr_pair[1]\\n return attr_dic\",\n \"def meta(cls):\\n if getattr(cls, '__from_class__', None) is not None:\\n cls = cls.__from_class__\\n attribute_info = {}\\n for name, value in cls.__table__.columns.items():\\n attribute_info[name] = str(value.type).lower()\\n\\n return {cls.__name__: attribute_info}\",\n \"def attributeType(self) -> unicode:\\n ...\",\n \"def description(self):\\n desc = self.title\\n ops = []\\n for attribute in self.attributes.all():\\n value = attribute.value\\n if isinstance(value, list):\\n ops.append(\\n \\\"%s = '%s'\\\" % (attribute.type, (\\\", \\\".join([str(v) for v in value])))\\n )\\n else:\\n ops.append(\\\"%s = '%s'\\\" % (attribute.type, value))\\n if ops:\\n desc = \\\"%s (%s)\\\" % (desc, \\\", \\\".join(ops))\\n return desc\",\n \"def getAttributeInfoDictionary(attr, format=None):\\n format = format or _getDocFormat(attr)\\n return {'name': attr.getName(),\\n 'doc': renderText(attr.getDoc() or '', format=format)}\",\n \"def proc_attr(inp):\\n dic = {}\\n for att in inp.attrs.keys():\\n if getattr(inp.attrs[att], \\\"dtype\\\", None) is None:\\n dic[att] = inp.attrs[att]\\n elif inp.attrs[att].dtype.char == 'S':\\n dic[att] = [\\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\\n ]\\n else:\\n dic[att] = (\\n inp.attrs[att][0]\\n if isinstance(inp.attrs[att],np.ndarray) and\\n inp.attrs[att].size==1\\n else inp.attrs[att]\\n )\\n return dic\\n pass\",\n \"def attributes(self):\\n attrs_ = [\\\"name\\\", \\\"type\\\"]\\n if self.exclusive:\\n attrs_.append(\\\"exclusive\\\")\\n if self.default is not None:\\n attrs_.append(\\\"default\\\")\\n\\n return attrs_\",\n \"def get_attrs_dict(self, root_element):\\n attr_elements = root_element.findall(\\\"attribute\\\")\\n attrs_dict = {}\\n for el in attr_elements:\\n attrs_dict[el.attrib[\\\"name\\\"]] = {\\n \\\"value\\\": el.attrib[\\\"value\\\"],\\n \\\"type\\\": el.attrib.get(\\\"type\\\", None)\\n }\\n return attrs_dict\",\n \"def to_dict(\\n self,\\n attributes: Iterable[str] = (\\\"xyz\\\", \\\"viewdir\\\", \\\"imgsz\\\", \\\"f\\\", \\\"c\\\", \\\"k\\\", \\\"p\\\"),\\n ) -> Dict[str, tuple]:\\n return {key: helpers.numpy_to_native(getattr(self, key)) for key in attributes}\",\n \"def dict(self) -> dict():\\n\\n dict_reg_hive = {}\\n\\n for _attribute in self.attributes.__dict__.items():\\n if isinstance(_attribute[1], str):\\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\\n _attribute_value = getattr(self, _attribute[1])\\n dict_reg_hive.update({_attribute[1]: _attribute_value})\\n\\n return dict_reg_hive\",\n \"def get_attrib_dict(self, attribs: Tuple[str]) -> Dict[str, str]:\\n attrs = self.get_attribs(attribs)\\n attrs = tuple(map(lambda a: (a[0][1:], a[1]), attrs))\\n return dict(attrs)\",\n \"def attribute_metadata(attr: Attr, parent_namespace: Optional[str]) -> Dict:\\n metadata = dict(\\n name=None\\n if attr.is_nameless or attr.local_name == attribute_name(attr.name)\\n else attr.local_name,\\n type=attr.xml_type,\\n namespace=attr.namespace\\n if parent_namespace != attr.namespace or attr.is_attribute\\n else None,\\n **attr.restrictions.asdict(),\\n )\\n\\n return {\\n key: value\\n for key, value in metadata.items()\\n if value is not None and value is not False\\n }\",\n \"def get_attribute_data(self):\\n ret = {}\\n\\n for attribute in Attribute.objects.all().prefetch_related(\\\"value_choices\\\"):\\n deserialized_value = None\\n\\n if attribute.value_type == Attribute.TYPE_GEOMETRY:\\n geometry = ProjectAttributeMultipolygonGeometry.objects.filter(\\n attribute=attribute, project=self\\n ).first()\\n if not geometry:\\n continue\\n deserialized_value = geometry.geometry\\n elif attribute.value_type in [Attribute.TYPE_IMAGE, Attribute.TYPE_FILE]:\\n try:\\n deserialized_value = ProjectAttributeFile.objects.filter(\\n attribute=attribute, project=self\\n ).order_by(\\\"-created_at\\\").first().file\\n except AttributeError:\\n deserialized_value = None\\n elif attribute.identifier in self.attribute_data:\\n deserialized_value = attribute.deserialize_value(\\n self.attribute_data[attribute.identifier]\\n )\\n\\n ret[attribute.identifier] = deserialized_value\\n return ret\",\n \"def read_attr_type_file():\\n with open(args.attr_type_file_path, 'r') as f:\\n content = f.readlines()\\n\\n # Strip lines of newline/return characters in csv file\\n content = [x.strip(' \\\\t\\\\n\\\\r') for x in content]\\n\\n # Generate dictionary of types and their count\\n attribute_type_dict = {}\\n for item in content:\\n key, value = item.split('|')\\n attribute_type_dict[key.strip()] = value.strip()\\n \\n return attribute_type_dict\",\n \"def __getAttributeInfo(self, atName):\\n cifDataType = self.__dApi.getTypeCode(self.getName(), atName)\\n cifPrimitiveType = self.__dApi.getTypePrimitive(self.getName(), atName)\\n isMandatory = self.__dApi.getMandatoryCode(self.getName(), atName) in [\\\"yes\\\", \\\"implicit\\\", \\\"implicit-ordinal\\\"]\\n dataType = \\\"integer\\\" if \\\"int\\\" in cifDataType else \\\"float\\\" if cifPrimitiveType == \\\"numb\\\" else \\\"string\\\"\\n return dataType, isMandatory\",\n \"def attributeInfo(*args, allAttributes: bool=True, bool: bool=True, enumerated: bool=True,\\n hidden: bool=True, inherited: bool=True, internal: bool=True, leaf: bool=True,\\n logicalAnd: bool=True, multi: bool=True, short: bool=True, userInterface:\\n bool=True, writable: bool=True, type: AnyStr=\\\"\\\", **kwargs)->List[AnyStr]:\\n pass\",\n \"def get_module_attributes(module) -> Dict[str, Tuple[Any, str]]:\\n try:\\n source = inspect.getsource(module) or \\\"\\\"\\n if not source:\\n return {}\\n except (OSError, TypeError):\\n return {}\\n node = ast.parse(source)\\n\\n attr_list: List[Tuple] = []\\n globals = dict(inspect.getmembers(module))\\n for x in ast.iter_child_nodes(node):\\n if isinstance(x, _ast.AnnAssign):\\n attr, lineno, type_str = parse_annotation_assign(x)\\n type = eval(type_str, globals)\\n attr_list.append((attr, lineno, type))\\n if isinstance(x, _ast.Assign):\\n attr_list.append(parse_attribute_with_lineno(x))\\n attr_list = sorted(attr_list, key=lambda x: x[1])\\n\\n attrs: Dict[str, Tuple[Any, str]] = {}\\n lines = source.split(\\\"\\\\n\\\")\\n for name, lineno, *type in attr_list:\\n desc = get_description(lines, lineno)\\n if type:\\n attrs[name] = type[0], desc # Assignment with type annotation wins.\\n elif name not in attrs:\\n attrs[name] = None, desc\\n return attrs\",\n \"def get_attributes(cls):\\r\\n return [Attribute('size', '20'),\\r\\n Attribute('label', ''), ]\",\n \"def get_attributes(self):\\n\\n endpoint = self._get_api_endpoint() + '/attributes'\\n results = self.tq.get(endpoint, withp='attribute')\\n if 'data' not in results:\\n return {}\\n\\n return results['data']\\n # tr = {}\\n # for attribute in results['data']:\\n # tr[attribute['attribute']['name']] = attribute['value']\\n # return tr\",\n \"def to_dict(\\n self, attributes: Sequence[str] = (\\n 'demand_instruments', 'supply_instruments', 'inverse_covariance_matrix',\\n 'expected_xi_by_theta_jacobian', 'expected_omega_by_theta_jacobian', 'expected_prices',\\n 'expected_shares', 'computation_time', 'draws', 'fp_converged', 'fp_iterations',\\n 'contraction_evaluations'\\n )) -> dict:\\n return {k: getattr(self, k) for k in attributes}\",\n \"def getDict(self):\\n res = {}\\n for attr, value in self.__dict__.iteritems():\\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\\n res[attr] = value\\n elif isinstance(attr, datetime.datetime):\\n res[attr] = value.isoformat('-')\\n \\n return res\",\n \"def category_attributes_types(categories, db_info, connection):\\n attributes = {}\\n for cat in categories:\\n attributes[cat] = {}\\n category_info = api_category_info(cat, db_info, connection)\\n\\n attr = {}\\n for a in category_info.get(\\\"attributes\\\"):\\n for key in a:\\n attr[key] = a[key]\\n\\n attributes[cat][\\\"attributes\\\"] = {k: d for d, k in attr.items()}\\n\\n types = category_info.get(\\\"types\\\")\\n attributes[cat][\\\"types\\\"] = {\\n attr.get(a): types.get(a) for a in types}\\n\\n attributes[cat][\\\"dialogs\\\"] = category_info.get(\\\"dialogs\\\")\\n\\n return attributes\",\n \"def attributes(self):\\n _attrs = [\\\"label\\\"]\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs\",\n \"def attributes(self):\\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }\",\n \"def attributes(self, *args):\\n kwargs = {}\\n if args:\\n kwargs[\\\"attributenames\\\"] = args\\n\\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\\n\\n # parse contennt looking for all attributes\\n attributes = []\\n for line in r.text.splitlines():\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.name)=(.*)\\\", line)\\n if r:\\n name = r.groups()[1]\\n attributes.append([name, None])\\n continue # next line\\n\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.value)=(.*)\\\", line)\\n if r:\\n value = r.groups()[1]\\n # last name parsed is where it has to\\n # be stacked\\n if attributes[-1][1] == None:\\n attributes[-1][1] = value\\n if isinstance(attributes[-1][1], list):\\n attributes[-1][1].append(value)\\n else:\\n # cast to list\\n attributes[-1].append([attributes[-1][1], value])\\n\\n return dict([(item[0], item[1]) for item in attributes])\",\n \"def describe(self):\\r\\n return dict((field.name, dict(\\r\\n id=field.name,\\r\\n name=field.label,\\r\\n validators=ValidatorSerializer(\\r\\n field.requires if isSequenceType(field.requires) else [field.requires])(),\\r\\n comment=field.comment,\\r\\n readable=field.readable,\\r\\n writable=field.writable,\\r\\n type=getattr(field, 'wtype',\\r\\n field.type.type if isinstance(field.type, SQLCustomType) else field.type.split('(')[0]),\\r\\n # w2pwidget=field.widget,\\r\\n )) for field in self.descibe_columns)\",\n \"def attributes(self):\\n return dict(self.__attributes)\",\n \"def get_attributes(obj) -> Dict[str, Tuple[Any, str]]:\\n if is_dataclass(obj):\\n return get_dataclass_attributes(obj)\\n elif inspect.isclass(obj):\\n return get_class_attributes(obj)\\n elif inspect.ismodule(obj):\\n return get_module_attributes(obj)\\n return {}\",\n \"def attribute_to_dict(attr: onnx.AttributeProto) -> Dict:\\n ret = {}\\n for a in attr:\\n value = get_attribute_value(a)\\n if isinstance(value, bytes):\\n value = str(value, 'utf-8')\\n ret[a.name] = value\\n return ret\",\n \"def process_attrs(attrs):\\n if attrs.getLength() == 0:\\n return {}\\n tmp_dict = {}\\n for name in attrs.getNames():\\n tmp_dict[name] = attrs.getValue(name)\\n return tmp_dict\",\n \"def _get_attribute_dict(self, attributes, classname=None):\\n if attributes and isinstance(attributes, six.string_types):\\n return {\\n 'class': attributes\\n }\\n if not attributes:\\n attributes = {}\\n if not classname:\\n classname = self.DEFAULT_CLASS_NAME\\n attributes.setdefault('class', classname)\\n return attributes\",\n \"def _parse_attr(self, attr_proto):\\n attrs = {}\\n for a in attr_proto:\\n for f in ['f', 'i', 's']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['floats', 'ints', 'strings']:\\n if list(getattr(a, f)):\\n assert a.name not in attrs, \\\"Only one type of attr is allowed\\\"\\n attrs[a.name] = tuple(getattr(a, f))\\n for f in ['t', 'g']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['tensors', 'graphs']:\\n if list(getattr(a, f)):\\n raise NotImplementedError(\\\"Filed {} is not supported in mxnet.\\\".format(f))\\n if a.name not in attrs:\\n raise ValueError(\\\"Cannot parse attribute: \\\\n{}\\\\n.\\\".format(a))\\n return attrs\",\n \"def attributes(self):\\n _attrs = []\\n if self.name:\\n _attrs.append(\\\"name\\\")\\n if self.label:\\n _attrs.append(\\\"label\\\")\\n if self.confidence:\\n _attrs.append(\\\"confidence\\\")\\n if self.index:\\n _attrs.append(\\\"index\\\")\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs + [\\\"points\\\"]\",\n \"def attrs_to_dict(self, attrs):\\n return {k: v for k, v in attrs}\",\n \"def ATTRIBUTE():\\n return \\\"author\\\", \\\"title\\\", \\\"publisher\\\", \\\"shelf\\\", \\\"category\\\", \\\"subject\\\"\",\n \"def _get_attrs_symbols():\\n return {\\n 'True', 'False', 'None', # those are identifiers in Python 2.7\\n 'self',\\n 'parent',\\n 'id',\\n 'uid',\\n 'context',\\n 'context_today',\\n 'active_id',\\n 'active_ids',\\n 'allowed_company_ids',\\n 'current_company_id',\\n 'active_model',\\n 'time',\\n 'datetime',\\n 'relativedelta',\\n 'current_date',\\n 'abs',\\n 'len',\\n 'bool',\\n 'float',\\n 'str',\\n 'unicode',\\n }\",\n \"def capability_attributes(self) -> Mapping[str, Any] | None:\\n if state_class := self.state_class:\\n return {ATTR_STATE_CLASS: state_class}\\n\\n if options := self.options:\\n return {ATTR_OPTIONS: options}\\n\\n return None\",\n \"def attributes(self) -> Optional[Mapping[str, Sequence[str]]]:\\n return pulumi.get(self, \\\"attributes\\\")\",\n \"def _describe(self) -> Dict[str, Any]:\",\n \"def get_class_attributes(cls) -> Dict[str, Tuple[Any, str]]:\\n try:\\n source = inspect.getsource(cls.__init__) or \\\"\\\"\\n if not source:\\n return {}\\n except TypeError:\\n return {}\\n source = utils.join(source.split(\\\"\\\\n\\\"))\\n node = ast.parse(source)\\n\\n attr_list: List[Tuple] = []\\n module = importlib.import_module(cls.__module__)\\n globals = dict(inspect.getmembers(module))\\n for x in ast.walk(node):\\n if isinstance(x, _ast.AnnAssign):\\n attr, lineno, type_str = parse_annotation_assign(x)\\n type = eval(type_str, globals)\\n attr_list.append((attr, lineno, type))\\n if isinstance(x, _ast.Attribute) and isinstance(x.ctx, _ast.Store):\\n attr_list.append(parse_attribute_with_lineno(x))\\n attr_list = sorted(attr_list, key=lambda x: x[1])\\n\\n attrs: Dict[str, Tuple[Any, str]] = {}\\n lines = source.split(\\\"\\\\n\\\")\\n for name, lineno, *type in attr_list:\\n if name.startswith(\\\"self.\\\"):\\n name = name[5:]\\n desc = get_description(lines, lineno)\\n if type:\\n attrs[name] = type[0], desc # Assignment with type annotation wins.\\n elif name not in attrs:\\n attrs[name] = None, desc\\n return attrs\",\n \"def state_attributes(self) -> dict[str, StateType]:\\n attributes: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}\\n\\n if self.gps is not None:\\n attributes[ATTR_LATITUDE] = self.gps[0]\\n attributes[ATTR_LONGITUDE] = self.gps[1]\\n attributes[ATTR_GPS_ACCURACY] = self.gps_accuracy\\n\\n if self.battery is not None:\\n attributes[ATTR_BATTERY] = self.battery\\n\\n return attributes\",\n \"def to_dict(self):\\n d = {}\\n i = 0\\n for entry in self.entries:\\n d[i] = {}\\n attributes = self.get_attribute_list()\\n print (attributes)\\n for data in attributes:\\n d[i][data] = entry.__getattribute__(data)\\n i = i + 1\\n return d\",\n \"def device_state_attributes(self):\\n attrs = {}\\n\\n attrs[ATTR_ATTRIBUTION] = ATTRIBUTION\\n attrs[\\\"brand\\\"] = DEFAULT_BRAND\\n attrs[ATTR_CAMERA_TYPE] = self._camera_type\\n attrs[\\\"friendly_name\\\"] = self._name\\n\\n return attrs\",\n \"def types(self) -> Dict[str, str]:\\n return {name: self.hyperparams[name][0] for name in self.names()}\",\n \"def thrift_type_to_dict(obj: Any) -> Dict[str, Any]:\\n return {\\n camel_to_snake_case(attr): getattr(obj, attr)\\n for attr in thrift_attrs(obj)\\n }\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute('size', '20'),\\r\\n Attribute('inline', False),\\r\\n Attribute('label', ''),\\r\\n ]\",\n \"def get_question_name_to_answer_attribute_table(cls):\\n return {\\n value.question_name: attr_name\\n for attr_name, value in cls.__dict__.items()\\n if isinstance(value, answer.BaseAnswer)\\n }\",\n \"def create_descr(self, attr_name):\",\n \"def get_attributes_of_node(core, node):\\n attributes = {}\\n for attribute in core.get_attribute_names(node):\\n attributes[attribute] = core.get_attribute(node,attribute)\\n return attributes\",\n \"def get_attributes(self, shape):\\n attributes = {}\\n identifier_names = [i.name for i in self.identifiers]\\n\\n for name, member in shape.members.items():\\n snake_cased = xform_name(name)\\n if snake_cased in identifier_names:\\n # Skip identifiers, these are set through other means\\n continue\\n snake_cased = self._get_name(\\n 'attribute', snake_cased, snake_case=False\\n )\\n attributes[snake_cased] = (name, member)\\n\\n return attributes\",\n \"def info(self):\\n return (self.kind, self.value)\",\n \"def get_attributes(self):\\n\\t\\treturn dict(list(self.__element.items()))\",\n \"def attributes(self):\\n return {'op_type': self.__class__.__name__, 'arguments': {}}\",\n \"def getAttributeDict(self):\\n result = {}\\n dict = self.getDict()\\n for key in dict.keys():\\n value = dict.get(key)\\n if value.__class__.__name__ != 'SpecialDict':\\n result[key] = value\\n return result\",\n \"def as_dict(self):\\n result = {}\\n for attr in self.__attr:\\n result[attr] = getattr(self, attr)\\n return result\",\n \"def dict_by_attr(collection, attrname, value_attrname=None):\\n mapping = {}\\n for item in collection:\\n if callable(attrname):\\n key = attrname(item)\\n else:\\n key = extended_getattr(item, attrname)\\n if value_attrname:\\n item = extended_getattr(item, value_attrname)\\n mapping[key] = mapping.get(key, []) + [item]\\n return mapping\",\n \"def _process_attrs(attrs):\\n new_attrs = OrderedDict()\\n for attr in attrs:\\n col = attr\\n if isinstance(attr, tuple):\\n col, attr = attr\\n # special cases\\n if attr == 'class_name':\\n attr = '__class__.__name__'\\n if attr == 'repr':\\n attr = repr\\n new_attrs[col] = attr\\n\\n return new_attrs\",\n \"def __get_attr_format (self, attrs):\\r\\n format = { \\r\\n 'editor': None,\\r\\n 'min': None,\\r\\n 'max': None,\\r\\n 'step': None,\\r\\n 'subtype': None,\\r\\n 'flags': None,\\r\\n 'enums': None\\r\\n }\\r\\n\\r\\n for attr in attrs: \\r\\n attr_type = attr[\\\"type\\\"]\\r\\n if \\\"editor\\\" == attr_type:\\r\\n format['editor'] = attr[\\\"value\\\"] \\r\\n if \\\"min\\\" == attr_type:\\r\\n format['min'] = attr[\\\"value\\\"] \\r\\n if \\\"max\\\" == attr_type:\\r\\n format['max'] = attr[\\\"value\\\"] \\r\\n if \\\"default\\\" == attr_type:\\r\\n format['default'] = attr[\\\"value\\\"] \\r\\n if \\\"step\\\" == attr_type:\\r\\n format['step'] = attr[\\\"value\\\"]\\r\\n if \\\"subtype\\\" == attr_type:\\r\\n format['subtype'] = attr[\\\"value\\\"]\\r\\n if \\\"flags\\\" == attr_type:\\r\\n format['flags'] = attr['value']\\r\\n if \\\"enums\\\" == attr_type:\\r\\n format['enums'] = attr['value']\\r\\n\\r\\n return format\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute('height', None),\\r\\n Attribute('width', None),\\r\\n Attribute('parts', None),\\r\\n Attribute('analyses', None),\\r\\n Attribute('initial_value', None),\\r\\n Attribute('submit_analyses', None),\\r\\n Attribute('label', ''),\\r\\n ]\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(map(\\n lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x,\\n value\\n ))\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\") else item,\\n value.items()\\n ))\\n else:\\n result[attr] = value\\n if issubclass(UserAttributeInfo, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def expected_types_and_attributes(self):\\n return {self.configs[\\\"entry_type\\\"]: set()}\",\n \"def attribute_dict(self):\\n return self.__attribute_dict\",\n \"def to_dict(cls):\\n result = {}\\n for attr_name in _.reject(set(dir(cls)), lambda x: x.startswith('_')):\\n attr = getattr(cls, attr_name)\\n if _.is_list(attr) or _.is_string(attr):\\n result[attr_name] = attr\\n return result\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute(\\\"show_correctness\\\", \\\"always\\\"),\\r\\n Attribute(\\\"submitted_message\\\", \\\"Answer received.\\\"),\\r\\n Attribute(\\\"label\\\", \\\"\\\"),\\r\\n ]\",\n \"def as_dict(self):\\n return {c.key: getattr(self, c.key)\\n for c in inspect(self).mapper.column_attrs}\",\n \"def readTypes(self):\\r\\n types = {}\\r\\n for m in re.finditer(\\\"TYPE (.*) = (.*);\\\", self.data):\\r\\n typename, typetype = m.groups() \\r\\n if typetype in self.SIMPLETYPES:\\r\\n types[typename] = typetype\\r\\n else:\\r\\n types[typename] = \\\"#\\\" + typetype\\r\\n \\r\\n return types\",\n \"def GetAttributes(self, type):\\n if type == ArrayAssociation.FIELD:\\n return DataSetAttributes(self.VTKObject.GetFieldData(), self, type)\\n return DataSetAttributes(self.VTKObject.GetAttributes(type), self, type)\",\n \"def _get_var_attrs(var):\\n\\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\\n 'missing_value': -9999, 'height': '',\\n 'standard_name': '', 'group_name': '',\\n 'serial_number': ''}\\n\\n generic_dict.update(attrs_dict[var])\\n return generic_dict\",\n \"def tags_dict(self):\\n return ({'name': 'tag', 'attrs': {'k': k, 'v': v}} for k, v in self.tags.items())\",\n \"def extract_attrs(attr_string):\\n attributes = {}\\n for name, val in FIND_ATTRS.findall(attr_string):\\n val = (\\n val.replace(\\\"<\\\", \\\"<\\\")\\n .replace(\\\">\\\", \\\">\\\")\\n .replace(\\\""\\\", '\\\"')\\n .replace(\\\"&\\\", \\\"&\\\")\\n )\\n attributes[name] = val\\n return attributes\",\n \"def attrs(self):\\n return [name for name in self.traits() if self.trait_metadata(name, \\\"attr\\\")]\",\n \"def attrs(self):\\n return [name for name in self.traits() if self.trait_metadata(name, \\\"attr\\\")]\",\n \"def get_attribute_counts(self):\\n counts = defaultdict(int)\\n for attr in self:\\n counts[attr.name] += 1\\n\\n return dict(counts)\",\n \"def record_dict(self):\\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}\",\n \"def attributes(self):\\n return [self._ELE_ATTR]\",\n \"def parse_attributes(self, attr):\\n result = {}\\n annotations = []\\n # Sanitize and split attributes up\\n split_attr = attr.strip(' \\\\t\\\\n;').split(';')\\n for pair in split_attr:\\n splitpair = pair.split('=')\\n if len(splitpair) != 2:\\n continue\\n if splitpair[0] == \\\"ID\\\":\\n result['identifier'] = splitpair[1]\\n elif splitpair[0] == \\\"Name\\\":\\n result['name'] = splitpair[1]\\n elif splitpair[0] == \\\"Parent\\\":\\n result['parent_id'] = splitpair[1]\\n elif splitpair[0] == \\\"Dbxref\\\" or splitpair[0] == \\\"Ontology_term\\\":\\n annotations.append(splitpair)\\n # Make sure we found an ID\\n if \\\"identifier\\\" not in result:\\n return {}\\n # Add annotations if we found any\\n if annotations:\\n result[\\\"annotations\\\"] = annotations\\n return result\",\n \"def device_state_attributes(self):\\n if self.airly.data_available:\\n if self.type == ATTR_CAQI_DESCRIPTION:\\n self._attrs[ATTR_CAQI_ADVICE] = (self.airly.data\\n [ATTR_CAQI_ADVICE])\\n if self.type == ATTR_CAQI:\\n self._attrs[ATTR_CAQI_LEVEL] = self.airly.data[ATTR_CAQI_LEVEL]\\n if self.type == ATTR_PM25:\\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM25_LIMIT]\\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\\n [ATTR_PM25_PERCENT]))\\n if self.type == ATTR_PM10:\\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM10_LIMIT]\\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\\n [ATTR_PM10_PERCENT]))\\n return self._attrs\",\n \"def whoAreYou(self):\\n tempDict = {}\\n tempDict['Class'] = '{0:15}'.format(self.__class__.__name__) +' from '+' '.join([str(base) for base in self.__class__.__bases__])\\n tempDict['Type' ] = self.type\\n tempDict['Name' ] = self.name\\n return tempDict\",\n \"def values(self):\\n return {n: getattr(self, n) for n in self._hparam_types.keys()}\",\n \"def _metadata_map():\\n return {\\n 'date_added': 'dateAdded',\\n 'dns_active': 'dnsActive',\\n 'last_modified': 'lastModified',\\n 'private_flag': 'privateFlag',\\n 'whois_active': 'whoisActive',\\n 'key_name': 'Key Name',\\n 'value_type': 'Value Type',\\n 'value_name': 'Value Name',\\n 'block': 'Block',\\n 'mutex': 'Mutex',\\n 'as_number': 'AS Number',\\n 'hostname': 'hostName',\\n }\",\n \"def getDataAttributes(self):\\n asRet = [];\\n asAttrs = dir(self);\\n for sAttr in asAttrs:\\n if sAttr[0] == '_' or sAttr[0] == 'k':\\n continue;\\n if sAttr in self.kasInternalAttributes:\\n continue;\\n oValue = getattr(self, sAttr);\\n if callable(oValue):\\n continue;\\n asRet.append(sAttr);\\n return asRet;\",\n \"def get_attributes(self):\\n _attributes = {\\n 'function_id': self.function_id,\\n 'hardware_id': self.hardware_id,\\n 'mode_id': self.mode_id,\\n 'critical_item': self.critical_item,\\n 'description': self.description,\\n 'design_provisions': self.design_provisions,\\n 'detection_method': self.detection_method,\\n 'effect_end': self.effect_end,\\n 'effect_local': self.effect_local,\\n 'effect_next': self.effect_next,\\n 'effect_probability': self.effect_probability,\\n 'hazard_rate_source': self.hazard_rate_source,\\n 'isolation_method': self.isolation_method,\\n 'mission': self.mission,\\n 'mission_phase': self.mission_phase,\\n 'mode_criticality': self.mode_criticality,\\n 'mode_hazard_rate': self.mode_hazard_rate,\\n 'mode_op_time': self.mode_op_time,\\n 'mode_probability': self.mode_probability,\\n 'mode_ratio': self.mode_ratio,\\n 'operator_actions': self.operator_actions,\\n 'other_indications': self.other_indications,\\n 'remarks': self.remarks,\\n 'rpn_severity': self.rpn_severity,\\n 'rpn_severity_new': self.rpn_severity_new,\\n 'severity_class': self.severity_class,\\n 'single_point': self.single_point,\\n 'type_id': self.type_id\\n }\\n\\n return _attributes\",\n \"def getAttributeInfo(self, atName):\\n try:\\n dataType, mandatoryCode = self.__getAttributeInfo(atName)\\n return dataType, mandatoryCode\\n except Exception:\\n return None, None\",\n \"def as_attrdict(self) -> AttributeDict:\\n return AttributeDict(\\n {\\n x: Configuration(v).as_attrdict() if isinstance(v, Mapping) else v\\n for x, v in self.items(levels=1)\\n }\\n )\",\n \"def to_dict(self):\\n dct = dict(zip(self._fields, self))\\n dct['type'] = type(self).__name__\\n return dct\",\n \"def attributes(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"attributes\\\")\",\n \"def keys(self):\\n return list(s.name.lower() for s in self.attributes)\",\n \"def get_attributes(self):\\n _attributes = {\\n 'measurement_id': self.measurement_id,\\n 'code': self.code,\\n 'description': self.description,\\n 'measurement_type': self.measurement_type\\n }\\n\\n return _attributes\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def arm_to_dict(arm: Arm) -> Dict[str, Any]:\\n return {\\n \\\"__type\\\": arm.__class__.__name__,\\n \\\"parameters\\\": arm.parameters,\\n \\\"name\\\": arm._name,\\n }\",\n \"def to_dictionary(self):\\n attributes = [\\\"id\\\", \\\"size\\\", \\\"x\\\", \\\"y\\\"]\\n return {key: getattr(self, key) for key in attributes}\",\n \"def dict_to_label_attr_map(input_dict):\\n return {key+':': [key, type(val)] for key, val in input_dict.items()}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6793609","0.6674305","0.6664413","0.6616096","0.64803094","0.64548177","0.64188623","0.63728285","0.63316894","0.62979114","0.6276313","0.62762487","0.6258179","0.62334234","0.62087464","0.6139291","0.6099927","0.6081081","0.6017317","0.59891033","0.59812504","0.5979476","0.5950849","0.59350693","0.59120417","0.58949643","0.58688116","0.58687997","0.5835244","0.5803443","0.5801994","0.57980466","0.57622504","0.57506835","0.57452977","0.573632","0.5721086","0.57088363","0.5701109","0.5699161","0.5698955","0.56718576","0.56560326","0.5646675","0.5644275","0.5622441","0.56027544","0.56010985","0.55815053","0.5581215","0.5575585","0.5572098","0.55694664","0.55685365","0.55563986","0.5554785","0.5552076","0.5544977","0.5544627","0.55417","0.5539493","0.5539029","0.55349696","0.5523133","0.55177563","0.55088794","0.5501874","0.5494877","0.5489911","0.5488944","0.54736656","0.5472781","0.54719675","0.5456656","0.54562825","0.54514486","0.54402345","0.5435867","0.5435867","0.543066","0.54294395","0.54255444","0.5422349","0.54203343","0.54193854","0.54160106","0.54154223","0.5413171","0.5411299","0.5409558","0.5408751","0.5407834","0.5405463","0.53973424","0.5389468","0.53761625","0.53761625","0.5370725","0.5364506","0.5361778"],"string":"[\n \"0.6793609\",\n \"0.6674305\",\n \"0.6664413\",\n \"0.6616096\",\n \"0.64803094\",\n \"0.64548177\",\n \"0.64188623\",\n \"0.63728285\",\n \"0.63316894\",\n \"0.62979114\",\n \"0.6276313\",\n \"0.62762487\",\n \"0.6258179\",\n \"0.62334234\",\n \"0.62087464\",\n \"0.6139291\",\n \"0.6099927\",\n \"0.6081081\",\n \"0.6017317\",\n \"0.59891033\",\n \"0.59812504\",\n \"0.5979476\",\n \"0.5950849\",\n \"0.59350693\",\n \"0.59120417\",\n \"0.58949643\",\n \"0.58688116\",\n \"0.58687997\",\n \"0.5835244\",\n \"0.5803443\",\n \"0.5801994\",\n \"0.57980466\",\n \"0.57622504\",\n \"0.57506835\",\n \"0.57452977\",\n \"0.573632\",\n \"0.5721086\",\n \"0.57088363\",\n \"0.5701109\",\n \"0.5699161\",\n \"0.5698955\",\n \"0.56718576\",\n \"0.56560326\",\n \"0.5646675\",\n \"0.5644275\",\n \"0.5622441\",\n \"0.56027544\",\n \"0.56010985\",\n \"0.55815053\",\n \"0.5581215\",\n \"0.5575585\",\n \"0.5572098\",\n \"0.55694664\",\n \"0.55685365\",\n \"0.55563986\",\n \"0.5554785\",\n \"0.5552076\",\n \"0.5544977\",\n \"0.5544627\",\n \"0.55417\",\n \"0.5539493\",\n \"0.5539029\",\n \"0.55349696\",\n \"0.5523133\",\n \"0.55177563\",\n \"0.55088794\",\n \"0.5501874\",\n \"0.5494877\",\n \"0.5489911\",\n \"0.5488944\",\n \"0.54736656\",\n \"0.5472781\",\n \"0.54719675\",\n \"0.5456656\",\n \"0.54562825\",\n \"0.54514486\",\n \"0.54402345\",\n \"0.5435867\",\n \"0.5435867\",\n \"0.543066\",\n \"0.54294395\",\n \"0.54255444\",\n \"0.5422349\",\n \"0.54203343\",\n \"0.54193854\",\n \"0.54160106\",\n \"0.54154223\",\n \"0.5413171\",\n \"0.5411299\",\n \"0.5409558\",\n \"0.5408751\",\n \"0.5407834\",\n \"0.5405463\",\n \"0.53973424\",\n \"0.5389468\",\n \"0.53761625\",\n \"0.53761625\",\n \"0.5370725\",\n \"0.5364506\",\n \"0.5361778\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61141795"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":76092,"cells":{"query":{"kind":"string","value":"Returns a dictionary that maps attribute name to a tuple of (type, description)."},"document":{"kind":"string","value":"def get_attributes(obj) -> Dict[str, Tuple[Any, str]]:\n if is_dataclass(obj):\n return get_dataclass_attributes(obj)\n elif inspect.isclass(obj):\n return get_class_attributes(obj)\n elif inspect.ismodule(obj):\n return get_module_attributes(obj)\n return {}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}","def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a","def get_attributes(self) -> Dict[str, str]:\n pass","def map_field_name_to_attribute() -> typing.Dict:\n return {\n \"tag\": \"tag\",\n \"contact\": \"contact\",\n }","def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs","def attributes_metadata(self):\n\n attribute_meta = collections.defaultdict(dict)\n\n for attribute in self.attributes:\n attribute_meta[attribute.name]['valuemap'] = attribute.valuemap\n attribute_meta[attribute.name]['qualifiers'] = attribute.qualifiers\n\n return dict(attribute_meta)","def get_attributes(self):\n \n retdict = {}\n retdict['s'] = str(self.s)\n if self.t != None:\n retdict['t'] = str(self.t)\n retdict['a'] = str(self.a)\n retdict['b'] = str(self.b)\n retdict['c'] = str(self.c)\n retdict['d'] = str(self.d)\n return retdict","def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic","def meta(cls):\n if getattr(cls, '__from_class__', None) is not None:\n cls = cls.__from_class__\n attribute_info = {}\n for name, value in cls.__table__.columns.items():\n attribute_info[name] = str(value.type).lower()\n\n return {cls.__name__: attribute_info}","def attributeType(self) -> unicode:\n ...","def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}","def description(self):\n desc = self.title\n ops = []\n for attribute in self.attributes.all():\n value = attribute.value\n if isinstance(value, list):\n ops.append(\n \"%s = '%s'\" % (attribute.type, (\", \".join([str(v) for v in value])))\n )\n else:\n ops.append(\"%s = '%s'\" % (attribute.type, value))\n if ops:\n desc = \"%s (%s)\" % (desc, \", \".join(ops))\n return desc","def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass","def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_","def get_attrs_dict(self, root_element):\n attr_elements = root_element.findall(\"attribute\")\n attrs_dict = {}\n for el in attr_elements:\n attrs_dict[el.attrib[\"name\"]] = {\n \"value\": el.attrib[\"value\"],\n \"type\": el.attrib.get(\"type\", None)\n }\n return attrs_dict","def to_dict(\n self,\n attributes: Iterable[str] = (\"xyz\", \"viewdir\", \"imgsz\", \"f\", \"c\", \"k\", \"p\"),\n ) -> Dict[str, tuple]:\n return {key: helpers.numpy_to_native(getattr(self, key)) for key in attributes}","def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:\n fields = cls.__dataclass_fields__.values()\n attrs = {}\n for field in fields:\n if field.type != InitVar:\n attrs[field.name] = field.type, \"\"\n return attrs","def dict(self) -> dict():\n\n dict_reg_hive = {}\n\n for _attribute in self.attributes.__dict__.items():\n if isinstance(_attribute[1], str):\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\n _attribute_value = getattr(self, _attribute[1])\n dict_reg_hive.update({_attribute[1]: _attribute_value})\n\n return dict_reg_hive","def get_attrib_dict(self, attribs: Tuple[str]) -> Dict[str, str]:\n attrs = self.get_attribs(attribs)\n attrs = tuple(map(lambda a: (a[0][1:], a[1]), attrs))\n return dict(attrs)","def attribute_metadata(attr: Attr, parent_namespace: Optional[str]) -> Dict:\n metadata = dict(\n name=None\n if attr.is_nameless or attr.local_name == attribute_name(attr.name)\n else attr.local_name,\n type=attr.xml_type,\n namespace=attr.namespace\n if parent_namespace != attr.namespace or attr.is_attribute\n else None,\n **attr.restrictions.asdict(),\n )\n\n return {\n key: value\n for key, value in metadata.items()\n if value is not None and value is not False\n }","def get_attribute_data(self):\n ret = {}\n\n for attribute in Attribute.objects.all().prefetch_related(\"value_choices\"):\n deserialized_value = None\n\n if attribute.value_type == Attribute.TYPE_GEOMETRY:\n geometry = ProjectAttributeMultipolygonGeometry.objects.filter(\n attribute=attribute, project=self\n ).first()\n if not geometry:\n continue\n deserialized_value = geometry.geometry\n elif attribute.value_type in [Attribute.TYPE_IMAGE, Attribute.TYPE_FILE]:\n try:\n deserialized_value = ProjectAttributeFile.objects.filter(\n attribute=attribute, project=self\n ).order_by(\"-created_at\").first().file\n except AttributeError:\n deserialized_value = None\n elif attribute.identifier in self.attribute_data:\n deserialized_value = attribute.deserialize_value(\n self.attribute_data[attribute.identifier]\n )\n\n ret[attribute.identifier] = deserialized_value\n return ret","def read_attr_type_file():\n with open(args.attr_type_file_path, 'r') as f:\n content = f.readlines()\n\n # Strip lines of newline/return characters in csv file\n content = [x.strip(' \\t\\n\\r') for x in content]\n\n # Generate dictionary of types and their count\n attribute_type_dict = {}\n for item in content:\n key, value = item.split('|')\n attribute_type_dict[key.strip()] = value.strip()\n \n return attribute_type_dict","def __getAttributeInfo(self, atName):\n cifDataType = self.__dApi.getTypeCode(self.getName(), atName)\n cifPrimitiveType = self.__dApi.getTypePrimitive(self.getName(), atName)\n isMandatory = self.__dApi.getMandatoryCode(self.getName(), atName) in [\"yes\", \"implicit\", \"implicit-ordinal\"]\n dataType = \"integer\" if \"int\" in cifDataType else \"float\" if cifPrimitiveType == \"numb\" else \"string\"\n return dataType, isMandatory","def attributeInfo(*args, allAttributes: bool=True, bool: bool=True, enumerated: bool=True,\n hidden: bool=True, inherited: bool=True, internal: bool=True, leaf: bool=True,\n logicalAnd: bool=True, multi: bool=True, short: bool=True, userInterface:\n bool=True, writable: bool=True, type: AnyStr=\"\", **kwargs)->List[AnyStr]:\n pass","def get_module_attributes(module) -> Dict[str, Tuple[Any, str]]:\n try:\n source = inspect.getsource(module) or \"\"\n if not source:\n return {}\n except (OSError, TypeError):\n return {}\n node = ast.parse(source)\n\n attr_list: List[Tuple] = []\n globals = dict(inspect.getmembers(module))\n for x in ast.iter_child_nodes(node):\n if isinstance(x, _ast.AnnAssign):\n attr, lineno, type_str = parse_annotation_assign(x)\n type = eval(type_str, globals)\n attr_list.append((attr, lineno, type))\n if isinstance(x, _ast.Assign):\n attr_list.append(parse_attribute_with_lineno(x))\n attr_list = sorted(attr_list, key=lambda x: x[1])\n\n attrs: Dict[str, Tuple[Any, str]] = {}\n lines = source.split(\"\\n\")\n for name, lineno, *type in attr_list:\n desc = get_description(lines, lineno)\n if type:\n attrs[name] = type[0], desc # Assignment with type annotation wins.\n elif name not in attrs:\n attrs[name] = None, desc\n return attrs","def get_attributes(cls):\r\n return [Attribute('size', '20'),\r\n Attribute('label', ''), ]","def get_attributes(self):\n\n endpoint = self._get_api_endpoint() + '/attributes'\n results = self.tq.get(endpoint, withp='attribute')\n if 'data' not in results:\n return {}\n\n return results['data']\n # tr = {}\n # for attribute in results['data']:\n # tr[attribute['attribute']['name']] = attribute['value']\n # return tr","def getDict(self):\n res = {}\n for attr, value in self.__dict__.iteritems():\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\n res[attr] = value\n elif isinstance(attr, datetime.datetime):\n res[attr] = value.isoformat('-')\n \n return res","def to_dict(\n self, attributes: Sequence[str] = (\n 'demand_instruments', 'supply_instruments', 'inverse_covariance_matrix',\n 'expected_xi_by_theta_jacobian', 'expected_omega_by_theta_jacobian', 'expected_prices',\n 'expected_shares', 'computation_time', 'draws', 'fp_converged', 'fp_iterations',\n 'contraction_evaluations'\n )) -> dict:\n return {k: getattr(self, k) for k in attributes}","def category_attributes_types(categories, db_info, connection):\n attributes = {}\n for cat in categories:\n attributes[cat] = {}\n category_info = api_category_info(cat, db_info, connection)\n\n attr = {}\n for a in category_info.get(\"attributes\"):\n for key in a:\n attr[key] = a[key]\n\n attributes[cat][\"attributes\"] = {k: d for d, k in attr.items()}\n\n types = category_info.get(\"types\")\n attributes[cat][\"types\"] = {\n attr.get(a): types.get(a) for a in types}\n\n attributes[cat][\"dialogs\"] = category_info.get(\"dialogs\")\n\n return attributes","def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs","def attributes(self):\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }","def attributes(self, *args):\n kwargs = {}\n if args:\n kwargs[\"attributenames\"] = args\n\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\n\n # parse contennt looking for all attributes\n attributes = []\n for line in r.text.splitlines():\n r = re.match(\"(userdetails\\.attribute\\.name)=(.*)\", line)\n if r:\n name = r.groups()[1]\n attributes.append([name, None])\n continue # next line\n\n r = re.match(\"(userdetails\\.attribute\\.value)=(.*)\", line)\n if r:\n value = r.groups()[1]\n # last name parsed is where it has to\n # be stacked\n if attributes[-1][1] == None:\n attributes[-1][1] = value\n if isinstance(attributes[-1][1], list):\n attributes[-1][1].append(value)\n else:\n # cast to list\n attributes[-1].append([attributes[-1][1], value])\n\n return dict([(item[0], item[1]) for item in attributes])","def describe(self):\r\n return dict((field.name, dict(\r\n id=field.name,\r\n name=field.label,\r\n validators=ValidatorSerializer(\r\n field.requires if isSequenceType(field.requires) else [field.requires])(),\r\n comment=field.comment,\r\n readable=field.readable,\r\n writable=field.writable,\r\n type=getattr(field, 'wtype',\r\n field.type.type if isinstance(field.type, SQLCustomType) else field.type.split('(')[0]),\r\n # w2pwidget=field.widget,\r\n )) for field in self.descibe_columns)","def attributes(self):\n return dict(self.__attributes)","def attribute_to_dict(attr: onnx.AttributeProto) -> Dict:\n ret = {}\n for a in attr:\n value = get_attribute_value(a)\n if isinstance(value, bytes):\n value = str(value, 'utf-8')\n ret[a.name] = value\n return ret","def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict","def _get_attribute_dict(self, attributes, classname=None):\n if attributes and isinstance(attributes, six.string_types):\n return {\n 'class': attributes\n }\n if not attributes:\n attributes = {}\n if not classname:\n classname = self.DEFAULT_CLASS_NAME\n attributes.setdefault('class', classname)\n return attributes","def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs","def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}","def attributes(self):\n _attrs = []\n if self.name:\n _attrs.append(\"name\")\n if self.label:\n _attrs.append(\"label\")\n if self.confidence:\n _attrs.append(\"confidence\")\n if self.index:\n _attrs.append(\"index\")\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs + [\"points\"]","def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"","def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }","def capability_attributes(self) -> Mapping[str, Any] | None:\n if state_class := self.state_class:\n return {ATTR_STATE_CLASS: state_class}\n\n if options := self.options:\n return {ATTR_OPTIONS: options}\n\n return None","def attributes(self) -> Optional[Mapping[str, Sequence[str]]]:\n return pulumi.get(self, \"attributes\")","def _describe(self) -> Dict[str, Any]:","def get_class_attributes(cls) -> Dict[str, Tuple[Any, str]]:\n try:\n source = inspect.getsource(cls.__init__) or \"\"\n if not source:\n return {}\n except TypeError:\n return {}\n source = utils.join(source.split(\"\\n\"))\n node = ast.parse(source)\n\n attr_list: List[Tuple] = []\n module = importlib.import_module(cls.__module__)\n globals = dict(inspect.getmembers(module))\n for x in ast.walk(node):\n if isinstance(x, _ast.AnnAssign):\n attr, lineno, type_str = parse_annotation_assign(x)\n type = eval(type_str, globals)\n attr_list.append((attr, lineno, type))\n if isinstance(x, _ast.Attribute) and isinstance(x.ctx, _ast.Store):\n attr_list.append(parse_attribute_with_lineno(x))\n attr_list = sorted(attr_list, key=lambda x: x[1])\n\n attrs: Dict[str, Tuple[Any, str]] = {}\n lines = source.split(\"\\n\")\n for name, lineno, *type in attr_list:\n if name.startswith(\"self.\"):\n name = name[5:]\n desc = get_description(lines, lineno)\n if type:\n attrs[name] = type[0], desc # Assignment with type annotation wins.\n elif name not in attrs:\n attrs[name] = None, desc\n return attrs","def state_attributes(self) -> dict[str, StateType]:\n attributes: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}\n\n if self.gps is not None:\n attributes[ATTR_LATITUDE] = self.gps[0]\n attributes[ATTR_LONGITUDE] = self.gps[1]\n attributes[ATTR_GPS_ACCURACY] = self.gps_accuracy\n\n if self.battery is not None:\n attributes[ATTR_BATTERY] = self.battery\n\n return attributes","def to_dict(self):\n d = {}\n i = 0\n for entry in self.entries:\n d[i] = {}\n attributes = self.get_attribute_list()\n print (attributes)\n for data in attributes:\n d[i][data] = entry.__getattribute__(data)\n i = i + 1\n return d","def device_state_attributes(self):\n attrs = {}\n\n attrs[ATTR_ATTRIBUTION] = ATTRIBUTION\n attrs[\"brand\"] = DEFAULT_BRAND\n attrs[ATTR_CAMERA_TYPE] = self._camera_type\n attrs[\"friendly_name\"] = self._name\n\n return attrs","def types(self) -> Dict[str, str]:\n return {name: self.hyperparams[name][0] for name in self.names()}","def thrift_type_to_dict(obj: Any) -> Dict[str, Any]:\n return {\n camel_to_snake_case(attr): getattr(obj, attr)\n for attr in thrift_attrs(obj)\n }","def get_attributes(cls):\r\n return [\r\n Attribute('size', '20'),\r\n Attribute('inline', False),\r\n Attribute('label', ''),\r\n ]","def get_question_name_to_answer_attribute_table(cls):\n return {\n value.question_name: attr_name\n for attr_name, value in cls.__dict__.items()\n if isinstance(value, answer.BaseAnswer)\n }","def create_descr(self, attr_name):","def get_attributes_of_node(core, node):\n attributes = {}\n for attribute in core.get_attribute_names(node):\n attributes[attribute] = core.get_attribute(node,attribute)\n return attributes","def get_attributes(self, shape):\n attributes = {}\n identifier_names = [i.name for i in self.identifiers]\n\n for name, member in shape.members.items():\n snake_cased = xform_name(name)\n if snake_cased in identifier_names:\n # Skip identifiers, these are set through other means\n continue\n snake_cased = self._get_name(\n 'attribute', snake_cased, snake_case=False\n )\n attributes[snake_cased] = (name, member)\n\n return attributes","def info(self):\n return (self.kind, self.value)","def get_attributes(self):\n\t\treturn dict(list(self.__element.items()))","def attributes(self):\n return {'op_type': self.__class__.__name__, 'arguments': {}}","def getAttributeDict(self):\n result = {}\n dict = self.getDict()\n for key in dict.keys():\n value = dict.get(key)\n if value.__class__.__name__ != 'SpecialDict':\n result[key] = value\n return result","def as_dict(self):\n result = {}\n for attr in self.__attr:\n result[attr] = getattr(self, attr)\n return result","def dict_by_attr(collection, attrname, value_attrname=None):\n mapping = {}\n for item in collection:\n if callable(attrname):\n key = attrname(item)\n else:\n key = extended_getattr(item, attrname)\n if value_attrname:\n item = extended_getattr(item, value_attrname)\n mapping[key] = mapping.get(key, []) + [item]\n return mapping","def _process_attrs(attrs):\n new_attrs = OrderedDict()\n for attr in attrs:\n col = attr\n if isinstance(attr, tuple):\n col, attr = attr\n # special cases\n if attr == 'class_name':\n attr = '__class__.__name__'\n if attr == 'repr':\n attr = repr\n new_attrs[col] = attr\n\n return new_attrs","def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format","def get_attributes(cls):\r\n return [\r\n Attribute('height', None),\r\n Attribute('width', None),\r\n Attribute('parts', None),\r\n Attribute('analyses', None),\r\n Attribute('initial_value', None),\r\n Attribute('submit_analyses', None),\r\n Attribute('label', ''),\r\n ]","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n if issubclass(UserAttributeInfo, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def expected_types_and_attributes(self):\n return {self.configs[\"entry_type\"]: set()}","def attribute_dict(self):\n return self.__attribute_dict","def to_dict(cls):\n result = {}\n for attr_name in _.reject(set(dir(cls)), lambda x: x.startswith('_')):\n attr = getattr(cls, attr_name)\n if _.is_list(attr) or _.is_string(attr):\n result[attr_name] = attr\n return result","def readTypes(self):\r\n types = {}\r\n for m in re.finditer(\"TYPE (.*) = (.*);\", self.data):\r\n typename, typetype = m.groups() \r\n if typetype in self.SIMPLETYPES:\r\n types[typename] = typetype\r\n else:\r\n types[typename] = \"#\" + typetype\r\n \r\n return types","def as_dict(self):\n return {c.key: getattr(self, c.key)\n for c in inspect(self).mapper.column_attrs}","def get_attributes(cls):\r\n return [\r\n Attribute(\"show_correctness\", \"always\"),\r\n Attribute(\"submitted_message\", \"Answer received.\"),\r\n Attribute(\"label\", \"\"),\r\n ]","def GetAttributes(self, type):\n if type == ArrayAssociation.FIELD:\n return DataSetAttributes(self.VTKObject.GetFieldData(), self, type)\n return DataSetAttributes(self.VTKObject.GetAttributes(type), self, type)","def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict","def tags_dict(self):\n return ({'name': 'tag', 'attrs': {'k': k, 'v': v}} for k, v in self.tags.items())","def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes","def attrs(self):\n return [name for name in self.traits() if self.trait_metadata(name, \"attr\")]","def attrs(self):\n return [name for name in self.traits() if self.trait_metadata(name, \"attr\")]","def get_attribute_counts(self):\n counts = defaultdict(int)\n for attr in self:\n counts[attr.name] += 1\n\n return dict(counts)","def record_dict(self):\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}","def attributes(self):\n return [self._ELE_ATTR]","def parse_attributes(self, attr):\n result = {}\n annotations = []\n # Sanitize and split attributes up\n split_attr = attr.strip(' \\t\\n;').split(';')\n for pair in split_attr:\n splitpair = pair.split('=')\n if len(splitpair) != 2:\n continue\n if splitpair[0] == \"ID\":\n result['identifier'] = splitpair[1]\n elif splitpair[0] == \"Name\":\n result['name'] = splitpair[1]\n elif splitpair[0] == \"Parent\":\n result['parent_id'] = splitpair[1]\n elif splitpair[0] == \"Dbxref\" or splitpair[0] == \"Ontology_term\":\n annotations.append(splitpair)\n # Make sure we found an ID\n if \"identifier\" not in result:\n return {}\n # Add annotations if we found any\n if annotations:\n result[\"annotations\"] = annotations\n return result","def whoAreYou(self):\n tempDict = {}\n tempDict['Class'] = '{0:15}'.format(self.__class__.__name__) +' from '+' '.join([str(base) for base in self.__class__.__bases__])\n tempDict['Type' ] = self.type\n tempDict['Name' ] = self.name\n return tempDict","def device_state_attributes(self):\n if self.airly.data_available:\n if self.type == ATTR_CAQI_DESCRIPTION:\n self._attrs[ATTR_CAQI_ADVICE] = (self.airly.data\n [ATTR_CAQI_ADVICE])\n if self.type == ATTR_CAQI:\n self._attrs[ATTR_CAQI_LEVEL] = self.airly.data[ATTR_CAQI_LEVEL]\n if self.type == ATTR_PM25:\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM25_LIMIT]\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\n [ATTR_PM25_PERCENT]))\n if self.type == ATTR_PM10:\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM10_LIMIT]\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\n [ATTR_PM10_PERCENT]))\n return self._attrs","def values(self):\n return {n: getattr(self, n) for n in self._hparam_types.keys()}","def _metadata_map():\n return {\n 'date_added': 'dateAdded',\n 'dns_active': 'dnsActive',\n 'last_modified': 'lastModified',\n 'private_flag': 'privateFlag',\n 'whois_active': 'whoisActive',\n 'key_name': 'Key Name',\n 'value_type': 'Value Type',\n 'value_name': 'Value Name',\n 'block': 'Block',\n 'mutex': 'Mutex',\n 'as_number': 'AS Number',\n 'hostname': 'hostName',\n }","def getDataAttributes(self):\n asRet = [];\n asAttrs = dir(self);\n for sAttr in asAttrs:\n if sAttr[0] == '_' or sAttr[0] == 'k':\n continue;\n if sAttr in self.kasInternalAttributes:\n continue;\n oValue = getattr(self, sAttr);\n if callable(oValue):\n continue;\n asRet.append(sAttr);\n return asRet;","def get_attributes(self):\n _attributes = {\n 'function_id': self.function_id,\n 'hardware_id': self.hardware_id,\n 'mode_id': self.mode_id,\n 'critical_item': self.critical_item,\n 'description': self.description,\n 'design_provisions': self.design_provisions,\n 'detection_method': self.detection_method,\n 'effect_end': self.effect_end,\n 'effect_local': self.effect_local,\n 'effect_next': self.effect_next,\n 'effect_probability': self.effect_probability,\n 'hazard_rate_source': self.hazard_rate_source,\n 'isolation_method': self.isolation_method,\n 'mission': self.mission,\n 'mission_phase': self.mission_phase,\n 'mode_criticality': self.mode_criticality,\n 'mode_hazard_rate': self.mode_hazard_rate,\n 'mode_op_time': self.mode_op_time,\n 'mode_probability': self.mode_probability,\n 'mode_ratio': self.mode_ratio,\n 'operator_actions': self.operator_actions,\n 'other_indications': self.other_indications,\n 'remarks': self.remarks,\n 'rpn_severity': self.rpn_severity,\n 'rpn_severity_new': self.rpn_severity_new,\n 'severity_class': self.severity_class,\n 'single_point': self.single_point,\n 'type_id': self.type_id\n }\n\n return _attributes","def as_attrdict(self) -> AttributeDict:\n return AttributeDict(\n {\n x: Configuration(v).as_attrdict() if isinstance(v, Mapping) else v\n for x, v in self.items(levels=1)\n }\n )","def to_dict(self):\n dct = dict(zip(self._fields, self))\n dct['type'] = type(self).__name__\n return dct","def getAttributeInfo(self, atName):\n try:\n dataType, mandatoryCode = self.__getAttributeInfo(atName)\n return dataType, mandatoryCode\n except Exception:\n return None, None","def attributes(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\n return pulumi.get(self, \"attributes\")","def keys(self):\n return list(s.name.lower() for s in self.attributes)","def get_attributes(self):\n _attributes = {\n 'measurement_id': self.measurement_id,\n 'code': self.code,\n 'description': self.description,\n 'measurement_type': self.measurement_type\n }\n\n return _attributes","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def arm_to_dict(arm: Arm) -> Dict[str, Any]:\n return {\n \"__type\": arm.__class__.__name__,\n \"parameters\": arm.parameters,\n \"name\": arm._name,\n }","def to_dictionary(self):\n attributes = [\"id\", \"size\", \"x\", \"y\"]\n return {key: getattr(self, key) for key in attributes}","def dict_to_label_attr_map(input_dict):\n return {key+':': [key, type(val)] for key, val in input_dict.items()}"],"string":"[\n \"def _attrs_map(self) -> \\\"dict[int, str]\\\":\\n return {i: attr.name for i, attr in enumerate(self._attrs())}\",\n \"def _attribs(self, name=None, description=None):\\n a = {}\\n if name:\\n a['name'] = name\\n if description:\\n a['description'] = description\\n return a\",\n \"def get_attributes(self) -> Dict[str, str]:\\n pass\",\n \"def map_field_name_to_attribute() -> typing.Dict:\\n return {\\n \\\"tag\\\": \\\"tag\\\",\\n \\\"contact\\\": \\\"contact\\\",\\n }\",\n \"def attributes(self):\\n _attrs = [\\\"type\\\", \\\"name\\\", \\\"value\\\"]\\n if self.confidence is not None:\\n _attrs.append(\\\"confidence\\\")\\n if self.constant:\\n _attrs.append(\\\"constant\\\")\\n if self.tags:\\n _attrs.append(\\\"tags\\\")\\n\\n return _attrs\",\n \"def attributes_metadata(self):\\n\\n attribute_meta = collections.defaultdict(dict)\\n\\n for attribute in self.attributes:\\n attribute_meta[attribute.name]['valuemap'] = attribute.valuemap\\n attribute_meta[attribute.name]['qualifiers'] = attribute.qualifiers\\n\\n return dict(attribute_meta)\",\n \"def get_attributes(self):\\n \\n retdict = {}\\n retdict['s'] = str(self.s)\\n if self.t != None:\\n retdict['t'] = str(self.t)\\n retdict['a'] = str(self.a)\\n retdict['b'] = str(self.b)\\n retdict['c'] = str(self.c)\\n retdict['d'] = str(self.d)\\n return retdict\",\n \"def _get_attribute_dic(self, attrs):\\n attr_dic = {}\\n for attr_pair in attrs:\\n attr_dic[attr_pair[0]] = attr_pair[1]\\n return attr_dic\",\n \"def meta(cls):\\n if getattr(cls, '__from_class__', None) is not None:\\n cls = cls.__from_class__\\n attribute_info = {}\\n for name, value in cls.__table__.columns.items():\\n attribute_info[name] = str(value.type).lower()\\n\\n return {cls.__name__: attribute_info}\",\n \"def attributeType(self) -> unicode:\\n ...\",\n \"def getAttributeInfoDictionary(attr, format=None):\\n format = format or _getDocFormat(attr)\\n return {'name': attr.getName(),\\n 'doc': renderText(attr.getDoc() or '', format=format)}\",\n \"def description(self):\\n desc = self.title\\n ops = []\\n for attribute in self.attributes.all():\\n value = attribute.value\\n if isinstance(value, list):\\n ops.append(\\n \\\"%s = '%s'\\\" % (attribute.type, (\\\", \\\".join([str(v) for v in value])))\\n )\\n else:\\n ops.append(\\\"%s = '%s'\\\" % (attribute.type, value))\\n if ops:\\n desc = \\\"%s (%s)\\\" % (desc, \\\", \\\".join(ops))\\n return desc\",\n \"def proc_attr(inp):\\n dic = {}\\n for att in inp.attrs.keys():\\n if getattr(inp.attrs[att], \\\"dtype\\\", None) is None:\\n dic[att] = inp.attrs[att]\\n elif inp.attrs[att].dtype.char == 'S':\\n dic[att] = [\\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\\n ]\\n else:\\n dic[att] = (\\n inp.attrs[att][0]\\n if isinstance(inp.attrs[att],np.ndarray) and\\n inp.attrs[att].size==1\\n else inp.attrs[att]\\n )\\n return dic\\n pass\",\n \"def attributes(self):\\n attrs_ = [\\\"name\\\", \\\"type\\\"]\\n if self.exclusive:\\n attrs_.append(\\\"exclusive\\\")\\n if self.default is not None:\\n attrs_.append(\\\"default\\\")\\n\\n return attrs_\",\n \"def get_attrs_dict(self, root_element):\\n attr_elements = root_element.findall(\\\"attribute\\\")\\n attrs_dict = {}\\n for el in attr_elements:\\n attrs_dict[el.attrib[\\\"name\\\"]] = {\\n \\\"value\\\": el.attrib[\\\"value\\\"],\\n \\\"type\\\": el.attrib.get(\\\"type\\\", None)\\n }\\n return attrs_dict\",\n \"def to_dict(\\n self,\\n attributes: Iterable[str] = (\\\"xyz\\\", \\\"viewdir\\\", \\\"imgsz\\\", \\\"f\\\", \\\"c\\\", \\\"k\\\", \\\"p\\\"),\\n ) -> Dict[str, tuple]:\\n return {key: helpers.numpy_to_native(getattr(self, key)) for key in attributes}\",\n \"def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:\\n fields = cls.__dataclass_fields__.values()\\n attrs = {}\\n for field in fields:\\n if field.type != InitVar:\\n attrs[field.name] = field.type, \\\"\\\"\\n return attrs\",\n \"def dict(self) -> dict():\\n\\n dict_reg_hive = {}\\n\\n for _attribute in self.attributes.__dict__.items():\\n if isinstance(_attribute[1], str):\\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\\n _attribute_value = getattr(self, _attribute[1])\\n dict_reg_hive.update({_attribute[1]: _attribute_value})\\n\\n return dict_reg_hive\",\n \"def get_attrib_dict(self, attribs: Tuple[str]) -> Dict[str, str]:\\n attrs = self.get_attribs(attribs)\\n attrs = tuple(map(lambda a: (a[0][1:], a[1]), attrs))\\n return dict(attrs)\",\n \"def attribute_metadata(attr: Attr, parent_namespace: Optional[str]) -> Dict:\\n metadata = dict(\\n name=None\\n if attr.is_nameless or attr.local_name == attribute_name(attr.name)\\n else attr.local_name,\\n type=attr.xml_type,\\n namespace=attr.namespace\\n if parent_namespace != attr.namespace or attr.is_attribute\\n else None,\\n **attr.restrictions.asdict(),\\n )\\n\\n return {\\n key: value\\n for key, value in metadata.items()\\n if value is not None and value is not False\\n }\",\n \"def get_attribute_data(self):\\n ret = {}\\n\\n for attribute in Attribute.objects.all().prefetch_related(\\\"value_choices\\\"):\\n deserialized_value = None\\n\\n if attribute.value_type == Attribute.TYPE_GEOMETRY:\\n geometry = ProjectAttributeMultipolygonGeometry.objects.filter(\\n attribute=attribute, project=self\\n ).first()\\n if not geometry:\\n continue\\n deserialized_value = geometry.geometry\\n elif attribute.value_type in [Attribute.TYPE_IMAGE, Attribute.TYPE_FILE]:\\n try:\\n deserialized_value = ProjectAttributeFile.objects.filter(\\n attribute=attribute, project=self\\n ).order_by(\\\"-created_at\\\").first().file\\n except AttributeError:\\n deserialized_value = None\\n elif attribute.identifier in self.attribute_data:\\n deserialized_value = attribute.deserialize_value(\\n self.attribute_data[attribute.identifier]\\n )\\n\\n ret[attribute.identifier] = deserialized_value\\n return ret\",\n \"def read_attr_type_file():\\n with open(args.attr_type_file_path, 'r') as f:\\n content = f.readlines()\\n\\n # Strip lines of newline/return characters in csv file\\n content = [x.strip(' \\\\t\\\\n\\\\r') for x in content]\\n\\n # Generate dictionary of types and their count\\n attribute_type_dict = {}\\n for item in content:\\n key, value = item.split('|')\\n attribute_type_dict[key.strip()] = value.strip()\\n \\n return attribute_type_dict\",\n \"def __getAttributeInfo(self, atName):\\n cifDataType = self.__dApi.getTypeCode(self.getName(), atName)\\n cifPrimitiveType = self.__dApi.getTypePrimitive(self.getName(), atName)\\n isMandatory = self.__dApi.getMandatoryCode(self.getName(), atName) in [\\\"yes\\\", \\\"implicit\\\", \\\"implicit-ordinal\\\"]\\n dataType = \\\"integer\\\" if \\\"int\\\" in cifDataType else \\\"float\\\" if cifPrimitiveType == \\\"numb\\\" else \\\"string\\\"\\n return dataType, isMandatory\",\n \"def attributeInfo(*args, allAttributes: bool=True, bool: bool=True, enumerated: bool=True,\\n hidden: bool=True, inherited: bool=True, internal: bool=True, leaf: bool=True,\\n logicalAnd: bool=True, multi: bool=True, short: bool=True, userInterface:\\n bool=True, writable: bool=True, type: AnyStr=\\\"\\\", **kwargs)->List[AnyStr]:\\n pass\",\n \"def get_module_attributes(module) -> Dict[str, Tuple[Any, str]]:\\n try:\\n source = inspect.getsource(module) or \\\"\\\"\\n if not source:\\n return {}\\n except (OSError, TypeError):\\n return {}\\n node = ast.parse(source)\\n\\n attr_list: List[Tuple] = []\\n globals = dict(inspect.getmembers(module))\\n for x in ast.iter_child_nodes(node):\\n if isinstance(x, _ast.AnnAssign):\\n attr, lineno, type_str = parse_annotation_assign(x)\\n type = eval(type_str, globals)\\n attr_list.append((attr, lineno, type))\\n if isinstance(x, _ast.Assign):\\n attr_list.append(parse_attribute_with_lineno(x))\\n attr_list = sorted(attr_list, key=lambda x: x[1])\\n\\n attrs: Dict[str, Tuple[Any, str]] = {}\\n lines = source.split(\\\"\\\\n\\\")\\n for name, lineno, *type in attr_list:\\n desc = get_description(lines, lineno)\\n if type:\\n attrs[name] = type[0], desc # Assignment with type annotation wins.\\n elif name not in attrs:\\n attrs[name] = None, desc\\n return attrs\",\n \"def get_attributes(cls):\\r\\n return [Attribute('size', '20'),\\r\\n Attribute('label', ''), ]\",\n \"def get_attributes(self):\\n\\n endpoint = self._get_api_endpoint() + '/attributes'\\n results = self.tq.get(endpoint, withp='attribute')\\n if 'data' not in results:\\n return {}\\n\\n return results['data']\\n # tr = {}\\n # for attribute in results['data']:\\n # tr[attribute['attribute']['name']] = attribute['value']\\n # return tr\",\n \"def getDict(self):\\n res = {}\\n for attr, value in self.__dict__.iteritems():\\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\\n res[attr] = value\\n elif isinstance(attr, datetime.datetime):\\n res[attr] = value.isoformat('-')\\n \\n return res\",\n \"def to_dict(\\n self, attributes: Sequence[str] = (\\n 'demand_instruments', 'supply_instruments', 'inverse_covariance_matrix',\\n 'expected_xi_by_theta_jacobian', 'expected_omega_by_theta_jacobian', 'expected_prices',\\n 'expected_shares', 'computation_time', 'draws', 'fp_converged', 'fp_iterations',\\n 'contraction_evaluations'\\n )) -> dict:\\n return {k: getattr(self, k) for k in attributes}\",\n \"def category_attributes_types(categories, db_info, connection):\\n attributes = {}\\n for cat in categories:\\n attributes[cat] = {}\\n category_info = api_category_info(cat, db_info, connection)\\n\\n attr = {}\\n for a in category_info.get(\\\"attributes\\\"):\\n for key in a:\\n attr[key] = a[key]\\n\\n attributes[cat][\\\"attributes\\\"] = {k: d for d, k in attr.items()}\\n\\n types = category_info.get(\\\"types\\\")\\n attributes[cat][\\\"types\\\"] = {\\n attr.get(a): types.get(a) for a in types}\\n\\n attributes[cat][\\\"dialogs\\\"] = category_info.get(\\\"dialogs\\\")\\n\\n return attributes\",\n \"def attributes(self):\\n _attrs = [\\\"label\\\"]\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs\",\n \"def attributes(self):\\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }\",\n \"def attributes(self, *args):\\n kwargs = {}\\n if args:\\n kwargs[\\\"attributenames\\\"] = args\\n\\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\\n\\n # parse contennt looking for all attributes\\n attributes = []\\n for line in r.text.splitlines():\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.name)=(.*)\\\", line)\\n if r:\\n name = r.groups()[1]\\n attributes.append([name, None])\\n continue # next line\\n\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.value)=(.*)\\\", line)\\n if r:\\n value = r.groups()[1]\\n # last name parsed is where it has to\\n # be stacked\\n if attributes[-1][1] == None:\\n attributes[-1][1] = value\\n if isinstance(attributes[-1][1], list):\\n attributes[-1][1].append(value)\\n else:\\n # cast to list\\n attributes[-1].append([attributes[-1][1], value])\\n\\n return dict([(item[0], item[1]) for item in attributes])\",\n \"def describe(self):\\r\\n return dict((field.name, dict(\\r\\n id=field.name,\\r\\n name=field.label,\\r\\n validators=ValidatorSerializer(\\r\\n field.requires if isSequenceType(field.requires) else [field.requires])(),\\r\\n comment=field.comment,\\r\\n readable=field.readable,\\r\\n writable=field.writable,\\r\\n type=getattr(field, 'wtype',\\r\\n field.type.type if isinstance(field.type, SQLCustomType) else field.type.split('(')[0]),\\r\\n # w2pwidget=field.widget,\\r\\n )) for field in self.descibe_columns)\",\n \"def attributes(self):\\n return dict(self.__attributes)\",\n \"def attribute_to_dict(attr: onnx.AttributeProto) -> Dict:\\n ret = {}\\n for a in attr:\\n value = get_attribute_value(a)\\n if isinstance(value, bytes):\\n value = str(value, 'utf-8')\\n ret[a.name] = value\\n return ret\",\n \"def process_attrs(attrs):\\n if attrs.getLength() == 0:\\n return {}\\n tmp_dict = {}\\n for name in attrs.getNames():\\n tmp_dict[name] = attrs.getValue(name)\\n return tmp_dict\",\n \"def _get_attribute_dict(self, attributes, classname=None):\\n if attributes and isinstance(attributes, six.string_types):\\n return {\\n 'class': attributes\\n }\\n if not attributes:\\n attributes = {}\\n if not classname:\\n classname = self.DEFAULT_CLASS_NAME\\n attributes.setdefault('class', classname)\\n return attributes\",\n \"def _parse_attr(self, attr_proto):\\n attrs = {}\\n for a in attr_proto:\\n for f in ['f', 'i', 's']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['floats', 'ints', 'strings']:\\n if list(getattr(a, f)):\\n assert a.name not in attrs, \\\"Only one type of attr is allowed\\\"\\n attrs[a.name] = tuple(getattr(a, f))\\n for f in ['t', 'g']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['tensors', 'graphs']:\\n if list(getattr(a, f)):\\n raise NotImplementedError(\\\"Filed {} is not supported in mxnet.\\\".format(f))\\n if a.name not in attrs:\\n raise ValueError(\\\"Cannot parse attribute: \\\\n{}\\\\n.\\\".format(a))\\n return attrs\",\n \"def attrs_to_dict(self, attrs):\\n return {k: v for k, v in attrs}\",\n \"def attributes(self):\\n _attrs = []\\n if self.name:\\n _attrs.append(\\\"name\\\")\\n if self.label:\\n _attrs.append(\\\"label\\\")\\n if self.confidence:\\n _attrs.append(\\\"confidence\\\")\\n if self.index:\\n _attrs.append(\\\"index\\\")\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs + [\\\"points\\\"]\",\n \"def ATTRIBUTE():\\n return \\\"author\\\", \\\"title\\\", \\\"publisher\\\", \\\"shelf\\\", \\\"category\\\", \\\"subject\\\"\",\n \"def _get_attrs_symbols():\\n return {\\n 'True', 'False', 'None', # those are identifiers in Python 2.7\\n 'self',\\n 'parent',\\n 'id',\\n 'uid',\\n 'context',\\n 'context_today',\\n 'active_id',\\n 'active_ids',\\n 'allowed_company_ids',\\n 'current_company_id',\\n 'active_model',\\n 'time',\\n 'datetime',\\n 'relativedelta',\\n 'current_date',\\n 'abs',\\n 'len',\\n 'bool',\\n 'float',\\n 'str',\\n 'unicode',\\n }\",\n \"def capability_attributes(self) -> Mapping[str, Any] | None:\\n if state_class := self.state_class:\\n return {ATTR_STATE_CLASS: state_class}\\n\\n if options := self.options:\\n return {ATTR_OPTIONS: options}\\n\\n return None\",\n \"def attributes(self) -> Optional[Mapping[str, Sequence[str]]]:\\n return pulumi.get(self, \\\"attributes\\\")\",\n \"def _describe(self) -> Dict[str, Any]:\",\n \"def get_class_attributes(cls) -> Dict[str, Tuple[Any, str]]:\\n try:\\n source = inspect.getsource(cls.__init__) or \\\"\\\"\\n if not source:\\n return {}\\n except TypeError:\\n return {}\\n source = utils.join(source.split(\\\"\\\\n\\\"))\\n node = ast.parse(source)\\n\\n attr_list: List[Tuple] = []\\n module = importlib.import_module(cls.__module__)\\n globals = dict(inspect.getmembers(module))\\n for x in ast.walk(node):\\n if isinstance(x, _ast.AnnAssign):\\n attr, lineno, type_str = parse_annotation_assign(x)\\n type = eval(type_str, globals)\\n attr_list.append((attr, lineno, type))\\n if isinstance(x, _ast.Attribute) and isinstance(x.ctx, _ast.Store):\\n attr_list.append(parse_attribute_with_lineno(x))\\n attr_list = sorted(attr_list, key=lambda x: x[1])\\n\\n attrs: Dict[str, Tuple[Any, str]] = {}\\n lines = source.split(\\\"\\\\n\\\")\\n for name, lineno, *type in attr_list:\\n if name.startswith(\\\"self.\\\"):\\n name = name[5:]\\n desc = get_description(lines, lineno)\\n if type:\\n attrs[name] = type[0], desc # Assignment with type annotation wins.\\n elif name not in attrs:\\n attrs[name] = None, desc\\n return attrs\",\n \"def state_attributes(self) -> dict[str, StateType]:\\n attributes: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}\\n\\n if self.gps is not None:\\n attributes[ATTR_LATITUDE] = self.gps[0]\\n attributes[ATTR_LONGITUDE] = self.gps[1]\\n attributes[ATTR_GPS_ACCURACY] = self.gps_accuracy\\n\\n if self.battery is not None:\\n attributes[ATTR_BATTERY] = self.battery\\n\\n return attributes\",\n \"def to_dict(self):\\n d = {}\\n i = 0\\n for entry in self.entries:\\n d[i] = {}\\n attributes = self.get_attribute_list()\\n print (attributes)\\n for data in attributes:\\n d[i][data] = entry.__getattribute__(data)\\n i = i + 1\\n return d\",\n \"def device_state_attributes(self):\\n attrs = {}\\n\\n attrs[ATTR_ATTRIBUTION] = ATTRIBUTION\\n attrs[\\\"brand\\\"] = DEFAULT_BRAND\\n attrs[ATTR_CAMERA_TYPE] = self._camera_type\\n attrs[\\\"friendly_name\\\"] = self._name\\n\\n return attrs\",\n \"def types(self) -> Dict[str, str]:\\n return {name: self.hyperparams[name][0] for name in self.names()}\",\n \"def thrift_type_to_dict(obj: Any) -> Dict[str, Any]:\\n return {\\n camel_to_snake_case(attr): getattr(obj, attr)\\n for attr in thrift_attrs(obj)\\n }\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute('size', '20'),\\r\\n Attribute('inline', False),\\r\\n Attribute('label', ''),\\r\\n ]\",\n \"def get_question_name_to_answer_attribute_table(cls):\\n return {\\n value.question_name: attr_name\\n for attr_name, value in cls.__dict__.items()\\n if isinstance(value, answer.BaseAnswer)\\n }\",\n \"def create_descr(self, attr_name):\",\n \"def get_attributes_of_node(core, node):\\n attributes = {}\\n for attribute in core.get_attribute_names(node):\\n attributes[attribute] = core.get_attribute(node,attribute)\\n return attributes\",\n \"def get_attributes(self, shape):\\n attributes = {}\\n identifier_names = [i.name for i in self.identifiers]\\n\\n for name, member in shape.members.items():\\n snake_cased = xform_name(name)\\n if snake_cased in identifier_names:\\n # Skip identifiers, these are set through other means\\n continue\\n snake_cased = self._get_name(\\n 'attribute', snake_cased, snake_case=False\\n )\\n attributes[snake_cased] = (name, member)\\n\\n return attributes\",\n \"def info(self):\\n return (self.kind, self.value)\",\n \"def get_attributes(self):\\n\\t\\treturn dict(list(self.__element.items()))\",\n \"def attributes(self):\\n return {'op_type': self.__class__.__name__, 'arguments': {}}\",\n \"def getAttributeDict(self):\\n result = {}\\n dict = self.getDict()\\n for key in dict.keys():\\n value = dict.get(key)\\n if value.__class__.__name__ != 'SpecialDict':\\n result[key] = value\\n return result\",\n \"def as_dict(self):\\n result = {}\\n for attr in self.__attr:\\n result[attr] = getattr(self, attr)\\n return result\",\n \"def dict_by_attr(collection, attrname, value_attrname=None):\\n mapping = {}\\n for item in collection:\\n if callable(attrname):\\n key = attrname(item)\\n else:\\n key = extended_getattr(item, attrname)\\n if value_attrname:\\n item = extended_getattr(item, value_attrname)\\n mapping[key] = mapping.get(key, []) + [item]\\n return mapping\",\n \"def _process_attrs(attrs):\\n new_attrs = OrderedDict()\\n for attr in attrs:\\n col = attr\\n if isinstance(attr, tuple):\\n col, attr = attr\\n # special cases\\n if attr == 'class_name':\\n attr = '__class__.__name__'\\n if attr == 'repr':\\n attr = repr\\n new_attrs[col] = attr\\n\\n return new_attrs\",\n \"def __get_attr_format (self, attrs):\\r\\n format = { \\r\\n 'editor': None,\\r\\n 'min': None,\\r\\n 'max': None,\\r\\n 'step': None,\\r\\n 'subtype': None,\\r\\n 'flags': None,\\r\\n 'enums': None\\r\\n }\\r\\n\\r\\n for attr in attrs: \\r\\n attr_type = attr[\\\"type\\\"]\\r\\n if \\\"editor\\\" == attr_type:\\r\\n format['editor'] = attr[\\\"value\\\"] \\r\\n if \\\"min\\\" == attr_type:\\r\\n format['min'] = attr[\\\"value\\\"] \\r\\n if \\\"max\\\" == attr_type:\\r\\n format['max'] = attr[\\\"value\\\"] \\r\\n if \\\"default\\\" == attr_type:\\r\\n format['default'] = attr[\\\"value\\\"] \\r\\n if \\\"step\\\" == attr_type:\\r\\n format['step'] = attr[\\\"value\\\"]\\r\\n if \\\"subtype\\\" == attr_type:\\r\\n format['subtype'] = attr[\\\"value\\\"]\\r\\n if \\\"flags\\\" == attr_type:\\r\\n format['flags'] = attr['value']\\r\\n if \\\"enums\\\" == attr_type:\\r\\n format['enums'] = attr['value']\\r\\n\\r\\n return format\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute('height', None),\\r\\n Attribute('width', None),\\r\\n Attribute('parts', None),\\r\\n Attribute('analyses', None),\\r\\n Attribute('initial_value', None),\\r\\n Attribute('submit_analyses', None),\\r\\n Attribute('label', ''),\\r\\n ]\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(map(\\n lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x,\\n value\\n ))\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\") else item,\\n value.items()\\n ))\\n else:\\n result[attr] = value\\n if issubclass(UserAttributeInfo, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def expected_types_and_attributes(self):\\n return {self.configs[\\\"entry_type\\\"]: set()}\",\n \"def attribute_dict(self):\\n return self.__attribute_dict\",\n \"def to_dict(cls):\\n result = {}\\n for attr_name in _.reject(set(dir(cls)), lambda x: x.startswith('_')):\\n attr = getattr(cls, attr_name)\\n if _.is_list(attr) or _.is_string(attr):\\n result[attr_name] = attr\\n return result\",\n \"def readTypes(self):\\r\\n types = {}\\r\\n for m in re.finditer(\\\"TYPE (.*) = (.*);\\\", self.data):\\r\\n typename, typetype = m.groups() \\r\\n if typetype in self.SIMPLETYPES:\\r\\n types[typename] = typetype\\r\\n else:\\r\\n types[typename] = \\\"#\\\" + typetype\\r\\n \\r\\n return types\",\n \"def as_dict(self):\\n return {c.key: getattr(self, c.key)\\n for c in inspect(self).mapper.column_attrs}\",\n \"def get_attributes(cls):\\r\\n return [\\r\\n Attribute(\\\"show_correctness\\\", \\\"always\\\"),\\r\\n Attribute(\\\"submitted_message\\\", \\\"Answer received.\\\"),\\r\\n Attribute(\\\"label\\\", \\\"\\\"),\\r\\n ]\",\n \"def GetAttributes(self, type):\\n if type == ArrayAssociation.FIELD:\\n return DataSetAttributes(self.VTKObject.GetFieldData(), self, type)\\n return DataSetAttributes(self.VTKObject.GetAttributes(type), self, type)\",\n \"def _get_var_attrs(var):\\n\\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\\n 'missing_value': -9999, 'height': '',\\n 'standard_name': '', 'group_name': '',\\n 'serial_number': ''}\\n\\n generic_dict.update(attrs_dict[var])\\n return generic_dict\",\n \"def tags_dict(self):\\n return ({'name': 'tag', 'attrs': {'k': k, 'v': v}} for k, v in self.tags.items())\",\n \"def extract_attrs(attr_string):\\n attributes = {}\\n for name, val in FIND_ATTRS.findall(attr_string):\\n val = (\\n val.replace(\\\"<\\\", \\\"<\\\")\\n .replace(\\\">\\\", \\\">\\\")\\n .replace(\\\""\\\", '\\\"')\\n .replace(\\\"&\\\", \\\"&\\\")\\n )\\n attributes[name] = val\\n return attributes\",\n \"def attrs(self):\\n return [name for name in self.traits() if self.trait_metadata(name, \\\"attr\\\")]\",\n \"def attrs(self):\\n return [name for name in self.traits() if self.trait_metadata(name, \\\"attr\\\")]\",\n \"def get_attribute_counts(self):\\n counts = defaultdict(int)\\n for attr in self:\\n counts[attr.name] += 1\\n\\n return dict(counts)\",\n \"def record_dict(self):\\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}\",\n \"def attributes(self):\\n return [self._ELE_ATTR]\",\n \"def parse_attributes(self, attr):\\n result = {}\\n annotations = []\\n # Sanitize and split attributes up\\n split_attr = attr.strip(' \\\\t\\\\n;').split(';')\\n for pair in split_attr:\\n splitpair = pair.split('=')\\n if len(splitpair) != 2:\\n continue\\n if splitpair[0] == \\\"ID\\\":\\n result['identifier'] = splitpair[1]\\n elif splitpair[0] == \\\"Name\\\":\\n result['name'] = splitpair[1]\\n elif splitpair[0] == \\\"Parent\\\":\\n result['parent_id'] = splitpair[1]\\n elif splitpair[0] == \\\"Dbxref\\\" or splitpair[0] == \\\"Ontology_term\\\":\\n annotations.append(splitpair)\\n # Make sure we found an ID\\n if \\\"identifier\\\" not in result:\\n return {}\\n # Add annotations if we found any\\n if annotations:\\n result[\\\"annotations\\\"] = annotations\\n return result\",\n \"def whoAreYou(self):\\n tempDict = {}\\n tempDict['Class'] = '{0:15}'.format(self.__class__.__name__) +' from '+' '.join([str(base) for base in self.__class__.__bases__])\\n tempDict['Type' ] = self.type\\n tempDict['Name' ] = self.name\\n return tempDict\",\n \"def device_state_attributes(self):\\n if self.airly.data_available:\\n if self.type == ATTR_CAQI_DESCRIPTION:\\n self._attrs[ATTR_CAQI_ADVICE] = (self.airly.data\\n [ATTR_CAQI_ADVICE])\\n if self.type == ATTR_CAQI:\\n self._attrs[ATTR_CAQI_LEVEL] = self.airly.data[ATTR_CAQI_LEVEL]\\n if self.type == ATTR_PM25:\\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM25_LIMIT]\\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\\n [ATTR_PM25_PERCENT]))\\n if self.type == ATTR_PM10:\\n self._attrs[ATTR_LIMIT] = self.airly.data[ATTR_PM10_LIMIT]\\n self._attrs[ATTR_PERCENT] = (round(self.airly.data\\n [ATTR_PM10_PERCENT]))\\n return self._attrs\",\n \"def values(self):\\n return {n: getattr(self, n) for n in self._hparam_types.keys()}\",\n \"def _metadata_map():\\n return {\\n 'date_added': 'dateAdded',\\n 'dns_active': 'dnsActive',\\n 'last_modified': 'lastModified',\\n 'private_flag': 'privateFlag',\\n 'whois_active': 'whoisActive',\\n 'key_name': 'Key Name',\\n 'value_type': 'Value Type',\\n 'value_name': 'Value Name',\\n 'block': 'Block',\\n 'mutex': 'Mutex',\\n 'as_number': 'AS Number',\\n 'hostname': 'hostName',\\n }\",\n \"def getDataAttributes(self):\\n asRet = [];\\n asAttrs = dir(self);\\n for sAttr in asAttrs:\\n if sAttr[0] == '_' or sAttr[0] == 'k':\\n continue;\\n if sAttr in self.kasInternalAttributes:\\n continue;\\n oValue = getattr(self, sAttr);\\n if callable(oValue):\\n continue;\\n asRet.append(sAttr);\\n return asRet;\",\n \"def get_attributes(self):\\n _attributes = {\\n 'function_id': self.function_id,\\n 'hardware_id': self.hardware_id,\\n 'mode_id': self.mode_id,\\n 'critical_item': self.critical_item,\\n 'description': self.description,\\n 'design_provisions': self.design_provisions,\\n 'detection_method': self.detection_method,\\n 'effect_end': self.effect_end,\\n 'effect_local': self.effect_local,\\n 'effect_next': self.effect_next,\\n 'effect_probability': self.effect_probability,\\n 'hazard_rate_source': self.hazard_rate_source,\\n 'isolation_method': self.isolation_method,\\n 'mission': self.mission,\\n 'mission_phase': self.mission_phase,\\n 'mode_criticality': self.mode_criticality,\\n 'mode_hazard_rate': self.mode_hazard_rate,\\n 'mode_op_time': self.mode_op_time,\\n 'mode_probability': self.mode_probability,\\n 'mode_ratio': self.mode_ratio,\\n 'operator_actions': self.operator_actions,\\n 'other_indications': self.other_indications,\\n 'remarks': self.remarks,\\n 'rpn_severity': self.rpn_severity,\\n 'rpn_severity_new': self.rpn_severity_new,\\n 'severity_class': self.severity_class,\\n 'single_point': self.single_point,\\n 'type_id': self.type_id\\n }\\n\\n return _attributes\",\n \"def as_attrdict(self) -> AttributeDict:\\n return AttributeDict(\\n {\\n x: Configuration(v).as_attrdict() if isinstance(v, Mapping) else v\\n for x, v in self.items(levels=1)\\n }\\n )\",\n \"def to_dict(self):\\n dct = dict(zip(self._fields, self))\\n dct['type'] = type(self).__name__\\n return dct\",\n \"def getAttributeInfo(self, atName):\\n try:\\n dataType, mandatoryCode = self.__getAttributeInfo(atName)\\n return dataType, mandatoryCode\\n except Exception:\\n return None, None\",\n \"def attributes(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"attributes\\\")\",\n \"def keys(self):\\n return list(s.name.lower() for s in self.attributes)\",\n \"def get_attributes(self):\\n _attributes = {\\n 'measurement_id': self.measurement_id,\\n 'code': self.code,\\n 'description': self.description,\\n 'measurement_type': self.measurement_type\\n }\\n\\n return _attributes\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def arm_to_dict(arm: Arm) -> Dict[str, Any]:\\n return {\\n \\\"__type\\\": arm.__class__.__name__,\\n \\\"parameters\\\": arm.parameters,\\n \\\"name\\\": arm._name,\\n }\",\n \"def to_dictionary(self):\\n attributes = [\\\"id\\\", \\\"size\\\", \\\"x\\\", \\\"y\\\"]\\n return {key: getattr(self, key) for key in attributes}\",\n \"def dict_to_label_attr_map(input_dict):\\n return {key+':': [key, type(val)] for key, val in input_dict.items()}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67937475","0.6673932","0.6665609","0.6616133","0.6480975","0.645589","0.6419423","0.6373563","0.63325965","0.62991995","0.62763846","0.6275178","0.62591964","0.6234089","0.6209144","0.61401665","0.61152714","0.61013734","0.60815376","0.6018292","0.59895635","0.5982113","0.59789133","0.5950351","0.59355","0.59124696","0.58944845","0.58701","0.5869577","0.5836679","0.58033514","0.58024967","0.579765","0.57630837","0.57521486","0.5737469","0.5722125","0.57093596","0.5701787","0.5700318","0.5699739","0.56730247","0.56565213","0.5646546","0.5644311","0.56236094","0.5603082","0.56012475","0.5582454","0.5580904","0.55778646","0.5573508","0.55695975","0.55686903","0.55556273","0.5554678","0.55520004","0.5545998","0.554533","0.5542943","0.5539966","0.5539763","0.5535748","0.5524026","0.55183625","0.55091023","0.5503433","0.54976785","0.54903495","0.5490037","0.5473721","0.54736143","0.54734737","0.545725","0.5456306","0.5452801","0.54403377","0.54363036","0.54363036","0.54306144","0.54301465","0.54251486","0.5423411","0.5421412","0.5419505","0.5417112","0.54160124","0.5413124","0.54117006","0.5410065","0.5409895","0.5408909","0.54056025","0.53980744","0.5390367","0.53766954","0.53766954","0.537108","0.5366387","0.53611696"],"string":"[\n \"0.67937475\",\n \"0.6673932\",\n \"0.6665609\",\n \"0.6616133\",\n \"0.6480975\",\n \"0.645589\",\n \"0.6419423\",\n \"0.6373563\",\n \"0.63325965\",\n \"0.62991995\",\n \"0.62763846\",\n \"0.6275178\",\n \"0.62591964\",\n \"0.6234089\",\n \"0.6209144\",\n \"0.61401665\",\n \"0.61152714\",\n \"0.61013734\",\n \"0.60815376\",\n \"0.6018292\",\n \"0.59895635\",\n \"0.5982113\",\n \"0.59789133\",\n \"0.5950351\",\n \"0.59355\",\n \"0.59124696\",\n \"0.58944845\",\n \"0.58701\",\n \"0.5869577\",\n \"0.5836679\",\n \"0.58033514\",\n \"0.58024967\",\n \"0.579765\",\n \"0.57630837\",\n \"0.57521486\",\n \"0.5737469\",\n \"0.5722125\",\n \"0.57093596\",\n \"0.5701787\",\n \"0.5700318\",\n \"0.5699739\",\n \"0.56730247\",\n \"0.56565213\",\n \"0.5646546\",\n \"0.5644311\",\n \"0.56236094\",\n \"0.5603082\",\n \"0.56012475\",\n \"0.5582454\",\n \"0.5580904\",\n \"0.55778646\",\n \"0.5573508\",\n \"0.55695975\",\n \"0.55686903\",\n \"0.55556273\",\n \"0.5554678\",\n \"0.55520004\",\n \"0.5545998\",\n \"0.554533\",\n \"0.5542943\",\n \"0.5539966\",\n \"0.5539763\",\n \"0.5535748\",\n \"0.5524026\",\n \"0.55183625\",\n \"0.55091023\",\n \"0.5503433\",\n \"0.54976785\",\n \"0.54903495\",\n \"0.5490037\",\n \"0.5473721\",\n \"0.54736143\",\n \"0.54734737\",\n \"0.545725\",\n \"0.5456306\",\n \"0.5452801\",\n \"0.54403377\",\n \"0.54363036\",\n \"0.54363036\",\n \"0.54306144\",\n \"0.54301465\",\n \"0.54251486\",\n \"0.5423411\",\n \"0.5421412\",\n \"0.5419505\",\n \"0.5417112\",\n \"0.54160124\",\n \"0.5413124\",\n \"0.54117006\",\n \"0.5410065\",\n \"0.5409895\",\n \"0.5408909\",\n \"0.54056025\",\n \"0.53980744\",\n \"0.5390367\",\n \"0.53766954\",\n \"0.53766954\",\n \"0.537108\",\n \"0.5366387\",\n \"0.53611696\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57462233"},"document_rank":{"kind":"string","value":"35"}}},{"rowIdx":76093,"cells":{"query":{"kind":"string","value":"Time complexity > O(n) Space complexity > O(1)"},"document":{"kind":"string","value":"def subtract_product_and_sum(n):\n product = 1\n addition = 0\n\n while n > 0:\n element = n % 10\n n = n // 10\n\n product *= element\n addition += element\n \n return product - addition"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def time_complexities():\n return \"Best Case: O(n), Average Case: O(n), Worst Case: O(n)\"","def sem_repetidos (l): # n = len(l), O(n^2)\n resultado = []\n for e in l: # n vezes\n if not e in resultado: # 1 + O(n)\n resultado.append(e) # O(1)\n return resultado","def fn(i):\n if i == 2*n-1 or ans[i] and fn(i+1): return True \n for x in reversed(range(1, n+1)): \n if x not in ans: \n ii = x if x > 1 else 0 \n if i+ii < 2*n-1 and ans[i] == ans[i+ii] == 0: \n ans[i] = ans[i+ii] = x\n if fn(i+1): return True \n ans[i] = ans[i+ii] = 0","def solution(number): # O(N)\n m = {\n 0: 0,\n 1: 1\n } # O(1)\n\n for i in range(2, number + 1): # O(N)\n m[i] = m[i - 1] + m[i - 2] # O(1)\n\n return m[number] # O(1)","def twentyone():\r\n \r\n notamicable = []\r\n isamicable = []\r\n \r\n for i in range(10000):\r\n if i not in notamicable and i not in isamicable:\r\n a = i\r\n b = amicable(findDivisors(a))\r\n c = amicable(findDivisors(b))\r\n if a == c and not a == b:\r\n isamicable.append(a)\r\n isamicable.append(b)\r\n else:\r\n notamicable.append(a)\r\n notamicable.append(b)\r\n \r\n print isamicable\r\n t = 0\r\n for v in isamicable:\r\n t += v\r\n return t","def solution(A):\n \n cars = 0\n ones = 0\n\n for i in range(len(A), 0, -1):\n\n if A[i-1] == 1:\n ones += 1\n else:\n cars += ones\n\n return (-1 if cars > 1000000000 else cars)","def fn(i):\n if i == 0: return 1 # boundary condition \n ans = 0\n for k in range(1, N+1): \n if k not in seen and (k%i == 0 or i%k == 0): \n seen.add(k)\n ans += fn(i-1)\n seen.remove(k)\n return ans","def twoSum(self, nums: List[int], target: int) -> List[int]:\n #computational complexity: O(N) since we iterate through n elements only once\n #space comlexity: O(N) since we need to store n elements in the array\n\n #(0) use hashtable to store the number and its index.\n hashTable={}\n #(1) iterating through all the itmes\n for i in range(len(nums)):\n complement = target - nums[i]\n #(2) check if the complement is in the hashTable. If not, put it into the hashtable\n if complement in hashTable:\n return [hashTable[complement],i]\n else:\n hashTable[nums[i]] = i","def performance():\n\tn = 1024\n\twhile n < 5000000: \n\t\tsorted = range(n)\n\t\tnow = time()\n\n\t\t# Code whose performance is to be evalutated\n\t\tbs_contains(sorted, -1)\n\n\t\tdone = time()\n\n\t\tprint n, (done-now)*10000\n\t\tn *= 2","def schrage_nlogn(data):\n N = data.copy()\n for i in range(len(data)):\n N[i] = (N[i][0], N[i])\n heapq.heapify(N)\n \"\"\"\"\n mozna to zaltwic przy wczytaniu danych nie wplywa na zloznosc samego algorytmu\n \n N to tablica tablica krotek takich że (r , [r, p,q]), (r1, [r1 ,p1 , q1]) ........\n heapq sortuje po pierwszym elemncie dlatego tak\n \n G analogicznie z tym że sortowane jest malejaco po q więc G = [(q, [r, p ,q ]), (q1, [r1, p1, q1]) .......... ] \n \"\"\"\n G = []\n Pi = []\n t = N[0][0]\n start = timer()\n while len(G) != 0 or len(N) != 0:\n while len(N) != 0 and Schrage.save_min(N) <= t:\n e = heapq.heappop(N)\n heapq.heappush(G, (-e[1][2], e[1])) # O(log n)\n if len(G) != 0:\n e = heapq.heappop(G) # O(log n)\n Pi.append(e[1]) # O(1)\n t = t + e[1][1]\n else:\n t = N[0][0] # O(1)\n end = timer()\n executionTime = end - start\n return Pi, executionTime","def fn(k, i, j):\n if not (0 <= i < N and 0 <= j < N): return 0\n if k == 0: return 1 \n return 1/8*sum(fn(k-1, i+ii, j+jj) for ii, jj in ((-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)))","def fn(i):\n if i == len(nums): ans.append(nums.copy())\n seen = set()\n for k in range(i, len(nums)):\n if nums[k] not in seen:\n seen.add(nums[k])\n nums[i], nums[k] = nums[k], nums[i]\n fn(i+1)\n nums[i], nums[k] = nums[k], nums[i]","def fn(i, j, mv):\n if not (0 <= i < m and 0 <= j < n): return 1 \n if mv == 0: return 0\n return (fn(i-1, j, mv-1) + fn(i, j-1, mv-1) + fn(i, j+1, mv-1) + fn(i+1, j, mv-1)) % 1_000_000_007","def solution(A):\n \"\"\"method 2 n**2\n east=[] #0\n west=[] #1\n for i in range(len(A)):\n if A[i] == 0:\n east.append(i)\n else:\n west.append(i)\n\n result = 0\n for e in east:\n count = 0\n for j in range(len(west)):\n if e > west[j]:\n continue\n if e < west[j]:\n count = len(west) - j\n result += count\n #print(e, count)\n break\n return result\n \"\"\"\n east=[] #0\n west=[] #1\n l = len(A)\n for i in range(len(A)):\n if A[i] == 0:\n east.append(i)\n else:\n west.append(i)\n\n result = {}\n for i in range(len(east)):\n e = east[i]\n if i == 0:\n result[e] = l - e - len(east)\n if i != 0:\n result[e] = result[east[i-1]] - (e - east[i-1]-1)\n\n #print(result)\n s = sum(result.values())\n if s > 1000000000:\n return -1\n return s","def solution(s):","def gn(i, j, k):\n if i+j < n: return anti[i+j][i+k] - anti[i+j][i]\n return anti[i+j][n-1-j+k] - anti[i+j][n-1-j]","def complexity(self):\n raise NotImplementedError()","def naive(p, t):\n occurences = []\n for i in range(len(t) - len(p) + 1):\n match = True\n for j in range(len(p)):\n if t[i + j] != p[j]:\n match = False\n break\n if match:\n occurences.append(i)\n return occurences","def Efficient(self): #CLEANS THE INEFFICIENT PATH AND MAKES IT EFFICIENT\n self.efficient=[]\n for i in range(len(self.Path)):\n #print(self.efficient)\n self.efficient.append(self.Path[i])\n if self.Path[i] in self.efficient[:-1]:\n #print(self.efficient)\n ind=self.efficient.index(self.Path[i])\n self.efficient=self.efficient[:ind+1]\n #n+=1\n return self.efficient #Creates the most efficient path ","def am(n):\r\n for i in range(1,n+1):\r\n if i not in d1.keys() :\r\n d1[i] = d1[i-1] + (i*((-1)**i))\r\n# print(d1)\r\n else:\r\n pass\r\n return d1[n]","def J (self, n):","def fn(i, j):\n if not (0 <= i < n and 0 <= j < n): return inf\n if i == 0: return A[i][j]\n return min(fn(i-1, j-1), fn(i-1, j), fn(i-1, j+1)) + A[i][j]","def method2():\n n = 1000\n s = 0\n multiples = [3,5]\n total = []\n\n for m in multiples:\n total.append(0)\n\n minValue = 0\n while(minValue < 1000):\n minValue = 1000\n minPosition = 0\n for i, v in enumerate(total):\n if v < minValue:\n minValue = v\n minPosition = i\n\n temp = total[minPosition] + multiples[minPosition]\n\n if(temp < 1000) and (temp not in total):\n s += temp\n\n total[minPosition] = temp\n\n return s","def compute(n):\n if n == 1:\n return 1\n else:\n i = find_i(n)\n return 2 * compute(n - i) + 2 ** i - 1","def solution(A): # A not necessarily sorted and may have repeated elements\n \n mid = len(A)/2\n A1=A[0:int(mid)]\n A2=A[int(mid):]\n out = find_arrays(A1,A2)\n return out\n pass","def I (self, n):","def complexity(s, **kwargs):\n num, den = 1, 1\n for k in range(1, len(s)):\n k4 = 4**k # For DNA\n num += min(len(set(s[i:i+k] for i in range(len(s) - k + 1))), k4)\n den += min(len(s) - k + 1, k4)\n return num / den","def solution(A):\n # 1. corner case\n #if len(A) == 2:\n # if A[0] <= A[1]:\n # return 0\n # return 1\n\n # 2. find min avg of slices O(N^2)\n avg_min = 100000\n P = 0\n Q = 1\n idx = 0\n for i in range(len(A)):\n s = A[i]\n P = i\n for j in range(i+1, min(i+3,len(A))):\n s += A[j]\n Q = j\n if s / (Q - P + 1) < avg_min:\n avg_min = s / (Q - P + 1)\n idx = P\n #print(P,Q, avg_min)\n return idx","def solution(n: int = 28123) -> int:\n\n nums = range(1, n+1)\n abundant = list(filter(is_abundant, nums))\n abundant_sums = set(all_sums(abundant, n))\n fit = set(nums) - abundant_sums\n return fit","def sol(n, mem):\n if mem[n] != -1:\n return mem[n]\n \n mem[n] = 0\n for i in range(2, n+1):\n mem[n]+=sol(n-i, mem)*sol(i-2, mem)\n \n return mem[n]","def singleNonDuplicate(self, nums):\n \n #Every element appears exactly twice, except for one\n #O(log n) time\n #O(1) space\n #0 1 2 3 4\n #1 3 3 5 5 \n \n \n #0 1 2 3 4 5 6 \n #1 3 3 5 5 7 7\n \n \n #O log(n) solution \n #index = [0,....n-1]\n n = len(nums)\n \n low=0\n high=n-1\n \n if high == 1:\n return nums[high]\n \n \n while low<high:\n mid=(low+high)//2\n \n if (mid%2==1 and nums[mid-1]==nums[mid]) or (mid%2 == 0 and nums[mid] == nums[mid + 1]):\n low=mid+1\n else:\n high=mid\n return nums[low]","def threeSum(self, nums):\n # sort\n nums.sort()\n length = len(nums)\n result = []\n # get unique list\n unique = set()\n for i in xrange(length):\n # if nums[i] exist in unique\n if nums[i] in unique:\n continue\n else:\n unique.add(nums[i])\n j = i + 1\n k = length - 1\n # get unique nums[j]\n unique_local = set()\n while k > j:\n unique_local.add(nums[j])\n # when need j+=1: sign = 1\n sign = 0\n if (nums[j] + nums[k]) < -nums[i]:\n j += 1\n sign = 1\n elif (nums[j] + nums[k]) > -nums[i]:\n k -= 1\n else: #nums[j] + nums[k] == -nums[i]\n lst = [nums[i], nums[j], nums[k]]\n result.append(lst)\n j += 1\n k -= 1\n sign = 1\n if sign == 1:\n # if nums[j] in unique_local: j++\n while j < length and nums[j] in unique_local:\n j += 1\n return result","def algorithm_p(n):\n partition = [0]*n\n last_replaced = 0\n partition[last_replaced] = n\n idx = last_replaced - (n == 1)\n\n while True:\n yield partition[0:last_replaced + 1]\n if idx < 0:\n return\n if partition[idx] == 2:\n partition[idx] = 1\n idx -= 1\n last_replaced += 1\n partition[last_replaced] = 1\n else:\n replacement = partition[idx] - 1\n partition[idx] = replacement\n n = last_replaced - idx + 1\n last_replaced = idx + 1\n while n > replacement:\n partition[last_replaced] = replacement\n last_replaced += 1\n n -= replacement\n partition[last_replaced] = n\n idx = last_replaced - (n == 1)","def twoSumFaster(nums, target):\n my_hash = {}\n for a in range(0,len(nums)):\n my_hash[nums[a]] = a\n\n for indice_a in range(0,len(nums) - 1):\n diff = target - nums[indice_a]\n if diff in my_hash:\n for indice_b in range(indice_a + 1, len(nums)):\n if nums[indice_b] == diff:\n return [indice_a, indice_b]","def naive(p, t):\n\toccurence = []\n\tfor i in range(len(t)-len(p) + 1):\n\t\tmatch = True\n\t\tfor j in range(len(p)):\n\t\t\tif not p[j] == t[i+j]:\n\t\t\t\tmatch = False\n\t\t\t\tbreak\n\t\tif match:\n\t\t\toccurence.append(i)\n\treturn occurence","def naive_2mm(p, t):\n\toccurence = []\n\tfor i in range(len(t)-len(p) + 1):\n\t\tmatch = True\n\t\tunmatch = 0\n\t\tfor j in range(len(p)):\n\t\t\tif not p[j] == t[i+j]:\n\t\t\t\tunmatch += 1\n\t\t\t\tif unmatch > 2:\n\t\t\t\t\tmatch = False\n\t\t\t\t\tbreak\n\t\tif match:\n\t\t\toccurence.append(i)\n\treturn occurence","def fn(i, seen=set(), ans=0):\n if i == n: ans += 1\n for j in range(n):\n place = {(\"col\", j), (\"diag\", i-j), (\"anti\", i+j)}\n if not (place & seen): \n seen |= place\n ans = fn(i+1, seen, ans)\n seen -= place \n return ans","def fn(i, seen=set()):\n ans = 0\n if i < len(s): # boundary condition when i == len(s)\n for ii in range(i+1, len(s)+1): \n if s[i:ii] not in seen: \n seen.add(s[i:ii])\n ans = max(ans, 1 + fn(ii, seen))\n seen.remove(s[i:ii])\n return ans","def solution2(nums, K):\n s = 0\n sum_til = []\n for n in nums:\n s += n\n sum_til.append(s)\n\n l = len(nums)\n for i in range(l):\n for j in range(i+1, l):\n sum_ij = sum_til[j] if i == 0 else sum_til[j] - sum_til[i-1]\n if K != 0 and sum_ij % K == 0:\n return True\n if K == 0 and sum_ij == 0:\n return True\n return False","def orderByIncreasingBitCount(n):\n res = [0] # freebie\n biggest = 2**n - 1\n for i in range(1, n):\n for j in range(1, biggest):\n if hamming_weight(j) == i:\n res.append(j)\n res.append(biggest) # another freebie\n return res","def beautifulSubsets(self, nums: List[int], k: int) -> int:\n\n \"\"\"\n queue = deque([([], -1)])\n res = 0\n\n while queue:\n cur, idx = queue.popleft()\n res += 1\n\n for i in range(idx + 1, len(nums)):\n if nums[i] - k in cur or nums[i] + k in cur:\n continue\n\n queue.append((cur + [nums[i]], i))\n\n return res - 1\n \"\"\"\n\n \"\"\"\n # dp0 is the ways that without A[i]\n # dp1 is the ways that with A[i]\n\n count = [Counter() for i in range(k)]\n for n in nums:\n count[n % k][n] += 1\n\n res = 1\n for i in range(k):\n prev, dp0, dp1 = 0, 1, 0\n for n in sorted(count[i]):\n v = pow(2, count[i][n])\n if prev + k == n:\n dp0, dp1 = dp0 + dp1, dp0 * (v - 1)\n else:\n dp0, dp1 = dp0 + dp1, (dp0 + dp1) * (v - 1)\n\n prev = n\n\n res *= dp0 + dp1\n\n return res - 1\n \"\"\"\n\n # Count the frequency of A, and then consider all the arithmetic sequence with difference k.\n # Each arithmetic sequence can be solve as a hourse robber problem.\n # We solve the hourse robber by dp.\n # dp(a) return the result for sequence no bigger than a.\n\n # dp(a)[0] is the ways that without a\n # dp(a)[1] is the ways that with a\n\n # dp(a)[0] = dp(a - k)[0] + dp(a - k)[1]\n # dp(a)[1] = dp(a - k)[0] * (2 ^ count(a) - 1\n\n count = Counter(nums)\n\n def dp(n):\n dp0, dp1 = dp(n - k) if n - k in count else (1, 0)\n return dp0 + dp1, dp0 * (pow(2, count[n]) - 1)\n\n return functools.reduce(operator.mul, (sum(dp(n)) for n in count if not count[n + k])) - 1","def solution():\n i = 1\n\n while True:\n if (\n sorted(str(i))\n == sorted(str(2 * i))\n == sorted(str(3 * i))\n == sorted(str(4 * i))\n == sorted(str(5 * i))\n == sorted(str(6 * i))\n ):\n return i\n\n i += 1","def sum_in_set_linear(array, x):\n\n s = set() \n for i in range(len(array)):\n diff = x - array[i]\n if diff in s:\n return True\n s.add(array[i])\n return False","def fn(i, j):\n if i == len(costs): return 0 # no more houses to paint \n return costs[i][j] + min(fn(i+1, jj) for jj in range(3) if j != jj)","def fn(vals):\n total = odd = 0 \n for i, x in enumerate(vals): \n if vals[0] == x: \n total += 1\n if i&1: odd += 1\n elif vals[0] ^ x != (1 << n) - 1: return inf\n ans = inf \n if len(vals) <= 2*total <= len(vals)+1: ans = min(ans, odd)\n if len(vals)-1 <= 2*total <= len(vals): ans = min(ans, total - odd)\n return ans","def distinct_partition(n: int):\n p_list = [1] + [0]*n\n for i in range(1, n+1):\n for j in reversed(range(i, n+1)):\n p_list[j] += p_list[j - i]\n return p_list[n] - 1","def index(i, j):\n return i * N + j","def drecurrance(cache, a, b, i, j):\n if i == j and j == 0:\n cache[i][j] = 0\n elif i == 0:\n cache[i][j] = j\n elif j == 0:\n cache[i][j] = i\n elif a[i-1] == b[j-1]:\n cache[i][j] = cache[i-1][j-1]\n else:\n cache[i][j] = 1 + min(cache[i-1][j], cache[i][j-1], cache[i-1][j-1])","def solution(A):\n A = set(A) # cast to a set to remove all duplicates\n i = 1 # set incrementor == 1 (greater than 0)\n while i in A: # if the incrementor is in our array\n i += 1 # increment it and repeat. this continues until we find the lowest missing number\n return i","def uniqueP(self, m, n, x, y, store):\n # print store \n if x == m and y == n:\n return 1\n\n if x >= m:\n return self.uniqueP(m, n, x, y+1, store)\n\n if y >= n:\n return self.uniqueP(m, n, x+1, y, store)\n\n if y not in store[x]:\n store[x][y] = self.uniqueP(m, n, x+1, y, store) + self.uniqueP(m, n, x, y+1, store)\n # pp = pprint.PrettyPrinter(depth=6)\n #pp.pprint(store)\n return store[x][y]","def threesumzero(a):\n result = set() # set to eliminate deuplicates!\n a.sort() # sort it\n n = len(a) # number of items in a\n for x in a: # for each element in a, see if its part of some triplet\n target_sum = 0 - x # x and other two items must sum to 0, so other two must sum to -x\n i = 0 # from beginning\n j = n - 1 # from end\n while i < j:\n if a[i] + a[j] == target_sum: # we found triplet\n result.add( tuple( sorted( [x, a[i], a[j] ] ) ) ) # sort it (for uniqueness) and convert it to tuple as its immutable\n i += 1\n j -= 1\n elif a[i] + a[j] > target_sum:\n j -= 1\n else: # a[i] + a[j] < target_sum\n i += 1\n\n return result","def complexity(self):\n complexity = 0\n for k in self.keys():\n for i, j in combinations(range(1, max(k) + 1), 2):\n seq = filter(lambda x: x == i or x == j, k)\n cpxty = len([p for p, q in pairwise(seq) if p != q])\n complexity = max(cpxty, complexity)\n return complexity","def firstMissingPositive(nums):\n\n n = len(nums)\n\n # Base case.\n if 1 not in nums:\n return 1\n\n # nums = [1]\n if n == 1:\n return 2\n\n # Replace negative numbers, zeros,\n # and numbers larger than n by 1s.\n # After this conversion nums will contain \n # only positive numbers.\n for i in range(n):\n if nums[i] <= 0 or nums[i] > n:\n nums[i] = 1\n\n # Use index as a hash key and number sign as a presence detector.\n # For example, if nums[1] is negative that means that number `1`\n # is present in the array. \n # If nums[2] is positive - number 2 is missing.\n for i in range(n): \n a = abs(nums[i])\n # If you meet number a in the array - change the sign of a-th element.\n # Be careful with duplicates : do it only once.\n # [3,4,-1,1]\n if a == n:\n nums[0] = - abs(nums[0])\n else:\n nums[a] = - abs(nums[a])\n \n # Now the index of the first positive number \n # is equal to first missing positive.\n for i in range(1, n):\n if nums[i] > 0:\n return i\n\n if nums[0] > 0:\n return n\n\n return n + 1","def fn(x):\n if len(x) == len(s): ans.append(x)\n for k, v in freq.items(): \n if v >= 2: \n freq[k] -= 2\n fn(k + x + k)\n freq[k] += 2","def k(n):\r\n primes = u.sieve(n)\r\n l = [1, 0]\r\n for i in range(2, n + 1):\r\n l1 = [l[r] * sopf(i - r, primes) for r in range(1, i)]\r\n s = (sum(l1) + sopf(i, primes)) // i\r\n l.append(s)\r\n return l[n]","def sieve(n):\n\n results = [1 for _ in range(n+1)]\n results[0], results[1] = 0, 0\n results = [0,0] + [1]*(n - 1)\n len(results)\n div = 2\n\n for i,num in enumerate(results):\n if num:\n k = i * 2\n while k <= n:\n seive[k] = 0\n k+= i\n return [x for (x,y) in enumerate(results) if y]\n\n while div <= n // 2 + 1:\n for i in range(div * div, n+1, div):\n if results[i] == 0:\n continue\n else:\n results[i] = 0\n div += 1\n\n #return sum(results)\n return [i for i in range(len(results)) if results[i] == 1]","def sum_unique(l):\n pass","def remove_duplicates(nums: List[int]) -> int:\n\n if not nums:\n return 0\n\n slow = 0\n for fast in range(1, len(nums)):\n # compare element with a next one in order to find a duplicate in a non-decreasing array\n # if current element is unique,\n # slow runner grows one step and copys the current value\n if nums[slow] != nums[fast]:\n slow += 1\n nums[slow] = nums[fast]\n return slow + 1","def unique_climbs(N, X={1, 2}):\n result = 0\n\n if N == 0:\n return 1\n if N < 0:\n return 0\n\n for cnt in X:\n result += unique_climbs(N-cnt, X)\n\n return result","def find_missing_pos_nlogn(input):\n input = sorted(input)\n min = 1\n for ii in input:\n if ii > 0:\n if ii == min:\n min += 1\n else:\n return min\n\n return min","def fn(arr, k):\n ans = []\n for i, x in enumerate(arr): \n while ans and ans[-1] < x and len(ans) + len(arr) - i > k: ans.pop()\n if len(ans) < k: ans.append(x)\n return ans","def nits(self):","def eliminate(n, t, T, k, A, P0, S0, delta):\r\n P = P0*(n/t)\r\n S = S0*(n/((n-1)*t))\r\n th = 2*np.log10(4*(n**2)*(t**2)/delta)/(t/n)\r\n C_t = (np.sqrt(th) + th/3)*(k+1)*0.5\r\n th = (n/(n-1))*np.sqrt(2*np.log10(4*n*(t**2)/delta)/t)\r\n l = np.size(A)\r\n new_A = np.copy(A)\r\n for x in range(l):\r\n for y in range(x+1, l):\r\n i = A[x]\r\n j = A[y]\r\n if(S[i] > (S[j] + th)):\r\n new_A = new_A[new_A != j]\r\n if(S[j] > (S[i] + th)):\r\n new_A = new_A[new_A != i]\r\n if(t > T):\r\n omega = np.array([])\r\n for w in range(n):\r\n if((not w == i) and (not w == j)):\r\n omega = np.append(omega, abs(P[i][w] - P[j][w]))\r\n else:\r\n omega = np.append(omega, 0)\r\n o_set = np.argsort(omega)[::-1]\r\n delta_ij = 2*(P[i][j] - 0.5)\r\n delta_ji = 2*(P[j][i] - 0.5)\r\n for w in range(k):\r\n delta_ij += (P[i][w] - P[j][w])\r\n delta_ji += (P[j][w] - P[i][w])\r\n if(delta_ij > C_t):\r\n new_A = new_A[new_A != j]\r\n if(delta_ji > C_t):\r\n new_A = new_A[new_A != i]\r\n return new_A, P0, S0","def find(n):\n tn = int(n / 2)\n s = 2 * tn + 1\n count = 0\n line_list = []\n for i in range(1, n + 1):\n for j in range(i + 1, n + 1):\n if i + j != s:\n line_list.append(str(i) + \" \" + str(j))\n count += 1\n\n return count, line_list","def fn(n, k):\n if n == k: return 1\n if k == 0: return 0\n return ((n-1)*fn(n-1, k) + fn(n-1, k-1)) % 1_000_000_007","def ncore(self):","def repeatedNTimes(self, A: List[int]) -> int:\n \"\"\" \n A = sorted(A)\n if A[0] == A[1]:\n return A[0]\n return A[int(len(A)/2)]\n \"\"\"\n res = set()\n for a in A:\n if a in res:\n return a\n res.add(a)","def genapri(R, sup, n):\n invalid_count = 0\n res = []\n I = []\n if len(R) < 2:\n return []\n try:\n Ck = [{x[0]} for x in R]\n except TypeError:\n Ck = [set(x[0]) for x in R]\n\n for i in range(len(R) - 1):\n for j in range(i + 1, len(R)):\n try:\n R_i = {R[i][0]}\n R_j = {R[j][0]}\n R_o = {R[0][0]}\n except TypeError:\n R_i = set(R[i][0])\n R_j = set(R[j][0])\n R_o = set(R[0][0])\n temp = R_i | R_j\n invtemp = {inv(x) for x in temp}\n if (len(temp) == len(R_o) + 1) and (not (I != [] and temp in I)) \\\n and (not (I != [] and invtemp in I)):\n test = 1\n for k in temp:\n try:\n k_set = {k}\n except TypeError:\n k_set = set(k)\n temp2 = temp - k_set\n invtemp2 = {inv(x) for x in temp2}\n if not temp2 in Ck and not invtemp2 in Ck:\n test = 0\n break\n if test == 1:\n m = R[i][1] * R[j][1]\n t = float(np.sum(m)) / float(n * (n - 1.0) / 2.0)\n if t > sup:\n res.append([temp, m])\n else:\n invalid_count += 1\n I.append(temp)\n gc.collect()\n return res, invalid_count","def fn(nums):\n ans, vals = [], []\n for i, x in enumerate(nums): \n k = bisect_left(vals, x)\n if k == len(vals): vals.append(x)\n else: vals[k] = x\n ans.append(k)\n return ans","def fn(x):\n nonlocal ans \n if x < ans: \n if min(depth) == n: ans = x # all tiled\n else: \n i = min(depth)\n j = jj = depth.index(i) # (i, j)\n while jj < m and depth[jj] == depth[j]: jj += 1\n k = min(n - i, jj - j)\n for kk in reversed(range(1, k+1)): \n for jj in range(j, j+kk): depth[jj] += kk\n fn(x+1)\n for jj in range(j, j+kk): depth[jj] -= kk","def solution(N):\n max_distance = count = 0\n ones = []\n i = 0\n while (N > 0):\n if (N % 2 == 1):\n ones.append(i)\n i+=1\n N //= 2\n for k in range(1, len(ones)):\n max_distance = max(max_distance, ones[k] - ones[k-1])\n return max_distance","def find_i(n):\n lst = []\n for i in range(1, n):\n lst.append(2 * compute(n - i) + 2 ** i - 1)\n result = min(lst)\n return lst.index(result) + 1","def duplicateZeros(self, arr: List[int]) -> None:\n# # way 1\n# # O(n^2)\n# i = 0\n \n# while i < len(arr) - 1:\n# if arr[i] == 0:\n# arr[i+2:] = arr[i+1:-1]\n# arr[i+1] = 0\n# i += 2\n# else:\n# i += 1\n\n # way 2\n # 借用数组副本辅助记录\n cop = arr[:]\n n = len(arr)\n i, j = 0, 0\n while j < n:\n arr[j] = cop[i]\n if cop[i] == 0:\n j += 1\n if j < n:\n arr[j] = 0\n j += 1\n i += 1","def solution2(n):\n if n == 0:\n return []\n m = int(math.floor(math.sqrt(n))**2)\n return [m] + solution2(n - m)","def landau1(n):\n\n i = 2\n sum_factors = 1\n factors = set()\n\n while i <= n: \n common = {j for j in factors if gcd(j, i) != 1}\n if len(common) == 0:\n factors = add_factor(i, n, factors)\n sum_factors = sum(factors)\n elif product(common) <= i:\n difference = factors.difference(common)\n new_factors = add_factor(i, n, difference)\n if product(new_factors) > product(factors):\n factors = new_factors\n sum_factors = sum(factors)\n i += 1\n\n print(n, product(factors), factors)\n return product(factors)","def merge(line):\n # replace with your code from the previous mini-project\n l = len(line)\n s1 = [0]*l\n j = 0\n for i in range(l):\n if line[i] != 0:\n s1[j] = line[i]\n j += 1\n\n for k in range(l-1):\n if s1[k] == s1[k+1]:\n s1[k] *=2\n s1.pop(k+1)\n s1.append(0)\n\n return s1","def merge(line):\r\n # Create a copy of the input list line\r\n list_copy=[]\r\n #adding the none zero elements of line to list_copy\r\n for dummy_i in range(len(line)):\r\n if line[dummy_i] != 0:\r\n list_copy.append(line[dummy_i])\r\n # adding the appropriate number of zeros to match the length of list_copy and line\r\n for dummy_j in range(len(list_copy),len(line)):\r\n list_copy.append(0)\r\n \r\n # merging the tiles that have the same value\r\n for dummy_k in range(len(list_copy)-1):\r\n # checking for equal values of the adjacent tiles \r\n if list_copy[dummy_k]!=0 and list_copy[dummy_k]==list_copy[dummy_k+1]:\r\n # if equal double the value of the first tile and assign zero to second tile\r\n list_copy[dummy_k]=2*list_copy[dummy_k]\r\n list_copy[dummy_k+1]=0\r\n \r\n #shifting the rest of the values ot the tiles by one place\r\n for dummy_p in range(dummy_k+1,len(list_copy)-1):\r\n list_copy[dummy_p]=list_copy[dummy_p+1]\r\n if (len(line)>3):\r\n list_copy[-2]=list_copy[-1]\r\n list_copy[-1]=0\r\n # returning list_copy which is the answer\r\n return list_copy","def process(v,s):\n i = len(v)\n l = i//2 -1\n if i & 0x1: # odd\n res = 1\n r = l + 2\n else:\n res = 0\n r = l + 1\n while l >=0 and r < len(s) and s[l] == s[r]: \n l -= 1\n r += 1\n res += 2\n return res","def m(self):\n\t\tn = 0\n\t\ti = self.k0\n\t\twhile 1:\n\t\t\tif i > self.j:\n\t\t\t\treturn n\n\t\t\tif not self.cons(i):\n\t\t\t\tbreak\n\t\t\ti = i + 1\n\t\ti = i + 1\n\t\twhile 1:\n\t\t\twhile 1:\n\t\t\t\tif i > self.j:\n\t\t\t\t\treturn n\n\t\t\t\tif self.cons(i):\n\t\t\t\t\tbreak\n\t\t\t\ti = i + 1\n\t\t\ti = i + 1\n\t\t\tn = n + 1\n\t\t\twhile 1:\n\t\t\t\tif i > self.j:\n\t\t\t\t\treturn n\n\t\t\t\tif not self.cons(i):\n\t\t\t\t\tbreak\n\t\t\t\ti = i + 1\n\t\t\ti = i + 1","def fn(n):\n if n == 0: return 1\n return sum(fn(i)*fn(n-i-1) for i in range(n))","def efficient_sol(rt=\"O(n)\"):\n def bribe_count(L): # L = line\n bribes = 0\n # from back to front\n for i in range(len(L) - 1, -1, -1):\n\n expected_index = i + 1\n # Case 1: Expected Person already in the right spot.\n if L[i] == expected_index:\n continue\n\n # Case 2: Expected Person is 1 step away. Swap.\n elif L[i - 1] == expected_index:\n L[i], L[i - 1] = L[i - 1], L[i]\n bribes += 1\n\n # Case 3: Expected person is 2 steps away. Put into proper place and other 2 up.\n elif L[i - 2] == expected_index:\n L[i - 2], L[i - 1], L[i] = L[i - 1], L[i], L[i - 2]\n bribes += 2\n else:\n return \"Too chaotic\" # Expected person is more than 2 steps away.\n return bribes\n\n test_count = int(input())\n for _ in range(test_count):\n input()\n line = list(map(int, input().split()))\n print(bribe_count(line))","def alternative_pos_neg_sub_optimal(arr):\n for i in range(len(arr)):\n j = 0 # j always starts from 0 as every while loop adjusts only 3 elements without checking back on previous values\n while j < len(arr)-2: # As we are getting 2 inidices ahead of time we dont want to cross the boundary\n s = arr[j:j+3]\n s = [1 if x > 0 else -1 for x in s]\n\n if s[0] == s[1] and s[1] != s[2]:\n arr[j+1], arr[j+2] = arr[j+2], arr[j+1]\n\n j += 1\n\n return arr","def sum_of_amicable_numbers(number: int):\n start_time = time.time()\n amicable = set()\n\n for n in range(1, number):\n if n not in amicable:\n a = sum_of_proper_divisors(n)\n b = sum_of_proper_divisors(a)\n if (n == b) and not (n == b == a):\n amicable.add(n)\n amicable.add(a)\n\n result = sum(amicable)\n print_time_log(start_time, result)\n return result","def binaire(x,n):\n a,q = [],0\n \n for i in range(n):\n q = x%2\n x //=2\n a = [q] + a\n \n return(a)","def two_sum(array):\n\n WIDTH = 10000\n out = set()\n for i in array:\n lower = bisect.bisect_left(array, -WIDTH - i)\n upper = bisect.bisect_right(array, WIDTH - i)\n out |= set([i + j for j in array[lower:upper]])\n return out","def problem9_naive(n):\n for a in range(4, n, 4):\n for b in range(3, n - a):\n c = n - a - b\n if a ** 2 + b ** 2 == c ** 2:\n return a * b * c\n return None","def answer():\n for k in range(2,3000):\n for j in range(k-1,0,-1):\n pj, pk = P(j), P(k)\n #print( j, k, pj, pk )\n if isPent(pk-pj):\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\n if isPent(pk+pj) and isPent(pk-pj):\n return pk-pj","def get_majority_element_linear(self, lst):\r\n # Idea: Boyer–Moore majority vote algorithm (O(n) time)\r\n lst, n = sorted(lst), len(lst)\r\n \r\n if n <= 2:\r\n if lst[0] == lst[1]: return 1\r\n else: return -1\r\n \r\n temp_lst, count = [], 1\r\n for i in range(n-1):\r\n if lst[i] == lst[i+1]:\r\n temp_lst.append(lst[i])\r\n count += 1\r\n else: \r\n if count > int(math.floor(n / 2.0)): return count\r\n else: count = 1\r\n i += 1\r\n \r\n return -1","def divisior(n: int) -> list:\n j = [n]\n for d in range(n+1): #loop bis n\n d > 0","def sgn_inplace(a):","def get_complexity(n):\n try:\n return complexity_map[n]\n except KeyError:\n if n - 1 in complexity_map:\n complexity_map[n] = complexity_map[n - 1] + 1\n for i in range(2, int(floor(n / 2) + 1)):\n if n % i == 0:\n complexity = get_complexity(i) + get_complexity(n / i)\n if n not in complexity_map or complexity < complexity_map[n]:\n complexity_map[n] = complexity\n return complexity_map[n]","def solution(A):\n xor = 0\n for item in A:\n xor ^= item\n return xor","def fn(k, i):\n ii = -1 \n for x in path:\n if gcd(nums[k], x) == 1: # coprime \n if path[x] and path[x][-1][1] > ii: \n ans[k] = path[x][-1][0]\n ii = path[x][-1][1]\n \n path.setdefault(nums[k], []).append((k, i))\n for kk in tree.get(k, []): \n if kk not in seen: \n seen.add(kk)\n fn(kk, i+1)\n path[nums[k]].pop()","def removeDuplicates(nums):\n i = 0\n j = 1\n for r in range(len(nums)):\n if j >= len(nums):\n print(i + 1, nums)\n return i + 1\n if nums[i] != nums[j]:\n i = i + 1\n nums[i] = nums[j]\n j = j + 1","def B(n, k):\n assert 0 < k <= n\n global lookup\n for index_y in range(len(lookup), n + 1):\n lookup.append([1])\n min_value = min(index_y, k)\n for index_x in range(min_value):\n if index_x < len(lookup[index_y - 1]) - 1:\n lookup[index_y].append(lookup[index_y - 1][index_x] + lookup[index_y - 1][index_x + 1])\n else:\n lookup[index_y].append(lookup[index_y - 1][index_x])\n return lookup[n][k]","def arrayManipulation_brute(n, queries):\n arr = [0] * n\n\n for i, row in enumerate(queries):\n a, b, k = row[0], row[1], row[2]\n for j in range(a - 1, b):\n arr[j] = arr[j] + k\n print(f'array size {arr.__sizeof__()/1000000}')\n return max(arr)","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\"\n aStarSearch(problem)","def partition_slow(n):\r\n def sub_partition(n, k):\r\n if n < 0:\r\n return 0\r\n if n <= 1 or k == 1:\r\n return 1\r\n s = 0\r\n for i in xrange(1, k+1):\r\n s += sub_partition(n-i, i)\r\n return s\r\n return sub_partition(n, n)","def solution(n: int) -> int:\n sizearr = n + 1\n\n # create zero-filled multi_arr\n multi_arr = [[0 for x in range(sizearr)] for n in range(sizearr)]\n\n # base value is always skipped after being padded\n multi_arr[0][0] = 1\n for last in range(1, sizearr):\n for next in range(0, sizearr):\n multi_arr[last][next] = multi_arr[last - 1][next]\n if next >= last:\n multi_arr[last][next] += multi_arr[last - 1][next - last]\n\n return multi_arr[n][n] - 1","def problem():\n size = 1001\n return sum(n**2 * 4 - 6 * n + 6 for n in range(3, size+1, 2)) + 1","def remove_duplicates(arr):\n if not arr:\n return 0\n last_unique = None\n ans = 0\n for curr in range(len(arr)):\n if arr[curr] != last_unique:\n ans += 1\n last_unique = arr[curr]\n return ans"],"string":"[\n \"def time_complexities():\\n return \\\"Best Case: O(n), Average Case: O(n), Worst Case: O(n)\\\"\",\n \"def sem_repetidos (l): # n = len(l), O(n^2)\\n resultado = []\\n for e in l: # n vezes\\n if not e in resultado: # 1 + O(n)\\n resultado.append(e) # O(1)\\n return resultado\",\n \"def fn(i):\\n if i == 2*n-1 or ans[i] and fn(i+1): return True \\n for x in reversed(range(1, n+1)): \\n if x not in ans: \\n ii = x if x > 1 else 0 \\n if i+ii < 2*n-1 and ans[i] == ans[i+ii] == 0: \\n ans[i] = ans[i+ii] = x\\n if fn(i+1): return True \\n ans[i] = ans[i+ii] = 0\",\n \"def solution(number): # O(N)\\n m = {\\n 0: 0,\\n 1: 1\\n } # O(1)\\n\\n for i in range(2, number + 1): # O(N)\\n m[i] = m[i - 1] + m[i - 2] # O(1)\\n\\n return m[number] # O(1)\",\n \"def twentyone():\\r\\n \\r\\n notamicable = []\\r\\n isamicable = []\\r\\n \\r\\n for i in range(10000):\\r\\n if i not in notamicable and i not in isamicable:\\r\\n a = i\\r\\n b = amicable(findDivisors(a))\\r\\n c = amicable(findDivisors(b))\\r\\n if a == c and not a == b:\\r\\n isamicable.append(a)\\r\\n isamicable.append(b)\\r\\n else:\\r\\n notamicable.append(a)\\r\\n notamicable.append(b)\\r\\n \\r\\n print isamicable\\r\\n t = 0\\r\\n for v in isamicable:\\r\\n t += v\\r\\n return t\",\n \"def solution(A):\\n \\n cars = 0\\n ones = 0\\n\\n for i in range(len(A), 0, -1):\\n\\n if A[i-1] == 1:\\n ones += 1\\n else:\\n cars += ones\\n\\n return (-1 if cars > 1000000000 else cars)\",\n \"def fn(i):\\n if i == 0: return 1 # boundary condition \\n ans = 0\\n for k in range(1, N+1): \\n if k not in seen and (k%i == 0 or i%k == 0): \\n seen.add(k)\\n ans += fn(i-1)\\n seen.remove(k)\\n return ans\",\n \"def twoSum(self, nums: List[int], target: int) -> List[int]:\\n #computational complexity: O(N) since we iterate through n elements only once\\n #space comlexity: O(N) since we need to store n elements in the array\\n\\n #(0) use hashtable to store the number and its index.\\n hashTable={}\\n #(1) iterating through all the itmes\\n for i in range(len(nums)):\\n complement = target - nums[i]\\n #(2) check if the complement is in the hashTable. If not, put it into the hashtable\\n if complement in hashTable:\\n return [hashTable[complement],i]\\n else:\\n hashTable[nums[i]] = i\",\n \"def performance():\\n\\tn = 1024\\n\\twhile n < 5000000: \\n\\t\\tsorted = range(n)\\n\\t\\tnow = time()\\n\\n\\t\\t# Code whose performance is to be evalutated\\n\\t\\tbs_contains(sorted, -1)\\n\\n\\t\\tdone = time()\\n\\n\\t\\tprint n, (done-now)*10000\\n\\t\\tn *= 2\",\n \"def schrage_nlogn(data):\\n N = data.copy()\\n for i in range(len(data)):\\n N[i] = (N[i][0], N[i])\\n heapq.heapify(N)\\n \\\"\\\"\\\"\\\"\\n mozna to zaltwic przy wczytaniu danych nie wplywa na zloznosc samego algorytmu\\n \\n N to tablica tablica krotek takich że (r , [r, p,q]), (r1, [r1 ,p1 , q1]) ........\\n heapq sortuje po pierwszym elemncie dlatego tak\\n \\n G analogicznie z tym że sortowane jest malejaco po q więc G = [(q, [r, p ,q ]), (q1, [r1, p1, q1]) .......... ] \\n \\\"\\\"\\\"\\n G = []\\n Pi = []\\n t = N[0][0]\\n start = timer()\\n while len(G) != 0 or len(N) != 0:\\n while len(N) != 0 and Schrage.save_min(N) <= t:\\n e = heapq.heappop(N)\\n heapq.heappush(G, (-e[1][2], e[1])) # O(log n)\\n if len(G) != 0:\\n e = heapq.heappop(G) # O(log n)\\n Pi.append(e[1]) # O(1)\\n t = t + e[1][1]\\n else:\\n t = N[0][0] # O(1)\\n end = timer()\\n executionTime = end - start\\n return Pi, executionTime\",\n \"def fn(k, i, j):\\n if not (0 <= i < N and 0 <= j < N): return 0\\n if k == 0: return 1 \\n return 1/8*sum(fn(k-1, i+ii, j+jj) for ii, jj in ((-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)))\",\n \"def fn(i):\\n if i == len(nums): ans.append(nums.copy())\\n seen = set()\\n for k in range(i, len(nums)):\\n if nums[k] not in seen:\\n seen.add(nums[k])\\n nums[i], nums[k] = nums[k], nums[i]\\n fn(i+1)\\n nums[i], nums[k] = nums[k], nums[i]\",\n \"def fn(i, j, mv):\\n if not (0 <= i < m and 0 <= j < n): return 1 \\n if mv == 0: return 0\\n return (fn(i-1, j, mv-1) + fn(i, j-1, mv-1) + fn(i, j+1, mv-1) + fn(i+1, j, mv-1)) % 1_000_000_007\",\n \"def solution(A):\\n \\\"\\\"\\\"method 2 n**2\\n east=[] #0\\n west=[] #1\\n for i in range(len(A)):\\n if A[i] == 0:\\n east.append(i)\\n else:\\n west.append(i)\\n\\n result = 0\\n for e in east:\\n count = 0\\n for j in range(len(west)):\\n if e > west[j]:\\n continue\\n if e < west[j]:\\n count = len(west) - j\\n result += count\\n #print(e, count)\\n break\\n return result\\n \\\"\\\"\\\"\\n east=[] #0\\n west=[] #1\\n l = len(A)\\n for i in range(len(A)):\\n if A[i] == 0:\\n east.append(i)\\n else:\\n west.append(i)\\n\\n result = {}\\n for i in range(len(east)):\\n e = east[i]\\n if i == 0:\\n result[e] = l - e - len(east)\\n if i != 0:\\n result[e] = result[east[i-1]] - (e - east[i-1]-1)\\n\\n #print(result)\\n s = sum(result.values())\\n if s > 1000000000:\\n return -1\\n return s\",\n \"def solution(s):\",\n \"def gn(i, j, k):\\n if i+j < n: return anti[i+j][i+k] - anti[i+j][i]\\n return anti[i+j][n-1-j+k] - anti[i+j][n-1-j]\",\n \"def complexity(self):\\n raise NotImplementedError()\",\n \"def naive(p, t):\\n occurences = []\\n for i in range(len(t) - len(p) + 1):\\n match = True\\n for j in range(len(p)):\\n if t[i + j] != p[j]:\\n match = False\\n break\\n if match:\\n occurences.append(i)\\n return occurences\",\n \"def Efficient(self): #CLEANS THE INEFFICIENT PATH AND MAKES IT EFFICIENT\\n self.efficient=[]\\n for i in range(len(self.Path)):\\n #print(self.efficient)\\n self.efficient.append(self.Path[i])\\n if self.Path[i] in self.efficient[:-1]:\\n #print(self.efficient)\\n ind=self.efficient.index(self.Path[i])\\n self.efficient=self.efficient[:ind+1]\\n #n+=1\\n return self.efficient #Creates the most efficient path \",\n \"def am(n):\\r\\n for i in range(1,n+1):\\r\\n if i not in d1.keys() :\\r\\n d1[i] = d1[i-1] + (i*((-1)**i))\\r\\n# print(d1)\\r\\n else:\\r\\n pass\\r\\n return d1[n]\",\n \"def J (self, n):\",\n \"def fn(i, j):\\n if not (0 <= i < n and 0 <= j < n): return inf\\n if i == 0: return A[i][j]\\n return min(fn(i-1, j-1), fn(i-1, j), fn(i-1, j+1)) + A[i][j]\",\n \"def method2():\\n n = 1000\\n s = 0\\n multiples = [3,5]\\n total = []\\n\\n for m in multiples:\\n total.append(0)\\n\\n minValue = 0\\n while(minValue < 1000):\\n minValue = 1000\\n minPosition = 0\\n for i, v in enumerate(total):\\n if v < minValue:\\n minValue = v\\n minPosition = i\\n\\n temp = total[minPosition] + multiples[minPosition]\\n\\n if(temp < 1000) and (temp not in total):\\n s += temp\\n\\n total[minPosition] = temp\\n\\n return s\",\n \"def compute(n):\\n if n == 1:\\n return 1\\n else:\\n i = find_i(n)\\n return 2 * compute(n - i) + 2 ** i - 1\",\n \"def solution(A): # A not necessarily sorted and may have repeated elements\\n \\n mid = len(A)/2\\n A1=A[0:int(mid)]\\n A2=A[int(mid):]\\n out = find_arrays(A1,A2)\\n return out\\n pass\",\n \"def I (self, n):\",\n \"def complexity(s, **kwargs):\\n num, den = 1, 1\\n for k in range(1, len(s)):\\n k4 = 4**k # For DNA\\n num += min(len(set(s[i:i+k] for i in range(len(s) - k + 1))), k4)\\n den += min(len(s) - k + 1, k4)\\n return num / den\",\n \"def solution(A):\\n # 1. corner case\\n #if len(A) == 2:\\n # if A[0] <= A[1]:\\n # return 0\\n # return 1\\n\\n # 2. find min avg of slices O(N^2)\\n avg_min = 100000\\n P = 0\\n Q = 1\\n idx = 0\\n for i in range(len(A)):\\n s = A[i]\\n P = i\\n for j in range(i+1, min(i+3,len(A))):\\n s += A[j]\\n Q = j\\n if s / (Q - P + 1) < avg_min:\\n avg_min = s / (Q - P + 1)\\n idx = P\\n #print(P,Q, avg_min)\\n return idx\",\n \"def solution(n: int = 28123) -> int:\\n\\n nums = range(1, n+1)\\n abundant = list(filter(is_abundant, nums))\\n abundant_sums = set(all_sums(abundant, n))\\n fit = set(nums) - abundant_sums\\n return fit\",\n \"def sol(n, mem):\\n if mem[n] != -1:\\n return mem[n]\\n \\n mem[n] = 0\\n for i in range(2, n+1):\\n mem[n]+=sol(n-i, mem)*sol(i-2, mem)\\n \\n return mem[n]\",\n \"def singleNonDuplicate(self, nums):\\n \\n #Every element appears exactly twice, except for one\\n #O(log n) time\\n #O(1) space\\n #0 1 2 3 4\\n #1 3 3 5 5 \\n \\n \\n #0 1 2 3 4 5 6 \\n #1 3 3 5 5 7 7\\n \\n \\n #O log(n) solution \\n #index = [0,....n-1]\\n n = len(nums)\\n \\n low=0\\n high=n-1\\n \\n if high == 1:\\n return nums[high]\\n \\n \\n while low<high:\\n mid=(low+high)//2\\n \\n if (mid%2==1 and nums[mid-1]==nums[mid]) or (mid%2 == 0 and nums[mid] == nums[mid + 1]):\\n low=mid+1\\n else:\\n high=mid\\n return nums[low]\",\n \"def threeSum(self, nums):\\n # sort\\n nums.sort()\\n length = len(nums)\\n result = []\\n # get unique list\\n unique = set()\\n for i in xrange(length):\\n # if nums[i] exist in unique\\n if nums[i] in unique:\\n continue\\n else:\\n unique.add(nums[i])\\n j = i + 1\\n k = length - 1\\n # get unique nums[j]\\n unique_local = set()\\n while k > j:\\n unique_local.add(nums[j])\\n # when need j+=1: sign = 1\\n sign = 0\\n if (nums[j] + nums[k]) < -nums[i]:\\n j += 1\\n sign = 1\\n elif (nums[j] + nums[k]) > -nums[i]:\\n k -= 1\\n else: #nums[j] + nums[k] == -nums[i]\\n lst = [nums[i], nums[j], nums[k]]\\n result.append(lst)\\n j += 1\\n k -= 1\\n sign = 1\\n if sign == 1:\\n # if nums[j] in unique_local: j++\\n while j < length and nums[j] in unique_local:\\n j += 1\\n return result\",\n \"def algorithm_p(n):\\n partition = [0]*n\\n last_replaced = 0\\n partition[last_replaced] = n\\n idx = last_replaced - (n == 1)\\n\\n while True:\\n yield partition[0:last_replaced + 1]\\n if idx < 0:\\n return\\n if partition[idx] == 2:\\n partition[idx] = 1\\n idx -= 1\\n last_replaced += 1\\n partition[last_replaced] = 1\\n else:\\n replacement = partition[idx] - 1\\n partition[idx] = replacement\\n n = last_replaced - idx + 1\\n last_replaced = idx + 1\\n while n > replacement:\\n partition[last_replaced] = replacement\\n last_replaced += 1\\n n -= replacement\\n partition[last_replaced] = n\\n idx = last_replaced - (n == 1)\",\n \"def twoSumFaster(nums, target):\\n my_hash = {}\\n for a in range(0,len(nums)):\\n my_hash[nums[a]] = a\\n\\n for indice_a in range(0,len(nums) - 1):\\n diff = target - nums[indice_a]\\n if diff in my_hash:\\n for indice_b in range(indice_a + 1, len(nums)):\\n if nums[indice_b] == diff:\\n return [indice_a, indice_b]\",\n \"def naive(p, t):\\n\\toccurence = []\\n\\tfor i in range(len(t)-len(p) + 1):\\n\\t\\tmatch = True\\n\\t\\tfor j in range(len(p)):\\n\\t\\t\\tif not p[j] == t[i+j]:\\n\\t\\t\\t\\tmatch = False\\n\\t\\t\\t\\tbreak\\n\\t\\tif match:\\n\\t\\t\\toccurence.append(i)\\n\\treturn occurence\",\n \"def naive_2mm(p, t):\\n\\toccurence = []\\n\\tfor i in range(len(t)-len(p) + 1):\\n\\t\\tmatch = True\\n\\t\\tunmatch = 0\\n\\t\\tfor j in range(len(p)):\\n\\t\\t\\tif not p[j] == t[i+j]:\\n\\t\\t\\t\\tunmatch += 1\\n\\t\\t\\t\\tif unmatch > 2:\\n\\t\\t\\t\\t\\tmatch = False\\n\\t\\t\\t\\t\\tbreak\\n\\t\\tif match:\\n\\t\\t\\toccurence.append(i)\\n\\treturn occurence\",\n \"def fn(i, seen=set(), ans=0):\\n if i == n: ans += 1\\n for j in range(n):\\n place = {(\\\"col\\\", j), (\\\"diag\\\", i-j), (\\\"anti\\\", i+j)}\\n if not (place & seen): \\n seen |= place\\n ans = fn(i+1, seen, ans)\\n seen -= place \\n return ans\",\n \"def fn(i, seen=set()):\\n ans = 0\\n if i < len(s): # boundary condition when i == len(s)\\n for ii in range(i+1, len(s)+1): \\n if s[i:ii] not in seen: \\n seen.add(s[i:ii])\\n ans = max(ans, 1 + fn(ii, seen))\\n seen.remove(s[i:ii])\\n return ans\",\n \"def solution2(nums, K):\\n s = 0\\n sum_til = []\\n for n in nums:\\n s += n\\n sum_til.append(s)\\n\\n l = len(nums)\\n for i in range(l):\\n for j in range(i+1, l):\\n sum_ij = sum_til[j] if i == 0 else sum_til[j] - sum_til[i-1]\\n if K != 0 and sum_ij % K == 0:\\n return True\\n if K == 0 and sum_ij == 0:\\n return True\\n return False\",\n \"def orderByIncreasingBitCount(n):\\n res = [0] # freebie\\n biggest = 2**n - 1\\n for i in range(1, n):\\n for j in range(1, biggest):\\n if hamming_weight(j) == i:\\n res.append(j)\\n res.append(biggest) # another freebie\\n return res\",\n \"def beautifulSubsets(self, nums: List[int], k: int) -> int:\\n\\n \\\"\\\"\\\"\\n queue = deque([([], -1)])\\n res = 0\\n\\n while queue:\\n cur, idx = queue.popleft()\\n res += 1\\n\\n for i in range(idx + 1, len(nums)):\\n if nums[i] - k in cur or nums[i] + k in cur:\\n continue\\n\\n queue.append((cur + [nums[i]], i))\\n\\n return res - 1\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n # dp0 is the ways that without A[i]\\n # dp1 is the ways that with A[i]\\n\\n count = [Counter() for i in range(k)]\\n for n in nums:\\n count[n % k][n] += 1\\n\\n res = 1\\n for i in range(k):\\n prev, dp0, dp1 = 0, 1, 0\\n for n in sorted(count[i]):\\n v = pow(2, count[i][n])\\n if prev + k == n:\\n dp0, dp1 = dp0 + dp1, dp0 * (v - 1)\\n else:\\n dp0, dp1 = dp0 + dp1, (dp0 + dp1) * (v - 1)\\n\\n prev = n\\n\\n res *= dp0 + dp1\\n\\n return res - 1\\n \\\"\\\"\\\"\\n\\n # Count the frequency of A, and then consider all the arithmetic sequence with difference k.\\n # Each arithmetic sequence can be solve as a hourse robber problem.\\n # We solve the hourse robber by dp.\\n # dp(a) return the result for sequence no bigger than a.\\n\\n # dp(a)[0] is the ways that without a\\n # dp(a)[1] is the ways that with a\\n\\n # dp(a)[0] = dp(a - k)[0] + dp(a - k)[1]\\n # dp(a)[1] = dp(a - k)[0] * (2 ^ count(a) - 1\\n\\n count = Counter(nums)\\n\\n def dp(n):\\n dp0, dp1 = dp(n - k) if n - k in count else (1, 0)\\n return dp0 + dp1, dp0 * (pow(2, count[n]) - 1)\\n\\n return functools.reduce(operator.mul, (sum(dp(n)) for n in count if not count[n + k])) - 1\",\n \"def solution():\\n i = 1\\n\\n while True:\\n if (\\n sorted(str(i))\\n == sorted(str(2 * i))\\n == sorted(str(3 * i))\\n == sorted(str(4 * i))\\n == sorted(str(5 * i))\\n == sorted(str(6 * i))\\n ):\\n return i\\n\\n i += 1\",\n \"def sum_in_set_linear(array, x):\\n\\n s = set() \\n for i in range(len(array)):\\n diff = x - array[i]\\n if diff in s:\\n return True\\n s.add(array[i])\\n return False\",\n \"def fn(i, j):\\n if i == len(costs): return 0 # no more houses to paint \\n return costs[i][j] + min(fn(i+1, jj) for jj in range(3) if j != jj)\",\n \"def fn(vals):\\n total = odd = 0 \\n for i, x in enumerate(vals): \\n if vals[0] == x: \\n total += 1\\n if i&1: odd += 1\\n elif vals[0] ^ x != (1 << n) - 1: return inf\\n ans = inf \\n if len(vals) <= 2*total <= len(vals)+1: ans = min(ans, odd)\\n if len(vals)-1 <= 2*total <= len(vals): ans = min(ans, total - odd)\\n return ans\",\n \"def distinct_partition(n: int):\\n p_list = [1] + [0]*n\\n for i in range(1, n+1):\\n for j in reversed(range(i, n+1)):\\n p_list[j] += p_list[j - i]\\n return p_list[n] - 1\",\n \"def index(i, j):\\n return i * N + j\",\n \"def drecurrance(cache, a, b, i, j):\\n if i == j and j == 0:\\n cache[i][j] = 0\\n elif i == 0:\\n cache[i][j] = j\\n elif j == 0:\\n cache[i][j] = i\\n elif a[i-1] == b[j-1]:\\n cache[i][j] = cache[i-1][j-1]\\n else:\\n cache[i][j] = 1 + min(cache[i-1][j], cache[i][j-1], cache[i-1][j-1])\",\n \"def solution(A):\\n A = set(A) # cast to a set to remove all duplicates\\n i = 1 # set incrementor == 1 (greater than 0)\\n while i in A: # if the incrementor is in our array\\n i += 1 # increment it and repeat. this continues until we find the lowest missing number\\n return i\",\n \"def uniqueP(self, m, n, x, y, store):\\n # print store \\n if x == m and y == n:\\n return 1\\n\\n if x >= m:\\n return self.uniqueP(m, n, x, y+1, store)\\n\\n if y >= n:\\n return self.uniqueP(m, n, x+1, y, store)\\n\\n if y not in store[x]:\\n store[x][y] = self.uniqueP(m, n, x+1, y, store) + self.uniqueP(m, n, x, y+1, store)\\n # pp = pprint.PrettyPrinter(depth=6)\\n #pp.pprint(store)\\n return store[x][y]\",\n \"def threesumzero(a):\\n result = set() # set to eliminate deuplicates!\\n a.sort() # sort it\\n n = len(a) # number of items in a\\n for x in a: # for each element in a, see if its part of some triplet\\n target_sum = 0 - x # x and other two items must sum to 0, so other two must sum to -x\\n i = 0 # from beginning\\n j = n - 1 # from end\\n while i < j:\\n if a[i] + a[j] == target_sum: # we found triplet\\n result.add( tuple( sorted( [x, a[i], a[j] ] ) ) ) # sort it (for uniqueness) and convert it to tuple as its immutable\\n i += 1\\n j -= 1\\n elif a[i] + a[j] > target_sum:\\n j -= 1\\n else: # a[i] + a[j] < target_sum\\n i += 1\\n\\n return result\",\n \"def complexity(self):\\n complexity = 0\\n for k in self.keys():\\n for i, j in combinations(range(1, max(k) + 1), 2):\\n seq = filter(lambda x: x == i or x == j, k)\\n cpxty = len([p for p, q in pairwise(seq) if p != q])\\n complexity = max(cpxty, complexity)\\n return complexity\",\n \"def firstMissingPositive(nums):\\n\\n n = len(nums)\\n\\n # Base case.\\n if 1 not in nums:\\n return 1\\n\\n # nums = [1]\\n if n == 1:\\n return 2\\n\\n # Replace negative numbers, zeros,\\n # and numbers larger than n by 1s.\\n # After this conversion nums will contain \\n # only positive numbers.\\n for i in range(n):\\n if nums[i] <= 0 or nums[i] > n:\\n nums[i] = 1\\n\\n # Use index as a hash key and number sign as a presence detector.\\n # For example, if nums[1] is negative that means that number `1`\\n # is present in the array. \\n # If nums[2] is positive - number 2 is missing.\\n for i in range(n): \\n a = abs(nums[i])\\n # If you meet number a in the array - change the sign of a-th element.\\n # Be careful with duplicates : do it only once.\\n # [3,4,-1,1]\\n if a == n:\\n nums[0] = - abs(nums[0])\\n else:\\n nums[a] = - abs(nums[a])\\n \\n # Now the index of the first positive number \\n # is equal to first missing positive.\\n for i in range(1, n):\\n if nums[i] > 0:\\n return i\\n\\n if nums[0] > 0:\\n return n\\n\\n return n + 1\",\n \"def fn(x):\\n if len(x) == len(s): ans.append(x)\\n for k, v in freq.items(): \\n if v >= 2: \\n freq[k] -= 2\\n fn(k + x + k)\\n freq[k] += 2\",\n \"def k(n):\\r\\n primes = u.sieve(n)\\r\\n l = [1, 0]\\r\\n for i in range(2, n + 1):\\r\\n l1 = [l[r] * sopf(i - r, primes) for r in range(1, i)]\\r\\n s = (sum(l1) + sopf(i, primes)) // i\\r\\n l.append(s)\\r\\n return l[n]\",\n \"def sieve(n):\\n\\n results = [1 for _ in range(n+1)]\\n results[0], results[1] = 0, 0\\n results = [0,0] + [1]*(n - 1)\\n len(results)\\n div = 2\\n\\n for i,num in enumerate(results):\\n if num:\\n k = i * 2\\n while k <= n:\\n seive[k] = 0\\n k+= i\\n return [x for (x,y) in enumerate(results) if y]\\n\\n while div <= n // 2 + 1:\\n for i in range(div * div, n+1, div):\\n if results[i] == 0:\\n continue\\n else:\\n results[i] = 0\\n div += 1\\n\\n #return sum(results)\\n return [i for i in range(len(results)) if results[i] == 1]\",\n \"def sum_unique(l):\\n pass\",\n \"def remove_duplicates(nums: List[int]) -> int:\\n\\n if not nums:\\n return 0\\n\\n slow = 0\\n for fast in range(1, len(nums)):\\n # compare element with a next one in order to find a duplicate in a non-decreasing array\\n # if current element is unique,\\n # slow runner grows one step and copys the current value\\n if nums[slow] != nums[fast]:\\n slow += 1\\n nums[slow] = nums[fast]\\n return slow + 1\",\n \"def unique_climbs(N, X={1, 2}):\\n result = 0\\n\\n if N == 0:\\n return 1\\n if N < 0:\\n return 0\\n\\n for cnt in X:\\n result += unique_climbs(N-cnt, X)\\n\\n return result\",\n \"def find_missing_pos_nlogn(input):\\n input = sorted(input)\\n min = 1\\n for ii in input:\\n if ii > 0:\\n if ii == min:\\n min += 1\\n else:\\n return min\\n\\n return min\",\n \"def fn(arr, k):\\n ans = []\\n for i, x in enumerate(arr): \\n while ans and ans[-1] < x and len(ans) + len(arr) - i > k: ans.pop()\\n if len(ans) < k: ans.append(x)\\n return ans\",\n \"def nits(self):\",\n \"def eliminate(n, t, T, k, A, P0, S0, delta):\\r\\n P = P0*(n/t)\\r\\n S = S0*(n/((n-1)*t))\\r\\n th = 2*np.log10(4*(n**2)*(t**2)/delta)/(t/n)\\r\\n C_t = (np.sqrt(th) + th/3)*(k+1)*0.5\\r\\n th = (n/(n-1))*np.sqrt(2*np.log10(4*n*(t**2)/delta)/t)\\r\\n l = np.size(A)\\r\\n new_A = np.copy(A)\\r\\n for x in range(l):\\r\\n for y in range(x+1, l):\\r\\n i = A[x]\\r\\n j = A[y]\\r\\n if(S[i] > (S[j] + th)):\\r\\n new_A = new_A[new_A != j]\\r\\n if(S[j] > (S[i] + th)):\\r\\n new_A = new_A[new_A != i]\\r\\n if(t > T):\\r\\n omega = np.array([])\\r\\n for w in range(n):\\r\\n if((not w == i) and (not w == j)):\\r\\n omega = np.append(omega, abs(P[i][w] - P[j][w]))\\r\\n else:\\r\\n omega = np.append(omega, 0)\\r\\n o_set = np.argsort(omega)[::-1]\\r\\n delta_ij = 2*(P[i][j] - 0.5)\\r\\n delta_ji = 2*(P[j][i] - 0.5)\\r\\n for w in range(k):\\r\\n delta_ij += (P[i][w] - P[j][w])\\r\\n delta_ji += (P[j][w] - P[i][w])\\r\\n if(delta_ij > C_t):\\r\\n new_A = new_A[new_A != j]\\r\\n if(delta_ji > C_t):\\r\\n new_A = new_A[new_A != i]\\r\\n return new_A, P0, S0\",\n \"def find(n):\\n tn = int(n / 2)\\n s = 2 * tn + 1\\n count = 0\\n line_list = []\\n for i in range(1, n + 1):\\n for j in range(i + 1, n + 1):\\n if i + j != s:\\n line_list.append(str(i) + \\\" \\\" + str(j))\\n count += 1\\n\\n return count, line_list\",\n \"def fn(n, k):\\n if n == k: return 1\\n if k == 0: return 0\\n return ((n-1)*fn(n-1, k) + fn(n-1, k-1)) % 1_000_000_007\",\n \"def ncore(self):\",\n \"def repeatedNTimes(self, A: List[int]) -> int:\\n \\\"\\\"\\\" \\n A = sorted(A)\\n if A[0] == A[1]:\\n return A[0]\\n return A[int(len(A)/2)]\\n \\\"\\\"\\\"\\n res = set()\\n for a in A:\\n if a in res:\\n return a\\n res.add(a)\",\n \"def genapri(R, sup, n):\\n invalid_count = 0\\n res = []\\n I = []\\n if len(R) < 2:\\n return []\\n try:\\n Ck = [{x[0]} for x in R]\\n except TypeError:\\n Ck = [set(x[0]) for x in R]\\n\\n for i in range(len(R) - 1):\\n for j in range(i + 1, len(R)):\\n try:\\n R_i = {R[i][0]}\\n R_j = {R[j][0]}\\n R_o = {R[0][0]}\\n except TypeError:\\n R_i = set(R[i][0])\\n R_j = set(R[j][0])\\n R_o = set(R[0][0])\\n temp = R_i | R_j\\n invtemp = {inv(x) for x in temp}\\n if (len(temp) == len(R_o) + 1) and (not (I != [] and temp in I)) \\\\\\n and (not (I != [] and invtemp in I)):\\n test = 1\\n for k in temp:\\n try:\\n k_set = {k}\\n except TypeError:\\n k_set = set(k)\\n temp2 = temp - k_set\\n invtemp2 = {inv(x) for x in temp2}\\n if not temp2 in Ck and not invtemp2 in Ck:\\n test = 0\\n break\\n if test == 1:\\n m = R[i][1] * R[j][1]\\n t = float(np.sum(m)) / float(n * (n - 1.0) / 2.0)\\n if t > sup:\\n res.append([temp, m])\\n else:\\n invalid_count += 1\\n I.append(temp)\\n gc.collect()\\n return res, invalid_count\",\n \"def fn(nums):\\n ans, vals = [], []\\n for i, x in enumerate(nums): \\n k = bisect_left(vals, x)\\n if k == len(vals): vals.append(x)\\n else: vals[k] = x\\n ans.append(k)\\n return ans\",\n \"def fn(x):\\n nonlocal ans \\n if x < ans: \\n if min(depth) == n: ans = x # all tiled\\n else: \\n i = min(depth)\\n j = jj = depth.index(i) # (i, j)\\n while jj < m and depth[jj] == depth[j]: jj += 1\\n k = min(n - i, jj - j)\\n for kk in reversed(range(1, k+1)): \\n for jj in range(j, j+kk): depth[jj] += kk\\n fn(x+1)\\n for jj in range(j, j+kk): depth[jj] -= kk\",\n \"def solution(N):\\n max_distance = count = 0\\n ones = []\\n i = 0\\n while (N > 0):\\n if (N % 2 == 1):\\n ones.append(i)\\n i+=1\\n N //= 2\\n for k in range(1, len(ones)):\\n max_distance = max(max_distance, ones[k] - ones[k-1])\\n return max_distance\",\n \"def find_i(n):\\n lst = []\\n for i in range(1, n):\\n lst.append(2 * compute(n - i) + 2 ** i - 1)\\n result = min(lst)\\n return lst.index(result) + 1\",\n \"def duplicateZeros(self, arr: List[int]) -> None:\\n# # way 1\\n# # O(n^2)\\n# i = 0\\n \\n# while i < len(arr) - 1:\\n# if arr[i] == 0:\\n# arr[i+2:] = arr[i+1:-1]\\n# arr[i+1] = 0\\n# i += 2\\n# else:\\n# i += 1\\n\\n # way 2\\n # 借用数组副本辅助记录\\n cop = arr[:]\\n n = len(arr)\\n i, j = 0, 0\\n while j < n:\\n arr[j] = cop[i]\\n if cop[i] == 0:\\n j += 1\\n if j < n:\\n arr[j] = 0\\n j += 1\\n i += 1\",\n \"def solution2(n):\\n if n == 0:\\n return []\\n m = int(math.floor(math.sqrt(n))**2)\\n return [m] + solution2(n - m)\",\n \"def landau1(n):\\n\\n i = 2\\n sum_factors = 1\\n factors = set()\\n\\n while i <= n: \\n common = {j for j in factors if gcd(j, i) != 1}\\n if len(common) == 0:\\n factors = add_factor(i, n, factors)\\n sum_factors = sum(factors)\\n elif product(common) <= i:\\n difference = factors.difference(common)\\n new_factors = add_factor(i, n, difference)\\n if product(new_factors) > product(factors):\\n factors = new_factors\\n sum_factors = sum(factors)\\n i += 1\\n\\n print(n, product(factors), factors)\\n return product(factors)\",\n \"def merge(line):\\n # replace with your code from the previous mini-project\\n l = len(line)\\n s1 = [0]*l\\n j = 0\\n for i in range(l):\\n if line[i] != 0:\\n s1[j] = line[i]\\n j += 1\\n\\n for k in range(l-1):\\n if s1[k] == s1[k+1]:\\n s1[k] *=2\\n s1.pop(k+1)\\n s1.append(0)\\n\\n return s1\",\n \"def merge(line):\\r\\n # Create a copy of the input list line\\r\\n list_copy=[]\\r\\n #adding the none zero elements of line to list_copy\\r\\n for dummy_i in range(len(line)):\\r\\n if line[dummy_i] != 0:\\r\\n list_copy.append(line[dummy_i])\\r\\n # adding the appropriate number of zeros to match the length of list_copy and line\\r\\n for dummy_j in range(len(list_copy),len(line)):\\r\\n list_copy.append(0)\\r\\n \\r\\n # merging the tiles that have the same value\\r\\n for dummy_k in range(len(list_copy)-1):\\r\\n # checking for equal values of the adjacent tiles \\r\\n if list_copy[dummy_k]!=0 and list_copy[dummy_k]==list_copy[dummy_k+1]:\\r\\n # if equal double the value of the first tile and assign zero to second tile\\r\\n list_copy[dummy_k]=2*list_copy[dummy_k]\\r\\n list_copy[dummy_k+1]=0\\r\\n \\r\\n #shifting the rest of the values ot the tiles by one place\\r\\n for dummy_p in range(dummy_k+1,len(list_copy)-1):\\r\\n list_copy[dummy_p]=list_copy[dummy_p+1]\\r\\n if (len(line)>3):\\r\\n list_copy[-2]=list_copy[-1]\\r\\n list_copy[-1]=0\\r\\n # returning list_copy which is the answer\\r\\n return list_copy\",\n \"def process(v,s):\\n i = len(v)\\n l = i//2 -1\\n if i & 0x1: # odd\\n res = 1\\n r = l + 2\\n else:\\n res = 0\\n r = l + 1\\n while l >=0 and r < len(s) and s[l] == s[r]: \\n l -= 1\\n r += 1\\n res += 2\\n return res\",\n \"def m(self):\\n\\t\\tn = 0\\n\\t\\ti = self.k0\\n\\t\\twhile 1:\\n\\t\\t\\tif i > self.j:\\n\\t\\t\\t\\treturn n\\n\\t\\t\\tif not self.cons(i):\\n\\t\\t\\t\\tbreak\\n\\t\\t\\ti = i + 1\\n\\t\\ti = i + 1\\n\\t\\twhile 1:\\n\\t\\t\\twhile 1:\\n\\t\\t\\t\\tif i > self.j:\\n\\t\\t\\t\\t\\treturn n\\n\\t\\t\\t\\tif self.cons(i):\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\ti = i + 1\\n\\t\\t\\ti = i + 1\\n\\t\\t\\tn = n + 1\\n\\t\\t\\twhile 1:\\n\\t\\t\\t\\tif i > self.j:\\n\\t\\t\\t\\t\\treturn n\\n\\t\\t\\t\\tif not self.cons(i):\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\ti = i + 1\\n\\t\\t\\ti = i + 1\",\n \"def fn(n):\\n if n == 0: return 1\\n return sum(fn(i)*fn(n-i-1) for i in range(n))\",\n \"def efficient_sol(rt=\\\"O(n)\\\"):\\n def bribe_count(L): # L = line\\n bribes = 0\\n # from back to front\\n for i in range(len(L) - 1, -1, -1):\\n\\n expected_index = i + 1\\n # Case 1: Expected Person already in the right spot.\\n if L[i] == expected_index:\\n continue\\n\\n # Case 2: Expected Person is 1 step away. Swap.\\n elif L[i - 1] == expected_index:\\n L[i], L[i - 1] = L[i - 1], L[i]\\n bribes += 1\\n\\n # Case 3: Expected person is 2 steps away. Put into proper place and other 2 up.\\n elif L[i - 2] == expected_index:\\n L[i - 2], L[i - 1], L[i] = L[i - 1], L[i], L[i - 2]\\n bribes += 2\\n else:\\n return \\\"Too chaotic\\\" # Expected person is more than 2 steps away.\\n return bribes\\n\\n test_count = int(input())\\n for _ in range(test_count):\\n input()\\n line = list(map(int, input().split()))\\n print(bribe_count(line))\",\n \"def alternative_pos_neg_sub_optimal(arr):\\n for i in range(len(arr)):\\n j = 0 # j always starts from 0 as every while loop adjusts only 3 elements without checking back on previous values\\n while j < len(arr)-2: # As we are getting 2 inidices ahead of time we dont want to cross the boundary\\n s = arr[j:j+3]\\n s = [1 if x > 0 else -1 for x in s]\\n\\n if s[0] == s[1] and s[1] != s[2]:\\n arr[j+1], arr[j+2] = arr[j+2], arr[j+1]\\n\\n j += 1\\n\\n return arr\",\n \"def sum_of_amicable_numbers(number: int):\\n start_time = time.time()\\n amicable = set()\\n\\n for n in range(1, number):\\n if n not in amicable:\\n a = sum_of_proper_divisors(n)\\n b = sum_of_proper_divisors(a)\\n if (n == b) and not (n == b == a):\\n amicable.add(n)\\n amicable.add(a)\\n\\n result = sum(amicable)\\n print_time_log(start_time, result)\\n return result\",\n \"def binaire(x,n):\\n a,q = [],0\\n \\n for i in range(n):\\n q = x%2\\n x //=2\\n a = [q] + a\\n \\n return(a)\",\n \"def two_sum(array):\\n\\n WIDTH = 10000\\n out = set()\\n for i in array:\\n lower = bisect.bisect_left(array, -WIDTH - i)\\n upper = bisect.bisect_right(array, WIDTH - i)\\n out |= set([i + j for j in array[lower:upper]])\\n return out\",\n \"def problem9_naive(n):\\n for a in range(4, n, 4):\\n for b in range(3, n - a):\\n c = n - a - b\\n if a ** 2 + b ** 2 == c ** 2:\\n return a * b * c\\n return None\",\n \"def answer():\\n for k in range(2,3000):\\n for j in range(k-1,0,-1):\\n pj, pk = P(j), P(k)\\n #print( j, k, pj, pk )\\n if isPent(pk-pj):\\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\\n if isPent(pk+pj) and isPent(pk-pj):\\n return pk-pj\",\n \"def get_majority_element_linear(self, lst):\\r\\n # Idea: Boyer–Moore majority vote algorithm (O(n) time)\\r\\n lst, n = sorted(lst), len(lst)\\r\\n \\r\\n if n <= 2:\\r\\n if lst[0] == lst[1]: return 1\\r\\n else: return -1\\r\\n \\r\\n temp_lst, count = [], 1\\r\\n for i in range(n-1):\\r\\n if lst[i] == lst[i+1]:\\r\\n temp_lst.append(lst[i])\\r\\n count += 1\\r\\n else: \\r\\n if count > int(math.floor(n / 2.0)): return count\\r\\n else: count = 1\\r\\n i += 1\\r\\n \\r\\n return -1\",\n \"def divisior(n: int) -> list:\\n j = [n]\\n for d in range(n+1): #loop bis n\\n d > 0\",\n \"def sgn_inplace(a):\",\n \"def get_complexity(n):\\n try:\\n return complexity_map[n]\\n except KeyError:\\n if n - 1 in complexity_map:\\n complexity_map[n] = complexity_map[n - 1] + 1\\n for i in range(2, int(floor(n / 2) + 1)):\\n if n % i == 0:\\n complexity = get_complexity(i) + get_complexity(n / i)\\n if n not in complexity_map or complexity < complexity_map[n]:\\n complexity_map[n] = complexity\\n return complexity_map[n]\",\n \"def solution(A):\\n xor = 0\\n for item in A:\\n xor ^= item\\n return xor\",\n \"def fn(k, i):\\n ii = -1 \\n for x in path:\\n if gcd(nums[k], x) == 1: # coprime \\n if path[x] and path[x][-1][1] > ii: \\n ans[k] = path[x][-1][0]\\n ii = path[x][-1][1]\\n \\n path.setdefault(nums[k], []).append((k, i))\\n for kk in tree.get(k, []): \\n if kk not in seen: \\n seen.add(kk)\\n fn(kk, i+1)\\n path[nums[k]].pop()\",\n \"def removeDuplicates(nums):\\n i = 0\\n j = 1\\n for r in range(len(nums)):\\n if j >= len(nums):\\n print(i + 1, nums)\\n return i + 1\\n if nums[i] != nums[j]:\\n i = i + 1\\n nums[i] = nums[j]\\n j = j + 1\",\n \"def B(n, k):\\n assert 0 < k <= n\\n global lookup\\n for index_y in range(len(lookup), n + 1):\\n lookup.append([1])\\n min_value = min(index_y, k)\\n for index_x in range(min_value):\\n if index_x < len(lookup[index_y - 1]) - 1:\\n lookup[index_y].append(lookup[index_y - 1][index_x] + lookup[index_y - 1][index_x + 1])\\n else:\\n lookup[index_y].append(lookup[index_y - 1][index_x])\\n return lookup[n][k]\",\n \"def arrayManipulation_brute(n, queries):\\n arr = [0] * n\\n\\n for i, row in enumerate(queries):\\n a, b, k = row[0], row[1], row[2]\\n for j in range(a - 1, b):\\n arr[j] = arr[j] + k\\n print(f'array size {arr.__sizeof__()/1000000}')\\n return max(arr)\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\\\"\\n aStarSearch(problem)\",\n \"def partition_slow(n):\\r\\n def sub_partition(n, k):\\r\\n if n < 0:\\r\\n return 0\\r\\n if n <= 1 or k == 1:\\r\\n return 1\\r\\n s = 0\\r\\n for i in xrange(1, k+1):\\r\\n s += sub_partition(n-i, i)\\r\\n return s\\r\\n return sub_partition(n, n)\",\n \"def solution(n: int) -> int:\\n sizearr = n + 1\\n\\n # create zero-filled multi_arr\\n multi_arr = [[0 for x in range(sizearr)] for n in range(sizearr)]\\n\\n # base value is always skipped after being padded\\n multi_arr[0][0] = 1\\n for last in range(1, sizearr):\\n for next in range(0, sizearr):\\n multi_arr[last][next] = multi_arr[last - 1][next]\\n if next >= last:\\n multi_arr[last][next] += multi_arr[last - 1][next - last]\\n\\n return multi_arr[n][n] - 1\",\n \"def problem():\\n size = 1001\\n return sum(n**2 * 4 - 6 * n + 6 for n in range(3, size+1, 2)) + 1\",\n \"def remove_duplicates(arr):\\n if not arr:\\n return 0\\n last_unique = None\\n ans = 0\\n for curr in range(len(arr)):\\n if arr[curr] != last_unique:\\n ans += 1\\n last_unique = arr[curr]\\n return ans\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.634884","0.5989984","0.5891454","0.58846223","0.58472943","0.5787732","0.57261235","0.56967765","0.56430763","0.564266","0.5621399","0.5620132","0.5600542","0.5588314","0.55832464","0.5568193","0.553908","0.5530704","0.5509698","0.5506223","0.5499427","0.54835635","0.5482579","0.54780924","0.54712355","0.5450046","0.54406434","0.5416852","0.54096246","0.54046905","0.54019254","0.5394647","0.53769976","0.53665787","0.53662395","0.53661007","0.5365698","0.53651345","0.5342411","0.5334061","0.5333794","0.5333094","0.533247","0.53142995","0.5311996","0.5311039","0.53066576","0.53025454","0.5301771","0.52997756","0.5298123","0.5295277","0.5288611","0.52878505","0.5275899","0.5274456","0.5261518","0.525985","0.5259156","0.5256813","0.52490973","0.5248423","0.5247268","0.52390826","0.5235031","0.5227895","0.5226237","0.5224366","0.5218386","0.52178484","0.5216868","0.52120304","0.5182336","0.51669765","0.5163741","0.51616406","0.51607364","0.51603127","0.51450944","0.51435727","0.5139837","0.5139616","0.5137442","0.5135226","0.51307034","0.5130499","0.513005","0.51219046","0.51218134","0.5121076","0.5120875","0.51187605","0.511505","0.51134014","0.5111944","0.51085114","0.5107603","0.5103849","0.51031756","0.5102016","0.50986904"],"string":"[\n \"0.634884\",\n \"0.5989984\",\n \"0.5891454\",\n \"0.58846223\",\n \"0.58472943\",\n \"0.5787732\",\n \"0.57261235\",\n \"0.56967765\",\n \"0.56430763\",\n \"0.564266\",\n \"0.5621399\",\n \"0.5620132\",\n \"0.5600542\",\n \"0.5588314\",\n \"0.55832464\",\n \"0.5568193\",\n \"0.553908\",\n \"0.5530704\",\n \"0.5509698\",\n \"0.5506223\",\n \"0.5499427\",\n \"0.54835635\",\n \"0.5482579\",\n \"0.54780924\",\n \"0.54712355\",\n \"0.5450046\",\n \"0.54406434\",\n \"0.5416852\",\n \"0.54096246\",\n \"0.54046905\",\n \"0.54019254\",\n \"0.5394647\",\n \"0.53769976\",\n \"0.53665787\",\n \"0.53662395\",\n \"0.53661007\",\n \"0.5365698\",\n \"0.53651345\",\n \"0.5342411\",\n \"0.5334061\",\n \"0.5333794\",\n \"0.5333094\",\n \"0.533247\",\n \"0.53142995\",\n \"0.5311996\",\n \"0.5311039\",\n \"0.53066576\",\n \"0.53025454\",\n \"0.5301771\",\n \"0.52997756\",\n \"0.5298123\",\n \"0.5295277\",\n \"0.5288611\",\n \"0.52878505\",\n \"0.5275899\",\n \"0.5274456\",\n \"0.5261518\",\n \"0.525985\",\n \"0.5259156\",\n \"0.5256813\",\n \"0.52490973\",\n \"0.5248423\",\n \"0.5247268\",\n \"0.52390826\",\n \"0.5235031\",\n \"0.5227895\",\n \"0.5226237\",\n \"0.5224366\",\n \"0.5218386\",\n \"0.52178484\",\n \"0.5216868\",\n \"0.52120304\",\n \"0.5182336\",\n \"0.51669765\",\n \"0.5163741\",\n \"0.51616406\",\n \"0.51607364\",\n \"0.51603127\",\n \"0.51450944\",\n \"0.51435727\",\n \"0.5139837\",\n \"0.5139616\",\n \"0.5137442\",\n \"0.5135226\",\n \"0.51307034\",\n \"0.5130499\",\n \"0.513005\",\n \"0.51219046\",\n \"0.51218134\",\n \"0.5121076\",\n \"0.5120875\",\n \"0.51187605\",\n \"0.511505\",\n \"0.51134014\",\n \"0.5111944\",\n \"0.51085114\",\n \"0.5107603\",\n \"0.5103849\",\n \"0.51031756\",\n \"0.5102016\",\n \"0.50986904\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76094,"cells":{"query":{"kind":"string","value":"Calculate the number of digits in a number and the armstrong_sum. Return true if the armstrong_sum equals the armstrong_candidate"},"document":{"kind":"string","value":"def is_armstrong_number(armstrong_candidate: int) -> bool:\n\n if armstrong_candidate < 0:\n return False\n\n nr_digits = nr_digits_number(armstrong_candidate)\n a_sum = armstrong_sum(armstrong_candidate, nr_digits)\n\n return True if a_sum == armstrong_candidate else False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def armstrong_sum(armstrong_candidate: int, nr_digits: int) -> int:\n a_sum = 0\n\n while armstrong_candidate != 0:\n digit_in_armstrong_candidate = armstrong_candidate % 10\n a_sum += digit_in_armstrong_candidate ** nr_digits\n armstrong_candidate = int(armstrong_candidate / 10)\n return a_sum","def nr_digits_number(armstrong_candidate: int) -> int:\n number_of_digits = 0\n while armstrong_candidate != 0:\n armstrong_candidate = int(armstrong_candidate / 10)\n number_of_digits += 1\n\n return number_of_digits","def check_if_armstrong_number(number):\n sum = 0\n number_as_string = str(number)\n digits_number = len(number_as_string)\n for character in number_as_string:\n sum += int(character) ** digits_number\n\n return sum == number","def is_armstrong(number):\n return number == reduce(lambda x, y: x + y,\n map(lambda x: int(x) ** len(str(number)),\n str(number)))","def is_armstrong_number(number: int) -> bool:\n result = 0\n num_str = str(number)\n for i in num_str:\n result += int(i) ** len(num_str)\n return result == number","def is_armstrong_number(number: int) -> bool:\n\n str_number = f\"{number}\"\n return sum(pow(int(x), len(str_number)) for x in str_number) == number","def check_number(self):\n digits = self.number\n _sum = 0\n alt = False\n ix = []\n for x in str(digits):\n ix.append(int(x))\n for d in reversed(ix):\n assert 0 <= d <= 9\n if alt:\n d *= 2\n if d > 9:\n d -= 9\n _sum += d\n alt = not alt\n return (_sum % 10) == 0","def sumDigit():","def is_armstrong_number(number: int) -> bool:\n return get_armstrong_value(number) == number","def calc_check_digit(number):\n weights = (2, 4, 8, 5, 10, 9, 7, 3, 6)\n return str(sum(w * int(n) for w, n in zip(weights, number)) % 11 % 10)","def amstrong(num) :\r\n sum = 0\r\n temp = num\r\n order=len(str(num))\r\n while num > 0 :\r\n r = num % 10\r\n sum += r ** order\r\n num //= 10\r\n\r\n if sum == temp :\r\n print(f\"{sum} is Amstrong Number\")\r\n else :\r\n print(\"Number is not Amstrong Number\")","def get_armstrong_value(number: int) -> int:\n armstrong_value: list = []\n number_len: int = len(str(number))\n\n for digit in str(number):\n armstrong_value.append(int(digit) ** number_len)\n return sum(armstrong_value)","def calc_check_digit(number):\n number = compact(number)\n alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n weights = (29, 23, 19, 17, 13, 7, 5, 3)\n if not isdigits(number):\n number = number[0] + str('ABCEHKMOPT'.index(number[1])) + number[2:]\n c = sum(w * alphabet.index(n) for w, n in zip(weights, number)) % 11\n if c > 9:\n raise InvalidChecksum()\n return str(c)","def verify(n):\n\n # Take the sum of all digits.\n sum_of_digits = sum(luhn_digits(n))\n\n # The number is valid iff the sum of digits modulo 10 is equal to 0\n return sum_of_digits % 10 == 0","def generate_check_sum(account_id):\n card_number = str(Bank.iin) + str(account_id).zfill(9)\n step_one = []\n for i in range(len(card_number)):\n digit = int(card_number[i])\n if i % 2 == 0:\n digit *= 2\n if digit > 9:\n digit -= 9\n step_one.append(digit)\n step_two = sum(step_one)\n remainder = step_two % 10\n check_sum = (10 - remainder) if remainder else remainder\n return check_sum","def check(card_number):\n if re.search(r'\\d{4} \\d{4} \\d{4} \\d{4}', card_number): \n if sum(int(c) for c in card_number.replace(\" \",\"\"))%10 == 0:\n return True","def check_digit(tracking_number):\n check_digit = 10 - ((sum(itertools.starmap(operator.mul, zip(itertools.cycle((3, 1)), map(int, str(tracking_number))))) + 1) % 10)\n if check_digit == 10:\n check_digit = 0\n return check_digit","def problem33(nr_digits):\n\n a_sum = 1\n b_sum = 1\n for a in range(10**(nr_digits - 1), (10**nr_digits) - 1):\n for b in range(a + 1, 10**nr_digits):\n # print(a/b);\n\n a_str = str(a)\n b_str = str(b)\n\n for sa in range(0, nr_digits):\n if a_str[sa] == '0':\n continue\n\n # check in b\n for sb in range(0, nr_digits):\n if (a_str[sa] == b_str[sb]):\n a_short = a_str[:sa] + a_str[sa + 1:]\n b_short = b_str[:sb] + b_str[sb + 1:]\n a_short_int = int(a_short)\n b_short_int = int(b_short)\n if (b_short_int == 0):\n continue\n\n if (a / b == a_short_int / b_short_int):\n a_sum *= a_short_int\n b_sum *= b_short_int\n #print(a_str, \"/\", b_str, \"->\",\n # a_short, \"/\", b_short)\n\n return Fraction(a_sum, b_sum).denominator","def calculate_luhn_check_digit(partial_card_number):\n checksum = luhn_checksum(int(partial_card_number) * 10)\n if checksum == 0:\n check_digit = 0\n else:\n check_digit = 10 - checksum\n return check_digit","def test_hackerrank_sample1(self):\n result = find_digits(12)\n self.assertEquals(result, 2)","def validate(number):\n # numbers only:\n try:\n long(number)\n except:\n return 0\n\n # must be at least 13 digits:\n if len(str(number)) < 13:\n return 0\n\n # can't be all zeros, even though this passes the check below\n if long(number) == 0:\n return 0\n \n ### check the digits: ###########\n # see http://www.beachnet.com/~hstiles/cardtype.html\n\n # digits, from right to left...\n digits = list(str(number))\n digits.reverse()\n\n doubles = \"\"\n sum = 0\n # Step 1: Double the value of alternate digits of the primary\n # account number beginning with the second digit from the right\n # (the first right--hand digit is the check digit.)\n for i in range(len(digits)):\n if i % 2:\n # note that this does NOT fire for the rightmost digit,\n # because 0 % 2 is 0... :)\n doubles = doubles + str(int(digits[i]) * 2)\n\n # Step 2: Add the individual digits comprising the products\n # obtained in Step 1 to each of the unaffected digits in the\n # original number.\n else:\n sum = sum + int(digits[i])\n\n for ch in doubles:\n sum = sum + int(ch)\n\n # Step 3: The total obtained in Step 2 must be a number ending in\n # zero (30, 40, 50, etc.) for the account number to be validated.\n if (sum % 10) != 0:\n return 0\n\n return 1","def verify_sum_of_million_complexities():\n assert 39519866 == integer_complexity.get_integer_complexity_sum(1000000)","def answer(n_digits):\n\n best = 0\n pairs = combinations(xrange(10 ** (n_digits - 1), 10 ** (n_digits)), 2)\n\n for (x, y) in pairs:\n prod = str(x * y)\n if prod == prod[::-1]:\n best = max(best, x * y)\n\n return best","def lv_checksum(value):\n multipliers = (1, 6, 3, 7, 9, 10, 5, 8, 4, 2)\n\n check = sum(mult * int(c) for mult, c in zip(multipliers, value))\n return ((1 - check) % 11) % 10","def has_valid_sum(self):\n return 1 - MassFunction.precision <= self._sum() <= 1 + MassFunction.precision","def cardLuhnChecksumIsValid(card_number):\n sum = 0\n num_digits = len(card_number)\n oddeven = num_digits & 1\n for count in range(0, num_digits):\n digit = int(card_number[count])\n if not (( count & 1 ) ^ oddeven ):\n digit = digit * 2\n if digit > 9:\n digit = digit - 9\n sum = sum + digit\n return ( (sum % 10) == 0 )","def solution(x):\n if x is None:\n return x\n return total_digits(x)","def test_hackerrank_sample2(self):\n result = find_digits(1012)\n self.assertEquals(result, 3)","def isbn_check_digit(isbn):\n return (11 - (sum(x * y for (x, y) in enumerate(reversed(isbn), start=2))\n % 11)) % 11","def valid_checkdigit(ccnum):\n\n sum = 0\n num_digits = len(ccnum)\n oddeven = num_digits & 1\n\n for count in range(0, num_digits):\n digit = int(ccnum[count])\n\n if not ((count & 1) ^ oddeven):\n digit = digit * 2\n if digit > 9:\n digit = digit - 9\n\n sum = sum + digit\n\n return ((sum % 10) == 0)","def narcissistic(*, value: int) -> bool:\n # solution one line code\n # return sum([int(number)**len(str(value)) for number in str(value)]) == value\n if not value:\n return False\n\n result = 0\n for number in str(value):\n result += int(number)**len(str(value))\n return result == value","def digital_sum(n):\n r = 0\n while n:\n r, n = r + n % 10, n // 10\n return r","def test_luhn_checksum(self):\n check_digit = calculate_luhn(\"7992739871\")\n assert check_digit == 3","def check_similar_number(n, d) -> (int, bool):\n \n num = str(n)\n den = str(d)\n uniques = set(num + den)\n total_similar = 0\n answer = 0\n\n for u in uniques:\n if (u in num) and (u in den):\n total_similar += 1\n answer = int(u)\n\n if total_similar == 1:\n return answer, True\n\n return 0, False","def meets_criteria2(num):\n output = True\n if not exactly_two_same_digits(num):\n output = False\n if not digits_increase(num):\n output = False\n return output","def square_digit_sum(number):\n return sum(precomputed_digit_squares[digit] for digit in str(number))","def check_input_digits_count(self):\n check = len(str(self.input)) == 4\n return check","def add_no_carry(*args):\r\n num_digits = []\r\n\r\n for arg in args:\r\n num_digits.append(len(str(arg)))\r\n\r\n max_digits = max(num_digits)\r\n # list comprehension way\r\n # max_digits = max([len(str(arg)) for arg in args])\r\n final_sum = 0\r\n\r\n for pwr in range(1, max_digits + 1): # iterate through ea decimal\r\n result_no_carry = 0\r\n for arg in args:\r\n if len(str(arg)) >= pwr:\r\n # modulus sets the current decimal as the most significant\r\n # decimal\r\n # floor div selects the most significant decimal\r\n result_no_carry += arg % 10**pwr // 10**(pwr - 1)\r\n\r\n # list comprehension way\r\n # result_no_carry = sum([arg % 10**pwr // 10**(pwr - 1) for arg in args if len(str(arg)) >= pwr])\r\n\r\n # final_sum = str(result_no_carry % 10) + final_sum\r\n final_sum += result_no_carry % 10\r\n\r\n return int(final_sum)","def calculate(candidate, roles_of_module):\n\n # See find_solution for explanation on the try method\n try:\n to_deploy_list, roles_left = deploy_players(candidate,\n roles_of_module,\n 'adapted')\n\n # If the roles to deploy can be covered with a malus we return the\n # number of malus assigned\n\n if malus_roles_left(to_deploy_list, roles_left):\n return malus_roles_left(to_deploy_list, roles_left)\n else:\n return False\n\n except TypeError:\n return False","def digitSum ( n ) :\n return sum ( map ( int , str ( n ) ) )","def digit_sum(n):\n\treturn sum(int(c) for c in str(n))","def siruta_is_valid(self, siruta):\n if type(siruta) != int:\n siruta = int(siruta)\n if siruta >= 10**6:\n return False\n weights = [1, 2, 3, 5, 7]\n checksum = 0\n checkdigit = siruta % 10\n index = 0\n while (index < 5):\n siruta = int(siruta / 10)\n left = (siruta % 10) * weights[index]\n checksum += sum(map(int, str(left))) # sum of digits of left\n index += 1\n checksum %= 10\n checksum = 11 - checksum\n checksum %= 10\n return checksum == checkdigit","def verify(isbn):\n\n isbn = isbn.replace(\"-\", \"\")\n if not verify_format(isbn):\n return False\n\n isbn_sum = 0\n for digit, i in zip(isbn, range(10, 0, -1)):\n if digit == \"X\":\n isbn_sum += 10 * i\n else:\n isbn_sum += int(digit) * i\n\n return isbn_sum % 11 == 0","def check_prize(correct_num):","def sum_cubes(a:int) -> bool:\n tens = a // 10\n units = a % 10\n total = 4 * (tens ** 3 + units ** 3)\n return(total == a ** 2)","def sum_digits(n):\n \"*** YOUR CODE HERE ***\"\n count=0\n length=len(str(n))\n last=0\n sum=0\n while count<length:\n last=n%10\n n//=10\n sum+=last\n count+=1\n return sum","def judge(n1: List[int], n2: List[int]) -> int:\n\tmin_length = min(len(n1),len(n2))\n\tpass_count = 0\n\tfor i in range(min_length):\n\t\tpass_count += get_lowest_16(n1[i]) == get_lowest_16(n2[i])\n\n\treturn pass_count","def is_code_valid_checksum(processed_code):\n\n if processed_code.isnumeric():\n list_of_digits = [int(digit) for digit in processed_code]\n else:\n converted_digits = convert_code_to_decimal(processed_code)\n list_of_digits = [int(digit) for digit in converted_digits]\n\n return sum(list_of_digits) > 0 and get_calculated_checksum(list_of_digits) % 11 == 0","def sum_digits(n):\n num = n\n incTen = 1\n summy = 0\n if num > 10:\n while incTen * 10 < num:\n incTen = incTen * 10\n while incTen >= 10:\n summy += num // incTen\n num = num % incTen\n incTen = incTen // 10\n summy += num\n return summy\n elif num == 10:\n return 1\n else:\n return num","def is_sum(check_list, number):\n for i, num1 in enumerate(check_list):\n for num2 in check_list[i+1:]:\n if num1 + num2 == number and num1 != num2:\n return True\n return False","def test_fasle_is_armstrongs(number: int):\n assert is_armstrong(number) is False","def ndigits(n):\n return len(str(abs(n)))","def checksum(number):\n return sum(i * int(n) for i, n in enumerate(reversed(number), 1)) % 11","def checks(candidate, primeList, r = 10):\n\n ############ 6k BASIC CHECK #########\n # all primes > 3 are of the form 6k + 1 or 6k -1 so skip testing any not of this form\n mod6 = candidate % 6\n\n if candidate > 3 and mod6 != 1 and mod6 != 5:\n return False # if check fails return False\n\n ############ TRIAL-DIVISION CHECK #########\n if not trialDivision(candidate, primeList):\n return False # if check fails return False\n\n ############ Miller-Rabin CHECK #########\n return millerRabin(candidate, r)","def print_if_armstrong(start, end):\n for i in range(start, end):\n h, t, u = get_digits(i)\n if i == h**3 + t**3 + u**3 :\n print(i)","def digit_sum(n):\n s = 0\n while n:\n s += n % 10\n n //= 10\n return s","def is_perfect_number(x):\n return sum(proper_divisors(x)) == x","def test_count_459(self):\n value: int = 459\n result: int = 148\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')","def blackjack_result(cards):\n sum = 0\n a_cards = 0\n dictionary = {\n '2': 2,\n '3': 3,\n '4': 4,\n '5': 5,\n '6': 6,\n '7': 7,\n '8': 8,\n '9': 9,\n 'T': 10,\n 'J': 10,\n 'Q': 10,\n 'K': 10,\n }\n for card in cards.split():\n if card in dictionary:\n sum = sum + dictionary[card]\n elif card == 'A':\n a_cards = a_cards + 1\n\n if a_cards > 0:\n for i in range(a_cards):\n if a_cards > 1:\n sum = sum + 1\n a_cards = a_cards - 1\n else:\n if sum + 11 < 22:\n sum = sum + 11\n else:\n sum = sum + 1\n\n return sum","def luhn(card_number):\n card_number = str(card_number)\n sum = 0\n num_digits = len(card_number)\n odd_even = num_digits & 1\n\n for i in range(0, num_digits):\n digit = int(card_number[i])\n if not (( i & 1 ) ^ odd_even ):\n digit = digit * 2\n if digit > 9:\n digit = digit - 9\n sum = sum + digit\n\n return (sum % 10) == 0","def check_sum(self) -> str:\n pass","def calculate_checksum(code):\n\n sum_odd = reduce(sum_chars, code[::2])\n sum_even = reduce(sum_chars, code[1:-1:2])\n check = (sum_even + sum_odd * 3) % 10\n\n if check == 0:\n return 0\n else:\n return 10 - check","def test_if_it_outputs_correct_output_for_numbers_greater_than_50(self):\n self.assertEquals(len(prime_numbers(55)), 16)","def total_number_of_residues(self, jdict):\n chain_sizes = jdict[\"chain_sizes\"]\n total = 0\n if chain_sizes == None:\n return \"NULL\"\n\n ## Sum total number of residues from each chain (ignore type)\n for c in chain_sizes.split(';'):\n chid, length, selected, type = misc.parse_chains(c)\n if selected == \"1\":\n total += int(length)\n\n return total","def check_mountain_number(n):\n def helper(x, is_incresing):\n if x // 10 == 0:\n return True\n if is_incresing and (x % 10) < ((x // 10) % 10):\n return helper(x // 10, is_incresing)\n return (x % 10) > ((x // 10) % 10) and helper(x // 10, False)\n return helper(n, True)","def calculate_candidate(gram_list, candidate):\n gram_sub_str = ' '.join(gram_list)\n return len(re.findall(gram_sub_str, candidate))","def test_count_1719(self):\n value: int = 2645\n result: int = 1113\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')","def count_digits(n):\n return len(str(n))","def calculate_candidate(gram_list, candidate):\r\n gram_sub_str = ' '.join(gram_list)\r\n return len(re.findall(gram_sub_str, candidate))","def test_count_770(self):\n value: int = 770\n result: int = 306\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')","def sum_of_digits_in_number(n: int) -> int:\n return sum(int(digit) for digit in str(n))","def total(self):\n for card in self.cards:\n if not card.value:\n return 0\n t = 0\n for card in self.cards:\n t += card.value\n contains_ace = False\n for card in self.cards:\n if card.value == BJ_Card.ACE_VALUE:\n contains_ace = True\n if contains_ace and t <= 11:\n t += 10\n return t","def solve() -> int:\n\n return sum(1 for n in range(1, 10_000) if is_lychrel(n))","def sum_digits(n):\n if (n < 10):\n return n\n else:\n all_but_last, last = split(n)\n return sum_digits(all_but_last) + last","def isbn_10_check_digit(nine_digits):\r\n if len(nine_digits) != 9: return None\r\n try: int(nine_digits)\r\n except: return None\r\n remainder = int(sum((i + 2) * int(x) for i, x in enumerate(reversed(nine_digits))) % 11)\r\n if remainder == 0: tenth_digit = 0\r\n else: tenth_digit = 11 - remainder\r\n if tenth_digit == 10: tenth_digit = 'X'\r\n return str(tenth_digit)","def checksum(n):\n\n # Compute the sum of the non-check digits.\n s = sum(luhn_digits(n * 10))\n\n # Multiply by 9.\n result = s * 9\n\n # The units digit is the check digit\n check_digit = result % 10\n\n m = int(str(n) + str(check_digit))\n assert(verify(m))\n\n return check_digit","def test_count_770_000(self):\n value: int = 770_000\n result: int = 410_562\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')","def sum_of_digits(n):\n return sum(int(c) for c in str(n))","def check_digit(raw_code):\n s = sum(code(char) * 2**index for index, char in enumerate(raw_code))\n return s % 11 % 10","def check_sum(num_list: list) -> bool:\r\n num_list_len = len(num_list)\r\n\r\n if num_list_len <= 0:\r\n return False\r\n\r\n for i in range(num_list_len):\r\n for j in range(i+1, num_list_len):\r\n if num_list[i] + num_list[j] == 0:\r\n return True\r\n return False","def test_count_361_077(self):\n value: int = 361_077\n result: int = 188_065\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')","def sum_of_digits(n):\n rest_of_num, last_num = split(n)\n if rest_of_num < 10:\n \treturn last_num + rest_of_num\n return last_num + sum_of_digits(rest_of_num)","def luhn_algo(num):\n sum = 0\n num_string = str(num) # Converts num into string type\n # Starts with second to last digit\n # iterates by -2 until length of string is reached\n for i in range(-2, -len(num_string) - 1, -2):\n dig_product = int(num_string[i]) * 2\n if dig_product > 9: # If product is 2 digits, sum both individual digits\n sum += dig_product % 10\n sum += dig_product // 10 # int division to get first digit\n else:\n sum += dig_product % 10\n for i in range(-1, -len(num_string) - 1, -2):\n sum += int(num_string[i])\n return sum","def test_true_is_armstrong(number: int):\n assert is_armstrong(number)","def digit_sum(n):\n sum_of_digits = 0\n for c in str(n):\n sum_of_digits += int(c)\n return sum_of_digits","def is_amnicable(num):\n\n # Because d(m) = d(n) = s(m) + s(n)\n # so d(s(m) - m) = d(n)\n result = divisor(1, num)\n\n # s(n) and n is supposed to be\n # different numbers so not amnicable\n if 2 * num == result:\n return False\n\n result2 = divisor(1, result - num)\n return result == result2","def calculate_digits_sum(number: int) -> int:\n\n # Return value\n ret = 0\n\n while number != 0:\n # Extract the last digit number and add it to ret\n ret += number % 10\n\n # Delete the last digit of the number\n number //= 10\n\n return ret","def count_divisible_digits(n, m):\n result = 0\n if m == 0:\n return 0\n n = abs(n)\n while n != 0:\n temp = n % 10\n if temp % m == 0:\n result += 1\n n = n // 10\n return result","def sum_of_digits(number):\n \n if number < 0:\n number = -number\n \n digit_sum = 0\n while True:\n if number == 0:\n break\n digit = number % 10 # Get the digit\n digit_sum = digit_sum + digit # Accumulate it into the sum\n number = number // 10 # Get ready for the next digit\n \n return digit_sum","def makes10(a, b):\n if a == 10: \n return True\n elif b == 10: \n return True \n elif a + b == 10: \n return True\n else: \n return False","def sat(nums: List[int], n=12345):\n return len(nums) <= 4 and sum(i ** 2 for i in nums) == n","def rabinMillerPassed(mrc, rabin_miller_rounds):\n maxDivisionsByTwo = 0\n ec = mrc - 1\n while ec % 2 == 0:\n ec >>= 1\n maxDivisionsByTwo += 1\n assert (2 ** maxDivisionsByTwo * ec == mrc - 1)\n\n def trialComposite(round_tester):\n if pow(round_tester, ec, mrc) == 1:\n return False\n for i in range(maxDivisionsByTwo):\n if pow(round_tester, 2 ** i * ec, mrc) == mrc - 1:\n return False\n return True\n\n # Set number of trials here\n for i in range(rabin_miller_rounds):\n round_tester = random.randrange(2, mrc)\n if trialComposite(round_tester):\n return False\n return True","def sum_digits(n):\n digits = [int(i) for i in str(n)]\n return sum(digits)","def sum_digits(n):\n sum = 0\n while n > 0:\n num = n % 10\n sum += num\n n //= 10\n return sum","def perfect_num(number):\n new_list=[]\n for indx in range(1,number):\n if number % indx==0:\n new_list.append(indx)\n total=sum(new_list)\n if total==number:\n return True\n else:\n return False","def oracle(ct: int) -> bool:\n return rsa.dec(ct) & 1 == 0","def challenge_solver(number1, number2, threshold):\n return (sum_of_n_terms(number1, threshold)\n + sum_of_n_terms(number2, threshold)\n - sum_of_n_terms(number1 * number2, threshold))","def test_count_2645(self):\n value: int = 1719\n result: int = 723\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')","def luhn_verifica(ccred):\n \n # Primeiro criamos uma nova cadeia, n, com os digitos do cartao de credito sem o de controle.\n # Usamos a funcao calc_soma para somar os digitos do cartao de acordo com o algoritmo de Luhn e juntamos o digito de controle. Caso este ultimo nao seja um algarismo, chamamos a atencao ao utilizador para o erro.\n # Caso o resto da divisao por 10 seja 0, a funcao devolve o valor logico True. \n \n\n n = ccred[:-1]\n dig_verificacao = ccred[-1]\n \n if '0' <= dig_verificacao <= '9':\n soma = calc_soma(n) + eval(dig_verificacao)\n \n else:\n raise ValueError ('function luhn_verifica() O string recebido apenas pode conter digitos') \n \n return soma % 10 == 0","def is_abundant_number(x):\n return sum(proper_divisors(x)) > x"],"string":"[\n \"def armstrong_sum(armstrong_candidate: int, nr_digits: int) -> int:\\n a_sum = 0\\n\\n while armstrong_candidate != 0:\\n digit_in_armstrong_candidate = armstrong_candidate % 10\\n a_sum += digit_in_armstrong_candidate ** nr_digits\\n armstrong_candidate = int(armstrong_candidate / 10)\\n return a_sum\",\n \"def nr_digits_number(armstrong_candidate: int) -> int:\\n number_of_digits = 0\\n while armstrong_candidate != 0:\\n armstrong_candidate = int(armstrong_candidate / 10)\\n number_of_digits += 1\\n\\n return number_of_digits\",\n \"def check_if_armstrong_number(number):\\n sum = 0\\n number_as_string = str(number)\\n digits_number = len(number_as_string)\\n for character in number_as_string:\\n sum += int(character) ** digits_number\\n\\n return sum == number\",\n \"def is_armstrong(number):\\n return number == reduce(lambda x, y: x + y,\\n map(lambda x: int(x) ** len(str(number)),\\n str(number)))\",\n \"def is_armstrong_number(number: int) -> bool:\\n result = 0\\n num_str = str(number)\\n for i in num_str:\\n result += int(i) ** len(num_str)\\n return result == number\",\n \"def is_armstrong_number(number: int) -> bool:\\n\\n str_number = f\\\"{number}\\\"\\n return sum(pow(int(x), len(str_number)) for x in str_number) == number\",\n \"def check_number(self):\\n digits = self.number\\n _sum = 0\\n alt = False\\n ix = []\\n for x in str(digits):\\n ix.append(int(x))\\n for d in reversed(ix):\\n assert 0 <= d <= 9\\n if alt:\\n d *= 2\\n if d > 9:\\n d -= 9\\n _sum += d\\n alt = not alt\\n return (_sum % 10) == 0\",\n \"def sumDigit():\",\n \"def is_armstrong_number(number: int) -> bool:\\n return get_armstrong_value(number) == number\",\n \"def calc_check_digit(number):\\n weights = (2, 4, 8, 5, 10, 9, 7, 3, 6)\\n return str(sum(w * int(n) for w, n in zip(weights, number)) % 11 % 10)\",\n \"def amstrong(num) :\\r\\n sum = 0\\r\\n temp = num\\r\\n order=len(str(num))\\r\\n while num > 0 :\\r\\n r = num % 10\\r\\n sum += r ** order\\r\\n num //= 10\\r\\n\\r\\n if sum == temp :\\r\\n print(f\\\"{sum} is Amstrong Number\\\")\\r\\n else :\\r\\n print(\\\"Number is not Amstrong Number\\\")\",\n \"def get_armstrong_value(number: int) -> int:\\n armstrong_value: list = []\\n number_len: int = len(str(number))\\n\\n for digit in str(number):\\n armstrong_value.append(int(digit) ** number_len)\\n return sum(armstrong_value)\",\n \"def calc_check_digit(number):\\n number = compact(number)\\n alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\\n weights = (29, 23, 19, 17, 13, 7, 5, 3)\\n if not isdigits(number):\\n number = number[0] + str('ABCEHKMOPT'.index(number[1])) + number[2:]\\n c = sum(w * alphabet.index(n) for w, n in zip(weights, number)) % 11\\n if c > 9:\\n raise InvalidChecksum()\\n return str(c)\",\n \"def verify(n):\\n\\n # Take the sum of all digits.\\n sum_of_digits = sum(luhn_digits(n))\\n\\n # The number is valid iff the sum of digits modulo 10 is equal to 0\\n return sum_of_digits % 10 == 0\",\n \"def generate_check_sum(account_id):\\n card_number = str(Bank.iin) + str(account_id).zfill(9)\\n step_one = []\\n for i in range(len(card_number)):\\n digit = int(card_number[i])\\n if i % 2 == 0:\\n digit *= 2\\n if digit > 9:\\n digit -= 9\\n step_one.append(digit)\\n step_two = sum(step_one)\\n remainder = step_two % 10\\n check_sum = (10 - remainder) if remainder else remainder\\n return check_sum\",\n \"def check(card_number):\\n if re.search(r'\\\\d{4} \\\\d{4} \\\\d{4} \\\\d{4}', card_number): \\n if sum(int(c) for c in card_number.replace(\\\" \\\",\\\"\\\"))%10 == 0:\\n return True\",\n \"def check_digit(tracking_number):\\n check_digit = 10 - ((sum(itertools.starmap(operator.mul, zip(itertools.cycle((3, 1)), map(int, str(tracking_number))))) + 1) % 10)\\n if check_digit == 10:\\n check_digit = 0\\n return check_digit\",\n \"def problem33(nr_digits):\\n\\n a_sum = 1\\n b_sum = 1\\n for a in range(10**(nr_digits - 1), (10**nr_digits) - 1):\\n for b in range(a + 1, 10**nr_digits):\\n # print(a/b);\\n\\n a_str = str(a)\\n b_str = str(b)\\n\\n for sa in range(0, nr_digits):\\n if a_str[sa] == '0':\\n continue\\n\\n # check in b\\n for sb in range(0, nr_digits):\\n if (a_str[sa] == b_str[sb]):\\n a_short = a_str[:sa] + a_str[sa + 1:]\\n b_short = b_str[:sb] + b_str[sb + 1:]\\n a_short_int = int(a_short)\\n b_short_int = int(b_short)\\n if (b_short_int == 0):\\n continue\\n\\n if (a / b == a_short_int / b_short_int):\\n a_sum *= a_short_int\\n b_sum *= b_short_int\\n #print(a_str, \\\"/\\\", b_str, \\\"->\\\",\\n # a_short, \\\"/\\\", b_short)\\n\\n return Fraction(a_sum, b_sum).denominator\",\n \"def calculate_luhn_check_digit(partial_card_number):\\n checksum = luhn_checksum(int(partial_card_number) * 10)\\n if checksum == 0:\\n check_digit = 0\\n else:\\n check_digit = 10 - checksum\\n return check_digit\",\n \"def test_hackerrank_sample1(self):\\n result = find_digits(12)\\n self.assertEquals(result, 2)\",\n \"def validate(number):\\n # numbers only:\\n try:\\n long(number)\\n except:\\n return 0\\n\\n # must be at least 13 digits:\\n if len(str(number)) < 13:\\n return 0\\n\\n # can't be all zeros, even though this passes the check below\\n if long(number) == 0:\\n return 0\\n \\n ### check the digits: ###########\\n # see http://www.beachnet.com/~hstiles/cardtype.html\\n\\n # digits, from right to left...\\n digits = list(str(number))\\n digits.reverse()\\n\\n doubles = \\\"\\\"\\n sum = 0\\n # Step 1: Double the value of alternate digits of the primary\\n # account number beginning with the second digit from the right\\n # (the first right--hand digit is the check digit.)\\n for i in range(len(digits)):\\n if i % 2:\\n # note that this does NOT fire for the rightmost digit,\\n # because 0 % 2 is 0... :)\\n doubles = doubles + str(int(digits[i]) * 2)\\n\\n # Step 2: Add the individual digits comprising the products\\n # obtained in Step 1 to each of the unaffected digits in the\\n # original number.\\n else:\\n sum = sum + int(digits[i])\\n\\n for ch in doubles:\\n sum = sum + int(ch)\\n\\n # Step 3: The total obtained in Step 2 must be a number ending in\\n # zero (30, 40, 50, etc.) for the account number to be validated.\\n if (sum % 10) != 0:\\n return 0\\n\\n return 1\",\n \"def verify_sum_of_million_complexities():\\n assert 39519866 == integer_complexity.get_integer_complexity_sum(1000000)\",\n \"def answer(n_digits):\\n\\n best = 0\\n pairs = combinations(xrange(10 ** (n_digits - 1), 10 ** (n_digits)), 2)\\n\\n for (x, y) in pairs:\\n prod = str(x * y)\\n if prod == prod[::-1]:\\n best = max(best, x * y)\\n\\n return best\",\n \"def lv_checksum(value):\\n multipliers = (1, 6, 3, 7, 9, 10, 5, 8, 4, 2)\\n\\n check = sum(mult * int(c) for mult, c in zip(multipliers, value))\\n return ((1 - check) % 11) % 10\",\n \"def has_valid_sum(self):\\n return 1 - MassFunction.precision <= self._sum() <= 1 + MassFunction.precision\",\n \"def cardLuhnChecksumIsValid(card_number):\\n sum = 0\\n num_digits = len(card_number)\\n oddeven = num_digits & 1\\n for count in range(0, num_digits):\\n digit = int(card_number[count])\\n if not (( count & 1 ) ^ oddeven ):\\n digit = digit * 2\\n if digit > 9:\\n digit = digit - 9\\n sum = sum + digit\\n return ( (sum % 10) == 0 )\",\n \"def solution(x):\\n if x is None:\\n return x\\n return total_digits(x)\",\n \"def test_hackerrank_sample2(self):\\n result = find_digits(1012)\\n self.assertEquals(result, 3)\",\n \"def isbn_check_digit(isbn):\\n return (11 - (sum(x * y for (x, y) in enumerate(reversed(isbn), start=2))\\n % 11)) % 11\",\n \"def valid_checkdigit(ccnum):\\n\\n sum = 0\\n num_digits = len(ccnum)\\n oddeven = num_digits & 1\\n\\n for count in range(0, num_digits):\\n digit = int(ccnum[count])\\n\\n if not ((count & 1) ^ oddeven):\\n digit = digit * 2\\n if digit > 9:\\n digit = digit - 9\\n\\n sum = sum + digit\\n\\n return ((sum % 10) == 0)\",\n \"def narcissistic(*, value: int) -> bool:\\n # solution one line code\\n # return sum([int(number)**len(str(value)) for number in str(value)]) == value\\n if not value:\\n return False\\n\\n result = 0\\n for number in str(value):\\n result += int(number)**len(str(value))\\n return result == value\",\n \"def digital_sum(n):\\n r = 0\\n while n:\\n r, n = r + n % 10, n // 10\\n return r\",\n \"def test_luhn_checksum(self):\\n check_digit = calculate_luhn(\\\"7992739871\\\")\\n assert check_digit == 3\",\n \"def check_similar_number(n, d) -> (int, bool):\\n \\n num = str(n)\\n den = str(d)\\n uniques = set(num + den)\\n total_similar = 0\\n answer = 0\\n\\n for u in uniques:\\n if (u in num) and (u in den):\\n total_similar += 1\\n answer = int(u)\\n\\n if total_similar == 1:\\n return answer, True\\n\\n return 0, False\",\n \"def meets_criteria2(num):\\n output = True\\n if not exactly_two_same_digits(num):\\n output = False\\n if not digits_increase(num):\\n output = False\\n return output\",\n \"def square_digit_sum(number):\\n return sum(precomputed_digit_squares[digit] for digit in str(number))\",\n \"def check_input_digits_count(self):\\n check = len(str(self.input)) == 4\\n return check\",\n \"def add_no_carry(*args):\\r\\n num_digits = []\\r\\n\\r\\n for arg in args:\\r\\n num_digits.append(len(str(arg)))\\r\\n\\r\\n max_digits = max(num_digits)\\r\\n # list comprehension way\\r\\n # max_digits = max([len(str(arg)) for arg in args])\\r\\n final_sum = 0\\r\\n\\r\\n for pwr in range(1, max_digits + 1): # iterate through ea decimal\\r\\n result_no_carry = 0\\r\\n for arg in args:\\r\\n if len(str(arg)) >= pwr:\\r\\n # modulus sets the current decimal as the most significant\\r\\n # decimal\\r\\n # floor div selects the most significant decimal\\r\\n result_no_carry += arg % 10**pwr // 10**(pwr - 1)\\r\\n\\r\\n # list comprehension way\\r\\n # result_no_carry = sum([arg % 10**pwr // 10**(pwr - 1) for arg in args if len(str(arg)) >= pwr])\\r\\n\\r\\n # final_sum = str(result_no_carry % 10) + final_sum\\r\\n final_sum += result_no_carry % 10\\r\\n\\r\\n return int(final_sum)\",\n \"def calculate(candidate, roles_of_module):\\n\\n # See find_solution for explanation on the try method\\n try:\\n to_deploy_list, roles_left = deploy_players(candidate,\\n roles_of_module,\\n 'adapted')\\n\\n # If the roles to deploy can be covered with a malus we return the\\n # number of malus assigned\\n\\n if malus_roles_left(to_deploy_list, roles_left):\\n return malus_roles_left(to_deploy_list, roles_left)\\n else:\\n return False\\n\\n except TypeError:\\n return False\",\n \"def digitSum ( n ) :\\n return sum ( map ( int , str ( n ) ) )\",\n \"def digit_sum(n):\\n\\treturn sum(int(c) for c in str(n))\",\n \"def siruta_is_valid(self, siruta):\\n if type(siruta) != int:\\n siruta = int(siruta)\\n if siruta >= 10**6:\\n return False\\n weights = [1, 2, 3, 5, 7]\\n checksum = 0\\n checkdigit = siruta % 10\\n index = 0\\n while (index < 5):\\n siruta = int(siruta / 10)\\n left = (siruta % 10) * weights[index]\\n checksum += sum(map(int, str(left))) # sum of digits of left\\n index += 1\\n checksum %= 10\\n checksum = 11 - checksum\\n checksum %= 10\\n return checksum == checkdigit\",\n \"def verify(isbn):\\n\\n isbn = isbn.replace(\\\"-\\\", \\\"\\\")\\n if not verify_format(isbn):\\n return False\\n\\n isbn_sum = 0\\n for digit, i in zip(isbn, range(10, 0, -1)):\\n if digit == \\\"X\\\":\\n isbn_sum += 10 * i\\n else:\\n isbn_sum += int(digit) * i\\n\\n return isbn_sum % 11 == 0\",\n \"def check_prize(correct_num):\",\n \"def sum_cubes(a:int) -> bool:\\n tens = a // 10\\n units = a % 10\\n total = 4 * (tens ** 3 + units ** 3)\\n return(total == a ** 2)\",\n \"def sum_digits(n):\\n \\\"*** YOUR CODE HERE ***\\\"\\n count=0\\n length=len(str(n))\\n last=0\\n sum=0\\n while count<length:\\n last=n%10\\n n//=10\\n sum+=last\\n count+=1\\n return sum\",\n \"def judge(n1: List[int], n2: List[int]) -> int:\\n\\tmin_length = min(len(n1),len(n2))\\n\\tpass_count = 0\\n\\tfor i in range(min_length):\\n\\t\\tpass_count += get_lowest_16(n1[i]) == get_lowest_16(n2[i])\\n\\n\\treturn pass_count\",\n \"def is_code_valid_checksum(processed_code):\\n\\n if processed_code.isnumeric():\\n list_of_digits = [int(digit) for digit in processed_code]\\n else:\\n converted_digits = convert_code_to_decimal(processed_code)\\n list_of_digits = [int(digit) for digit in converted_digits]\\n\\n return sum(list_of_digits) > 0 and get_calculated_checksum(list_of_digits) % 11 == 0\",\n \"def sum_digits(n):\\n num = n\\n incTen = 1\\n summy = 0\\n if num > 10:\\n while incTen * 10 < num:\\n incTen = incTen * 10\\n while incTen >= 10:\\n summy += num // incTen\\n num = num % incTen\\n incTen = incTen // 10\\n summy += num\\n return summy\\n elif num == 10:\\n return 1\\n else:\\n return num\",\n \"def is_sum(check_list, number):\\n for i, num1 in enumerate(check_list):\\n for num2 in check_list[i+1:]:\\n if num1 + num2 == number and num1 != num2:\\n return True\\n return False\",\n \"def test_fasle_is_armstrongs(number: int):\\n assert is_armstrong(number) is False\",\n \"def ndigits(n):\\n return len(str(abs(n)))\",\n \"def checksum(number):\\n return sum(i * int(n) for i, n in enumerate(reversed(number), 1)) % 11\",\n \"def checks(candidate, primeList, r = 10):\\n\\n ############ 6k BASIC CHECK #########\\n # all primes > 3 are of the form 6k + 1 or 6k -1 so skip testing any not of this form\\n mod6 = candidate % 6\\n\\n if candidate > 3 and mod6 != 1 and mod6 != 5:\\n return False # if check fails return False\\n\\n ############ TRIAL-DIVISION CHECK #########\\n if not trialDivision(candidate, primeList):\\n return False # if check fails return False\\n\\n ############ Miller-Rabin CHECK #########\\n return millerRabin(candidate, r)\",\n \"def print_if_armstrong(start, end):\\n for i in range(start, end):\\n h, t, u = get_digits(i)\\n if i == h**3 + t**3 + u**3 :\\n print(i)\",\n \"def digit_sum(n):\\n s = 0\\n while n:\\n s += n % 10\\n n //= 10\\n return s\",\n \"def is_perfect_number(x):\\n return sum(proper_divisors(x)) == x\",\n \"def test_count_459(self):\\n value: int = 459\\n result: int = 148\\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')\",\n \"def blackjack_result(cards):\\n sum = 0\\n a_cards = 0\\n dictionary = {\\n '2': 2,\\n '3': 3,\\n '4': 4,\\n '5': 5,\\n '6': 6,\\n '7': 7,\\n '8': 8,\\n '9': 9,\\n 'T': 10,\\n 'J': 10,\\n 'Q': 10,\\n 'K': 10,\\n }\\n for card in cards.split():\\n if card in dictionary:\\n sum = sum + dictionary[card]\\n elif card == 'A':\\n a_cards = a_cards + 1\\n\\n if a_cards > 0:\\n for i in range(a_cards):\\n if a_cards > 1:\\n sum = sum + 1\\n a_cards = a_cards - 1\\n else:\\n if sum + 11 < 22:\\n sum = sum + 11\\n else:\\n sum = sum + 1\\n\\n return sum\",\n \"def luhn(card_number):\\n card_number = str(card_number)\\n sum = 0\\n num_digits = len(card_number)\\n odd_even = num_digits & 1\\n\\n for i in range(0, num_digits):\\n digit = int(card_number[i])\\n if not (( i & 1 ) ^ odd_even ):\\n digit = digit * 2\\n if digit > 9:\\n digit = digit - 9\\n sum = sum + digit\\n\\n return (sum % 10) == 0\",\n \"def check_sum(self) -> str:\\n pass\",\n \"def calculate_checksum(code):\\n\\n sum_odd = reduce(sum_chars, code[::2])\\n sum_even = reduce(sum_chars, code[1:-1:2])\\n check = (sum_even + sum_odd * 3) % 10\\n\\n if check == 0:\\n return 0\\n else:\\n return 10 - check\",\n \"def test_if_it_outputs_correct_output_for_numbers_greater_than_50(self):\\n self.assertEquals(len(prime_numbers(55)), 16)\",\n \"def total_number_of_residues(self, jdict):\\n chain_sizes = jdict[\\\"chain_sizes\\\"]\\n total = 0\\n if chain_sizes == None:\\n return \\\"NULL\\\"\\n\\n ## Sum total number of residues from each chain (ignore type)\\n for c in chain_sizes.split(';'):\\n chid, length, selected, type = misc.parse_chains(c)\\n if selected == \\\"1\\\":\\n total += int(length)\\n\\n return total\",\n \"def check_mountain_number(n):\\n def helper(x, is_incresing):\\n if x // 10 == 0:\\n return True\\n if is_incresing and (x % 10) < ((x // 10) % 10):\\n return helper(x // 10, is_incresing)\\n return (x % 10) > ((x // 10) % 10) and helper(x // 10, False)\\n return helper(n, True)\",\n \"def calculate_candidate(gram_list, candidate):\\n gram_sub_str = ' '.join(gram_list)\\n return len(re.findall(gram_sub_str, candidate))\",\n \"def test_count_1719(self):\\n value: int = 2645\\n result: int = 1113\\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')\",\n \"def count_digits(n):\\n return len(str(n))\",\n \"def calculate_candidate(gram_list, candidate):\\r\\n gram_sub_str = ' '.join(gram_list)\\r\\n return len(re.findall(gram_sub_str, candidate))\",\n \"def test_count_770(self):\\n value: int = 770\\n result: int = 306\\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')\",\n \"def sum_of_digits_in_number(n: int) -> int:\\n return sum(int(digit) for digit in str(n))\",\n \"def total(self):\\n for card in self.cards:\\n if not card.value:\\n return 0\\n t = 0\\n for card in self.cards:\\n t += card.value\\n contains_ace = False\\n for card in self.cards:\\n if card.value == BJ_Card.ACE_VALUE:\\n contains_ace = True\\n if contains_ace and t <= 11:\\n t += 10\\n return t\",\n \"def solve() -> int:\\n\\n return sum(1 for n in range(1, 10_000) if is_lychrel(n))\",\n \"def sum_digits(n):\\n if (n < 10):\\n return n\\n else:\\n all_but_last, last = split(n)\\n return sum_digits(all_but_last) + last\",\n \"def isbn_10_check_digit(nine_digits):\\r\\n if len(nine_digits) != 9: return None\\r\\n try: int(nine_digits)\\r\\n except: return None\\r\\n remainder = int(sum((i + 2) * int(x) for i, x in enumerate(reversed(nine_digits))) % 11)\\r\\n if remainder == 0: tenth_digit = 0\\r\\n else: tenth_digit = 11 - remainder\\r\\n if tenth_digit == 10: tenth_digit = 'X'\\r\\n return str(tenth_digit)\",\n \"def checksum(n):\\n\\n # Compute the sum of the non-check digits.\\n s = sum(luhn_digits(n * 10))\\n\\n # Multiply by 9.\\n result = s * 9\\n\\n # The units digit is the check digit\\n check_digit = result % 10\\n\\n m = int(str(n) + str(check_digit))\\n assert(verify(m))\\n\\n return check_digit\",\n \"def test_count_770_000(self):\\n value: int = 770_000\\n result: int = 410_562\\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')\",\n \"def sum_of_digits(n):\\n return sum(int(c) for c in str(n))\",\n \"def check_digit(raw_code):\\n s = sum(code(char) * 2**index for index, char in enumerate(raw_code))\\n return s % 11 % 10\",\n \"def check_sum(num_list: list) -> bool:\\r\\n num_list_len = len(num_list)\\r\\n\\r\\n if num_list_len <= 0:\\r\\n return False\\r\\n\\r\\n for i in range(num_list_len):\\r\\n for j in range(i+1, num_list_len):\\r\\n if num_list[i] + num_list[j] == 0:\\r\\n return True\\r\\n return False\",\n \"def test_count_361_077(self):\\n value: int = 361_077\\n result: int = 188_065\\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')\",\n \"def sum_of_digits(n):\\n rest_of_num, last_num = split(n)\\n if rest_of_num < 10:\\n \\treturn last_num + rest_of_num\\n return last_num + sum_of_digits(rest_of_num)\",\n \"def luhn_algo(num):\\n sum = 0\\n num_string = str(num) # Converts num into string type\\n # Starts with second to last digit\\n # iterates by -2 until length of string is reached\\n for i in range(-2, -len(num_string) - 1, -2):\\n dig_product = int(num_string[i]) * 2\\n if dig_product > 9: # If product is 2 digits, sum both individual digits\\n sum += dig_product % 10\\n sum += dig_product // 10 # int division to get first digit\\n else:\\n sum += dig_product % 10\\n for i in range(-1, -len(num_string) - 1, -2):\\n sum += int(num_string[i])\\n return sum\",\n \"def test_true_is_armstrong(number: int):\\n assert is_armstrong(number)\",\n \"def digit_sum(n):\\n sum_of_digits = 0\\n for c in str(n):\\n sum_of_digits += int(c)\\n return sum_of_digits\",\n \"def is_amnicable(num):\\n\\n # Because d(m) = d(n) = s(m) + s(n)\\n # so d(s(m) - m) = d(n)\\n result = divisor(1, num)\\n\\n # s(n) and n is supposed to be\\n # different numbers so not amnicable\\n if 2 * num == result:\\n return False\\n\\n result2 = divisor(1, result - num)\\n return result == result2\",\n \"def calculate_digits_sum(number: int) -> int:\\n\\n # Return value\\n ret = 0\\n\\n while number != 0:\\n # Extract the last digit number and add it to ret\\n ret += number % 10\\n\\n # Delete the last digit of the number\\n number //= 10\\n\\n return ret\",\n \"def count_divisible_digits(n, m):\\n result = 0\\n if m == 0:\\n return 0\\n n = abs(n)\\n while n != 0:\\n temp = n % 10\\n if temp % m == 0:\\n result += 1\\n n = n // 10\\n return result\",\n \"def sum_of_digits(number):\\n \\n if number < 0:\\n number = -number\\n \\n digit_sum = 0\\n while True:\\n if number == 0:\\n break\\n digit = number % 10 # Get the digit\\n digit_sum = digit_sum + digit # Accumulate it into the sum\\n number = number // 10 # Get ready for the next digit\\n \\n return digit_sum\",\n \"def makes10(a, b):\\n if a == 10: \\n return True\\n elif b == 10: \\n return True \\n elif a + b == 10: \\n return True\\n else: \\n return False\",\n \"def sat(nums: List[int], n=12345):\\n return len(nums) <= 4 and sum(i ** 2 for i in nums) == n\",\n \"def rabinMillerPassed(mrc, rabin_miller_rounds):\\n maxDivisionsByTwo = 0\\n ec = mrc - 1\\n while ec % 2 == 0:\\n ec >>= 1\\n maxDivisionsByTwo += 1\\n assert (2 ** maxDivisionsByTwo * ec == mrc - 1)\\n\\n def trialComposite(round_tester):\\n if pow(round_tester, ec, mrc) == 1:\\n return False\\n for i in range(maxDivisionsByTwo):\\n if pow(round_tester, 2 ** i * ec, mrc) == mrc - 1:\\n return False\\n return True\\n\\n # Set number of trials here\\n for i in range(rabin_miller_rounds):\\n round_tester = random.randrange(2, mrc)\\n if trialComposite(round_tester):\\n return False\\n return True\",\n \"def sum_digits(n):\\n digits = [int(i) for i in str(n)]\\n return sum(digits)\",\n \"def sum_digits(n):\\n sum = 0\\n while n > 0:\\n num = n % 10\\n sum += num\\n n //= 10\\n return sum\",\n \"def perfect_num(number):\\n new_list=[]\\n for indx in range(1,number):\\n if number % indx==0:\\n new_list.append(indx)\\n total=sum(new_list)\\n if total==number:\\n return True\\n else:\\n return False\",\n \"def oracle(ct: int) -> bool:\\n return rsa.dec(ct) & 1 == 0\",\n \"def challenge_solver(number1, number2, threshold):\\n return (sum_of_n_terms(number1, threshold)\\n + sum_of_n_terms(number2, threshold)\\n - sum_of_n_terms(number1 * number2, threshold))\",\n \"def test_count_2645(self):\\n value: int = 1719\\n result: int = 723\\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')\",\n \"def luhn_verifica(ccred):\\n \\n # Primeiro criamos uma nova cadeia, n, com os digitos do cartao de credito sem o de controle.\\n # Usamos a funcao calc_soma para somar os digitos do cartao de acordo com o algoritmo de Luhn e juntamos o digito de controle. Caso este ultimo nao seja um algarismo, chamamos a atencao ao utilizador para o erro.\\n # Caso o resto da divisao por 10 seja 0, a funcao devolve o valor logico True. \\n \\n\\n n = ccred[:-1]\\n dig_verificacao = ccred[-1]\\n \\n if '0' <= dig_verificacao <= '9':\\n soma = calc_soma(n) + eval(dig_verificacao)\\n \\n else:\\n raise ValueError ('function luhn_verifica() O string recebido apenas pode conter digitos') \\n \\n return soma % 10 == 0\",\n \"def is_abundant_number(x):\\n return sum(proper_divisors(x)) > x\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79819995","0.73977816","0.71560806","0.6935217","0.68870246","0.66913134","0.65789026","0.6340746","0.6177836","0.6057625","0.5992606","0.59754694","0.5964514","0.5883641","0.5847304","0.57634735","0.57392144","0.5727389","0.5718226","0.56865513","0.55863965","0.5584119","0.5570434","0.5569619","0.5518257","0.5506484","0.5505834","0.5491252","0.54831374","0.54787856","0.5476114","0.5474101","0.5472411","0.5448638","0.54382116","0.5435744","0.54212505","0.53873724","0.5382496","0.5375985","0.5374493","0.5372824","0.5367279","0.53631616","0.53588563","0.5350962","0.53491503","0.53456867","0.53343296","0.5332554","0.5331966","0.53202534","0.53174806","0.5311127","0.5310788","0.53050655","0.5304938","0.52847326","0.5284472","0.52715117","0.52714306","0.5270221","0.5265388","0.5262633","0.5256885","0.5254685","0.5252836","0.52446854","0.52442855","0.5233409","0.52332425","0.5232428","0.5232281","0.5231525","0.52307147","0.52284","0.5228169","0.52254134","0.5220525","0.5193624","0.51924783","0.5189116","0.5183506","0.51816815","0.5177984","0.51673806","0.51654303","0.51616997","0.51562417","0.51495713","0.51452005","0.513515","0.51261044","0.5115609","0.5110657","0.5105213","0.5083777","0.507388","0.50676763","0.5067635"],"string":"[\n \"0.79819995\",\n \"0.73977816\",\n \"0.71560806\",\n \"0.6935217\",\n \"0.68870246\",\n \"0.66913134\",\n \"0.65789026\",\n \"0.6340746\",\n \"0.6177836\",\n \"0.6057625\",\n \"0.5992606\",\n \"0.59754694\",\n \"0.5964514\",\n \"0.5883641\",\n \"0.5847304\",\n \"0.57634735\",\n \"0.57392144\",\n \"0.5727389\",\n \"0.5718226\",\n \"0.56865513\",\n \"0.55863965\",\n \"0.5584119\",\n \"0.5570434\",\n \"0.5569619\",\n \"0.5518257\",\n \"0.5506484\",\n \"0.5505834\",\n \"0.5491252\",\n \"0.54831374\",\n \"0.54787856\",\n \"0.5476114\",\n \"0.5474101\",\n \"0.5472411\",\n \"0.5448638\",\n \"0.54382116\",\n \"0.5435744\",\n \"0.54212505\",\n \"0.53873724\",\n \"0.5382496\",\n \"0.5375985\",\n \"0.5374493\",\n \"0.5372824\",\n \"0.5367279\",\n \"0.53631616\",\n \"0.53588563\",\n \"0.5350962\",\n \"0.53491503\",\n \"0.53456867\",\n \"0.53343296\",\n \"0.5332554\",\n \"0.5331966\",\n \"0.53202534\",\n \"0.53174806\",\n \"0.5311127\",\n \"0.5310788\",\n \"0.53050655\",\n \"0.5304938\",\n \"0.52847326\",\n \"0.5284472\",\n \"0.52715117\",\n \"0.52714306\",\n \"0.5270221\",\n \"0.5265388\",\n \"0.5262633\",\n \"0.5256885\",\n \"0.5254685\",\n \"0.5252836\",\n \"0.52446854\",\n \"0.52442855\",\n \"0.5233409\",\n \"0.52332425\",\n \"0.5232428\",\n \"0.5232281\",\n \"0.5231525\",\n \"0.52307147\",\n \"0.52284\",\n \"0.5228169\",\n \"0.52254134\",\n \"0.5220525\",\n \"0.5193624\",\n \"0.51924783\",\n \"0.5189116\",\n \"0.5183506\",\n \"0.51816815\",\n \"0.5177984\",\n \"0.51673806\",\n \"0.51654303\",\n \"0.51616997\",\n \"0.51562417\",\n \"0.51495713\",\n \"0.51452005\",\n \"0.513515\",\n \"0.51261044\",\n \"0.5115609\",\n \"0.5110657\",\n \"0.5105213\",\n \"0.5083777\",\n \"0.507388\",\n \"0.50676763\",\n \"0.5067635\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.807842"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76095,"cells":{"query":{"kind":"string","value":"Estimate the number of digits in a number. Return the number of digits."},"document":{"kind":"string","value":"def nr_digits_number(armstrong_candidate: int) -> int:\n number_of_digits = 0\n while armstrong_candidate != 0:\n armstrong_candidate = int(armstrong_candidate / 10)\n number_of_digits += 1\n\n return number_of_digits"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _number_of_digits(number: int) -> int:\n return int(log10(number)) + 1","def count_digits(n):\n return len(str(n))","def ndigits(n):\n return len(str(abs(n)))","def count_digits(n):\n count = 0\n n=abs(n)\n while n!=0:\n count += 1\n n = n // 10\n return count","def count_digits(num):\n total = 0\n while num is not 0:\n total += num % 10\n num //= 10\n return total","def digit_count(x):\n return int(math.floor(math.log10(x)) + 1)","def sum_of_digits_in_number(n: int) -> int:\n return sum(int(digit) for digit in str(n))","def num_digits(num):\r\n if num == 0:\r\n return 1\r\n return int(log10(num)+1)","def get_number_length(number):\n return len(str(number))","def sum_digits(n):\n num = n\n incTen = 1\n summy = 0\n if num > 10:\n while incTen * 10 < num:\n incTen = incTen * 10\n while incTen >= 10:\n summy += num // incTen\n num = num % incTen\n incTen = incTen // 10\n summy += num\n return summy\n elif num == 10:\n return 1\n else:\n return num","def calculate_digits_sum(number: int) -> int:\n\n # Return value\n ret = 0\n\n while number != 0:\n # Extract the last digit number and add it to ret\n ret += number % 10\n\n # Delete the last digit of the number\n number //= 10\n\n return ret","def _count_zero(number):\n zero_count = 0\n while number > 9:\n if number % 10 == 0:\n zero_count += 1\n number /= 10\n else:\n break\n return zero_count","def sum_of_digits(n):\n return sum(int(c) for c in str(n))","def sum_of_digits(number):\n # Students: While you are welcome to try to understand this\n # function definition, all you have to do is trust\n # that the green doc-string is correct (it is!).\n if number < 0:\n number = -number\n\n digit_sum = 0\n while True:\n if number == 0:\n break\n digit = number % 10 # Get the digit\n digit_sum = digit_sum + digit # Accumulate it into the sum\n number = number // 10 # Get ready for the next digit\n\n return digit_sum","def ndigits(x):\n if type(x) != int: # basic error handling of non-int\n print('The value of x is not an integer')\n return None\n if abs(x) < 10:\n return 1 # single digit case\n x_recursive = int((x - x % 10)/10) # remove last digit using modulo\n return 1 + ndigits(x_recursive)","def digits(n, base=10):\n if n == 0:\n return 1\n\n n = abs(n)\n if base != 10:\n digits = math.log(n, base)\n else:\n digits = math.log10(n)\n return int(digits) + 1","def _get_digit_counts(self, value):\n sign, digittuple, exponent = value.as_tuple()\n decimals = abs(exponent)\n digits = len(digittuple)\n if decimals > digits:\n digits = decimals\n whole_digits = digits - decimals\n return (digits, whole_digits, decimals)","def get_sum_of_digits(number):\n return sum(int(digit) for digit in str(number))","def sum_of_digits(n):\n rest_of_num, last_num = split(n)\n if rest_of_num < 10:\n \treturn last_num + rest_of_num\n return last_num + sum_of_digits(rest_of_num)","def countDigits(n):\n digits = [0]*10\n while n > 0:\n digits[n%10] += 1\n n = n//10\n return digits","def get_n_digit(num):\n cnt = 0\n while num & 1 != 1:\n num >>= 1\n cnt += 1\n # print(cnt)\n return cnt","def lenOfRec(denom):\n d = denom\n n = 1 #numerator\n count = 0\n while n!=0:\n n = n*10 % d\n count += 1\n if n == 1:\n break\n \n return count","def decimal_to_digits(decimal, min_digits=None):\n digits = abs(int(np.log10(decimal)))\n if min_digits is not None:\n digits = np.clip(digits, min_digits, 20)\n return digits","def sum_digits(n):\n \"*** YOUR CODE HERE ***\"\n count=0\n length=len(str(n))\n last=0\n sum=0\n while count<length:\n last=n%10\n n//=10\n sum+=last\n count+=1\n return sum","def sum_of_digits(number):\n \n if number < 0:\n number = -number\n \n digit_sum = 0\n while True:\n if number == 0:\n break\n digit = number % 10 # Get the digit\n digit_sum = digit_sum + digit # Accumulate it into the sum\n number = number // 10 # Get ready for the next digit\n \n return digit_sum","def sum_digits(n):\n if (n < 10):\n return n\n else:\n all_but_last, last = split(n)\n return sum_digits(all_but_last) + last","def _binary_digits(num):\n ln = math.log(abs(num), 2) if num != 0 else 1\n ndigits = math.ceil(ln)\n if int(ln) == ln:\n ndigits += 1\n\n should_pad = ((ndigits % 8) != 0)\n if should_pad:\n ndigits = (int(ndigits / 8) * 8) + 8\n\n return ndigits","def sum_digits(n):\n sum = 0\n while n > 0:\n num = n % 10\n sum += num\n n //= 10\n return sum","def count_divisible_digits(n, m):\n result = 0\n if m == 0:\n return 0\n n = abs(n)\n while n != 0:\n temp = n % 10\n if temp % m == 0:\n result += 1\n n = n // 10\n return result","def count_digit(x, i):\n \"\"\" GRAPSTE TON KWDIKA SAS APO KATW \"\"\"\n su = 0\n s = 0\n k = x\n while(i>1):\n x = x//10\n i = i-1\n s = x%10\n while(k>0):\n if((k%10)==s):\n su = su + 1\n k = k//10\n return su","def round_to_ten(number):\n count = len(str(int(number)))\n if number == 1:\n count = 0\n elif number % 10 == 0:\n count = count - 1\n return 10 ** count","def digit(number: int, n: int) -> int:\n return number // 10 ** n % 10","def sum_digits(n):\n digits = [int(i) for i in str(n)]\n return sum(digits)","def _calculate_precision(interval_value: int) -> int:\n # log10(interval_value) + 1 is equivalent to len(str(interval_value)), but is significantly\n # faster and more memory-efficient\n if interval_value == 0:\n return 0\n if interval_value < 0:\n raise ValueError(\n f\"Expecting value to be a non-negative integer, got {interval_value}\"\n )\n return int(math.log10(interval_value)) + 1","def get_tens_ones_digits(number):\n return int(number/10), number // 10**0 % 10","def _num_factor(number, factor):\n assert factor != 0\n return number // factor","def digit_sum(n):\n sum_of_digits = 0\n for c in str(n):\n sum_of_digits += int(c)\n return sum_of_digits","def cut_number(n):\n i = 0\n while True:\n cur = n % 10\n ahead = n // 10 % 10\n if cur > ahead:\n i += 1\n break\n i += 1\n n //= 10\n return i","def sumDigit():","def get_max_digs(self):\n\n # Get maximum number of digits\n # 20200607: np.ceil --> np.floor + 1\n # Consider edge case n = 9 vs n = 10\n # ceil(log_10(9)) == 1, ceil(log_10(10)) == 1\n # floor(log_10(9)) + 1 == 1, floor(log_10(10)) + 1 == 2\n max_digs = int(np.floor(np.log10(np.max(self.heap))) + 1)\n\n return max_digs","def digitSum ( n ) :\n return sum ( map ( int , str ( n ) ) )","def count_divisor(num):\n ans = 2 # considering 1 and number itself by default\n for i in range(2, int(math.sqrt(num)) + 1):\n if num % i == 0:\n # for equal divisor (incase of perfect square)\n if (num / i) == i:\n ans += 1\n else:\n ans += 2\n return ans","def num_sevens(n):\n if n < 10 and n != 7:\n return 0\n else:\n return (n%10 == 7) + num_sevens(n//10)","def length(n):\n a, b, c = n / 100, (n % 100) / 10 * 10, n % 10\n total = 0\n if a:\n total += num_to_len[a] + len('hundred')\n if b or c:\n total += len('and')\n if b == 10:\n total += num_to_len[b+c]\n else :\n if b > 1:\n total += num_to_len[b]\n if c:\n total += num_to_len[c]\n return total","def digit_sum(x):\n s = 0\n while x>0:\n s = s+(x%10)\n x = x//10\n\n return s","def digit_sum(n):\n s = 0\n while n:\n s += n % 10\n n //= 10\n return s","def num_permut(x) -> tuple:\n h = x // 100\n d = (x % 100) // 10\n n = x % 10\n return(n * 100 + d * 10 + h)","def last_n_digits(num, n):\n return num%(10**n)","def period_cntfrac_sqrt(num):\r\n r = limit = int(sqrt(num))\r\n if limit * limit == num:\r\n return 0\r\n k, period = 1, 0\r\n while k != 1 or period == 0:\r\n k = (num - r * r) / k\r\n r = ((limit + r) / k) * k - r\r\n period += 1\r\n return period","def noOfFactors(num):\n primeFactors = getPrimeFactors(num) # A dictionary containing degrees of each prime factor for given num\n prod = 1\n for p in primeFactors:\n prod *= primeFactors[p] + 1\n return prod","def float_precision(float_number):\n decimal = str(float_number).split('.')[-1]\n return len(decimal)","def bitlen(number):\n assert(isinstance(number, int))\n if number == 0:\n return 1\n else:\n return floor(log2(number)) + 1","def get_digits(i):\n unit = i % 10\n hundred = i // 100\n ten = (i - hundred*100) // 10\n return hundred, ten, unit","def first_n_digits(num, n):\n return num // 10 ** (int(math.log(num, 10)) - n + 1)","def numbits(n):\n return int(math.ceil(math.log(n, 2)))","def Sum_Numbers_x_Power_Digits(x):\n totalSum = 0 \n for i in xrange(10, 999999):\n if i == sum([int(j)**x for j in str(i)]):\n totalSum += i\n return totalSum","def solution(x):\n if x is None:\n return x\n return total_digits(x)","def get_int_width(integer):\n return len(str(integer))","def test_computes_max_nth_digit_by_multiples_of_ten(self):\n\t\tself.assertEqual(1, products_of_multiplied_nth_digits(20, 10))","def digit_sum(n):\n\treturn sum(int(c) for c in str(n))","def calculate(x: int) -> int:\n\n digits = list(map(int, list(str(x))))\n return sum(list(map(lambda a: a**2, digits)))","def square_digit_sum(number):\n return sum(precomputed_digit_squares[digit] for digit in str(number))","def numberOfSteps(num):\n steps = 0\n \n while num != 0:\n if num % 2 == 0:\n num /= 2\n steps += 1\n else:\n num -= 1\n steps += 1\n return steps","def sum_squares(num):\n sum = 0\n while (num != 0):\n sum += math.pow((num % 10), 2)\n num = num/10\n return int(sum)","def print_digits(number):\n if number > 0 and number <= 100:\n tens_digit = int(number / 10);\n ones_digit = int(number % 10);\n total_digits = \"The tens digit is \" + str(tens_digit) + \", and the ones digit is \" + str(ones_digit) + \".\"\n else:\n total_digits = \"Error: Input is not a two-digit number.\"\n return print(total_digits)","def get_length_repeating_decimals(num, den):\n # When we use longhand divison for the fraction we find that we get a cycle of reminders that\n # repeats, we can use this knowledge to find the length of the repeating part of the decimal by\n # finding the reminder multiplying it with ten and devide it again, if we then get back to a reminder\n # we have had before, we know that we will have an infinite repetition again, and the length from the last\n # time we had this reminder will be the length of the cycle\n\n # keep running the formula until we get a reminder we have seen before\n reminders = []\n\n reminder = num % den\n\n while reminder not in reminders:\n reminders.append(reminder)\n reminder = reminder * 10 % den\n\n # now find how long ago it is that we saw this reminder last\n cycle_length = len(reminders) - reminders.index(reminder)\n\n return cycle_length","def round_counts(n):\n n = int(n)\n assert n == math.floor(n) # make sure it is an integer; shouldn't be needed with above\n assert n >= 0\n if 0 <= n < 15: return LESS_THAN_15\n if 15 <= n <= 99: return str(nearest( n, 10))\n if 100 <= n <= 999: return str(nearest( n, 50))\n if 1000 <= n <= 9999: return str(nearest( n, 100))\n if 10000 <= n <= 99999: return str(nearest( n, 500))\n if 100000 <= n <= 999999: return str(nearest( n, 1000))\n return round4_decimal(n)","def divisor_counter(num):\n if num <= 0:\n raise ValueError('num must be a positive, non-zero number')\n\n divisors = 0\n num_sq_rt = num ** .5\n for possible_divisor in range(1, int(num_sq_rt)):\n if num % possible_divisor == 0:\n divisors += 1\n\n divisors *= 2\n # If num is a perfect square, we have to subtract one so we only count\n # the square root once. i.e. if num is 16, we only want to count 4 once\n if num_sq_rt.is_integer():\n divisors -= 1\n return divisors*2","def num_decims(num):\r\n\r\n if (\".\" in num):\r\n \r\n numA, numB = num.split(\".\") \r\n num_decms = len(numB)\r\n \r\n elif (\".\" not in num):\r\n \r\n num_decms = 0\r\n \r\n return num_decms","def count_divisions(num, n):\n count = 0\n while pe_005.is_divisible(num, n):\n num = num // n\n count += 1\n return count, num","def twenty():\r\n \r\n n = 100\r\n factorial = 1\r\n sum = 0\r\n \r\n while n > 0:\r\n factorial *= n\r\n n -= 1\r\n \r\n for c in str(factorial):\r\n sum += int(c)\r\n \r\n return sum","def calc_check_digit(number):\n weights = (2, 4, 8, 5, 10, 9, 7, 3, 6)\n return str(sum(w * int(n) for w, n in zip(weights, number)) % 11 % 10)","def test_count_1_000_000_000_000_000_000(self):\n value: int = 1_000_000_000_000_000_000\n result: int = 264160473575034274\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')","def factorial_digit_sum(n):\n sum = 0\n factStr = str(factorial(n))\n for digit in factStr:\n sum += int(digit)\n return sum","def test_size(self) -> int:\n return int(self.data_size * self.__test_fraction)","def get_digit(n):\n \"\"\"\n 9 - 9\n 10-99 - 2*90 \n 100-999 - 3*900\n \"\"\"\n i = 0\n start = 0\n done = False\n while not done:\n step = (i+1)*9*(10**i)\n if start + step > n:\n done = True\n else:\n start += step\n i += 1\n\n num_digits = i + 1\n\n offset = n - start\n number = offset // num_digits + \\\n (10**(num_digits-1) if (num_digits - 1) else 0)\n _i = (offset - 1) % num_digits\n return int(str(number)[_i])","def fn(n):\n digits = [int(x) for x in str(n)]\n for i in reversed(range(len(digits)//2+1)): \n if digits[i] < 9: break \n else: return 10*n + 11\n digits[i] = digits[~i] = digits[i] + 1\n for ii in range(i): \n digits[~ii] = digits[ii]\n for ii in range(i+1, len(digits)//2+1): \n digits[ii] = digits[~ii] = 0\n return int(\"\".join(map(str, digits)))","def pixels_to_length(pixels, boxsize, num_pixels):\n length = (boxsize * pixels) / num_pixels\n\n return length","def compute(num):\n # 567 / 9 = 63, 235 / 47 = 5\n num = (num * 63 + 7492) * 5 - 498\n if num < 0: # modulus won't give correct result if number is negative\n num *= -1\n res = (num // 10) % 10\n return res","def number_of_iterations(self) -> int:\n return self._stats[\"iter_count\"]","def get_decimal_precision(number: decimal.Decimal) -> int:\n # Copied from: https://github.com/mahmoud/boltons/pull/59\n assert isinstance(number, decimal.Decimal)\n decimal_tuple = number.normalize().as_tuple()\n # Note: DecimalTuple.exponent can be 'n' (qNaN), 'N' (sNaN), or 'F' (Infinity)\n if not isinstance(decimal_tuple.exponent, int) or decimal_tuple.exponent >= 0:\n return 0\n return abs(decimal_tuple.exponent)","def get_digits(num: int) -> str:\n return \"\".join(sorted(str(num**3)))","def num_of_num(first_number: float, second_number: float) -> float:\n return round( second_number / ( first_number / 100 ))","def get_decimals() -> int:\n return _decimals","def decimal_ceil(x):\n int_x = int(x)\n if x - int_x == 0:\n return int_x\n return int_x + 1","def count_multiples( start, stop, divisor ):\n count = 0\n num = start\n while num < stop + 1:\n if num % divisor == 0:\n count += 1\n num += 1\n return count","def add_digits(n):\n return sum([int(d) for d in str(n)])","def lastTen(self, num, length):\n\t\tif (length-num <=10):\n\t\t\treturn 1\n\t\treturn 0","def numLetterCount(maxNum):\n sum = 0\n for num in range(1,maxNum+1):\n sum += len(num2words(num))\n print(str(num) + ' = ' + str(num2words(num)))\n return sum","def ceil_10(i: int) -> int:\n return 10 ** (math.ceil(math.log10(i)))","def sum_of_digit_powers_in_number(n: int, power: int) -> int:\n return sum(int(digit) ** power for digit in str(n))","def get_num(digits):\r\n\r\n number = 0\r\n sign = 1\r\n digit_number = 0\r\n decimal = 0\r\n number_of_digits = len(digits)\r\n \r\n for digit in digits:\r\n if digit == \"-\":\r\n sign = -1\r\n digit_number += 1\r\n elif digit == \".\":\r\n decimal = number_of_digits - digit_number\r\n else:\r\n number += int(digit)*(10**(number_of_digits-digit_number-1))\r\n digit_number += 1\r\n \r\n return float(number*sign)/(10**decimal)","def count_to10():\n numberx = 0\n while numberx < 10:\n numberx += 1\n print(numberx)","def Nround(self,limite):\n\t\tdec = str(limite).split(\".\")\n\t\t\"\"\"asignacion de un valor de la clase limite con el metodo split\"\"\"\n\t\treturn len(dec[1])\n\t\t\"\"\"retorna el tamaño del valor\"\"\"","def totalmb(self):\n megabytes = 0\n for i in self.size_dups():\n megabytes += i[0]\n if megabytes:\n return self.humanvalue(megabytes)\n else:\n return 0","def totient(n):\n count = 0\n for i in range(1, n):\n if math.gcd(n, i) == 1:\n count += 1\n return count","def decimals(self) -> int:\n return self._parseChunkToInt(self.chunks[7], 1, 1, True)","def unique_digits(n):\n \"*** YOUR CODE HERE ***\"\n count = 0\n for k in range(0, 10):\n if has_digit(n, k):\n count = count + 1\n return count","def divisor_num(x):\n factor_pow = map(lambda y: y + 1, factorint(x).values())\n div_num = reduce(mul, factor_pow)\n return div_num","def reverse_digits(number: int):\n acc = 0\n\n while number != 0:\n acc *= 10\n acc += number % 10\n\n number //= 10 # 정수 나눗셈\n\n return acc"],"string":"[\n \"def _number_of_digits(number: int) -> int:\\n return int(log10(number)) + 1\",\n \"def count_digits(n):\\n return len(str(n))\",\n \"def ndigits(n):\\n return len(str(abs(n)))\",\n \"def count_digits(n):\\n count = 0\\n n=abs(n)\\n while n!=0:\\n count += 1\\n n = n // 10\\n return count\",\n \"def count_digits(num):\\n total = 0\\n while num is not 0:\\n total += num % 10\\n num //= 10\\n return total\",\n \"def digit_count(x):\\n return int(math.floor(math.log10(x)) + 1)\",\n \"def sum_of_digits_in_number(n: int) -> int:\\n return sum(int(digit) for digit in str(n))\",\n \"def num_digits(num):\\r\\n if num == 0:\\r\\n return 1\\r\\n return int(log10(num)+1)\",\n \"def get_number_length(number):\\n return len(str(number))\",\n \"def sum_digits(n):\\n num = n\\n incTen = 1\\n summy = 0\\n if num > 10:\\n while incTen * 10 < num:\\n incTen = incTen * 10\\n while incTen >= 10:\\n summy += num // incTen\\n num = num % incTen\\n incTen = incTen // 10\\n summy += num\\n return summy\\n elif num == 10:\\n return 1\\n else:\\n return num\",\n \"def calculate_digits_sum(number: int) -> int:\\n\\n # Return value\\n ret = 0\\n\\n while number != 0:\\n # Extract the last digit number and add it to ret\\n ret += number % 10\\n\\n # Delete the last digit of the number\\n number //= 10\\n\\n return ret\",\n \"def _count_zero(number):\\n zero_count = 0\\n while number > 9:\\n if number % 10 == 0:\\n zero_count += 1\\n number /= 10\\n else:\\n break\\n return zero_count\",\n \"def sum_of_digits(n):\\n return sum(int(c) for c in str(n))\",\n \"def sum_of_digits(number):\\n # Students: While you are welcome to try to understand this\\n # function definition, all you have to do is trust\\n # that the green doc-string is correct (it is!).\\n if number < 0:\\n number = -number\\n\\n digit_sum = 0\\n while True:\\n if number == 0:\\n break\\n digit = number % 10 # Get the digit\\n digit_sum = digit_sum + digit # Accumulate it into the sum\\n number = number // 10 # Get ready for the next digit\\n\\n return digit_sum\",\n \"def ndigits(x):\\n if type(x) != int: # basic error handling of non-int\\n print('The value of x is not an integer')\\n return None\\n if abs(x) < 10:\\n return 1 # single digit case\\n x_recursive = int((x - x % 10)/10) # remove last digit using modulo\\n return 1 + ndigits(x_recursive)\",\n \"def digits(n, base=10):\\n if n == 0:\\n return 1\\n\\n n = abs(n)\\n if base != 10:\\n digits = math.log(n, base)\\n else:\\n digits = math.log10(n)\\n return int(digits) + 1\",\n \"def _get_digit_counts(self, value):\\n sign, digittuple, exponent = value.as_tuple()\\n decimals = abs(exponent)\\n digits = len(digittuple)\\n if decimals > digits:\\n digits = decimals\\n whole_digits = digits - decimals\\n return (digits, whole_digits, decimals)\",\n \"def get_sum_of_digits(number):\\n return sum(int(digit) for digit in str(number))\",\n \"def sum_of_digits(n):\\n rest_of_num, last_num = split(n)\\n if rest_of_num < 10:\\n \\treturn last_num + rest_of_num\\n return last_num + sum_of_digits(rest_of_num)\",\n \"def countDigits(n):\\n digits = [0]*10\\n while n > 0:\\n digits[n%10] += 1\\n n = n//10\\n return digits\",\n \"def get_n_digit(num):\\n cnt = 0\\n while num & 1 != 1:\\n num >>= 1\\n cnt += 1\\n # print(cnt)\\n return cnt\",\n \"def lenOfRec(denom):\\n d = denom\\n n = 1 #numerator\\n count = 0\\n while n!=0:\\n n = n*10 % d\\n count += 1\\n if n == 1:\\n break\\n \\n return count\",\n \"def decimal_to_digits(decimal, min_digits=None):\\n digits = abs(int(np.log10(decimal)))\\n if min_digits is not None:\\n digits = np.clip(digits, min_digits, 20)\\n return digits\",\n \"def sum_digits(n):\\n \\\"*** YOUR CODE HERE ***\\\"\\n count=0\\n length=len(str(n))\\n last=0\\n sum=0\\n while count<length:\\n last=n%10\\n n//=10\\n sum+=last\\n count+=1\\n return sum\",\n \"def sum_of_digits(number):\\n \\n if number < 0:\\n number = -number\\n \\n digit_sum = 0\\n while True:\\n if number == 0:\\n break\\n digit = number % 10 # Get the digit\\n digit_sum = digit_sum + digit # Accumulate it into the sum\\n number = number // 10 # Get ready for the next digit\\n \\n return digit_sum\",\n \"def sum_digits(n):\\n if (n < 10):\\n return n\\n else:\\n all_but_last, last = split(n)\\n return sum_digits(all_but_last) + last\",\n \"def _binary_digits(num):\\n ln = math.log(abs(num), 2) if num != 0 else 1\\n ndigits = math.ceil(ln)\\n if int(ln) == ln:\\n ndigits += 1\\n\\n should_pad = ((ndigits % 8) != 0)\\n if should_pad:\\n ndigits = (int(ndigits / 8) * 8) + 8\\n\\n return ndigits\",\n \"def sum_digits(n):\\n sum = 0\\n while n > 0:\\n num = n % 10\\n sum += num\\n n //= 10\\n return sum\",\n \"def count_divisible_digits(n, m):\\n result = 0\\n if m == 0:\\n return 0\\n n = abs(n)\\n while n != 0:\\n temp = n % 10\\n if temp % m == 0:\\n result += 1\\n n = n // 10\\n return result\",\n \"def count_digit(x, i):\\n \\\"\\\"\\\" GRAPSTE TON KWDIKA SAS APO KATW \\\"\\\"\\\"\\n su = 0\\n s = 0\\n k = x\\n while(i>1):\\n x = x//10\\n i = i-1\\n s = x%10\\n while(k>0):\\n if((k%10)==s):\\n su = su + 1\\n k = k//10\\n return su\",\n \"def round_to_ten(number):\\n count = len(str(int(number)))\\n if number == 1:\\n count = 0\\n elif number % 10 == 0:\\n count = count - 1\\n return 10 ** count\",\n \"def digit(number: int, n: int) -> int:\\n return number // 10 ** n % 10\",\n \"def sum_digits(n):\\n digits = [int(i) for i in str(n)]\\n return sum(digits)\",\n \"def _calculate_precision(interval_value: int) -> int:\\n # log10(interval_value) + 1 is equivalent to len(str(interval_value)), but is significantly\\n # faster and more memory-efficient\\n if interval_value == 0:\\n return 0\\n if interval_value < 0:\\n raise ValueError(\\n f\\\"Expecting value to be a non-negative integer, got {interval_value}\\\"\\n )\\n return int(math.log10(interval_value)) + 1\",\n \"def get_tens_ones_digits(number):\\n return int(number/10), number // 10**0 % 10\",\n \"def _num_factor(number, factor):\\n assert factor != 0\\n return number // factor\",\n \"def digit_sum(n):\\n sum_of_digits = 0\\n for c in str(n):\\n sum_of_digits += int(c)\\n return sum_of_digits\",\n \"def cut_number(n):\\n i = 0\\n while True:\\n cur = n % 10\\n ahead = n // 10 % 10\\n if cur > ahead:\\n i += 1\\n break\\n i += 1\\n n //= 10\\n return i\",\n \"def sumDigit():\",\n \"def get_max_digs(self):\\n\\n # Get maximum number of digits\\n # 20200607: np.ceil --> np.floor + 1\\n # Consider edge case n = 9 vs n = 10\\n # ceil(log_10(9)) == 1, ceil(log_10(10)) == 1\\n # floor(log_10(9)) + 1 == 1, floor(log_10(10)) + 1 == 2\\n max_digs = int(np.floor(np.log10(np.max(self.heap))) + 1)\\n\\n return max_digs\",\n \"def digitSum ( n ) :\\n return sum ( map ( int , str ( n ) ) )\",\n \"def count_divisor(num):\\n ans = 2 # considering 1 and number itself by default\\n for i in range(2, int(math.sqrt(num)) + 1):\\n if num % i == 0:\\n # for equal divisor (incase of perfect square)\\n if (num / i) == i:\\n ans += 1\\n else:\\n ans += 2\\n return ans\",\n \"def num_sevens(n):\\n if n < 10 and n != 7:\\n return 0\\n else:\\n return (n%10 == 7) + num_sevens(n//10)\",\n \"def length(n):\\n a, b, c = n / 100, (n % 100) / 10 * 10, n % 10\\n total = 0\\n if a:\\n total += num_to_len[a] + len('hundred')\\n if b or c:\\n total += len('and')\\n if b == 10:\\n total += num_to_len[b+c]\\n else :\\n if b > 1:\\n total += num_to_len[b]\\n if c:\\n total += num_to_len[c]\\n return total\",\n \"def digit_sum(x):\\n s = 0\\n while x>0:\\n s = s+(x%10)\\n x = x//10\\n\\n return s\",\n \"def digit_sum(n):\\n s = 0\\n while n:\\n s += n % 10\\n n //= 10\\n return s\",\n \"def num_permut(x) -> tuple:\\n h = x // 100\\n d = (x % 100) // 10\\n n = x % 10\\n return(n * 100 + d * 10 + h)\",\n \"def last_n_digits(num, n):\\n return num%(10**n)\",\n \"def period_cntfrac_sqrt(num):\\r\\n r = limit = int(sqrt(num))\\r\\n if limit * limit == num:\\r\\n return 0\\r\\n k, period = 1, 0\\r\\n while k != 1 or period == 0:\\r\\n k = (num - r * r) / k\\r\\n r = ((limit + r) / k) * k - r\\r\\n period += 1\\r\\n return period\",\n \"def noOfFactors(num):\\n primeFactors = getPrimeFactors(num) # A dictionary containing degrees of each prime factor for given num\\n prod = 1\\n for p in primeFactors:\\n prod *= primeFactors[p] + 1\\n return prod\",\n \"def float_precision(float_number):\\n decimal = str(float_number).split('.')[-1]\\n return len(decimal)\",\n \"def bitlen(number):\\n assert(isinstance(number, int))\\n if number == 0:\\n return 1\\n else:\\n return floor(log2(number)) + 1\",\n \"def get_digits(i):\\n unit = i % 10\\n hundred = i // 100\\n ten = (i - hundred*100) // 10\\n return hundred, ten, unit\",\n \"def first_n_digits(num, n):\\n return num // 10 ** (int(math.log(num, 10)) - n + 1)\",\n \"def numbits(n):\\n return int(math.ceil(math.log(n, 2)))\",\n \"def Sum_Numbers_x_Power_Digits(x):\\n totalSum = 0 \\n for i in xrange(10, 999999):\\n if i == sum([int(j)**x for j in str(i)]):\\n totalSum += i\\n return totalSum\",\n \"def solution(x):\\n if x is None:\\n return x\\n return total_digits(x)\",\n \"def get_int_width(integer):\\n return len(str(integer))\",\n \"def test_computes_max_nth_digit_by_multiples_of_ten(self):\\n\\t\\tself.assertEqual(1, products_of_multiplied_nth_digits(20, 10))\",\n \"def digit_sum(n):\\n\\treturn sum(int(c) for c in str(n))\",\n \"def calculate(x: int) -> int:\\n\\n digits = list(map(int, list(str(x))))\\n return sum(list(map(lambda a: a**2, digits)))\",\n \"def square_digit_sum(number):\\n return sum(precomputed_digit_squares[digit] for digit in str(number))\",\n \"def numberOfSteps(num):\\n steps = 0\\n \\n while num != 0:\\n if num % 2 == 0:\\n num /= 2\\n steps += 1\\n else:\\n num -= 1\\n steps += 1\\n return steps\",\n \"def sum_squares(num):\\n sum = 0\\n while (num != 0):\\n sum += math.pow((num % 10), 2)\\n num = num/10\\n return int(sum)\",\n \"def print_digits(number):\\n if number > 0 and number <= 100:\\n tens_digit = int(number / 10);\\n ones_digit = int(number % 10);\\n total_digits = \\\"The tens digit is \\\" + str(tens_digit) + \\\", and the ones digit is \\\" + str(ones_digit) + \\\".\\\"\\n else:\\n total_digits = \\\"Error: Input is not a two-digit number.\\\"\\n return print(total_digits)\",\n \"def get_length_repeating_decimals(num, den):\\n # When we use longhand divison for the fraction we find that we get a cycle of reminders that\\n # repeats, we can use this knowledge to find the length of the repeating part of the decimal by\\n # finding the reminder multiplying it with ten and devide it again, if we then get back to a reminder\\n # we have had before, we know that we will have an infinite repetition again, and the length from the last\\n # time we had this reminder will be the length of the cycle\\n\\n # keep running the formula until we get a reminder we have seen before\\n reminders = []\\n\\n reminder = num % den\\n\\n while reminder not in reminders:\\n reminders.append(reminder)\\n reminder = reminder * 10 % den\\n\\n # now find how long ago it is that we saw this reminder last\\n cycle_length = len(reminders) - reminders.index(reminder)\\n\\n return cycle_length\",\n \"def round_counts(n):\\n n = int(n)\\n assert n == math.floor(n) # make sure it is an integer; shouldn't be needed with above\\n assert n >= 0\\n if 0 <= n < 15: return LESS_THAN_15\\n if 15 <= n <= 99: return str(nearest( n, 10))\\n if 100 <= n <= 999: return str(nearest( n, 50))\\n if 1000 <= n <= 9999: return str(nearest( n, 100))\\n if 10000 <= n <= 99999: return str(nearest( n, 500))\\n if 100000 <= n <= 999999: return str(nearest( n, 1000))\\n return round4_decimal(n)\",\n \"def divisor_counter(num):\\n if num <= 0:\\n raise ValueError('num must be a positive, non-zero number')\\n\\n divisors = 0\\n num_sq_rt = num ** .5\\n for possible_divisor in range(1, int(num_sq_rt)):\\n if num % possible_divisor == 0:\\n divisors += 1\\n\\n divisors *= 2\\n # If num is a perfect square, we have to subtract one so we only count\\n # the square root once. i.e. if num is 16, we only want to count 4 once\\n if num_sq_rt.is_integer():\\n divisors -= 1\\n return divisors*2\",\n \"def num_decims(num):\\r\\n\\r\\n if (\\\".\\\" in num):\\r\\n \\r\\n numA, numB = num.split(\\\".\\\") \\r\\n num_decms = len(numB)\\r\\n \\r\\n elif (\\\".\\\" not in num):\\r\\n \\r\\n num_decms = 0\\r\\n \\r\\n return num_decms\",\n \"def count_divisions(num, n):\\n count = 0\\n while pe_005.is_divisible(num, n):\\n num = num // n\\n count += 1\\n return count, num\",\n \"def twenty():\\r\\n \\r\\n n = 100\\r\\n factorial = 1\\r\\n sum = 0\\r\\n \\r\\n while n > 0:\\r\\n factorial *= n\\r\\n n -= 1\\r\\n \\r\\n for c in str(factorial):\\r\\n sum += int(c)\\r\\n \\r\\n return sum\",\n \"def calc_check_digit(number):\\n weights = (2, 4, 8, 5, 10, 9, 7, 3, 6)\\n return str(sum(w * int(n) for w, n in zip(weights, number)) % 11 % 10)\",\n \"def test_count_1_000_000_000_000_000_000(self):\\n value: int = 1_000_000_000_000_000_000\\n result: int = 264160473575034274\\n self.assertEqual(count(value), result, f'Between 0 and {value}, there are {result} lucky numbers.')\",\n \"def factorial_digit_sum(n):\\n sum = 0\\n factStr = str(factorial(n))\\n for digit in factStr:\\n sum += int(digit)\\n return sum\",\n \"def test_size(self) -> int:\\n return int(self.data_size * self.__test_fraction)\",\n \"def get_digit(n):\\n \\\"\\\"\\\"\\n 9 - 9\\n 10-99 - 2*90 \\n 100-999 - 3*900\\n \\\"\\\"\\\"\\n i = 0\\n start = 0\\n done = False\\n while not done:\\n step = (i+1)*9*(10**i)\\n if start + step > n:\\n done = True\\n else:\\n start += step\\n i += 1\\n\\n num_digits = i + 1\\n\\n offset = n - start\\n number = offset // num_digits + \\\\\\n (10**(num_digits-1) if (num_digits - 1) else 0)\\n _i = (offset - 1) % num_digits\\n return int(str(number)[_i])\",\n \"def fn(n):\\n digits = [int(x) for x in str(n)]\\n for i in reversed(range(len(digits)//2+1)): \\n if digits[i] < 9: break \\n else: return 10*n + 11\\n digits[i] = digits[~i] = digits[i] + 1\\n for ii in range(i): \\n digits[~ii] = digits[ii]\\n for ii in range(i+1, len(digits)//2+1): \\n digits[ii] = digits[~ii] = 0\\n return int(\\\"\\\".join(map(str, digits)))\",\n \"def pixels_to_length(pixels, boxsize, num_pixels):\\n length = (boxsize * pixels) / num_pixels\\n\\n return length\",\n \"def compute(num):\\n # 567 / 9 = 63, 235 / 47 = 5\\n num = (num * 63 + 7492) * 5 - 498\\n if num < 0: # modulus won't give correct result if number is negative\\n num *= -1\\n res = (num // 10) % 10\\n return res\",\n \"def number_of_iterations(self) -> int:\\n return self._stats[\\\"iter_count\\\"]\",\n \"def get_decimal_precision(number: decimal.Decimal) -> int:\\n # Copied from: https://github.com/mahmoud/boltons/pull/59\\n assert isinstance(number, decimal.Decimal)\\n decimal_tuple = number.normalize().as_tuple()\\n # Note: DecimalTuple.exponent can be 'n' (qNaN), 'N' (sNaN), or 'F' (Infinity)\\n if not isinstance(decimal_tuple.exponent, int) or decimal_tuple.exponent >= 0:\\n return 0\\n return abs(decimal_tuple.exponent)\",\n \"def get_digits(num: int) -> str:\\n return \\\"\\\".join(sorted(str(num**3)))\",\n \"def num_of_num(first_number: float, second_number: float) -> float:\\n return round( second_number / ( first_number / 100 ))\",\n \"def get_decimals() -> int:\\n return _decimals\",\n \"def decimal_ceil(x):\\n int_x = int(x)\\n if x - int_x == 0:\\n return int_x\\n return int_x + 1\",\n \"def count_multiples( start, stop, divisor ):\\n count = 0\\n num = start\\n while num < stop + 1:\\n if num % divisor == 0:\\n count += 1\\n num += 1\\n return count\",\n \"def add_digits(n):\\n return sum([int(d) for d in str(n)])\",\n \"def lastTen(self, num, length):\\n\\t\\tif (length-num <=10):\\n\\t\\t\\treturn 1\\n\\t\\treturn 0\",\n \"def numLetterCount(maxNum):\\n sum = 0\\n for num in range(1,maxNum+1):\\n sum += len(num2words(num))\\n print(str(num) + ' = ' + str(num2words(num)))\\n return sum\",\n \"def ceil_10(i: int) -> int:\\n return 10 ** (math.ceil(math.log10(i)))\",\n \"def sum_of_digit_powers_in_number(n: int, power: int) -> int:\\n return sum(int(digit) ** power for digit in str(n))\",\n \"def get_num(digits):\\r\\n\\r\\n number = 0\\r\\n sign = 1\\r\\n digit_number = 0\\r\\n decimal = 0\\r\\n number_of_digits = len(digits)\\r\\n \\r\\n for digit in digits:\\r\\n if digit == \\\"-\\\":\\r\\n sign = -1\\r\\n digit_number += 1\\r\\n elif digit == \\\".\\\":\\r\\n decimal = number_of_digits - digit_number\\r\\n else:\\r\\n number += int(digit)*(10**(number_of_digits-digit_number-1))\\r\\n digit_number += 1\\r\\n \\r\\n return float(number*sign)/(10**decimal)\",\n \"def count_to10():\\n numberx = 0\\n while numberx < 10:\\n numberx += 1\\n print(numberx)\",\n \"def Nround(self,limite):\\n\\t\\tdec = str(limite).split(\\\".\\\")\\n\\t\\t\\\"\\\"\\\"asignacion de un valor de la clase limite con el metodo split\\\"\\\"\\\"\\n\\t\\treturn len(dec[1])\\n\\t\\t\\\"\\\"\\\"retorna el tamaño del valor\\\"\\\"\\\"\",\n \"def totalmb(self):\\n megabytes = 0\\n for i in self.size_dups():\\n megabytes += i[0]\\n if megabytes:\\n return self.humanvalue(megabytes)\\n else:\\n return 0\",\n \"def totient(n):\\n count = 0\\n for i in range(1, n):\\n if math.gcd(n, i) == 1:\\n count += 1\\n return count\",\n \"def decimals(self) -> int:\\n return self._parseChunkToInt(self.chunks[7], 1, 1, True)\",\n \"def unique_digits(n):\\n \\\"*** YOUR CODE HERE ***\\\"\\n count = 0\\n for k in range(0, 10):\\n if has_digit(n, k):\\n count = count + 1\\n return count\",\n \"def divisor_num(x):\\n factor_pow = map(lambda y: y + 1, factorint(x).values())\\n div_num = reduce(mul, factor_pow)\\n return div_num\",\n \"def reverse_digits(number: int):\\n acc = 0\\n\\n while number != 0:\\n acc *= 10\\n acc += number % 10\\n\\n number //= 10 # 정수 나눗셈\\n\\n return acc\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8419208","0.79809237","0.7913502","0.7809456","0.76983887","0.75223655","0.72983843","0.72151583","0.716701","0.7089731","0.7057321","0.6973305","0.6938531","0.6913356","0.68830156","0.6864402","0.682758","0.680548","0.67883587","0.67420894","0.6736806","0.6733639","0.6662354","0.66622543","0.6658343","0.6656348","0.6654035","0.665055","0.65615046","0.6547947","0.65365607","0.65339303","0.6509994","0.64389545","0.6350348","0.61914533","0.6136538","0.60887915","0.6088142","0.6087978","0.60558856","0.60363233","0.6028753","0.59947747","0.5992544","0.5991141","0.5974169","0.59390205","0.5929303","0.5897183","0.58851993","0.5842578","0.58392215","0.58361745","0.58191055","0.58135384","0.5810861","0.5808042","0.57998914","0.57789147","0.5775357","0.5767902","0.57156384","0.57105017","0.5709399","0.5704759","0.5697293","0.5689468","0.5686937","0.56725407","0.56514925","0.5649963","0.563798","0.5635335","0.562305","0.562275","0.56113535","0.5607221","0.5602425","0.55987054","0.55847216","0.55837494","0.556692","0.5562595","0.5557938","0.55398273","0.55365586","0.55354786","0.55234265","0.55190283","0.55179745","0.55152375","0.55062973","0.5498771","0.54908854","0.54817355","0.54781014","0.54722804","0.5469248","0.54690474"],"string":"[\n \"0.8419208\",\n \"0.79809237\",\n \"0.7913502\",\n \"0.7809456\",\n \"0.76983887\",\n \"0.75223655\",\n \"0.72983843\",\n \"0.72151583\",\n \"0.716701\",\n \"0.7089731\",\n \"0.7057321\",\n \"0.6973305\",\n \"0.6938531\",\n \"0.6913356\",\n \"0.68830156\",\n \"0.6864402\",\n \"0.682758\",\n \"0.680548\",\n \"0.67883587\",\n \"0.67420894\",\n \"0.6736806\",\n \"0.6733639\",\n \"0.6662354\",\n \"0.66622543\",\n \"0.6658343\",\n \"0.6656348\",\n \"0.6654035\",\n \"0.665055\",\n \"0.65615046\",\n \"0.6547947\",\n \"0.65365607\",\n \"0.65339303\",\n \"0.6509994\",\n \"0.64389545\",\n \"0.6350348\",\n \"0.61914533\",\n \"0.6136538\",\n \"0.60887915\",\n \"0.6088142\",\n \"0.6087978\",\n \"0.60558856\",\n \"0.60363233\",\n \"0.6028753\",\n \"0.59947747\",\n \"0.5992544\",\n \"0.5991141\",\n \"0.5974169\",\n \"0.59390205\",\n \"0.5929303\",\n \"0.5897183\",\n \"0.58851993\",\n \"0.5842578\",\n \"0.58392215\",\n \"0.58361745\",\n \"0.58191055\",\n \"0.58135384\",\n \"0.5810861\",\n \"0.5808042\",\n \"0.57998914\",\n \"0.57789147\",\n \"0.5775357\",\n \"0.5767902\",\n \"0.57156384\",\n \"0.57105017\",\n \"0.5709399\",\n \"0.5704759\",\n \"0.5697293\",\n \"0.5689468\",\n \"0.5686937\",\n \"0.56725407\",\n \"0.56514925\",\n \"0.5649963\",\n \"0.563798\",\n \"0.5635335\",\n \"0.562305\",\n \"0.562275\",\n \"0.56113535\",\n \"0.5607221\",\n \"0.5602425\",\n \"0.55987054\",\n \"0.55847216\",\n \"0.55837494\",\n \"0.556692\",\n \"0.5562595\",\n \"0.5557938\",\n \"0.55398273\",\n \"0.55365586\",\n \"0.55354786\",\n \"0.55234265\",\n \"0.55190283\",\n \"0.55179745\",\n \"0.55152375\",\n \"0.55062973\",\n \"0.5498771\",\n \"0.54908854\",\n \"0.54817355\",\n \"0.54781014\",\n \"0.54722804\",\n \"0.5469248\",\n \"0.54690474\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7020397"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":76096,"cells":{"query":{"kind":"string","value":"Calculate and return the armstrong_sum"},"document":{"kind":"string","value":"def armstrong_sum(armstrong_candidate: int, nr_digits: int) -> int:\n a_sum = 0\n\n while armstrong_candidate != 0:\n digit_in_armstrong_candidate = armstrong_candidate % 10\n a_sum += digit_in_armstrong_candidate ** nr_digits\n armstrong_candidate = int(armstrong_candidate / 10)\n return a_sum"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def sum(self):\n return self.vsum","def calculate_sum(self):\n\n left_sum = self.left.calculate_sum() if self.left else 0\n right_sum = self.right.calculate_sum() if self.right else 0\n return self.data + left_sum + right_sum","def summation(self):\n return sum(self.read_ints())","def _sum(self):\n s = 0\n for element, value in self.items():\n s += value\n return s","def sum(self) -> int:\n return self.root.sum","def weighted_sum(h):\n return h","def calculate(self) -> float:","def get_sum(a,b):\n return","def totalValue(self):\n\n\t\tvalue = 0\n\t\tfor bottle in self.bottles:\n\t\t\tvalue += bottle.inflatedCost\n\n\t\treturn value","def sum(self) -> float:\n return sum(self.values)","def sum(self):\n return self._reduce_for_stat_function(F.sum, only_numeric=True)","def segment_sum(self, left, right):\n if self.empty():\n return 0\n less, _ = self.root.split_sums(left)\n _, greater = self.root.split_sums(right)\n return self.sum - less - greater","def get_weights_sum(self):\n return self.w_sum","def get_sum(self, node: Optional[TreeNode]) -> int:\n if not node:\n return 0\n l_sub_sum, r_sub_sum = self.get_sum(node.left), self.get_sum(node.right)\n self.ans += abs(l_sub_sum - r_sub_sum)\n\n return node.val + l_sub_sum + r_sub_sum","def calculate(self):\n avg = self.sum / self.n if self.n != 0 else 0\n self.running_avg.append(avg)\n return avg","def sum(self):\n return sum(self.items())","def radical_sum(num, level):\n if level == 0:\n return 0\n \n return ((radical_sum(num, level - 1) + num) ** 0.5)","def sum_value(self, lv, rv):","def final_amt(p,r,n,t):\n\n a = p * (1 + r/n) ** (n*t)\n return a #This is what makes the function \"fruitful\"","def sumForRow(self, row):\n s = float(self.betas[0]) # b0 has no match in x\n for i in range(row.size):\n s+=(row[i]*self.betas[i+1])\n return s","def add(self):\n return self._do_calc(self.adder)","def add(self):\n return self._do_calc(self.adder)","def add(self):\n return self._do_calc(self.adder)","def addition_homework(data: Iterator[str]) -> int:\n n = final_sum(data)\n return n.magnitude","def sum_normed (self):\n return self / self.sum","def weighted_sum(self):\n return sum(self.wvalues)","def with_sum_sum_reduction(self):\n return self.with_reduction(lambda x: x.sum())","def calculate_total_cost(state):\r\n return state.cost()","def wsum(self):\n return reduce(operator.add, self.wvalues, 0.0)","def sum(self):\n return self.aggregate(np.sum)","def sum(self):\n return sum(self.values)","def sum(self):\n if self.isscalar():\n s = self.defval\n else:\n if self.defval:\n msg = \"Sum of a tensor wish defval != 0 not implemented.\"\n raise NotImplementedError(msg)\n s = 0\n for v in self.sects.values():\n s += np.sum(v)\n return s","def sum(self):\n return np.dot(self.data.T, self.weights)","def total_reward(self):\n return np.sum(self.rewards)","def sum(self):\n # skipna == True\n # only_numerical == True\n # skipna == True\n return self._lift(\"sum\")","def eval_sum(parse_result):\r\n total = 0.0\r\n current_op = operator.add\r\n for token in parse_result:\r\n if token == '+':\r\n current_op = operator.add\r\n elif token == '-':\r\n current_op = operator.sub\r\n else:\r\n total = current_op(total, token)\r\n return total","def calculate_total_cost(state):\n pass","def terninger_sum(antal_kast):\n return(sum(terning2(antal_kast))) #Sum() returnere summen af alle elementer i en liste.","def getSum(self, a, b):\n #\n # 首先，sum 存放每次循环中 a 与 b 的异或值，也就是直接相加值；\n # b 存放每次的进位值，然后 a 存储 sum （也就是直接相加值）进入下一次循环（当进位值非空）；\n # 当且仅当进位值为空时，用户的上一次循环中的 sum 已经是可以直接相加的异或结果了，此时得到结果，返回。\n #\n # if a == 0:\n # return b\n # if b == 0:\n # return a\n # while b != 0:\n # carry = a & b\n # a = a ^ b\n # b = carry << 1\n # return a\n # 32 bits interger max\n MAX = 0x7FFFFFFF\n # 32 bits interger min\n MIN = 0x80000000\n # mask to get last 32 bits\n mask = 0xFFFFFFFF\n\n #print('doc:', )\n while b != 0:\n a, b = (a ^ b) & mask, ((a & b) << 1) & mask\n\n return a if a <= MAX else ~(a ^ mask)","def mlp_weight_sum(self) -> Tuple[Tensor, Tensor]:\n if self._model:\n return self._model.mlp_weight_sum()\n return torch.tensor([0.0]), torch.tensor([0.0])","def get_sum(self):\n return self.__tree[0]","def balance(self):\n return self._rbal - self._lbal","def _harmonic_sum(self, rank: int) -> complex:\n return (self.flm * self.slepian.eigenvectors[rank].conj()).sum()","def tot(self):\n return self.det + self.out + self.faint + self.late","def balance(self):\n return sum(self.operations.select())\n 11","def calculate(self):\r\n self.result.config(text=float_sum(self.operand_A.get(),self.operand_B.get()))","def som(getallenlijst):\r\n total = sum(getallenlijst)\r\n return total","def investment_sum(self, user=None, stock=None, brokerage_account=None, budget_account=None):\n query_args = {'user': user, 'stock': stock, 'brokerage_account': brokerage_account, 'budget_account': budget_account}\n # don't include the args if the value is none\n final_query_args = {k: v for k, v in query_args.items() if v is not None}\n queryset = super().get_queryset().filter(**final_query_args)\n total = queryset.aggregate(total=Sum(F('num_shares') * F('stock__market_price')))['total']\n\n if total is None:\n return 0\n\n return round(total, 2)","def sum_biomass_weight(reaction):\n return sum(-coef * met.formula_weight\n for (met, coef) in iteritems(reaction.metabolites)) / 1000.0","def get_billed_amount(self):\n return Leg.objects.filter(transaction__recurred_cost__recurring_cost=self, amount__gt=0).sum_to_balance()","def summed(L):\r\n result = 0\r\n for e in L:\r\n result = result + e # or result += e\r\n return result","def _get_sum_total(\n self, cr, uid, brw, operand, number_month=None,\n one_per=False, bag=None, context=None):\n context = context and dict(context) or {}\n res = 0\n\n # If the report is two or twelve columns, will choose the field needed\n # to make the sum\n if context.get('whole_fy', False) or one_per:\n field_name = 'ytd'\n else:\n field_name = 'period_%s' % str(number_month)\n\n # It takes the sum of the total_ids & operand_ids\n for ttt in getattr(brw, operand):\n res += bag[ttt.id].get(field_name, 0.0)\n return res","def calculateR(sapienses: list) -> float:\n r = 0\n for i in sapienses:\n r = r + i.numberInfected\n r=r/I0\n r = r*S/(S+R+D)\n return r","def calc_return_temp(sum_t_m, sum_m):\n if sum_m > 0:\n tr = sum_t_m / sum_m\n else:\n tr = 0\n return tr","def _compute_amount(self):\n raise NotImplementedError()","def lsum (inlist):\r\n s = 0\r\n for item in inlist:\r\n s = s + item\r\n return s","def sum (self):\n return self.values.sum ()","def sum (self):\n return self.values.sum ()","def _get_sum(self):\r\n try:\r\n return self._sum\r\n except AttributeError:\r\n self._sum = self.no_nan.sum()\r\n # The following 2 lines are needede as in Python 3.3 with NumPy\r\n # 1.7.1, numpy.ndarray and numpy.memmap aren't hashable.\r\n if type(self._sum) is numpy.memmap:\r\n self._sum = numpy.asarray(self._sum).item()\r\n if self.has_nan and self.no_nan.mask.all():\r\n # In this case the sum is not properly computed by numpy.\r\n self._sum = 0\r\n if numpy.isinf(self._sum) or numpy.isnan(self._sum):\r\n # NaN may happen when there are both -inf and +inf values.\r\n if self.has_nan:\r\n # Filter both NaN and Inf values.\r\n mask = self.no_nan.mask + numpy.isinf(self[1])\r\n else:\r\n # Filter only Inf values.\r\n mask = numpy.isinf(self[1])\r\n if mask.all():\r\n self._sum = 0\r\n else:\r\n self._sum = numpy.ma.masked_array(self[1], mask).sum()\r\n # At this point there should be no more NaN.\r\n assert not numpy.isnan(self._sum)\r\n return self._sum","def suma(a, b):\n\n\ttotal = a + b\n\treturn total","def calculate(self):","def sum_sum(t, init):\n return sum(t, init)","def calc_sum(a, b, c, d, e):\n return (a + b + c + d + e)","def sum(self):\n\n return time_stat(self, stat=\"sum\")","def compute_total_paid(self):\n total = 0.0\n for line in self.loan_ids:\n if line.pay:\n total += line.amount\n self.total_paid = total","def get(self):\n args = single_parser.parse_args()\n n1 = args.n\n m1 = args.m\n r = summation(n1, m1)\n print(r)\n return {\"add\": r}","def get_total_redeem(self):\n total = 0\n for redeem in self.get_redeems():\n total += redeem.get_total()\n return total","def sum(self):\n return sum(self.times)","def sum(self):\n return sum(self.times)","def sum(self):\n return sum(self.times)","def findPayment (loan, r , m):\r\n\r\n return loan*((r*(l+r)**m)/((l+r)**m-1))","def val_sum(self, axis = None):\n f = self.to_Poly()\n return f.val_sum(axis).to_PolyMesh(self.params)","def sum(matrix):\n\n return float(sum([sum(row) for row in matrix]))","def computing(self, inputList):\n\t\tr = 0\t# The sum variable\n\n\t\t# Summation and Threshold function(Activate function)\n\t\tfor i in range(0, self.numberOfInput):\n\t\t\tr += (int)(inputList[i]) * self.weight[i]\n\t\t\tif debugMode == True:\n\t\t\t\tprint \"\"\n\t\t\t\tprint \"input: \", inputList[i], \"weight: \", self.weight[i]\n\t\t\t\tprint \"sum: \", r\n\t\tif r > self.theta:\n\t\t\treturn 1.0\n\t\telse:\n\t\t\treturn -1.0;","def embedding_sum(self) -> Tuple[Tensor, Tensor]:\n if self._model:\n return self._model.embedding_sum()\n return torch.tensor([0.0]), torch.tensor([0.0])","def calculate_pool_reward(height: uint32) -> uint64:\n\n if height == 0:\n return uint64(int((9 / 10) * 21000062 * _mojo_per_ethgreen))\n elif height < 3 * _blocks_per_year:\n return uint64(int((8 / 10) * 20 * _mojo_per_ethgreen))\n elif height < 6 * _blocks_per_year:\n return uint64(int((8 / 10) * 10 * _mojo_per_ethgreen))\n elif height < 9 * _blocks_per_year:\n return uint64(int((8 / 10) * 5 * _mojo_per_ethgreen))\n elif height < 12 * _blocks_per_year:\n return uint64(int((8 / 10) * 2.5 * _mojo_per_ethgreen))\n else:\n return uint64(int((8 / 10) * 1.25 * _mojo_per_ethgreen))","def get_blr_strength(self,\n blr: BoundedLinearRegressions) -> float:\n # Return 0 if slopes are different signs.\n if blr.minima_regression.slope * blr.maxima_regression.slope < 0:\n return 0\n\n # Return 0 if not enough data.\n if len(blr.candles) <= 3:\n return 0\n\n # Find high and low prices of the trendline period.\n high_price = max([candle.high for candle in blr.candles])\n low_price = max([candle.low for candle in blr.candles])\n\n # Find start and end of the period.\n start_moment = max([candle.moment for candle in blr.candles])\n end_moment = min([candle.moment for candle in blr.candles])\n\n # Take signal strength to be the average of the two slopes.\n minima_slope_pct = abs(blr.minima_regression.y_of_x(end_moment) - blr.minima_regression.y_of_x(start_moment)) \\\n / max(0.01, high_price - low_price)\n maxima_slope_pct = abs(blr.maxima_regression.y_of_x(end_moment) - blr.maxima_regression.y_of_x(start_moment)) \\\n / max(0.01, high_price - low_price)\n signal_strength = (minima_slope_pct + maxima_slope_pct) / 2.0\n\n # Scale down signal strength.\n signal_strength = min(1, signal_strength / 5.0)\n\n # Ensure the signal strength has the correct sign.\n if blr.minima_regression.slope < 0:\n signal_strength += -1\n\n return signal_strength","def get_wh_sum(self, fb_brw):\n get_wh_sum = 0.0\n for line in fb_brw.fbl_ids:\n get_wh_sum += line['get_wh_vat']\n return get_wh_sum","def n_suma(a1,nr_wyrazu,r):\n return (2*a1+(nr_wyrazu-1))*nr_wyrazu/2","def calculate_total(self):\n if self.total_price == 0:\n for discount in self.discounts:\n for item in self.items:\n item.add_discount(discount)\n\n for item in self.items:\n self.total_price += item.final_price()\n\n return self.total_price","def mean(self):\n return self.sum / self.sum_weights","def sum(a,b):\r\n c=a+b\r\n return c","def total_value(self):\n total = 0.0\n for account in self.accounts():\n total += account.available_cash()\n for asset in account.assets():\n total += asset.adjusted_value()\n return total","def calc(self):\n data = [self.calc_noise(name) for name in self._noise_objs.keys() if name in self._budget_noises]\n return quadsum(data)","def run_solution2_simple(self):\n total_fuel_sum = 0\n for n in self.data:\n module_fuel = 0\n base_fuel = n\n while base_fuel > 0:\n base_fuel = self.calculate_fuel(base_fuel)\n module_fuel += base_fuel\n total_fuel_sum += module_fuel\n return total_fuel_sum","def calculate_value(self):\n base = self.balance\n bag = self.bag * self.state['price'] * (1-self.gap)\n value = base + bag\n self.value = value\n return value","def fsum(items):\n return math.fsum(items)","def sumar(self):\n self.resultado = self.valor_1 + self.valor_2","def calculate_pool_reward(height: uint32) -> uint64:\n\n if height == 0:\n return uint64(int((7 / 8) * 21000000 * _mojo_per_chia))\n elif height < 3 * _blocks_per_year:\n return uint64(int((7 / 8) * 2 * _mojo_per_chia))\n elif height < 6 * _blocks_per_year:\n return uint64(int((7 / 8) * 1 * _mojo_per_chia))\n elif height < 9 * _blocks_per_year:\n return uint64(int((7 / 8) * 0.5 * _mojo_per_chia))\n elif height < 12 * _blocks_per_year:\n return uint64(int((7 / 8) * 0.25 * _mojo_per_chia))\n else:\n return uint64(int((7 / 8) * 0.125 * _mojo_per_chia))","def total_earnings(self):\n return self.total_balance - self.net_invested","def get_bprop_reducesum(self):\n\n def bprop(x, axis, out, dout):\n dx = _sum_grad(x, axis, dout)\n return dx, zeros_like(axis)\n return bprop","def sum(self, flow=False):\n return self._hist.sum(flow)","def fsum(iterable):\n return 0.0","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n\n agreement = tp + tn\n chance0 = (tn + fn) * (tn + fp)\n chance1 = (fp + tp) * (fn + tp)\n sum_ = tn + fn + fp + tp\n chance = (chance0 + chance1) / sum_\n\n return (agreement - chance) / (sum_ - chance)","def constraint_sum(w):\n return sum(w) - 1","def balance(p, r, t):\n return p*(1 + r)**t","def _compute_reward(self):\n reward = 0.0\n return reward","def cost(self):\n\t\treturn self.g + self.h","def get_reward(self):\n \n ##get total reward value from Q\n total_reward = 0.0\n for value in self.Q.itervalues():\n total_reward = total_reward + value\n \n ##return the average reward\n return total_reward","def get_reward(self):\n \n ##get total reward value from Q\n total_reward = 0.0\n for value in self.Q.itervalues():\n total_reward = total_reward + value\n \n ##return the average reward\n return total_reward"],"string":"[\n \"def sum(self):\\n return self.vsum\",\n \"def calculate_sum(self):\\n\\n left_sum = self.left.calculate_sum() if self.left else 0\\n right_sum = self.right.calculate_sum() if self.right else 0\\n return self.data + left_sum + right_sum\",\n \"def summation(self):\\n return sum(self.read_ints())\",\n \"def _sum(self):\\n s = 0\\n for element, value in self.items():\\n s += value\\n return s\",\n \"def sum(self) -> int:\\n return self.root.sum\",\n \"def weighted_sum(h):\\n return h\",\n \"def calculate(self) -> float:\",\n \"def get_sum(a,b):\\n return\",\n \"def totalValue(self):\\n\\n\\t\\tvalue = 0\\n\\t\\tfor bottle in self.bottles:\\n\\t\\t\\tvalue += bottle.inflatedCost\\n\\n\\t\\treturn value\",\n \"def sum(self) -> float:\\n return sum(self.values)\",\n \"def sum(self):\\n return self._reduce_for_stat_function(F.sum, only_numeric=True)\",\n \"def segment_sum(self, left, right):\\n if self.empty():\\n return 0\\n less, _ = self.root.split_sums(left)\\n _, greater = self.root.split_sums(right)\\n return self.sum - less - greater\",\n \"def get_weights_sum(self):\\n return self.w_sum\",\n \"def get_sum(self, node: Optional[TreeNode]) -> int:\\n if not node:\\n return 0\\n l_sub_sum, r_sub_sum = self.get_sum(node.left), self.get_sum(node.right)\\n self.ans += abs(l_sub_sum - r_sub_sum)\\n\\n return node.val + l_sub_sum + r_sub_sum\",\n \"def calculate(self):\\n avg = self.sum / self.n if self.n != 0 else 0\\n self.running_avg.append(avg)\\n return avg\",\n \"def sum(self):\\n return sum(self.items())\",\n \"def radical_sum(num, level):\\n if level == 0:\\n return 0\\n \\n return ((radical_sum(num, level - 1) + num) ** 0.5)\",\n \"def sum_value(self, lv, rv):\",\n \"def final_amt(p,r,n,t):\\n\\n a = p * (1 + r/n) ** (n*t)\\n return a #This is what makes the function \\\"fruitful\\\"\",\n \"def sumForRow(self, row):\\n s = float(self.betas[0]) # b0 has no match in x\\n for i in range(row.size):\\n s+=(row[i]*self.betas[i+1])\\n return s\",\n \"def add(self):\\n return self._do_calc(self.adder)\",\n \"def add(self):\\n return self._do_calc(self.adder)\",\n \"def add(self):\\n return self._do_calc(self.adder)\",\n \"def addition_homework(data: Iterator[str]) -> int:\\n n = final_sum(data)\\n return n.magnitude\",\n \"def sum_normed (self):\\n return self / self.sum\",\n \"def weighted_sum(self):\\n return sum(self.wvalues)\",\n \"def with_sum_sum_reduction(self):\\n return self.with_reduction(lambda x: x.sum())\",\n \"def calculate_total_cost(state):\\r\\n return state.cost()\",\n \"def wsum(self):\\n return reduce(operator.add, self.wvalues, 0.0)\",\n \"def sum(self):\\n return self.aggregate(np.sum)\",\n \"def sum(self):\\n return sum(self.values)\",\n \"def sum(self):\\n if self.isscalar():\\n s = self.defval\\n else:\\n if self.defval:\\n msg = \\\"Sum of a tensor wish defval != 0 not implemented.\\\"\\n raise NotImplementedError(msg)\\n s = 0\\n for v in self.sects.values():\\n s += np.sum(v)\\n return s\",\n \"def sum(self):\\n return np.dot(self.data.T, self.weights)\",\n \"def total_reward(self):\\n return np.sum(self.rewards)\",\n \"def sum(self):\\n # skipna == True\\n # only_numerical == True\\n # skipna == True\\n return self._lift(\\\"sum\\\")\",\n \"def eval_sum(parse_result):\\r\\n total = 0.0\\r\\n current_op = operator.add\\r\\n for token in parse_result:\\r\\n if token == '+':\\r\\n current_op = operator.add\\r\\n elif token == '-':\\r\\n current_op = operator.sub\\r\\n else:\\r\\n total = current_op(total, token)\\r\\n return total\",\n \"def calculate_total_cost(state):\\n pass\",\n \"def terninger_sum(antal_kast):\\n return(sum(terning2(antal_kast))) #Sum() returnere summen af alle elementer i en liste.\",\n \"def getSum(self, a, b):\\n #\\n # 首先，sum 存放每次循环中 a 与 b 的异或值，也就是直接相加值；\\n # b 存放每次的进位值，然后 a 存储 sum （也就是直接相加值）进入下一次循环（当进位值非空）；\\n # 当且仅当进位值为空时，用户的上一次循环中的 sum 已经是可以直接相加的异或结果了，此时得到结果，返回。\\n #\\n # if a == 0:\\n # return b\\n # if b == 0:\\n # return a\\n # while b != 0:\\n # carry = a & b\\n # a = a ^ b\\n # b = carry << 1\\n # return a\\n # 32 bits interger max\\n MAX = 0x7FFFFFFF\\n # 32 bits interger min\\n MIN = 0x80000000\\n # mask to get last 32 bits\\n mask = 0xFFFFFFFF\\n\\n #print('doc:', )\\n while b != 0:\\n a, b = (a ^ b) & mask, ((a & b) << 1) & mask\\n\\n return a if a <= MAX else ~(a ^ mask)\",\n \"def mlp_weight_sum(self) -> Tuple[Tensor, Tensor]:\\n if self._model:\\n return self._model.mlp_weight_sum()\\n return torch.tensor([0.0]), torch.tensor([0.0])\",\n \"def get_sum(self):\\n return self.__tree[0]\",\n \"def balance(self):\\n return self._rbal - self._lbal\",\n \"def _harmonic_sum(self, rank: int) -> complex:\\n return (self.flm * self.slepian.eigenvectors[rank].conj()).sum()\",\n \"def tot(self):\\n return self.det + self.out + self.faint + self.late\",\n \"def balance(self):\\n return sum(self.operations.select())\\n 11\",\n \"def calculate(self):\\r\\n self.result.config(text=float_sum(self.operand_A.get(),self.operand_B.get()))\",\n \"def som(getallenlijst):\\r\\n total = sum(getallenlijst)\\r\\n return total\",\n \"def investment_sum(self, user=None, stock=None, brokerage_account=None, budget_account=None):\\n query_args = {'user': user, 'stock': stock, 'brokerage_account': brokerage_account, 'budget_account': budget_account}\\n # don't include the args if the value is none\\n final_query_args = {k: v for k, v in query_args.items() if v is not None}\\n queryset = super().get_queryset().filter(**final_query_args)\\n total = queryset.aggregate(total=Sum(F('num_shares') * F('stock__market_price')))['total']\\n\\n if total is None:\\n return 0\\n\\n return round(total, 2)\",\n \"def sum_biomass_weight(reaction):\\n return sum(-coef * met.formula_weight\\n for (met, coef) in iteritems(reaction.metabolites)) / 1000.0\",\n \"def get_billed_amount(self):\\n return Leg.objects.filter(transaction__recurred_cost__recurring_cost=self, amount__gt=0).sum_to_balance()\",\n \"def summed(L):\\r\\n result = 0\\r\\n for e in L:\\r\\n result = result + e # or result += e\\r\\n return result\",\n \"def _get_sum_total(\\n self, cr, uid, brw, operand, number_month=None,\\n one_per=False, bag=None, context=None):\\n context = context and dict(context) or {}\\n res = 0\\n\\n # If the report is two or twelve columns, will choose the field needed\\n # to make the sum\\n if context.get('whole_fy', False) or one_per:\\n field_name = 'ytd'\\n else:\\n field_name = 'period_%s' % str(number_month)\\n\\n # It takes the sum of the total_ids & operand_ids\\n for ttt in getattr(brw, operand):\\n res += bag[ttt.id].get(field_name, 0.0)\\n return res\",\n \"def calculateR(sapienses: list) -> float:\\n r = 0\\n for i in sapienses:\\n r = r + i.numberInfected\\n r=r/I0\\n r = r*S/(S+R+D)\\n return r\",\n \"def calc_return_temp(sum_t_m, sum_m):\\n if sum_m > 0:\\n tr = sum_t_m / sum_m\\n else:\\n tr = 0\\n return tr\",\n \"def _compute_amount(self):\\n raise NotImplementedError()\",\n \"def lsum (inlist):\\r\\n s = 0\\r\\n for item in inlist:\\r\\n s = s + item\\r\\n return s\",\n \"def sum (self):\\n return self.values.sum ()\",\n \"def sum (self):\\n return self.values.sum ()\",\n \"def _get_sum(self):\\r\\n try:\\r\\n return self._sum\\r\\n except AttributeError:\\r\\n self._sum = self.no_nan.sum()\\r\\n # The following 2 lines are needede as in Python 3.3 with NumPy\\r\\n # 1.7.1, numpy.ndarray and numpy.memmap aren't hashable.\\r\\n if type(self._sum) is numpy.memmap:\\r\\n self._sum = numpy.asarray(self._sum).item()\\r\\n if self.has_nan and self.no_nan.mask.all():\\r\\n # In this case the sum is not properly computed by numpy.\\r\\n self._sum = 0\\r\\n if numpy.isinf(self._sum) or numpy.isnan(self._sum):\\r\\n # NaN may happen when there are both -inf and +inf values.\\r\\n if self.has_nan:\\r\\n # Filter both NaN and Inf values.\\r\\n mask = self.no_nan.mask + numpy.isinf(self[1])\\r\\n else:\\r\\n # Filter only Inf values.\\r\\n mask = numpy.isinf(self[1])\\r\\n if mask.all():\\r\\n self._sum = 0\\r\\n else:\\r\\n self._sum = numpy.ma.masked_array(self[1], mask).sum()\\r\\n # At this point there should be no more NaN.\\r\\n assert not numpy.isnan(self._sum)\\r\\n return self._sum\",\n \"def suma(a, b):\\n\\n\\ttotal = a + b\\n\\treturn total\",\n \"def calculate(self):\",\n \"def sum_sum(t, init):\\n return sum(t, init)\",\n \"def calc_sum(a, b, c, d, e):\\n return (a + b + c + d + e)\",\n \"def sum(self):\\n\\n return time_stat(self, stat=\\\"sum\\\")\",\n \"def compute_total_paid(self):\\n total = 0.0\\n for line in self.loan_ids:\\n if line.pay:\\n total += line.amount\\n self.total_paid = total\",\n \"def get(self):\\n args = single_parser.parse_args()\\n n1 = args.n\\n m1 = args.m\\n r = summation(n1, m1)\\n print(r)\\n return {\\\"add\\\": r}\",\n \"def get_total_redeem(self):\\n total = 0\\n for redeem in self.get_redeems():\\n total += redeem.get_total()\\n return total\",\n \"def sum(self):\\n return sum(self.times)\",\n \"def sum(self):\\n return sum(self.times)\",\n \"def sum(self):\\n return sum(self.times)\",\n \"def findPayment (loan, r , m):\\r\\n\\r\\n return loan*((r*(l+r)**m)/((l+r)**m-1))\",\n \"def val_sum(self, axis = None):\\n f = self.to_Poly()\\n return f.val_sum(axis).to_PolyMesh(self.params)\",\n \"def sum(matrix):\\n\\n return float(sum([sum(row) for row in matrix]))\",\n \"def computing(self, inputList):\\n\\t\\tr = 0\\t# The sum variable\\n\\n\\t\\t# Summation and Threshold function(Activate function)\\n\\t\\tfor i in range(0, self.numberOfInput):\\n\\t\\t\\tr += (int)(inputList[i]) * self.weight[i]\\n\\t\\t\\tif debugMode == True:\\n\\t\\t\\t\\tprint \\\"\\\"\\n\\t\\t\\t\\tprint \\\"input: \\\", inputList[i], \\\"weight: \\\", self.weight[i]\\n\\t\\t\\t\\tprint \\\"sum: \\\", r\\n\\t\\tif r > self.theta:\\n\\t\\t\\treturn 1.0\\n\\t\\telse:\\n\\t\\t\\treturn -1.0;\",\n \"def embedding_sum(self) -> Tuple[Tensor, Tensor]:\\n if self._model:\\n return self._model.embedding_sum()\\n return torch.tensor([0.0]), torch.tensor([0.0])\",\n \"def calculate_pool_reward(height: uint32) -> uint64:\\n\\n if height == 0:\\n return uint64(int((9 / 10) * 21000062 * _mojo_per_ethgreen))\\n elif height < 3 * _blocks_per_year:\\n return uint64(int((8 / 10) * 20 * _mojo_per_ethgreen))\\n elif height < 6 * _blocks_per_year:\\n return uint64(int((8 / 10) * 10 * _mojo_per_ethgreen))\\n elif height < 9 * _blocks_per_year:\\n return uint64(int((8 / 10) * 5 * _mojo_per_ethgreen))\\n elif height < 12 * _blocks_per_year:\\n return uint64(int((8 / 10) * 2.5 * _mojo_per_ethgreen))\\n else:\\n return uint64(int((8 / 10) * 1.25 * _mojo_per_ethgreen))\",\n \"def get_blr_strength(self,\\n blr: BoundedLinearRegressions) -> float:\\n # Return 0 if slopes are different signs.\\n if blr.minima_regression.slope * blr.maxima_regression.slope < 0:\\n return 0\\n\\n # Return 0 if not enough data.\\n if len(blr.candles) <= 3:\\n return 0\\n\\n # Find high and low prices of the trendline period.\\n high_price = max([candle.high for candle in blr.candles])\\n low_price = max([candle.low for candle in blr.candles])\\n\\n # Find start and end of the period.\\n start_moment = max([candle.moment for candle in blr.candles])\\n end_moment = min([candle.moment for candle in blr.candles])\\n\\n # Take signal strength to be the average of the two slopes.\\n minima_slope_pct = abs(blr.minima_regression.y_of_x(end_moment) - blr.minima_regression.y_of_x(start_moment)) \\\\\\n / max(0.01, high_price - low_price)\\n maxima_slope_pct = abs(blr.maxima_regression.y_of_x(end_moment) - blr.maxima_regression.y_of_x(start_moment)) \\\\\\n / max(0.01, high_price - low_price)\\n signal_strength = (minima_slope_pct + maxima_slope_pct) / 2.0\\n\\n # Scale down signal strength.\\n signal_strength = min(1, signal_strength / 5.0)\\n\\n # Ensure the signal strength has the correct sign.\\n if blr.minima_regression.slope < 0:\\n signal_strength += -1\\n\\n return signal_strength\",\n \"def get_wh_sum(self, fb_brw):\\n get_wh_sum = 0.0\\n for line in fb_brw.fbl_ids:\\n get_wh_sum += line['get_wh_vat']\\n return get_wh_sum\",\n \"def n_suma(a1,nr_wyrazu,r):\\n return (2*a1+(nr_wyrazu-1))*nr_wyrazu/2\",\n \"def calculate_total(self):\\n if self.total_price == 0:\\n for discount in self.discounts:\\n for item in self.items:\\n item.add_discount(discount)\\n\\n for item in self.items:\\n self.total_price += item.final_price()\\n\\n return self.total_price\",\n \"def mean(self):\\n return self.sum / self.sum_weights\",\n \"def sum(a,b):\\r\\n c=a+b\\r\\n return c\",\n \"def total_value(self):\\n total = 0.0\\n for account in self.accounts():\\n total += account.available_cash()\\n for asset in account.assets():\\n total += asset.adjusted_value()\\n return total\",\n \"def calc(self):\\n data = [self.calc_noise(name) for name in self._noise_objs.keys() if name in self._budget_noises]\\n return quadsum(data)\",\n \"def run_solution2_simple(self):\\n total_fuel_sum = 0\\n for n in self.data:\\n module_fuel = 0\\n base_fuel = n\\n while base_fuel > 0:\\n base_fuel = self.calculate_fuel(base_fuel)\\n module_fuel += base_fuel\\n total_fuel_sum += module_fuel\\n return total_fuel_sum\",\n \"def calculate_value(self):\\n base = self.balance\\n bag = self.bag * self.state['price'] * (1-self.gap)\\n value = base + bag\\n self.value = value\\n return value\",\n \"def fsum(items):\\n return math.fsum(items)\",\n \"def sumar(self):\\n self.resultado = self.valor_1 + self.valor_2\",\n \"def calculate_pool_reward(height: uint32) -> uint64:\\n\\n if height == 0:\\n return uint64(int((7 / 8) * 21000000 * _mojo_per_chia))\\n elif height < 3 * _blocks_per_year:\\n return uint64(int((7 / 8) * 2 * _mojo_per_chia))\\n elif height < 6 * _blocks_per_year:\\n return uint64(int((7 / 8) * 1 * _mojo_per_chia))\\n elif height < 9 * _blocks_per_year:\\n return uint64(int((7 / 8) * 0.5 * _mojo_per_chia))\\n elif height < 12 * _blocks_per_year:\\n return uint64(int((7 / 8) * 0.25 * _mojo_per_chia))\\n else:\\n return uint64(int((7 / 8) * 0.125 * _mojo_per_chia))\",\n \"def total_earnings(self):\\n return self.total_balance - self.net_invested\",\n \"def get_bprop_reducesum(self):\\n\\n def bprop(x, axis, out, dout):\\n dx = _sum_grad(x, axis, dout)\\n return dx, zeros_like(axis)\\n return bprop\",\n \"def sum(self, flow=False):\\n return self._hist.sum(flow)\",\n \"def fsum(iterable):\\n return 0.0\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n\\n agreement = tp + tn\\n chance0 = (tn + fn) * (tn + fp)\\n chance1 = (fp + tp) * (fn + tp)\\n sum_ = tn + fn + fp + tp\\n chance = (chance0 + chance1) / sum_\\n\\n return (agreement - chance) / (sum_ - chance)\",\n \"def constraint_sum(w):\\n return sum(w) - 1\",\n \"def balance(p, r, t):\\n return p*(1 + r)**t\",\n \"def _compute_reward(self):\\n reward = 0.0\\n return reward\",\n \"def cost(self):\\n\\t\\treturn self.g + self.h\",\n \"def get_reward(self):\\n \\n ##get total reward value from Q\\n total_reward = 0.0\\n for value in self.Q.itervalues():\\n total_reward = total_reward + value\\n \\n ##return the average reward\\n return total_reward\",\n \"def get_reward(self):\\n \\n ##get total reward value from Q\\n total_reward = 0.0\\n for value in self.Q.itervalues():\\n total_reward = total_reward + value\\n \\n ##return the average reward\\n return total_reward\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6603156","0.6591869","0.627234","0.62047184","0.61978614","0.6112021","0.60509235","0.5939432","0.5937607","0.5934721","0.5928078","0.5926152","0.5860448","0.5854603","0.58539337","0.58510864","0.58500665","0.5822862","0.581909","0.58153033","0.57878613","0.57878613","0.57878613","0.57816666","0.5768905","0.5766367","0.5717654","0.571306","0.57075083","0.5703199","0.56993514","0.5691724","0.56723875","0.56652147","0.5663449","0.5659694","0.565051","0.5644532","0.56294286","0.5624084","0.5621903","0.56069505","0.5597349","0.5580462","0.5579641","0.55738276","0.55506235","0.55458647","0.55414414","0.5540763","0.5537327","0.5529825","0.5523015","0.55114937","0.55103797","0.55051774","0.5495838","0.5495838","0.5487361","0.5479333","0.54792446","0.54712677","0.5459729","0.54588735","0.5443768","0.5426011","0.5422741","0.5421814","0.5421814","0.5421814","0.54193574","0.5417455","0.54174197","0.54062986","0.5405635","0.54050064","0.54047614","0.54045707","0.5402415","0.54009557","0.5400052","0.5395444","0.53939074","0.5390553","0.53881574","0.5384627","0.538284","0.5379991","0.5375103","0.5344186","0.5342139","0.533844","0.5336377","0.533527","0.53340673","0.5332518","0.53293693","0.5328179","0.5322672","0.5322672"],"string":"[\n \"0.6603156\",\n \"0.6591869\",\n \"0.627234\",\n \"0.62047184\",\n \"0.61978614\",\n \"0.6112021\",\n \"0.60509235\",\n \"0.5939432\",\n \"0.5937607\",\n \"0.5934721\",\n \"0.5928078\",\n \"0.5926152\",\n \"0.5860448\",\n \"0.5854603\",\n \"0.58539337\",\n \"0.58510864\",\n \"0.58500665\",\n \"0.5822862\",\n \"0.581909\",\n \"0.58153033\",\n \"0.57878613\",\n \"0.57878613\",\n \"0.57878613\",\n \"0.57816666\",\n \"0.5768905\",\n \"0.5766367\",\n \"0.5717654\",\n \"0.571306\",\n \"0.57075083\",\n \"0.5703199\",\n \"0.56993514\",\n \"0.5691724\",\n \"0.56723875\",\n \"0.56652147\",\n \"0.5663449\",\n \"0.5659694\",\n \"0.565051\",\n \"0.5644532\",\n \"0.56294286\",\n \"0.5624084\",\n \"0.5621903\",\n \"0.56069505\",\n \"0.5597349\",\n \"0.5580462\",\n \"0.5579641\",\n \"0.55738276\",\n \"0.55506235\",\n \"0.55458647\",\n \"0.55414414\",\n \"0.5540763\",\n \"0.5537327\",\n \"0.5529825\",\n \"0.5523015\",\n \"0.55114937\",\n \"0.55103797\",\n \"0.55051774\",\n \"0.5495838\",\n \"0.5495838\",\n \"0.5487361\",\n \"0.5479333\",\n \"0.54792446\",\n \"0.54712677\",\n \"0.5459729\",\n \"0.54588735\",\n \"0.5443768\",\n \"0.5426011\",\n \"0.5422741\",\n \"0.5421814\",\n \"0.5421814\",\n \"0.5421814\",\n \"0.54193574\",\n \"0.5417455\",\n \"0.54174197\",\n \"0.54062986\",\n \"0.5405635\",\n \"0.54050064\",\n \"0.54047614\",\n \"0.54045707\",\n \"0.5402415\",\n \"0.54009557\",\n \"0.5400052\",\n \"0.5395444\",\n \"0.53939074\",\n \"0.5390553\",\n \"0.53881574\",\n \"0.5384627\",\n \"0.538284\",\n \"0.5379991\",\n \"0.5375103\",\n \"0.5344186\",\n \"0.5342139\",\n \"0.533844\",\n \"0.5336377\",\n \"0.533527\",\n \"0.53340673\",\n \"0.5332518\",\n \"0.53293693\",\n \"0.5328179\",\n \"0.5322672\",\n \"0.5322672\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69721985"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76097,"cells":{"query":{"kind":"string","value":"Split data by options of an attribute"},"document":{"kind":"string","value":"def splitBy(data, attribute_id):\n \n col = getColumn(data, attribute_id)\n values = set(col)\n split_data = [] \n for i in values:\n subset = [row for row in data if row[attribute_id] == i]\n split_data.append(subset)\n \n return split_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getNewData(self, data, splitIndex, attrVal):\n newData = []\n for record in data:\n if record[splitIndex] == attrVal:\n newRecord =[]\n lenRecord = len(record)\n\n for i in range(lenRecord):\n # doesnt include the split attribute\n if i == splitIndex:\n continue\n newRecord.append(record[i])\n newData.append(newRecord)\n return newData","def split_attrs(s, *a, **kw):\n return split_attrs(s, *a, **kw)","def split(self, X):","def splitAttribute(self, atr, divider=0.5):\n big, lit = DecisionTree(None, self.atr), DecisionTree(None, self.atr)\n for d in self:\n if d[atr] > divider: big.append(d)\n else: lit.append(d)\n return lit, big","def split_features(data):\n X = data.copy()\n #split nucleotid string (len=60) into a list of independent characters (DNA nucleotids)\n X['dna'] = X['dna'].map(lambda x : list(str(x).strip()))\n #create 60 new attributes (columns) for each DNA nucleotide index\n #each attribute has name dna_idx where idx is index (1-based) in the list above\n for idx in range(60):\n X['dna_%d' % (idx+1)] = X['dna'].map(lambda x : x[idx])\n #remove the old dna column (redundant information)\n del X['dna']\n #remove descriptor\n del X['id']\n \n return X","def getSplitAttr(self, data, attributes):\n splitAttrIndex = 0\n lengthAttr = len(attributes)\n del self.infoGain[:]\n index = 0\n while index < lengthAttr:\n self.infoGain.append(self.getInfoGain(data, index))\n index += 1\n\n for gain in self.infoGain:\n if gain == max(self.infoGain):\n break\n splitAttrIndex += 1\n return splitAttrIndex","def extractAttrs(data):\n\treturn [instance[1:] for instance in data]","def split_by_attribute(dbsession, group, attr):\n values = []\n for item in group.items:\n if attr in item.attributes and item.attributes[attr]:\n values.extend(item.attributes[attr])\n categories = [\n (v, c) for v, c in Counter(values).most_common() if c < len(group.items) * 0.6666 and c >= 15 # noqa: PLR2004\n ]\n if categories:\n category_values = [v for v, _ in categories]\n has_values = 0\n for item in group.items:\n found = False\n for value in item.attributes[attr]:\n if value in category_values:\n found = True\n break\n if found:\n has_values = has_values + 1\n if has_values / len(group.items) > 0.9: # noqa: PLR2004\n categories.reverse()\n for category in categories:\n new_group = Group(\n value=category[0], label=f\"{group.label} - {category[0]}\", parent=group, split=\"attribute\"\n )\n dbsession.add(new_group)\n for item in list(group.items):\n if category[0] in item.attributes[attr]:\n item.group = new_group\n new_group = Group(value=group.label, label=group.label, parent=group, split=\"attribute\")\n dbsession.add(new_group)\n for item in list(group.items):\n item.group = new_group\n return True\n return False","def split_validation_data(*data, divmod=0.5):\n n = round((len(data[0]) - 1) * divmod)\n return [(d[n:], d[:n]) for d in data]","def partition_instances(instances, split_attribute, attribute_domains):\n # this is a group by split_attribute's domain, not by\n # the values of this attribute in instances\n # example: if split_attribute is \"level\"\n attribute_domain = attribute_domains[split_attribute] # [\"Senior\", \"Mid\", \"Junior\"]\n # Build a dictionary\n partitions = {} # key (attribute value): value (list of instances with this attribute value)\n # For loop through attributes in dictionary\n for attribute_value in attribute_domain:\n partitions[attribute_value] = []\n for instance in instances:\n index = int(split_attribute[3:])\n if instance[index] == attribute_value:\n partitions[attribute_value].append(instance)\n return partitions","def split(df, group):\n\n data = namedtuple(\"data\", [\"filename\", \"object\"]) #initiate \"data\" tyoe\n gb = df.groupby(group) #group df by group attribute\n return [\n data(filename, gb.get_group(x))\n for filename, x in zip(gb.groups.keys(), gb.groups)\n ]","def split_dataset_for_one_attribute(gender_confident_data, attribute='text_cleaned'):\n\n # Converting text strings into a matrix of word token counts.\n cv = CountVectorizer()\n inputString = cv.fit_transform(gender_confident_data[attribute])\n\n # Encodes class labels from 0 to Num_of_classes-1\n le = LabelEncoder()\n outputString = le.fit_transform(gender_confident_data['gender'])\n\n # Splitting the data such that 66% of the data is assigned as training data and the rest as the test data set.\n input_train, input_test, output_train, output_test = train_test_split(inputString, outputString, train_size=0.66)\n\n return input_train, output_train, input_test, output_test","def split(self, attribute):\n if attribute not in self.attributes:\n raise KeyError('Attribute not present in node')\n \n self.split_attr = attribute\n \n # list() is used to make a copy of the list instead of pointing to the same list\n child_attributes = list(self.attributes)\n child_attributes.remove(attribute)\n \n child1_ancestors = list(self.ancestors)\n child0_ancestors = list(self.ancestors)\n child1_ancestors.append(attribute_value(attribute, 1))\n child0_ancestors.append(attribute_value(attribute, 0))\n \n self.val1 = Node(child_attributes, child1_ancestors, self.data, self.heuristic)\n self.val0 = Node(child_attributes, child0_ancestors, self.data, self.heuristic)","def split_X_y(data):\n return data.drop(columns=\"price\"), data[\"price\"]","def splitmetric(self, dataset, attr, target_attr):\n raise NotImplementedError('Subclass should implement this method')","def targetFeatureSplit( data ):\n\n target = []\n features = []\n for item in data:\n target.append( item[0] )\n features.append( item[1:] )\n\n return target, features","def making_dataset_list_val(data:pandas.core.frame.DataFrame, split_num:int) -> list:\n val_data_list = []\n for i in range(split_num):\n val_data_list.append(data[data['separate_num'] == i])\n for i in range(split_num):\n val_data_list[i] = val_data_list[i].drop(['separate_num'], axis = 1)\n return val_data_list","def split_data_into_input_and_output(data):\n data_in, data_out = list(zip(*[((x[\"synopsis\"]), x[\"gross\"]) for x in data]))\n return np.array(data_in), np.array(data_out)","def csv_attribute_unpacker(self, attribute_tuples: List[Tuple[str, str]], separator: str = \",\") \\\n -> Tuple[List[str], List[str]]:\n\n if not attribute_tuples:\n raise ValueError(\"The list of tuples containing the attributes is missing.\")\n\n join_attributes_set: set = set()\n selection_attributes_set: set = set()\n\n for j_attribute_string, s_attribute_string in attribute_tuples:\n for j_attribute in j_attribute_string.split(separator):\n join_attributes_set.add(j_attribute.strip())\n\n for operator in self.operators:\n s_attribute_string = s_attribute_string.replace(separator + operator + separator, operator)\n\n for s_attribute in s_attribute_string.split(separator):\n for operator in self.operators:\n if operator in s_attribute:\n s_attribute = s_attribute.split(operator)[0].strip()\n selection_attributes_set.add(s_attribute)\n break\n\n return list(join_attributes_set), list(selection_attributes_set)","def partition_by(inputs, attribute):\n groups = defaultdict(list)\n for input in inputs:\n key = input[0][attribute] # get the value of the specified attribute\n groups[key].append(input) # then add this input to the correct list\n return groups","def split(input, output, fields, delimiter, encoding, verbose, format_in, zipfile, gzipfile, chunksize, filter):\n if verbose:\n enableVerbose()\n options = {}\n options['delimiter'] = delimiter\n options['fields'] = fields\n options['output'] = output\n options['encoding'] = encoding\n options['format_in'] = format_in\n options['zipfile'] = zipfile\n options['gzipfile'] = gzipfile\n options['chunksize'] = chunksize\n options['filter'] = filter\n acmd = Selector()\n acmd.split(input, options)\n pass","def splitmetric(self, dataset, attr, target_attr):\n freq = {}\n splitinfo = 0.0\n \n #Call information gain\n gain = ID3.splitmetric(self, dataset, attr, target_attr);\n samplenumbers = len(dataset)\n # Calculate the frequency of each of the values in the split attribute\n for record in dataset:\n if (record[attr] in freq):\n freq[record[attr]] += 1.0\n else:\n freq[record[attr]] = 1.0\n \n #Calculate split info, entropy of splitter\n for val in list(freq.values()):\n splitinfo += (- val / samplenumbers) * math.log(val / samplenumbers, 2)\n \n #Split info equals 0 when there only one class in data set\n if splitinfo == 0:\n splitinfo = 0.00000001\n \n return gain / splitinfo","def split_trips(data, fields):\n #todo: use two list comprehensions\n split = []\n for row in data:\n new_row = {\n \"type\": \"start\",\n \"x\": row[fields[\"trip_start_x_field\"]],\n \"y\": row[fields[\"trip_start_y_field\"]],\n }\n\n new_row.update(**row)\n\n split.append(new_row)\n\n new_row = {\n \"type\": \"end\",\n fields[\"trip_id_field\"]: row[fields[\"trip_id_field\"]],\n \"x\": row[fields[\"trip_end_x_field\"]],\n \"y\": row[fields[\"trip_end_y_field\"]],\n }\n\n new_row.update(**row)\n\n split.append(new_row)\n\n return split","def get_possible_splits( df , attribute ):\n ds = df.loc[:,attribute]\n \n # First sort the values \n ds = ds.sort_values().drop_duplicates()\n \n # Compute averages of consecutive values \n ds = ds.rolling(2).sum().divide(2)\n splits = ds[1:].tolist()\n \n # return the possible splits \n return splits","def extract(self, data):","def split_dict_into_options_fontattrs_and_case(*a, **kw):\n return split_dict_into_options_fontattrs_and_case(*a, **kw)","def split_data(self, model_data, tuning=True):\n pass","def _select_attributes(self, item_data):\r\n return item_data","def split_data(name, is_train = True):\r\n data = pd.read_csv(name, header = 0, encoding = 'ISO-8859-1')\r\n X = data['text']\r\n if is_train:\r\n Y = data['polarity']\r\n return X, Y\r\n return X","def seperateDataCompany(data):\n assert isinstance(data, dict)\n dictionary = dict(data)\n tmp = dictionary.pop('University of California, San Diego - Jacobs School of Engineering')\n dictionary['University of California San Diego'] += tmp\n tmp = dictionary.pop('Amazon Web Services (AWS)')\n dictionary['Amazon'] += tmp\n \n keys = list(dictionary.keys())\n values = list(dictionary.values()) \n return (keys), (values)","def _split_proxy_info(data: str) -> list:\n \n country = data[:2]\n anonymity = data[3:4]\n type_ = data[4:].strip('-+ ') # Remove splitting (- and space) and google_passed flag (+)\n google_passed = data[-1]\n\n return [country, anonymity, type_, google_passed]","def split_data(x, weight = 0.9):\n offset = int(len(x) * weight)\n return x[:offset], x[offset:]","def partition_by(inputs, attribute):\n groups = defaultdict(list)\n for input in inputs:\n key = input[0][attribute]\n groups[key].append(input)\n return groups","def get_attribut(cls, attribut):\n\n if attribut:\n lst_attribut = [\"%s\" % value for value in attribut.split(',')]\n return lst_attribut\n return False","def _split_model_kwargs_association(self, data):\n association_attrs = {\n key: value\n for key, value in iteritems(data)\n # association proxy\n if hasattr(getattr(self.opts.model, key, None), \"remote_attr\")\n }\n kwargs = {\n key: value\n for key, value in iteritems(data)\n if (hasattr(self.opts.model, key) and key not in association_attrs)\n }\n return kwargs, association_attrs","def _split_makeotf_options(comma_str):\n if not comma_str.startswith('-'):\n comma_str = '-' + comma_str\n return comma_str.split(',')","def split(self,\n allow_nonseq_value: bool = False) -> Sequence['DataSample']:\n # 1. split\n data_sample_list = [DataSample() for _ in range(len(self))]\n for k in self.all_keys():\n stacked_value = self.get(k)\n if isinstance(stacked_value, torch.Tensor):\n # split tensor shape like (N, *shape) to N (*shape) tensors\n values = [v for v in stacked_value]\n elif isinstance(stacked_value, LabelData):\n # split tensor shape like (N, *shape) to N (*shape) tensors\n labels = [l_ for l_ in stacked_value.label]\n values = [LabelData(label=l_) for l_ in labels]\n elif isinstance(stacked_value, DataSample):\n values = stacked_value.split()\n else:\n if is_splitable_var(stacked_value):\n values = stacked_value\n elif allow_nonseq_value:\n values = [deepcopy(stacked_value)] * len(self)\n else:\n raise TypeError(\n f'\\'{k}\\' is non-sequential data and '\n '\\'allow_nonseq_value\\' is False. Please check your '\n 'data sample or set \\'allow_nonseq_value\\' as True '\n f'to copy field \\'{k}\\' for all split data sample.')\n\n field = 'metainfo' if k in self.metainfo_keys() else 'data'\n for data, v in zip(data_sample_list, values):\n data.set_field(v, k, field_type=field)\n\n return data_sample_list","def split_model_attr_lookups(self):\n return self.model_attr.split(\"__\")","def split_dataset(dataset):\n sequence = dataset.split()\n return sequence","def split_dataset(dataset):\n sequence = dataset.split()\n return sequence","def splits(cls, exts, fields, root='/Users/yingliu/PycharmProjects/Seq2SeqSemantic/data/',\n train='train2', validation='val2', test='test2', **kwargs):\n return super(SPDataset, cls).splits(\n exts, fields, path=root,\n train = train, validation = validation, test = test, **kwargs)","def split_data(df, split_method='fo', test_size=.2, random_state=42):\n if split_method == 'fo':\n train_set, test_set = _split_fo(df,\n test_size=test_size,\n random_state=random_state)\n elif split_method == 'tfo':\n train_set, test_set = _split_tfo(df, test_size=test_size)\n elif split_method == 'ufo':\n train_set, test_set = _split_ufo(df,\n test_size=test_size,\n random_state=random_state)\n elif split_method == 'utfo':\n train_set, test_set = _split_utfo(df, test_size=test_size)\n else:\n raise HuitreError('Invalid data_split value, expect: ufo, utfo')\n train_set = train_set.reset_index(drop=True)\n test_set = test_set.reset_index(drop=True)\n return train_set, test_set","def extract_data(line):\n tmp = line.split('=',1)[1]\n tmp = tmp.split('data = ')[1:]\n tmp = [x.split('}') for x in tmp]\n tmp = [x[0] for x in tmp]\n tmp = [x.lstrip('{') for x in tmp]\n return tmp","def extract(obj, splitter='<!--more-->'): \n return obj.split(splitter)","def map_csv_attributes(self, attributes: List[tuple]):\n woocommerce_attributes, _ = self._api.get_all_attributes()\n api_attributes = []\n for index, attrs in enumerate(attributes):\n woo_attr = next((x for x in woocommerce_attributes if x[\"name\"] == attrs[0]), None)\n woo_attr_id = 0\n woo_attr_name = attrs[0]\n if woo_attr:\n woo_attr_id = woo_attr[\"id\"]\n woo_attr_name = woo_attr[\"name\"]\n api_attributes.append({\n \"id\": woo_attr_id,\n \"name\": woo_attr_name,\n \"position\": index,\n \"visible\": True,\n \"options\": [attrs[1]]\n })\n return api_attributes","def split(a):\r\n compos = [-1] # compos stores the positions of the relevant commas in the argument string\r\n compos.extend(t[2][1] for t in generate_tokens(StringIO(a).readline) if t[1] == ',')\r\n compos.append(len(a))\r\n return [ a[compos[i]+1:compos[i+1]] for i in xrange(len(compos)-1)]","def splitXY(self, df = None):\n df = df if isinstance(df, pd.DataFrame) else self.df # <-- default\n return tuple(df.filter(regex = self.regex[k])\n for k in ('features', 'targets'))","def split_data(paragraphs):\n para_count = len(paragraphs)\n training_index = int(para_count * 0.7)\n validation_index = int(para_count * 0.9)\n training_data = paragraphs[:training_index]\n validation_data = paragraphs[training_index:validation_index]\n test_data = paragraphs[validation_index:]\n return training_data, validation_data, test_data","def prepare_data(self, lines: List[str]) -> List[str]:\n if self.is_tokenized:\n if self.parser == \"spacy\":\n lines = [l.split() for l in lines]\n elif self.parser == \"udpipe\":\n lines = [[l.split()] for l in lines]\n\n return lines","def getSplit(self):\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\n for j in range(len(self[0]) - 1):\n for i in range(len(self)):\n groups = self.splitAttribute(j, self[i][j]) # lit, big\n gini = self.giniIndex(groups)\n if gini < b_score and (j, \"%.1f\" % self[i][j]) not in self.atr:\n b_index, b_value, b_score, b_groups = j, self[i][\n j], gini, groups\n return b_index, b_value, b_groups, b_score","def extract_opt(options, optname):\n extracted = []\n remaining = []\n for o, v in options:\n if o == optname:\n extracted.append((o, v))\n else:\n remaining.append((o, v))\n return extracted, remaining","def parse_groups(data):\n for k, g in itertools.groupby((line.strip() for line in data), bool):\n if k:\n yield list(g)","def seperateData(data):\n assert isinstance(data, dict)\n dictionary = dict(data)\n keys = dictionary.keys()\n values = dictionary.values()\n return list(keys), list(values)","def make_split_data(read_data):\n split_data = re.split('[,|\\.|\\-|\\*|\\[|\\]|\\#|\\:|\\;|(\\|)|\\\"|\\'|!|\\s]+',read_data)\n\n if split_data[-1] == '':\n del split_data[-1]\n\n return split_data","def making_dataset_list_train(data:pandas.core.frame.DataFrame, split_num:int) -> list:\n train_data_list = []\n for i in range(split_num):\n train_data_list.append(data[data['separate_num'] != i])\n for i in range(split_num):\n train_data_list[i] = train_data_list[i].drop(['separate_num'], axis = 1)\n return train_data_list","def splits(cls, **kwargs):\n kwargs_copy = {x: y for x, y in kwargs.items()}\n if 'mode' not in kwargs:\n kwargs_copy['mode'] = 'answer'\n train = cls(split='train', **kwargs_copy)\n val = cls(split='val', **kwargs_copy)\n # test = cls(split='test', **kwargs_copy)\n return train, val","def split(data):\n return data[:len(data) // 2], data[len(data) // 2:]","def split_data_set_splitted(X, Y):\n\n # Uso la funcion de scikitlearn para separar el data_set\n # Esta funcion por defecto mezcla los datos para asegurar la representacion\n # de los datos en los dos subconjuntos\n #\n # Blanca Cano Camarero me comenta que ponga el stratify = Y porque asi se lo\n # indica el profesor Pablo Mesejo en una consulta realizada. En la referencia\n # que indico de scikitlearn tambien viene documentado este parametro\n # Lo que hace es evitar que haya clases que queden infrarepresentadas\n X_training, X_test, Y_training, Y_test= train_test_split(X, Y, train_size = 0.75, test_size = 0.25, stratify = Y)\n return X_training, X_test, Y_training, Y_test","def splitData(df, split):\n train = df.iloc[:int(len(df)*split)]\n test = df.iloc[int(len(df)*split):]\n \n return train, test","def split_data(data,param):\n all_x = data[['GDP_scaled','CLPRB_scaled','EMFDB_scaled','ENPRP_scaled','NGMPB_scaled','PAPRB_scaled','PCP_scaled','ZNDX_scaled','OP_scaled', 'OP2_scaled']][:55]\n all_y = data[[param]][:55]\n return cross_validation.train_test_split(all_x, all_y, test_size=0.2, random_state=0)","def delimiter_split(\n line: Line, features: Collection[Feature], mode: Mode\n) -> Iterator[Line]:\n try:\n last_leaf = line.leaves[-1]\n except IndexError:\n raise CannotSplit(\"Line empty\") from None\n\n bt = line.bracket_tracker\n try:\n delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)})\n except ValueError:\n raise CannotSplit(\"No delimiters found\") from None\n\n if delimiter_priority == DOT_PRIORITY:\n if bt.delimiter_count_with_priority(delimiter_priority) == 1:\n raise CannotSplit(\"Splitting a single attribute from its owner looks wrong\")\n\n current_line = Line(\n mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets\n )\n lowest_depth = sys.maxsize\n trailing_comma_safe = True\n\n def append_to_line(leaf: Leaf) -> Iterator[Line]:\n \"\"\"Append `leaf` to current line or to new line if appending impossible.\"\"\"\n nonlocal current_line\n try:\n current_line.append_safe(leaf, preformatted=True)\n except ValueError:\n yield current_line\n\n current_line = Line(\n mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets\n )\n current_line.append(leaf)\n\n last_non_comment_leaf = _get_last_non_comment_leaf(line)\n for leaf_idx, leaf in enumerate(line.leaves):\n yield from append_to_line(leaf)\n\n for comment_after in line.comments_after(leaf):\n yield from append_to_line(comment_after)\n\n lowest_depth = min(lowest_depth, leaf.bracket_depth)\n if leaf.bracket_depth == lowest_depth:\n if is_vararg(leaf, within={syms.typedargslist}):\n trailing_comma_safe = (\n trailing_comma_safe and Feature.TRAILING_COMMA_IN_DEF in features\n )\n elif is_vararg(leaf, within={syms.arglist, syms.argument}):\n trailing_comma_safe = (\n trailing_comma_safe and Feature.TRAILING_COMMA_IN_CALL in features\n )\n\n if (\n Preview.add_trailing_comma_consistently in mode\n and last_leaf.type == STANDALONE_COMMENT\n and leaf_idx == last_non_comment_leaf\n ):\n current_line = _safe_add_trailing_comma(\n trailing_comma_safe, delimiter_priority, current_line\n )\n\n leaf_priority = bt.delimiters.get(id(leaf))\n if leaf_priority == delimiter_priority:\n yield current_line\n\n current_line = Line(\n mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets\n )\n if current_line:\n current_line = _safe_add_trailing_comma(\n trailing_comma_safe, delimiter_priority, current_line\n )\n yield current_line","def split(items):\n return {\n \"class\": \"split\",\n \"items\": items\n }","def split_data(dataset, ratio = 0.9):\n cutoff_row = int(dataset.shape[0] * ratio)\n return (dataset[:cutoff_row], dataset[cutoff_row:])","def optgroups(self, name, value, attrs=None):\n options = []\n\n for index, (name, product_data) in enumerate(self.product_fields.items()):\n quantity = product_data['quantity']\n name = product_data['name']\n price = product_data['price']\n if index:\n label = 'product_{}'.format(str(index))\n else:\n label = 'product'\n\n options.append({\n 'value': quantity,\n 'price': price,\n 'name': 'products',\n 'label': name,\n 'type': self.input_type,\n 'template_name': self.option_template_name,\n 'wrap_label': True,\n 'index': index\n })\n\n return options","def generate_splits( records, index ):\n splits = []\n is_numerical = feature_is_numerical( records, index )\n if is_numerical:\n splits = generate_numerical_splits( records, index )\n else:\n splits = generate_category_splits( records, index )\n\n return splits","def split_dev_data(input_data: List[Tuple[str, int]]) -> Tuple[List[Tuple[str, int]],\n List[Tuple[str, int]],\n List[Tuple[str, int]]]:\n training_data, test_data = split_data(input_data)\n\n # split test data in half to test on\n dev_data = set(random.sample(test_data, int(len(test_data) / 2)))\n test_data = set(test_data) - set(dev_data)\n\n return list(training_data), list(test_data), list(test_data)","def split_chunk(chunk, *a, **kw):\n return split_chunk(chunk, *a, **kw)","def getcsv(self, section, option):\n elements = self.get(section, option)\n splitter = ',' if ',' in elements else None\n return [element.strip() for element in elements.split(splitter)]","def split(iterator, criterion):\n a = []\n b = []\n for x in iterator:\n if criterion(x):\n a.append(x)\n else:\n b.append(x)\n\n return a, b","def explode(self, header_attribute='header', value_attribute='value'):\n\n import hxl.filters\n return hxl.filters.ExplodeFilter(self, header_attribute, value_attribute)","def separate_by(self, *criteria):\n def is_a(seq): return all(c(seq) for c in criteria)\n \n def op_separate(s):\n if s is None: return None, None\n return [s for s in s if is_a(s)], [s for s in s if not is_a(s)]\n tuple_array = self.element_wise(op_separate)\n\n return tuple_array.element_wise(lambda x: x[0]), tuple_array.element_wise(lambda x: x[1])","def preprocess_split(self, input_dataset, last_id, num_sents, max_sent_len, prefix_id = \"\"):\n dataset = []\n for sent in input_dataset[last_id:]:\n last_id += 1\n if type(sent) == tuple or len(sent) > max_sent_len or len(sent) <= 1:\n continue\n dataset.append(self.preprocess_sent(sent, prefix_id + str(len(dataset))))\n if len(dataset) == num_sents:\n break\n\n return dataset, last_id","def addSplit(self):\n pass","def split_data(data, feature, split_point):\n data_l = data[data[:, feature - 1] < split_point]\n data_r = data[data[:, feature - 1] >= split_point]\n\n return data_l, data_r","def applyAttrs(data, attrs):\n\tassert(len(data[0]) == len(attrs) + 1)\n\tnum_attrs = len(attrs)\n\tnum_instances = len(data)\n\n\tout = [None] * len(data)\n\tfor row in range(num_instances):\n\t\tinstance = data[row]\n\t\tout[row] = [instance[0]] + ['?' if instance[i+1] == '?' else attrs[i]['vals'][int(instance[i+1])] for i in range(num_attrs)]\n\n\treturn out","def split_data(X, scaling, ids, y, split_ratio=0.2):\r\n split = int(X.shape[0] * split_ratio) # index must be int\r\n X_test = X[:split, :, :, :]\r\n scaling_test = scaling[:split, :]\r\n ids_test = ids[:split]\r\n y_test = y[:split, :]\r\n X_train = X[split:, :, :, :]\r\n scaling_train = scaling[split:, :]\r\n ids_train = y[split:]\r\n y_train = y[split:, :]\r\n\r\n return X_train, scaling_train, ids_train, y_train, X_test, scaling_test, ids_test, y_test","def split_data(self):\n if self.seper == \"whitespace\":\n seperstring = \" \"\n elif self.seper == \"comma\":\n seperstring = \",\"\n elif self.seper == \"tab\":\n seperstring = \"\\t\"\n else:\n print self.seper + \"is not a supported delimiter. Only whitespace, comma, and tab are accepted.\"\n sys.exit()\n f = open(self.filelocation, \"rb\")\n temp = list()\n for line in f.readlines():\n temp.append(line.replace(\"\\n\", \"\").split(seperstring))\n f.close()\n data = dict()\n count = 0\n for row in temp:\n data[count] = list()\n for each in row:\n if each is not \"\":\n data[count].append(each)\n count += 1\n return data, count","def get_subset_split(annotation_data):\r\n\r\n # Get the audio filenames and the splits without duplicates\r\n data = annotation_data[['split', 'audio_filename', 'annotator_id']]\\\r\n .groupby(by=['split', 'audio_filename'], as_index=False)\\\r\n .min()\\\r\n .sort_values('audio_filename')\r\n\r\n train_idxs = []\r\n valid_idxs = []\r\n\r\n for idx, (_, row) in enumerate(data.iterrows()):\r\n if row['split'] == 'train':\r\n train_idxs.append(idx)\r\n elif row['split'] == 'validate' :\r\n # For validation examples, only use verified annotations\r\n valid_idxs.append(idx)\r\n\r\n return np.array(train_idxs), np.array(valid_idxs)","def splitData(data, class_label, seed, ratio):\n\t\n\trandom.seed(seed)\n\tsubset = data.clone()\n\tsize_data = subset.data.shape[0]\n\tn = int(np.floor(size_data * ratio)) # number of datasets in train\n\tindex = random.sample(range(1, size_data), n)\n\tsplit_list = [item for item in [0] for i in range(size_data)]\n\t\n\tfor i in index:\n\t\tsplit_list[i]=1\n\t\n\treturn split_list #returns list of indeces where 0 is test and 1 is training data ","def split_data(data, labels, proportion):\n size = data.shape[0]\n np.random.seed(42)\n s = np.random.permutation(size)\n split_idx = int(proportion * size)\n return (data[s[:split_idx]], data[s[split_idx:]], labels[s[:split_idx]], labels[s[split_idx:]])","def split_data(basedir, data_split=0.80):\n manip = data_manipulator(basedir)\n manip.train_test_split(data_split=data_split)","def _parse_groupped_data(self):\n for i, val in enumerate(self.values.keys()):\n xy = self.values[val]\n self._set_and_get(\"x_\", val, xy[:, 0])\n self._set_and_get(\"y_\", val, xy[:, 1])","def parse_csv_option(option):\n if option:\n return option.split(',')\n else:\n return []","def parse_csv_option(option):\n if option:\n return option.split(',')\n else:\n return []","def parse_dataset(self, data):\n pass","def extract_values(self, data):\n result = []\n for i in data:\n if(len(i) < 2):\n raise ValueError(\"Length of input list is less than 2!\")\n result.append(i[1])\n return result","def split(self, x):\r\n new_beams = np.array([])\r\n for bar in self.bar_elements:\r\n new_beams = np.concatenate((new_beams, bar.split(x)))\r\n return BeamElements(new_beams)","def filter_attributes(self, data):\n self._attributes = {\n \"Yesterday\": data[\"-1\"][self._unit][\"Scale\"],\n \"Tomorrow\": data[\"1\"][self._unit][\"Scale\"],\n \"Day after tomorrow\": data[\"2\"][self._unit][\"Scale\"],\n \"In three days\": data[\"3\"][self._unit][\"Scale\"]\n }","def _find_options(self, inputfield):\r\n elements = inputfield.findall('./options/option')\r\n return [{\r\n 'id': index,\r\n 'description': option.text,\r\n 'choice': option.get('choice')\r\n } for (index, option) in enumerate(elements)]","def split_on_sensitive_attribute(X, y, S):\n\n\tidx_pos = np.where(X[S] == 1)[0]\n\tX_pos, y_pos = X.iloc[idx_pos], y[idx_pos]\n\tX_neg, y_neg = X.drop(X.index[idx_pos]), np.delete(y, idx_pos)\n\n\treturn(X_pos, y_pos, X_neg, y_neg)","def split_records(data, delimiter=r\"\\r\\n\"):\n # https://stackoverflow.com/a/2787979\n return re.split(delimiter + \"\"\"(?=(?:[^'\"]|'[^']*'|\"[^\"]*\")*$)\"\"\", data)","def split_name_values(param_items):\n return_list = list()\n for single_item in param_items:\n temp_list = [single_item[1]]\n temp_list.extend(clear_useless_end(single_item[2]).split(\",\"))\n return_list.append(temp_list)\n\n return return_list","def split_words(self,data=[None]):\r\n content=[]\r\n self.data=data\r\n for i in data:\r\n liste=list(i)\r\n content.append(liste)\r\n return content","def best_split(self):\n sub_group = []\n\n current_entropy = self.entropy(self._Passengers)\n best_gain = 0 # holds the best entropy difference so far\n best_split = self._Attr[0].get_name()\n relative_entropy = 0 # entropy while taking account for the size of the population\n\n for Attribute in self._Attr:\n relative_entropy = 0\n print(\"Attr considered: \" + Attribute.get_name())\n for Attr_option in Attribute.get_options():\n sub_group = []\n for Passenger in self._Passengers:\n if self.passenger_attr_option_check(Passenger,\n Attribute.get_name(),\n Attr_option): # if P.A = V\n sub_group.append(Passenger)\n if len(sub_group) > 0 and len(self._Passengers) > 0:\n relative_entropy += self.entropy(sub_group) * (len(sub_group)/len(self._Passengers))\n\n if current_entropy - relative_entropy > best_gain:\n best_gain = current_entropy - relative_entropy\n best_split = Attribute.get_name()\n\n print(f\"best split:{best_split} \\n with entropy gain of:\\n {best_gain}\")\n\n return best_split","def _split_morph_attrs(attrs: dict) -> Tuple[dict, dict]:\n other_attrs = {}\n morph_attrs = {}\n for k, v in attrs.items():\n if k in \"_\" or k in IDS.keys() or k in IDS.values():\n other_attrs[k] = v\n else:\n morph_attrs[k] = v\n return other_attrs, morph_attrs","def _split_dataset(self, X, y, label, index, value, sample_weights=None):\n # YOUR CODE HERE\n # Hint: Do not forget to remove the index-th feature from X.\n # begin answer\n ret1=[]\n ret2=[]\n featVec=X[:,index]\n X=X[:,[i for i in range(X.shape[1]) if i!=index ]]\n for i in range(len(featVec)):\n if featVec[i]>=value:\n ret1.append(i)\n else:\n ret2.append(i)\n sub1_X = X[ret1,:]\n sub1_y = y[ret1]\n label_1=label[ret1]\n sub1_sample_weights=sample_weights[ret1]\n sub2_X = X[ret2,:]\n sub2_y = y[ret2]\n label_2=label[ret2]\n sub2_sample_weights=sample_weights[ret2]\n # end answer\n return sub1_X, sub1_y, label_1, sub1_sample_weights, sub2_X, sub2_y, label_2, sub2_sample_weights","def split_by(data_set, question, entropy_before):\r\n yea_set = []\r\n nay_set = []\r\n abstain_set = []\r\n\r\n for data_point in data_set:\r\n vote = data_point.dat_votes[ord(question)-97] #the way this representative voted is the data_point's votes indexed by question\r\n party = data_point.dat_party\r\n\r\n if vote == \"+\":\r\n yea_set.append(data_point)\r\n if vote == \"-\":\r\n nay_set.append(data_point)\r\n if vote == \".\":\r\n abstain_set.append(data_point)\r\n\r\n yea_entropy = abs(calc_entropy(yea_set) * (len(yea_set))/len(data_set))\r\n nay_entropy = abs(calc_entropy(nay_set) * (len(nay_set))/len(data_set))\r\n abstain_entropy = abs(calc_entropy(abstain_set) * (len(abstain_set))/len(data_set))\r\n calc_gain = entropy_before - (yea_entropy + nay_entropy + abstain_entropy)\r\n return (calc_gain,(yea_set, nay_set, abstain_set))","def _split_by_filename(\n df: pd.DataFrame):\n data = namedtuple('data', ['filename', 'object'])\n gb = df.groupby('filename')\n return [data(filename, gb.get_group(x)) for filename, x in zip(gb.groups.keys(), gb.groups)]","def _split(self, split, randomise=False, **kwargs):\r\n # Copy split to prevent modifying outside arguments\r\n split = split.copy()\r\n # Compute total\r\n total = sum(split.values())\r\n # If split contains floats, convert to integers\r\n if isinstance(total, float):\r\n assert_msg = 'Not enough data! ' \\\r\n + f'Split requires a total of {total*100}%. ' \\\r\n + 'Split should not exceed 100%.'\r\n assert total <= 1, assert_msg\r\n # Add 'rest' subset if not all data is used in split\r\n if total < 1:\r\n split['rest'] = 1 - total\r\n split = self._float_split_to_int(split)\r\n total = sum(split.values())\r\n # Create subsets based off integer values\r\n if isinstance(total, int):\r\n assert_msg = 'Not enough data! ' \\\r\n + f'Split requires a total of {total} data entries ' \\\r\n + f'but only {len(self.data)} are available.'\r\n assert total <= len(self.data), assert_msg\r\n # Add 'rest' subset if not all data is used in split\r\n if total < len(self.data):\r\n split['rest'] = len(self.data) - total\r\n # Create subsets\r\n index = 0\r\n for name, length in split.items():\r\n subset_name = f'{self.name}.{name}'\r\n subset_data = self.data[index:index + length]\r\n subset_seed = self.seed\r\n if self.seed is not None:\r\n subset_seed += sum([ord(c) for c in name]) + length\r\n subset = self._make_subset(subset_name,\r\n subset_data,\r\n randomise=randomise,\r\n seed=subset_seed,\r\n **kwargs\r\n )\r\n setattr(self, name, subset)\r\n index += length\r\n # Replace data with references to subsets\r\n self.data = []\r\n for name in split.keys():\r\n self.data.append(getattr(self, name, None))\r\n # Indicate that this is a superset\r\n self.is_superset = True","def split(self, **kwargs):\n if len(kwargs.keys()) != 1:\n raise ValueError(\n \"One keyword argument is required: Key must be a meta_data field.\"\n )\n data = self._data.copy()\n for colname, values in kwargs.items():\n values = [values] if type(values) == str else values\n mask = data[colname].isin(values)\n return self._copy(data[mask]), self._copy(data[~mask])"],"string":"[\n \"def getNewData(self, data, splitIndex, attrVal):\\n newData = []\\n for record in data:\\n if record[splitIndex] == attrVal:\\n newRecord =[]\\n lenRecord = len(record)\\n\\n for i in range(lenRecord):\\n # doesnt include the split attribute\\n if i == splitIndex:\\n continue\\n newRecord.append(record[i])\\n newData.append(newRecord)\\n return newData\",\n \"def split_attrs(s, *a, **kw):\\n return split_attrs(s, *a, **kw)\",\n \"def split(self, X):\",\n \"def splitAttribute(self, atr, divider=0.5):\\n big, lit = DecisionTree(None, self.atr), DecisionTree(None, self.atr)\\n for d in self:\\n if d[atr] > divider: big.append(d)\\n else: lit.append(d)\\n return lit, big\",\n \"def split_features(data):\\n X = data.copy()\\n #split nucleotid string (len=60) into a list of independent characters (DNA nucleotids)\\n X['dna'] = X['dna'].map(lambda x : list(str(x).strip()))\\n #create 60 new attributes (columns) for each DNA nucleotide index\\n #each attribute has name dna_idx where idx is index (1-based) in the list above\\n for idx in range(60):\\n X['dna_%d' % (idx+1)] = X['dna'].map(lambda x : x[idx])\\n #remove the old dna column (redundant information)\\n del X['dna']\\n #remove descriptor\\n del X['id']\\n \\n return X\",\n \"def getSplitAttr(self, data, attributes):\\n splitAttrIndex = 0\\n lengthAttr = len(attributes)\\n del self.infoGain[:]\\n index = 0\\n while index < lengthAttr:\\n self.infoGain.append(self.getInfoGain(data, index))\\n index += 1\\n\\n for gain in self.infoGain:\\n if gain == max(self.infoGain):\\n break\\n splitAttrIndex += 1\\n return splitAttrIndex\",\n \"def extractAttrs(data):\\n\\treturn [instance[1:] for instance in data]\",\n \"def split_by_attribute(dbsession, group, attr):\\n values = []\\n for item in group.items:\\n if attr in item.attributes and item.attributes[attr]:\\n values.extend(item.attributes[attr])\\n categories = [\\n (v, c) for v, c in Counter(values).most_common() if c < len(group.items) * 0.6666 and c >= 15 # noqa: PLR2004\\n ]\\n if categories:\\n category_values = [v for v, _ in categories]\\n has_values = 0\\n for item in group.items:\\n found = False\\n for value in item.attributes[attr]:\\n if value in category_values:\\n found = True\\n break\\n if found:\\n has_values = has_values + 1\\n if has_values / len(group.items) > 0.9: # noqa: PLR2004\\n categories.reverse()\\n for category in categories:\\n new_group = Group(\\n value=category[0], label=f\\\"{group.label} - {category[0]}\\\", parent=group, split=\\\"attribute\\\"\\n )\\n dbsession.add(new_group)\\n for item in list(group.items):\\n if category[0] in item.attributes[attr]:\\n item.group = new_group\\n new_group = Group(value=group.label, label=group.label, parent=group, split=\\\"attribute\\\")\\n dbsession.add(new_group)\\n for item in list(group.items):\\n item.group = new_group\\n return True\\n return False\",\n \"def split_validation_data(*data, divmod=0.5):\\n n = round((len(data[0]) - 1) * divmod)\\n return [(d[n:], d[:n]) for d in data]\",\n \"def partition_instances(instances, split_attribute, attribute_domains):\\n # this is a group by split_attribute's domain, not by\\n # the values of this attribute in instances\\n # example: if split_attribute is \\\"level\\\"\\n attribute_domain = attribute_domains[split_attribute] # [\\\"Senior\\\", \\\"Mid\\\", \\\"Junior\\\"]\\n # Build a dictionary\\n partitions = {} # key (attribute value): value (list of instances with this attribute value)\\n # For loop through attributes in dictionary\\n for attribute_value in attribute_domain:\\n partitions[attribute_value] = []\\n for instance in instances:\\n index = int(split_attribute[3:])\\n if instance[index] == attribute_value:\\n partitions[attribute_value].append(instance)\\n return partitions\",\n \"def split(df, group):\\n\\n data = namedtuple(\\\"data\\\", [\\\"filename\\\", \\\"object\\\"]) #initiate \\\"data\\\" tyoe\\n gb = df.groupby(group) #group df by group attribute\\n return [\\n data(filename, gb.get_group(x))\\n for filename, x in zip(gb.groups.keys(), gb.groups)\\n ]\",\n \"def split_dataset_for_one_attribute(gender_confident_data, attribute='text_cleaned'):\\n\\n # Converting text strings into a matrix of word token counts.\\n cv = CountVectorizer()\\n inputString = cv.fit_transform(gender_confident_data[attribute])\\n\\n # Encodes class labels from 0 to Num_of_classes-1\\n le = LabelEncoder()\\n outputString = le.fit_transform(gender_confident_data['gender'])\\n\\n # Splitting the data such that 66% of the data is assigned as training data and the rest as the test data set.\\n input_train, input_test, output_train, output_test = train_test_split(inputString, outputString, train_size=0.66)\\n\\n return input_train, output_train, input_test, output_test\",\n \"def split(self, attribute):\\n if attribute not in self.attributes:\\n raise KeyError('Attribute not present in node')\\n \\n self.split_attr = attribute\\n \\n # list() is used to make a copy of the list instead of pointing to the same list\\n child_attributes = list(self.attributes)\\n child_attributes.remove(attribute)\\n \\n child1_ancestors = list(self.ancestors)\\n child0_ancestors = list(self.ancestors)\\n child1_ancestors.append(attribute_value(attribute, 1))\\n child0_ancestors.append(attribute_value(attribute, 0))\\n \\n self.val1 = Node(child_attributes, child1_ancestors, self.data, self.heuristic)\\n self.val0 = Node(child_attributes, child0_ancestors, self.data, self.heuristic)\",\n \"def split_X_y(data):\\n return data.drop(columns=\\\"price\\\"), data[\\\"price\\\"]\",\n \"def splitmetric(self, dataset, attr, target_attr):\\n raise NotImplementedError('Subclass should implement this method')\",\n \"def targetFeatureSplit( data ):\\n\\n target = []\\n features = []\\n for item in data:\\n target.append( item[0] )\\n features.append( item[1:] )\\n\\n return target, features\",\n \"def making_dataset_list_val(data:pandas.core.frame.DataFrame, split_num:int) -> list:\\n val_data_list = []\\n for i in range(split_num):\\n val_data_list.append(data[data['separate_num'] == i])\\n for i in range(split_num):\\n val_data_list[i] = val_data_list[i].drop(['separate_num'], axis = 1)\\n return val_data_list\",\n \"def split_data_into_input_and_output(data):\\n data_in, data_out = list(zip(*[((x[\\\"synopsis\\\"]), x[\\\"gross\\\"]) for x in data]))\\n return np.array(data_in), np.array(data_out)\",\n \"def csv_attribute_unpacker(self, attribute_tuples: List[Tuple[str, str]], separator: str = \\\",\\\") \\\\\\n -> Tuple[List[str], List[str]]:\\n\\n if not attribute_tuples:\\n raise ValueError(\\\"The list of tuples containing the attributes is missing.\\\")\\n\\n join_attributes_set: set = set()\\n selection_attributes_set: set = set()\\n\\n for j_attribute_string, s_attribute_string in attribute_tuples:\\n for j_attribute in j_attribute_string.split(separator):\\n join_attributes_set.add(j_attribute.strip())\\n\\n for operator in self.operators:\\n s_attribute_string = s_attribute_string.replace(separator + operator + separator, operator)\\n\\n for s_attribute in s_attribute_string.split(separator):\\n for operator in self.operators:\\n if operator in s_attribute:\\n s_attribute = s_attribute.split(operator)[0].strip()\\n selection_attributes_set.add(s_attribute)\\n break\\n\\n return list(join_attributes_set), list(selection_attributes_set)\",\n \"def partition_by(inputs, attribute):\\n groups = defaultdict(list)\\n for input in inputs:\\n key = input[0][attribute] # get the value of the specified attribute\\n groups[key].append(input) # then add this input to the correct list\\n return groups\",\n \"def split(input, output, fields, delimiter, encoding, verbose, format_in, zipfile, gzipfile, chunksize, filter):\\n if verbose:\\n enableVerbose()\\n options = {}\\n options['delimiter'] = delimiter\\n options['fields'] = fields\\n options['output'] = output\\n options['encoding'] = encoding\\n options['format_in'] = format_in\\n options['zipfile'] = zipfile\\n options['gzipfile'] = gzipfile\\n options['chunksize'] = chunksize\\n options['filter'] = filter\\n acmd = Selector()\\n acmd.split(input, options)\\n pass\",\n \"def splitmetric(self, dataset, attr, target_attr):\\n freq = {}\\n splitinfo = 0.0\\n \\n #Call information gain\\n gain = ID3.splitmetric(self, dataset, attr, target_attr);\\n samplenumbers = len(dataset)\\n # Calculate the frequency of each of the values in the split attribute\\n for record in dataset:\\n if (record[attr] in freq):\\n freq[record[attr]] += 1.0\\n else:\\n freq[record[attr]] = 1.0\\n \\n #Calculate split info, entropy of splitter\\n for val in list(freq.values()):\\n splitinfo += (- val / samplenumbers) * math.log(val / samplenumbers, 2)\\n \\n #Split info equals 0 when there only one class in data set\\n if splitinfo == 0:\\n splitinfo = 0.00000001\\n \\n return gain / splitinfo\",\n \"def split_trips(data, fields):\\n #todo: use two list comprehensions\\n split = []\\n for row in data:\\n new_row = {\\n \\\"type\\\": \\\"start\\\",\\n \\\"x\\\": row[fields[\\\"trip_start_x_field\\\"]],\\n \\\"y\\\": row[fields[\\\"trip_start_y_field\\\"]],\\n }\\n\\n new_row.update(**row)\\n\\n split.append(new_row)\\n\\n new_row = {\\n \\\"type\\\": \\\"end\\\",\\n fields[\\\"trip_id_field\\\"]: row[fields[\\\"trip_id_field\\\"]],\\n \\\"x\\\": row[fields[\\\"trip_end_x_field\\\"]],\\n \\\"y\\\": row[fields[\\\"trip_end_y_field\\\"]],\\n }\\n\\n new_row.update(**row)\\n\\n split.append(new_row)\\n\\n return split\",\n \"def get_possible_splits( df , attribute ):\\n ds = df.loc[:,attribute]\\n \\n # First sort the values \\n ds = ds.sort_values().drop_duplicates()\\n \\n # Compute averages of consecutive values \\n ds = ds.rolling(2).sum().divide(2)\\n splits = ds[1:].tolist()\\n \\n # return the possible splits \\n return splits\",\n \"def extract(self, data):\",\n \"def split_dict_into_options_fontattrs_and_case(*a, **kw):\\n return split_dict_into_options_fontattrs_and_case(*a, **kw)\",\n \"def split_data(self, model_data, tuning=True):\\n pass\",\n \"def _select_attributes(self, item_data):\\r\\n return item_data\",\n \"def split_data(name, is_train = True):\\r\\n data = pd.read_csv(name, header = 0, encoding = 'ISO-8859-1')\\r\\n X = data['text']\\r\\n if is_train:\\r\\n Y = data['polarity']\\r\\n return X, Y\\r\\n return X\",\n \"def seperateDataCompany(data):\\n assert isinstance(data, dict)\\n dictionary = dict(data)\\n tmp = dictionary.pop('University of California, San Diego - Jacobs School of Engineering')\\n dictionary['University of California San Diego'] += tmp\\n tmp = dictionary.pop('Amazon Web Services (AWS)')\\n dictionary['Amazon'] += tmp\\n \\n keys = list(dictionary.keys())\\n values = list(dictionary.values()) \\n return (keys), (values)\",\n \"def _split_proxy_info(data: str) -> list:\\n \\n country = data[:2]\\n anonymity = data[3:4]\\n type_ = data[4:].strip('-+ ') # Remove splitting (- and space) and google_passed flag (+)\\n google_passed = data[-1]\\n\\n return [country, anonymity, type_, google_passed]\",\n \"def split_data(x, weight = 0.9):\\n offset = int(len(x) * weight)\\n return x[:offset], x[offset:]\",\n \"def partition_by(inputs, attribute):\\n groups = defaultdict(list)\\n for input in inputs:\\n key = input[0][attribute]\\n groups[key].append(input)\\n return groups\",\n \"def get_attribut(cls, attribut):\\n\\n if attribut:\\n lst_attribut = [\\\"%s\\\" % value for value in attribut.split(',')]\\n return lst_attribut\\n return False\",\n \"def _split_model_kwargs_association(self, data):\\n association_attrs = {\\n key: value\\n for key, value in iteritems(data)\\n # association proxy\\n if hasattr(getattr(self.opts.model, key, None), \\\"remote_attr\\\")\\n }\\n kwargs = {\\n key: value\\n for key, value in iteritems(data)\\n if (hasattr(self.opts.model, key) and key not in association_attrs)\\n }\\n return kwargs, association_attrs\",\n \"def _split_makeotf_options(comma_str):\\n if not comma_str.startswith('-'):\\n comma_str = '-' + comma_str\\n return comma_str.split(',')\",\n \"def split(self,\\n allow_nonseq_value: bool = False) -> Sequence['DataSample']:\\n # 1. split\\n data_sample_list = [DataSample() for _ in range(len(self))]\\n for k in self.all_keys():\\n stacked_value = self.get(k)\\n if isinstance(stacked_value, torch.Tensor):\\n # split tensor shape like (N, *shape) to N (*shape) tensors\\n values = [v for v in stacked_value]\\n elif isinstance(stacked_value, LabelData):\\n # split tensor shape like (N, *shape) to N (*shape) tensors\\n labels = [l_ for l_ in stacked_value.label]\\n values = [LabelData(label=l_) for l_ in labels]\\n elif isinstance(stacked_value, DataSample):\\n values = stacked_value.split()\\n else:\\n if is_splitable_var(stacked_value):\\n values = stacked_value\\n elif allow_nonseq_value:\\n values = [deepcopy(stacked_value)] * len(self)\\n else:\\n raise TypeError(\\n f'\\\\'{k}\\\\' is non-sequential data and '\\n '\\\\'allow_nonseq_value\\\\' is False. Please check your '\\n 'data sample or set \\\\'allow_nonseq_value\\\\' as True '\\n f'to copy field \\\\'{k}\\\\' for all split data sample.')\\n\\n field = 'metainfo' if k in self.metainfo_keys() else 'data'\\n for data, v in zip(data_sample_list, values):\\n data.set_field(v, k, field_type=field)\\n\\n return data_sample_list\",\n \"def split_model_attr_lookups(self):\\n return self.model_attr.split(\\\"__\\\")\",\n \"def split_dataset(dataset):\\n sequence = dataset.split()\\n return sequence\",\n \"def split_dataset(dataset):\\n sequence = dataset.split()\\n return sequence\",\n \"def splits(cls, exts, fields, root='/Users/yingliu/PycharmProjects/Seq2SeqSemantic/data/',\\n train='train2', validation='val2', test='test2', **kwargs):\\n return super(SPDataset, cls).splits(\\n exts, fields, path=root,\\n train = train, validation = validation, test = test, **kwargs)\",\n \"def split_data(df, split_method='fo', test_size=.2, random_state=42):\\n if split_method == 'fo':\\n train_set, test_set = _split_fo(df,\\n test_size=test_size,\\n random_state=random_state)\\n elif split_method == 'tfo':\\n train_set, test_set = _split_tfo(df, test_size=test_size)\\n elif split_method == 'ufo':\\n train_set, test_set = _split_ufo(df,\\n test_size=test_size,\\n random_state=random_state)\\n elif split_method == 'utfo':\\n train_set, test_set = _split_utfo(df, test_size=test_size)\\n else:\\n raise HuitreError('Invalid data_split value, expect: ufo, utfo')\\n train_set = train_set.reset_index(drop=True)\\n test_set = test_set.reset_index(drop=True)\\n return train_set, test_set\",\n \"def extract_data(line):\\n tmp = line.split('=',1)[1]\\n tmp = tmp.split('data = ')[1:]\\n tmp = [x.split('}') for x in tmp]\\n tmp = [x[0] for x in tmp]\\n tmp = [x.lstrip('{') for x in tmp]\\n return tmp\",\n \"def extract(obj, splitter='<!--more-->'): \\n return obj.split(splitter)\",\n \"def map_csv_attributes(self, attributes: List[tuple]):\\n woocommerce_attributes, _ = self._api.get_all_attributes()\\n api_attributes = []\\n for index, attrs in enumerate(attributes):\\n woo_attr = next((x for x in woocommerce_attributes if x[\\\"name\\\"] == attrs[0]), None)\\n woo_attr_id = 0\\n woo_attr_name = attrs[0]\\n if woo_attr:\\n woo_attr_id = woo_attr[\\\"id\\\"]\\n woo_attr_name = woo_attr[\\\"name\\\"]\\n api_attributes.append({\\n \\\"id\\\": woo_attr_id,\\n \\\"name\\\": woo_attr_name,\\n \\\"position\\\": index,\\n \\\"visible\\\": True,\\n \\\"options\\\": [attrs[1]]\\n })\\n return api_attributes\",\n \"def split(a):\\r\\n compos = [-1] # compos stores the positions of the relevant commas in the argument string\\r\\n compos.extend(t[2][1] for t in generate_tokens(StringIO(a).readline) if t[1] == ',')\\r\\n compos.append(len(a))\\r\\n return [ a[compos[i]+1:compos[i+1]] for i in xrange(len(compos)-1)]\",\n \"def splitXY(self, df = None):\\n df = df if isinstance(df, pd.DataFrame) else self.df # <-- default\\n return tuple(df.filter(regex = self.regex[k])\\n for k in ('features', 'targets'))\",\n \"def split_data(paragraphs):\\n para_count = len(paragraphs)\\n training_index = int(para_count * 0.7)\\n validation_index = int(para_count * 0.9)\\n training_data = paragraphs[:training_index]\\n validation_data = paragraphs[training_index:validation_index]\\n test_data = paragraphs[validation_index:]\\n return training_data, validation_data, test_data\",\n \"def prepare_data(self, lines: List[str]) -> List[str]:\\n if self.is_tokenized:\\n if self.parser == \\\"spacy\\\":\\n lines = [l.split() for l in lines]\\n elif self.parser == \\\"udpipe\\\":\\n lines = [[l.split()] for l in lines]\\n\\n return lines\",\n \"def getSplit(self):\\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\\n for j in range(len(self[0]) - 1):\\n for i in range(len(self)):\\n groups = self.splitAttribute(j, self[i][j]) # lit, big\\n gini = self.giniIndex(groups)\\n if gini < b_score and (j, \\\"%.1f\\\" % self[i][j]) not in self.atr:\\n b_index, b_value, b_score, b_groups = j, self[i][\\n j], gini, groups\\n return b_index, b_value, b_groups, b_score\",\n \"def extract_opt(options, optname):\\n extracted = []\\n remaining = []\\n for o, v in options:\\n if o == optname:\\n extracted.append((o, v))\\n else:\\n remaining.append((o, v))\\n return extracted, remaining\",\n \"def parse_groups(data):\\n for k, g in itertools.groupby((line.strip() for line in data), bool):\\n if k:\\n yield list(g)\",\n \"def seperateData(data):\\n assert isinstance(data, dict)\\n dictionary = dict(data)\\n keys = dictionary.keys()\\n values = dictionary.values()\\n return list(keys), list(values)\",\n \"def make_split_data(read_data):\\n split_data = re.split('[,|\\\\.|\\\\-|\\\\*|\\\\[|\\\\]|\\\\#|\\\\:|\\\\;|(\\\\|)|\\\\\\\"|\\\\'|!|\\\\s]+',read_data)\\n\\n if split_data[-1] == '':\\n del split_data[-1]\\n\\n return split_data\",\n \"def making_dataset_list_train(data:pandas.core.frame.DataFrame, split_num:int) -> list:\\n train_data_list = []\\n for i in range(split_num):\\n train_data_list.append(data[data['separate_num'] != i])\\n for i in range(split_num):\\n train_data_list[i] = train_data_list[i].drop(['separate_num'], axis = 1)\\n return train_data_list\",\n \"def splits(cls, **kwargs):\\n kwargs_copy = {x: y for x, y in kwargs.items()}\\n if 'mode' not in kwargs:\\n kwargs_copy['mode'] = 'answer'\\n train = cls(split='train', **kwargs_copy)\\n val = cls(split='val', **kwargs_copy)\\n # test = cls(split='test', **kwargs_copy)\\n return train, val\",\n \"def split(data):\\n return data[:len(data) // 2], data[len(data) // 2:]\",\n \"def split_data_set_splitted(X, Y):\\n\\n # Uso la funcion de scikitlearn para separar el data_set\\n # Esta funcion por defecto mezcla los datos para asegurar la representacion\\n # de los datos en los dos subconjuntos\\n #\\n # Blanca Cano Camarero me comenta que ponga el stratify = Y porque asi se lo\\n # indica el profesor Pablo Mesejo en una consulta realizada. En la referencia\\n # que indico de scikitlearn tambien viene documentado este parametro\\n # Lo que hace es evitar que haya clases que queden infrarepresentadas\\n X_training, X_test, Y_training, Y_test= train_test_split(X, Y, train_size = 0.75, test_size = 0.25, stratify = Y)\\n return X_training, X_test, Y_training, Y_test\",\n \"def splitData(df, split):\\n train = df.iloc[:int(len(df)*split)]\\n test = df.iloc[int(len(df)*split):]\\n \\n return train, test\",\n \"def split_data(data,param):\\n all_x = data[['GDP_scaled','CLPRB_scaled','EMFDB_scaled','ENPRP_scaled','NGMPB_scaled','PAPRB_scaled','PCP_scaled','ZNDX_scaled','OP_scaled', 'OP2_scaled']][:55]\\n all_y = data[[param]][:55]\\n return cross_validation.train_test_split(all_x, all_y, test_size=0.2, random_state=0)\",\n \"def delimiter_split(\\n line: Line, features: Collection[Feature], mode: Mode\\n) -> Iterator[Line]:\\n try:\\n last_leaf = line.leaves[-1]\\n except IndexError:\\n raise CannotSplit(\\\"Line empty\\\") from None\\n\\n bt = line.bracket_tracker\\n try:\\n delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)})\\n except ValueError:\\n raise CannotSplit(\\\"No delimiters found\\\") from None\\n\\n if delimiter_priority == DOT_PRIORITY:\\n if bt.delimiter_count_with_priority(delimiter_priority) == 1:\\n raise CannotSplit(\\\"Splitting a single attribute from its owner looks wrong\\\")\\n\\n current_line = Line(\\n mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets\\n )\\n lowest_depth = sys.maxsize\\n trailing_comma_safe = True\\n\\n def append_to_line(leaf: Leaf) -> Iterator[Line]:\\n \\\"\\\"\\\"Append `leaf` to current line or to new line if appending impossible.\\\"\\\"\\\"\\n nonlocal current_line\\n try:\\n current_line.append_safe(leaf, preformatted=True)\\n except ValueError:\\n yield current_line\\n\\n current_line = Line(\\n mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets\\n )\\n current_line.append(leaf)\\n\\n last_non_comment_leaf = _get_last_non_comment_leaf(line)\\n for leaf_idx, leaf in enumerate(line.leaves):\\n yield from append_to_line(leaf)\\n\\n for comment_after in line.comments_after(leaf):\\n yield from append_to_line(comment_after)\\n\\n lowest_depth = min(lowest_depth, leaf.bracket_depth)\\n if leaf.bracket_depth == lowest_depth:\\n if is_vararg(leaf, within={syms.typedargslist}):\\n trailing_comma_safe = (\\n trailing_comma_safe and Feature.TRAILING_COMMA_IN_DEF in features\\n )\\n elif is_vararg(leaf, within={syms.arglist, syms.argument}):\\n trailing_comma_safe = (\\n trailing_comma_safe and Feature.TRAILING_COMMA_IN_CALL in features\\n )\\n\\n if (\\n Preview.add_trailing_comma_consistently in mode\\n and last_leaf.type == STANDALONE_COMMENT\\n and leaf_idx == last_non_comment_leaf\\n ):\\n current_line = _safe_add_trailing_comma(\\n trailing_comma_safe, delimiter_priority, current_line\\n )\\n\\n leaf_priority = bt.delimiters.get(id(leaf))\\n if leaf_priority == delimiter_priority:\\n yield current_line\\n\\n current_line = Line(\\n mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets\\n )\\n if current_line:\\n current_line = _safe_add_trailing_comma(\\n trailing_comma_safe, delimiter_priority, current_line\\n )\\n yield current_line\",\n \"def split(items):\\n return {\\n \\\"class\\\": \\\"split\\\",\\n \\\"items\\\": items\\n }\",\n \"def split_data(dataset, ratio = 0.9):\\n cutoff_row = int(dataset.shape[0] * ratio)\\n return (dataset[:cutoff_row], dataset[cutoff_row:])\",\n \"def optgroups(self, name, value, attrs=None):\\n options = []\\n\\n for index, (name, product_data) in enumerate(self.product_fields.items()):\\n quantity = product_data['quantity']\\n name = product_data['name']\\n price = product_data['price']\\n if index:\\n label = 'product_{}'.format(str(index))\\n else:\\n label = 'product'\\n\\n options.append({\\n 'value': quantity,\\n 'price': price,\\n 'name': 'products',\\n 'label': name,\\n 'type': self.input_type,\\n 'template_name': self.option_template_name,\\n 'wrap_label': True,\\n 'index': index\\n })\\n\\n return options\",\n \"def generate_splits( records, index ):\\n splits = []\\n is_numerical = feature_is_numerical( records, index )\\n if is_numerical:\\n splits = generate_numerical_splits( records, index )\\n else:\\n splits = generate_category_splits( records, index )\\n\\n return splits\",\n \"def split_dev_data(input_data: List[Tuple[str, int]]) -> Tuple[List[Tuple[str, int]],\\n List[Tuple[str, int]],\\n List[Tuple[str, int]]]:\\n training_data, test_data = split_data(input_data)\\n\\n # split test data in half to test on\\n dev_data = set(random.sample(test_data, int(len(test_data) / 2)))\\n test_data = set(test_data) - set(dev_data)\\n\\n return list(training_data), list(test_data), list(test_data)\",\n \"def split_chunk(chunk, *a, **kw):\\n return split_chunk(chunk, *a, **kw)\",\n \"def getcsv(self, section, option):\\n elements = self.get(section, option)\\n splitter = ',' if ',' in elements else None\\n return [element.strip() for element in elements.split(splitter)]\",\n \"def split(iterator, criterion):\\n a = []\\n b = []\\n for x in iterator:\\n if criterion(x):\\n a.append(x)\\n else:\\n b.append(x)\\n\\n return a, b\",\n \"def explode(self, header_attribute='header', value_attribute='value'):\\n\\n import hxl.filters\\n return hxl.filters.ExplodeFilter(self, header_attribute, value_attribute)\",\n \"def separate_by(self, *criteria):\\n def is_a(seq): return all(c(seq) for c in criteria)\\n \\n def op_separate(s):\\n if s is None: return None, None\\n return [s for s in s if is_a(s)], [s for s in s if not is_a(s)]\\n tuple_array = self.element_wise(op_separate)\\n\\n return tuple_array.element_wise(lambda x: x[0]), tuple_array.element_wise(lambda x: x[1])\",\n \"def preprocess_split(self, input_dataset, last_id, num_sents, max_sent_len, prefix_id = \\\"\\\"):\\n dataset = []\\n for sent in input_dataset[last_id:]:\\n last_id += 1\\n if type(sent) == tuple or len(sent) > max_sent_len or len(sent) <= 1:\\n continue\\n dataset.append(self.preprocess_sent(sent, prefix_id + str(len(dataset))))\\n if len(dataset) == num_sents:\\n break\\n\\n return dataset, last_id\",\n \"def addSplit(self):\\n pass\",\n \"def split_data(data, feature, split_point):\\n data_l = data[data[:, feature - 1] < split_point]\\n data_r = data[data[:, feature - 1] >= split_point]\\n\\n return data_l, data_r\",\n \"def applyAttrs(data, attrs):\\n\\tassert(len(data[0]) == len(attrs) + 1)\\n\\tnum_attrs = len(attrs)\\n\\tnum_instances = len(data)\\n\\n\\tout = [None] * len(data)\\n\\tfor row in range(num_instances):\\n\\t\\tinstance = data[row]\\n\\t\\tout[row] = [instance[0]] + ['?' if instance[i+1] == '?' else attrs[i]['vals'][int(instance[i+1])] for i in range(num_attrs)]\\n\\n\\treturn out\",\n \"def split_data(X, scaling, ids, y, split_ratio=0.2):\\r\\n split = int(X.shape[0] * split_ratio) # index must be int\\r\\n X_test = X[:split, :, :, :]\\r\\n scaling_test = scaling[:split, :]\\r\\n ids_test = ids[:split]\\r\\n y_test = y[:split, :]\\r\\n X_train = X[split:, :, :, :]\\r\\n scaling_train = scaling[split:, :]\\r\\n ids_train = y[split:]\\r\\n y_train = y[split:, :]\\r\\n\\r\\n return X_train, scaling_train, ids_train, y_train, X_test, scaling_test, ids_test, y_test\",\n \"def split_data(self):\\n if self.seper == \\\"whitespace\\\":\\n seperstring = \\\" \\\"\\n elif self.seper == \\\"comma\\\":\\n seperstring = \\\",\\\"\\n elif self.seper == \\\"tab\\\":\\n seperstring = \\\"\\\\t\\\"\\n else:\\n print self.seper + \\\"is not a supported delimiter. Only whitespace, comma, and tab are accepted.\\\"\\n sys.exit()\\n f = open(self.filelocation, \\\"rb\\\")\\n temp = list()\\n for line in f.readlines():\\n temp.append(line.replace(\\\"\\\\n\\\", \\\"\\\").split(seperstring))\\n f.close()\\n data = dict()\\n count = 0\\n for row in temp:\\n data[count] = list()\\n for each in row:\\n if each is not \\\"\\\":\\n data[count].append(each)\\n count += 1\\n return data, count\",\n \"def get_subset_split(annotation_data):\\r\\n\\r\\n # Get the audio filenames and the splits without duplicates\\r\\n data = annotation_data[['split', 'audio_filename', 'annotator_id']]\\\\\\r\\n .groupby(by=['split', 'audio_filename'], as_index=False)\\\\\\r\\n .min()\\\\\\r\\n .sort_values('audio_filename')\\r\\n\\r\\n train_idxs = []\\r\\n valid_idxs = []\\r\\n\\r\\n for idx, (_, row) in enumerate(data.iterrows()):\\r\\n if row['split'] == 'train':\\r\\n train_idxs.append(idx)\\r\\n elif row['split'] == 'validate' :\\r\\n # For validation examples, only use verified annotations\\r\\n valid_idxs.append(idx)\\r\\n\\r\\n return np.array(train_idxs), np.array(valid_idxs)\",\n \"def splitData(data, class_label, seed, ratio):\\n\\t\\n\\trandom.seed(seed)\\n\\tsubset = data.clone()\\n\\tsize_data = subset.data.shape[0]\\n\\tn = int(np.floor(size_data * ratio)) # number of datasets in train\\n\\tindex = random.sample(range(1, size_data), n)\\n\\tsplit_list = [item for item in [0] for i in range(size_data)]\\n\\t\\n\\tfor i in index:\\n\\t\\tsplit_list[i]=1\\n\\t\\n\\treturn split_list #returns list of indeces where 0 is test and 1 is training data \",\n \"def split_data(data, labels, proportion):\\n size = data.shape[0]\\n np.random.seed(42)\\n s = np.random.permutation(size)\\n split_idx = int(proportion * size)\\n return (data[s[:split_idx]], data[s[split_idx:]], labels[s[:split_idx]], labels[s[split_idx:]])\",\n \"def split_data(basedir, data_split=0.80):\\n manip = data_manipulator(basedir)\\n manip.train_test_split(data_split=data_split)\",\n \"def _parse_groupped_data(self):\\n for i, val in enumerate(self.values.keys()):\\n xy = self.values[val]\\n self._set_and_get(\\\"x_\\\", val, xy[:, 0])\\n self._set_and_get(\\\"y_\\\", val, xy[:, 1])\",\n \"def parse_csv_option(option):\\n if option:\\n return option.split(',')\\n else:\\n return []\",\n \"def parse_csv_option(option):\\n if option:\\n return option.split(',')\\n else:\\n return []\",\n \"def parse_dataset(self, data):\\n pass\",\n \"def extract_values(self, data):\\n result = []\\n for i in data:\\n if(len(i) < 2):\\n raise ValueError(\\\"Length of input list is less than 2!\\\")\\n result.append(i[1])\\n return result\",\n \"def split(self, x):\\r\\n new_beams = np.array([])\\r\\n for bar in self.bar_elements:\\r\\n new_beams = np.concatenate((new_beams, bar.split(x)))\\r\\n return BeamElements(new_beams)\",\n \"def filter_attributes(self, data):\\n self._attributes = {\\n \\\"Yesterday\\\": data[\\\"-1\\\"][self._unit][\\\"Scale\\\"],\\n \\\"Tomorrow\\\": data[\\\"1\\\"][self._unit][\\\"Scale\\\"],\\n \\\"Day after tomorrow\\\": data[\\\"2\\\"][self._unit][\\\"Scale\\\"],\\n \\\"In three days\\\": data[\\\"3\\\"][self._unit][\\\"Scale\\\"]\\n }\",\n \"def _find_options(self, inputfield):\\r\\n elements = inputfield.findall('./options/option')\\r\\n return [{\\r\\n 'id': index,\\r\\n 'description': option.text,\\r\\n 'choice': option.get('choice')\\r\\n } for (index, option) in enumerate(elements)]\",\n \"def split_on_sensitive_attribute(X, y, S):\\n\\n\\tidx_pos = np.where(X[S] == 1)[0]\\n\\tX_pos, y_pos = X.iloc[idx_pos], y[idx_pos]\\n\\tX_neg, y_neg = X.drop(X.index[idx_pos]), np.delete(y, idx_pos)\\n\\n\\treturn(X_pos, y_pos, X_neg, y_neg)\",\n \"def split_records(data, delimiter=r\\\"\\\\r\\\\n\\\"):\\n # https://stackoverflow.com/a/2787979\\n return re.split(delimiter + \\\"\\\"\\\"(?=(?:[^'\\\"]|'[^']*'|\\\"[^\\\"]*\\\")*$)\\\"\\\"\\\", data)\",\n \"def split_name_values(param_items):\\n return_list = list()\\n for single_item in param_items:\\n temp_list = [single_item[1]]\\n temp_list.extend(clear_useless_end(single_item[2]).split(\\\",\\\"))\\n return_list.append(temp_list)\\n\\n return return_list\",\n \"def split_words(self,data=[None]):\\r\\n content=[]\\r\\n self.data=data\\r\\n for i in data:\\r\\n liste=list(i)\\r\\n content.append(liste)\\r\\n return content\",\n \"def best_split(self):\\n sub_group = []\\n\\n current_entropy = self.entropy(self._Passengers)\\n best_gain = 0 # holds the best entropy difference so far\\n best_split = self._Attr[0].get_name()\\n relative_entropy = 0 # entropy while taking account for the size of the population\\n\\n for Attribute in self._Attr:\\n relative_entropy = 0\\n print(\\\"Attr considered: \\\" + Attribute.get_name())\\n for Attr_option in Attribute.get_options():\\n sub_group = []\\n for Passenger in self._Passengers:\\n if self.passenger_attr_option_check(Passenger,\\n Attribute.get_name(),\\n Attr_option): # if P.A = V\\n sub_group.append(Passenger)\\n if len(sub_group) > 0 and len(self._Passengers) > 0:\\n relative_entropy += self.entropy(sub_group) * (len(sub_group)/len(self._Passengers))\\n\\n if current_entropy - relative_entropy > best_gain:\\n best_gain = current_entropy - relative_entropy\\n best_split = Attribute.get_name()\\n\\n print(f\\\"best split:{best_split} \\\\n with entropy gain of:\\\\n {best_gain}\\\")\\n\\n return best_split\",\n \"def _split_morph_attrs(attrs: dict) -> Tuple[dict, dict]:\\n other_attrs = {}\\n morph_attrs = {}\\n for k, v in attrs.items():\\n if k in \\\"_\\\" or k in IDS.keys() or k in IDS.values():\\n other_attrs[k] = v\\n else:\\n morph_attrs[k] = v\\n return other_attrs, morph_attrs\",\n \"def _split_dataset(self, X, y, label, index, value, sample_weights=None):\\n # YOUR CODE HERE\\n # Hint: Do not forget to remove the index-th feature from X.\\n # begin answer\\n ret1=[]\\n ret2=[]\\n featVec=X[:,index]\\n X=X[:,[i for i in range(X.shape[1]) if i!=index ]]\\n for i in range(len(featVec)):\\n if featVec[i]>=value:\\n ret1.append(i)\\n else:\\n ret2.append(i)\\n sub1_X = X[ret1,:]\\n sub1_y = y[ret1]\\n label_1=label[ret1]\\n sub1_sample_weights=sample_weights[ret1]\\n sub2_X = X[ret2,:]\\n sub2_y = y[ret2]\\n label_2=label[ret2]\\n sub2_sample_weights=sample_weights[ret2]\\n # end answer\\n return sub1_X, sub1_y, label_1, sub1_sample_weights, sub2_X, sub2_y, label_2, sub2_sample_weights\",\n \"def split_by(data_set, question, entropy_before):\\r\\n yea_set = []\\r\\n nay_set = []\\r\\n abstain_set = []\\r\\n\\r\\n for data_point in data_set:\\r\\n vote = data_point.dat_votes[ord(question)-97] #the way this representative voted is the data_point's votes indexed by question\\r\\n party = data_point.dat_party\\r\\n\\r\\n if vote == \\\"+\\\":\\r\\n yea_set.append(data_point)\\r\\n if vote == \\\"-\\\":\\r\\n nay_set.append(data_point)\\r\\n if vote == \\\".\\\":\\r\\n abstain_set.append(data_point)\\r\\n\\r\\n yea_entropy = abs(calc_entropy(yea_set) * (len(yea_set))/len(data_set))\\r\\n nay_entropy = abs(calc_entropy(nay_set) * (len(nay_set))/len(data_set))\\r\\n abstain_entropy = abs(calc_entropy(abstain_set) * (len(abstain_set))/len(data_set))\\r\\n calc_gain = entropy_before - (yea_entropy + nay_entropy + abstain_entropy)\\r\\n return (calc_gain,(yea_set, nay_set, abstain_set))\",\n \"def _split_by_filename(\\n df: pd.DataFrame):\\n data = namedtuple('data', ['filename', 'object'])\\n gb = df.groupby('filename')\\n return [data(filename, gb.get_group(x)) for filename, x in zip(gb.groups.keys(), gb.groups)]\",\n \"def _split(self, split, randomise=False, **kwargs):\\r\\n # Copy split to prevent modifying outside arguments\\r\\n split = split.copy()\\r\\n # Compute total\\r\\n total = sum(split.values())\\r\\n # If split contains floats, convert to integers\\r\\n if isinstance(total, float):\\r\\n assert_msg = 'Not enough data! ' \\\\\\r\\n + f'Split requires a total of {total*100}%. ' \\\\\\r\\n + 'Split should not exceed 100%.'\\r\\n assert total <= 1, assert_msg\\r\\n # Add 'rest' subset if not all data is used in split\\r\\n if total < 1:\\r\\n split['rest'] = 1 - total\\r\\n split = self._float_split_to_int(split)\\r\\n total = sum(split.values())\\r\\n # Create subsets based off integer values\\r\\n if isinstance(total, int):\\r\\n assert_msg = 'Not enough data! ' \\\\\\r\\n + f'Split requires a total of {total} data entries ' \\\\\\r\\n + f'but only {len(self.data)} are available.'\\r\\n assert total <= len(self.data), assert_msg\\r\\n # Add 'rest' subset if not all data is used in split\\r\\n if total < len(self.data):\\r\\n split['rest'] = len(self.data) - total\\r\\n # Create subsets\\r\\n index = 0\\r\\n for name, length in split.items():\\r\\n subset_name = f'{self.name}.{name}'\\r\\n subset_data = self.data[index:index + length]\\r\\n subset_seed = self.seed\\r\\n if self.seed is not None:\\r\\n subset_seed += sum([ord(c) for c in name]) + length\\r\\n subset = self._make_subset(subset_name,\\r\\n subset_data,\\r\\n randomise=randomise,\\r\\n seed=subset_seed,\\r\\n **kwargs\\r\\n )\\r\\n setattr(self, name, subset)\\r\\n index += length\\r\\n # Replace data with references to subsets\\r\\n self.data = []\\r\\n for name in split.keys():\\r\\n self.data.append(getattr(self, name, None))\\r\\n # Indicate that this is a superset\\r\\n self.is_superset = True\",\n \"def split(self, **kwargs):\\n if len(kwargs.keys()) != 1:\\n raise ValueError(\\n \\\"One keyword argument is required: Key must be a meta_data field.\\\"\\n )\\n data = self._data.copy()\\n for colname, values in kwargs.items():\\n values = [values] if type(values) == str else values\\n mask = data[colname].isin(values)\\n return self._copy(data[mask]), self._copy(data[~mask])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5996887","0.5792106","0.5760196","0.575071","0.57116055","0.5524944","0.55180806","0.55036134","0.5439692","0.542324","0.54069096","0.53839254","0.5351785","0.5330941","0.53060323","0.51633775","0.51120734","0.50981104","0.5087688","0.50799423","0.50781137","0.5071375","0.5056163","0.5052915","0.504714","0.50282884","0.50264055","0.5019826","0.50170124","0.50037533","0.49784884","0.49505687","0.4948199","0.4946973","0.49344036","0.49314803","0.4929073","0.48851046","0.4883505","0.4883505","0.4877765","0.48646295","0.4856964","0.4846911","0.48395878","0.48367402","0.48314124","0.48313504","0.4831193","0.48304638","0.48188335","0.4801035","0.47959763","0.479357","0.4792228","0.47895685","0.47677237","0.4756676","0.47543365","0.47511947","0.474501","0.47435045","0.47351968","0.47303635","0.4728081","0.4720744","0.47161886","0.4712622","0.47108647","0.47031394","0.4702606","0.47021928","0.4696417","0.46930414","0.4688835","0.46798202","0.4674762","0.46730122","0.4671944","0.46708053","0.46706784","0.46611407","0.4659484","0.4659484","0.46572208","0.4651226","0.46351737","0.4634824","0.46316117","0.46291816","0.46133518","0.46116164","0.46116072","0.46097487","0.46085066","0.4599631","0.45993984","0.45908275","0.45907262","0.45879102"],"string":"[\n \"0.5996887\",\n \"0.5792106\",\n \"0.5760196\",\n \"0.575071\",\n \"0.57116055\",\n \"0.5524944\",\n \"0.55180806\",\n \"0.55036134\",\n \"0.5439692\",\n \"0.542324\",\n \"0.54069096\",\n \"0.53839254\",\n \"0.5351785\",\n \"0.5330941\",\n \"0.53060323\",\n \"0.51633775\",\n \"0.51120734\",\n \"0.50981104\",\n \"0.5087688\",\n \"0.50799423\",\n \"0.50781137\",\n \"0.5071375\",\n \"0.5056163\",\n \"0.5052915\",\n \"0.504714\",\n \"0.50282884\",\n \"0.50264055\",\n \"0.5019826\",\n \"0.50170124\",\n \"0.50037533\",\n \"0.49784884\",\n \"0.49505687\",\n \"0.4948199\",\n \"0.4946973\",\n \"0.49344036\",\n \"0.49314803\",\n \"0.4929073\",\n \"0.48851046\",\n \"0.4883505\",\n \"0.4883505\",\n \"0.4877765\",\n \"0.48646295\",\n \"0.4856964\",\n \"0.4846911\",\n \"0.48395878\",\n \"0.48367402\",\n \"0.48314124\",\n \"0.48313504\",\n \"0.4831193\",\n \"0.48304638\",\n \"0.48188335\",\n \"0.4801035\",\n \"0.47959763\",\n \"0.479357\",\n \"0.4792228\",\n \"0.47895685\",\n \"0.47677237\",\n \"0.4756676\",\n \"0.47543365\",\n \"0.47511947\",\n \"0.474501\",\n \"0.47435045\",\n \"0.47351968\",\n \"0.47303635\",\n \"0.4728081\",\n \"0.4720744\",\n \"0.47161886\",\n \"0.4712622\",\n \"0.47108647\",\n \"0.47031394\",\n \"0.4702606\",\n \"0.47021928\",\n \"0.4696417\",\n \"0.46930414\",\n \"0.4688835\",\n \"0.46798202\",\n \"0.4674762\",\n \"0.46730122\",\n \"0.4671944\",\n \"0.46708053\",\n \"0.46706784\",\n \"0.46611407\",\n \"0.4659484\",\n \"0.4659484\",\n \"0.46572208\",\n \"0.4651226\",\n \"0.46351737\",\n \"0.4634824\",\n \"0.46316117\",\n \"0.46291816\",\n \"0.46133518\",\n \"0.46116164\",\n \"0.46116072\",\n \"0.46097487\",\n \"0.46085066\",\n \"0.4599631\",\n \"0.45993984\",\n \"0.45908275\",\n \"0.45907262\",\n \"0.45879102\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65550715"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76098,"cells":{"query":{"kind":"string","value":"Calculate the information gain"},"document":{"kind":"string","value":"def informationGain2(data, attribute):\n \n split_data = splitBy(data, attribute) \n weighted_entropies = 0\n \n for set in split_data:\n weighted_entropies += len(set) / len(data) * entropy2(set) \n \n columnIG = entropy2(data) - weighted_entropies\n \n return columnIG"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _information_gain(self, feature, node):\n return node.entropy() - self._entropy(feature, node)","def info_gain(self, left, right, current_uncertainty):\n p = float(len(left)) / (len(left) + len(right))\n return current_uncertainty - p * self.gini(left) - (1 - p) * self.gini(right)","def gain(self):\n return self[1]","def infoGain(self,attr, data, target_attr):\n remainder = 0\n p = 0\n ent = 0\n for ele in target_attr:\n if ele == 1:\n p +=1\n \n q = p / (len(target_attr)) \n if 0 < q < 1:\n ent = -((q * math.log2(q)) + ((1-q) * math.log2(1-q))) \n \n unique = list(pd.unique(self.data_set[attr])) \n l = self.data_set[attr]\n for ele in unique:\n pk =0\n nk=0\n j=0\n for i in range (0, len(data)): #len (l) changed to len(data)\n j = j+1\n ele1 = l[i]\n if ele1 == ele:\n out = target_attr[i]\n if out == 1:\n pk += 1\n else:\n nk += 1\n if (pk+nk) != 0:\n q1 = pk / (pk +nk)\n if 0 < q1 < 1:\n e = -((q1 * math.log2(q1)) + ((1-q1) * math.log2(1-q1)))\n remainder += (pk + nk)/(len(target_attr)) * e\n \n return (ent - remainder, attr)","def info_gain(left, right, current_uncertainty):\n p = float(len(left)) / (len(left) + len(right))\n return current_uncertainty - p * gini(left) - (1 - p) * gini(right)","def get_information_gain(self, word, documents):\n gain = self.get_entropy(documents)\n with_word, without_word = self.get_split_data(word, documents)\n gain -= self.get_entropy(with_word) * len(with_word) / len(documents)\n gain -= self.get_entropy(without_word) * len(without_word) / len(documents)\n return gain","def _calculate_information_gain(self, cur_state, next_state):\n\n n = len(cur_state)\n information_gain_per_action = np.zeros((n, self.action_dim))\n\n prob_cur = self.classifier.get_class1_prob(obs=cur_state)\n prob_next = self.classifier.get_class1_prob(obs=next_state)\n information_gain_true = (prob_next - prob_cur).reshape(-1, 1)\n\n next_state_null = np.copy(next_state)\n next_state_null[:, -self.action_dim:] = self.classifier.missing_value\n prob_next_null = self.classifier.get_class1_prob(next_state_null)\n\n for i in range(self.action_dim):\n next_state_i = np.copy(next_state)\n next_state_i[:, -self.action_dim:] = self.classifier.missing_value\n next_state_i[:, -i - 1] = next_state[:, -i - 1]\n\n prob_next_i = self.classifier.get_class1_prob(obs=next_state_i)\n information_gain_per_action[:, -i - 1] = prob_next_i - prob_next_null\n\n information_gain_sum = np.sum(information_gain_per_action, axis=1, keepdims=True)\n ratio = information_gain_true / information_gain_sum\n ratio[information_gain_sum == 0] = 0\n information_gain_per_action = information_gain_per_action * ratio\n return information_gain_per_action","def getInfoGain(self, data, index):\n # count for True Positive, True Negitive, False Positive and False Negitive\n TP = 0\n TN = 0\n FP = 0\n FN = 0\n\n for record in data:\n attrValue = record[index]\n clsValue = record[-1]\n\n if attrValue == 'True':\n if clsValue == 'en':\n TP += 1\n else:\n TN += 1\n elif attrValue == 'False':\n if clsValue == 'en':\n FP += 1\n else:\n FN += 1\n\n # calculate class entropy and entropy of each value of an attribute\n E_init = self.getEntropy(self.enClass, self.nlClass)\n E_attr = self.getAttrEntropy(TP, TN, FP, FN)\n\n infoGain = E_init - E_attr\n\n self.entropy = E_init\n return infoGain","def information_gain(f1, f2):\n\n ig = ee.entropyd(f1) - conditional_entropy(f1, f2)\n return ig","def _calculate_information_gain(self, cur_state, next_state, next_label):\n n = len(cur_state)\n information_gain_per_action = np.zeros((n, self.action_dim))\n prob_prev = self.classifier.get_class1_prob(obs=cur_state)\n\n for i in range(self.action_dim):\n obs_i = np.copy(next_state)\n obs_i[:, -self.action_dim:] = cur_state[:, -self.action_dim:]\n obs_i[:, - i - 1] = next_state[:, -i - 1]\n\n prob_i = self.classifier.get_class1_prob(obs=obs_i)\n class_1_gain = (prob_i - prob_prev) * next_label[:, 0]\n class_0_gain = (prob_i - prob_prev) * (1 - next_label)[:, 0]\n\n if self.positive_only:\n class_1_gain[class_1_gain < 0] = 0\n class_0_gain[class_0_gain < 0] = 0\n else:\n class_0_gain = - class_0_gain\n\n information_gain_per_action[:, - i - 1] = (class_1_gain + class_0_gain)\n\n return information_gain_per_action","def _gain(self):\n return None","def _calculate_information_gain(self, obs, label):\n n = len(obs)\n information_gain_per_action = np.zeros((n, self.action_dim))\n\n obs_null = np.copy(obs)\n obs_null[:, -self.action_dim:] = self.classifier.missing_value\n prob_null = self.classifier.get_class1_prob(obs=obs_null)\n\n for i in range(self.action_dim):\n obs_i = np.copy(obs)\n for j in range(self.action_dim):\n if i != j:\n obs_i[:, - j - 1] = self.classifier.missing_value\n prob_i = self.classifier.get_class1_prob(obs=obs_i)\n class_1_gain = (prob_i - prob_null) * label[:, 0]\n class_0_gain = (prob_i - prob_null) * (1 - label)[:, 0]\n\n if self.positive_only:\n class_1_gain[class_1_gain < 0] = 0\n class_0_gain[class_0_gain < 0] = 0\n else:\n class_0_gain = - class_0_gain\n\n information_gain_per_action[:, - i - 1] = (class_1_gain + class_0_gain)\n\n return information_gain_per_action","def _calculate_information_gain(self, obs, label):\n n = len(obs)\n information_gain_per_action = np.zeros((n, self.action_dim))\n\n obs_null = np.copy(obs)\n obs_null[:, -self.action_dim:] = self.classifier.missing_value\n ce_loss_null = self.classifier.calculate_ce_loss(obs=obs_null, label=label)\n\n for i in range(self.action_dim):\n obs_i = np.copy(obs)\n for j in range(self.action_dim):\n if i != j:\n obs_i[:, - j - 1] = self.classifier.missing_value\n ce_loss_i = self.classifier.calculate_ce_loss(obs=obs_i, label=label)\n\n information_gain_per_action[:, - i - 1] = (ce_loss_null - ce_loss_i)[:, 0]\n\n return information_gain_per_action","def front_column_model_p_gain():","def calc_information_gain(data, split_name, target_name):\r\n # Calculate the original entropy\r\n original_entropy = calc_entropy(data[target_name])\r\n \r\n # Find the median of the column we're splitting\r\n column = data[split_name]\r\n median = column.median()\r\n \r\n # Make two subsets of the data, based on the median\r\n left_split = data[column <= median]\r\n right_split = data[column > median]\r\n \r\n # Loop through the splits and calculate the subset entropies\r\n to_subtract = 0\r\n for subset in [left_split, right_split]:\r\n prob = (subset.shape[0] / data.shape[0]) \r\n to_subtract += prob * calc_entropy(subset[target_name])\r\n \r\n # Return information gain\r\n return original_entropy - to_subtract","def _information_gain(self, y, subsets):\n n = y.shape[0]\n child_entropy = 0\n\n for y_i in subsets:\n child_entropy += self._entropy(y_i) * y_i.shape[0] / float(n)\n\n return self._entropy(y) - child_entropy","def digital_gain():\n def r(x):\n return x/512.\n\n def w(x):\n return int(x*512)\n return r, w","def information_gain(features, attribute_index, targets):\r\n\r\n possible_feature_values = [0,1]\r\n \r\n possible_classifications = [0,1]\r\n \r\n feature = features[:,attribute_index]\r\n \r\n \r\n number_of_samples = len(feature)\r\n \r\n import math\r\n \r\n \r\n #current_entropy = np.sum([-(len(targets[targets==possible_classification])/number_of_samples)*math.log(len(targets[targets==possible_classification])/number_of_samples, 2) for possible_classification in possible_classifications])\r\n \r\n terms_to_be_summed_for_current_entropy = []\r\n \r\n for classification in possible_classifications:\r\n \r\n number_of_elements_with_this_classification = len(targets[targets==classification])\r\n \r\n p_for_this_classification = number_of_elements_with_this_classification/len(targets)\r\n \r\n if p_for_this_classification != 0:\r\n terms_to_be_summed_for_current_entropy.append(-p_for_this_classification*math.log(p_for_this_classification,2))\r\n else:\r\n terms_to_be_summed_for_current_entropy.append(0)\r\n \r\n current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\r\n \r\n \r\n \r\n terms_to_be_summed_for_weighted_entropy = []\r\n \r\n for possible_value in possible_feature_values:\r\n \r\n targets_split_by_feature_value = targets[feature.flatten() == possible_value]\r\n \r\n if len(targets_split_by_feature_value) != 0:\r\n \r\n \r\n weight_of_feature_value = len(targets_split_by_feature_value)/len(targets)\r\n \r\n terms_for_entropy_within_subset = []\r\n \r\n for classification in possible_classifications:\r\n \r\n number_of_subset_elements_with_this_classification = len(targets_split_by_feature_value[targets_split_by_feature_value==classification])\r\n \r\n p_in_subset_for_this_classification = number_of_subset_elements_with_this_classification/len(targets_split_by_feature_value)\r\n \r\n if p_in_subset_for_this_classification != 0:\r\n terms_for_entropy_within_subset.append(-p_in_subset_for_this_classification*math.log(p_in_subset_for_this_classification,2))\r\n else:\r\n terms_for_entropy_within_subset.append(0)\r\n \r\n entropy_within_subset = np.sum(terms_for_entropy_within_subset)\r\n \r\n terms_to_be_summed_for_weighted_entropy.append(weight_of_feature_value*entropy_within_subset)\r\n \r\n weighted_entropy = np.sum(terms_to_be_summed_for_weighted_entropy)\r\n \r\n \r\n #current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\r\n \r\n #weighted_entropy = np.sum([(len(feature[feature==possible_value])/number_of_samples)*(len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value]))*math.log((len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value])), 2) for possible_classification in possible_classifications for possible_value in possible_feature_values])\r\n\r\n information_gain = current_entropy - weighted_entropy \r\n \r\n return information_gain","def calc_information_gain(data, split_name, target_name):\n # Calculate the original entropy\n original_entropy = calc_entropy(data[target_name])\n \n # Find the median of the column we're splitting\n column = data[split_name]\n median = column.median()\n \n # Make two subsets of the data, based on the median\n left_split = data[column <= median]\n right_split = data[column > median]\n \n # Loop through the splits and calculate the subset entropies\n to_subtract = 0\n for subset in [left_split, right_split]:\n prob = (subset.shape[0] / data.shape[0]) \n to_subtract += prob * calc_entropy(subset[target_name])\n \n # Return information gain\n return original_entropy - to_subtract","def return_infogain(instances, labels):\n # some initial calculations\n infogain = dict.fromkeys(range(instances.shape[1]), 0)\n cnt = Counts(instances, labels)\n len_instances = instances.shape[0]\n feature_frequency = cnt.count_document_frequency()\n label_frequency = cnt.count_label_frequency()\n label_feature_frequency = cnt.count_label_feature_frequency()\n label_probability = [(label_frequency[label] / len_instances) for label in label_frequency.keys()]\n initial_entropy = -sum([prob * math.log(prob, 2) for prob in label_probability if prob != 0])\n # assign infogain values to each feature\n for feature in feature_frequency.keys():\n # calculate positive entropy\n frequency = feature_frequency[feature]\n if frequency > 0:\n feature_probability = frequency / len_instances\n positive_label_probabilities = []\n for label in labels:\n if label_feature_frequency[label][feature] > 0:\n positive_label_probabilities.append(label_feature_frequency[label][feature] / frequency)\n else:\n positive_label_probabilities.append(0)\n positive_entropy = -sum([prob * math.log(prob, 2) for prob in positive_label_probabilities if prob != 0])\n else:\n positive_entropy = 0\n # calculate negative entropy\n inverse_frequency = len_instances - feature_frequency[feature]\n negative_probability = inverse_frequency / len_instances\n negative_label_probabilities = [((label_frequency[label] - label_feature_frequency[label][feature]) / inverse_frequency) for label in labels]\n negative_entropy = -sum([prob * math.log(prob, 2) for prob in negative_label_probabilities if prob != 0])\n # based on positive and negative entropy, calculate final entropy\n final_entropy = positive_entropy - negative_entropy\n infogain[feature] = initial_entropy - final_entropy\n return infogain","def dcgain(sys):\n return sys.dcgain()","def gain(self, target_attr, attr, debug=False):\n current_entropy = self.entropy(target_attr)[0]\n # print\n # print attr\n\n gain = current_entropy - self.remainder(target_attr=target_attr, attr=attr)\n if debug is True:\n print attr, \": \", gain\n return gain","def gain(Y, X):\n return entropy(Y) - cEntropy(Y,X)","def gain(self) -> int:\n return self._gain","def get_info_gain(true_rows, false_rows, current_impurity):\n avg_impurity = (len(true_rows)/(len(true_rows)+len(false_rows))) * get_gini(true_rows) + \\\n (len(false_rows)/(len(true_rows)+len(false_rows))) * get_gini(false_rows)\n return current_impurity - avg_impurity","def information_gain(Y, attr):\n initial_gain = entropy(Y)\n\n temp_Y = Y.tolist()\n temp_attr = attr.tolist()\n\n temp_attr = list(np.unique(attr))\n\n for a in temp_attr:\n l = []\n count = 0\n for j in attr:\n if (j == a):\n l.append(temp_Y[count])\n count+=1\n initial_gain -= ((len(l) / len(temp_Y)) * entropy(pd.Series(l)))\n return initial_gain","def _calc(self):\r\n tot_sum: float = 0 # ? total sum of the noise values\r\n max_amp: float = 0 # ? keep the sum in [0,1]\r\n amp: float = 1.0 # ? amplitude of each noise value\r\n freq: float = 1.0 # ? frequency for getting the detailed noise\r\n\r\n # for each octave we twice the frequency and multiply the amplitude \r\n # by persistance to get the detailed noise value\r\n # to keep the final sum value in the range [0, 1] we keep track of the \r\n # max amplitude (sum of all the amplitudes)\r\n for octave in range(self.octaves):\r\n noise_obj = PerlinNoise(self.inp_x*freq, self.inp_y*freq, self.inp_z*freq)\r\n # ? multiply the noise value by the amplitude\r\n tot_sum += noise_obj.val() * amp\r\n max_amp += amp\r\n\r\n amp *= self.persist\r\n freq *= 2.0 # double the freq each iteration\r\n\r\n # value is in the range [0,1]\r\n self.value = tot_sum / max_amp","def vga_gain(self):\n return float(self._read(0x15, 4, 0x70) + 8)","def estimateInfo(Analysis, ImageData, diffract, print_opt=False): \n total_images = ImageData['totalImages'] \n\n for key in Analysis:\n Analysis[key]['cones'] = [1,2,3,4,5,6]\n Analysis[key]['info'] = np.zeros(len(\n Analysis[key]['cones']))\n\n for amp in ImageData['rawAmp']:\n\n for key in Analysis:\n ind = len(diffract['cpd'])\n fooInfo = info.SingleConeEntropyFunc((amp[ind] ** 2 *\n Analysis[key]['retina']), \n Analysis[key]['cones']) \n Analysis[key]['info'] += fooInfo / total_images\n\n if print_opt == True:\n print ' '\n print 'Information'\n print '------------'\n for key in Analysis:\n print key, ': ', Analysis[key]['info']\n\n return Analysis","def get_gain(self, *args):\n return _uhd_swig.usrp_sink_sptr_get_gain(self, *args)","def dcgain(self):\n raise NotImplementedError(\"dcgain not implemented for %s objects\" %\n str(self.__class__))","def get_gain(self, *args):\n return _uhd_swig.usrp_sink_get_gain(self, *args)","def calculate_gains(self,data, map_fits, avg_map_fits):\n nFeeds,nBands,nChans,nParams = map_fits['Values'].shape\n frequencies = data[f'{self.level2}/averaged_frequency'][...]\n kb = 1.38064852e-23\n c = 2.99792458e8\n scale = 2 * kb * (1e9/ c)**2 * 1e26\n\n source = self.getSource(data)\n self.flux = np.zeros((len(self.feeds),nBands, nChans))\n self.gain = np.zeros((len(self.feeds),nBands, nChans))\n\n for i,(ifeed,feed) in enumerate(zip(self.feedlist,self.feeds)):\n for iband in range(nBands):\n nu = frequencies[iband]\n sigx = avg_map_fits[iband]['Values'][2] \n sigy = avg_map_fits[iband]['Values'][2]*avg_map_fits[iband]['Values'][4]\n amps = map_fits['Values'][i,iband,:,0]\n self.flux[i,iband,:] = 2*np.pi*amps*sigx*sigy*(np.pi/180.)**2 * scale*nu**2\n mdl_flux = self.models[source](nu,map_fits['MJD'],return_jansky=True,allpos=True)\n self.gain[i,iband,:] = self.flux[i,iband,:]/mdl_flux\n\n return self.flux, self.gain","def informationGain(data, class_label, attribute, indices=None):\n\tsubset = data[:] if indices == None else data.loc[indices]\n\t\n\tsublist = subset[attribute].tolist()\n\tvalues = list(set(sublist))\n\tinfoGain = entropyOnSubset(subset, class_label)\n\t\n\t#print (sublist)\n\t\n\tfor i in values:\n\t\tindex = list(subset.index[subset[attribute] == i])\n\t\tinfoGain -= sublist.count(i)/len(sublist) * entropyOnSubset(subset, class_label, index)\n\n\t\n\treturn infoGain","def feedback_gain(self):\n return self._feedback_gain","def __calc_info_gain(self, parent, left_child, right_child):\n parent_entropy = self.__entropy(parent[:, -1])\n\n num_rows_left = left_child.shape[0]\n num_rows_right = right_child.shape[0]\n num_rows_total = num_rows_left + num_rows_right\n\n # don't calculate if any of the children rows are empty\n if num_rows_left == 0 or num_rows_right == 0:\n return 0\n\n # calculate entropy of the children data\n left_child_entropy = self.__entropy(left_child[:, -1])\n right_child_entropy = self.__entropy(right_child[:, -1])\n left_child_contribution = (num_rows_left/num_rows_total)*left_child_entropy\n right_child_contribution = (num_rows_right/num_rows_total)*right_child_entropy\n new_entropy = left_child_contribution + right_child_contribution\n\n info_gain = parent_entropy - new_entropy\n return info_gain","def info_gain_ratio(Ex, a, nan=True):\n # Check whether examples and attributes have the same lengths.\n if len(Ex) != len(a):\n raise ValueError(\"Ex and a must be of the same size.\")\n\n # Compute information gain ratio as IG/IV\n return info_gain(Ex, a, nan) / intrinsic_value(Ex, a, nan)","def EM_gain(self):\n gain = ct.c_int()\n self.lib.GetEMCCDGain(ct.pointer(gain))\n\n return gain.value","def get_gain(self, *args):\n return _uhd_swig.usrp_source_get_gain(self, *args)","def get_gain(self, *args):\n return _uhd_swig.usrp_source_sptr_get_gain(self, *args)","def calc_gain(s, i):\n return math.sqrt((i + s) / (6 * s))","def __call__(cls, image):\n\n logger.info('Gain Correcting Image')\n\n saturate = 0.\n gains = []\n for amp in decaminfo.amps:\n sec = section2slice(image['DATASEC' + amp])\n gain = image['GAIN' + amp]\n gains.append(gain)\n image.data[sec] *= gain\n\n # Adjust the weight or variance image if present:\n if image.weight is not None:\n image.weight[sec] *= 1. / (gain * gain)\n if image.variance is not None:\n image.variance[sec] *= gain * gain\n\n # Adjust keywords\n image['GAIN' + amp] = image['GAIN' + amp] / gain\n image['SATURAT' + amp] = image['SATURAT' + amp] * gain\n saturate = max(saturate, image['SATURAT' + amp])\n # Scale the SKYVAR if it's already here\n kw = 'SKYVAR' + amp\n if kw in image.header.keys():\n image[kw] = image[kw] * gain * gain\n # The FLATMED will keep track of rescalings *after* gain:\n image['FLATMED' + amp] = 1.\n\n # The SATURATE keyword is assigned to maximum of the two amps.\n image['SATURATE'] = saturate\n\n # Some other keywords that we will adjust crudely with mean gain\n # if they are present:\n gain = np.mean(gains)\n for kw in ('SKYBRITE', 'SKYSIGMA'):\n if kw in image.header.keys():\n image[kw] = image[kw] * gain\n\n # One other keyword to adjust:\n image['BUNIT'] = 'electrons'\n\n logger.debug('Finished applying Gain Correction')\n ret_code = 0\n return ret_code","def lms_gain(self):\n return self._lms_gain","def zenith_gain(freq):\n parfile = open(project_path\n + \"DSS-28_technical/efficiency_vs_freq_pars.pkl\",\"r\")\n pars = cPickle.load(parfile)\n parfile.close()\n effic = {}\n avg_effic = 0\n for key in list(pars.keys()):\n effic[key] = pars[key](freq)/100.\n avg_effic += effic[key]\n # right now I don't know what Pol A and Pol B are\n avg_effic /= len(list(pars.keys()))\n return avg_effic","def dbgain(self, pt_1, pt_2):\n raise NotImplementedError","def get_gains(self):\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x8000+i,0)/100 for i in range(4)])","def calcInfoGainBySplitValue(self, data, structure, colName, splitVal):\n result = self.calcDataEntropy(data, structure) - self.calcEntropyBySplitValue(data, structure, colName, splitVal)\n result = 0 if result < 0 else result\n return round(result, 3)","def internal_heat_gain(dwelling):\n losses_gain = -40 * dwelling.Nocc\n water_heating_gains = (1000. / 24.) * dwelling.heat_gains_from_hw / DAYS_PER_MONTH\n\n mean_appliance_energy = 207.8 * (dwelling.GFA * dwelling.Nocc) ** 0.4714\n appliance_consumption_per_day = (mean_appliance_energy / 365.) * (\n 1 + 0.157 * numpy.cos((2. * math.pi / 12.) * (numpy.arange(12) - .78)))\n\n appliance_consumption = appliance_consumption_per_day * DAYS_PER_MONTH\n\n if dwelling.reduced_gains:\n met_gain = 50 * dwelling.Nocc\n cooking_gain = 23 + 5 * dwelling.Nocc\n appliance_gain = (0.67 * 1000. / 24) * appliance_consumption_per_day\n light_gain = 0.4 * dwelling.full_light_gain\n else:\n met_gain = 60 * dwelling.Nocc\n cooking_gain = 35 + 7 * dwelling.Nocc\n appliance_gain = (1000. / 24) * appliance_consumption_per_day\n light_gain = dwelling.full_light_gain\n\n total_internal_gains = (met_gain\n + light_gain\n + appliance_gain\n + cooking_gain\n + water_heating_gains\n + dwelling.pump_gain\n + losses_gain)\n\n if dwelling.reduced_gains:\n summer_met_gain = 60 * dwelling.Nocc\n summer_cooking_gain = 35 + 7 * dwelling.Nocc\n summer_appliance_gain = (1000. / 24) * appliance_consumption_per_day\n summer_light_gain = dwelling.full_light_gain\n total_internal_gains_summer = (summer_met_gain +\n water_heating_gains +\n summer_light_gain +\n summer_appliance_gain +\n summer_cooking_gain +\n dwelling.pump_gain +\n losses_gain\n - dwelling.heating_system_pump_gain)\n else:\n total_internal_gains_summer = total_internal_gains - dwelling.heating_system_pump_gain\n\n # Apply results to dwelling\n return dict(appliance_consumption=appliance_consumption,\n met_gain=met_gain,\n cooking_gain=cooking_gain,\n appliance_gain=appliance_gain,\n light_gain=light_gain,\n water_heating_gains=water_heating_gains,\n losses_gain=losses_gain,\n total_internal_gains=total_internal_gains,\n total_internal_gains_summer=total_internal_gains_summer)","def calculateDataRate(self):\n pass","def calculate(self) -> float:","def calc(self,index,counter_values):\n gr = self.grSign * self.grPitch['Value'].value\n m = self.mSign * self.mPitch['Value'].value\n \n offsetG,offsetM = self.checkOffset()\n beta = self.toRadians(gr) - (math.pi/2.0) - offsetG\n theta = (math.pi/2.0) - (self.toRadians(m)) - offsetM\n alpha = (2.0*theta) + beta\n numerator = (math.sin(alpha) + math.sin(beta))\n denominator = (self.DiffrOrder * self.look_at_grx())\n wavelength = numerator / denominator\n \n if wavelength == 0.0:\n energy_physicalmot = 0.0\n else:\n energy_physicalmot = self.hc / wavelength\n #if self.FixedM2Pit: \n Cff = math.cos(beta)/math.cos(alpha)\n if energy_physicalmot < 0 :\n #warning: wavelength se vuelve negativo ... ??????\n energy_physicalmot = energy_physicalmot *(-1) \n \n # Real Energy is equal to the energy calculated by the encoders\n # minus an offset that depends on the same energy calculated by the \n # encoders:\n # E_physicalmot = Ereal + offset\n # with offset = a*Ereal + b\n # This implies that: Ereal = (Ephysicalmot - b)/(1+a) \n a_coeff = self.EnergyDP.a_offset_coeff\n b_coeff = self.EnergyDP.b_offset_coeff\n numerator = energy_physicalmot - b_coeff\n denominator = 1 + a_coeff\n energy = numerator / denominator\n \n if index == 1:\n return energy\n elif index == 2:\n return Cff","def showAverageGainWon(self) :\n averageGainWon = 0\n for level in self.level_history :\n averageGainWon += level.profit\n averageGainWon = averageGainWon/len(self.level_history)\n Scenario.messageGetAverageGainWon(averageGainWon)","def su_calculation(f1, f2):\n # calculate information gain of f1 and f2, t1 = ig(f1, f2)\n t1 = information_gain(f1, f2)\n # calculate entropy of f1\n t2 = ee.entropyd(f1)\n # calculate entropy of f2\n t3 = ee.entropyd(f2)\n\n su = 2.0 * t1 / (t2 + t3)\n\n return su","def calibration(self) -> int:","def info_gain(Ex, a, nan=True):\n # Check whether examples and attributes have the same lengths.\n if len(Ex) != len(a):\n raise ValueError(\"Ex and a must be of the same size.\")\n\n # Compute the entropy of examples\n H_Ex = entropy(list(Counter(Ex).values()))\n\n # If nan is True, replace all nan values in a by the string \"__nan__\"\n if nan:\n a = ['__nan__' if isinstance(x, float) and math.isnan(x) else x for x in a]\n \n # Compute the sum of all values v in a\n sum_v = 0\n for v in set(a):\n Ex_a_v = [x for x, t in zip(Ex, a) if t == v]\n sum_v += (len(Ex_a_v) / len(Ex)) *\\\n (entropy(list(Counter(Ex_a_v).values())))\n\n # Return result\n return H_Ex - sum_v","def get_mod_gain_val(self):\n return self.mod_gain_table[self.tx_pwr_dbm];","def get_gain(self):\n gain = float(self._driver.Gain.Value)\n return gain","def calculate_gain_table(info_table):\n\n\t# sort and separate\n\tinfo_table['decile'] = 10 - pd.qcut(info_table['proba'], 10, labels = False)\n\n\t# group by each decile, calculate gain score\n\ttotal_positive = sum(info_table['target'])\n\tgain_table = info_table.groupby('decile', as_index = False)['target'].sum()\n\tgain_table = gain_table.rename(columns = {'target': 'positive'})\n\tgain_table['gain_score'] = gain_table['positive'] / total_positive\n\n\t# gain = cumsum(gain score)\n\tgain_table['gain'] = gain_table['gain_score'].cumsum()\n\n\treturn gain_table","def strength(self) -> float:\n ...","def compute_gains(self, t, add_noise=True):\n #get the basis funtion at a time step\n basis, Dbasis = self.get_basis(t)\n\n if t < self._time_steps-1:\n basis_t_dt, _ = self.get_basis(t+1)\n else:\n basis_t_dt = np.zeros_like(basis)\n\n\n #part 1 equation 46\n B_pseudo = np.linalg.pinv(self._B)\n\n #equation 12 for t\n Sigma_t = np.dot(np.dot(basis, self._sigma_W), basis.T)\n\n #equation 12 for t+dt\n Sigma_t_dt = np.dot(np.dot(basis_t_dt, self._sigma_W), basis_t_dt.T)\n\n #Cross correlation between t, t+dt, Equation 49\n Ct = np.dot(np.dot(basis, self._sigma_W), basis_t_dt.T)\n\n #System noise Equation 51\n Sigma_s = (1./self._dt)* ( Sigma_t_dt - np.dot( np.dot( Ct.T, np.linalg.inv(Sigma_t) ), Ct) )\n\n #control noise Equation 52\n Sigma_u = np.dot(np.dot(B_pseudo, Sigma_s), B_pseudo.T)\n\n #part 2 equation 46\n tmp1 = np.dot(np.dot(Dbasis, self._sigma_W), basis.T)\n\n #part 3 equation 46\n tmp2 = np.dot(self._A, Sigma_t) + 0.5*Sigma_s\n\n #compute feedback gain; complete equation 46\n K = np.dot( np.dot(B_pseudo, (tmp1-tmp2) ), np.linalg.inv(Sigma_t))\n\n #part 1 equation 48\n tmp3 = np.dot(Dbasis, self._mean_W)\n\n #part 2 equation 48\n tmp4 = np.dot( (self._A + np.dot(self._B, K)), np.dot(basis, self._mean_W) )\n\n #compute feedforward gain; complete equation 48\n k = np.dot(B_pseudo, (tmp3-tmp4))\n\n return K, k, Sigma_u","def _adsc_module_gain(self, model=None):\n\n if model is None:\n sn = int(self._header_dictionary[\"DETECTOR_SN\"])\n model = self._sn_to_model.get(sn)\n return super()._adsc_module_gain(model=model)","def _measurement_update(self, y_i, h_tilde, pert_m, k_gain, cov_m):\n innovation = np.subtract(np.transpose(y_i),\n np.matmul(h_tilde, pert_m))\n pert_p = np.add(pert_m, np.matmul(k_gain, innovation))\n\n L = np.subtract(np.identity(len(self.istate)),\n np.matmul(k_gain, h_tilde))\n\n cov_p = np.matmul(L, cov_m)\n\n return (cov_p, pert_p)","def servo_gainupdate(self, *args, **kwargs) -> Any:\n pass","def calcInfoGainByColumnSplit(self, data, structure, colName):\n result = self.calcDataEntropy(data, structure) - self.calcEntropyByColumnSplit(data, structure, colName)\n result = 0 if result < 0 else result\n return round(result, 3)","def advancedStats():","def obtain_data(self):\n ##MODIFY THIS\n #ipdb.set_trace()\n print('obtain_data')\n print(self.enabler)\n print(self.index)\n helper = '>'+str(1+int(self.chann_span.get()))+'Q'\n print('helper='+helper)\n while(self.enabler):\n #print('size'+str(1+int(self.chann_span.get())))\n #print('offset'+str(self.index-self.index_offset))\n A2 = struct.unpack(helper, fpga.read('A2', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8))) \n #print(A2)\n #print(str(10*np.log10(A2))+'dB')\n self.amp_a2[0] = np.mean(A2)\n self.amp_a2 = np.roll(self.amp_a2, -1)\n B2 = struct.unpack(helper, fpga.read('B2', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\n self.amp_b2[0] = np.mean(B2)\n self.amp_b2 = np.roll(self.amp_b2, -1)\n AB_re = struct.unpack(helper, fpga.read('AB_re', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\n self.ab_re[0] = np.mean(AB_re)\n self.ab_re = np.roll(self.ab_re, -1)\n AB_im = struct.unpack(helper, fpga.read('AB_im', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\n self.ab_im[0] = np.mean(AB_im)\n self.ab_im = np.roll(self.ab_im, -1) \n # print('RE:' + str(self.ab_re)+ '\\t IM:' +str(self.ab_im))\n log_a = 10*np.log10(np.mean(self.amp_a2)+1.0)\n log_b = 10*np.log10(np.mean(self.amp_b2)+1.0) \n ang = np.rad2deg(np.arctan2(np.mean(self.ab_im), np.mean(self.ab_re))) #review the way of avg this... i dont know if its the most correct way to do it...\n self.a2.set(log_a)\n self.b2.set(log_b)\n self.ang.set(ang)\n self.amp_rel.set(log_a-log_b)\n return 1","def mutual_information(x, y, w):\r\n \r\n\r\n total_entropy = entropy(y,w)\r\n\r\n partitioned_x = partition(x)\r\n weighted_entropy = 0\r\n # calculate the weighted entropy over the partition of x\r\n vals,counts= np.unique(x,return_counts=True)\r\n for key in partitioned_x:\r\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\r\n\r\n information_gain = total_entropy - weighted_entropy\r\n return information_gain","def measure(self, imgage, previous=None):","def calculate(self):","def gain(self):\r\n \r\n for node in self.G.nodes():\r\n # Get number of nodes connected on same and other partition\r\n movForce, retForce = self.nodeForces(node)\r\n nodeGain = movForce-retForce\r\n\r\n #Fill list of Nodes with gains\r\n self.gainOrder.append((nodeGain,node))\r\n \r\n self.gainOrder.sort(key=lambda r: r[0])\r\n self.keys = [r[1] for r in self.gainOrder]","def ComputeEnergyConsumption(self):\r\n pass","def calculate_output(self):","def coefficient(self) -> float:\n ...","def gradient_descent_gain(self):\n return self._gradient_descent_gain","def dB2gain(dB):\n V = math.exp(dB/20)\n return V","def calc_q_gain(Tfl, Tabs, q_rad_Whperm2, DT, Tin, Tout, aperture_area_m2, c1, c2, Mfl, delts, Cp_waterglycol, C_eff, Te):\n\n xgain = 1\n xgainmax = 100\n exit = False\n while exit == False:\n qgain_Whperm2 = q_rad_Whperm2 - c1 * (DT[1]) - c2 * abs(DT[1]) * DT[1] # heat production from solar collector, eq.(5)\n\n if Mfl > 0:\n Tout = ((Mfl * Cp_waterglycol * Tin) / aperture_area_m2 - (C_eff * Tin) / (2 * delts) + qgain_Whperm2 + (\n C_eff * Tfl[1]) / delts) / (Mfl * Cp_waterglycol / aperture_area_m2 + C_eff / (2 * delts)) # eq.(6)\n Tfl[2] = (Tin + Tout) / 2\n DT[2] = Tfl[2] - Te\n qdiff = Mfl / aperture_area_m2 * Cp_waterglycol * 2 * (DT[2] - DT[1])\n else:\n Tout = Tfl[1] + (qgain_Whperm2 * delts) / C_eff # eq.(8)\n Tfl[2] = Tout\n DT[2] = Tfl[2] - Te\n qdiff = 5 * (DT[2] - DT[1])\n\n if abs(qdiff < 0.1):\n DT[1] = DT[2]\n exit = True\n else:\n if xgain > 40:\n DT[1] = (DT[1] + DT[2]) / 2\n if xgain == xgainmax:\n exit = True\n else:\n DT[1] = DT[2]\n xgain += 1\n\n # FIXME: redundant...\n # qout = Mfl * Cp_waterglycol * (Tout - Tin) / aperture_area\n # qmtherm = (Tfl[2] - Tfl[1]) * C_eff / delts\n # qbal = qgain - qout - qmtherm\n # if abs(qbal) > 1:\n # qbal = qbal\n return qgain_Whperm2","def compute_kalman_gain(jacobian, oldCovariance, measurementCovariance):\n\n return None","def calc_states_info_gain(A, qs_pi):\n\n n_steps = len(qs_pi)\n\n states_surprise = 0\n for t in range(n_steps):\n states_surprise += spm_MDP_G(A, qs_pi[t])\n\n return states_surprise","def gain2dB(gain):\n dB = 20*math.log(gain)\n return dB","def compute_gain(loudness, renormalize_loudness):\n gain = []\n for i in range(len(loudness)):\n delta_loudness = renormalize_loudness[i] - loudness[i]\n gain.append(np.power(10.0, delta_loudness / 20.0))\n return gain","def get_mod_gain_output(self, mod_gain_input):\n\n output = ((( (mod_gain_input*self.tx_rate_decim_dict[self.dec_filt_rate]) & 0x7FFFFF) >> 11)*\\\n (self.mod_gain_table[self.tx_pwr_dbm])) >> 11\n return output","def compute_gain( hv, cv, thot, tcold):\n\n nData = len(cv) \n epsilons = np.full( nData, EPSILON)\n\n # For full Temp calibration, a spectrum taken at high elevation, away from \n # The galactic plan is used.\n dv = hv - cv \n dv = np.maximum( dv, epsilons)\n hv = np.maximum( hv, epsilons)\n\n # use the comparison of hot and cold to get gain without trx contribution\n gain = (thot - tcold)/dv\n\n trx = gain*cv \n trx = trx - tcold # correct for cold load input in counts\n\n n6 = int(nData/6)\n n56 = 5*n6\n\n trxmedian = np.median( trx[n6:n56])\n gain = (thot + trxmedian)/hv\n \n return trxmedian, gain # channel by channel gain in K/counts","def tGain(self, dt, r):\n\t return 1./(10.**6)*r#*precip.r","def microphone_sensitivity(transferfactor: float) -> float:\n return amp2db(transferfactor/1000.)","def intensity(self) -> int:","def test_information_gain(self):\n self.decision_tree.train(self.data,\n list(range(self.data.num_samples)),\n max_depth=1,\n min_samples_per_node=1,\n use_stop_conditions=False,\n max_p_value_chi_sq=None)\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 1)\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\n [set([0]), set([1]), set([2])])\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\n {0:0, 1:1, 2:2})\n self.assertAlmostEqual(self.decision_tree.get_root_node().node_split.criterion_value,\n 2. * -0.3 * math.log2(0.3) - 0.4 * math.log2(0.4))","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n n = self.confusion_matrix.n\n\n fn_tp = fn + tp\n fp_tp = fp + tp\n\n h1 = -((fn_tp / n) * math.log2(fn_tp / n) +\n (1 - fn_tp / n) * math.log2(1 - fn_tp / n))\n\n h2 = -((fp_tp / n) * math.log2(fp_tp / n) +\n (1 - fp_tp / n) * math.log2(1 - fp_tp / n))\n\n p00 = 1 if tn == 0 else (tn / n)\n p01 = 1 if fn == 0 else (fn / n)\n p10 = 1 if fp == 0 else (fp / n)\n p11 = 1 if tp == 0 else (tp / n)\n\n h12 = -((tn / n) * math.log2(p00) +\n (fn / n) * math.log2(p01) +\n (fp / n) * math.log2(p10) +\n (tp / n) * math.log2(p11))\n\n mi = h1 + h2 - h12\n\n vi = h1 + h2 - 2 * mi\n return vi","def get_gain(self, channel_data):\n values = getattr(channel_data, self.field, None)\n if values is None:\n raise ValueError(f\"Channel group {channel_data} does not contain \"\n f\"{self.field} field.\")\n return values.astype(float)","def compute_gain_readnoise(flat1, flat2, zero1, zero2, section=\"[*,*]\"):\r\n\r\n iraf.noao(_doprint=0)\r\n iraf.obsutil(_doprint=0)\r\n iraf.imarith(flat1, '-', flat2, 'flatdif')\r\n iraf.imarith(zero1, '-', zero2, 'zerodif')\r\n s = iraf.imstat('%s%s' % (flat1, section), fields=\"mean\", nclip=20, \r\n Stdout=1, format=\"no\")\r\n mean_flat1 = np.float(s[0])\r\n s = iraf.imstat('%s%s' % (flat2, section), fields=\"mean\", nclip=20, \r\n Stdout=1, format=\"no\")\r\n mean_flat2 = np.float(s[0])\r\n s = iraf.imstat('%s%s' % (zero1, section), fields=\"mean\", nclip=20, \r\n Stdout=1, format=\"no\")\r\n mean_zero1 = np.float(s[0])\r\n s = iraf.imstat('%s%s' % (zero2, section), fields=\"mean\", nclip=20, \r\n Stdout=1, format=\"no\")\r\n mean_zero2 = np.float(s[0])\r\n s = iraf.imstat('%s%s' % ('flatdif', section), fields=\"stddev\", nclip=20, \r\n Stdout=1, format=\"no\")\r\n sigma_flatdif = np.float(s[0])\r\n s = iraf.imstat('%s%s' % ('zerodif', section), fields=\"stddev\", nclip=20, \r\n Stdout=1, format=\"no\")\r\n sigma_zerodif = np.float(s[0])\r\n gain = (((mean_flat1 + mean_flat2) - (mean_zero1 + mean_zero2)) / \r\n ((sigma_flatdif)**2 - (sigma_zerodif)**2))\r\n readnoise = gain * sigma_zerodif / np.sqrt(2)\r\n iraf.delete('flatdif.fits', verify=\"no\")\r\n iraf.delete('zerodif.fits', verify=\"no\")\r\n return gain, readnoise","def compute_information_gain(Y, xi):\r\n H_Y = H(Y)\r\n\r\n TrainSet = np.delete(AllSets[2], -1, axis=1)\r\n ColumnInd = AllSets[3].index(xi) # extract from dictionary\r\n\r\n NumHeadlines = AllSets[2].shape[0]\r\n AllOccurences, Count = np.unique(AllSets[2][:, ColumnInd], return_counts=True)\r\n\r\n TotalH_YGivenX = 0\r\n for i, count in zip(AllOccurences, Count):\r\n NewY = Y[TrainSet[:, ColumnInd] == i]\r\n\r\n TotalH_YGivenX += H(NewY) * float(count) / NumHeadlines\r\n\r\n return H_Y - TotalH_YGivenX","def _information_gain(self, y, X_column, split_thersh):\n # parent E\n parent_entropy = entropy(y)\n # generate split\n left_idxs, right_idxs = self._split(X_column, split_thersh)\n\n if len(left_idxs) == 0 or len(right_idxs) == 0:\n return 0\n # weighted avg child E\n n = len(y)\n n_left_samples, n_right_samples = len(left_idxs), len(right_idxs)\n entropy_left, entropy_right = entropy(y[left_idxs]), entropy(y[right_idxs])\n child_entropy = (n_left_samples/n) * entropy_left + (n_right_samples/n) * entropy_right\n\n # return IG\n ig = parent_entropy - child_entropy\n return ig","def calculate(self):\n\n sensitivity = self.confusion_matrix.tp / (self.confusion_matrix.tp + self.confusion_matrix.fn)\n return 1 - sensitivity","def _calculate_feedback(self):\r\n age = self.age_field.value()\r\n height_cm = self.height_field.value()\r\n weight_kg = self.weight_field.value()\r\n body_fat = self.bodyFat_field.value()\r\n male = bool(self.gender_combobox.currentIndex())\r\n\r\n if self._mode != 'metric':\r\n height_cm *= 2.54\r\n weight_kg *= 0.454\r\n\r\n document = getWeightLogDocument(height_cm, weight_kg, age, body_fat, male, None, 1.2)\r\n self.feedback_field.setHtml(document)","def calc_pB_info_gain(pB, qs_pi, qs_prev, policy):\n\n n_steps = len(qs_pi)\n\n num_factors = len(pB)\n wB = utils.obj_array(num_factors)\n for factor, pB_f in enumerate(pB):\n wB[factor] = spm_wnorm(pB_f)\n\n pB_infogain = 0\n\n for t in range(n_steps):\n # the 'past posterior' used for the information gain about pB here is the posterior\n # over expected states at the timestep previous to the one under consideration\n # if we're on the first timestep, we just use the latest posterior in the\n # entire action-perception cycle as the previous posterior\n if t == 0:\n previous_qs = qs_prev\n # otherwise, we use the expected states for the timestep previous to the timestep under consideration\n else:\n previous_qs = qs_pi[t - 1]\n\n # get the list of action-indices for the current timestep\n policy_t = policy[t, :]\n for factor, a_i in enumerate(policy_t):\n wB_factor_t = wB[factor][:, :, int(a_i)] * (pB[factor][:, :, int(a_i)] > 0).astype(\"float\")\n pB_infogain -= qs_pi[t][factor].dot(wB_factor_t.dot(previous_qs[factor]))\n\n return pB_infogain","def weight(self):","def information_content(self):\n ic = 0\n for row in self.pwm:\n ic += 2.0 + np.sum([row[x] * log(row[x])/log(2) for x in range(4) if row[x] > 0])\n return ic","def feedforward_1st_gain(self):\n return self._read(MX_FEEDFORWARD_1ST_GAIN)","def cost(self) -> float:","def get_a(self):\n return 0.5*-G*self._mm*self._sm/self.geten()","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n n = self.confusion_matrix.n\n\n fn_tp = fn + tp\n fp_tp = fp + tp\n\n h1 = -((fn_tp / n) * math.log2(fn_tp / n) +\n (1 - fn_tp / n) * math.log2(1 - fn_tp / n))\n\n h2 = -((fp_tp / n) * math.log2(fp_tp / n) +\n (1 - fp_tp / n) * math.log2(1 - fp_tp / n))\n\n p00 = 1 if tn == 0 else (tn / n)\n p01 = 1 if fn == 0 else (fn / n)\n p10 = 1 if fp == 0 else (fp / n)\n p11 = 1 if tp == 0 else (tp / n)\n\n h12 = -((tn / n) * math.log2(p00) +\n (fn / n) * math.log2(p01) +\n (fp / n) * math.log2(p10) +\n (tp / n) * math.log2(p11))\n\n mi = h1 + h2 - h12\n return mi"],"string":"[\n \"def _information_gain(self, feature, node):\\n return node.entropy() - self._entropy(feature, node)\",\n \"def info_gain(self, left, right, current_uncertainty):\\n p = float(len(left)) / (len(left) + len(right))\\n return current_uncertainty - p * self.gini(left) - (1 - p) * self.gini(right)\",\n \"def gain(self):\\n return self[1]\",\n \"def infoGain(self,attr, data, target_attr):\\n remainder = 0\\n p = 0\\n ent = 0\\n for ele in target_attr:\\n if ele == 1:\\n p +=1\\n \\n q = p / (len(target_attr)) \\n if 0 < q < 1:\\n ent = -((q * math.log2(q)) + ((1-q) * math.log2(1-q))) \\n \\n unique = list(pd.unique(self.data_set[attr])) \\n l = self.data_set[attr]\\n for ele in unique:\\n pk =0\\n nk=0\\n j=0\\n for i in range (0, len(data)): #len (l) changed to len(data)\\n j = j+1\\n ele1 = l[i]\\n if ele1 == ele:\\n out = target_attr[i]\\n if out == 1:\\n pk += 1\\n else:\\n nk += 1\\n if (pk+nk) != 0:\\n q1 = pk / (pk +nk)\\n if 0 < q1 < 1:\\n e = -((q1 * math.log2(q1)) + ((1-q1) * math.log2(1-q1)))\\n remainder += (pk + nk)/(len(target_attr)) * e\\n \\n return (ent - remainder, attr)\",\n \"def info_gain(left, right, current_uncertainty):\\n p = float(len(left)) / (len(left) + len(right))\\n return current_uncertainty - p * gini(left) - (1 - p) * gini(right)\",\n \"def get_information_gain(self, word, documents):\\n gain = self.get_entropy(documents)\\n with_word, without_word = self.get_split_data(word, documents)\\n gain -= self.get_entropy(with_word) * len(with_word) / len(documents)\\n gain -= self.get_entropy(without_word) * len(without_word) / len(documents)\\n return gain\",\n \"def _calculate_information_gain(self, cur_state, next_state):\\n\\n n = len(cur_state)\\n information_gain_per_action = np.zeros((n, self.action_dim))\\n\\n prob_cur = self.classifier.get_class1_prob(obs=cur_state)\\n prob_next = self.classifier.get_class1_prob(obs=next_state)\\n information_gain_true = (prob_next - prob_cur).reshape(-1, 1)\\n\\n next_state_null = np.copy(next_state)\\n next_state_null[:, -self.action_dim:] = self.classifier.missing_value\\n prob_next_null = self.classifier.get_class1_prob(next_state_null)\\n\\n for i in range(self.action_dim):\\n next_state_i = np.copy(next_state)\\n next_state_i[:, -self.action_dim:] = self.classifier.missing_value\\n next_state_i[:, -i - 1] = next_state[:, -i - 1]\\n\\n prob_next_i = self.classifier.get_class1_prob(obs=next_state_i)\\n information_gain_per_action[:, -i - 1] = prob_next_i - prob_next_null\\n\\n information_gain_sum = np.sum(information_gain_per_action, axis=1, keepdims=True)\\n ratio = information_gain_true / information_gain_sum\\n ratio[information_gain_sum == 0] = 0\\n information_gain_per_action = information_gain_per_action * ratio\\n return information_gain_per_action\",\n \"def getInfoGain(self, data, index):\\n # count for True Positive, True Negitive, False Positive and False Negitive\\n TP = 0\\n TN = 0\\n FP = 0\\n FN = 0\\n\\n for record in data:\\n attrValue = record[index]\\n clsValue = record[-1]\\n\\n if attrValue == 'True':\\n if clsValue == 'en':\\n TP += 1\\n else:\\n TN += 1\\n elif attrValue == 'False':\\n if clsValue == 'en':\\n FP += 1\\n else:\\n FN += 1\\n\\n # calculate class entropy and entropy of each value of an attribute\\n E_init = self.getEntropy(self.enClass, self.nlClass)\\n E_attr = self.getAttrEntropy(TP, TN, FP, FN)\\n\\n infoGain = E_init - E_attr\\n\\n self.entropy = E_init\\n return infoGain\",\n \"def information_gain(f1, f2):\\n\\n ig = ee.entropyd(f1) - conditional_entropy(f1, f2)\\n return ig\",\n \"def _calculate_information_gain(self, cur_state, next_state, next_label):\\n n = len(cur_state)\\n information_gain_per_action = np.zeros((n, self.action_dim))\\n prob_prev = self.classifier.get_class1_prob(obs=cur_state)\\n\\n for i in range(self.action_dim):\\n obs_i = np.copy(next_state)\\n obs_i[:, -self.action_dim:] = cur_state[:, -self.action_dim:]\\n obs_i[:, - i - 1] = next_state[:, -i - 1]\\n\\n prob_i = self.classifier.get_class1_prob(obs=obs_i)\\n class_1_gain = (prob_i - prob_prev) * next_label[:, 0]\\n class_0_gain = (prob_i - prob_prev) * (1 - next_label)[:, 0]\\n\\n if self.positive_only:\\n class_1_gain[class_1_gain < 0] = 0\\n class_0_gain[class_0_gain < 0] = 0\\n else:\\n class_0_gain = - class_0_gain\\n\\n information_gain_per_action[:, - i - 1] = (class_1_gain + class_0_gain)\\n\\n return information_gain_per_action\",\n \"def _gain(self):\\n return None\",\n \"def _calculate_information_gain(self, obs, label):\\n n = len(obs)\\n information_gain_per_action = np.zeros((n, self.action_dim))\\n\\n obs_null = np.copy(obs)\\n obs_null[:, -self.action_dim:] = self.classifier.missing_value\\n prob_null = self.classifier.get_class1_prob(obs=obs_null)\\n\\n for i in range(self.action_dim):\\n obs_i = np.copy(obs)\\n for j in range(self.action_dim):\\n if i != j:\\n obs_i[:, - j - 1] = self.classifier.missing_value\\n prob_i = self.classifier.get_class1_prob(obs=obs_i)\\n class_1_gain = (prob_i - prob_null) * label[:, 0]\\n class_0_gain = (prob_i - prob_null) * (1 - label)[:, 0]\\n\\n if self.positive_only:\\n class_1_gain[class_1_gain < 0] = 0\\n class_0_gain[class_0_gain < 0] = 0\\n else:\\n class_0_gain = - class_0_gain\\n\\n information_gain_per_action[:, - i - 1] = (class_1_gain + class_0_gain)\\n\\n return information_gain_per_action\",\n \"def _calculate_information_gain(self, obs, label):\\n n = len(obs)\\n information_gain_per_action = np.zeros((n, self.action_dim))\\n\\n obs_null = np.copy(obs)\\n obs_null[:, -self.action_dim:] = self.classifier.missing_value\\n ce_loss_null = self.classifier.calculate_ce_loss(obs=obs_null, label=label)\\n\\n for i in range(self.action_dim):\\n obs_i = np.copy(obs)\\n for j in range(self.action_dim):\\n if i != j:\\n obs_i[:, - j - 1] = self.classifier.missing_value\\n ce_loss_i = self.classifier.calculate_ce_loss(obs=obs_i, label=label)\\n\\n information_gain_per_action[:, - i - 1] = (ce_loss_null - ce_loss_i)[:, 0]\\n\\n return information_gain_per_action\",\n \"def front_column_model_p_gain():\",\n \"def calc_information_gain(data, split_name, target_name):\\r\\n # Calculate the original entropy\\r\\n original_entropy = calc_entropy(data[target_name])\\r\\n \\r\\n # Find the median of the column we're splitting\\r\\n column = data[split_name]\\r\\n median = column.median()\\r\\n \\r\\n # Make two subsets of the data, based on the median\\r\\n left_split = data[column <= median]\\r\\n right_split = data[column > median]\\r\\n \\r\\n # Loop through the splits and calculate the subset entropies\\r\\n to_subtract = 0\\r\\n for subset in [left_split, right_split]:\\r\\n prob = (subset.shape[0] / data.shape[0]) \\r\\n to_subtract += prob * calc_entropy(subset[target_name])\\r\\n \\r\\n # Return information gain\\r\\n return original_entropy - to_subtract\",\n \"def _information_gain(self, y, subsets):\\n n = y.shape[0]\\n child_entropy = 0\\n\\n for y_i in subsets:\\n child_entropy += self._entropy(y_i) * y_i.shape[0] / float(n)\\n\\n return self._entropy(y) - child_entropy\",\n \"def digital_gain():\\n def r(x):\\n return x/512.\\n\\n def w(x):\\n return int(x*512)\\n return r, w\",\n \"def information_gain(features, attribute_index, targets):\\r\\n\\r\\n possible_feature_values = [0,1]\\r\\n \\r\\n possible_classifications = [0,1]\\r\\n \\r\\n feature = features[:,attribute_index]\\r\\n \\r\\n \\r\\n number_of_samples = len(feature)\\r\\n \\r\\n import math\\r\\n \\r\\n \\r\\n #current_entropy = np.sum([-(len(targets[targets==possible_classification])/number_of_samples)*math.log(len(targets[targets==possible_classification])/number_of_samples, 2) for possible_classification in possible_classifications])\\r\\n \\r\\n terms_to_be_summed_for_current_entropy = []\\r\\n \\r\\n for classification in possible_classifications:\\r\\n \\r\\n number_of_elements_with_this_classification = len(targets[targets==classification])\\r\\n \\r\\n p_for_this_classification = number_of_elements_with_this_classification/len(targets)\\r\\n \\r\\n if p_for_this_classification != 0:\\r\\n terms_to_be_summed_for_current_entropy.append(-p_for_this_classification*math.log(p_for_this_classification,2))\\r\\n else:\\r\\n terms_to_be_summed_for_current_entropy.append(0)\\r\\n \\r\\n current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\\r\\n \\r\\n \\r\\n \\r\\n terms_to_be_summed_for_weighted_entropy = []\\r\\n \\r\\n for possible_value in possible_feature_values:\\r\\n \\r\\n targets_split_by_feature_value = targets[feature.flatten() == possible_value]\\r\\n \\r\\n if len(targets_split_by_feature_value) != 0:\\r\\n \\r\\n \\r\\n weight_of_feature_value = len(targets_split_by_feature_value)/len(targets)\\r\\n \\r\\n terms_for_entropy_within_subset = []\\r\\n \\r\\n for classification in possible_classifications:\\r\\n \\r\\n number_of_subset_elements_with_this_classification = len(targets_split_by_feature_value[targets_split_by_feature_value==classification])\\r\\n \\r\\n p_in_subset_for_this_classification = number_of_subset_elements_with_this_classification/len(targets_split_by_feature_value)\\r\\n \\r\\n if p_in_subset_for_this_classification != 0:\\r\\n terms_for_entropy_within_subset.append(-p_in_subset_for_this_classification*math.log(p_in_subset_for_this_classification,2))\\r\\n else:\\r\\n terms_for_entropy_within_subset.append(0)\\r\\n \\r\\n entropy_within_subset = np.sum(terms_for_entropy_within_subset)\\r\\n \\r\\n terms_to_be_summed_for_weighted_entropy.append(weight_of_feature_value*entropy_within_subset)\\r\\n \\r\\n weighted_entropy = np.sum(terms_to_be_summed_for_weighted_entropy)\\r\\n \\r\\n \\r\\n #current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\\r\\n \\r\\n #weighted_entropy = np.sum([(len(feature[feature==possible_value])/number_of_samples)*(len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value]))*math.log((len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value])), 2) for possible_classification in possible_classifications for possible_value in possible_feature_values])\\r\\n\\r\\n information_gain = current_entropy - weighted_entropy \\r\\n \\r\\n return information_gain\",\n \"def calc_information_gain(data, split_name, target_name):\\n # Calculate the original entropy\\n original_entropy = calc_entropy(data[target_name])\\n \\n # Find the median of the column we're splitting\\n column = data[split_name]\\n median = column.median()\\n \\n # Make two subsets of the data, based on the median\\n left_split = data[column <= median]\\n right_split = data[column > median]\\n \\n # Loop through the splits and calculate the subset entropies\\n to_subtract = 0\\n for subset in [left_split, right_split]:\\n prob = (subset.shape[0] / data.shape[0]) \\n to_subtract += prob * calc_entropy(subset[target_name])\\n \\n # Return information gain\\n return original_entropy - to_subtract\",\n \"def return_infogain(instances, labels):\\n # some initial calculations\\n infogain = dict.fromkeys(range(instances.shape[1]), 0)\\n cnt = Counts(instances, labels)\\n len_instances = instances.shape[0]\\n feature_frequency = cnt.count_document_frequency()\\n label_frequency = cnt.count_label_frequency()\\n label_feature_frequency = cnt.count_label_feature_frequency()\\n label_probability = [(label_frequency[label] / len_instances) for label in label_frequency.keys()]\\n initial_entropy = -sum([prob * math.log(prob, 2) for prob in label_probability if prob != 0])\\n # assign infogain values to each feature\\n for feature in feature_frequency.keys():\\n # calculate positive entropy\\n frequency = feature_frequency[feature]\\n if frequency > 0:\\n feature_probability = frequency / len_instances\\n positive_label_probabilities = []\\n for label in labels:\\n if label_feature_frequency[label][feature] > 0:\\n positive_label_probabilities.append(label_feature_frequency[label][feature] / frequency)\\n else:\\n positive_label_probabilities.append(0)\\n positive_entropy = -sum([prob * math.log(prob, 2) for prob in positive_label_probabilities if prob != 0])\\n else:\\n positive_entropy = 0\\n # calculate negative entropy\\n inverse_frequency = len_instances - feature_frequency[feature]\\n negative_probability = inverse_frequency / len_instances\\n negative_label_probabilities = [((label_frequency[label] - label_feature_frequency[label][feature]) / inverse_frequency) for label in labels]\\n negative_entropy = -sum([prob * math.log(prob, 2) for prob in negative_label_probabilities if prob != 0])\\n # based on positive and negative entropy, calculate final entropy\\n final_entropy = positive_entropy - negative_entropy\\n infogain[feature] = initial_entropy - final_entropy\\n return infogain\",\n \"def dcgain(sys):\\n return sys.dcgain()\",\n \"def gain(self, target_attr, attr, debug=False):\\n current_entropy = self.entropy(target_attr)[0]\\n # print\\n # print attr\\n\\n gain = current_entropy - self.remainder(target_attr=target_attr, attr=attr)\\n if debug is True:\\n print attr, \\\": \\\", gain\\n return gain\",\n \"def gain(Y, X):\\n return entropy(Y) - cEntropy(Y,X)\",\n \"def gain(self) -> int:\\n return self._gain\",\n \"def get_info_gain(true_rows, false_rows, current_impurity):\\n avg_impurity = (len(true_rows)/(len(true_rows)+len(false_rows))) * get_gini(true_rows) + \\\\\\n (len(false_rows)/(len(true_rows)+len(false_rows))) * get_gini(false_rows)\\n return current_impurity - avg_impurity\",\n \"def information_gain(Y, attr):\\n initial_gain = entropy(Y)\\n\\n temp_Y = Y.tolist()\\n temp_attr = attr.tolist()\\n\\n temp_attr = list(np.unique(attr))\\n\\n for a in temp_attr:\\n l = []\\n count = 0\\n for j in attr:\\n if (j == a):\\n l.append(temp_Y[count])\\n count+=1\\n initial_gain -= ((len(l) / len(temp_Y)) * entropy(pd.Series(l)))\\n return initial_gain\",\n \"def _calc(self):\\r\\n tot_sum: float = 0 # ? total sum of the noise values\\r\\n max_amp: float = 0 # ? keep the sum in [0,1]\\r\\n amp: float = 1.0 # ? amplitude of each noise value\\r\\n freq: float = 1.0 # ? frequency for getting the detailed noise\\r\\n\\r\\n # for each octave we twice the frequency and multiply the amplitude \\r\\n # by persistance to get the detailed noise value\\r\\n # to keep the final sum value in the range [0, 1] we keep track of the \\r\\n # max amplitude (sum of all the amplitudes)\\r\\n for octave in range(self.octaves):\\r\\n noise_obj = PerlinNoise(self.inp_x*freq, self.inp_y*freq, self.inp_z*freq)\\r\\n # ? multiply the noise value by the amplitude\\r\\n tot_sum += noise_obj.val() * amp\\r\\n max_amp += amp\\r\\n\\r\\n amp *= self.persist\\r\\n freq *= 2.0 # double the freq each iteration\\r\\n\\r\\n # value is in the range [0,1]\\r\\n self.value = tot_sum / max_amp\",\n \"def vga_gain(self):\\n return float(self._read(0x15, 4, 0x70) + 8)\",\n \"def estimateInfo(Analysis, ImageData, diffract, print_opt=False): \\n total_images = ImageData['totalImages'] \\n\\n for key in Analysis:\\n Analysis[key]['cones'] = [1,2,3,4,5,6]\\n Analysis[key]['info'] = np.zeros(len(\\n Analysis[key]['cones']))\\n\\n for amp in ImageData['rawAmp']:\\n\\n for key in Analysis:\\n ind = len(diffract['cpd'])\\n fooInfo = info.SingleConeEntropyFunc((amp[ind] ** 2 *\\n Analysis[key]['retina']), \\n Analysis[key]['cones']) \\n Analysis[key]['info'] += fooInfo / total_images\\n\\n if print_opt == True:\\n print ' '\\n print 'Information'\\n print '------------'\\n for key in Analysis:\\n print key, ': ', Analysis[key]['info']\\n\\n return Analysis\",\n \"def get_gain(self, *args):\\n return _uhd_swig.usrp_sink_sptr_get_gain(self, *args)\",\n \"def dcgain(self):\\n raise NotImplementedError(\\\"dcgain not implemented for %s objects\\\" %\\n str(self.__class__))\",\n \"def get_gain(self, *args):\\n return _uhd_swig.usrp_sink_get_gain(self, *args)\",\n \"def calculate_gains(self,data, map_fits, avg_map_fits):\\n nFeeds,nBands,nChans,nParams = map_fits['Values'].shape\\n frequencies = data[f'{self.level2}/averaged_frequency'][...]\\n kb = 1.38064852e-23\\n c = 2.99792458e8\\n scale = 2 * kb * (1e9/ c)**2 * 1e26\\n\\n source = self.getSource(data)\\n self.flux = np.zeros((len(self.feeds),nBands, nChans))\\n self.gain = np.zeros((len(self.feeds),nBands, nChans))\\n\\n for i,(ifeed,feed) in enumerate(zip(self.feedlist,self.feeds)):\\n for iband in range(nBands):\\n nu = frequencies[iband]\\n sigx = avg_map_fits[iband]['Values'][2] \\n sigy = avg_map_fits[iband]['Values'][2]*avg_map_fits[iband]['Values'][4]\\n amps = map_fits['Values'][i,iband,:,0]\\n self.flux[i,iband,:] = 2*np.pi*amps*sigx*sigy*(np.pi/180.)**2 * scale*nu**2\\n mdl_flux = self.models[source](nu,map_fits['MJD'],return_jansky=True,allpos=True)\\n self.gain[i,iband,:] = self.flux[i,iband,:]/mdl_flux\\n\\n return self.flux, self.gain\",\n \"def informationGain(data, class_label, attribute, indices=None):\\n\\tsubset = data[:] if indices == None else data.loc[indices]\\n\\t\\n\\tsublist = subset[attribute].tolist()\\n\\tvalues = list(set(sublist))\\n\\tinfoGain = entropyOnSubset(subset, class_label)\\n\\t\\n\\t#print (sublist)\\n\\t\\n\\tfor i in values:\\n\\t\\tindex = list(subset.index[subset[attribute] == i])\\n\\t\\tinfoGain -= sublist.count(i)/len(sublist) * entropyOnSubset(subset, class_label, index)\\n\\n\\t\\n\\treturn infoGain\",\n \"def feedback_gain(self):\\n return self._feedback_gain\",\n \"def __calc_info_gain(self, parent, left_child, right_child):\\n parent_entropy = self.__entropy(parent[:, -1])\\n\\n num_rows_left = left_child.shape[0]\\n num_rows_right = right_child.shape[0]\\n num_rows_total = num_rows_left + num_rows_right\\n\\n # don't calculate if any of the children rows are empty\\n if num_rows_left == 0 or num_rows_right == 0:\\n return 0\\n\\n # calculate entropy of the children data\\n left_child_entropy = self.__entropy(left_child[:, -1])\\n right_child_entropy = self.__entropy(right_child[:, -1])\\n left_child_contribution = (num_rows_left/num_rows_total)*left_child_entropy\\n right_child_contribution = (num_rows_right/num_rows_total)*right_child_entropy\\n new_entropy = left_child_contribution + right_child_contribution\\n\\n info_gain = parent_entropy - new_entropy\\n return info_gain\",\n \"def info_gain_ratio(Ex, a, nan=True):\\n # Check whether examples and attributes have the same lengths.\\n if len(Ex) != len(a):\\n raise ValueError(\\\"Ex and a must be of the same size.\\\")\\n\\n # Compute information gain ratio as IG/IV\\n return info_gain(Ex, a, nan) / intrinsic_value(Ex, a, nan)\",\n \"def EM_gain(self):\\n gain = ct.c_int()\\n self.lib.GetEMCCDGain(ct.pointer(gain))\\n\\n return gain.value\",\n \"def get_gain(self, *args):\\n return _uhd_swig.usrp_source_get_gain(self, *args)\",\n \"def get_gain(self, *args):\\n return _uhd_swig.usrp_source_sptr_get_gain(self, *args)\",\n \"def calc_gain(s, i):\\n return math.sqrt((i + s) / (6 * s))\",\n \"def __call__(cls, image):\\n\\n logger.info('Gain Correcting Image')\\n\\n saturate = 0.\\n gains = []\\n for amp in decaminfo.amps:\\n sec = section2slice(image['DATASEC' + amp])\\n gain = image['GAIN' + amp]\\n gains.append(gain)\\n image.data[sec] *= gain\\n\\n # Adjust the weight or variance image if present:\\n if image.weight is not None:\\n image.weight[sec] *= 1. / (gain * gain)\\n if image.variance is not None:\\n image.variance[sec] *= gain * gain\\n\\n # Adjust keywords\\n image['GAIN' + amp] = image['GAIN' + amp] / gain\\n image['SATURAT' + amp] = image['SATURAT' + amp] * gain\\n saturate = max(saturate, image['SATURAT' + amp])\\n # Scale the SKYVAR if it's already here\\n kw = 'SKYVAR' + amp\\n if kw in image.header.keys():\\n image[kw] = image[kw] * gain * gain\\n # The FLATMED will keep track of rescalings *after* gain:\\n image['FLATMED' + amp] = 1.\\n\\n # The SATURATE keyword is assigned to maximum of the two amps.\\n image['SATURATE'] = saturate\\n\\n # Some other keywords that we will adjust crudely with mean gain\\n # if they are present:\\n gain = np.mean(gains)\\n for kw in ('SKYBRITE', 'SKYSIGMA'):\\n if kw in image.header.keys():\\n image[kw] = image[kw] * gain\\n\\n # One other keyword to adjust:\\n image['BUNIT'] = 'electrons'\\n\\n logger.debug('Finished applying Gain Correction')\\n ret_code = 0\\n return ret_code\",\n \"def lms_gain(self):\\n return self._lms_gain\",\n \"def zenith_gain(freq):\\n parfile = open(project_path\\n + \\\"DSS-28_technical/efficiency_vs_freq_pars.pkl\\\",\\\"r\\\")\\n pars = cPickle.load(parfile)\\n parfile.close()\\n effic = {}\\n avg_effic = 0\\n for key in list(pars.keys()):\\n effic[key] = pars[key](freq)/100.\\n avg_effic += effic[key]\\n # right now I don't know what Pol A and Pol B are\\n avg_effic /= len(list(pars.keys()))\\n return avg_effic\",\n \"def dbgain(self, pt_1, pt_2):\\n raise NotImplementedError\",\n \"def get_gains(self):\\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x8000+i,0)/100 for i in range(4)])\",\n \"def calcInfoGainBySplitValue(self, data, structure, colName, splitVal):\\n result = self.calcDataEntropy(data, structure) - self.calcEntropyBySplitValue(data, structure, colName, splitVal)\\n result = 0 if result < 0 else result\\n return round(result, 3)\",\n \"def internal_heat_gain(dwelling):\\n losses_gain = -40 * dwelling.Nocc\\n water_heating_gains = (1000. / 24.) * dwelling.heat_gains_from_hw / DAYS_PER_MONTH\\n\\n mean_appliance_energy = 207.8 * (dwelling.GFA * dwelling.Nocc) ** 0.4714\\n appliance_consumption_per_day = (mean_appliance_energy / 365.) * (\\n 1 + 0.157 * numpy.cos((2. * math.pi / 12.) * (numpy.arange(12) - .78)))\\n\\n appliance_consumption = appliance_consumption_per_day * DAYS_PER_MONTH\\n\\n if dwelling.reduced_gains:\\n met_gain = 50 * dwelling.Nocc\\n cooking_gain = 23 + 5 * dwelling.Nocc\\n appliance_gain = (0.67 * 1000. / 24) * appliance_consumption_per_day\\n light_gain = 0.4 * dwelling.full_light_gain\\n else:\\n met_gain = 60 * dwelling.Nocc\\n cooking_gain = 35 + 7 * dwelling.Nocc\\n appliance_gain = (1000. / 24) * appliance_consumption_per_day\\n light_gain = dwelling.full_light_gain\\n\\n total_internal_gains = (met_gain\\n + light_gain\\n + appliance_gain\\n + cooking_gain\\n + water_heating_gains\\n + dwelling.pump_gain\\n + losses_gain)\\n\\n if dwelling.reduced_gains:\\n summer_met_gain = 60 * dwelling.Nocc\\n summer_cooking_gain = 35 + 7 * dwelling.Nocc\\n summer_appliance_gain = (1000. / 24) * appliance_consumption_per_day\\n summer_light_gain = dwelling.full_light_gain\\n total_internal_gains_summer = (summer_met_gain +\\n water_heating_gains +\\n summer_light_gain +\\n summer_appliance_gain +\\n summer_cooking_gain +\\n dwelling.pump_gain +\\n losses_gain\\n - dwelling.heating_system_pump_gain)\\n else:\\n total_internal_gains_summer = total_internal_gains - dwelling.heating_system_pump_gain\\n\\n # Apply results to dwelling\\n return dict(appliance_consumption=appliance_consumption,\\n met_gain=met_gain,\\n cooking_gain=cooking_gain,\\n appliance_gain=appliance_gain,\\n light_gain=light_gain,\\n water_heating_gains=water_heating_gains,\\n losses_gain=losses_gain,\\n total_internal_gains=total_internal_gains,\\n total_internal_gains_summer=total_internal_gains_summer)\",\n \"def calculateDataRate(self):\\n pass\",\n \"def calculate(self) -> float:\",\n \"def calc(self,index,counter_values):\\n gr = self.grSign * self.grPitch['Value'].value\\n m = self.mSign * self.mPitch['Value'].value\\n \\n offsetG,offsetM = self.checkOffset()\\n beta = self.toRadians(gr) - (math.pi/2.0) - offsetG\\n theta = (math.pi/2.0) - (self.toRadians(m)) - offsetM\\n alpha = (2.0*theta) + beta\\n numerator = (math.sin(alpha) + math.sin(beta))\\n denominator = (self.DiffrOrder * self.look_at_grx())\\n wavelength = numerator / denominator\\n \\n if wavelength == 0.0:\\n energy_physicalmot = 0.0\\n else:\\n energy_physicalmot = self.hc / wavelength\\n #if self.FixedM2Pit: \\n Cff = math.cos(beta)/math.cos(alpha)\\n if energy_physicalmot < 0 :\\n #warning: wavelength se vuelve negativo ... ??????\\n energy_physicalmot = energy_physicalmot *(-1) \\n \\n # Real Energy is equal to the energy calculated by the encoders\\n # minus an offset that depends on the same energy calculated by the \\n # encoders:\\n # E_physicalmot = Ereal + offset\\n # with offset = a*Ereal + b\\n # This implies that: Ereal = (Ephysicalmot - b)/(1+a) \\n a_coeff = self.EnergyDP.a_offset_coeff\\n b_coeff = self.EnergyDP.b_offset_coeff\\n numerator = energy_physicalmot - b_coeff\\n denominator = 1 + a_coeff\\n energy = numerator / denominator\\n \\n if index == 1:\\n return energy\\n elif index == 2:\\n return Cff\",\n \"def showAverageGainWon(self) :\\n averageGainWon = 0\\n for level in self.level_history :\\n averageGainWon += level.profit\\n averageGainWon = averageGainWon/len(self.level_history)\\n Scenario.messageGetAverageGainWon(averageGainWon)\",\n \"def su_calculation(f1, f2):\\n # calculate information gain of f1 and f2, t1 = ig(f1, f2)\\n t1 = information_gain(f1, f2)\\n # calculate entropy of f1\\n t2 = ee.entropyd(f1)\\n # calculate entropy of f2\\n t3 = ee.entropyd(f2)\\n\\n su = 2.0 * t1 / (t2 + t3)\\n\\n return su\",\n \"def calibration(self) -> int:\",\n \"def info_gain(Ex, a, nan=True):\\n # Check whether examples and attributes have the same lengths.\\n if len(Ex) != len(a):\\n raise ValueError(\\\"Ex and a must be of the same size.\\\")\\n\\n # Compute the entropy of examples\\n H_Ex = entropy(list(Counter(Ex).values()))\\n\\n # If nan is True, replace all nan values in a by the string \\\"__nan__\\\"\\n if nan:\\n a = ['__nan__' if isinstance(x, float) and math.isnan(x) else x for x in a]\\n \\n # Compute the sum of all values v in a\\n sum_v = 0\\n for v in set(a):\\n Ex_a_v = [x for x, t in zip(Ex, a) if t == v]\\n sum_v += (len(Ex_a_v) / len(Ex)) *\\\\\\n (entropy(list(Counter(Ex_a_v).values())))\\n\\n # Return result\\n return H_Ex - sum_v\",\n \"def get_mod_gain_val(self):\\n return self.mod_gain_table[self.tx_pwr_dbm];\",\n \"def get_gain(self):\\n gain = float(self._driver.Gain.Value)\\n return gain\",\n \"def calculate_gain_table(info_table):\\n\\n\\t# sort and separate\\n\\tinfo_table['decile'] = 10 - pd.qcut(info_table['proba'], 10, labels = False)\\n\\n\\t# group by each decile, calculate gain score\\n\\ttotal_positive = sum(info_table['target'])\\n\\tgain_table = info_table.groupby('decile', as_index = False)['target'].sum()\\n\\tgain_table = gain_table.rename(columns = {'target': 'positive'})\\n\\tgain_table['gain_score'] = gain_table['positive'] / total_positive\\n\\n\\t# gain = cumsum(gain score)\\n\\tgain_table['gain'] = gain_table['gain_score'].cumsum()\\n\\n\\treturn gain_table\",\n \"def strength(self) -> float:\\n ...\",\n \"def compute_gains(self, t, add_noise=True):\\n #get the basis funtion at a time step\\n basis, Dbasis = self.get_basis(t)\\n\\n if t < self._time_steps-1:\\n basis_t_dt, _ = self.get_basis(t+1)\\n else:\\n basis_t_dt = np.zeros_like(basis)\\n\\n\\n #part 1 equation 46\\n B_pseudo = np.linalg.pinv(self._B)\\n\\n #equation 12 for t\\n Sigma_t = np.dot(np.dot(basis, self._sigma_W), basis.T)\\n\\n #equation 12 for t+dt\\n Sigma_t_dt = np.dot(np.dot(basis_t_dt, self._sigma_W), basis_t_dt.T)\\n\\n #Cross correlation between t, t+dt, Equation 49\\n Ct = np.dot(np.dot(basis, self._sigma_W), basis_t_dt.T)\\n\\n #System noise Equation 51\\n Sigma_s = (1./self._dt)* ( Sigma_t_dt - np.dot( np.dot( Ct.T, np.linalg.inv(Sigma_t) ), Ct) )\\n\\n #control noise Equation 52\\n Sigma_u = np.dot(np.dot(B_pseudo, Sigma_s), B_pseudo.T)\\n\\n #part 2 equation 46\\n tmp1 = np.dot(np.dot(Dbasis, self._sigma_W), basis.T)\\n\\n #part 3 equation 46\\n tmp2 = np.dot(self._A, Sigma_t) + 0.5*Sigma_s\\n\\n #compute feedback gain; complete equation 46\\n K = np.dot( np.dot(B_pseudo, (tmp1-tmp2) ), np.linalg.inv(Sigma_t))\\n\\n #part 1 equation 48\\n tmp3 = np.dot(Dbasis, self._mean_W)\\n\\n #part 2 equation 48\\n tmp4 = np.dot( (self._A + np.dot(self._B, K)), np.dot(basis, self._mean_W) )\\n\\n #compute feedforward gain; complete equation 48\\n k = np.dot(B_pseudo, (tmp3-tmp4))\\n\\n return K, k, Sigma_u\",\n \"def _adsc_module_gain(self, model=None):\\n\\n if model is None:\\n sn = int(self._header_dictionary[\\\"DETECTOR_SN\\\"])\\n model = self._sn_to_model.get(sn)\\n return super()._adsc_module_gain(model=model)\",\n \"def _measurement_update(self, y_i, h_tilde, pert_m, k_gain, cov_m):\\n innovation = np.subtract(np.transpose(y_i),\\n np.matmul(h_tilde, pert_m))\\n pert_p = np.add(pert_m, np.matmul(k_gain, innovation))\\n\\n L = np.subtract(np.identity(len(self.istate)),\\n np.matmul(k_gain, h_tilde))\\n\\n cov_p = np.matmul(L, cov_m)\\n\\n return (cov_p, pert_p)\",\n \"def servo_gainupdate(self, *args, **kwargs) -> Any:\\n pass\",\n \"def calcInfoGainByColumnSplit(self, data, structure, colName):\\n result = self.calcDataEntropy(data, structure) - self.calcEntropyByColumnSplit(data, structure, colName)\\n result = 0 if result < 0 else result\\n return round(result, 3)\",\n \"def advancedStats():\",\n \"def obtain_data(self):\\n ##MODIFY THIS\\n #ipdb.set_trace()\\n print('obtain_data')\\n print(self.enabler)\\n print(self.index)\\n helper = '>'+str(1+int(self.chann_span.get()))+'Q'\\n print('helper='+helper)\\n while(self.enabler):\\n #print('size'+str(1+int(self.chann_span.get())))\\n #print('offset'+str(self.index-self.index_offset))\\n A2 = struct.unpack(helper, fpga.read('A2', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8))) \\n #print(A2)\\n #print(str(10*np.log10(A2))+'dB')\\n self.amp_a2[0] = np.mean(A2)\\n self.amp_a2 = np.roll(self.amp_a2, -1)\\n B2 = struct.unpack(helper, fpga.read('B2', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\\n self.amp_b2[0] = np.mean(B2)\\n self.amp_b2 = np.roll(self.amp_b2, -1)\\n AB_re = struct.unpack(helper, fpga.read('AB_re', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\\n self.ab_re[0] = np.mean(AB_re)\\n self.ab_re = np.roll(self.ab_re, -1)\\n AB_im = struct.unpack(helper, fpga.read('AB_im', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\\n self.ab_im[0] = np.mean(AB_im)\\n self.ab_im = np.roll(self.ab_im, -1) \\n # print('RE:' + str(self.ab_re)+ '\\\\t IM:' +str(self.ab_im))\\n log_a = 10*np.log10(np.mean(self.amp_a2)+1.0)\\n log_b = 10*np.log10(np.mean(self.amp_b2)+1.0) \\n ang = np.rad2deg(np.arctan2(np.mean(self.ab_im), np.mean(self.ab_re))) #review the way of avg this... i dont know if its the most correct way to do it...\\n self.a2.set(log_a)\\n self.b2.set(log_b)\\n self.ang.set(ang)\\n self.amp_rel.set(log_a-log_b)\\n return 1\",\n \"def mutual_information(x, y, w):\\r\\n \\r\\n\\r\\n total_entropy = entropy(y,w)\\r\\n\\r\\n partitioned_x = partition(x)\\r\\n weighted_entropy = 0\\r\\n # calculate the weighted entropy over the partition of x\\r\\n vals,counts= np.unique(x,return_counts=True)\\r\\n for key in partitioned_x:\\r\\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\\r\\n\\r\\n information_gain = total_entropy - weighted_entropy\\r\\n return information_gain\",\n \"def measure(self, imgage, previous=None):\",\n \"def calculate(self):\",\n \"def gain(self):\\r\\n \\r\\n for node in self.G.nodes():\\r\\n # Get number of nodes connected on same and other partition\\r\\n movForce, retForce = self.nodeForces(node)\\r\\n nodeGain = movForce-retForce\\r\\n\\r\\n #Fill list of Nodes with gains\\r\\n self.gainOrder.append((nodeGain,node))\\r\\n \\r\\n self.gainOrder.sort(key=lambda r: r[0])\\r\\n self.keys = [r[1] for r in self.gainOrder]\",\n \"def ComputeEnergyConsumption(self):\\r\\n pass\",\n \"def calculate_output(self):\",\n \"def coefficient(self) -> float:\\n ...\",\n \"def gradient_descent_gain(self):\\n return self._gradient_descent_gain\",\n \"def dB2gain(dB):\\n V = math.exp(dB/20)\\n return V\",\n \"def calc_q_gain(Tfl, Tabs, q_rad_Whperm2, DT, Tin, Tout, aperture_area_m2, c1, c2, Mfl, delts, Cp_waterglycol, C_eff, Te):\\n\\n xgain = 1\\n xgainmax = 100\\n exit = False\\n while exit == False:\\n qgain_Whperm2 = q_rad_Whperm2 - c1 * (DT[1]) - c2 * abs(DT[1]) * DT[1] # heat production from solar collector, eq.(5)\\n\\n if Mfl > 0:\\n Tout = ((Mfl * Cp_waterglycol * Tin) / aperture_area_m2 - (C_eff * Tin) / (2 * delts) + qgain_Whperm2 + (\\n C_eff * Tfl[1]) / delts) / (Mfl * Cp_waterglycol / aperture_area_m2 + C_eff / (2 * delts)) # eq.(6)\\n Tfl[2] = (Tin + Tout) / 2\\n DT[2] = Tfl[2] - Te\\n qdiff = Mfl / aperture_area_m2 * Cp_waterglycol * 2 * (DT[2] - DT[1])\\n else:\\n Tout = Tfl[1] + (qgain_Whperm2 * delts) / C_eff # eq.(8)\\n Tfl[2] = Tout\\n DT[2] = Tfl[2] - Te\\n qdiff = 5 * (DT[2] - DT[1])\\n\\n if abs(qdiff < 0.1):\\n DT[1] = DT[2]\\n exit = True\\n else:\\n if xgain > 40:\\n DT[1] = (DT[1] + DT[2]) / 2\\n if xgain == xgainmax:\\n exit = True\\n else:\\n DT[1] = DT[2]\\n xgain += 1\\n\\n # FIXME: redundant...\\n # qout = Mfl * Cp_waterglycol * (Tout - Tin) / aperture_area\\n # qmtherm = (Tfl[2] - Tfl[1]) * C_eff / delts\\n # qbal = qgain - qout - qmtherm\\n # if abs(qbal) > 1:\\n # qbal = qbal\\n return qgain_Whperm2\",\n \"def compute_kalman_gain(jacobian, oldCovariance, measurementCovariance):\\n\\n return None\",\n \"def calc_states_info_gain(A, qs_pi):\\n\\n n_steps = len(qs_pi)\\n\\n states_surprise = 0\\n for t in range(n_steps):\\n states_surprise += spm_MDP_G(A, qs_pi[t])\\n\\n return states_surprise\",\n \"def gain2dB(gain):\\n dB = 20*math.log(gain)\\n return dB\",\n \"def compute_gain(loudness, renormalize_loudness):\\n gain = []\\n for i in range(len(loudness)):\\n delta_loudness = renormalize_loudness[i] - loudness[i]\\n gain.append(np.power(10.0, delta_loudness / 20.0))\\n return gain\",\n \"def get_mod_gain_output(self, mod_gain_input):\\n\\n output = ((( (mod_gain_input*self.tx_rate_decim_dict[self.dec_filt_rate]) & 0x7FFFFF) >> 11)*\\\\\\n (self.mod_gain_table[self.tx_pwr_dbm])) >> 11\\n return output\",\n \"def compute_gain( hv, cv, thot, tcold):\\n\\n nData = len(cv) \\n epsilons = np.full( nData, EPSILON)\\n\\n # For full Temp calibration, a spectrum taken at high elevation, away from \\n # The galactic plan is used.\\n dv = hv - cv \\n dv = np.maximum( dv, epsilons)\\n hv = np.maximum( hv, epsilons)\\n\\n # use the comparison of hot and cold to get gain without trx contribution\\n gain = (thot - tcold)/dv\\n\\n trx = gain*cv \\n trx = trx - tcold # correct for cold load input in counts\\n\\n n6 = int(nData/6)\\n n56 = 5*n6\\n\\n trxmedian = np.median( trx[n6:n56])\\n gain = (thot + trxmedian)/hv\\n \\n return trxmedian, gain # channel by channel gain in K/counts\",\n \"def tGain(self, dt, r):\\n\\t return 1./(10.**6)*r#*precip.r\",\n \"def microphone_sensitivity(transferfactor: float) -> float:\\n return amp2db(transferfactor/1000.)\",\n \"def intensity(self) -> int:\",\n \"def test_information_gain(self):\\n self.decision_tree.train(self.data,\\n list(range(self.data.num_samples)),\\n max_depth=1,\\n min_samples_per_node=1,\\n use_stop_conditions=False,\\n max_p_value_chi_sq=None)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 1)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\\n [set([0]), set([1]), set([2])])\\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\\n {0:0, 1:1, 2:2})\\n self.assertAlmostEqual(self.decision_tree.get_root_node().node_split.criterion_value,\\n 2. * -0.3 * math.log2(0.3) - 0.4 * math.log2(0.4))\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n n = self.confusion_matrix.n\\n\\n fn_tp = fn + tp\\n fp_tp = fp + tp\\n\\n h1 = -((fn_tp / n) * math.log2(fn_tp / n) +\\n (1 - fn_tp / n) * math.log2(1 - fn_tp / n))\\n\\n h2 = -((fp_tp / n) * math.log2(fp_tp / n) +\\n (1 - fp_tp / n) * math.log2(1 - fp_tp / n))\\n\\n p00 = 1 if tn == 0 else (tn / n)\\n p01 = 1 if fn == 0 else (fn / n)\\n p10 = 1 if fp == 0 else (fp / n)\\n p11 = 1 if tp == 0 else (tp / n)\\n\\n h12 = -((tn / n) * math.log2(p00) +\\n (fn / n) * math.log2(p01) +\\n (fp / n) * math.log2(p10) +\\n (tp / n) * math.log2(p11))\\n\\n mi = h1 + h2 - h12\\n\\n vi = h1 + h2 - 2 * mi\\n return vi\",\n \"def get_gain(self, channel_data):\\n values = getattr(channel_data, self.field, None)\\n if values is None:\\n raise ValueError(f\\\"Channel group {channel_data} does not contain \\\"\\n f\\\"{self.field} field.\\\")\\n return values.astype(float)\",\n \"def compute_gain_readnoise(flat1, flat2, zero1, zero2, section=\\\"[*,*]\\\"):\\r\\n\\r\\n iraf.noao(_doprint=0)\\r\\n iraf.obsutil(_doprint=0)\\r\\n iraf.imarith(flat1, '-', flat2, 'flatdif')\\r\\n iraf.imarith(zero1, '-', zero2, 'zerodif')\\r\\n s = iraf.imstat('%s%s' % (flat1, section), fields=\\\"mean\\\", nclip=20, \\r\\n Stdout=1, format=\\\"no\\\")\\r\\n mean_flat1 = np.float(s[0])\\r\\n s = iraf.imstat('%s%s' % (flat2, section), fields=\\\"mean\\\", nclip=20, \\r\\n Stdout=1, format=\\\"no\\\")\\r\\n mean_flat2 = np.float(s[0])\\r\\n s = iraf.imstat('%s%s' % (zero1, section), fields=\\\"mean\\\", nclip=20, \\r\\n Stdout=1, format=\\\"no\\\")\\r\\n mean_zero1 = np.float(s[0])\\r\\n s = iraf.imstat('%s%s' % (zero2, section), fields=\\\"mean\\\", nclip=20, \\r\\n Stdout=1, format=\\\"no\\\")\\r\\n mean_zero2 = np.float(s[0])\\r\\n s = iraf.imstat('%s%s' % ('flatdif', section), fields=\\\"stddev\\\", nclip=20, \\r\\n Stdout=1, format=\\\"no\\\")\\r\\n sigma_flatdif = np.float(s[0])\\r\\n s = iraf.imstat('%s%s' % ('zerodif', section), fields=\\\"stddev\\\", nclip=20, \\r\\n Stdout=1, format=\\\"no\\\")\\r\\n sigma_zerodif = np.float(s[0])\\r\\n gain = (((mean_flat1 + mean_flat2) - (mean_zero1 + mean_zero2)) / \\r\\n ((sigma_flatdif)**2 - (sigma_zerodif)**2))\\r\\n readnoise = gain * sigma_zerodif / np.sqrt(2)\\r\\n iraf.delete('flatdif.fits', verify=\\\"no\\\")\\r\\n iraf.delete('zerodif.fits', verify=\\\"no\\\")\\r\\n return gain, readnoise\",\n \"def compute_information_gain(Y, xi):\\r\\n H_Y = H(Y)\\r\\n\\r\\n TrainSet = np.delete(AllSets[2], -1, axis=1)\\r\\n ColumnInd = AllSets[3].index(xi) # extract from dictionary\\r\\n\\r\\n NumHeadlines = AllSets[2].shape[0]\\r\\n AllOccurences, Count = np.unique(AllSets[2][:, ColumnInd], return_counts=True)\\r\\n\\r\\n TotalH_YGivenX = 0\\r\\n for i, count in zip(AllOccurences, Count):\\r\\n NewY = Y[TrainSet[:, ColumnInd] == i]\\r\\n\\r\\n TotalH_YGivenX += H(NewY) * float(count) / NumHeadlines\\r\\n\\r\\n return H_Y - TotalH_YGivenX\",\n \"def _information_gain(self, y, X_column, split_thersh):\\n # parent E\\n parent_entropy = entropy(y)\\n # generate split\\n left_idxs, right_idxs = self._split(X_column, split_thersh)\\n\\n if len(left_idxs) == 0 or len(right_idxs) == 0:\\n return 0\\n # weighted avg child E\\n n = len(y)\\n n_left_samples, n_right_samples = len(left_idxs), len(right_idxs)\\n entropy_left, entropy_right = entropy(y[left_idxs]), entropy(y[right_idxs])\\n child_entropy = (n_left_samples/n) * entropy_left + (n_right_samples/n) * entropy_right\\n\\n # return IG\\n ig = parent_entropy - child_entropy\\n return ig\",\n \"def calculate(self):\\n\\n sensitivity = self.confusion_matrix.tp / (self.confusion_matrix.tp + self.confusion_matrix.fn)\\n return 1 - sensitivity\",\n \"def _calculate_feedback(self):\\r\\n age = self.age_field.value()\\r\\n height_cm = self.height_field.value()\\r\\n weight_kg = self.weight_field.value()\\r\\n body_fat = self.bodyFat_field.value()\\r\\n male = bool(self.gender_combobox.currentIndex())\\r\\n\\r\\n if self._mode != 'metric':\\r\\n height_cm *= 2.54\\r\\n weight_kg *= 0.454\\r\\n\\r\\n document = getWeightLogDocument(height_cm, weight_kg, age, body_fat, male, None, 1.2)\\r\\n self.feedback_field.setHtml(document)\",\n \"def calc_pB_info_gain(pB, qs_pi, qs_prev, policy):\\n\\n n_steps = len(qs_pi)\\n\\n num_factors = len(pB)\\n wB = utils.obj_array(num_factors)\\n for factor, pB_f in enumerate(pB):\\n wB[factor] = spm_wnorm(pB_f)\\n\\n pB_infogain = 0\\n\\n for t in range(n_steps):\\n # the 'past posterior' used for the information gain about pB here is the posterior\\n # over expected states at the timestep previous to the one under consideration\\n # if we're on the first timestep, we just use the latest posterior in the\\n # entire action-perception cycle as the previous posterior\\n if t == 0:\\n previous_qs = qs_prev\\n # otherwise, we use the expected states for the timestep previous to the timestep under consideration\\n else:\\n previous_qs = qs_pi[t - 1]\\n\\n # get the list of action-indices for the current timestep\\n policy_t = policy[t, :]\\n for factor, a_i in enumerate(policy_t):\\n wB_factor_t = wB[factor][:, :, int(a_i)] * (pB[factor][:, :, int(a_i)] > 0).astype(\\\"float\\\")\\n pB_infogain -= qs_pi[t][factor].dot(wB_factor_t.dot(previous_qs[factor]))\\n\\n return pB_infogain\",\n \"def weight(self):\",\n \"def information_content(self):\\n ic = 0\\n for row in self.pwm:\\n ic += 2.0 + np.sum([row[x] * log(row[x])/log(2) for x in range(4) if row[x] > 0])\\n return ic\",\n \"def feedforward_1st_gain(self):\\n return self._read(MX_FEEDFORWARD_1ST_GAIN)\",\n \"def cost(self) -> float:\",\n \"def get_a(self):\\n return 0.5*-G*self._mm*self._sm/self.geten()\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n n = self.confusion_matrix.n\\n\\n fn_tp = fn + tp\\n fp_tp = fp + tp\\n\\n h1 = -((fn_tp / n) * math.log2(fn_tp / n) +\\n (1 - fn_tp / n) * math.log2(1 - fn_tp / n))\\n\\n h2 = -((fp_tp / n) * math.log2(fp_tp / n) +\\n (1 - fp_tp / n) * math.log2(1 - fp_tp / n))\\n\\n p00 = 1 if tn == 0 else (tn / n)\\n p01 = 1 if fn == 0 else (fn / n)\\n p10 = 1 if fp == 0 else (fp / n)\\n p11 = 1 if tp == 0 else (tp / n)\\n\\n h12 = -((tn / n) * math.log2(p00) +\\n (fn / n) * math.log2(p01) +\\n (fp / n) * math.log2(p10) +\\n (tp / n) * math.log2(p11))\\n\\n mi = h1 + h2 - h12\\n return mi\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71510774","0.7104761","0.7051002","0.70116246","0.70019746","0.6977662","0.6969875","0.6891857","0.6791996","0.6740312","0.6715083","0.66847247","0.6643833","0.661401","0.6557161","0.65524924","0.652679","0.65203816","0.64868385","0.64760065","0.64751744","0.6411805","0.6381089","0.6372968","0.6334193","0.62599367","0.6243074","0.62266153","0.62119293","0.61915153","0.6188294","0.6187531","0.6160368","0.6144146","0.6135364","0.61105305","0.61037135","0.6098024","0.60875136","0.6078199","0.6070509","0.6056658","0.60344106","0.6027446","0.60267687","0.60220236","0.6014023","0.5998644","0.5962357","0.5958971","0.59088933","0.590171","0.5900548","0.5889058","0.5883074","0.5883048","0.5881294","0.58740795","0.5868461","0.58682525","0.58439165","0.58354056","0.5828276","0.58133125","0.58090156","0.5787748","0.57787144","0.57746345","0.5770449","0.5770011","0.57592416","0.574673","0.5744973","0.5738498","0.5738324","0.57287157","0.5726526","0.5722274","0.5710825","0.5707041","0.5704982","0.5696327","0.56934065","0.56876993","0.5686261","0.56841445","0.5669096","0.5663755","0.5656253","0.5654044","0.5653401","0.56387454","0.56338125","0.5627769","0.56266993","0.56217307","0.5620524","0.56178886","0.56039286","0.56038195"],"string":"[\n \"0.71510774\",\n \"0.7104761\",\n \"0.7051002\",\n \"0.70116246\",\n \"0.70019746\",\n \"0.6977662\",\n \"0.6969875\",\n \"0.6891857\",\n \"0.6791996\",\n \"0.6740312\",\n \"0.6715083\",\n \"0.66847247\",\n \"0.6643833\",\n \"0.661401\",\n \"0.6557161\",\n \"0.65524924\",\n \"0.652679\",\n \"0.65203816\",\n \"0.64868385\",\n \"0.64760065\",\n \"0.64751744\",\n \"0.6411805\",\n \"0.6381089\",\n \"0.6372968\",\n \"0.6334193\",\n \"0.62599367\",\n \"0.6243074\",\n \"0.62266153\",\n \"0.62119293\",\n \"0.61915153\",\n \"0.6188294\",\n \"0.6187531\",\n \"0.6160368\",\n \"0.6144146\",\n \"0.6135364\",\n \"0.61105305\",\n \"0.61037135\",\n \"0.6098024\",\n \"0.60875136\",\n \"0.6078199\",\n \"0.6070509\",\n \"0.6056658\",\n \"0.60344106\",\n \"0.6027446\",\n \"0.60267687\",\n \"0.60220236\",\n \"0.6014023\",\n \"0.5998644\",\n \"0.5962357\",\n \"0.5958971\",\n \"0.59088933\",\n \"0.590171\",\n \"0.5900548\",\n \"0.5889058\",\n \"0.5883074\",\n \"0.5883048\",\n \"0.5881294\",\n \"0.58740795\",\n \"0.5868461\",\n \"0.58682525\",\n \"0.58439165\",\n \"0.58354056\",\n \"0.5828276\",\n \"0.58133125\",\n \"0.58090156\",\n \"0.5787748\",\n \"0.57787144\",\n \"0.57746345\",\n \"0.5770449\",\n \"0.5770011\",\n \"0.57592416\",\n \"0.574673\",\n \"0.5744973\",\n \"0.5738498\",\n \"0.5738324\",\n \"0.57287157\",\n \"0.5726526\",\n \"0.5722274\",\n \"0.5710825\",\n \"0.5707041\",\n \"0.5704982\",\n \"0.5696327\",\n \"0.56934065\",\n \"0.56876993\",\n \"0.5686261\",\n \"0.56841445\",\n \"0.5669096\",\n \"0.5663755\",\n \"0.5656253\",\n \"0.5654044\",\n \"0.5653401\",\n \"0.56387454\",\n \"0.56338125\",\n \"0.5627769\",\n \"0.56266993\",\n \"0.56217307\",\n \"0.5620524\",\n \"0.56178886\",\n \"0.56039286\",\n \"0.56038195\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60878724"},"document_rank":{"kind":"string","value":"38"}}},{"rowIdx":76099,"cells":{"query":{"kind":"string","value":"Get the attribute with the highest IG"},"document":{"kind":"string","value":"def maxIG(data):\n \n index = -1\n max_gain = -1\n \n for i in range(len(data[0]) - 1):\n gain = informationGain2(data, i)\n if gain > max_gain:\n index = i\n max_gain = gain\n \n return (index, max_gain)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def imax(self):\n return self.elem.index(max(self))","def _best_individual(self):\n return max(self._population, key=attrgetter(\"fitness\"))","def get_max_key(dico):\n our_max = 0\n argmax = None\n for key, val in dico.items():\n if val > our_max:\n argmax = key\n our_max = val\n return argmax","def get_stock_symbol_with_highest_cap():\n #highest_cap = 0\n highest_cap_stock = max(data, key=lambda counter: _cap_str_to_mln_float(counter['cap']))\n #for counter in data:\n # if _cap_str_to_mln_float(counter['cap']) > highest_cap:\n # highest_cap_stock = counter['symbol']\n # highest_cap = _cap_str_to_mln_float(counter['cap'])\n return highest_cap_stock['symbol']","def _get_max_estimated_bandit(self)->Bandit:\n # print(\"mus - \", self.mu)\n # print(\"actions - \", np.argmax(self.mu))\n unique, counts = np.unique(self.mu, return_counts=True)\n lens = counts[np.argmax(unique)] \n if lens>1: # if two actions have same argmax\n # then return arbitrarily from those max ones\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\n return np.random.choice(maxs)\n # otherwise return the max one\n return self.bandits[np.argmax(self.mu)]","def Max(attribute):\n\n def annot(attrs):\n # We want to return None on an empty attribute rather than throwing\n try:\n return max(attrs.get(attribute, []))\n except ValueError:\n return None\n\n return annot","def search_for_maximum(self):\n return self.maximise_aquisition(self.expected_improvement)","def get_max_interest(self):\n max_int = max(self.table[\"interest\"])\n print(max_int)\n for index in self.table[\"index\"]:\n if self.table[\"interest\"][index] == max_int:\n return index","def get_greatest_probability(self):\n greatest = -1\n for i in range(self.dim):\n for j in range(self.dim):\n if self.kb[i][j] > greatest:\n greatest = self.kb[i][j]\n\n return greatest","def argmax(table):\n return max((v,k) for k,v in table.iteritems())[1]","def agility(self):\n return self._getAttribute(Attribute.agility)","def max(self):\n return self.get_first()","def get_stock_symbol_with_highest_cap():\n #data2 = _cap_str_to_mln_float('cap')\n symbol_max = dict()\n for items in data:\n if items['symbol'] in symbol_max.keys():\n symbol_max[items['symbol']] = max(symbol_max[items['symbol']], _cap_str_to_mln_float(items['cap']))\n else:\n symbol_max[items['symbol']] = _cap_str_to_mln_float(items['cap'])\n\n value = sorted(symbol_max.items(), key = lambda x:x[1], reverse=True)[0][0]\n #sorted(symbol_max.items(), key = lambda x:x[1])\n return value","def choose_optimal_attribute(dataset) :\n num_attr = len(dataset[0] - 1) # subtract 1 for label\n num_data = len(dataset)\n base_entropy = calculate_entropy(dataset)\n most_info_gain = 0\n optimal_attr_index = -1\n for i in range(num_attr) :\n attr_list = [data[i] for data in dataset]\n attr_unique_vals = set(attr_list)\n new_entropy = 0\n # for each attribute unique values see how much entropy is caused\n # and add them to finalize the total entropy when splitted by\n # this specific attribute\n for val in attr_unique_vals :\n sub_dataset = reduce_dataset(dataset, i, val)\n prob = len(sub_dataset) / num_data\n new_entropy += prob * calculate_entropy(sub_dataset)\n # compare and choose the attr with the most info gain\n info_gain = base_entropy - new_entropy\n if info_gain > most_info_gain :\n most_info_gain = info_gain\n optimal_attr_index = i\n return optimal_attr_index","def argmax(d):\n return max(d.iteritems(), key=operator.itemgetter(1))","def _get_maxth(self):\n return self.__maxth","def _get_maxth(self):\n return self.__maxth","def _get_maxth(self):\n return self.__maxth","def _get_maxth(self):\n return self.__maxth","def _get_maxth(self):\n return self.__maxth","def _get_maxth(self):\n return self.__maxth","def get_detected_intent(prediction):\n return max(prediction, key=lambda x: prediction[x])","def argMax(self):\n if len(self.keys()) == 0: return None\n all = list(self.items())\n values = [x[1] for x in all]\n maxIndex = values.index(max(values))\n return all[maxIndex][0]","def max(self):\n most = self.data[0]\n \n for i in range(len(self.data)):\n if self.data[i] > least:\n most = self.data[i]\n return most","def get_highest(self, test):\n return","def get_max(self):\n return self.serie.max()","def find_max(self):\n if self.right:\n return self.right.find_max()\n return self.data","def get_max(self):\n raise NotImplementedError(\"This is an abstract method and needs to be implemented in derived classes.\")","def get_max(self):\n return self.max[-1]","def argMax(self):\n if len(list(self.keys())) == 0:\n return None\n all = list(self.items())\n values = [x[1] for x in all]\n maxIndex = values.index(max(values))\n return all[maxIndex][0]","def find_max(self):\n\n if self.right:\n return self.right.find_max()\n\n return self.data","def max(self, i):\n x=self.val(i,0)\n lm=len(self)\n t=1\n while t<lm:\n y=self.val(i,t)\n if x<y:\n x=y\n t+=1\n return x","def _get_maximum(self):\n return self._maximum","def _maxAlien(self):\n maxA = 0\n for r in self._aliens:\n for y in r:\n if(y != None):\n maxA = max(maxA,y.x)\n return maxA","def get_higher(self, term):\n try:\n ret = self.metadata[self.metadata['Higher Taxonomy'] == term].sort_values(['Lower Taxonomy', 'Unique ID']).reset_index(drop=True)\n except KeyError:\n sys.exit(f'{term} is not a valid Higher Taxonomy')\n return ret","def get_max_index(a):\n return a.argmax()","def get_max_index(a):\n return a.argmax()","def get_max_index(a):\n return a.argmax()","def max_gain(self):\n if self.val1:\n val1_gain_tuple, val0_gain_tuple = self.val1.max_gain(), self.val0.max_gain()\n if val1_gain_tuple.gain > val0_gain_tuple.gain:\n return val1_gain_tuple\n else:\n return val0_gain_tuple\n elif self.attributes:\n filtered_data = filter_data(self.data,self.ancestors)\n max_attribute, max_gain = max([(attribute,\n self.heuristic(self,attribute)) for attribute in self.attributes],\n key = lambda x: x[1])\n return gain_tuple(self, max_attribute, max_gain)\n return gain_tuple(None, '', 0)","def maxLike(self):\n return max(self.d.values())","def max(self):\n return self._reduce_for_stat_function(F.max, only_numeric=False)","def find_max(self):\n return max(self.nodes, key=int)","def best(self):\n if len(self) == 0:\n return None\n return max_elems(self, key=attr.getter(\"value\"), gt=self.solver.sense.is_better)[0]","def get_stock_symbol_with_highest_cap() -> str:\n caps = [(entry[\"symbol\"], _cap_str_to_mln_float(entry[\"cap\"])) for entry in data]\n return max(caps, key=lambda x: x[1])[0]","def get_maximum ( self, object ):\n return self.maximum","def data_dict_max(data_dict, feature):\n name = max(filter(lambda k: isinstance(data_dict[k][feature],\n (int, float)), data_dict), key=lambda k: data_dict[k][feature])\n\n return name, data_dict[name][feature]","def get_max(self):\n\t\tif self.right:\n\t\t\treturn self.right.get_max()\n\t\treturn self.value","def max_level(self):\n return self.__max","def max(self):\n try:\n val = iinfo._max_vals[self.key]\n except KeyError:\n if self.kind == 'u':\n val = int((1 << self.bits) - 1)\n else:\n val = int((1 << (self.bits-1)) - 1)\n iinfo._max_vals[self.key] = val\n return val","def max(self):\n try:\n val = iinfo._max_vals[self.key]\n except KeyError:\n if self.kind == 'u':\n val = int((1 << self.bits) - 1)\n else:\n val = int((1 << (self.bits-1)) - 1)\n iinfo._max_vals[self.key] = val\n return val","def calculate_greatest(self):\n greatest = 0\n for resourceList in self.loading.values():\n for time, use in resourceList:\n if use > greatest:\n greatest = use\n self.emit(\"greatest_calculated\",greatest)\n return greatest","def getBestOption(self):\n if len(self.Data) < 1:\n return None\n else:\n bestR = max(self.Data.items(), key=lambda x: x[1]['SPat'].I)\n return bestR[1]","def GetMaximum(self):\n return _itkStatisticsImageFilterPython.itkStatisticsImageFilterIUS3_GetMaximum(self)","def best_split(self, X, y, attributes):\n if (self.criterion==\"information_gain\"):\n global_if = float('-inf') # the highest value of information gain/gini gain seen so far\n attr = None\n for attribute in attributes:\n attr_val = X[attribute].copy()\n cur_if = information_gain(y,attr_val,self.type)\n if (cur_if>global_if):\n # Update when a better split is receieved\n global_if = cur_if\n attr = attribute\n return attr\n else:\n global_if = float('inf')\n attr = None\n for attribute in attributes:\n attr_val = X[attribute].copy()\n cur_if = gini_gain(y,attr_val)\n if (global_if>cur_if):\n # Update when a better split is receieved\n global_if = cur_if\n attr = attribute\n return attr","def get_best_individual(self):\n return self._best_indv","def find_max_f():\n fmax = fmin(g, 2)\n return fmax[0]","def maximum(self):\n return self.properties.get('maximum')","def GetMaximum(self):\n return _itkStatisticsImageFilterPython.itkStatisticsImageFilterIUS2_GetMaximum(self)","def attribute(self, attribute):\n value = 3\n if self.age == \"child\":\n value -= 1\n if attribute == \"physique\" or attribute == \"phy\":\n if self.age == \"adult\":\n value += 1\n if self.gender == \"male\":\n value += 1\n elif self.gender == \"female\":\n value -= 1\n\n if attribute == \"sensitivity\" or attribute == \"sns\":\n if self.age == \"child\":\n value += 2\n if self.gender == \"male\":\n value -= 1\n elif self.gender == \"female\":\n value += 1\n\n if attribute == \"agility\" or attribute == \"agi\":\n if self.age == \"child\":\n value += 1 # to be equally as high as adult and young\n elif self.age == \"elder\":\n value -= 1\n\n if attribute == \"mind\" or attribute == \"mnd\":\n if self.age == \"elder\":\n value += 1\n\n for feature in self.features:\n if feature.name == \"blood\":\n for key in feature.modifiers:\n if attribute == key:\n value += feature.modifiers[key]\n\n if value < 1:\n value = 1\n return value","def extract_max_value(h: np.ndarray):\n return np.argmax(h, axis=1)","def get_worst_fitness(self):\n f = min(self.characters, key=operator.attrgetter('fitness'))\n self.worst_fitness = round(f.fitness, 3)","def select_worst_idx(population, k, fit_attr=\"fitness\"):\n zipped = list(zip(population, list(range(len(population)))))\n worst = sorted(zipped, key=lambda tup: attrgetter(fit_attr)(tup[0]))[:k]\n return [tup[1] for tup in worst]","def __find_max_price(self):\n prices_map = map(\n lambda iceberg: utils.get_actual_penguin_amount(\n self.__game, iceberg),\n self.__game.get_all_icebergs()\n )\n return max(prices_map)","def max_path_cost(self, path, attr): \n return max([self.G[path[i]][path[i+1]][attr] for i in range(len(path)-1)])","def get_max(bij, exploration, bij_bool):\n\n#\tbij[bij_bool] = -sys.maxint - 1\n\n\tm = bij.argmax()\n\tc = np.unravel_index(m, bij.shape)\n\t#c = np.unravel_index(bij.argmax(), bij.shape)\n\n############################## A MODIFIER EVENTUELLEMENT #################\n#\tb = bij[bij_bool]\n#\tm = b.argmax()\n#\tind = np.unravel_index(m, b.shape)\n#\tc = np.where(bij == b[ind])\n#\tc = (c[0][0], c[1][0])\n#\tprint('mMAXx', bij[c])\n\treturn (c)","def get_highest_accuracy(self) -> Tuple[float, Dict[str, Any]]:\n highest_val = float('-inf')\n data = None\n for instance in self.stats:\n if self.stats[instance][\"Accuracy\"] > highest_val:\n highest_val = self.stats[instance][\"Accuracy\"]\n data = self.stats[instance]\n return highest_val, data","def get_max(self):\n return self._max","def stock_max(stock):\n max_price=0\n for i in stock['Close']:\n if i > max_price:\n max_price=i\n return max_price","def max_key (dict):\n output = -1\n for key, value in dict.items():\n output = max(output, key)\n return output","def maximal_valance(self) -> int:\n max_valances = {'H': 1, 'B': 4, 'C': 4, 'N': 4, 'O': 3, 'F': 1,\n 'Si': 4, 'P': 6, 'S': 6, 'Cl': 4, 'Br': 4, 'I': 6}\n\n if self.label in max_valances:\n return max_valances[self.label]\n\n else:\n logger.warning(f'Could not find a valid valance for {self}. '\n f'Guessing at 6')\n return 6","def max(self):\n return max(self)","def max(self):\r\n\t\treturn max(self.sample)","def highest_value():\n maximum_number = 0\n for i in xrange(length):\n challenger = frames[i]\n if abs(challenger) > maximum_number:\n maximum_number = abs(challenger)\n return maximum_number","def max(self):\n max = 0\n a = self.array_form\n for i in xrange(len(a)):\n if a[i] != i and a[i] > max:\n max = a[i]\n return max","def max(self):\n return self.__max","def max(self):\n assert self.__stack\n return self.__max_values[-1]","def get_highest_priority(self):\n for i in self.query.index.values.tolist():\n if not int(self.query.loc[i,'in_%s'%self.program]):\n pick = self.query.loc[i]\n break\n return pick","def find_max_tag(self, word):\n count = []\n for tag in self.pos_tags:\n count.append(self.tag_word_data.count((tag, word)))\n max_index = np.argmax(np.asarray(count))\n return self.pos_tags[max_index]","def getMaxKey(self):\n print self.freq\n if self.freq:\n max_freq = max(self.freq.keys())\n return list(self.freq[max_freq])[0]\n\n return ''","def Max(data):\n return data.max()","def mostCommonClassAttribute(self, data, structure):\n maxCount, classIndex, mostCommonClassAttribute = 0, structure['class']['index'], None\n for value in structure['class']['values']:\n newData = list(filter(lambda y: y[classIndex] == value, data))\n if len(newData) >= maxCount:\n maxCount = len(newData)\n mostCommonClassAttribute = value\n return mostCommonClassAttribute","def attributeSelection(data, attributes, class_label, indices=None):\n\tbest = 0\n\tbestIndex = 0\n\tcounter = 0\n\tfor i in attributes:\n\t\tinfoG = informationGain(data, class_label, i, indices)\n\t\tif infoG > best:\n\t\t\tbest = infoG\n\t\t\tbestIndex = counter\n\t\tcounter += 1 \n\t\n\treturn bestIndex","def key_of_max(d):\n keys = list(d.keys())\n keys.sort()\n return max(keys, key=lambda x: d[x])","def largest_item(list):\n pass","def max(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"max\")","def max(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"max\")","def find_max(self):\r\n maxVal = self.items[1]\r\n if maxVal is None:\r\n return None\r\n \r\n for i in range(1,len(self.items)):\r\n if self.items[i] is not None:\r\n if self.items[i] > maxVal:\r\n maxVal = self.items[i]\r\n return maxVal","def most_visited_child(self):\n return max(self.children, key=lambda c: c.explore_count)","def get_food_most_calories(df=df):\r\n max_calories_row = df.loc[df['Calories'].idxmax()]\r\n return max_calories_row['Item']","def most_occured(dict):\n\n max = dict['e']\n max_alpha = 'e'\n\n for i, j in zip(dict.values(), dict.keys()):\n\n if max < i:\n max = i\n max_alpha = j\n \n return max_alpha","def cmax(self):\n return self[\"cmax\"]","def max(self):\n if self.right is None:\n return self.item\n else:\n return self.right.max()","def strongest(nanobots):\n return max(nanobots, key=attrgetter('strength'))","def GetMaximum(self):\n return _itkStatisticsImageFilterPython.itkStatisticsImageFilterIUL2_GetMaximum(self)","def highCard(self):\n return max(self)","def get_max(self):\n max_value= self.df[self.col_name].max()\n return max_value","def max(self):\n\n return time_stat(self, stat=\"max\")","def youngest(self):\n # Your implementation here","def GetMaximum(self):\n return _itkStatisticsImageFilterPython.itkStatisticsImageFilterIUL3_GetMaximum(self)","def max(self):\n return numpy.ma.max(self.data)"],"string":"[\n \"def imax(self):\\n return self.elem.index(max(self))\",\n \"def _best_individual(self):\\n return max(self._population, key=attrgetter(\\\"fitness\\\"))\",\n \"def get_max_key(dico):\\n our_max = 0\\n argmax = None\\n for key, val in dico.items():\\n if val > our_max:\\n argmax = key\\n our_max = val\\n return argmax\",\n \"def get_stock_symbol_with_highest_cap():\\n #highest_cap = 0\\n highest_cap_stock = max(data, key=lambda counter: _cap_str_to_mln_float(counter['cap']))\\n #for counter in data:\\n # if _cap_str_to_mln_float(counter['cap']) > highest_cap:\\n # highest_cap_stock = counter['symbol']\\n # highest_cap = _cap_str_to_mln_float(counter['cap'])\\n return highest_cap_stock['symbol']\",\n \"def _get_max_estimated_bandit(self)->Bandit:\\n # print(\\\"mus - \\\", self.mu)\\n # print(\\\"actions - \\\", np.argmax(self.mu))\\n unique, counts = np.unique(self.mu, return_counts=True)\\n lens = counts[np.argmax(unique)] \\n if lens>1: # if two actions have same argmax\\n # then return arbitrarily from those max ones\\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\\n return np.random.choice(maxs)\\n # otherwise return the max one\\n return self.bandits[np.argmax(self.mu)]\",\n \"def Max(attribute):\\n\\n def annot(attrs):\\n # We want to return None on an empty attribute rather than throwing\\n try:\\n return max(attrs.get(attribute, []))\\n except ValueError:\\n return None\\n\\n return annot\",\n \"def search_for_maximum(self):\\n return self.maximise_aquisition(self.expected_improvement)\",\n \"def get_max_interest(self):\\n max_int = max(self.table[\\\"interest\\\"])\\n print(max_int)\\n for index in self.table[\\\"index\\\"]:\\n if self.table[\\\"interest\\\"][index] == max_int:\\n return index\",\n \"def get_greatest_probability(self):\\n greatest = -1\\n for i in range(self.dim):\\n for j in range(self.dim):\\n if self.kb[i][j] > greatest:\\n greatest = self.kb[i][j]\\n\\n return greatest\",\n \"def argmax(table):\\n return max((v,k) for k,v in table.iteritems())[1]\",\n \"def agility(self):\\n return self._getAttribute(Attribute.agility)\",\n \"def max(self):\\n return self.get_first()\",\n \"def get_stock_symbol_with_highest_cap():\\n #data2 = _cap_str_to_mln_float('cap')\\n symbol_max = dict()\\n for items in data:\\n if items['symbol'] in symbol_max.keys():\\n symbol_max[items['symbol']] = max(symbol_max[items['symbol']], _cap_str_to_mln_float(items['cap']))\\n else:\\n symbol_max[items['symbol']] = _cap_str_to_mln_float(items['cap'])\\n\\n value = sorted(symbol_max.items(), key = lambda x:x[1], reverse=True)[0][0]\\n #sorted(symbol_max.items(), key = lambda x:x[1])\\n return value\",\n \"def choose_optimal_attribute(dataset) :\\n num_attr = len(dataset[0] - 1) # subtract 1 for label\\n num_data = len(dataset)\\n base_entropy = calculate_entropy(dataset)\\n most_info_gain = 0\\n optimal_attr_index = -1\\n for i in range(num_attr) :\\n attr_list = [data[i] for data in dataset]\\n attr_unique_vals = set(attr_list)\\n new_entropy = 0\\n # for each attribute unique values see how much entropy is caused\\n # and add them to finalize the total entropy when splitted by\\n # this specific attribute\\n for val in attr_unique_vals :\\n sub_dataset = reduce_dataset(dataset, i, val)\\n prob = len(sub_dataset) / num_data\\n new_entropy += prob * calculate_entropy(sub_dataset)\\n # compare and choose the attr with the most info gain\\n info_gain = base_entropy - new_entropy\\n if info_gain > most_info_gain :\\n most_info_gain = info_gain\\n optimal_attr_index = i\\n return optimal_attr_index\",\n \"def argmax(d):\\n return max(d.iteritems(), key=operator.itemgetter(1))\",\n \"def _get_maxth(self):\\n return self.__maxth\",\n \"def _get_maxth(self):\\n return self.__maxth\",\n \"def _get_maxth(self):\\n return self.__maxth\",\n \"def _get_maxth(self):\\n return self.__maxth\",\n \"def _get_maxth(self):\\n return self.__maxth\",\n \"def _get_maxth(self):\\n return self.__maxth\",\n \"def get_detected_intent(prediction):\\n return max(prediction, key=lambda x: prediction[x])\",\n \"def argMax(self):\\n if len(self.keys()) == 0: return None\\n all = list(self.items())\\n values = [x[1] for x in all]\\n maxIndex = values.index(max(values))\\n return all[maxIndex][0]\",\n \"def max(self):\\n most = self.data[0]\\n \\n for i in range(len(self.data)):\\n if self.data[i] > least:\\n most = self.data[i]\\n return most\",\n \"def get_highest(self, test):\\n return\",\n \"def get_max(self):\\n return self.serie.max()\",\n \"def find_max(self):\\n if self.right:\\n return self.right.find_max()\\n return self.data\",\n \"def get_max(self):\\n raise NotImplementedError(\\\"This is an abstract method and needs to be implemented in derived classes.\\\")\",\n \"def get_max(self):\\n return self.max[-1]\",\n \"def argMax(self):\\n if len(list(self.keys())) == 0:\\n return None\\n all = list(self.items())\\n values = [x[1] for x in all]\\n maxIndex = values.index(max(values))\\n return all[maxIndex][0]\",\n \"def find_max(self):\\n\\n if self.right:\\n return self.right.find_max()\\n\\n return self.data\",\n \"def max(self, i):\\n x=self.val(i,0)\\n lm=len(self)\\n t=1\\n while t<lm:\\n y=self.val(i,t)\\n if x<y:\\n x=y\\n t+=1\\n return x\",\n \"def _get_maximum(self):\\n return self._maximum\",\n \"def _maxAlien(self):\\n maxA = 0\\n for r in self._aliens:\\n for y in r:\\n if(y != None):\\n maxA = max(maxA,y.x)\\n return maxA\",\n \"def get_higher(self, term):\\n try:\\n ret = self.metadata[self.metadata['Higher Taxonomy'] == term].sort_values(['Lower Taxonomy', 'Unique ID']).reset_index(drop=True)\\n except KeyError:\\n sys.exit(f'{term} is not a valid Higher Taxonomy')\\n return ret\",\n \"def get_max_index(a):\\n return a.argmax()\",\n \"def get_max_index(a):\\n return a.argmax()\",\n \"def get_max_index(a):\\n return a.argmax()\",\n \"def max_gain(self):\\n if self.val1:\\n val1_gain_tuple, val0_gain_tuple = self.val1.max_gain(), self.val0.max_gain()\\n if val1_gain_tuple.gain > val0_gain_tuple.gain:\\n return val1_gain_tuple\\n else:\\n return val0_gain_tuple\\n elif self.attributes:\\n filtered_data = filter_data(self.data,self.ancestors)\\n max_attribute, max_gain = max([(attribute,\\n self.heuristic(self,attribute)) for attribute in self.attributes],\\n key = lambda x: x[1])\\n return gain_tuple(self, max_attribute, max_gain)\\n return gain_tuple(None, '', 0)\",\n \"def maxLike(self):\\n return max(self.d.values())\",\n \"def max(self):\\n return self._reduce_for_stat_function(F.max, only_numeric=False)\",\n \"def find_max(self):\\n return max(self.nodes, key=int)\",\n \"def best(self):\\n if len(self) == 0:\\n return None\\n return max_elems(self, key=attr.getter(\\\"value\\\"), gt=self.solver.sense.is_better)[0]\",\n \"def get_stock_symbol_with_highest_cap() -> str:\\n caps = [(entry[\\\"symbol\\\"], _cap_str_to_mln_float(entry[\\\"cap\\\"])) for entry in data]\\n return max(caps, key=lambda x: x[1])[0]\",\n \"def get_maximum ( self, object ):\\n return self.maximum\",\n \"def data_dict_max(data_dict, feature):\\n name = max(filter(lambda k: isinstance(data_dict[k][feature],\\n (int, float)), data_dict), key=lambda k: data_dict[k][feature])\\n\\n return name, data_dict[name][feature]\",\n \"def get_max(self):\\n\\t\\tif self.right:\\n\\t\\t\\treturn self.right.get_max()\\n\\t\\treturn self.value\",\n \"def max_level(self):\\n return self.__max\",\n \"def max(self):\\n try:\\n val = iinfo._max_vals[self.key]\\n except KeyError:\\n if self.kind == 'u':\\n val = int((1 << self.bits) - 1)\\n else:\\n val = int((1 << (self.bits-1)) - 1)\\n iinfo._max_vals[self.key] = val\\n return val\",\n \"def max(self):\\n try:\\n val = iinfo._max_vals[self.key]\\n except KeyError:\\n if self.kind == 'u':\\n val = int((1 << self.bits) - 1)\\n else:\\n val = int((1 << (self.bits-1)) - 1)\\n iinfo._max_vals[self.key] = val\\n return val\",\n \"def calculate_greatest(self):\\n greatest = 0\\n for resourceList in self.loading.values():\\n for time, use in resourceList:\\n if use > greatest:\\n greatest = use\\n self.emit(\\\"greatest_calculated\\\",greatest)\\n return greatest\",\n \"def getBestOption(self):\\n if len(self.Data) < 1:\\n return None\\n else:\\n bestR = max(self.Data.items(), key=lambda x: x[1]['SPat'].I)\\n return bestR[1]\",\n \"def GetMaximum(self):\\n return _itkStatisticsImageFilterPython.itkStatisticsImageFilterIUS3_GetMaximum(self)\",\n \"def best_split(self, X, y, attributes):\\n if (self.criterion==\\\"information_gain\\\"):\\n global_if = float('-inf') # the highest value of information gain/gini gain seen so far\\n attr = None\\n for attribute in attributes:\\n attr_val = X[attribute].copy()\\n cur_if = information_gain(y,attr_val,self.type)\\n if (cur_if>global_if):\\n # Update when a better split is receieved\\n global_if = cur_if\\n attr = attribute\\n return attr\\n else:\\n global_if = float('inf')\\n attr = None\\n for attribute in attributes:\\n attr_val = X[attribute].copy()\\n cur_if = gini_gain(y,attr_val)\\n if (global_if>cur_if):\\n # Update when a better split is receieved\\n global_if = cur_if\\n attr = attribute\\n return attr\",\n \"def get_best_individual(self):\\n return self._best_indv\",\n \"def find_max_f():\\n fmax = fmin(g, 2)\\n return fmax[0]\",\n \"def maximum(self):\\n return self.properties.get('maximum')\",\n \"def GetMaximum(self):\\n return _itkStatisticsImageFilterPython.itkStatisticsImageFilterIUS2_GetMaximum(self)\",\n \"def attribute(self, attribute):\\n value = 3\\n if self.age == \\\"child\\\":\\n value -= 1\\n if attribute == \\\"physique\\\" or attribute == \\\"phy\\\":\\n if self.age == \\\"adult\\\":\\n value += 1\\n if self.gender == \\\"male\\\":\\n value += 1\\n elif self.gender == \\\"female\\\":\\n value -= 1\\n\\n if attribute == \\\"sensitivity\\\" or attribute == \\\"sns\\\":\\n if self.age == \\\"child\\\":\\n value += 2\\n if self.gender == \\\"male\\\":\\n value -= 1\\n elif self.gender == \\\"female\\\":\\n value += 1\\n\\n if attribute == \\\"agility\\\" or attribute == \\\"agi\\\":\\n if self.age == \\\"child\\\":\\n value += 1 # to be equally as high as adult and young\\n elif self.age == \\\"elder\\\":\\n value -= 1\\n\\n if attribute == \\\"mind\\\" or attribute == \\\"mnd\\\":\\n if self.age == \\\"elder\\\":\\n value += 1\\n\\n for feature in self.features:\\n if feature.name == \\\"blood\\\":\\n for key in feature.modifiers:\\n if attribute == key:\\n value += feature.modifiers[key]\\n\\n if value < 1:\\n value = 1\\n return value\",\n \"def extract_max_value(h: np.ndarray):\\n return np.argmax(h, axis=1)\",\n \"def get_worst_fitness(self):\\n f = min(self.characters, key=operator.attrgetter('fitness'))\\n self.worst_fitness = round(f.fitness, 3)\",\n \"def select_worst_idx(population, k, fit_attr=\\\"fitness\\\"):\\n zipped = list(zip(population, list(range(len(population)))))\\n worst = sorted(zipped, key=lambda tup: attrgetter(fit_attr)(tup[0]))[:k]\\n return [tup[1] for tup in worst]\",\n \"def __find_max_price(self):\\n prices_map = map(\\n lambda iceberg: utils.get_actual_penguin_amount(\\n self.__game, iceberg),\\n self.__game.get_all_icebergs()\\n )\\n return max(prices_map)\",\n \"def max_path_cost(self, path, attr): \\n return max([self.G[path[i]][path[i+1]][attr] for i in range(len(path)-1)])\",\n \"def get_max(bij, exploration, bij_bool):\\n\\n#\\tbij[bij_bool] = -sys.maxint - 1\\n\\n\\tm = bij.argmax()\\n\\tc = np.unravel_index(m, bij.shape)\\n\\t#c = np.unravel_index(bij.argmax(), bij.shape)\\n\\n############################## A MODIFIER EVENTUELLEMENT #################\\n#\\tb = bij[bij_bool]\\n#\\tm = b.argmax()\\n#\\tind = np.unravel_index(m, b.shape)\\n#\\tc = np.where(bij == b[ind])\\n#\\tc = (c[0][0], c[1][0])\\n#\\tprint('mMAXx', bij[c])\\n\\treturn (c)\",\n \"def get_highest_accuracy(self) -> Tuple[float, Dict[str, Any]]:\\n highest_val = float('-inf')\\n data = None\\n for instance in self.stats:\\n if self.stats[instance][\\\"Accuracy\\\"] > highest_val:\\n highest_val = self.stats[instance][\\\"Accuracy\\\"]\\n data = self.stats[instance]\\n return highest_val, data\",\n \"def get_max(self):\\n return self._max\",\n \"def stock_max(stock):\\n max_price=0\\n for i in stock['Close']:\\n if i > max_price:\\n max_price=i\\n return max_price\",\n \"def max_key (dict):\\n output = -1\\n for key, value in dict.items():\\n output = max(output, key)\\n return output\",\n \"def maximal_valance(self) -> int:\\n max_valances = {'H': 1, 'B': 4, 'C': 4, 'N': 4, 'O': 3, 'F': 1,\\n 'Si': 4, 'P': 6, 'S': 6, 'Cl': 4, 'Br': 4, 'I': 6}\\n\\n if self.label in max_valances:\\n return max_valances[self.label]\\n\\n else:\\n logger.warning(f'Could not find a valid valance for {self}. '\\n f'Guessing at 6')\\n return 6\",\n \"def max(self):\\n return max(self)\",\n \"def max(self):\\r\\n\\t\\treturn max(self.sample)\",\n \"def highest_value():\\n maximum_number = 0\\n for i in xrange(length):\\n challenger = frames[i]\\n if abs(challenger) > maximum_number:\\n maximum_number = abs(challenger)\\n return maximum_number\",\n \"def max(self):\\n max = 0\\n a = self.array_form\\n for i in xrange(len(a)):\\n if a[i] != i and a[i] > max:\\n max = a[i]\\n return max\",\n \"def max(self):\\n return self.__max\",\n \"def max(self):\\n assert self.__stack\\n return self.__max_values[-1]\",\n \"def get_highest_priority(self):\\n for i in self.query.index.values.tolist():\\n if not int(self.query.loc[i,'in_%s'%self.program]):\\n pick = self.query.loc[i]\\n break\\n return pick\",\n \"def find_max_tag(self, word):\\n count = []\\n for tag in self.pos_tags:\\n count.append(self.tag_word_data.count((tag, word)))\\n max_index = np.argmax(np.asarray(count))\\n return self.pos_tags[max_index]\",\n \"def getMaxKey(self):\\n print self.freq\\n if self.freq:\\n max_freq = max(self.freq.keys())\\n return list(self.freq[max_freq])[0]\\n\\n return ''\",\n \"def Max(data):\\n return data.max()\",\n \"def mostCommonClassAttribute(self, data, structure):\\n maxCount, classIndex, mostCommonClassAttribute = 0, structure['class']['index'], None\\n for value in structure['class']['values']:\\n newData = list(filter(lambda y: y[classIndex] == value, data))\\n if len(newData) >= maxCount:\\n maxCount = len(newData)\\n mostCommonClassAttribute = value\\n return mostCommonClassAttribute\",\n \"def attributeSelection(data, attributes, class_label, indices=None):\\n\\tbest = 0\\n\\tbestIndex = 0\\n\\tcounter = 0\\n\\tfor i in attributes:\\n\\t\\tinfoG = informationGain(data, class_label, i, indices)\\n\\t\\tif infoG > best:\\n\\t\\t\\tbest = infoG\\n\\t\\t\\tbestIndex = counter\\n\\t\\tcounter += 1 \\n\\t\\n\\treturn bestIndex\",\n \"def key_of_max(d):\\n keys = list(d.keys())\\n keys.sort()\\n return max(keys, key=lambda x: d[x])\",\n \"def largest_item(list):\\n pass\",\n \"def max(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"max\\\")\",\n \"def max(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"max\\\")\",\n \"def find_max(self):\\r\\n maxVal = self.items[1]\\r\\n if maxVal is None:\\r\\n return None\\r\\n \\r\\n for i in range(1,len(self.items)):\\r\\n if self.items[i] is not None:\\r\\n if self.items[i] > maxVal:\\r\\n maxVal = self.items[i]\\r\\n return maxVal\",\n \"def most_visited_child(self):\\n return max(self.children, key=lambda c: c.explore_count)\",\n \"def get_food_most_calories(df=df):\\r\\n max_calories_row = df.loc[df['Calories'].idxmax()]\\r\\n return max_calories_row['Item']\",\n \"def most_occured(dict):\\n\\n max = dict['e']\\n max_alpha = 'e'\\n\\n for i, j in zip(dict.values(), dict.keys()):\\n\\n if max < i:\\n max = i\\n max_alpha = j\\n \\n return max_alpha\",\n \"def cmax(self):\\n return self[\\\"cmax\\\"]\",\n \"def max(self):\\n if self.right is None:\\n return self.item\\n else:\\n return self.right.max()\",\n \"def strongest(nanobots):\\n return max(nanobots, key=attrgetter('strength'))\",\n \"def GetMaximum(self):\\n return _itkStatisticsImageFilterPython.itkStatisticsImageFilterIUL2_GetMaximum(self)\",\n \"def highCard(self):\\n return max(self)\",\n \"def get_max(self):\\n max_value= self.df[self.col_name].max()\\n return max_value\",\n \"def max(self):\\n\\n return time_stat(self, stat=\\\"max\\\")\",\n \"def youngest(self):\\n # Your implementation here\",\n \"def GetMaximum(self):\\n return _itkStatisticsImageFilterPython.itkStatisticsImageFilterIUL3_GetMaximum(self)\",\n \"def max(self):\\n return numpy.ma.max(self.data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6761436","0.66377854","0.64832205","0.645513","0.6428963","0.6424145","0.63717365","0.62889665","0.6267934","0.62075317","0.62063825","0.6203469","0.62030816","0.62002635","0.61884105","0.6144686","0.6144686","0.6144686","0.6144686","0.6144686","0.6144686","0.61365134","0.61342525","0.61177194","0.6112162","0.6103859","0.6093528","0.60859513","0.6085129","0.6079006","0.6053244","0.6049297","0.6041716","0.6022241","0.59639454","0.595931","0.595931","0.595931","0.5933927","0.59294194","0.5908512","0.5903635","0.5901329","0.589707","0.58871436","0.5886245","0.58717746","0.5865514","0.58636314","0.58636314","0.5845495","0.58433616","0.58353746","0.5833176","0.5832716","0.5827193","0.58167416","0.58129436","0.58022547","0.5799062","0.5795675","0.5794942","0.5786342","0.57852787","0.5785193","0.5779625","0.57794476","0.5772676","0.5771489","0.5765838","0.57650787","0.5755918","0.57555485","0.57554114","0.57551944","0.5753711","0.5753584","0.5751765","0.57404625","0.5738171","0.57353044","0.5733764","0.5732453","0.57303804","0.5728693","0.5728693","0.5727266","0.57191586","0.5712289","0.57103074","0.5708468","0.5707887","0.57040226","0.5703141","0.5702125","0.56919396","0.56896967","0.5685612","0.5684273","0.56773394"],"string":"[\n \"0.6761436\",\n \"0.66377854\",\n \"0.64832205\",\n \"0.645513\",\n \"0.6428963\",\n \"0.6424145\",\n \"0.63717365\",\n \"0.62889665\",\n \"0.6267934\",\n \"0.62075317\",\n \"0.62063825\",\n \"0.6203469\",\n \"0.62030816\",\n \"0.62002635\",\n \"0.61884105\",\n \"0.6144686\",\n \"0.6144686\",\n \"0.6144686\",\n \"0.6144686\",\n \"0.6144686\",\n \"0.6144686\",\n \"0.61365134\",\n \"0.61342525\",\n \"0.61177194\",\n \"0.6112162\",\n \"0.6103859\",\n \"0.6093528\",\n \"0.60859513\",\n \"0.6085129\",\n \"0.6079006\",\n \"0.6053244\",\n \"0.6049297\",\n \"0.6041716\",\n \"0.6022241\",\n \"0.59639454\",\n \"0.595931\",\n \"0.595931\",\n \"0.595931\",\n \"0.5933927\",\n \"0.59294194\",\n \"0.5908512\",\n \"0.5903635\",\n \"0.5901329\",\n \"0.589707\",\n \"0.58871436\",\n \"0.5886245\",\n \"0.58717746\",\n \"0.5865514\",\n \"0.58636314\",\n \"0.58636314\",\n \"0.5845495\",\n \"0.58433616\",\n \"0.58353746\",\n \"0.5833176\",\n \"0.5832716\",\n \"0.5827193\",\n \"0.58167416\",\n \"0.58129436\",\n \"0.58022547\",\n \"0.5799062\",\n \"0.5795675\",\n \"0.5794942\",\n \"0.5786342\",\n \"0.57852787\",\n \"0.5785193\",\n \"0.5779625\",\n \"0.57794476\",\n \"0.5772676\",\n \"0.5771489\",\n \"0.5765838\",\n \"0.57650787\",\n \"0.5755918\",\n \"0.57555485\",\n \"0.57554114\",\n \"0.57551944\",\n \"0.5753711\",\n \"0.5753584\",\n \"0.5751765\",\n \"0.57404625\",\n \"0.5738171\",\n \"0.57353044\",\n \"0.5733764\",\n \"0.5732453\",\n \"0.57303804\",\n \"0.5728693\",\n \"0.5728693\",\n \"0.5727266\",\n \"0.57191586\",\n \"0.5712289\",\n \"0.57103074\",\n \"0.5708468\",\n \"0.5707887\",\n \"0.57040226\",\n \"0.5703141\",\n \"0.5702125\",\n \"0.56919396\",\n \"0.56896967\",\n \"0.5685612\",\n \"0.5684273\",\n \"0.56773394\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6309714"},"document_rank":{"kind":"string","value":"7"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":760,"numItemsPerPage":100,"numTotalItems":95772,"offset":76000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjU3NzA1MywianRpIjoiN2YyMzZiNDMtYjRmNy00YjlkLWI2MDMtZGNlYTU2NGNhN2YyIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY1ODA2NTMsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.ryfjf3RbJ0O8rrXnHjvRKJFAPygCkDnXUDDZfJtBgYWN4UeEf_xa6m6hAoeHXaRroPcuwLIidyPWBkEtCjtPBQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Indicates that the parser enters into an unsupportedattributestag group. | def unsupported_attributes_tag(self) :
self._curattributes = self._unsupported_attributes
return self.parseTag() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unknown_starttag(self, tag, attrs):\n if tag in self.valid_tags:\n self.result.append('<' + tag)\n for k, v in attrs:\n if string.lower(k[0:2]) != 'on' and",
"def test_fetchParserUnknownAttribute(self):\n p = imap4._Fet... | [
"0.5917786",
"0.5775716",
"0.56351364",
"0.5381743",
"0.53326553",
"0.5275372",
"0.5197594",
"0.5179682",
"0.5155139",
"0.509307",
"0.5074497",
"0.5070778",
"0.5019276",
"0.49966884",
"0.49966884",
"0.49716008",
"0.4971445",
"0.49685493",
"0.49527672",
"0.49197876",
"0.491650... | 0.70035094 | 0 |
Indicates that the parser enters into a subscriptionattributestag group. | def subscription_attributes_tag(self) :
self._curattributes = self._subscription_attributes
return self.parseTag() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __on_group_created(self, logger, *args):",
"def on_subscribe( client, userdata, mid, granted_qos ):\n logging.info( \"Topic successfully subcribed with QoS: %s\" %granted_qos )",
"def log_group_arn(self) -> str:\n ...",
"def process(self, event):\n matchgroups = {}\n try:\n ... | [
"0.5545517",
"0.48461246",
"0.47890064",
"0.4731607",
"0.46983153",
"0.4677109",
"0.4675229",
"0.4673879",
"0.46679845",
"0.4644136",
"0.4639828",
"0.4598391",
"0.4586624",
"0.4523136",
"0.45071408",
"0.45024773",
"0.4499094",
"0.4495115",
"0.4495115",
"0.4495115",
"0.4485821... | 0.53500694 | 1 |
Indicates that the parser enters into an eventnotificationattributestag group. | def event_notification_attributes_tag(self) :
self._curattributes = self._event_notification_attributes
return self.parseTag() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __on_group_created(self, logger, *args):",
"def unknown_starttag(self, tag, attrs):\n if tag in self.valid_tags:\n self.result.append('<' + tag)\n for k, v in attrs:\n if string.lower(k[0:2]) != 'on' and",
"def visit_event(s... | [
"0.53819436",
"0.49599183",
"0.49296498",
"0.4853252",
"0.48404688",
"0.48267183",
"0.4818338",
"0.48151654",
"0.47872686",
"0.47819456",
"0.47710592",
"0.47700667",
"0.47468475",
"0.47368065",
"0.4735554",
"0.47104743",
"0.46678525",
"0.466398",
"0.4663215",
"0.46572715",
"0... | 0.59145147 | 0 |
Finner geometritype og antall koordinatpunkt i WKT streng | def koordinatpunkt( wktstring ):
wkt_type = wktstring.split()[0]
if 'Z' in wktstring[0:30].upper():
wkt_type += ' Z'
wktstring = re.sub( r'[a-zA-Z]+', '', wktstring)
wktstring = re.sub( r'\(+', '', wktstring)
wktstring = re.sub( r'\)+', '', wktstring)
antall_koordinatpunkt = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wgs84_wkt():\n return WGS84.to_wkt()",
"def spatial(self):",
"def geo_transform(self):\n pass",
"def point2wgs84(self, crsop):\n latr = math.radians(self.lat)\n lngr = math.radians(self.lng)\n \n # a is the semi-major axis of given datum.\n a = crsop.Semimajor... | [
"0.69687706",
"0.69472766",
"0.6695512",
"0.64280033",
"0.64193696",
"0.64041555",
"0.6368389",
"0.61432874",
"0.59421605",
"0.5880003",
"0.5833728",
"0.5769047",
"0.57581174",
"0.57469046",
"0.5734468",
"0.5733256",
"0.57178426",
"0.5708388",
"0.5700761",
"0.5630413",
"0.561... | 0.60767895 | 8 |
Lager statistikk over antall lenker og utbredelse til NVDB stedfesting | def veglenkestatistikk( stedfesting ):
antall_stedfestingelementer = len( stedfesting )
utbredelse = None
unike_veglenker = None
if 'type' in stedfesting[0]:
if stedfesting[0]['type'] == 'Linje':
utbredelse = sum( [ k['sluttposisjon']-k['startposisjon'] for k in stedfestin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query3() :",
"def update_vluln_table():",
"def ustvari(self):\n raise NotImplementedError",
"def get_total_stateless(db):\n pass",
"def stats(self):",
"def overheadstats(sdb, obsdate, update=True):\n bvs_updated = 0\n scams=0\n #for a given obsdate get the night info\n nid=getnighti... | [
"0.57543916",
"0.55784565",
"0.55619425",
"0.5497133",
"0.54629505",
"0.5411191",
"0.5397337",
"0.52770716",
"0.524446",
"0.52380294",
"0.5190501",
"0.51876616",
"0.5183608",
"0.5163349",
"0.5152543",
"0.51474845",
"0.5139914",
"0.50777394",
"0.5056625",
"0.50381786",
"0.5028... | 0.6221996 | 0 |
Using eigen value decomposition (eigendecomposition) for dimensionality reduction. Outputs the components that explain X% of the variance in the data. (X% is the quality_percent). TAKES TOO MUCH TIME, BECAUSE OF THE COVARIANCE MATRIX. | def fit_evd(self):
# EVD only work on square matrices as we need to compute the eigenvalues and eigenvectors
# For this we compute the covariance matrix K
# K should be n x n matrix (pixels x pixels)
# The covariance matrix is nxn
self.cov_matrix = np.zeros(shape=[self.n_featur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eigen_decomposition(X, features):\n # Center to average\n Xctr = X - X.mean(0)\n # covariance matrix\n Xcov = np.cov(Xctr.T)\n\n # Compute eigenvalues and eigenvectors\n eigen_values, eigen_vectors = sp.linalg.eigh(Xcov)\n\n # Sort the eigenvalues and the eigenvectors descending\n sorte... | [
"0.65321",
"0.6287839",
"0.6122023",
"0.6052969",
"0.60071176",
"0.5969323",
"0.58543324",
"0.5676435",
"0.5669116",
"0.56286806",
"0.5590691",
"0.55898774",
"0.5563641",
"0.5545428",
"0.5533987",
"0.5528895",
"0.5517526",
"0.54985064",
"0.54313755",
"0.5378376",
"0.5334669",... | 0.68186647 | 0 |
Dimensionality reduction using singular value decomposition (SVD). Outputs the components that explain X% of the variance in the data. (X% is the quality_percent) | def fit_svd(self):
# U has the eigenvectors of G.Gt as columns ()
# S has square roots of the eigenvalues of G.Gt and Gt.G in its diagonal
# The square roos of the eigenvalues are called singular values
# V has the eigenvectors of Gt.G as columns ()
# full_matrices set to false ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def svd(self, X): # [5pts]\n N,D = X.shape[0],X.shape[1]\n if X.ndim == 3:\n U = np.zeros((N,N,3))\n S = np.zeros((min(N,D),3))\n V = np.zeros((D,D,3))\n for i in range(3):\n U_temp,S_temp,V_temp = np.linalg.svd(X[:,:,i],compute_uv=True, full... | [
"0.69040626",
"0.68697",
"0.6656673",
"0.6501096",
"0.6389488",
"0.6386059",
"0.6347023",
"0.6329251",
"0.6273901",
"0.62269294",
"0.62042505",
"0.61884207",
"0.61802185",
"0.61400044",
"0.6100364",
"0.605698",
"0.6007152",
"0.6001164",
"0.598117",
"0.5975402",
"0.5959942",
... | 0.70182264 | 0 |
Uses the components from the fit functions to transform an Image_matrix (of the training or testing set) | def transform(self, image_matrix):
# Centering the data
mean = np.mean(image_matrix, axis=0)
image_matrix = image_matrix - mean
# Dimension reduction is done by multiplying the original matrix with the components
transformed_matrix = np.dot(image_matrix, self.components.T)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_transform(self, x: Array2D) -> Array2D:",
"def _apply_transform(self, img: np.ndarray): \n img = self.transform(image=img)[\"image\"]\n return img",
"def _apply_transform(self, img: np.ndarray): \n img = self.transform(image=img)[\"image\"]\n return img",
"def apply_transf... | [
"0.6525222",
"0.6483429",
"0.6483429",
"0.6235002",
"0.6186154",
"0.6173184",
"0.61298996",
"0.60044026",
"0.5990308",
"0.59790784",
"0.5963861",
"0.5924043",
"0.5909698",
"0.59093964",
"0.59062135",
"0.5882084",
"0.583149",
"0.58172005",
"0.5807438",
"0.5804453",
"0.5762179"... | 0.6286367 | 3 |
Loads class labels at 'path' | def load_classes(path):
fp = open(path, "r")
names = fp.read().split("\n")[:-1]
# -1까지 하는 이유 마지막에 공백이 있다.
print("Load Class Nums : ",len(names))
return names | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_labels(self, pathLabel):\n self.pathLabel = pathLabel\n self.labelList = os.listdir(pathLabel)",
"def load_label(path: str) -> dict:\n if not os.path.exists(path):\n print(f\"Warning, try to load non-exist label {path}\")\n return None\n return np.load(path, allow_pickl... | [
"0.76263887",
"0.70822763",
"0.6987063",
"0.6917422",
"0.6886614",
"0.684222",
"0.6831526",
"0.67475176",
"0.67435664",
"0.6732817",
"0.66995424",
"0.6691952",
"0.6691952",
"0.6649412",
"0.66031843",
"0.6593739",
"0.65641505",
"0.649268",
"0.6491007",
"0.6329085",
"0.6310958"... | 0.6657494 | 13 |
Compute true positives, predicted scores and predicted labels per sample | def get_batch_statistics(outputs, targets, iou_threshold):
batch_metrics = []
for sample_i in range(len(outputs)): # output 은 배열형태
if outputs[sample_i] is None:
continue
output = outputs[sample_i]
pred_boxes = output[:, :4]
pred_scores = output[:, 4]
pred... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prediction():\r\n\r\n\r\n\tpredictVal = []\r\n\taccuracy = 0.0\r\n\r\n\t# Calculate accuracy for each class in testData\r\n\tfor item in testData:\r\n\t\tclass0Prediction = posProb / 100\r\n\t\tclass1Prediction = negProb / 100\r\n\t\t\r\n\t\t# Multiply the prior probablities for negative and positive reviews b... | [
"0.7230884",
"0.72161835",
"0.72122383",
"0.72010857",
"0.7200459",
"0.7191637",
"0.7166481",
"0.7063089",
"0.70126003",
"0.70126003",
"0.6979515",
"0.69782597",
"0.69651514",
"0.6958174",
"0.6927955",
"0.6899901",
"0.6873471",
"0.6863262",
"0.6822898",
"0.68122464",
"0.68022... | 0.0 | -1 |
Parse content and metadata of markdown files. | def read(self, source_path):
self._source_path = source_path
self._md = Markdown(extensions=self.extensions)
# Custom handling of ^include.html^
self._md.inlinePatterns['include_html'] = IncludeHtmlPattern(self)
with pelican_open(source_path) as text:
content = sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_markdown(self):\n renderer = MyRenderer()\n md = mistune.Markdown(renderer=renderer)\n md.render(self._markdown_text)\n self._bash_commands = renderer._bash_commands",
"def read(self, source_path):\r\n\r\n self._md = Markdown(extensions=self.extensions)\r\n wi... | [
"0.703052",
"0.6902194",
"0.6663789",
"0.66204745",
"0.6522781",
"0.64834344",
"0.6438712",
"0.63117796",
"0.6289006",
"0.6217851",
"0.6162338",
"0.61167693",
"0.60662013",
"0.6044367",
"0.59481674",
"0.5941305",
"0.59341216",
"0.5924921",
"0.5914844",
"0.5913281",
"0.5899294... | 0.6742364 | 2 |
Parse content and metadata of .yml files | def read(self, source_path):
content = None
metadata = dict()
self._source_path = source_path
with pelican_open(source_path) as text:
metadata = yaml.load(text)
# Turn these into expected objects
# 'author': pelican.urlwrappers.Author object
if 'auth... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_yamls(folder):\n for item in iglob(folder + \"/*.yaml\"):\n data_file = os.path.join(folder, item)\n data = yaml.load(open(data_file))\n load_data(data)",
"def parse(file_contents, file_name):\n\n try:\n yaml.load(file_contents)\n except Exception:\n\n _, e... | [
"0.63108075",
"0.61328685",
"0.6085054",
"0.60793495",
"0.6052815",
"0.6027979",
"0.5993412",
"0.5960239",
"0.591337",
"0.59100944",
"0.590964",
"0.58585054",
"0.584181",
"0.5835282",
"0.58184296",
"0.57883096",
"0.5787211",
"0.573365",
"0.5728019",
"0.5714711",
"0.5706502",
... | 0.6347969 | 0 |
Called when the Readers instance has parsed the READERS settings. Associate all Markdown file extensions with the MarkdownExtReader. | def on_readers_init(readers):
for fmt in MarkdownExtReader.file_extensions:
readers.reader_classes[fmt] = MarkdownExtReader | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def registerExtensions(self, extensions, configs):\n for ext in extensions:\n try:\n if isinstance(ext, util.string_type):\n ext = self.build_extension(ext, configs.get(ext, []))\n if isinstance(ext, Extension):\n ext.extendMarkd... | [
"0.5789195",
"0.5561572",
"0.5184722",
"0.5121114",
"0.5109936",
"0.51069635",
"0.506897",
"0.5020507",
"0.4993649",
"0.49655452",
"0.49195173",
"0.4918681",
"0.4900654",
"0.48862994",
"0.48733476",
"0.48583728",
"0.4821897",
"0.48209038",
"0.47776324",
"0.47749218",
"0.47437... | 0.8195992 | 0 |
Check all the posts in the subreddit for | def parse_sub_reddits(sub_reddit: str,
match_words: list):
url_to_open = f"https://www.reddit.com/r/{sub_reddit}.json"
success_status = 0
while success_status != 200:
try:
response = urlopen(url_to_open, timeout=10)
success_status = response.status
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iteratePosts(self):\n try:\n replies = self.soup.find('div','vt_postrow_holder').findAll('div', 'vt_postrow_rest')\n if not replies:\n log.info(self.log_msg('No posts found in url %s'%self.currenturi))\n return False\n replies.reverse()\n ... | [
"0.66930366",
"0.6662355",
"0.65778077",
"0.6348439",
"0.6179751",
"0.6077247",
"0.6058444",
"0.6025194",
"0.5994543",
"0.5980211",
"0.5944144",
"0.58667725",
"0.58650124",
"0.5832116",
"0.58242166",
"0.57604986",
"0.5733013",
"0.57307196",
"0.5701638",
"0.56455827",
"0.56387... | 0.5699975 | 19 |
Generates a pandas dataframe with scraped comments and replies data. Will concatenate replies with comments | def comment_data(post_id: str,
sub_reddit: str):
url_to_open = f"https://www.reddit.com/r/{sub_reddit}/comments/{post_id}.json"
success_status = 0
while success_status != 200:
try:
response = urlopen(url_to_open, timeout=10)
success_status = response.status
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_comments(**kwargs):\r\n\r\n # Log in to get cookies.\r\n cookies = _login(**kwargs)\r\n\r\n if 'r' not in kwargs:\r\n # This is the first comments request.\r\n # Make the comments request and set an empty list.\r\n kwargs['r'] = requests.get('https://news.ycombinator.com/thre... | [
"0.6028869",
"0.59971136",
"0.594456",
"0.59385234",
"0.592934",
"0.5916526",
"0.5916526",
"0.5870459",
"0.58392066",
"0.58221716",
"0.5795665",
"0.5788009",
"0.57595724",
"0.5736693",
"0.5731914",
"0.5636468",
"0.56259465",
"0.56077534",
"0.5583711",
"0.5546369",
"0.552571",... | 0.6636042 | 0 |
Appends to CSVs and removes any duplicated tweets or users before saving | def stream_to_db(subreddit: str,
df_dict: dict,
db_path: str) -> None:
file_lkps = {'posts': f"reddit-{subreddit}-posts.csv",
'comments': f"reddit-{subreddit}-comments.csv"}
for _key in df_dict:
if df_dict.get(_key) is None:
pass
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_to_file(self) -> None:\n with open(self.output_file_path, mode='w', newline='') as csv_file:\n tweet = ['id', 'created_time', 'text']\n writer = csv.DictWriter(csv_file, fieldnames=tweet)\n writer.writeheader()\n for tweet in self.clean_unique_tweets:\n ... | [
"0.6951189",
"0.6666629",
"0.63679606",
"0.6294705",
"0.62620443",
"0.6217467",
"0.61684036",
"0.60575086",
"0.6054395",
"0.60091347",
"0.5874869",
"0.58692265",
"0.5854355",
"0.58093345",
"0.57850754",
"0.5769864",
"0.5757674",
"0.5757009",
"0.57195675",
"0.5675526",
"0.5671... | 0.0 | -1 |
The identity block is the block that has no ConvGRU layer at shortcut. Arguments | def identity_block(input_tensor, kernel_size, filters, stage, block):
filters1, filters2, filters3 = filters
if K.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def identity_block(self,X,stage,block):\n conv_name_base='res'+str(stage)+block+'_branch'\n bn_name_base='bn'+str(stage)+block+'_branch'\n \n #retrieve the filters\n #F1,F2,F3=filters\n \n X_shortcut=X\n \n #first component of main path\n X=Conv... | [
"0.7053969",
"0.6951196",
"0.69148076",
"0.69123244",
"0.69026166",
"0.6895569",
"0.68718547",
"0.68239397",
"0.67982614",
"0.6778847",
"0.6770707",
"0.6738197",
"0.67351675",
"0.67298466",
"0.67144144",
"0.67034507",
"0.67034507",
"0.66972566",
"0.6693836",
"0.66613907",
"0.... | 0.7369076 | 0 |
A block that has a conv layer at shortcut. Arguments | def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(2, 2)):
filters1, filters2, filters3 = filters
if K.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conv_block(self, output_channel, filter_, activate):\n return self.add_layer(conv_block, output_channel, filter_, activate)",
"def _convolution_block(self, X, filters, f, s, stage, block):\n\n\t\tconv_layer_name = 'res' + str(stage) + block + '_branch'\n\t\tbn_layer_name = 'bn' + str(stage) + block + ... | [
"0.72210574",
"0.6797653",
"0.67508686",
"0.673468",
"0.6702727",
"0.66709983",
"0.66706705",
"0.6638113",
"0.6602907",
"0.6602907",
"0.65983295",
"0.65591985",
"0.6556552",
"0.6553555",
"0.6531844",
"0.65101147",
"0.650745",
"0.6479069",
"0.6421294",
"0.64118993",
"0.6391051... | 0.6319449 | 30 |
CallChangeOption Helper function used to call Config.ChangeOption. | def CallChangeOption(event, option, val, IdRange=0):
Config.ChangeOption(option, val, IdRange) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cb_config(data, option, value):\n option_name = option.split(\".\")[-1]\n if option_name in vimode_settings:\n vimode_settings[option_name] = value\n return weechat.WEECHAT_RC_OK",
"def __call__(self, givenEvent):\n return self._options[givenEvent]()",
"def config_option(func):\n\n ... | [
"0.5770124",
"0.56601584",
"0.5591877",
"0.54953575",
"0.541492",
"0.5305409",
"0.52639145",
"0.524375",
"0.5221593",
"0.51719373",
"0.51574725",
"0.5091422",
"0.5087586",
"0.502432",
"0.5001329",
"0.49955308",
"0.4986194",
"0.49639228",
"0.49518788",
"0.49281865",
"0.4927516... | 0.8534425 | 0 |
CallChangeColorFile Used to call ChangeColorFile | def CallChangeColorFile(event, item, newcolor):
ChangeColorFile(item, newcolor)
event.Skip() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_file_change(op_list_file):\n if os.path.exists(\"flag_change_file.txt\"):\n print(\n \"-----maybe op_file has changed, so don't need to change again------\"\n )\n else:\n run_multi_thread(op_list_file)",
"def setColorDiffuse(*args):",
"def _color(self, args):",
"... | [
"0.5624063",
"0.5616077",
"0.55919427",
"0.5476601",
"0.5475762",
"0.546004",
"0.54469645",
"0.54314727",
"0.5325275",
"0.5319817",
"0.5314164",
"0.5309682",
"0.53093964",
"0.52945733",
"0.52685404",
"0.5266808",
"0.5259466",
"0.52457315",
"0.524514",
"0.52394056",
"0.5238474... | 0.82037705 | 0 |
ToggleSpinner Disables or enables the suplied widget depending on the arguments. | def ToggleSpinner(event, state, widget):
if state == True:
widget.Enable()
else:
widget.Disable()
event.Skip() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toggle(self):\n if self.is_enabled:\n self.disable()\n else:\n self.enable()",
"def getSpinControl(*args):",
"def toggle(self, **kwargs):\n self.on = False if self.on else True",
"def spin(self):\n spinner = self._spinner_dict.get(self._current_gui, lambd... | [
"0.60068536",
"0.5711606",
"0.5626328",
"0.559918",
"0.5583677",
"0.55804306",
"0.55801517",
"0.5556936",
"0.5454728",
"0.5453252",
"0.54468673",
"0.54066956",
"0.5290974",
"0.5263952",
"0.5262461",
"0.5248748",
"0.5246615",
"0.5209481",
"0.5189879",
"0.5189879",
"0.5099715",... | 0.82428086 | 0 |
__init__ Builds the entire frame GUI and binds their events across 3 Notebook tabs. | def __init__(self, IdRange, parent=None):
wx.Frame.__init__(self, parent, -1, 'Settings', size=(300, 500))
self.SetIcon(wx.Icon('icons/gEcrit.png', wx.BITMAP_TYPE_PNG))
ConfigBook = wx.Notebook(self)
dflt_text_win = DefaultCodeFr(self, -1)
ConfigPanel = wx.Panel(ConfigBook)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self,*args, **kwargs):\n tk.Tk.__init__(self, *args, **kwargs)\n self.winfo_toplevel().title(\"ElogQP\")\n self.container = tk.Frame(self)\n self.container.pack(side=\"top\", fill=\"both\", expand=True)\n self.container.grid_rowconfigure(0, weight=1)\n self.co... | [
"0.7510324",
"0.7279233",
"0.7052397",
"0.6984583",
"0.6961576",
"0.6837817",
"0.67607445",
"0.67595774",
"0.67372406",
"0.6733946",
"0.67217106",
"0.67028195",
"0.6688515",
"0.6667774",
"0.6654397",
"0.6649185",
"0.66375756",
"0.6632218",
"0.66252106",
"0.6616836",
"0.661658... | 0.0 | -1 |
ShowMe Makes window visible. | def ShowMe(self, event):
self.Show(True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_window(self):\n self.show()",
"def show(self):\n self._window.show()",
"def show(self, window):\r\n\r\n return",
"def show(self):\n self.wid.show()",
"def show_window(self):\n self._window.grab_set()\n self._window.wait_window()",
"def show(self):\n ... | [
"0.78528696",
"0.7491415",
"0.734914",
"0.72472316",
"0.7217072",
"0.7105373",
"0.709106",
"0.70552",
"0.6812878",
"0.68034613",
"0.6783857",
"0.67171425",
"0.66291493",
"0.66144276",
"0.65156806",
"0.65005463",
"0.6489242",
"0.6466619",
"0.6453149",
"0.6444627",
"0.6414573",... | 0.7963508 | 0 |
HideMe Hides the window. | def HideMe(self, event):
self.Hide() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hide (self):\n \n self.top.withdraw()",
"def hide(self):\n\n self.stop_repl()\n self.visible = False\n self.withdraw() # Hide window",
"def hideWindow(*args, **kwargs):\n\targs[0].hide()\n\treturn True # Prevents windows from being destroyed",
"def hide_gui():\n ... | [
"0.7509359",
"0.74262136",
"0.74119747",
"0.7347229",
"0.7313304",
"0.7259042",
"0.72342604",
"0.72129107",
"0.712137",
"0.71150166",
"0.70670795",
"0.695298",
"0.695298",
"0.69347274",
"0.69264334",
"0.68977106",
"0.6878487",
"0.6852868",
"0.68457806",
"0.68457806",
"0.66689... | 0.8016458 | 0 |
viewLog Creates child class and the required controls to view the log file. | def viewLog(self, event):
logcontent = ""
if Config.GetOption("ActLog") == True:
logFrame = wx.Frame(None, -1, "View Log", size=(500, 500))
panel5 = wx.Panel(logFrame)
data = wx.richtext.RichTextCtrl(panel5, pos=(0, 0), size=(500,
500))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def onViewLog(self):\n view_log.ViewLog(self.root, self.log)",
"def __init__(self, log):\n self.log = log\n self.logger = logging.getLogger(self.__class__.__name__)",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.log = logging.getLogger(logg... | [
"0.7140692",
"0.6262259",
"0.6205708",
"0.6183581",
"0.6140777",
"0.6120262",
"0.6110456",
"0.6074646",
"0.6068381",
"0.5992768",
"0.59753233",
"0.59445345",
"0.5932987",
"0.59261584",
"0.5916817",
"0.5870651",
"0.5854801",
"0.582109",
"0.5819214",
"0.57651544",
"0.57493365",... | 0.6518171 | 1 |
Deletes a database (including all of its content) | def dropDatabase(database: str) -> int:
bd = _database(database)
if bd:
mode = bd["modo"]
val = -1
if mode == "avl":
val = avl.dropDatabase(database)
elif mode == "b":
val = b.dropDatabase(database)
elif mode == "bplus":
val = bp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete():\n\n from slicr.extensions import db\n\n click.echo('deleting database...')\n\n db.drop_all()",
"def delete_db():\n db.drop_all()",
"def delete_database(self, db_name):\n seqids = self.read_sequence_ids()\n if seqids.has_key(db_name):\n del seqids[db_name]\n ... | [
"0.8474899",
"0.8428532",
"0.8335932",
"0.8017926",
"0.7911105",
"0.78136265",
"0.77087384",
"0.76592094",
"0.7650008",
"0.7644191",
"0.76279265",
"0.76096135",
"0.75515336",
"0.7541356",
"0.7520412",
"0.7507527",
"0.7507527",
"0.7507527",
"0.7507527",
"0.7507527",
"0.7507527... | 0.6470409 | 85 |
Show stored tables in a database | def showTables(database: str) -> list:
bd = _database(database)
if bd:
temp = []
for tabla in bd["tablas"]:
temp.append(tabla["nombre"])
return temp
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_tables(db_name):\n output = execute_sql(db_name, \"SELECT name FROM sqlite_master WHERE type='table';\")\n return output",
"def print_all_tables(self):\n conn = self.connect()\n cursor = conn.cursor()\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table';\")\n ... | [
"0.8200163",
"0.81605095",
"0.7972206",
"0.79212195",
"0.7688659",
"0.76660615",
"0.74795884",
"0.74692786",
"0.725298",
"0.72428435",
"0.7228695",
"0.7196219",
"0.71868455",
"0.7164307",
"0.71335703",
"0.71097875",
"0.70934194",
"0.7086187",
"0.7042627",
"0.7024616",
"0.6973... | 0.7387159 | 8 |
Shows the content of a table in a database | def extractTable(database: str, table: str) -> list:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.extractTable(database, table)
elif mode == "b":
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_table():\n\n title_list = ('ID', 'Platform', 'Producer', 'Year', 'Elements')\n \n return table, title_list",
"def show_table(table):\n # id: string\n # Unique and random generated (at least 2 special char()expect: ';'),\n # 2 number, 2 lower and 2 upper case letter)\n # title: strin... | [
"0.7212587",
"0.71289164",
"0.70197195",
"0.6874066",
"0.68284047",
"0.68177825",
"0.6747309",
"0.6714994",
"0.671255",
"0.66996676",
"0.6638418",
"0.6635951",
"0.66036886",
"0.65979177",
"0.6573617",
"0.6500042",
"0.64614534",
"0.6458373",
"0.6449587",
"0.6435649",
"0.640571... | 0.0 | -1 |
Shows the content whitin a range of a table in a database | def extractRangeTable(database: str, table: str, columnNumber: int, lower: any, upper: any) -> list:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.extractRangeT... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def range_table(self):\n raise NotImplementedError('Abstract method.')",
"def show_from_database(self, table_model):\n arr = [4, 1]\n # TODO",
"def stellar_parameter_range(database, wg=None):\n\n if wg is None:\n nodes = database.retrieve(\"SELECT id, wg, name FROM nodes\")\n ... | [
"0.6461188",
"0.6133613",
"0.6034139",
"0.60295755",
"0.59628725",
"0.58607167",
"0.5770134",
"0.574829",
"0.57135546",
"0.5680441",
"0.5577699",
"0.55736077",
"0.5572799",
"0.55701166",
"0.5559747",
"0.5543442",
"0.55161947",
"0.551111",
"0.5509736",
"0.5483184",
"0.5446467"... | 0.6045047 | 2 |
Adds a PK to a table in a database | def alterAddPK(database: str, table: str, columns: list) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.alterAddPK(database, table, columns)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_primary_key(conn, schema, table, pk_col):\n sql_str = \"\"\"alter table {schema}.{table} add primary key ({col})\"\"\".format(\n schema=schema, table=table, col=pk_col)\n\n conn.execute(sql_str)",
"def _add_pk(self, conn, *, tblname, pk_columns):\n idx_metadatum = partition_utils.Inde... | [
"0.797413",
"0.7212407",
"0.69147974",
"0.64817303",
"0.63581043",
"0.63272965",
"0.6162341",
"0.61356944",
"0.5969361",
"0.5936504",
"0.59194344",
"0.5830549",
"0.5788693",
"0.5765031",
"0.5741231",
"0.5717886",
"0.5691602",
"0.56784236",
"0.5649651",
"0.5644707",
"0.5643967... | 0.59272844 | 10 |
Deletes PKs of a table in a database | def alterDropPK(database: str, table: str) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.alterDropPK(database, table)
elif mode == "b":
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deletePlayers():\n executeNonQuery(\"TRUNCATE TABLE players CASCADE;\")",
"def deletePlayers():\n\n conn, c = main.connect()\n\n c.execute(\"TRUNCATE player CASCADE\")\n\n conn.commit()\n conn.close()",
"def _delete (self):\n self._exec ('delete from table_name where id=%(id)s')",
"... | [
"0.67841387",
"0.67500883",
"0.66656727",
"0.66598505",
"0.6647046",
"0.6556503",
"0.64608335",
"0.6454066",
"0.6424887",
"0.63952935",
"0.635271",
"0.6331988",
"0.63253903",
"0.63232535",
"0.6317377",
"0.6269487",
"0.62475073",
"0.62289524",
"0.620775",
"0.61977184",
"0.6180... | 0.5870445 | 50 |
Renames a table in a database | def alterTable(database: str, tableOld: str, tableNew: str) -> int:
bd = _database(database)
if bd:
tb = _table(database, tableOld)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.alterTable(database, tableOld, tableNew)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rename_table(base, tablename: str, table: Table) -> str:\n return snake_to_camel(tablename, upper=True)",
"def rename_table(self):\n\n return \"\"\"ALTER TABLE \"users\" RENAME TO \"core\\\"\"\"\"",
"def test_rename_table(self):\n name_column = Varchar()\n name_column._meta.name = \... | [
"0.7940475",
"0.74909514",
"0.7356303",
"0.7134465",
"0.70825166",
"0.6972991",
"0.6942648",
"0.6555865",
"0.64656806",
"0.6425714",
"0.6373571",
"0.6366362",
"0.6279711",
"0.62735",
"0.626685",
"0.6241444",
"0.6194818",
"0.61261487",
"0.60878855",
"0.6052213",
"0.6016514",
... | 0.54558754 | 54 |
Appends a column to a table in a database | def alterAddColumn(database: str, table: str, default: any) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.alterAddColumn(database, table, default)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _addColumn(self, table, column, init_data):\n\t\tcommand = \"ALTER TABLE \" + table + \" ADD COLUMN \" + str(column) + \" \" + getSQLiteType(init_data)\n\t\ttry:\n\t\t\tself._run_command(command)\n\t\texcept sqlite3.OperationalError:\n\t\t\tprint(\"Column \" + str(column) + \" already exists!\")",
"def add_c... | [
"0.76016784",
"0.7577322",
"0.74984765",
"0.73872393",
"0.7291336",
"0.7279017",
"0.7264292",
"0.7258774",
"0.72526145",
"0.7250797",
"0.7218453",
"0.70894194",
"0.7047689",
"0.7037254",
"0.6983311",
"0.69097465",
"0.6874578",
"0.6850834",
"0.68338376",
"0.6822801",
"0.682184... | 0.56772554 | 98 |
Deletes a column of a table in a database | def alterDropColumn(database: str, table: str, columnNumber: int) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.alterDropColumn(database, table, columnN... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def del_column(self, fieldname):\n ...",
"def deleteColumn(self, table: Table, column: Column,\n noLine, noColumn):\n database = SymbolTable().useDatabase\n if not database:\n desc = f\": Database not selected\"\n ErrorController().add(4, 'Execution'... | [
"0.80468893",
"0.7498241",
"0.7320566",
"0.7136943",
"0.7135099",
"0.7094313",
"0.67570573",
"0.67331475",
"0.6698586",
"0.6558055",
"0.65470445",
"0.6537746",
"0.6529836",
"0.65186834",
"0.65159416",
"0.6453438",
"0.6452822",
"0.6425234",
"0.628794",
"0.6216746",
"0.6178394"... | 0.6225687 | 19 |
Deletes a table in a database (including all of its content) | def dropTable(database: str, table: str) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.dropTable(database, table)
elif mode == "b":
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _delete_table(self, db, table_name):\n pass",
"def deleteTable(self):\n return self.db.table_drop(self.entity).run(self.r)",
"def delete_table(db, table_name):\n global DB_CONNECTIONS\n con = DB_CONNECTIONS.get(db, None)\n if con is not None:\n db_name = Path(db).name\n ... | [
"0.8282871",
"0.8208072",
"0.81827366",
"0.794374",
"0.79349744",
"0.7882655",
"0.78345776",
"0.7790499",
"0.7784332",
"0.7678593",
"0.76676506",
"0.7639929",
"0.76353526",
"0.75528246",
"0.7545451",
"0.750076",
"0.7459097",
"0.74460846",
"0.74400544",
"0.74296826",
"0.741218... | 0.0 | -1 |
Inserts a register into a table in a database | def insert(database: str, table: str, register: list) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
encoding = bd["encoding"]
mode = tb["modo"]
for y in register:
if type(y) == str:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register(self, username, password, phone, email):\n \n cur = self.db.cursor()\n query = \"\"\"INSERT INTO users( username, password, phone, email)\n VALUES(%s, %s, %s, %s) RETURNING username, password, phone, email;\"\"\"\n \n data = (username, password, phone, email)\... | [
"0.73191357",
"0.7190302",
"0.7068214",
"0.6826038",
"0.6779107",
"0.67736864",
"0.6741166",
"0.6665618",
"0.66551596",
"0.6636065",
"0.65866435",
"0.6579655",
"0.6553802",
"0.651125",
"0.64816",
"0.64687675",
"0.6458481",
"0.64559144",
"0.64423525",
"0.64351416",
"0.6427935"... | 0.66108173 | 10 |
Loads a csv file and inserts its content into a table in a database | def loadCSV(file: str, database: str, table: str) -> list:
bd = _database(database)
if bd:
tb = _table(database, table)
encoding = bd["encoding"]
if tb:
mode = tb["modo"]
try:
with open(file, 'r', encoding='utf-8-sig') as leer:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def populate_table_from_csv(csv_file, csv_encoding='iso-8859-15'):\n try:\n with open(file=csv_file, mode='r', encoding=csv_encoding) as input_file:\n # Could find a good place to add iterators/generators/comprehensions elsewhere, so made a new function\n # Also, yet another pylint ... | [
"0.77925056",
"0.74694026",
"0.7324558",
"0.7270698",
"0.7181123",
"0.7180284",
"0.71793205",
"0.7163057",
"0.71629786",
"0.71574324",
"0.71534336",
"0.71316504",
"0.70502",
"0.704839",
"0.69889295",
"0.69630796",
"0.6903439",
"0.68700767",
"0.6814116",
"0.6785114",
"0.677750... | 0.0 | -1 |
Shows a register of a table in a database | def extractRow(database: str, table: str, columns: list) -> list:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.extractRow(database, table, columns)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_register_form():\n return render_template(\"register-form.html\")",
"def show(self):\n return view('auth/register', {'app': application, 'Auth': Auth(self.request), 'json': json})",
"def register_form():\n\n return render_template(\"register.html\")",
"def register_form():\n\n return... | [
"0.62542564",
"0.61312747",
"0.6043063",
"0.5966525",
"0.59552217",
"0.59499764",
"0.5833451",
"0.58298564",
"0.5817573",
"0.58131176",
"0.57852143",
"0.57403255",
"0.5733492",
"0.57310855",
"0.56588715",
"0.5648972",
"0.5645039",
"0.5632103",
"0.5623753",
"0.5616882",
"0.558... | 0.0 | -1 |
Updates a register into a table in a database | def update(database: str, table: str, register: dict, columns: list) -> int:
datosAntiguos = False
nombreST = str(database) + '-' + str(table)
if BC.EsUnaTablaSegura(nombreST, _main_path):
datosAntiguos = extractRow(database, table, columns)
bd = _database(database)
if bd:
tb = _t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register(self, username, password, phone, email):\n \n cur = self.db.cursor()\n query = \"\"\"INSERT INTO users( username, password, phone, email)\n VALUES(%s, %s, %s, %s) RETURNING username, password, phone, email;\"\"\"\n \n data = (username, password, phone, email)\... | [
"0.6516402",
"0.6428764",
"0.6402065",
"0.6328693",
"0.6220912",
"0.6200072",
"0.6200072",
"0.617463",
"0.61485815",
"0.6130257",
"0.6029388",
"0.5936732",
"0.59345907",
"0.5929567",
"0.589191",
"0.5871383",
"0.5854142",
"0.58514607",
"0.58431804",
"0.5804175",
"0.576566",
... | 0.5758869 | 21 |
Deletes a register into a table in a database | def delete(database: str, table: str, columns: list) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.delete(database, table, columns)
elif mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self):\n DBSESSION.delete(self)\n DBSESSION.commit()\n LOG.info(f\"Register of {self.str_representation} with id = {self.id} was successfully deleted.\")",
"def delete_table(self, name: str) -> None:",
"def _delete_table(self, db, table_name):\n pass",
"def delete_table... | [
"0.7344221",
"0.7181427",
"0.706336",
"0.7025284",
"0.70190406",
"0.6915389",
"0.6836861",
"0.67948556",
"0.66886204",
"0.6609935",
"0.6599953",
"0.65704",
"0.65645623",
"0.65645623",
"0.65297383",
"0.65135294",
"0.6495734",
"0.6492094",
"0.6489976",
"0.6486023",
"0.64838046"... | 0.0 | -1 |
Deletes the content of a table in a database | def truncate(database: str, table: str) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.truncate(database, table)
elif mode == "b":
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _delete_table(self, db, table_name):\n pass",
"def delete_table(self, name: str) -> None:",
"def deleteTable(self):\n return self.db.table_drop(self.entity).run(self.r)",
"def _delete (self):\n self._exec ('delete from table_name where id=%(id)s')",
"def delete_table_data():\n t... | [
"0.808416",
"0.7975429",
"0.7945793",
"0.7791311",
"0.77786446",
"0.7748327",
"0.77452457",
"0.7692215",
"0.76638746",
"0.7551619",
"0.75302505",
"0.74895793",
"0.7483878",
"0.74780554",
"0.7450529",
"0.7442677",
"0.7392804",
"0.73516816",
"0.73074657",
"0.72962385",
"0.72219... | 0.0 | -1 |
Restructures a database inner structure | def alterDatabaseMode(database: str, mode: str) -> int:
try:
bd = _database(database)
if bd:
if bd["modo"] == mode or mode not in ["avl", "b", "bplus", "dict", "hash", "isam", "json"]:
return 4
data = []
lista_tablas = showTables(database)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_database(self):\n self.DBDict = self.data_df.to_dict(orient=\"index\")\n\n # calculate weight ratio\n self.DBDict = {k: self.calc_compound_weight_ratio(\n self.DBDict[k]) for k in self.DBDict}\n\n # export as dataframe\n self.converted_df = pd.DataFrame(sel... | [
"0.6076564",
"0.58922535",
"0.579",
"0.5749501",
"0.5711321",
"0.56398124",
"0.54710424",
"0.5437469",
"0.5436171",
"0.5378796",
"0.5349269",
"0.53385985",
"0.53322494",
"0.5315631",
"0.52831435",
"0.52700615",
"0.5260067",
"0.5251986",
"0.5149641",
"0.5125559",
"0.5113474",
... | 0.0 | -1 |
Restructures a table inner structure | def alterTableMode(database: str, table: str, mode: str) -> int:
try:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
if tb["modo"] == mode or mode not in ["avl", "b", "bplus", "dict", "hash", "isam", "json"]:
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_table(self):\n i = 0\n for item in ['DN[-]', 'd_out[mm]', 'tl_trub[mm]', 'roztec_trub[mm]', 'delka[mm]', 'roztec_prep[mm]', 'vyska_prep[mm]']:\n self.table.insertColumn(i)\n self.table.setHorizontalHeaderItem(i, QTableWidgetItem(item))\n i += 1\n fo... | [
"0.60329634",
"0.5926206",
"0.59235996",
"0.59156257",
"0.5842843",
"0.5792483",
"0.57503146",
"0.57097197",
"0.5705552",
"0.56952924",
"0.5677851",
"0.5660064",
"0.5639272",
"0.5616803",
"0.5605774",
"0.55533993",
"0.55469185",
"0.5540514",
"0.55137295",
"0.5497372",
"0.5477... | 0.0 | -1 |
Adds a foreign key to a table | def alterTableAddFK(database: str, table: str, indexName: str, columns: list, tableRef: str, columnsRef: list) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
tb_r = _table(database, tableRef)
if tb and tb_r:
if len(columns) != len(columnsRef):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_foreign_key(self, table_name, column, fk_table, fk_column, name=None):\n if not table_name:\n table_name = self.name\n if not name:\n name = self.new_fk_index_name(column, fk_column)\n try:\n self.execute(self.commands.add_foreign_key(\n ... | [
"0.77914417",
"0.6499988",
"0.6481544",
"0.64692926",
"0.6452423",
"0.63490236",
"0.63257205",
"0.6283345",
"0.62422293",
"0.61913806",
"0.61483616",
"0.60246605",
"0.5972212",
"0.5967249",
"0.5918298",
"0.5869725",
"0.56648976",
"0.56552577",
"0.5639564",
"0.56316566",
"0.56... | 0.63679653 | 5 |
Deletes a foreign key | def alterTableDropFK(database: str, table: str, indexName: str) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
fk = _foreign_key(database, indexName)
if fk:
return tb["foreign_keys"].delete(indexName)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drop_foreign_key(self, fk_table_name, fk_name):\n self.execute(self.commands.drop_foreign_key(fk_table_name, fk_name))\n self.commit()",
"def delete(self):\n query = \"DELETE FROM \" + self.table + \" WHERE \" + self.idfield + \"=%s\"\n dbh = dbstuff.getRW(self.dbh_key)\n try:\n c... | [
"0.7307489",
"0.6532903",
"0.6432936",
"0.6427881",
"0.64237875",
"0.6300452",
"0.6284552",
"0.6283573",
"0.62751234",
"0.6270331",
"0.6258694",
"0.620709",
"0.620648",
"0.620648",
"0.620648",
"0.620648",
"0.620648",
"0.620648",
"0.620648",
"0.620648",
"0.620648",
"0.618526... | 0.60653955 | 29 |
Adds an unique index to a table | def alterTableAddUnique(database: str, table: str, indexName: str, columns: list) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
tb["unique_index"].insert([indexName, table, columns])
return 0
else:
return 3
else... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ensure_table_indexes(collection) -> None:\n # Unique ticker event ID\n collection.create_index('data.u', unique=True)\n # The symbol, e.g. BTCUSDT\n collection.create_index('data.s')\n # The time for sorting.\n collection.create_index('time')",
"def create_index(self, indexname, table, colu... | [
"0.6950932",
"0.66842467",
"0.667532",
"0.6672381",
"0.6609532",
"0.6567683",
"0.63993394",
"0.63612676",
"0.6354538",
"0.6333292",
"0.6333292",
"0.632288",
"0.6283021",
"0.62678844",
"0.6257337",
"0.62452674",
"0.6228201",
"0.61746067",
"0.6142951",
"0.60947925",
"0.602906",... | 0.70561254 | 0 |
Deletes an unique index | def alterTableDropUnique(database: str, table: str, indexName: str) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
fk = _unique_index(database, indexName)
if fk:
return tb["unique_index"].delete(indexName)
el... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _delete_index( env, logger ):\n global adapter_glob\n if adapter_glob is not None:\n adapter = adapter_glob\n else:\n logger.warning( u\"Connecting to index...\" )\n adapter = adapter_file.adapter(env)\n adapter_glob = adapter\n adapter.delete( queries=[\"*:*\"] )\n a... | [
"0.7866251",
"0.7690482",
"0.7287023",
"0.7146124",
"0.71191764",
"0.7003967",
"0.69910884",
"0.69812775",
"0.6978048",
"0.6943532",
"0.6943532",
"0.69430524",
"0.68292207",
"0.6732258",
"0.672679",
"0.66857874",
"0.6668518",
"0.66267395",
"0.6616685",
"0.6585095",
"0.6505377... | 0.62490404 | 35 |
Adds an index to a table | def alterTableAddIndex(database: str, table: str, indexName: str, columns: list) -> int:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
tb["index"].insert([indexName, table, columns])
return 0
else:
return 3
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_index(self, index):\n self.add_index_sig(IndexSignature.from_index(index))",
"def add_index(self, index):\n self.add_index_sig(IndexSignature.from_index(index))",
"def create_index():",
"def post(self):\n args = table_index_create.parse_args(req=None, strict=False)\n retur... | [
"0.73783195",
"0.73783195",
"0.71194965",
"0.70425427",
"0.69791955",
"0.69791514",
"0.69791514",
"0.6961796",
"0.6901625",
"0.6799187",
"0.6746161",
"0.6639124",
"0.6572811",
"0.6415044",
"0.637327",
"0.6346673",
"0.6333546",
"0.63302356",
"0.6294157",
"0.6294157",
"0.628760... | 0.7019514 | 4 |
Changes a database encoding | def alterDatabaseEncoding(database: str, encoding: str) -> int:
bd = _database(database)
if bd:
if encoding not in ["utf8", "ascii", "iso-8859-1"]:
return 3
else:
bd["encoding"] = encoding
try:
table = bd["tablas"]
for t in ta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_encoding(self, encoding):\n\n self._encoding = encoding",
"def setEncoding(self,value):\n self.PDFreactorConfiguration.in1[\"encoding\"] = value",
"def encoding(self, enc):\n self._encoding = enc",
"def setEncoding(self, value):\n return self._set(encoding=value)",
"def chan... | [
"0.67461425",
"0.64060473",
"0.634873",
"0.623026",
"0.619429",
"0.61455333",
"0.6030758",
"0.5986381",
"0.5978252",
"0.59553367",
"0.5942807",
"0.5934476",
"0.5905521",
"0.5881358",
"0.5742639",
"0.5733933",
"0.5719861",
"0.56561494",
"0.5630939",
"0.562058",
"0.5567001",
... | 0.78333086 | 0 |
Generates a database checksum | def checksumDatabase(database: str, mode: str) -> str:
bd = _database(database)
if bd:
if mode not in ["MD5", "SHA256"]:
return None
return ch.checksumDatabase(database,mode)
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checksumTable(database: str, table: str, mode: str) -> str:\n\n bd = _database(database)\n\n if bd:\n\n tb = _table(database, table)\n\n if tb:\n\n if mode not in [\"MD5\", \"SHA256\"]:\n return None \n\n return ch.checksumTable(database, tabl... | [
"0.66937816",
"0.6190386",
"0.61403894",
"0.60973465",
"0.60893285",
"0.6068533",
"0.60548466",
"0.5977226",
"0.5915417",
"0.59037364",
"0.589102",
"0.58852303",
"0.58622736",
"0.58616817",
"0.5835881",
"0.5829948",
"0.5826346",
"0.57996047",
"0.5776036",
"0.5759001",
"0.5728... | 0.7103147 | 0 |
Generates a table checksum | def checksumTable(database: str, table: str, mode: str) -> str:
bd = _database(database)
if bd:
tb = _table(database, table)
if tb:
if mode not in ["MD5", "SHA256"]:
return None
return ch.checksumTable(database, table, mode)
else... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checksum_full_table(self):\n # Calculate checksum for old table\n old_checksum = self.query(\n sql.checksum_full_table(self.table_name, self._old_table.column_list)\n )\n\n # Calculate checksum for new table\n new_checksum = self.query(\n sql.checksum_fu... | [
"0.64989996",
"0.6389361",
"0.60043424",
"0.5984078",
"0.5979633",
"0.5943067",
"0.59368956",
"0.5757987",
"0.574514",
"0.57429785",
"0.5741921",
"0.5712693",
"0.566631",
"0.56360173",
"0.5609682",
"0.5606184",
"0.5592736",
"0.5590365",
"0.5528552",
"0.5523038",
"0.55114263",... | 0.6832998 | 0 |
Encrypts a database backup | def encrypt(backup: str, password: str) -> str:
try:
return comp.encriptar(backup, password)
except:
return '1' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backup():\n backup_shift(os, config.utils.tasks.backup_depth)\n if config.utils.tasks.secret_key is None:\n shutil.copyfile(config.core.database_name, config.core.database_name+'.1')\n else:\n data = get_encrypted_database()\n with open(config.core.database_name+'.1', 'wb') as f:\... | [
"0.76307666",
"0.68583685",
"0.6519847",
"0.6505042",
"0.63152915",
"0.62139744",
"0.6127814",
"0.6040174",
"0.6035554",
"0.5945199",
"0.5941164",
"0.5670987",
"0.56525385",
"0.5643152",
"0.56106496",
"0.5586842",
"0.5586417",
"0.55854",
"0.55685306",
"0.55681694",
"0.5545194... | 0.6583493 | 2 |
Encrypts a database backup | def decrypt(cipherBackup: str, password: str) -> str:
try:
return comp.desencriptar(cipherBackup, password)
except:
return '1' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backup():\n backup_shift(os, config.utils.tasks.backup_depth)\n if config.utils.tasks.secret_key is None:\n shutil.copyfile(config.core.database_name, config.core.database_name+'.1')\n else:\n data = get_encrypted_database()\n with open(config.core.database_name+'.1', 'wb') as f:\... | [
"0.76307666",
"0.68583685",
"0.6583493",
"0.6519847",
"0.6505042",
"0.63152915",
"0.62139744",
"0.6127814",
"0.6040174",
"0.6035554",
"0.5945199",
"0.5941164",
"0.5670987",
"0.56525385",
"0.5643152",
"0.5586842",
"0.5586417",
"0.55854",
"0.55685306",
"0.55681694",
"0.5545194"... | 0.56106496 | 15 |
Enables safe mode for a table in a database | def safeModeOn(database: str, table: str) -> int:
nombreST = str(database) + '-' + str(table)
if not _database(database):
return 2
if not _table(database, table):
return 3
if BC.EsUnaTablaSegura(nombreST, _main_path):
return 4
try:
BC.CreateBlockChain(nombreST, _ma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def safeModeOff(database: str, table: str) -> int:\n\n nombreST = str(database) + '-' + str(table)\n\n if not _database(database):\n return 2\n\n if not _table(database, table):\n return 3\n\n if not BC.EsUnaTablaSegura(nombreST, _main_path):\n return 4\n\n try:\n BC.Dele... | [
"0.6526765",
"0.649856",
"0.649856",
"0.64588463",
"0.6081784",
"0.60203445",
"0.599737",
"0.576383",
"0.57122225",
"0.566805",
"0.56553423",
"0.56194913",
"0.5618057",
"0.55770737",
"0.555558",
"0.55528665",
"0.5505558",
"0.54966724",
"0.5485075",
"0.5333716",
"0.53314537",
... | 0.6587872 | 0 |
Disables safe mode for a table in a database | def safeModeOff(database: str, table: str) -> int:
nombreST = str(database) + '-' + str(table)
if not _database(database):
return 2
if not _table(database, table):
return 3
if not BC.EsUnaTablaSegura(nombreST, _main_path):
return 4
try:
BC.DeleteSafeTable(nombreS... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disable(mode='soft'):\n Qdb().disable(mode)",
"def allow_syncdb(self, db, model):\n return True",
"def allow_syncdb(self, db, model):\n return True",
"def safeModeOn(database: str, table: str) -> int:\n nombreST = str(database) + '-' + str(table)\n if not _database(database):\n ... | [
"0.6601288",
"0.63316554",
"0.63316554",
"0.62221414",
"0.6210767",
"0.615746",
"0.59436333",
"0.58665496",
"0.5816745",
"0.5745367",
"0.5609925",
"0.5590738",
"0.55830115",
"0.5501912",
"0.5471799",
"0.54703504",
"0.54557586",
"0.54145384",
"0.5412278",
"0.54096645",
"0.5406... | 0.72843796 | 0 |
Graphs a database ERD | def graphDSD(database: str) -> int:
db = _database(database)
if db:
return graph.graphDSD(database)
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_sql(self, table_name=None):\n\t\tlabels={}\n\t\tif table_name in self.DiG:\n\t\t\tsubgraph = self.get_subgraph(table_name)\n\t\t\tfor node in subgraph:\n\t\t\t\tlabels[node] = node\n\t\t\tprint(labels)\n\t\t\tnx.draw_spring(subgraph,labels=labels,font_size=8,node_size=300,alpha=0.7)\n\t\t\tplt.draw()\n\t\... | [
"0.70083284",
"0.6847605",
"0.6845175",
"0.6487676",
"0.6411189",
"0.6335492",
"0.6328995",
"0.63088155",
"0.6299614",
"0.62519145",
"0.624884",
"0.62116575",
"0.62056077",
"0.61232126",
"0.6097815",
"0.60871184",
"0.6086293",
"0.60786444",
"0.6057168",
"0.6048504",
"0.602116... | 0.5324098 | 90 |
Graphs a table s functional dependencies | def graphDF(database: str, table: str) -> int:
db = _database(database)
if db:
return graph.graphDF(database,table)
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_dependencies(tables):\n tables = list(tables)\n graph = {}\n def visit_foreign_key(fkey):\n if fkey.use_alter:\n return\n parent_table = fkey.column.table\n if parent_table in tables:\n child_table = fkey.parent.table\n if parent_table is n... | [
"0.645483",
"0.5654069",
"0.5640785",
"0.561997",
"0.55941105",
"0.55789673",
"0.55632514",
"0.5560617",
"0.5552409",
"0.55237514",
"0.55124575",
"0.5441507",
"0.54151005",
"0.53559804",
"0.53465724",
"0.5327631",
"0.53274393",
"0.52924687",
"0.52850795",
"0.5280849",
"0.5220... | 0.0 | -1 |
Returns a dataset with the noliposome condition values subtracted. | def background_subtract_data(data):
bgsub_data = data.copy()
bax_concs = data.columns.levels[0]
lipo_concs = data.columns.levels[1]
for bax_conc in data.columns.levels[0]:
timecourses = data.xs(bax_conc, axis=1, level='Bax')
bg = timecourses[0.]
for lipo_conc in lipo_concs:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_negative_data(self):\n negative_df = pd.DataFrame(columns=HeatStrokeDataFiller.important_features, index=np.arange(self.num_negative))\n for field in negative_df.columns:\n parameter_distribution = HeatStrokeDataFiller.negative_default[field]\n negative_df[field].loc[:] ... | [
"0.6519424",
"0.5944461",
"0.58864164",
"0.58284235",
"0.576742",
"0.5748784",
"0.5742863",
"0.5741857",
"0.57243454",
"0.57041985",
"0.5657011",
"0.5646586",
"0.5629784",
"0.56278014",
"0.5496016",
"0.5485245",
"0.54735637",
"0.54533195",
"0.54512817",
"0.54376525",
"0.53877... | 0.0 | -1 |
Convert daily Github issues from mongodb to BigARTM format (UCI Bagofwords) | def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("-t", "--target-dir", required=True,
help="Directory to store bigARTM files")
parser.add_argument("--start-date", default="2015-12-01",
help="Start date(YYYY-MM-DD) to convert mongodb f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n verbose = False\n online = True\n\n if online:\n TOKEN = \"\"\n g = Github(base_url=\"https://github.ibm.com/api/v3\", login_or_token=TOKEN)\n repo = g.get_repo(\"Raphael-Lambert/test_note\")\n\n path = \"C:/Users/RaphaelLambert/Documents/git_issues\"\n onlyfiles =... | [
"0.5371995",
"0.5351099",
"0.5217168",
"0.5203004",
"0.51921064",
"0.5157592",
"0.50705695",
"0.5066366",
"0.5036247",
"0.4937896",
"0.47906277",
"0.47864658",
"0.47658864",
"0.4753645",
"0.47526726",
"0.47179803",
"0.47064632",
"0.47028103",
"0.46983656",
"0.46869716",
"0.46... | 0.5855663 | 0 |
Run experiment n_pulls times. Updates return Q on each iteration. | def experiment(self, n_pulls: int):
self.N = np.zeros(self.n_arms)
self.Q = np.zeros(self.n_arms)
Q_history = np.array([])
for pull in range(n_pulls):
action = self.get_action(pull)
reward = self.get_reward(action, pull)
Q = self.update_Q(action, rewa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def schedule_pulls():\n for repo in Repository.objects.all():\n # distribute pulls by delaying evenly across an hour\n pk_hash = hashlib.sha256(str(repo.pk).encode())\n delay_s = int(pk_hash.hexdigest(), 16) % (60 * 60)\n\n pull.apply_async(\n args=(repo.remote_id, repo.pr... | [
"0.58870846",
"0.58440375",
"0.5743763",
"0.5656772",
"0.55926",
"0.55351824",
"0.5529241",
"0.5444302",
"0.54419786",
"0.54373276",
"0.5437268",
"0.5400262",
"0.5295067",
"0.5259368",
"0.5251553",
"0.5244251",
"0.5202766",
"0.51938194",
"0.51859874",
"0.51479423",
"0.5139781... | 0.6956549 | 0 |
Execute command or private command. | def execute(cmd, msg, private=False):
cmd_dict = private_cmds if private else cmds
if cmd in cmd_dict:
return cmd_dict[cmd](msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute_command(self, command):\n raise NotImplementedError",
"def execute_command(self):\n raise Exception(\"Not implemented\")",
"def execute(self, command, user_context=None):\n return self.parse(command, user_context).execute()",
"def execute(cmd_string):\n pass",
"def execu... | [
"0.7519614",
"0.74905926",
"0.7160174",
"0.7044931",
"0.701376",
"0.6983892",
"0.69729316",
"0.6947648",
"0.6915622",
"0.6850946",
"0.68431306",
"0.68125206",
"0.6798981",
"0.6782056",
"0.6780938",
"0.6709017",
"0.66989166",
"0.66972363",
"0.6690021",
"0.6674003",
"0.6674003"... | 0.73234296 | 2 |
Wire type" is a part of the "key" that carries enough information to parse value from the wire, i.e. read correct amount of bytes, but there's not enough informaton to interprete in unambiguously. For example, one can't clearly distinguish 64bit fixedsized integers from 64bit floats, signed zigzagencoded varints from r... | def wire_type(self):
if hasattr(self, '_m_wire_type'):
return self._m_wire_type if hasattr(self, '_m_wire_type') else None
self._m_wire_type = self._root.Pair.WireTypes((self.key.value & 7))
return self._m_wire_type if hasattr(self, '_m_wire_type') else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def type(self):\n return struct.unpack('<B', self.raw_data[0])[0]",
"def pkt_type(self):\n return uint16_packer.unpack(self[32:34])[0]",
"def Type(self, String):\r\n\r\n if (String == \"byte\") or (String == \"sbyte\"):\r\n return 1\r\n elif (String == \"word\") or (Strin... | [
"0.64454204",
"0.6344862",
"0.6177453",
"0.5958382",
"0.5952993",
"0.5889277",
"0.5840352",
"0.5823337",
"0.5787412",
"0.577655",
"0.5731551",
"0.5713418",
"0.56753224",
"0.5661148",
"0.564763",
"0.56469196",
"0.5632343",
"0.56118524",
"0.55602056",
"0.55430776",
"0.55326146"... | 0.6732522 | 0 |
Identifies a field of protocol. One can look up symbolic field name in a `.proto` file by this field tag. | def field_tag(self):
if hasattr(self, '_m_field_tag'):
return self._m_field_tag if hasattr(self, '_m_field_tag') else None
self._m_field_tag = (self.key.value >> 3)
return self._m_field_tag if hasattr(self, '_m_field_tag') else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode_field(cls, fullpath, buf, offset, record):\n cur_offset = offset\n field_id, length = struct.unpack_from('>HH', buf, cur_offset)\n cur_offset += 4\n if field_id != 0xFFFF and length > 0:\n field_name, decoder = cls.named_fields().get(field_id, (None, None))\n ... | [
"0.5957529",
"0.59060884",
"0.5869169",
"0.5820498",
"0.58075804",
"0.5749224",
"0.571788",
"0.5674136",
"0.56662714",
"0.56519926",
"0.5555956",
"0.5481811",
"0.5475428",
"0.54737663",
"0.54220575",
"0.54131275",
"0.54060864",
"0.5402144",
"0.5399504",
"0.5397118",
"0.537876... | 0.54832816 | 11 |
creates combination of item based and content based recommender system | def incl_city_business(user_id, business_id, city):
frame1 = pd.concat([pd.DataFrame(REVIEWS[x]) for x in REVIEWS if x == city])
businesses = pd.DataFrame()
for business1 in BUSINESSES[city]:
for business2 in BUSINESSES[city]:
if business2['business_id'] != business_id and business1["b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_recommender(self):\n\n self._build_sample_graph()\n\n # set skill sa score to 1.0 and skill sb score to 0.5\n measure_sa = competency.SuccessRateCompetencyMeasure.load(\n self.user_id, self.sa.id)\n measure_sa.add_score(1.0)\n measure_sa.save()\n measur... | [
"0.5934041",
"0.5860087",
"0.5854633",
"0.58486146",
"0.5600619",
"0.5563894",
"0.54696375",
"0.54542816",
"0.5449051",
"0.5337651",
"0.5331255",
"0.5322723",
"0.52529424",
"0.52458346",
"0.5242455",
"0.5231326",
"0.52107245",
"0.5176489",
"0.5176489",
"0.5160324",
"0.5156272... | 0.0 | -1 |
creates item based recommender system | def itembase(user_id):
frame1 = pd.concat([pd.DataFrame(REVIEWS[x]) for x in REVIEWS])
filtered_data = recommender.filtering_not_city()
businesses = pd.DataFrame(filtered_data).set_index('business_id')
frame2 = frame1.drop_duplicates(subset=["user_id", "business_id"], keep='last', inplace=False)
ut... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_recommender(self):\n\n self._build_sample_graph()\n\n # set skill sa score to 1.0 and skill sb score to 0.5\n measure_sa = competency.SuccessRateCompetencyMeasure.load(\n self.user_id, self.sa.id)\n measure_sa.add_score(1.0)\n measure_sa.save()\n measur... | [
"0.6218103",
"0.6210257",
"0.61855394",
"0.6122803",
"0.58560014",
"0.58560014",
"0.5693004",
"0.56778383",
"0.5650346",
"0.5633571",
"0.557751",
"0.5532578",
"0.54750973",
"0.53958327",
"0.53644466",
"0.5362876",
"0.5344367",
"0.53431237",
"0.5330568",
"0.5299743",
"0.528890... | 0.50555146 | 38 |
given a userId and BusinessId, this function returns the corresponding review | def get_review(reviews, userId, BusinessId):
reviews = reviews[(reviews['business_id'] == BusinessId) & (reviews['user_id'] == userId)]
if reviews.empty:
return np.nan
elif len(reviews) > 1:
return float(reviews['stars'].max())
else:
return float(reviews['stars']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_reviews():\n print(\"***** Find Reviews of a Business *****\")\n while (True):\n print()\n business_object = query_business_name()\n if business_object == \"back\":\n return\n elif business_object is None:\n continue\n id = business_object['bu... | [
"0.6462504",
"0.63464046",
"0.61958796",
"0.6140048",
"0.6079224",
"0.59808564",
"0.58458614",
"0.5808643",
"0.5693213",
"0.55099154",
"0.5501791",
"0.54506606",
"0.54472685",
"0.5408173",
"0.5311152",
"0.528549",
"0.52852464",
"0.5272833",
"0.52651584",
"0.524855",
"0.523621... | 0.7737348 | 0 |
takes a review table as input and computes the utility matrix | def pivot_reviews(reviews):
businessIds = reviews['business_id'].unique()
userIds = reviews['user_id'].unique()
pivot_data = pd.DataFrame(np.nan, columns=userIds, index=businessIds, dtype=float)
for user in userIds:
for business in businessIds:
pivot_data.loc[business][user] = get_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def performance_matrix(df):\r\n total = df.count()\r\n nP = df.filter((F.col('prediction') == 1)).count()\r\n nN = df.filter((F.col('prediction') == 0)).count()\r\n TP = df.filter((F.col('prediction') == 1) & (F.col('label') == 1)).count()\r\n FP = df.filter((F.col('prediction') == 1) & (F.col('labe... | [
"0.5854542",
"0.58525765",
"0.58460265",
"0.57699704",
"0.57382894",
"0.5730551",
"0.57017535",
"0.5652791",
"0.5607779",
"0.5496936",
"0.5473677",
"0.5467458",
"0.54510313",
"0.5397981",
"0.53845805",
"0.5378737",
"0.5375182",
"0.5365264",
"0.53591096",
"0.53335047",
"0.5329... | 0.0 | -1 |
computes the euclidean similarity | def similarity_euclid(matrix, business1, business2):
selected_features = matrix.loc[business1].notna() & matrix.loc[business2].notna()
if not selected_features.any():
return 0
features1 = matrix.loc[business1][selected_features]
features2 = matrix.loc[business2][selected_features]
distance... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pairwise_euclidean_similarity(x, y):\n s = 2 * torch.mm(x, torch.transpose(y, 1, 0))\n diag_x = torch.sum(x * x, dim=-1)\n diag_x = torch.unsqueeze(diag_x, 0)\n diag_y = torch.reshape(torch.sum(y * y, dim=-1), (1, -1))\n\n return s - diag_x - diag_y",
"def euc_dist(self, squared=True):",
"de... | [
"0.7442795",
"0.7366634",
"0.73303705",
"0.72702587",
"0.7191978",
"0.71874243",
"0.7170478",
"0.71292555",
"0.7122205",
"0.71213186",
"0.7113179",
"0.71043175",
"0.7030621",
"0.70219976",
"0.70203394",
"0.70122296",
"0.69272286",
"0.692671",
"0.69088495",
"0.6883007",
"0.682... | 0.74360234 | 1 |
creates the similarity matrix based on euclidean distance | def create_similarity_matrix_euclid(matrix):
similarity_matrix_euclid = pd.DataFrame(0, index=matrix.index, columns=matrix.index, dtype=float)
for business1 in matrix.index:
for business2 in matrix.index:
similarity_matrix_euclid[business1][business2] = similarity_euclid(matrix, business1, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_euclidean_matrix(df):\n df.reset_index(drop=True, inplace=True)\n\n # foods = df['food_names']\n # food_examples = []\n # indices = list(range(0, len(foods)))\n # for i in indices:\n # food_examples.append(str(foods[i]) + str(i))\n # food_examples = pd.Series(food_examples)\n fo... | [
"0.7097548",
"0.69869065",
"0.6850637",
"0.68024546",
"0.6692717",
"0.6652696",
"0.6636552",
"0.6619056",
"0.6616738",
"0.6589348",
"0.6544284",
"0.6532676",
"0.6520318",
"0.6496218",
"0.64808625",
"0.6429152",
"0.64220136",
"0.64193624",
"0.6398457",
"0.6395359",
"0.6357025"... | 0.6689488 | 5 |
selects all items with similarity > 0 | def select_neighborhood(similarity_matrix, utility_matrix, target_user, target_business):
items_dict = {}
new_matrix = utility_matrix[target_user].dropna()
for business in new_matrix.index:
if new_matrix[business] and similarity_matrix[business][target_business] > 0:
items_dict[business... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_ratio_matches(matches, kp1, kp2, ratio=0.7):\n new_kp1, new_kp2, new_matches = [], [], []\n ctr = 0\n for i, (m, n) in enumerate(matches): #\n if m.distance < ratio * n.distance:\n new_kp1.append(kp1[m.queryIdx])\n new_kp2.append(kp2[m.trainIdx])\n new_m... | [
"0.5755423",
"0.5642819",
"0.5585275",
"0.5528982",
"0.549568",
"0.54791164",
"0.54765606",
"0.5459276",
"0.54465127",
"0.5431656",
"0.54239976",
"0.5412709",
"0.5372484",
"0.53679526",
"0.53638303",
"0.53536546",
"0.53348994",
"0.5329641",
"0.5297915",
"0.52857894",
"0.52804... | 0.0 | -1 |
computes the weighted mean | def weighted_mean(neighborhood, utility_matrix, user_id):
if neighborhood.sum() != 0:
return ((utility_matrix[user_id] * neighborhood).sum()) / neighborhood.sum()
else:
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weightedMean(numlist, weights):\n\twxsum = 0.0\n\twsum = 0.0\n\n\tassert len(numlist) == len(weights)\n\n\tfor (x,w) in zip(numlist, weights):\n\t\twxsum += x*w\n\t\twsum += w\n\tif wsum == 0.0:\n\t\treturn 0.0\n\treturn wxsum/wsum",
"def average_weights(w):\n w_avg = copy.deepcopy(w[0])\n for key in w... | [
"0.7932049",
"0.78005934",
"0.78005934",
"0.78005934",
"0.7797064",
"0.7758014",
"0.7724132",
"0.766356",
"0.76569927",
"0.76120603",
"0.7507334",
"0.7482594",
"0.7392918",
"0.7322675",
"0.73218936",
"0.72820747",
"0.72085583",
"0.7199587",
"0.71674925",
"0.7164931",
"0.71561... | 0.666516 | 42 |
Iterator for page links | def iter_page_links(self) -> Iterable[str]:
base_url = 'https://health.mil/About-MHS/OASDHA/Defense-Health-Agency/Resources-and-Management/DHA-Publications'
yield base_url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iter_links(self):",
"def iter_page_links(self) -> Iterable[str]:\n base_url = 'https://www.med.navy.mil'\n r = requests.get(self.starting_url, verify=CERTIFICATE_DIR + '/cat3.pem')\n soup = bs4.BeautifulSoup(r.content, features=\"html.parser\")\n\n # get target column of list item... | [
"0.80651504",
"0.75957644",
"0.7370286",
"0.73280376",
"0.69186187",
"0.69141686",
"0.6908116",
"0.6793799",
"0.67863417",
"0.6741017",
"0.66748494",
"0.6670355",
"0.66565365",
"0.6593838",
"0.65873545",
"0.65807104",
"0.6502916",
"0.6478992",
"0.64505965",
"0.64059603",
"0.6... | 0.750158 | 2 |
Parse document objects from page of text | def parse_docs_from_page(self, page_url: str, page_text: str) -> Iterable[Document]:
# get the data
data = requests.get(page_url)
# load data into bs4
soup = BeautifulSoup(data.text, 'html.parser')
# links = []
pdf_dis = []
dates = []
table = []
v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_docs_from_page(self, page_url: str, page_text: str) -> Iterable[Document]:\n # parse html response\n url = \"https://www.med.navy.mil/directives/Pages/Publications.aspx\"\n base_url = 'https://www.med.navy.mil'\n parsed_docs = []\n doc_name_list = []\n if (page_u... | [
"0.6943239",
"0.69207364",
"0.6807848",
"0.6564104",
"0.6440653",
"0.6434585",
"0.6419085",
"0.6406201",
"0.63876253",
"0.6367041",
"0.6246994",
"0.62138414",
"0.6203199",
"0.6178067",
"0.6176524",
"0.61475307",
"0.6122435",
"0.6108919",
"0.60970265",
"0.6094376",
"0.6085055"... | 0.71913856 | 0 |
run this CT model with other models CT input | def run(self, ct_data, state):
transformed_input = copy.deepcopy(ct_data)
output = self.model.run(ct_data, state)
result = {"output": output, "transformed input": transformed_input}
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_tests():\n source1 = TextModel('prep')\n source1.add_file('source_model_1.txt')\n \n source2 = TextModel('athletes')\n source2.add_file('source_model_2.txt')\n\n new1 = TextModel('my_writing')\n new1.add_file('my_writing.txt')\n new1.classify(source1, source2)\n\n # Add code for ... | [
"0.6460919",
"0.6433101",
"0.63607436",
"0.6235969",
"0.6233244",
"0.62312454",
"0.61591774",
"0.61472887",
"0.6144754",
"0.6134827",
"0.61335844",
"0.612184",
"0.6115578",
"0.6104375",
"0.61010057",
"0.6084759",
"0.60830665",
"0.607298",
"0.60646755",
"0.60414994",
"0.600721... | 0.62978494 | 3 |
Get the Men's Bathroom status. | def get_bathroom_buddy_mens_status(message):
status = subscribe.simple(
"Home/mens/state", hostname="m16.cloudmqtt.com",
auth={'username': os.environ['USERNAME'],
'password': os.environ['SLACK_PASS']},
port=21775, tls={'ca_certs': certifi.where()})
return(status.payload) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_power_status(self):\n response = self.parent.power_manager.get_status()\n if response is not None:\n response = response[0]\n\n batteries = []\n for batt in response[\"batt_data\"]:\n batteries.append(batt)\n response[\"batt_data\"] =... | [
"0.6127522",
"0.6055546",
"0.599644",
"0.59283227",
"0.5925165",
"0.58408403",
"0.5754333",
"0.575369",
"0.57490945",
"0.57337254",
"0.57331556",
"0.57121",
"0.57121",
"0.57121",
"0.57066834",
"0.5702639",
"0.5657467",
"0.5653847",
"0.56426734",
"0.5628258",
"0.5618401",
"0... | 0.54959536 | 35 |
Get the Women's Bathroom status. | def get_bathroom_buddy_womens_status(message):
status = subscribe.simple(
"Home/womens/state", hostname="m16.cloudmqtt.com",
auth={'username': os.environ['USERNAME'],
'password': os.environ['SLACK_PASS']},
port=21775, tls={'ca_certs': certifi.where()})
return(status.payloa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def status(self):\n return STATUSES.get(self._mower_status, {}).get('message', self._mower_status)",
"def get_power_status(self):\n response = self.parent.power_manager.get_status()\n if response is not None:\n response = response[0]\n\n batteries = []\n for ... | [
"0.6468318",
"0.6393942",
"0.6363238",
"0.63195926",
"0.60368097",
"0.6002562",
"0.59756094",
"0.59639066",
"0.59639066",
"0.59282535",
"0.590928",
"0.590928",
"0.590928",
"0.5900921",
"0.5868397",
"0.58677864",
"0.58677864",
"0.58677864",
"0.58677864",
"0.58677864",
"0.58677... | 0.63199383 | 3 |
The following function returns the current weather for South Bend, IN.... | def get_weather_south_bend(message):
weather_api = 'http://api.openweathermap.org/data/2.5/weather?id=4926563&&units=imperial&appid={}'.format(
os.environ['WEATHER_KEY'])
weather = requests.get(weather_api).json()
return("The current weather at Notre Dame is {} with a temperature of {}.".format(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weather_helper():\n\n weather = get_weather('Chicago')\n conditions = weather['weather'][0]['description']\n temperature = weather['main']['temp']\n location = weather['name']\n\n curr_weather = 'It is currently %s degrees with %s in %s' % (temperature, conditions, location)\n return curr_wea... | [
"0.6748897",
"0.6651157",
"0.65632546",
"0.654174",
"0.64824337",
"0.62617576",
"0.6250446",
"0.62484175",
"0.611307",
"0.609392",
"0.6065452",
"0.60488474",
"0.60212094",
"0.59851736",
"0.5981115",
"0.5960446",
"0.5955273",
"0.5950651",
"0.59499425",
"0.5916722",
"0.5912138"... | 0.67351866 | 1 |
Prometheus helper to quickly see the time in London. | def get_uk_time(message):
time_api = 'http://worldtimeapi.org/api/timezone/Europe/London.json'
london_time = requests.get(time_api).json()
return("The current time in London, England is {}".format(
london_time['datetime'][11:16])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_time(self):\n return self.run_command('get_time')[0]",
"def timezone():\n \n pass",
"def get_time_info(self):\n\n raise NotImplementedError",
"def get_nightly_start_time():\n return 14 # 2PM local Tucson time",
"def get_time():\n # Use this one for production:\n now... | [
"0.59689367",
"0.59094346",
"0.5783251",
"0.57631344",
"0.57395995",
"0.5718757",
"0.5704612",
"0.5699259",
"0.56886494",
"0.5673247",
"0.5653273",
"0.5640289",
"0.56305677",
"0.558655",
"0.5577585",
"0.5576624",
"0.5555275",
"0.55360794",
"0.5501735",
"0.54946667",
"0.548418... | 0.5973397 | 0 |
Return the scoreboard information for games matching the parameters as a dictionary. | def scoreboard(year, month, day):
# Get data from mlbgame library
data = mlbgame.data.get_scoreboard(year, month, day)
# Parse through returned data
parsed = etree.parse(data)
root = parsed.getroot()
output = []
# Loop through the list of games that are returned
for game in root:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scoreboard(year, month, day, home=None, away=None):\n # get data\n data = mlbgame.data.get_scoreboard(year, month, day)\n # parse data\n parsed = etree.parse(data)\n root = parsed.getroot()\n games = {}\n output = {}\n # loop through games\n for game in root:\n if game.tag == ... | [
"0.6896654",
"0.6882706",
"0.6848933",
"0.6711905",
"0.63978255",
"0.6303648",
"0.6230028",
"0.6196659",
"0.61953855",
"0.61835605",
"0.61832064",
"0.6141031",
"0.6121574",
"0.60932535",
"0.60710603",
"0.60630333",
"0.60620886",
"0.60424584",
"0.60335046",
"0.60295945",
"0.60... | 0.68596184 | 2 |
This function will fetch yesterday's mlb scores and return them in a similar fashion to how nhl scores are being returned. | def get_mlb_scores(message):
yesterday = datetime.date.today() - datetime.timedelta(days=1)
games = scoreboard(yesterday.year,
yesterday.month,
yesterday.day)
scores = []
for game in games:
home = "{} {}\n".format(
game['home_team'],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDayAheadMarketLBMPZonal(self):\n\n\t\t# Variables\n\t\ttoday = self.helper.getYear() + self.helper.getMonth() + self.helper.getDay()\n\t\turl = 'http://mis.nyiso.com/public/csv/damlbmp/'+today+'damlbmp_zone.csv' \n\t\tresponse = urllib2.urlopen(url)\n\t\tmarket_data = sorted(csv.reader(response... | [
"0.5864733",
"0.5720611",
"0.5628312",
"0.54834133",
"0.54429305",
"0.54429305",
"0.5391816",
"0.53706133",
"0.5342564",
"0.52987903",
"0.5291811",
"0.52855325",
"0.52515596",
"0.5246376",
"0.51850957",
"0.51413584",
"0.50993174",
"0.50862217",
"0.5074362",
"0.5064369",
"0.50... | 0.7069956 | 0 |
This function gets updated Covid stats for the state of Indiana. | def get_indiana_covid_stats(message):
api_link = "https://corona.lmao.ninja/v2/states"
get_stats = requests.get(api_link)
for state in get_stats.json():
if state['state'] == "Indiana":
cases = state['cases']
deaths = state['deaths']
covid_message = ":coronavirus: In Ind... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_covid_stats_for_all_states():\n url = \"https://corona.lmao.ninja/v2/states/\"\n response = requests.get(url)\n data = response.json()\n\n states = []\n\n for state in data:\n stateName = state[\"state\"]\n\n cases = state[\"cases\"]\n todaysCases = state[\"todayCases\"]... | [
"0.5786061",
"0.57647926",
"0.5751267",
"0.5653311",
"0.5646003",
"0.5581366",
"0.5580781",
"0.55658996",
"0.5481031",
"0.5458222",
"0.54489946",
"0.5434017",
"0.54039675",
"0.5381794",
"0.5363166",
"0.5323404",
"0.5323404",
"0.52979153",
"0.52888215",
"0.5287419",
"0.5280991... | 0.55448335 | 8 |
Returns a random Chuck Norris joke. | def chuck_norris_jokes(message):
joke = requests.get("https://api.chucknorris.io/jokes/random").json()
return joke['value'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_chuck_norris_joke():\n response = requests.get(\"https://api.chucknorris.io/jokes/random\")\n json_data = response.json()\n return json_data[\"value\"]",
"def get_joke(self):\n if not self.jokes:\n self.__init__()\n index = random.randint(0, len(self.jokes) - 1)\n ... | [
"0.7100957",
"0.6707431",
"0.6292626",
"0.62484074",
"0.6244774",
"0.62309253",
"0.5957998",
"0.56890154",
"0.56367815",
"0.5604061",
"0.5515048",
"0.5499996",
"0.54988563",
"0.54531413",
"0.5436678",
"0.5425449",
"0.5397241",
"0.53819555",
"0.537299",
"0.5371237",
"0.5358155... | 0.61729395 | 6 |
Returns a random bit of advice. | def random_advice(message):
advice = requests.get("https://api.adviceslip.com/advice").json()['slip']['advice']
return advice | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def random_test(self):\r\n return 1",
"def random_test(self):\r\n return 1",
"def randomHelmet():\n return random.choice(HELMETS)",
"def randomMethod(self):\n return random.random()",
"def RandomAgentProgram(actions):\n return lambda percept: random.choice(actions)",
"def Rando... | [
"0.6780925",
"0.6780925",
"0.6756225",
"0.6611887",
"0.64579284",
"0.64579284",
"0.64425486",
"0.6346136",
"0.63369906",
"0.6270907",
"0.6244317",
"0.6233644",
"0.62298036",
"0.62264895",
"0.62022316",
"0.61940515",
"0.61672014",
"0.6140617",
"0.6140617",
"0.61395633",
"0.612... | 0.6908676 | 0 |
Return the lyrics of the song submitted. | def song_lyrics(message):
spaceless_message = message.partition(' ')[2]
if ":" in spaceless_message:
# Try and find the lyrics.
band_name = spaceless_message[0]
song_title = spaceless_message[2]
response = requests.get("https://api.lyrics.ovh/v1/{}/{}".format(band_name, song_tit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lyrics(self):\n return get_lyrics(self.artist, self.title,'')",
"def get_lyrics(self):\n\t\treturn self._lyrics_list",
"def get_lyrics(self):\n url = 'http://api.lyricsnmusic.com/songs?api_key=[5358b25688164e6c2f771954f17460&q]=' + self.artist + '%20' + self.name\n r = requests.get(url... | [
"0.7824739",
"0.723227",
"0.7111751",
"0.70720786",
"0.6978943",
"0.6744991",
"0.66379493",
"0.6558411",
"0.65524745",
"0.6528179",
"0.6459133",
"0.64329433",
"0.6395972",
"0.6361504",
"0.6232909",
"0.61920947",
"0.61873704",
"0.61732334",
"0.6150045",
"0.61318433",
"0.599009... | 0.6255102 | 14 |
Test that the package provides customization_data that defines the function | def test_function_definition(self):
func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)
assert func is not None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_confirm_customization_details(self):\n pass",
"def pytest_funcarg__generate_golden_data(request):\r\n return request.config.option.generate_golden_data",
"def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func",
"def test... | [
"0.6495841",
"0.62949693",
"0.622999",
"0.622999",
"0.6012674",
"0.5847949",
"0.5794979",
"0.5786388",
"0.56368995",
"0.5633291",
"0.5617154",
"0.55914575",
"0.5590488",
"0.55788755",
"0.55642676",
"0.55561197",
"0.5555672",
"0.5555672",
"0.5554121",
"0.5550097",
"0.55453503"... | 0.602669 | 11 |
Test pattern_search using mocked response. | def test_pattern_search(self, mock_get, circuits_app, umbinv_regex, umbinv_start_epoch, umbinv_start_relative, umbinv_limit, umbinv_include_category):
keys_outer = ["matches", "limit", "totalResults", "expression", "moreDataAvailable"]
keys_match = ["name", "securityCategories", "firstSeen", "name", "f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mock_reddit_search_response(\n ) -> Dict:\n with open(\n \"util/reddit_search_response.json\"\n ) as static_response:\n mock_response = json.load(static_response)\n\n return(mock_response)",
"def test_search(self):\n d = self._search()\n self._response([2, 5, 1... | [
"0.6732833",
"0.66641694",
"0.63938046",
"0.6325752",
"0.62485534",
"0.6154589",
"0.6144737",
"0.6090113",
"0.60500705",
"0.60500705",
"0.60500705",
"0.60223466",
"0.60047615",
"0.60046566",
"0.59748423",
"0.58795416",
"0.587042",
"0.5864914",
"0.58384216",
"0.58313507",
"0.5... | 0.70248115 | 0 |
convert name to number | def name_to_number(name):
if name == "rock":
number = 0
elif name == "Spock":
number = 1
elif name == "paper":
number = 2
elif name == "lizard":
number = 3
elif name == "scissors":
number = 4
else:
print "Name is invalid!"
return 1
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def name_to_number(self, name):\r\n try:\r\n return self._numbers[name]\r\n except KeyError:\r\n raise KeyError(\"No field named %s in %r\" % (name, self._numbers.keys()))",
"def name_to_number(name):\r\n \r\n if name == \"rock\":\r\n return 0\r\n elif name == ... | [
"0.7741844",
"0.7352965",
"0.7345282",
"0.7291842",
"0.72166365",
"0.6983042",
"0.6895514",
"0.67996234",
"0.67324436",
"0.66536355",
"0.65847605",
"0.6520935",
"0.6479899",
"0.6476801",
"0.64197266",
"0.64054585",
"0.6389672",
"0.6386971",
"0.63465",
"0.6332023",
"0.6235999"... | 0.7410772 | 1 |
convert number to name | def number_to_name(number):
if number == 0:
name = "rock"
elif number == 1:
name = "Spock"
elif number == 2:
name = "paper"
elif number == 3:
name = "lizard"
elif number == 4:
name = "scissors"
else:
print "Number is invalid!"
return 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def number_to_name(self, number):\r\n return self._names[number]",
"def number_to_name(number):\r\n\r\n if number == 0:\r\n return \"rock\"\r\n elif number == 1:\r\n return \"Spock\"\r\n elif number == 2:\r\n return \"paper\"\r\n elif number == 3:\r\n return \"lizar... | [
"0.8246705",
"0.7550283",
"0.7530132",
"0.74987745",
"0.7460435",
"0.7435132",
"0.7311404",
"0.7058323",
"0.68847036",
"0.6775639",
"0.67526454",
"0.67350024",
"0.6674833",
"0.66491246",
"0.6633272",
"0.658147",
"0.64966327",
"0.6492684",
"0.64624995",
"0.6456531",
"0.6436228... | 0.77541053 | 1 |
get choices and print out the results(main function) | def rpsls(player_choice):
print
print "Player chooses " + player_choice
player_number = name_to_number(player_choice)
comp_number = random.randrange(0, 5)
comp_choice = number_to_name(comp_number)
print "Computer chooses " + comp_choice
if 0 < (player_number - comp_number) % 5 <= 2:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display(self):\n\n print('\\n')\n for key, val in self.option.items():\n print(key, val, '\\n') # make it more confortable to read\n self.get_choice() # launch automaticly the choice method after display",
"def print_choice_msg(self) -> None:\n pass",
"def get_optio... | [
"0.69602454",
"0.6944757",
"0.68645734",
"0.6550031",
"0.6543791",
"0.6523811",
"0.6480258",
"0.6450604",
"0.64299273",
"0.6420929",
"0.6349661",
"0.62972635",
"0.6249721",
"0.62495476",
"0.624387",
"0.6237897",
"0.6218892",
"0.62085146",
"0.61473715",
"0.6147141",
"0.6134839... | 0.0 | -1 |
Returns a dictionary that maps attribute name to a tuple of (type, description). | def get_class_attributes(cls) -> Dict[str, Tuple[Any, str]]:
try:
source = inspect.getsource(cls.__init__) or ""
if not source:
return {}
except TypeError:
return {}
source = utils.join(source.split("\n"))
node = ast.parse(source)
attr_list: List[Tuple] = []
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n retu... | [
"0.6793609",
"0.6674305",
"0.6664413",
"0.6616096",
"0.64803094",
"0.64548177",
"0.64188623",
"0.63728285",
"0.63316894",
"0.62979114",
"0.6276313",
"0.62762487",
"0.6258179",
"0.62334234",
"0.62087464",
"0.6139291",
"0.61141795",
"0.6099927",
"0.6081081",
"0.6017317",
"0.598... | 0.56027544 | 47 |
Returns a dictionary that maps attribute name to a tuple of (type, description). | def get_module_attributes(module) -> Dict[str, Tuple[Any, str]]:
try:
source = inspect.getsource(module) or ""
if not source:
return {}
except (OSError, TypeError):
return {}
node = ast.parse(source)
attr_list: List[Tuple] = []
globals = dict(inspect.getmembers(m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n retu... | [
"0.67931277",
"0.6674969",
"0.6665792",
"0.6615514",
"0.6481953",
"0.64552104",
"0.6419755",
"0.6372921",
"0.63325536",
"0.63000596",
"0.6278388",
"0.6277224",
"0.62586933",
"0.62347186",
"0.6207894",
"0.61394423",
"0.6115364",
"0.61008304",
"0.6080403",
"0.6016657",
"0.59896... | 0.5934517 | 24 |
Returns a dictionary that maps attribute name to a tuple of (type, description). | def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:
fields = cls.__dataclass_fields__.values()
attrs = {}
for field in fields:
if field.type != InitVar:
attrs[field.name] = field.type, ""
return attrs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n retu... | [
"0.6793609",
"0.6674305",
"0.6664413",
"0.6616096",
"0.64803094",
"0.64548177",
"0.64188623",
"0.63728285",
"0.63316894",
"0.62979114",
"0.6276313",
"0.62762487",
"0.6258179",
"0.62334234",
"0.62087464",
"0.6139291",
"0.6099927",
"0.6081081",
"0.6017317",
"0.59891033",
"0.598... | 0.61141795 | 16 |
Returns a dictionary that maps attribute name to a tuple of (type, description). | def get_attributes(obj) -> Dict[str, Tuple[Any, str]]:
if is_dataclass(obj):
return get_dataclass_attributes(obj)
elif inspect.isclass(obj):
return get_class_attributes(obj)
elif inspect.ismodule(obj):
return get_module_attributes(obj)
return {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n retu... | [
"0.67937475",
"0.6673932",
"0.6665609",
"0.6616133",
"0.6480975",
"0.645589",
"0.6419423",
"0.6373563",
"0.63325965",
"0.62991995",
"0.62763846",
"0.6275178",
"0.62591964",
"0.6234089",
"0.6209144",
"0.61401665",
"0.61152714",
"0.61013734",
"0.60815376",
"0.6018292",
"0.59895... | 0.57462233 | 35 |
Time complexity > O(n) Space complexity > O(1) | def subtract_product_and_sum(n):
product = 1
addition = 0
while n > 0:
element = n % 10
n = n // 10
product *= element
addition += element
return product - addition | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time_complexities():\n return \"Best Case: O(n), Average Case: O(n), Worst Case: O(n)\"",
"def sem_repetidos (l): # n = len(l), O(n^2)\n resultado = []\n for e in l: # n vezes\n if not e in resultado: # 1 + O(n)\n resultado.append(e) # O(1)\n return resultado",
"def fn(i):\n ... | [
"0.634884",
"0.5989984",
"0.5891454",
"0.58846223",
"0.58472943",
"0.5787732",
"0.57261235",
"0.56967765",
"0.56430763",
"0.564266",
"0.5621399",
"0.5620132",
"0.5600542",
"0.5588314",
"0.55832464",
"0.5568193",
"0.553908",
"0.5530704",
"0.5509698",
"0.5506223",
"0.5499427",
... | 0.0 | -1 |
Calculate the number of digits in a number and the armstrong_sum. Return true if the armstrong_sum equals the armstrong_candidate | def is_armstrong_number(armstrong_candidate: int) -> bool:
if armstrong_candidate < 0:
return False
nr_digits = nr_digits_number(armstrong_candidate)
a_sum = armstrong_sum(armstrong_candidate, nr_digits)
return True if a_sum == armstrong_candidate else False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def armstrong_sum(armstrong_candidate: int, nr_digits: int) -> int:\n a_sum = 0\n\n while armstrong_candidate != 0:\n digit_in_armstrong_candidate = armstrong_candidate % 10\n a_sum += digit_in_armstrong_candidate ** nr_digits\n armstrong_candidate = int(armstrong_candidate / 10)\n re... | [
"0.79819995",
"0.73977816",
"0.71560806",
"0.6935217",
"0.68870246",
"0.66913134",
"0.65789026",
"0.6340746",
"0.6177836",
"0.6057625",
"0.5992606",
"0.59754694",
"0.5964514",
"0.5883641",
"0.5847304",
"0.57634735",
"0.57392144",
"0.5727389",
"0.5718226",
"0.56865513",
"0.558... | 0.807842 | 0 |
Estimate the number of digits in a number. Return the number of digits. | def nr_digits_number(armstrong_candidate: int) -> int:
number_of_digits = 0
while armstrong_candidate != 0:
armstrong_candidate = int(armstrong_candidate / 10)
number_of_digits += 1
return number_of_digits | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _number_of_digits(number: int) -> int:\n return int(log10(number)) + 1",
"def count_digits(n):\n return len(str(n))",
"def ndigits(n):\n return len(str(abs(n)))",
"def count_digits(n):\n count = 0\n n=abs(n)\n while n!=0:\n count += 1\n n = n // 10\n return coun... | [
"0.8419208",
"0.79809237",
"0.7913502",
"0.7809456",
"0.76983887",
"0.75223655",
"0.72983843",
"0.72151583",
"0.716701",
"0.7089731",
"0.7057321",
"0.6973305",
"0.6938531",
"0.6913356",
"0.68830156",
"0.6864402",
"0.682758",
"0.680548",
"0.67883587",
"0.67420894",
"0.6736806"... | 0.7020397 | 11 |
Calculate and return the armstrong_sum | def armstrong_sum(armstrong_candidate: int, nr_digits: int) -> int:
a_sum = 0
while armstrong_candidate != 0:
digit_in_armstrong_candidate = armstrong_candidate % 10
a_sum += digit_in_armstrong_candidate ** nr_digits
armstrong_candidate = int(armstrong_candidate / 10)
return a_sum | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum(self):\n return self.vsum",
"def calculate_sum(self):\n\n left_sum = self.left.calculate_sum() if self.left else 0\n right_sum = self.right.calculate_sum() if self.right else 0\n return self.data + left_sum + right_sum",
"def summation(self):\n return sum(self.read_in... | [
"0.6603156",
"0.6591869",
"0.627234",
"0.62047184",
"0.61978614",
"0.6112021",
"0.60509235",
"0.5939432",
"0.5937607",
"0.5934721",
"0.5928078",
"0.5926152",
"0.5860448",
"0.5854603",
"0.58539337",
"0.58510864",
"0.58500665",
"0.5822862",
"0.581909",
"0.58153033",
"0.57878613... | 0.69721985 | 0 |
Split data by options of an attribute | def splitBy(data, attribute_id):
col = getColumn(data, attribute_id)
values = set(col)
split_data = []
for i in values:
subset = [row for row in data if row[attribute_id] == i]
split_data.append(subset)
return split_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getNewData(self, data, splitIndex, attrVal):\n newData = []\n for record in data:\n if record[splitIndex] == attrVal:\n newRecord =[]\n lenRecord = len(record)\n\n for i in range(lenRecord):\n # doesnt include the split at... | [
"0.5996887",
"0.5792106",
"0.5760196",
"0.575071",
"0.57116055",
"0.5524944",
"0.55180806",
"0.55036134",
"0.5439692",
"0.542324",
"0.54069096",
"0.53839254",
"0.5351785",
"0.5330941",
"0.53060323",
"0.51633775",
"0.51120734",
"0.50981104",
"0.5087688",
"0.50799423",
"0.50781... | 0.65550715 | 0 |
Calculate the information gain | def informationGain2(data, attribute):
split_data = splitBy(data, attribute)
weighted_entropies = 0
for set in split_data:
weighted_entropies += len(set) / len(data) * entropy2(set)
columnIG = entropy2(data) - weighted_entropies
return columnIG | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _information_gain(self, feature, node):\n return node.entropy() - self._entropy(feature, node)",
"def info_gain(self, left, right, current_uncertainty):\n p = float(len(left)) / (len(left) + len(right))\n return current_uncertainty - p * self.gini(left) - (1 - p) * self.gini(right)",
"... | [
"0.71510774",
"0.7104761",
"0.7051002",
"0.70116246",
"0.70019746",
"0.6977662",
"0.6969875",
"0.6891857",
"0.6791996",
"0.6740312",
"0.6715083",
"0.66847247",
"0.6643833",
"0.661401",
"0.6557161",
"0.65524924",
"0.652679",
"0.65203816",
"0.64868385",
"0.64760065",
"0.6475174... | 0.60878724 | 38 |
Get the attribute with the highest IG | def maxIG(data):
index = -1
max_gain = -1
for i in range(len(data[0]) - 1):
gain = informationGain2(data, i)
if gain > max_gain:
index = i
max_gain = gain
return (index, max_gain) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def imax(self):\n return self.elem.index(max(self))",
"def _best_individual(self):\n return max(self._population, key=attrgetter(\"fitness\"))",
"def get_max_key(dico):\n our_max = 0\n argmax = None\n for key, val in dico.items():\n if val > our_max:\n argmax = key\n ... | [
"0.6761436",
"0.66377854",
"0.64832205",
"0.645513",
"0.6428963",
"0.6424145",
"0.63717365",
"0.62889665",
"0.6267934",
"0.62075317",
"0.62063825",
"0.6203469",
"0.62030816",
"0.62002635",
"0.61884105",
"0.6144686",
"0.6144686",
"0.6144686",
"0.6144686",
"0.6144686",
"0.61446... | 0.6309714 | 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.