N x H\\n z = np.dot(activation[-1], W1) + b1 \\n # Activations, inputs to the final layer. \\n activation.append(sigmoid(z)) # output of the hidden layer, activation\\n # Final layer outputs: ( N x H ) * ( H, Dy) -> (N, Dy)\\n z = np.dot(activation[-1], W2) + b2\\n activation.append( softmax(z) )\\n\\n # Cross-entropy cost\\n\\n y_p = activation[-1]\\n activation = activation[:-1] # remove activation data (output)\\n\\n cost = -np.sum(labels * np.log(y_p))\\n \\n error = []\\n \\n ### backward propagation\\n sigma = (y_p - labels)\\n error.append(sigma)\\n\\n gradb2 = np.sum(error[-1], axis=0)\\n gradW2 = np.dot(activation[-1].T, error[-1])\\n\\n #\\n sigma = np.dot(W2, error[-1].T)\\n sigma = sigma.T * sigmoid_grad(activation[-1])\\n activation = activation[:-1] # remove activation data ( hidden layer )\\n\\n error.append(sigma)\\n\\n gradb1 = np.sum(error[-1], axis=0)\\n gradW1 = np.dot(activation[-1].T, error[-1])\\n\\n\\n ### Stack gradients (do not modify)\\n grad = np.concatenate((gradW1.flatten(), gradb1.flatten(), \\n gradW2.flatten(), gradb2.flatten()))\\n \\n return cost, grad\",\n \"def calc_gradients(\\n test_file,\\n model_name,\\n output_file_dir,\\n max_iter,\\n learning_rate=0.001,\\n targets=None,\\n weight_loss2=1,\\n data_spec=None,\\n batch_size=1,\\n seq_len=40,\\n resolution_x=16,\\n resolution_y=32,\\n resolution_z=32,\\n c_space=cv2.COLOR_BGR2LUV): \\n spec = data_spec\\n\\n modifier = tf.Variable(0.01*np.ones((1, seq_len, spec.crop_size,spec.crop_size,spec.channels),dtype=np.float32))\\n \\n input_image = tf.placeholder(tf.float32, (batch_size, seq_len, spec.crop_size, spec.crop_size, spec.channels))\\n input_label = tf.placeholder(tf.int32, (batch_size))\\n #input_image_cs = tf.placeholder(tf.float32, (batch_size, seq_len, spec.crop_size, spec.crop_size, spec.channels))\\n params_color = tf.Variable(np.empty_like(construct_identity_param(batch_size,resolution_x, resolution_y, resolution_z)).reshape(batch_size,-1,spec.channels))\\n \\n trans_color_img = function(input_image,params_color,batch_size, seq_len, spec.crop_size, spec.crop_size, spec.channels,resolution_x,resolution_y, resolution_z)\\n #print(tf.shape(trans_color_img))\\n #trans_input = np.array(trans_color_img,dtype=np.float32)\\n #trans_color_img = cv2.cvtColor( trans_input, cv2.COLOR_LUV2RGB)\\n # temporal mask, 1 indicates the selected frame\\n indicator = [0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0]\\n\\n true_image = tf.minimum(tf.maximum(modifier[0,0,:,:,:]+trans_color_img [0,0,:,:,:]*255.0, -spec.mean+spec.rescale[0]), -spec.mean+spec.rescale[1])/255.0\\n true_image = tf.expand_dims(true_image, 0)\\n for ll in range(seq_len-1):\\n if indicator[ll+1] == 1:\\n mask_temp = tf.minimum(tf.maximum(modifier[0,ll+1,:,:,:]+input_image[0,ll+1,:,:,:]*255.0, -spec.mean+spec.rescale[0]), -spec.mean+spec.rescale[1])/255.0\\n else:\\n mask_temp = input_image[0,ll+1,:,:,:]\\n mask_temp = tf.expand_dims(mask_temp,0)\\n true_image = tf.concat([true_image, mask_temp],0)\\n true_image = tf.expand_dims(true_image, 0)\\n\\n for kk in range(batch_size-1):\\n true_image_temp = tf.minimum(tf.maximum(modifier[0,0,:,:,:]+input_image[kk+1,0,:,:,:]*255.0, -spec.mean+spec.rescale[0]), -spec.mean+spec.rescale[1])/255.0\\n true_image_temp = tf.expand_dims(true_image_temp, 0)\\n for ll in range(seq_len-1):\\n if indicator[ll+1] == 1:\\n mask_temp = tf.minimum(tf.maximum(modifier[0,ll+1,:,:,:]+input_image[kk+1,ll+1,:,:,:]*255.0, -spec.mean+spec.rescale[0]), -spec.mean+spec.rescale[1])/255.0\\n else:\\n mask_temp = input_image[kk+1,ll+1,:,:,:]\\n mask_temp = tf.expand_dims(mask_temp,0)\\n true_image_temp = tf.concat([true_image_temp, mask_temp],0)\\n true_image_temp = tf.expand_dims(true_image_temp, 0)\\n\\n true_image = tf.concat([true_image, true_image_temp],0)\\n loss2 = tf.reduce_mean(1.0 - tf.image.ssim(true_image, input_image, max_val=255))\\n \\n #loss2 = tf.reduce_sum(tf.sqrt(tf.reduce_mean(tf.square(true_image-input_image), axis=[0, 2, 3, 4])))\\n norm_frame = tf.reduce_mean(tf.abs(modifier), axis=[2,3,4])\\n\\n sess = tf.Session()\\n probs, variable_set, pre_label,ince_output, pre_node = models.get_model(sess, true_image, model_name, False) \\n true_label_prob = tf.reduce_sum(probs*tf.one_hot(input_label,101),[1])\\n if targets is None:\\n loss1 = -tf.log(1 - true_label_prob + 1e-6)\\n else:\\n loss1 = -tf.log(true_label_prob + 1e-6)\\n loss1 = tf.reduce_mean(loss1)\\n loss = loss1 + weight_loss2 * loss2\\n\\n optimizer = tf.train.AdamOptimizer(learning_rate)\\n print('optimizer.minimize....')\\n train = optimizer.minimize(loss, var_list=[modifier,params_color])\\n # initiallize all uninitialized varibales\\n init_varibale_list = set(tf.all_variables()) - variable_set\\n sess.run(tf.initialize_variables(init_varibale_list))\\n\\n data = DataSet(test_list=test_file, seq_length=seq_len,image_shape=(spec.crop_size, spec.crop_size, spec.channels))\\n all_names = []\\n all_images = []\\n all_labels = []\\n \\n def_len = 40\\n for video in data.test_data:\\n frames = data.get_frames_for_sample(video)\\n if len(frames) < def_len:\\n continue\\n frames = data.rescale_list(frames, def_len)\\n frames_data = data.build_image_sequence(frames)\\n all_images.append(frames_data)\\n label, hot_labels = data.get_class_one_hot(video[1])\\n all_labels.append(label)\\n all_names.append(frames)\\n total = len(all_names)\\n all_indices = range(total)\\n num_batch = int(total/batch_size)\\n print('process data length:', num_batch)\\n\\n correct_ori = 0\\n correct_noi = 0\\n tot_image = 0\\n \\n for ii in range(num_batch): \\n images = all_images[ii*batch_size : (ii+1)*batch_size]\\n names = all_names[ii*batch_size : (ii+1)*batch_size]\\n labels = all_labels[ii*batch_size : (ii+1)*batch_size]\\n indices = all_indices[ii*batch_size : (ii+1)*batch_size]\\n print('------------------prediction for clean video-------------------')\\n print('---video-level prediction---')\\n for xx in range(len(indices)):\\n print(names[xx][0],'label:', labels[xx], 'indice:',indices[xx], 'size:', len(images[xx]), len(images[xx][0]), len(images[xx][0][0]), len(images[xx][0][0][0]))\\n sess.run(tf.initialize_variables(init_varibale_list))\\n if targets is not None:\\n labels = [targets[e] for e in names]\\n \\n feed_dict = {input_image: [images[0][0:seq_len]], input_label: labels}\\n var_loss, true_prob, var_loss1, var_loss2, var_pre, var_node = sess.run((loss, true_label_prob, loss1, loss2, pre_label, pre_node), feed_dict=feed_dict)\\n \\n correct_pre = correct_ori\\n for xx in range(len(indices)):\\n if labels[xx] == var_pre[xx]:\\n correct_ori += 1\\n\\n tot_image += 1\\n print('Start!')\\n min_loss = var_loss\\n last_min = -1\\n print('---frame-wise prediction---')\\n print('node_label:', var_node, 'label loss:', var_loss1, 'content loss:', var_loss2, 'prediction:', var_pre, 'probib', true_prob)\\n # record numer of iteration\\n tot_iter = 0\\n\\n if correct_pre == correct_ori:\\n ii += 1\\n continue\\n \\n print('------------------prediction for adversarial video-------------------')\\n\\n for cur_iter in range(max_iter):\\n tot_iter += 1\\n sess.run(train, feed_dict=feed_dict)\\n var_loss, true_prob, var_loss1, var_loss2, var_pre, var_node = sess.run((loss, true_label_prob, loss1, loss2, pre_label, pre_node), feed_dict=feed_dict)\\n print('iter:', cur_iter, 'total loss:', var_loss, 'label loss:', var_loss1, 'content loss:', var_loss2, 'prediction:', var_pre, 'probib:', true_prob)\\n break_condition = False\\n if var_loss < min_loss:\\n if np.absolute(var_loss-min_loss) < 0.00001:\\n break_condition = True\\n print(last_min)\\n min_loss = var_loss\\n last_min = cur_iter\\n\\n if cur_iter + 1 == max_iter or break_condition:\\n print('iter:', cur_iter, 'node_label:', var_node, 'label loss:', var_loss1, 'content loss:', var_loss2, 'prediction:', var_pre, 'probib:', true_prob)\\n var_diff, var_color,var_probs, noise_norm = sess.run((modifier, params_color,probs, norm_frame), feed_dict=feed_dict)\\n for pp in range(seq_len):\\n # print the map value for each frame\\n print(noise_norm[0][pp])\\n for i in range(len(indices)):\\n top1 = var_probs[i].argmax()\\n if labels[i] == top1:\\n correct_noi += 1\\n break\\n print('saved modifier paramters.', ii)\\n \\n for ll in range(len(indices)):\\n for kk in range(def_len):\\n if kk < seq_len:\\n attack_img = np.clip(images[ll][kk]*255.0+var_diff[0][kk]+data_spec.mean,data_spec.rescale[0],data_spec.rescale[1])\\n diff = np.clip(np.absolute(var_diff[0][kk])*255.0, data_spec.rescale[0],data_spec.rescale[1])\\n else:\\n attack_img = np.clip(images[ll][kk]*255.0+data_spec.mean,data_spec.rescale[0],data_spec.rescale[1])\\n diff = np.zeros((spec.crop_size,spec.crop_size,spec.channels))\\n im_diff = scipy.misc.toimage(arr=diff, cmin=data_spec.rescale[0], cmax=data_spec.rescale[1])\\n im = scipy.misc.toimage(arr=attack_img, cmin=data_spec.rescale[0], cmax=data_spec.rescale[1])\\n new_name = names[ll][kk].split('/')\\n \\n adv_dir = output_file_dir+'/adversarial/'\\n dif_dir = output_file_dir+'/noise/'\\n if not os.path.exists(adv_dir):\\n os.mkdir(adv_dir)\\n os.mkdir(dif_dir)\\n\\n tmp_dir = adv_dir+new_name[-2]\\n tmp1_dir = dif_dir+new_name[-2]\\n if not os.path.exists(tmp_dir):\\n os.mkdir(tmp_dir)\\n os.mkdir(tmp1_dir)\\n \\n new_name = new_name[-1] + '.png'\\n im.save(tmp_dir + '/' +new_name)\\n im_diff.save(tmp1_dir + '/' +new_name)\\n print('saved adversarial frames.', ii)\\n print('correct_ori:', correct_ori, 'correct_noi:', correct_noi)\",\n \"def delta_cross_entropy_softmax(outputs, labels):\\n \\n m = labels.shape[0]\\n grad = outputs\\n \\n grad[range(m),labels] -= torch.tensor(1.)\\n\\n grad = grad/m\\n avg_grads = grad\\n return avg_grads\",\n \"def rnn_backward(dh, cache):\\n dx, dh_prev, dWx, dWh, db = None, None, None, None, None\\n ##############################################################################\\n # TODO: Implement the backward pass for a vanilla RNN running an entire #\\n # sequence of data. You should use the rnn_step_backward function that you #\\n # defined above. #\\n ##############################################################################\\n \\\"\\\"\\\"\\n x, next_h, prev_h, Wx, Wh, b = cache\\n dz = (1-next_h*next_h)*dnext_h\\n # THIS ERROR IS SPREAD AMONG THE\\n # np.dot(x, Wx) + np.dot(prev_h, Wh) + b)\\n dx = np.dot(dz,Wx.T)\\n dprev_h = np.dot(dz,Wh.T)\\n db = np.sum(dz,axis=0)\\n dWx = np.dot(x.T,dz)\\n dWh = np.dot(prev_h.T,dz)\\n #d(tanh) = 1- tanh*tanh\\n \\\"\\\"\\\"\\n #pdb.set_trace()\\n # dh is not result of forward prop\\n # but\\n N,T,H = dh.shape\\n tmp_x, tmp_next_h, tmp_prev_h, tmp_Wx, tmp_Wh, tmp_b = cache[T-1]\\n D = tmp_x.shape[1]\\n\\n\\n dx = np.zeros((N,T,D))\\n dh_prev = np.zeros((N,H))\\n dWx = np.zeros((D,H))\\n dWh = np.zeros((H,H))\\n db = np.zeros((H))\\n\\n for i in reversed(list(range(0,T))):\\n # current gradient at timestep is the upstream gradient (provided as input)\\n # this may be coming from the Y as in the min_char_rnn.py (see line 59)\\n # + downstream gradient provided by rnn_step_backward.\\n dh_curr = dh[:,i,:] + dh_prev\\n dx_, dh_prev, dWx_, dWh_, db_ = rnn_step_backward(dh_curr, cache[i])\\n dWx += dWx_\\n dWh += dWh_\\n db += db_\\n dx[:,i,:]=dx_\\n\\n\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n return dx, dh_prev, dWx, dWh, db\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n # Implement the cost and gradients for one predicted word vector\\n # and one target word vector as a building block for word2vec\\n # models, assuming the softmax prediction function and cross\\n # entropy loss.\\n\\n # Inputs:\\n # - predicted: numpy ndarray, predicted word vector (\\\\hat{v} in\\n # the written component or \\\\hat{r} in an earlier version)\\n # - target: integer, the index of the target word\\n # - outputVectors: \\\"output\\\" vectors (as rows) for all tokens\\n # - dataset: needed for negative sampling, unused here.\\n\\n # Outputs:\\n # - cost: cross entropy cost for the softmax word prediction\\n # - gradPred: the gradient with respect to the predicted word\\n # vector\\n # - grad: the gradient with respect to all the other word\\n # vectors\\n\\n # We will not provide starter code for this function, but feel\\n # free to reference the code you previously wrote for this\\n # assignment!\\n\\n ### YOUR CODE HERE\\n yhat = softmax(np.dot(outputVectors, predicted))\\n\\n cost = -np.log(yhat[target])\\n\\n yhat_y = yhat.copy()\\n yhat_y[target] -= 1\\n\\n gradPred = np.dot(yhat_y, outputVectors)\\n\\n grad = yhat_y[:, np.newaxis] * np.tile(predicted, (yhat_y.shape[0], 1))\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def add_loss_op(self, preds):\\n ### YOUR CODE HERE (~2-4 lines)\\n trans = tf.get_variable('trans',\\n shape=[Config.n_classes, Config.n_classes],\\n initializer=tf.contrib.layers.xavier_initializer())\\n log_likelihood, _ = crf_log_likelihood(preds,\\n self.labels_placeholder,\\n self.length_placeholder,\\n trans)\\n #log_likelihood = tf.boolean_mask(log_likelihood, self.mask_placeholder)\\n loss = tf.reduce_mean(-1.0 * log_likelihood)\\n \\n ### END YOUR CODE\\n return trans, loss\",\n \"def SoftEntropy_sequence(nn_last_layer, correct_label, learning_rate): \\n \\n loss = tf2.math.reduce_sum( tf2.nn.softmax_cross_entropy_with_logits(tf2.stop_gradient(correct_label[:,12:38,:]), nn_last_layer[:,12:38,:]))\\n \\n #obtain training operation\\n optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate, epsilon = 1e-8) #Note default value of epsilon 1e-8 results in instability after few epochs\\n \\n #clip the gradients\\n gvs = optimizer.compute_gradients(loss)\\n #capped_gvs = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in gvs]\\n training_operation = optimizer.apply_gradients(gvs)\\n\\n return training_operation, loss\",\n \"def _AffBatchReluDrop_Backprop(self, dscores, cache):\\n grads = {}\\n loss = None\\n #Last Softmax Layer\\n ##Add L2 Regularization loss\\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\\n ##Calculate grads for last Affine\\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\\\\n affine_backward(dscores, cache[-1])\\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\\n\\n for i in range(self.num_layers-1, 0, -1): #hidden layers\\n ##L2 Reg. loss\\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\\n ##Calculate grads for [{affine-Batchnorm-relu-drop} X (L-1)]\\n dhid = dropout_backward(dhid, cache[i]['drop'])\\n dhid = relu_backward(dhid, cache[i]['relu'])\\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\\\\n batchnorm_backward_alt(dhid, cache[i]['batchnorm'])\\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\\\\n affine_backward(dhid, cache[i]['affine']) \\n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\\n\\n return grads, loss\",\n \"def forward_backward_prop(data, labels, params, dimensions):\\n\\n ### Unpack network parameters (do not modify)\\n ofs = 0\\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\\n\\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\\n ofs += Dx * H\\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\\n ofs += H\\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\\n ofs += H * Dy\\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\\n\\n ### YOUR CODE HERE: forward propagation\\n affine_1 = np.dot(data, W1) + b1\\n sigmoid_1 = sigmoid(affine_1)\\n affine_2 = np.dot(sigmoid_1, W2) + b2\\n scores = sigmoid(affine_2)\\n cost = - np.sum(np.multiply(np.log(softmax(scores)), labels))\\n ### END YOUR CODE\\n \\n ### YOUR CODE HERE: backward propagation\\n cross_entropy_grad_ = cross_entropy_grad(scores, labels)\\n sigmoid_2_grads = sigmoid_input_grad(cross_entropy_grad_, scores)\\n x_2_grad, gradW2, gradb2 = affine_grads(sigmoid_2_grads, sigmoid_1, W2, b2)\\n sigmoid_1_grads = sigmoid_input_grad(x_2_grad, sigmoid_1)\\n x_1_grad, gradW1, gradb1 = affine_grads(sigmoid_1_grads, data, W1, b1)\\n ### END YOUR CODE\\n \\n ### Stack gradients (do not modify)\\n grad = np.concatenate((gradW1.flatten(), gradb1.flatten(), \\n gradW2.flatten(), gradb2.flatten()))\\n return cost, grad\",\n \"def forward(input, label, conv, maxpool, softmax):\\n output = conv.forward((input / 255) - 0.5)\\n output = maxpool.forward(output)\\n output = softmax.forward(output)\\n\\n loss = -np.log(output[label])\\n acc = 1 if np.argmax(output) == label else 0\\n\\n return output, loss, acc\",\n \"def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\\n \\n for layer in range(len(architecture)-1,-1,-1):\\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imxi = architecture['layer{}'.format(layer+1)]\\n# print(\\\"Operation is:{} and Layer is: {}\\\".format(operationi,layer+1))\\n if operationi == 'softmax': # Last layer -> Dont apply softmax in any layer other than the last layer!\\n # not taking gradients here because we need dz_dX(secondlastlayer) which is y_pred - y\\n continue\\n \\n if operationi == 'conv_bn_relu' or operationi == 'conv_relu' or operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if operationi__1 == 'softmax':\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # .\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # .\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input_im2col)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input_im2col)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi #\\n elif operationi__1 == 'maxpool': # need to do something here to fix the problem\\n None\\n\\n elif 'flatten' in operationi__1:\\n # we currently have dz_doutput of flatten -> we want dz_doutput of the conv_bn_relu before flatten\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2] # weights2\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput of flatten\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5] # i\\n try:\\n dz_dXi = torch.t(weightsi__1).mm(dz_dXi__1)\\n except:\\n dz_dXi = weightsi__1.mm(dz_dXi__1)\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n\\n dz_dXi = torch.reshape(dz_dXi,(output_shapei[1]*output_shapei[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n dz_dweightsi = X_input_im2col.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n dz_dbi = dz_dXi\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)# Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi) # Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi) # Can also set this to layer like in line ~800\\n \\n else:\\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dX2 -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n \\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n if 'sigmoid' in operationi__1: # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi__1: # ...\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dXi = torch.reshape(dz_dXi,(output_shape_current_layer[1]*output_shape_current_layer[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,bias_current_layer.shape)\\n dz_dweightsi = X_im2col_current_layer.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n \\n if operationi == 'maxpool':\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n \\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n try:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n except:\\n Y = torch.t(weightsi__1).mm(dz_dXi__1) # Ensuring valid matrix multiplication here\\n \\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n \\n if operationi__1 == 'conv_sigmoid' or operationi__1 == 'conv_bn_sigmoid': # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXi[X_output <= 0] = 0\\n\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n \\n dz_dXinput = torch.zeros((X_input.shape))\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+1)][0] # output = output of maxpool\\n\\n dz_dXoutput = torch.reshape(dz_dXoutput,(output_shapei[0],X_input_im2col.shape[2]))\\n \\n for i in range(output_shapei[0]):\\n for j in range(X_input_im2col.shape[2]):\\n Xi2ci = X_im2col_current_layer[i,:,:]\\n idx = torch.argmax(Xi2ci[:,j]).item()\\n value = imxi[i][(idx,j)]\\n dz_dXinput[value[0],value[1],value[2]] += float(dz_dXoutput[i,j])\\n\\n# dz_dXinput = torch.reshape(dz_dXinput,output_shapei)\\n \\n X_prev_im2col = architecture['layer{}'.format(layer)][4]\\n X_output_prev = architecture['layer{}'.format(layer)][1]\\n X_output_prev = torch.reshape(X_output_prev,dz_dXinput.shape)\\n X_input_prev = architecture['layer{}'.format(layer)][0]\\n prev_bias = architecture['layer{}'.format(layer)][3]\\n output_shape_prev = architecture['layer{}'.format(layer)][6]\\n prev_operation = architecture['layer{}'.format(layer)][9]\\n \\n if prev_operation == 'conv_sigmoid' or prev_operation == 'conv_bn_sigmoid':\\n dz_dXinput *= sigmoid(X_output_prev)*(1-sigmoid(X_output_prev)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXinput[X_output_prev <= 0] = 0\\n \\n if len(dz_dXinput.shape) == 3:\\n dz_dXinput = torch.reshape(dz_dXinput,(-1,output_shape_prev[0]))\\n \\n dz_dbi = torch.reshape(dz_dXinput,prev_bias.shape)\\n dz_dweightsi = X_prev_im2col.mm(dz_dXinput)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer)][0] = torch.Tensor(dz_dXinput) # ...\\n \\n if 'flatten_dense' in operationi:\\n \\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n \\n if operationi__1 == 'softmax':\\n \\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n X_output = torch.reshape(X_output,(-1,1))\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if 'sigmoid' in operationi:\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # Can also set this to layer like in line ~800\\n \\n else:\\n # Have to modify and test this before implementation -> Specifically\\n # the backprop implementation is not consistent with the ones above\\n #\\n X_output = torch.reshape(X_output,(-1,1))\\n weights__i = architecture['layer{}'.format(layer+2)][2]\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+2)][0]\\n dz_dXoutput = torch.reshape(torch.Tensor(dz_dXoutput),X_output.shape)\\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n\\n if 'relu' in operationi:\\n dz_dXoutput[X_output<0] = 0\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n if 'sigmoid' in operationi:\\n dz_dXoutput*= sigmoid(X_output)*(1-sigmoid(X_output))\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n else:\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n \\n unflattened_Xinput = architecture['layer{}'.format(layer+1)][0]\\n dz_dXinput = torch.reshape(dz_dXinput,unflattened_Xinput.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXinput)\\n \\n if gradient_layerwise['layer{}'.format(layer+1)][1] is not None:\\n try:\\n grad_weights['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][1]\\n except:\\n grad_weights['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][1])\\n if gradient_layerwise['layer{}'.format(layer+1)][2] is not None:\\n try:\\n grad_bias['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][2]\\n except:\\n grad_bias['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][2])\\n \\n gc.collect()\\n return\",\n \"def _compute_loss(self, inputs, logits, targets, idxes):\\n clf_loss = F.cross_entropy(logits, targets)\\n\\n if self._task == 0:\\n distil_loss = torch.zeros(1, device=self._device)\\n else:\\n if self._finetuning:\\n # We only do distillation on current task during the distillation\\n # phase:\\n last_index = len(self._task_idxes)\\n else:\\n last_index = len(self._task_idxes) - 1\\n\\n distil_loss = 0.\\n #with torch.no_grad():\\n previous_logits = self._old_model(inputs)\\n\\n for i in range(last_index):\\n task_idxes = self._task_idxes[i]\\n\\n distil_loss += F.binary_cross_entropy(\\n F.softmax(logits[..., task_idxes] / self._temperature, dim=1),\\n F.softmax(previous_logits[..., task_idxes] / self._temperature, dim=1)\\n )\\n\\n return clf_loss, distil_loss\",\n \"def forward(self,pad_pred:torch.Tensor, pad_targets:torch.Tensor, ylen, ctc_out, hlens): # , ylen, encoder_output, hlens\\n batch_size,maxlen,_ = pad_pred.size()\\n self.loss = self.criterion(pad_pred.view(batch_size*maxlen,-1),pad_targets.view(-1))\\n ppl = self.compute_perplexity(self.loss.item())\\n self.loss *= (np.mean([ len(x[x!=self.ignore_label]) for x in pad_targets]) - 1)\\n\\n ## Try to add CTC loss.\\n ylen_tensor = torch.LongTensor([length for length in ylen])\\n hlens_tensor = torch.LongTensor([length for length in hlens])\\n ctc_pad_targets = torch.clone(pad_targets)\\n ctc_pad_targets[ctc_pad_targets==-1] = 0\\n self.loss = 0.9 * self.loss + 0.1 * \\\\\\n self.ctc(ctc_out.permute(1, 0, 2).log_softmax(-1), \\n ctc_pad_targets, hlens_tensor, ylen_tensor)\\n\\n if self.training:\\n return self.loss,self.compute_accuracy(pad_pred,pad_targets),None\\n else:\\n return self.loss,self.compute_accuracy(pad_pred,pad_targets),self.compute_wer(pad_pred,pad_targets)\",\n \"def loss_gradient(self, targets, scores):\\n m = targets * scores\\n numer = 4. * (2. * numpy.arctan(m) - 1.)\\n denom = 1. + m**2\\n return numer/denom\",\n \"def optimize(nn_last_layer, correct_label, learning_rate, num_classes):\\n logits = tf.reshape(nn_last_layer, (-1, num_classes), name='new_logits')\\n\\n labels = tf.reshape(correct_label, (-1, num_classes))\\n\\n logits = tf.Print(logits, [logits], message='logits: ', summarize = 100, first_n = 3)\\n labels = tf.Print(labels, [labels], message='labels: ', summarize = 100, first_n = 3)\\n #labels = tf.cast(labels, tf.float32)\\n\\n #cross_entropy_loss = tf.reduce_mean(\\n # tf.nn.softmax_cross_entropy_with_logits(logits=nn_last_layer, labels=correct_label))\\n\\n cross_entropy_loss = tf.reduce_mean(\\n tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))\\n\\n is_correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(tf.cast(labels, tf.float32), 1))\\n accuracy_op = tf.reduce_mean(tf.cast(is_correct_prediction, tf.float32), name=\\\"accuracy_op\\\")\\n\\n reg_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)\\n reg_constant = 0.01\\n loss_operation = tf.reduce_mean(cross_entropy_loss + reg_constant * sum(reg_losses))\\n\\n optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate)\\n #optimizer = tf.train.AdagradOptimizer(learning_rate = learning_rate)\\n\\n # https://discussions.udacity.com/t/using-transfer-learning/487140?u=subodh.malgonde\\n var_list = [var for var in tf.trainable_variables() if 'new_' in var.name]\\n print('Trainable variables: ', var_list)\\n train_op = optimizer.minimize(\\n loss_operation,\\n var_list = var_list)\\n\\n return logits, train_op, loss_operation, accuracy_op\",\n \"def train():\\n\\n ### DO NOT CHANGE SEEDS!\\n # Set the random seeds for reproducibility\\n np.random.seed(42)\\n\\n ## Prepare all functions\\n # Get number of units in each hidden layer specified in the string such as 100,100\\n if FLAGS.dnn_hidden_units:\\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\\\",\\\")\\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\\n else:\\n dnn_hidden_units = []\\n\\n # Get negative slope parameter for LeakyReLU\\n neg_slope = FLAGS.neg_slope\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n import matplotlib.pyplot as plt\\n\\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\\n train = data['train']\\n test = data['test']\\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\\n\\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\\n loss_module = CrossEntropyModule()\\n\\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n\\n images_test = test.images\\n labels_test = test.labels\\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\\n\\n for i in range(0, FLAGS.max_steps):\\n if PRINTS:\\n print('iter', i+1, end='\\\\r')\\n images, labels = train.next_batch(FLAGS.batch_size) \\n images = np.reshape(images, (images.shape[0], dim_x))\\n\\n pred = mlp.forward(images)\\n loss = loss_module.forward(pred, labels)\\n loss_grad = loss_module.backward(pred, labels)\\n mlp.backward(loss_grad)\\n\\n for module in reversed(mlp.modules):\\n if isinstance(module, LinearModule):\\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\\n if (i+1) % FLAGS.eval_freq == 0:\\n pred_test = mlp.forward(images_test)\\n loss_train[i // FLAGS.eval_freq] = loss\\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\\n if PRINTS:\\n print()\\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\\n\\n if PLOTS:\\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\\n fig.suptitle('Training curves for Numpy MLP\\\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\\n\\n ax[0].set_title('Loss')\\n ax[0].set_ylabel('Loss value')\\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[0].plot(loss_train, label='Train')\\n ax[0].plot(loss_test, label='Test')\\n ax[0].legend()\\n\\n ax[1].set_title('Accuracy')\\n ax[1].set_ylabel('Accuracy value')\\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[1].plot(accuracy_test, label='Test')\\n ax[1].legend()\\n plt.show()\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def process_gradient(engine, lr, parameters, grad_clip, accumulator):\\n with tf.GradientTape() as tape:\\n engine.optical_system.update()\\n engine.clear_ray_history()\\n engine.ray_trace(2)\\n output = tf.stack(\\n [engine.finished_rays[\\\"y_end\\\"], engine.finished_rays[\\\"z_end\\\"]],\\n axis=1\\n )\\n goal = tf.constant([(0, -.25)], dtype=tf.float64)\\n error = tf.math.squared_difference(output, goal)\\n grad = tape.gradient(error, parameters)\\n \\n print(f\\\"raw gradient: {grad}\\\")\\n \\n try:\\n grad = tf.where(tf.math.is_finite(grad), grad, tf.zeros_like(grad))\\n except(ValueError):\\n grad = tf.zeros_like(parameters, dtype=tf.float64)\\n grad *= lr\\n grad = tf.clip_by_value(grad, -grad_clip, grad_clip)\\n print(f\\\"gradient after scaling: {grad}\\\")\\n grad = tf.reshape(grad, (-1, 1))\\n grad = tf.matmul(accumulator, grad)\\n grad = tf.reshape(grad, (-1,))\\n print(f\\\"gradient after accumulation: {grad}\\\")\\n \\n return grad, tf.reduce_sum(error)\",\n \"def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\\n K=10):\\n\\n # Sampling of indices is done for you. Do not modify this if you\\n # wish to match the autograder and receive points!\\n indices = [target]\\n indices.extend(getNegativeSamples(target, dataset, K))\\n\\n ### YOUR CODE HERE\\n grad = np.zeros_like(outputVectors)\\n gradPred = np.zeros_like(predicted)\\n cost = 0.0\\n probability = 0.0\\n for sample_idx in indices:\\n similarity = outputVectors[sample_idx].dot(predicted.T)\\n probability = sigmoid(similarity) # squash to 0 ~ 1\\n if sample_idx == target: # positive sample\\n #p = sigmoid(outputVectors[sample_idx].dot(predicted.T))\\n cost += -np.log(sigmoid(similarity))\\n else: # negative sample\\n #p = sigmoid(-outputVectors[sample_idx].dot(predicted.T))\\n cost += -np.log(sigmoid(-similarity)) # deduction from reference 2.\\n \\n if sample_idx == target:\\n grad[sample_idx, :] += (probability - 1) * predicted\\n gradPred += (probability - 1) * outputVectors[sample_idx]\\n else:\\n grad[sample_idx, :] += probability * predicted\\n gradPred += probability * outputVectors[sample_idx]\\n '''\\n V, D = outputVectors.shape\\n one_hot_target = np.zeros(V)\\n one_hot_target[target] = 1\\n cost = 0\\n gradPred = np.zeros_like(predicted)\\n grad = np.zeros_like(outputVectors)\\n \\n for idx in indices:\\n context_vector = outputVectors[idx] # embedding vector (1, D)\\n cosine_similarity = normalizeRows(predicted).dot(normalizeRows(context_vector).T)\\n print('neg sample, consine_similarity={0}'.format(cosine_similarity))\\n binary_class = sigmoid(cosine_similarity)\\n print('neg sample, binary_class={0}'.format(binary_class))\\n \\n if idx == target:\\n cost += binary_class - 1\\n else:\\n cost += binary_class\\n \\n dlogits = sigmoid_grad(cosine_similarity)\\n #gradPred += dlogits * normalizeRows(context_vector)\\n #grad += np.outer(one_hot_target, dlogits * normalizeRows(predicted))\\n gradPred += dlogits\\n grad += np.outer(one_hot_target, dlogits)\\n '''\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def forward_backward_prop(data, labels, params, dimensions):\\n\\n ### Unpack network parameters (do not modify)\\n ofs = 0\\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\\n\\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\\n ofs += Dx * H\\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\\n ofs += H\\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\\n ofs += H * Dy\\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\\n\\n #print W2.shape, b2.shape\\n\\n #print len(W1), data[0], b1, len(data)\\n\\n ### YOUR CODE HERE: forward propagation\\n #Eg, find the cost function. Save some intermediate stuff though, seems like it'd be useful\\n #h = sigmoid(x * w1 + b1)\\n # y = (softmax( h * w2 + b2)\\n # hence the cost function will be labels * log(y) and then sum it all up\\n\\n z_1 = np.matrix(data) * W1 + b1\\n h = sigmoid(z_1)\\n y_prime = softmax(h * W2 + b2)\\n logs = np.log(y_prime)\\n\\n #print y_prime.shape\\n\\n #print np.array(logs) * labels\\n\\n cost = - np.sum(np.array(logs) * labels, axis = 1)\\n cost = np.sum(cost) # lets add up each instance fo the cost for now and see what happens\\n\\n # My question is then do we just sum up the costs of each function\\n #print cost #somethign is printing so I'm gonan say i'm a genius right here duh\\n\\n #Cost(y, y') = -sum of (y * log Y')\\n ### END YOUR CODE\\n\\n ### YOUR CODE HERE: backward propagation\\n\\n # you'll need gradients for each parameter except for the input vectors. Right now this isn't even a word2vec\\n delta_1 = y_prime - labels\\n delta_2 = delta_1 * W2.T\\n #print sigmoid_grad(h).shape\\n delta_3 = np.array(delta_2) * sigmoid_grad(h)\\n\\n gradW2 = np.array(h.T * delta_1) # i dunno or its reverse OMG I HASTE EVERYONE why is it that np.array fixes everything. Sigh\\n gradb2 = np.array(np.sum(delta_1, axis=0)) # main issue is that this is a 20 x 5 vector when it should be a 1 x 5\\n gradW1 = data.T.dot(delta_3)\\n gradb1 = np.sum(delta_3, axis=0) # this should be 1 x10 not 20 x 5\\n\\n\\n\\n ### END YOUR CODE\\n\\n #print gradW1, gradW1.flatten()\\n # print 'jee'\\n\\n ### Stack gradients (do not modify)\\n grad = np.concatenate((\\n gradW1.flatten(),\\n gradb1.flatten(),\\n gradW2.flatten(),\\n gradb2.flatten())\\n )\\n #print grad\\n #print cost\\n return cost, grad\",\n \"def compute_loss(darknet_output, ground_truth):\\n darknet_output = tf.reshape(darknet_output, [-1, 13, 13, 5, 85])\\n net_raw_xy = darknet_output[..., :2]\\n net_raw_hw = darknet_output[..., 2:4]\\n net_raw_conf = darknet_output[..., 4:5]\\n net_raw_prob = darknet_output[..., 5:]\\n\\n\\n prediction = output_to_prediction(darknet_output)\\n prediction = tf.reshape(prediction, [-1, 13, 13, 5, 85])\\n\\n # the factor used to calculate the object weight\\n obj_scale = 5\\n\\n # the factor used to calculate the no object weight\\n no_obj_scale = 1\\n\\n # the factor used to calculate the class prediction loss\\n class_scale = 1\\n\\n # the factor factor used to calculate the coordinate loss\\n coordinates_scale = 1\\n\\n # decode the prediction, convert all values to the 13x13 feature map\\n pred_xy_offset = prediction[..., :2]\\n pred_hw_ratio = prediction[..., 2:4]\\n pred_conf = prediction[..., 4:5]\\n pred_class = prediction[..., 5:]\\n\\n # decode the ground truth, convert all values to the 13x13 feature map\\n gt_xy_offset = ground_truth[..., :2]\\n gt_hw_ratio = ground_truth[..., 2:4]\\n gt_conf = ground_truth[..., 4:5]\\n gt_class = ground_truth[..., 5:]\\n\\n # 13 x 13 x 2 tensor, used to compute the x and y in the 13 x 13 feature map\\n biases = tf.Variable([[[j * 1.0, i * 1.0] for i in range(13)] for j in range(13)])\\n biases = tf.reshape(biases, [1, 13, 13, 1, 2])\\n\\n box_priors = tf.Variable([[0.57273, 0.677385], [1.87446, 2.06253], [3.33843, 5.47434], [7.88282, 3.52778], [9.77052, 9.16828]])\\n box_priors = tf.reshape(box_priors, [1, 1, 1, 5, 2])\\n\\n pred_xy = pred_xy_offset + biases\\n pred_hw = pred_hw_ratio * box_priors\\n\\n gt_xy = gt_xy_offset + biases\\n gt_hw = gt_hw_ratio * box_priors\\n\\n # calculate the top-left and bottom-right point of the predicted box\\n pred_xy_min, pred_xy_max = pred_xy - pred_hw / 2.0, pred_xy + pred_hw / 2.0\\n\\n gt_xy_min, gt_xy_max = gt_xy - gt_hw / 2.0, gt_xy + gt_hw / 2.0\\n\\n intersection_min = tf.maximum(gt_xy_min, pred_xy_min)\\n intersection_max = tf.minimum(gt_xy_max, pred_xy_max)\\n intersection_hw = tf.maximum(intersection_max - intersection_min, 0.0)\\n\\n # calculate the intersection area and the union area of the prediction and the ground truth\\n intersection_area = tf.multiply(intersection_hw[..., 0], intersection_hw[..., 1])\\n union_area = tf.multiply(gt_hw[..., 0], gt_hw[..., 1]) + tf.multiply(pred_hw[..., 0],\\n pred_hw[..., 1]) - intersection_area\\n # shape of iou: (?, 13, 13, 5)\\n box_iou = intersection_area / union_area\\n\\n obj = gt_conf\\n\\n gt_raw_hw = tf.log(gt_hw_ratio)\\n\\n gt_raw_hw = tf.where(tf.is_inf(gt_raw_hw), tf.zeros_like(gt_raw_hw), gt_raw_hw)\\n\\n # ======================================================================================\\n\\n coords_xy_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=net_raw_xy, labels=gt_xy_offset) * obj * coordinates_scale\\n coords_xy_loss = tf.reduce_sum(coords_xy_loss)\\n\\n coords_wh_loss = tf.square(net_raw_hw - gt_raw_hw) * 0.5 * obj * coordinates_scale\\n\\n coords_wh_loss = tf.reduce_sum(coords_wh_loss)\\n\\n coords_loss = coords_xy_loss + coords_wh_loss\\n\\n ignore_thresh = 0.5\\n\\n ignore_mask = tf.cast(tf.less(box_iou, ignore_thresh * tf.ones_like(box_iou)), tf.float32)\\n ignore_mask = tf.reshape(ignore_mask, [-1, 13, 13, 5])\\n ignore_mask = tf.expand_dims(ignore_mask, -1)\\n\\n back_loss = ((1 - obj) * tf.nn.sigmoid_cross_entropy_with_logits(logits=net_raw_conf, labels=obj) * ignore_mask)\\n back_loss = tf.reduce_sum(back_loss)\\n\\n fore_loss = obj * tf.nn.sigmoid_cross_entropy_with_logits(logits=net_raw_conf, labels=obj)\\n\\n fore_loss = tf.reduce_sum(fore_loss)\\n\\n conf_loss = back_loss + fore_loss\\n\\n class_loss = tf.reduce_sum(obj * tf.nn.sigmoid_cross_entropy_with_logits(logits=net_raw_prob, labels=gt_class))\\n\\n loss = coords_loss + conf_loss + class_loss\\n\\n return loss\",\n \"def projected_gradient_descent(self, x, y):\\n x_adv = x.clone().detach().requires_grad_(True).to(x.device)\\n targeted = self.y_target is not None\\n num_channels = x.shape[1]\\n\\n if self.random:\\n x_adv = random_perturbation(x_adv, self.norm, self.eps)\\n\\n for i in range(self.num_steps):\\n _x_adv = x_adv.clone().detach().requires_grad_(True)\\n\\n prediction = self.model(_x_adv)\\n loss = self.loss_fn(prediction, self.y_target if targeted else y)\\n loss.backward()\\n\\n with torch.no_grad():\\n # Force the gradient step to be a fixed size in a certain norm\\n if self.norm == 'inf':\\n gradients = _x_adv.grad.sign() * self.step_size\\n else:\\n # Note .view() assumes batched image data as 4D tensor\\n gradients = _x_adv.grad * self.step_size / _x_adv.grad.view(\\n _x_adv.shape[0], -1) \\\\\\n .norm(self.norm, dim=-1) \\\\\\n .view(-1, num_channels, 1, 1)\\n\\n if targeted:\\n # Targeted: Gradient descent with on the loss of the (incorrect) target label\\n # w.r.t. the image data\\n x_adv -= gradients\\n else:\\n # Untargeted: Gradient ascent on the loss of the correct label w.r.t.\\n # the model parameters\\n x_adv += gradients\\n\\n # Project back into l_norm ball and correct range\\n if self.norm == 'inf':\\n # Workaround as PyTorch doesn't have elementwise clip\\n x_adv = torch.max(torch.min(x_adv, x + self.eps), x - self.eps)\\n else:\\n delta = x_adv - x\\n\\n # Assume x and x_adv are batched tensors where the first dimension is\\n # a batch dimension\\n mask = delta.view(delta.shape[0], -1).norm(self.norm,\\n dim=1) <= self.eps\\n\\n scaling_factor = delta.view(delta.shape[0], -1).norm(self.norm,\\n dim=1)\\n scaling_factor[mask] = self.eps\\n\\n # .view() assumes batched images as a 4D Tensor\\n delta *= self.eps / scaling_factor.view(-1, 1, 1, 1)\\n\\n x_adv = x + delta\\n\\n x_adv = x_adv.clamp(*self.clamp)\\n\\n return x_adv.detach()\",\n \"def get_lr_cost(self):\\n\\n\\t\\tlabels = self.get_symbolic_expected_rewards()\\n\\n\\t\\treturn -theano.tensor.mean(\\n\\t\\t\\ttheano.tensor.log(labels)[\\n\\t\\t\\t\\ttheano.tensor.arange(self.symbolic_output.shape[0]),\\n\\t\\t\\t\\tself.symbolic_output])\",\n \"def loss_fn(outputs, labels, wts):\\n\\n # reshape labels to give a flat vector of length batch_size*seq_len\\n loss_noreduce = nn.BCEWithLogitsLoss(reduce=False)\\n loss = torch.mean(loss_noreduce(outputs, labels)*wts)\\n\\t\\n # compute cross entropy loss for all tokens\\n return loss\",\n \"def compute_gradients(images, model, class_index, **extra):\\n\\n num_classes = model.output.shape[1]\\n\\n expected_output = tf.ones([1, 14, 14, 14, 1])\\n\\n #if gt is not None:\\n # expected_output = gt\\n #else:\\n # expected_output = tf.one_hot([class_index] * images.shape[0], num_classes)\\n\\n #import ipdb; ipdb.set_trace()\\n inputs = tf.cast(images, tf.float32)\\n if model.name == \\\"unet\\\":\\n expected_output=extra['gt']\\n with tf.GradientTape() as tape:\\n inputs = tf.cast(inputs, tf.float32)\\n tape.watch(inputs)\\n predictions = model(inputs)\\n loss = tf.keras.losses.mse(\\n expected_output, predictions\\n ) \\n grad = tape.gradient(loss, inputs)\\n print('unet gradient')\\n return grad \\n\\n\\n elif model.name == 'discriminator':\\n expected_output = tf.ones([1, 14, 14, 14, 1])\\n # inputs = [inputs, extra['pred']]\\n # inputs = tf.cast(inputs, tf.float32)\\n #input_0 = tf.cast(inputs[0], tf.float32)\\n #input_1 = tf.cast(inputs[1], tf.float32)\\n with tf.GradientTape() as tape:\\n tape.watch(inputs)\\n # tape1.watch(inputs)\\n # predictions = model([input_0, input_1])\\n #predictions = model([extra['mri '], inputs])\\n predictions = model([inputs, extra['pred']])\\n loss = tf.keras.losses.mse(\\n expected_output, predictions\\n )\\n tape_grad = tape.gradient(loss, inputs)\\n \\n return tape_grad\",\n \"def optimize(nn_last_layer, correct_label, learning_rate, num_classes):\\n # TODO: Implement function\\n # reshape output Tensor from 4D to 2D\\n logits = tf.reshape(nn_last_layer, [-1, num_classes])\\n labels = tf.reshape(correct_label, [-1, num_classes])\\n\\n # calculate cross entropy loss\\n cross_entropy_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))\\n\\n # add regularization term\\n regularization_losses = tf.losses.get_regularization_losses()\\n loss = tf.add_n([cross_entropy_loss] + regularization_losses)\\n\\n # Adam offers several advantages over the simple tf.train.GradientDescentOptimizer.\\n # Foremost is that it uses moving averages of the parameters (momentum).\\n # Simply put, this enables Adam to use a larger effective step size, and the algorithm will converge\\n # to this step size without fine tuning. A simple tf.train.GradientDescentOptimizer could equally be used,\\n # but would require more hyperparameter tuning before it would converge as quickly.\\n train_op = tf.train.AdamOptimizer(learning_rate).minimize(loss)\\n return logits, train_op, loss\",\n \"def forward(self, *inputs):\\n\\n x = functional.relu(functional.max_pool2d(self.conv1(*inputs), 2))\\n x = functional.relu(functional.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\\n x = functional.relu(functional.max_pool2d(self.conv3(x), 2))\\n x = x.view(x.size(0), -1)\\n x = functional.relu(self.fc1(x))\\n x = functional.dropout(x, training=self.training)\\n x = self.fc2(x)\\n return functional.log_softmax(x, dim=1)\",\n \"def _custom_gradient_bi_tempered_logistic_loss(activations):\\n with tf.name_scope('gradient_bitempered_logistic'):\\n probabilities = tempered_softmax(activations, t2, num_iters)\\n loss_values = tf.math.multiply(\\n labels,\\n log_t(labels + 1e-10, t1) -\\n log_t(probabilities, t1)) - 1.0 / (2.0 - t1) * (\\n tf.math.pow(labels, 2.0 - t1) - tf.math.pow(probabilities, 2.0 - t1))\\n\\n def grad(d_loss):\\n \\\"\\\"\\\"Explicit gradient calculation.\\n Args:\\n d_loss: Infinitesimal change in the loss value.\\n Returns:\\n Loss gradient.\\n \\\"\\\"\\\"\\n delta_probs = probabilities - labels\\n forget_factor = tf.math.pow(probabilities, t2 - t1)\\n delta_probs_times_forget_factor = tf.math.multiply(delta_probs,\\n forget_factor)\\n delta_forget_sum = tf.math.reduce_sum(\\n delta_probs_times_forget_factor, -1, keepdims=True)\\n escorts = tf.math.pow(probabilities, t2)\\n escorts = escorts / tf.math.reduce_sum(escorts, -1, keepdims=True)\\n derivative = delta_probs_times_forget_factor - tf.math.multiply(\\n escorts, delta_forget_sum)\\n return tf.math.multiply(d_loss, derivative)\\n\\n return loss_values, grad\",\n \"def calculate_gradient_crf(train, model):\\n word = train[0]\\n label = train[1]\\n char_count, _ = word.shape\\n # get the marginals\\n marY, marY1 = get_marginals(word, model)\\n # calculate w_k for all 26 Ws. To do matrix approach\\n grad_W = []\\n for k in range(1,model.dimY+1):\\n ind_k = get_ind(label, k)\\n marginal_k = marY[:,k-1]\\n grad_k = np.dot((ind_k - marginal_k), word)\\n grad_W.append(grad_k)\\n \\n zero_mat = np.zeros((model.dimY,model.dimY))\\n label = np.array(label)\\n pairs = list(zip(label[:-1]-1, label[1:]-1))\\n grad_T = np.zeros((model.dimY,model.dimY))\\n for i,pair in enumerate(pairs):\\n ind_ij = zero_mat.copy()\\n ind_ij[pair] = 1.0\\n grad_T += ind_ij - marY1[i]\\n\\n grad_W = np.array(grad_W)\\n g = np.concatenate([grad_W.reshape(-1), grad_T.reshape(-1)])\\n return g\",\n \"def backPropagate(self, targets):\\n target = np.array(targets)\\n output_deltas = -(target - self.ao)\\n\\n error = output_deltas.dot(self.wo.T)\\n hidden2_deltas = dtanh(self.ah2) * error\\n\\n error = hidden2_deltas.dot(self.wh.T)\\n hidden1_deltas = dtanh(self.ah1) * error\\n\\n ############output ----> hidden_2##############\\n change = output_deltas.T.dot(self.ah2).T\\n self.wo -= (self.learning_rate * change) + (self.co * self.momentum)\\n self.co = change\\n ############hidden_2 ----> hidden_1##############\\n change = hidden2_deltas.T.dot(self.ah1).T\\n self.wh -= (self.learning_rate * change) + (self.ch * self.momentum)\\n self.ch = change\\n ############hidden_1 ----> input##############\\n change = hidden1_deltas.T.dot(self.ai).T\\n self.wi -= (self.learning_rate * change) + (self.ci * self.momentum)\\n self.ci = change\\n\\n return np.mean(-output_deltas)\",\n \"def get_d_data(conf, flow_hr, gen_outputs, r_targets, rnn_length):\\n # 3 frames are used as one entry, the last input images%3 frames are abandoned\\n t_size = int(3 * (rnn_length // 3))\\n t_gen_output = F.reshape(gen_outputs[:, :t_size, :, :, :], (conf.train.batch_size *\\n t_size, conf.train.crop_size*4, conf.train.crop_size*4, 3),\\n inplace=False)\\n t_targets = F.reshape(r_targets[:, :t_size, :, :, :], (conf.train.batch_size *\\n t_size, conf.train.crop_size*4, conf.train.crop_size*4, 3),\\n inplace=False)\\n t_batch = conf.train.batch_size * t_size // 3\\n t_inputs_v_pre_batch = F.identity(\\n flow_hr[:, 0:t_size:3, :, :, :]) # forward motion reused,\\n t_inputs_v_batch = nn.Variable(t_inputs_v_pre_batch.shape)\\n # no motion for middle frames\\n t_inputs_v_batch.data.zero()\\n t_inputs_v_nxt_batch = F.identity(\\n flow_hr[:, -2:-1-t_size:-3, :, :, :]) # backward motion\\n\\n t_vel = F.stack(\\n *[t_inputs_v_pre_batch, t_inputs_v_batch, t_inputs_v_nxt_batch], axis=2)\\n # batch, t_size/3, 3, FLAGS.crop_size*4, FLAGS.crop_size*4, 2\\n t_vel = F.reshape(t_vel, (conf.train.batch_size*t_size,\\n conf.train.crop_size*4, conf.train.crop_size*4, 2), inplace=False)\\n # Stop gradient to fnet from discriminator, details in TecoGAN supplemental paper\\n t_vel.need_grad = False\\n\\n disc_data = collections.namedtuple('disc_data',\\n 't_vel, t_gen_output, t_batch, t_targets, t_size')\\n return disc_data(\\n t_vel=t_vel,\\n t_gen_output=t_gen_output,\\n t_batch=t_batch,\\n t_targets=t_targets,\\n t_size=t_size\\n )\",\n \"def train(self, inputs, outputs, epochs = 10, batch_size = 32, lr = 0.001, transform = None, verbose = True):\\n\\n if transform:\\n outputs = transform(outputs)\\n n = (inputs.shape[1]-1)//batch_size + 1\\n\\n #inputs-1/batch - 1 < n <= inputs-1/batch\\n if len(outputs.shape) == 1:\\n outputs = outputs.reshape((1, outputs.shape[0]))\\n assert inputs.shape[1] == outputs.shape[1], \\\"Shapes does not match.\\\"\\n\\n data = nd.concat(inputs.T, outputs.T)\\n\\n efficiencies = []\\n cumuLosses = []\\n epochs = list(range(epochs))\\n\\n for i in epochs:\\n efficiency = 0\\n cumuLoss = 0\\n data = nd.shuffle(data)\\n batchs = [data[k*batch_size:min(inputs.shape[1], (k+1)*batch_size),:] for k in range(n)]\\n for batch in batchs:\\n with autograd.record():\\n output = self.compute(batch[:, :inputs.shape[0]].T)\\n loss = NeuralNet.squared_error(output, batch[:, inputs.shape[0]:].T)\\n loss.backward()\\n\\n self.adam_descent(batch_size, lr)\\n\\n output = nd.round(output)\\n cumuLoss += loss.asscalar()\\n efficiency += nd.sum(nd.equal(output, batch[:, inputs.shape[0]:].T)).asscalar()\\n\\n\\n efficiency /= outputs.shape[1] * outputs.shape[0]\\n efficiencies.append(efficiency)\\n\\n cumuLoss /= outputs.shape[1] * outputs.shape[0]\\n cumuLosses.append(cumuLoss)\\n\\n if verbose:\\n print(\\\"Epochs %d: Pe = %lf , loss = %lf\\\" % (i,1-efficiency,cumuLoss))\\n\\n return (epochs, cumuLosses, efficiencies)\",\n \"def forwardPropagation(self, inputs, label):\\n node_hidden = np.dot(inputs, self.input_W)\\n node_hidden = np.add(node_hidden, self.input_B)\\n node_hidden = np.maximum(0, node_hidden)\\n node_output = np.dot(node_hidden, self.hidden_W)\\n node_output = np.add(node_output, self.hidden_B)\\n #print(node_output)\\n exp_node_output = np.exp(node_output)\\n node_output = exp_node_output / np.sum(exp_node_output, axis=1, keepdims=True)\\n #print(node_output)\\n #node_output = self.softmax(node_output)\\n loss = np.sum(-np.log(node_output[range(inputs.shape[0]),label]))/(inputs.shape[0])+0.5 * self.regularizer*np.sum(self.input_W *self.input_W)+0.5 * self.regularizer*np.sum(self.hidden_W *self.hidden_W)\\n \\\"\\\"\\\"Loss= Input data loss + Loss correction by penalizing the loss, here we use 0.2 as an experimental value\\\"\\\"\\\"\\n #loss = np.sum(-np.log(node_output[range(inputs.shape[0]), label])) / (inputs.shape[0]) + 0.2 * self.regularizer * np.sum(self.input_W ^ 2) + 0.2 * self.regularizer * np.sum(self.hidden_W ^ 2)\\n return loss, node_hidden, node_output\",\n \"def compute_target_gradient(x, model, target):\\n with tf.GradientTape() as tape:\\n tape.watch(x) # need to watch the input tensor for grad wrt input\\n out = model(x, training=False) # in evaluation mode\\n target_out = out[:, target] # extract the target class outputs only\\n\\n image_grad = tape.gradient(target_out, x) # compute the gradient\\n\\n return out, image_grad\",\n \"def compute_target_gradient(x, model, target):\\n with tf.GradientTape() as tape:\\n tape.watch(x) # need to watch the input tensor for grad wrt input\\n out = model(x, training=False) # in evaluation mode\\n target_out = out[:, target] # extract the target class outputs only\\n\\n image_grad = tape.gradient(target_out, x) # compute the gradient\\n\\n return out, image_grad\",\n \"def _compute_loss(self, batch: Dict[str, torch.Tensor]) -> torch.Tensor:\\n\\n feat_static_cat = batch[\\\"feat_static_cat\\\"]\\n feat_static_real = batch[\\\"feat_static_real\\\"]\\n past_time_feat = batch[\\\"past_time_feat\\\"]\\n past_target = batch[\\\"past_target\\\"]\\n future_time_feat = batch[\\\"future_time_feat\\\"]\\n future_target = batch[\\\"future_target\\\"]\\n past_observed_values = batch[\\\"past_observed_values\\\"]\\n\\n picnn = self.model.picnn\\n\\n _, scale, hidden_state, _, _ = self.model.unroll_lagged_rnn(\\n feat_static_cat,\\n feat_static_real,\\n past_time_feat,\\n past_target,\\n past_observed_values,\\n future_time_feat,\\n future_target,\\n )\\n\\n hidden_state = hidden_state[:, : self.model.context_length]\\n\\n distr = self.model.output_distribution(picnn, hidden_state, scale)\\n\\n context_target = past_target[:, -self.model.context_length + 1 :]\\n target = torch.cat(\\n (context_target, future_target),\\n dim=1,\\n )\\n\\n loss_values = self.loss(distr, target)\\n\\n return loss_values.mean()\",\n \"def compile(self, optimizer, lr):\\n \\n #clip_morm = 0.1\\n self.loss_f = None\\n with self.graph.as_default():\\n \\n tvars = tf.trainable_variables()\\n ft_vars = [v for v in tvars if \\\"_fe\\\" in v.name] \\n lab_vars = [v for v in tvars if \\\"_dc\\\" not in v.name]\\n dom_vars = [v for v in tvars if \\\"_lp\\\" not in v.name]\\n\\n print()\\n print(\\\" ft updates:\\\", ft_vars)\\n print(\\\"96x3 updates:\\\", lab_vars)\\n print(\\\" 1x3 updates:\\\", dom_vars)\\n print()\\n\\n # `tf.nn.softmax_cross_entropy_with_logits` is deprcated.\\n # https://www.tensorflow.org/api_docs/python/tf/nn/softmax_cross_entropy_with_logits\\n self.loss = tf.nn.softmax_cross_entropy_with_logits_v2(labels=self.labels, logits=self.output, name='cross_entropy')\\n self.loss_adv = tf.nn.softmax_cross_entropy_with_logits_v2(labels=self.labels_adv, logits=self.output_adv, name='cross_entropy_adv')\\n \\n #grads_and_vars = optimizer.compute_gradients(loss, var_list=tf_vars)\\n #clipped_grads_and_vars = [(tf.clip_by_norm(grad, clip_norm=clip_norm), var) for grad, var in grads_and_vars]\\n \\n self.loss_fe = - lam * self.loss_adv\\n # `tf.control_dependencies` is necessary if `tf.layers.batch_normalization` is in the model\\n # https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization\\n self.train_step_adv = optimizer(lr).minimize(self.loss_fe, name='minimize_fe', var_list=ft_vars)\\n self.train_step = optimizer(lr).minimize(self.loss, name='minimize', var_list=lab_vars)\\n self.train_step_adv = optimizer(lr).minimize(self.loss_adv, name='minimize_adv', var_list=dom_vars)\\n\\n # Initialize all `tf.Variable`.\\n self.session.run(tf.global_variables_initializer())\",\n \"def calculate_prec_and_rec_gradient(y_true, output, thresholds, average):\\n# f1 = calculate_f1(y_true, output, thresholds, average)\\n prec, rec = calculate_prec_and_rec(y_true, output, thresholds, average)\\n\\n classes_num = len(thresholds)\\n\\n delta = 0.01\\n grads = []\\n # print(\\\"calculate_at_gradient, f1:\\\", f1)\\n\\n for k, threshold in enumerate(thresholds):\\n new_thresholds = thresholds.copy()\\n cnt = 0\\n while cnt < 10:\\n cnt += 1\\n new_thresholds[k] += delta\\n# f1_new = calculate_f1(y_true, output, new_thresholds, average)\\n prec_new, rec_new = calculate_prec_and_rec(y_true, output, new_thresholds, average)\\n# if f1_new != f1:\\n# break\\n if prec_new != prec or rec_new != rec:\\n break\\n\\n grad = 0.5 * (prec_new - prec + rec_new - rec) / (delta * cnt)\\n# grad = (0.2*(prec_new - prec) + 0.8*(rec_new - rec)) / (delta * cnt)\\n grads.append(grad)\\n\\n return grads\",\n \"def _flat_reconstruction_loss(self, flat_x_target, flat_rnn_output):\\n pass\",\n \"def training_step(self, rollouts):\\n self.optimizer.zero_grad()\\n\\n rollout_len = rollouts.shape[1]\\n input_frames = self.params['optimization']['input_frames']\\n assert(input_frames <= rollout_len) # optimization.use_steps must be smaller (or equal) to rollout.sequence_length\\n roll = rollouts[:, :input_frames]\\n\\n hgn_output = self.hgn.forward(rollout_batch=roll, n_steps=rollout_len - input_frames)\\n target = rollouts[:, input_frames-1:] # Fit first input_frames and try to predict the last + the next (rollout_len - input_frames)\\n prediction = hgn_output.reconstructed_rollout\\n\\n if self.params[\\\"networks\\\"][\\\"variational\\\"]:\\n tol = self.params[\\\"geco\\\"][\\\"tol\\\"]\\n alpha = self.params[\\\"geco\\\"][\\\"alpha\\\"]\\n lagrange_mult_param = self.params[\\\"geco\\\"][\\\"lagrange_multiplier_param\\\"]\\n\\n C, rec_loss = geco_constraint(target, prediction, tol) # C has gradient\\n\\n # Compute moving average of constraint C (without gradient)\\n if self.C_ma is None:\\n self.C_ma = C.detach()\\n else:\\n self.C_ma = alpha * self.C_ma + (1 - alpha) * C.detach()\\n C_curr = C.detach().item() # keep track for logging\\n C = C + (self.C_ma - C.detach()) # Move C without affecting its gradient\\n\\n # Compute KL divergence\\n mu = hgn_output.z_mean\\n logvar = hgn_output.z_logvar\\n kld = kld_loss(mu=mu, logvar=logvar)\\n\\n # normalize by number of frames, channels and pixels per frame\\n kld_normalizer = prediction.flatten(1).size(1)\\n kld = kld / kld_normalizer\\n\\n # Compute losses\\n train_loss = kld + self.langrange_multiplier * C\\n\\n # clamping the langrange multiplier to avoid inf values\\n self.langrange_multiplier = self.langrange_multiplier * torch.exp(\\n lagrange_mult_param * C.detach())\\n self.langrange_multiplier = torch.clamp(self.langrange_multiplier, 1e-10, 1e10)\\n\\n losses = {\\n 'loss/train': train_loss.item(),\\n 'loss/kld': kld.item(),\\n 'loss/C': C_curr,\\n 'loss/C_ma': self.C_ma.item(),\\n 'loss/rec': rec_loss.item(),\\n 'other/langrange_mult': self.langrange_multiplier.item()\\n }\\n\\n else: # not variational\\n # Compute frame reconstruction error\\n train_loss = reconstruction_loss(\\n target=target,\\n prediction=prediction)\\n losses = {'loss/train': train_loss.item()}\\n\\n train_loss.backward()\\n self.optimizer.step()\\n\\n return losses, hgn_output\",\n \"def grad_step(self, data, optimizer):\\n\\n running_loss = 0\\n \\n for i, batch in enumerate(data):\\n optimizer.zero_grad()\\n \\n # print(batch)\\n\\n nums, labels = batch\\n nums = nums.transpose(0,1)\\n # nums = nums.squeeze(1).reshape((-1, 784))\\n hidden = self.init_hidden(nums.size(1))\\n # print(nums.shape)\\n # # forward\\n out, _ = self(nums, hidden)\\n # loss = -self.obs.distr(out).log_prob(labels).mean()\\n # print(out.shape)\\n # print(labels.shape)\\n loss = nn.BCEWithLogitsLoss()(out.squeeze(), labels.squeeze())\\n # loss = -self.obs.distr(out).log_prob(labels).sum()\\n \\n # loss = -loglihood(self, nums, labels)\\n # foo = self(nums)[0]\\n # loss = nn.NLLLoss(reduction='sum')(foo, labels)\\n\\n # optimise\\n loss.backward()\\n optimizer.step()\\n \\n running_loss += loss.item()\\n \\n return running_loss/(i+1)\",\n \"def _tower_fn(\\n is_training,\\n weight_decay,\\n feature,\\n label,\\n data_format,\\n num_layers,\\n batch_norm_decay,\\n batch_norm_epsilon,\\n):\\n model = cifar10_model.ResNetCifar10(\\n num_layers,\\n batch_norm_decay=batch_norm_decay,\\n batch_norm_epsilon=batch_norm_epsilon,\\n is_training=is_training,\\n data_format=data_format,\\n )\\n logits = model.forward_pass(feature, input_data_format=\\\"channels_last\\\")\\n tower_pred = {\\n \\\"classes\\\": tf.argmax(input=logits, axis=1),\\n \\\"probabilities\\\": tf.nn.softmax(logits),\\n }\\n\\n tower_loss = tf.losses.sparse_softmax_cross_entropy(\\n logits=logits, labels=label\\n )\\n tower_loss = tf.reduce_mean(tower_loss)\\n\\n model_params = tf.trainable_variables()\\n tower_loss += weight_decay * tf.add_n(\\n [tf.nn.l2_loss(v) for v in model_params]\\n )\\n\\n tower_grad = tf.gradients(tower_loss, model_params)\\n\\n return tower_loss, zip(tower_grad, model_params), tower_pred\",\n \"def optimize(nn_last_layer, correct_label, learning_rate, num_classes):\\n # TODO: Implement function\\n \\n logits = tf.reshape(nn_last_layer, (-1, num_classes))\\n labels = tf.reshape(correct_label, (-1, num_classes))\\n #compute loss\\n cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels)\\n mean_cross_entropy_loss = tf.reduce_mean(cross_entropy, name=\\\"loss\\\")\\n\\n # perform accuracy operation\\n result_compare = tf.equal(tf.argmax(logits, axis=1), tf.argmax(labels, axis=1))\\n accuracy_op = tf.reduce_mean(tf.cast(result_compare, tf.float32), name=\\\"accuracy\\\")\\n\\n # initialize optimizer\\n optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)\\n\\n # create the minimize operation\\n trainable_variables = []\\n if TRANSFER_LEARNING_MODE:\\n# trainable_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope = \\\"deconv\\\")\\n for variable in tf.trainable_variables():\\n if \\\"de_conv\\\" in variable.name or 'beta' in variable.name:\\n trainable_variables.append(variable)\\n \\n training_op = optimizer.minimize( mean_cross_entropy_loss, var_list=trainable_variables, name=\\\"training_op\\\")\\n# training_op = optimizer.minimize(mean_cross_entropy_loss, name=\\\"training_op\\\")\\n\\n return logits, training_op, mean_cross_entropy_loss, accuracy_op\",\n \"def _AffBatchRelu_Backprop(self, dscores, cache):\\n grads = {}\\n loss = None\\n #Last Softmax Layer\\n ##Add L2 Regularization loss\\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\\n ##Calculate grads for last Affine\\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\\\\n affine_backward(dscores, cache[-1])\\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\\n\\n for i in range(self.num_layers-1, 0, -1): #hidden layers\\n ##L2 Reg. loss\\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\\n ##Calculate grads for [{affine-Batchnorm-relu} X (L-1)]\\n dhid = relu_backward(dhid, cache[i]['relu'])\\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\\\\n batchnorm_backward_alt(dhid, cache[i]['batchnorm'])\\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\\\\n affine_backward(dhid, cache[i]['affine']) \\n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\\n\\n return grads, loss\",\n \"def two_layer_net(X, model, y=None, reg=0.0):\\n\\n # unpack variables from the model dictionary\\n W1, b1, W2, b2 = model['W1'], model['b1'], model['W2'], model['b2']\\n N, D = X.shape\\n\\n # compute the forward pass\\n scores = None # shape (N, C)\\n\\n # Layer 1\\n # ReLU forward implementation\\n # Ref: http://cs231n.github.io/neural-networks-1/\\n s1 = X.dot(W1) + b1 # shape (N, H)\\n resp1 = np.where(s1 > 0, s1, 0) # shape (N, H)\\n\\n # Layer 2\\n s2 = resp1.dot(W2) + b2 # shape (N, C)\\n scores = s2\\n\\n # If the targets are not given then jump out, we're done\\n if y is None:\\n return scores\\n\\n # compute the loss\\n loss = None\\n f = scores.T - np.max(scores, axis=1) # shape (C, N)\\n f = np.exp(f)\\n p = f / np.sum(f, axis=0) # shape (C, N)\\n\\n # loss function\\n _sample_ix = np.arange(N)\\n loss = np.mean(-np.log(p[y, _sample_ix]))\\n loss += (0.5 * reg) * np.sum(W1 * W1)\\n loss += (0.5 * reg) * np.sum(W2 * W2)\\n\\n # compute the gradients\\n grads = {}\\n\\n df = p # (C, N)\\n df[y, _sample_ix] -= 1\\n # (H, C) = ((C, N) x (N, H)).T\\n dW2 = df.dot(resp1).T / N # (H, C)\\n dW2 += reg * W2\\n grads['W2'] = dW2\\n\\n # C = (C, N)\\n db2 = np.mean(df, axis=1) # C\\n grads['b2'] = db2\\n\\n # (N, H) = (H, C)\\n dresp1 = W2.dot(df).T / N\\n ds1 = np.where(s1 > 0, dresp1, 0) # (N, H)\\n dW1 = X.T.dot(ds1) # (D, H)\\n dW1 += reg * W1\\n grads['W1'] = dW1\\n\\n db1 = np.sum(ds1, axis=0) # H\\n grads['b1'] = db1\\n return loss, grads\",\n \"def class_gradient(self, x, label=None, logits=False):\\n logger.info('Apply Expectation over Transformations.')\\n class_gradient = self.classifier.class_gradient(next(self.transformation())(x), label, logits)\\n for _ in range(self.sample_size - 1):\\n class_gradient += self.classifier.class_gradient(next(self.transformation())(x), label, logits)\\n\\n return class_gradient / self.sample_size\",\n \"def CELOSS(output,label,delay = 0):\\n if delay > 0:\\n label.data[delay:,:] = label.data[0:-delay,:]\\n label.data[0:delay, :] = -1\\n _,predict = torch.max(output,1)\\n correct = (predict.data == label.view(-1).data).sum()\\n\\n #correct = np.sum(predict_data == yt.reshape(-1))\\n \\n mask = (label>=0)\\n output =F.log_softmax(output)\\n labselect = label + (label<0).long()\\n select = -torch.gather(output,1,labselect.view(-1,1))\\n losses = mask.float().cuda().view(-1,1)*select\\n loss = torch.sum(losses)/torch.sum(mask.float())\\n return loss, correct\",\n \"def _AffLayerReluDrop_Backprop(self, dscores, cache):\\n grads = {}\\n loss = None\\n #Last Softmax Layer\\n ##Add L2 Regularization loss\\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\\n ##Calculate grads for last Affine\\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\\\\n affine_backward(dscores, cache[-1])\\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\\n\\n for i in range(self.num_layers-1, 0, -1): #hidden layers\\n ##L2 Reg. loss\\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\\n ##Calculate grads for [{affine-Batchnorm-relu} X (L-1)]\\n dhid = dropout_backward(dhid, cache[i]['drop'])\\n dhid = relu_backward(dhid, cache[i]['relu'])\\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\\\\n layernorm_backward(dhid, cache[i]['layernorm'])\\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\\\\n affine_backward(dhid, cache[i]['affine']) \\n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\\n\\n return grads, loss\",\n \"def SoftEntropy(nn_last_layer, correct_label, learning_rate): \\n \\n loss = tf2.math.reduce_sum( tf2.nn.softmax_cross_entropy_with_logits(tf2.stop_gradient(correct_label), nn_last_layer))\\n \\n #obtain training operation\\n optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate, epsilon = 1e-8) #Note default value of epsilon 1e-8 results in instability after few epochs\\n \\n #clip the gradients\\n gvs = optimizer.compute_gradients(loss)\\n #capped_gvs = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in gvs]\\n training_operation = optimizer.apply_gradients(gvs)\\n\\n return training_operation, loss\",\n \"def _compute_gradients(self, config):\\n with tf.GradientTape() as tape:\\n all_loss = self._compute_loss(**config)\\n # Compute gradients wrt input image\\n total_loss = all_loss[0]\\n return tape.gradient(total_loss, config['init_image']), all_loss\",\n \"def backward(self, outputs, labels):\\n # Layers & shape\\n depth = len(self.layer_dimensions) - 1\\n # num_classes, batch_size = outputs.shape\\n batch_size, num_classes = outputs.shape\\n coefficient = 1 / batch_size\\n # 1/ First case : last layer -> output\\n layer_a = \\\"a_\\\" + str(depth - 1)\\n a = self._cache[layer_a]\\n Jz = outputs - labels\\n # Weights gradients\\n dw = coefficient * np.dot(a.T, Jz)\\n db = coefficient * np.sum(Jz, axis=0)\\n self._grad[\\\"dw_\\\" + str(depth)] = dw\\n self._grad[\\\"db_\\\" + str(depth)] = db\\n # 2/ Second case : inside the layers\\n for i in range(depth - 1, 0, -1):\\n # Get the weights and biases\\n layer_w = \\\"w_\\\" + str(i + 1)\\n layer_a = \\\"a_\\\" + str(i - 1)\\n layer_z = \\\"z_\\\" + str(i)\\n w = self._parameters[layer_w]\\n a = self._cache[layer_a]\\n z = self._cache[layer_z]\\n # Gradients\\n Jz = self.activation_hidden.backward(z) * np.dot(Jz, w.T)\\n db = coefficient * np.sum(Jz, axis=0)\\n dw = coefficient * np.dot(a.T, Jz)\\n self._grad[\\\"dw_\\\" + str(i)] = dw\\n self._grad[\\\"db_\\\" + str(i)] = db\",\n \"def compute_backward_variables(self, normalized_logits, target):\\n\\n target_length = target.shape[0]\\n num_time_steps = normalized_logits.shape[0]\\n\\n\\t\\t######################\\n\\t\\t### YOUR CODE HERE ###\\n\\t\\t######################\\n\\n blank_label = normalized_logits.shape[1] - 1\\n l = add_blanks(target, blank_label)\\n target_length = l.shape[0]\\n\\n beta = np.zeros((target_length, num_time_steps))\\n\\n # init\\n beta[target_length - 1, num_time_steps - 1] = normalized_logits[num_time_steps - 1, l[-1]]\\n beta[target_length - 2, num_time_steps - 1] = normalized_logits[num_time_steps - 1, l[-2]]\\n\\n for s in xrange(target_length - 2):\\n beta[s, num_time_steps - 2] = 0.0\\n\\n # recursive case\\n for t in xrange(num_time_steps - 2, -1, -1):\\n for s in xrange(target_length - 3, -1, -1):\\n b_bar = beta[s, t+1] + beta[s+1, t+1]\\n \\n if l[s] == blank_label or l[s+2] == l[s]:\\n beta[s, t] = b_bar * normalized_logits[t, l[s]]\\n else:\\n beta[s, t] = (b_bar + beta[s+2, t+1]) * normalized_logits[t, l[2]]\\n\\n return beta\",\n \"def _add_mxnet_ctc_loss(pred, seq_len, label):\\n pred_ctc = mx.sym.Reshape(data=pred, shape=(-4, seq_len, -1, 0))\\n\\n loss = mx.sym.contrib.ctc_loss(data=pred_ctc, label=label)\\n ctc_loss = mx.sym.MakeLoss(loss)\\n\\n softmax_class = mx.symbol.SoftmaxActivation(data=pred)\\n softmax_loss = mx.sym.MakeLoss(softmax_class)\\n softmax_loss = mx.sym.BlockGrad(softmax_loss)\\n return mx.sym.Group([softmax_loss, ctc_loss])\",\n \"def loss(self, X, y=None):\\n W1 = self.params['W1']\\n W2, b2 = self.params['W2'], self.params['b2']\\n W3, b3 = self.params['W3'], self.params['b3']\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\n\\n scores = None\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n X, cache_conv = conv_forward(X, W1)\\n X, x_relu1 = relu_forward(X)\\n X, cache_maxpool = max_pool_forward(X, pool_param)\\n N1,C1,H1,W1 = X.shape\\n X = X.reshape(N1, C1 * H1 * W1)\\n X, cache_fc2 = fc_forward(X, W2, b2)\\n X, x_relu2 = relu_forward(X)\\n X, cache_fc3 = fc_forward(X, W3, b3)\\n scores = X\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n if y is None:\\n return scores\\n\\n loss, grads = 0, {}\\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. #\\n ############################################################################\\n loss, dx = softmax_loss(X, y)\\n dx, dw, db = fc_backward(dx, cache_fc3)\\n grads['W3'] = dw\\n grads['b3'] = db\\n dx = relu_backward(dx, x_relu2)\\n dx, dw, db = fc_backward(dx, cache_fc2)\\n grads['W2'] = dw\\n grads['b2'] = db\\n xx, Ind, pp = cache_maxpool\\n N2,C2,H2,W2 = xx.shape\\n H2 = int(H2/2)\\n W2 = int(W2/2)\\n dx = dx.reshape(N2,C2,H2,W2)\\n dx = max_pool_backward(dx, cache_maxpool)\\n dx = relu_backward(dx, x_relu1)\\n dx, dw = conv_backward(dx, cache_conv)\\n grads['W1'] = dw\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, grads\",\n \"def charbonnier_loss(y_true, y_pred, y_mask):\\n y_shape = tf.shape(y_true)\\n border = 3\\n max_pixels_shifts = 2*border\\n # crop the center of the reconstructed HR image\\n size_image = HR_SIZE\\n size_croped_image = size_image - max_pixels_shifts\\n clear_pixels = size_croped_image*size_croped_image\\n cropped_predictions = y_pred[:, border:size_image -\\n border, border:size_image-border]\\n alpha = 0.45\\n beta = 1.0\\n epsilon = 0.001\\n\\n X = []\\n for i in range(max_pixels_shifts+1): # range(7)\\n for j in range(max_pixels_shifts+1): # range(7)\\n cropped_labels = y_true[:, i:i+(size_image-max_pixels_shifts),\\n j:j+(size_image-max_pixels_shifts)]\\n cropped_y_mask = y_mask[:, i:i+(size_image-max_pixels_shifts),\\n j:j+(size_image-max_pixels_shifts)]\\n\\n cropped_y_mask = tf.cast(cropped_y_mask, tf.float32)\\n\\n cropped_predictions_masked = cropped_predictions*cropped_y_mask\\n cropped_labels_masked = cropped_labels*cropped_y_mask\\n\\n total_pixels_masked = tf.reduce_sum(cropped_y_mask, axis=[1, 2])\\n\\n # bias brightness\\n b = (1.0/total_pixels_masked)*tf.reduce_sum(\\n tf.subtract(cropped_labels_masked, cropped_predictions_masked),\\n axis=[1, 2])\\n\\n b = tf.reshape(b, [y_shape[0], 1, 1, 1])\\n\\n corrected_cropped_predictions = cropped_predictions_masked+b\\n corrected_cropped_predictions = corrected_cropped_predictions*cropped_y_mask\\n diff = tf.subtract(cropped_labels_masked,\\n corrected_cropped_predictions)\\n\\n error = tf.pow(tf.square(diff * beta) + tf.square(epsilon), alpha)\\n error = tf.multiply(cropped_y_mask, error)\\n\\n X.append(tf.reduce_sum(error) / total_pixels_masked)\\n\\n X = tf.stack(X)\\n # Take the minimum mse\\n minim = tf.reduce_min(X, axis=0)\\n return minim\",\n \"def train(self, total_time):\\n\\n start_time = time.time()\\n time_so_far = 0\\n\\n while time_so_far < total_time:\\n\\n with tf.GradientTape(persistent=True) as tape:\\n\\n # DATA LOSS\\n data_idxs_batch = np.random.choice(self.pdf_dataset.shape[0], self.batch_size)\\n data_batch = self.pdf_dataset[data_idxs_batch, :]\\n data_batch = tf.Variable(data_batch, dtype = tf.float32)\\n data_xyts = data_batch[:, :3]\\n data_target = data_batch[:, 3:4]\\n data_p_out = self.net_p(data_xyts)\\n\\n data_loss = self.data_weight*self.MSE(data_p_out, data_target)\\n\\n\\n # PDE LOSS\\n idxs_batch = np.random.choice(self.PDE_dataset.shape[0], self.batch_size)\\n pde_batch = self.PDE_dataset[idxs_batch, :]\\n pde_batch = tf.Variable(pde_batch, dtype = tf.float32)\\n residual = FP_2D(self.net_p, self.net_D, self.net_U, pde_batch, tape)\\n\\n target = tf.zeros(residual.shape, dtype = tf.float32)\\n pde_loss = self.pde_weight*self.MSE(residual, target)\\n\\n\\n # BC LOSS\\n idxs_batch = np.random.choice(self.BC_dataset.shape[0], self.batch_size)\\n BC_batch = self.BC_dataset[idxs_batch, :]\\n BC_batch = tf.Variable(BC_batch, dtype = tf.float32)\\n p_out = self.net_p(BC_batch)\\n target = tf.fill(p_out[:, 0:1].shape, np.float32(0))\\n BC_loss = self.BC_weight*self.MSE(p_out, target)\\n\\n\\n # NORMALIZING LOSS\\n segment_area = (self.xlims[1] - self.xlims[0])*(self.ylims[1] - self.ylims[0])/(self.dims**2)\\n xyts = get_random_norm_slice(self.xlims, self.ylims, self.tlims, self.dims)\\n xyts = tf.Variable(xyts, dtype = tf.float32)\\n p_out = self.net_p(xyts)\\n pdf_integral = segment_area*tf.math.reduce_sum(p_out)\\n norm_loss = self.norm_weight*(pdf_integral - 1.)**2\\n\\n\\n total_loss = data_loss + pde_loss + BC_loss + norm_loss # note the weightings are applied before this\\n\\n\\n trainables = self.net_p.trainable_variables + self.net_D.trainable_variables + self.net_U.trainable_variables\\n\\n grads = tape.gradient(total_loss, trainables)\\n\\n del tape\\n\\n self.optimizer.apply_gradients(zip(grads, trainables))\\n\\n\\n time_so_far_prev = time_so_far\\n time_so_far = (time.time() - start_time)/3600.\\n\\n if self.iterations % 10 == 0:\\n\\n self.total_losses.append(total_loss.numpy())\\n self.data_losses.append(data_loss.numpy())\\n self.pde_losses.append(pde_loss.numpy())\\n self.BC_losses.append(BC_loss.numpy())\\n self.norm_losses.append(norm_loss)\\n\\n tf.print('It: %d, Total loss: %.3e, Data loss: %.3e, PDE loss: %.3e, BC loss: %.3e, norm_loss: %.3e, Time: %.2fh' \\\\\\n % (self.iterations, total_loss, data_loss, pde_loss, BC_loss, norm_loss, time_so_far))\\n sys.stdout.flush()\\n\\n\\n self.iterations += 1\",\n \"def model_loss(inp, fake, real_label, fake_label):\\n \\n \\n Dreal,realcls,R1 = gradpen(inp)\\n [Dfake,fakecls] = D(fake)\\n # 1. Adversarial loss\\n \\n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\\n \\n \\n \\n # D has no sigmoid activation: \\\"from_logits=True\\\"\\n real_loss = tf.keras.losses.binary_crossentropy(\\n dlabelr, Dreal, from_logits=True)\\n real_loss = tf.reduce_mean(real_loss)\\n \\n fake_loss = tf.keras.losses.binary_crossentropy(\\n dlabelf, Dfake, from_logits=True)\\n fake_loss = tf.reduce_mean(fake_loss)\\n \\n Dadv = 0.5*(real_loss+fake_loss)\\n \\n Gadv = tf.keras.losses.binary_crossentropy(\\n glabel, Dfake, from_logits=True)\\n Gadv = tf.reduce_mean(Gadv)\\n \\n # 2. Classification loss\\n \\n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\\n Dcls = tf.reduce_mean(Dcls)\\n \\n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\\n Gcls = tf.reduce_mean(Gcls)\\n \\n # 3. Total loss\\n \\n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\\n \\n Gloss = Gadv + LAMBDA_CLS*Gcls\\n \\n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)\",\n \"def train(self, inputs, targets, eta, niterations):\\n ndata = np.shape(inputs)[0] # number of data samples\\n # adding the bias\\n inputs = np.concatenate((inputs, -np.ones((ndata, 1))), axis=1)\\n\\n # numpy array to store the update weights\\n updatew1 = np.zeros((np.shape(self.weights1)))\\n updatew2 = np.zeros((np.shape(self.weights2)))\\n updatew3 = np.zeros((np.shape(self.weights3)))\\n\\n self.Errors = []\\n for n in range(niterations):\\n\\n #############################################################################\\n # TODO: implement the training phase of one iteration which consists of two phases:\\n # the forward phase and the backward phase. you will implement the forward phase in \\n # the self.forwardPass method and return the outputs to self.outputs. Then compute \\n # the error (hints: similar to what we did in the lab). Next is to implement the \\n # backward phase where you will compute the derivative of the layers and update \\n # their weights. \\n #############################################################################\\n\\n # forward phase \\n self.outputs = self.forwardPass(inputs)\\n\\n # Error using the sum-of-squares error function\\n error = 0.5 * np.sum((self.outputs - targets) ** 2)\\n\\n if np.mod(n, 100) == 0:\\n self.Errors.append(error)\\n print(\\\"Iteration: \\\", n, \\\" Error: \\\", error)\\n\\n # backward phase \\n # Compute the derivative of the output layer. NOTE: you will need to compute the derivative of \\n # the softmax function. Hints: equation 4.55 in the book. \\n # deltao = (self.outputs - targets) * (self.outputs - self.outputs ** 2)\\n deltao = (self.outputs - targets) * self.outputs * (1 - self.outputs)\\n\\n # compute the derivative of the second hidden layer\\n\\n deltah2 = self.beta * self.hidden2 * (1.0 - self.hidden2) * (np.dot(deltao, np.transpose(self.weights3)))\\n\\n\\n # compute the derivative of the first hidden layer\\n deltah1 = self.beta * self.hidden1 * (1.0 - self.hidden1) * (np.dot(deltah2[:, :-1], np.transpose(self.weights2)))\\n\\n # update the weights of the three layers: self.weights1, self.weights2 and self.weights3\\n # here you can update the weights as we did in the week 4 lab (using gradient descent) \\n # but you can also add the momentum\\n\\n updatew1 = eta * np.dot(np.transpose(inputs), deltah1[:, :-1]) + self.momentum * updatew1\\n updatew2 = eta * np.dot(np.transpose(self.hidden1), deltah2[:, :-1]) + self.momentum * updatew2\\n updatew3 = eta * np.dot(np.transpose(self.hidden2), deltao) + self.momentum * updatew3\\n\\n self.weights1 -= updatew1\\n self.weights2 -= updatew2\\n self.weights3 -= updatew3\\n\\n #############################################################################\\n # END of YOUR CODE \\n #############################################################################\",\n \"def loss_func(self, logits, targets):\\r\\n return -np.sum(targets * np.log(logits)) / logits.shape[0]\",\n \"def compute_loss(self):\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.data.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def loss_fn(self, targets, outputs, model):\",\n \"def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\\n K=10):\\n\\n # Sampling of indices is done for you. Do not modify this if you\\n # wish to match the autograder and receive points!\\n indices = [target]\\n indices.extend(getNegativeSamples(target, dataset, K))\\n\\n ### YOUR CODE HERE\\n # Similar to softmax, we find the target matrix\\n # v_c structured as 1xD matrix\\n # u_o assume to be 1xD matrix\\n # u_k assume to be K x D matrix\\n # we pull the data assuming that each row represent one vector\\n v_c = predicted\\n u_o = outputVectors[target]\\n u_k = outputVectors[indices]\\n\\n\\n # The intermediary matrix outputs\\n # z_o, h_o: single scalar number\\n # z_k, h_k: K x 1 vector, wich each number associated with a neg sample\\n z_o = np.dot(u_o, v_c)\\n h_o = sigmoid(z_o)\\n z_k = np.dot(u_k, v_c)\\n h_k = sigmoid( - z_k)\\n\\n J_1 = - np.log(h_o)\\n J_2 = - np.sum( np.log(h_k) )\\n cost = J_1+ J_2\\n\\n # Return the gradient for the prediction function\\n # the prediction vector interacts with both the predicted vector\\n # the negative sample vectors so below are both parts of the gradient\\n # here we are trying to increase the prediction matrix to maximize\\n # the similarity with the predicted vector\\n # output is a 1 x D matrix\\n grad_pred_o = - (1 - h_o)*u_o\\n\\n # the second part is tyring to decrease\\n # similarity with the negative sample vectors\\n # K x 1 multiply be input is a k x D matrix, we will need to sum all negative samples\\n # along the rows. output is a 1 x D matrix\\n # reshape h_k so that it can multiple\\n grad_pred_k = np.dot(( 1 - h_k).T, u_k)\\n # find the predicted matrix gradient\\n # output is a 1 x D matrix\\n gradPred = grad_pred_o + grad_pred_k\\n\\n\\n # Return the gradient of the output vector\\n # create a matrix the same shape as outputVector\\n grad = np.zeros(outputVectors.shape)\\n # first find the gradient wrt to the target output vector\\n # here we want to increase the similarity between\\n # the target output vector and the center vector\\n # outputs is a 1 x D matrix\\n grad_u_o = - (1-h_o)*v_c\\n\\n # print('***************grad_u_o************')\\n # print(grad_u_o)\\n # print(grad_u_o.shape)\\n # replace the target row in output vector gradient\\n grad[target, ] = grad_u_o\\n # then find the gradient descent of all the u_k matrices\\n # K x 1 matrix multiply by 1 x 3\\n # K x D\\n grad_uk = - np.outer((h_k - 1), v_c)\\n # print('***************grad_uk************')\\n # print(grad_uk)\\n # for each token (row) replace gradient\\n for k in xrange(u_k.shape[0]):\\n index = indices[k]\\n grad[index] += grad_uk[k]\\n\\n ### END YOUR CODE\\n return cost, gradPred, grad\",\n \"def test_softmax(n_epochs=250, optimizer='cg'):\\n n_hidden = 10\\n n_in = 5\\n n_steps = 10\\n n_seq = 10 # per batch\\n n_batches = 50\\n n_classes = 3\\n n_out = n_classes # restricted to single softmax per time step\\n\\n np.random.seed(0)\\n # simple lag test\\n seq = np.random.randn(n_steps, n_seq * n_batches, n_in)\\n targets = np.zeros((n_steps, n_seq * n_batches), dtype=np.int)\\n\\n thresh = 0.5\\n # if lag 1 (dim 3) is greater than lag 2 (dim 0) + thresh\\n # class 1\\n # if lag 1 (dim 3) is less than lag 2 (dim 0) - thresh\\n # class 2\\n # if lag 2(dim0) - thresh <= lag 1 (dim 3) <= lag2(dim0) + thresh\\n # class 0\\n targets[2:, :][seq[1:-1, :, 3] > seq[:-2, :, 0] + thresh] = 1\\n targets[2:, :][seq[1:-1, :, 3] < seq[:-2, :, 0] - thresh] = 2\\n #targets[:, 2:, 0] = np.cast[np.int](seq[:, 1:-1, 3] > seq[:, :-2, 0])\\n\\n model = MetaRNN(n_in=n_in, n_hidden=n_hidden, n_out=n_out,\\n learning_rate=0.005, learning_rate_decay=0.999,\\n n_epochs=n_epochs, batch_size=n_seq, activation='tanh',\\n output_type='softmax')\\n\\n model.fit(seq, targets, validate_every=10, compute_zero_one=True,\\n optimizer=optimizer)\\n\\n seqs = xrange(10)\\n\\n plt.close('all')\\n for seq_num in seqs:\\n fig = plt.figure()\\n ax1 = plt.subplot(211)\\n plt.plot(seq[:, seq_num])\\n ax1.set_title('input')\\n ax2 = plt.subplot(212)\\n\\n # blue line will represent true classes\\n true_targets = plt.step(xrange(n_steps), targets[:, seq_num],\\n marker='o')\\n\\n # show probabilities (in b/w) output by model\\n guess = model.predict_proba(seq[:, seq_num][:, np.newaxis])\\n guessed_probs = plt.imshow(guess.squeeze().T, interpolation='nearest',\\n cmap='gray')\\n ax2.set_title('blue: true class, grayscale: probs assigned by model')\",\n \"def negSamplingCostAndGradient(predicted_vc, target, outputVectors_uk, dataset,\\n K=10):\\n\\n # Sampling of indices is done for you. Do not modify this if you\\n # wish to match the autograder and receive points!\\n indices = [target]\\n indices.extend(getNegativeSamples(target, dataset, K))\\n\\n cost = 0.0\\n sigmd_uoT_vc = sigmoid(np.dot(predicted_vc.reshape(-1), outputVectors_uk[target].T))\\n cost += -np.log(sigmd_uoT_vc)\\n\\n gradPred_dJ_vc = np.zeros_like(predicted_vc)\\n gradPred_dJ_vc += (sigmd_uoT_vc - 1) * outputVectors_uk[target]\\n\\n grad_dJ_uw = np.zeros_like(outputVectors_uk)\\n grad_dJ_uw[target:target + 1] = (sigmd_uoT_vc - 1) * predicted_vc\\n\\n neg_samples = []\\n for i in range(K):\\n j = dataset.sampleTokenIdx()\\n if j == target or (j in neg_samples):\\n i -= 1 # if negative sample is same with target or already sampled, then resample.\\n continue\\n neg_samples.append(j)\\n\\n sigmd_ukT_vc = sigmoid(-np.dot(predicted_vc.reshape(-1), outputVectors_uk[j].T))\\n cost += -np.log(sigmd_ukT_vc) # cost for negative sample\\n\\n grad_dJ_uw[j:j + 1] = (1 - sigmd_ukT_vc) * predicted_vc # gradient for negative sample\\n gradPred_dJ_vc += (1 - sigmd_ukT_vc) * outputVectors_uk[j]\\n\\n return cost, gradPred_dJ_vc, grad_dJ_uw\",\n \"def __init__(self, incoming, n_units, W_ci, W_ig, W_og, W_fg,\\n b_ci=tf.zeros, b_ig=tf.zeros, b_og=tf.zeros, b_fg=tf.zeros,\\n a_ci=tf.tanh, a_ig=tf.sigmoid, a_og=tf.sigmoid, a_fg=tf.sigmoid, a_out=tf.nn.elu,\\n c_init=tf.zeros, h_init=tf.zeros, learn_c_init=False, learn_h_init=False, forgetgate=True, comb='add',\\n store_states=False, return_states=False, output_dropout=False, precomp_fwds=True, W_red_rec=None,\\n a_reduce_recurrents=None, tickerstep_biases=None, learn_tickerstep_biases=True,\\n dilation_rate=(1, 1), name='ConvLSTMLayer'):\\n super(ConvLSTMLayer, self).__init__()\\n with tf.variable_scope(name) as self.layer_scope:\\n self.incoming, self.incoming_shape = get_input(incoming)\\n self.n_units = n_units\\n self.lstm_inlets = ['ci', 'ig', 'og', 'fg']\\n if return_states:\\n store_states = True\\n \\n #\\n # Initialize weights and biases\\n #\\n \\n # Turn W inits into lists [forward_pass, backward_pass]\\n W_ci, W_ig, W_og, W_fg = [v[:2] if isinstance(v, list) else [v, v] for v in [W_ci, W_ig, W_og, W_fg]]\\n \\n # Check if feature dimensions to produce agree for all weight windows with n_units\\n W_dims = [[w[0].get_shape().as_list()[3], w[1].get_shape().as_list()[3]] for w in [W_ci, W_ig, W_og, W_fg]]\\n W_dims = np.array(W_dims).flatten()\\n if np.any(W_dims != n_units):\\n raise ValueError(\\\"Feature dimensions to produce must agree with n_units!\\\")\\n \\n # TODO: make all gates optional (list with keys and function for splitting)\\n if not forgetgate:\\n def a_fg(x):\\n return tf.ones(x.get_shape().as_list())\\n \\n # Make W and b tf variables\\n W_ci, W_ig, W_og, W_fg = [[tofov(w, shape=None, var_params=dict(name=n + suffix)) for w, suffix in\\n zip(v, ['_fwd', '_bwd'])] for v, n in\\n zip([W_ci, W_ig, W_og, W_fg], ['W_ci', 'W_ig', 'W_og', 'W_fg'])]\\n b_ci, b_ig, b_og, b_fg = [tofov(b, shape=[n_units], var_params=dict(name=n)) for b, n in\\n zip([b_ci, b_ig, b_og, b_fg], ['b_ci', 'b_ig', 'b_og', 'b_fg'])]\\n \\n # Pack weights for fwd and bwd connections by concatenating them at sliding mask feature dimension\\n # TODO: enable parallel calculation on multi-gpu\\n W_fwd_conc = tf.concat(axis=3, values=[W[0] for W in [W_ci, W_ig, W_og, W_fg]], name='W_fwd_conc')\\n W_bwd_conc = tf.concat(axis=3, values=[W[1] for W in [W_ci, W_ig, W_og, W_fg]], name='W_bwd_conc')\\n \\n # Initialize kernel for reducing recurrent features\\n self.reduce_recurrents = None\\n self.W_red_rec = W_red_rec\\n if a_reduce_recurrents is not None:\\n self.W_red_rec = tofov(W_red_rec, var_params=dict(name='W_red_rec'))\\n \\n def reduce_recurrents(h_prev):\\n \\\"\\\"\\\"Reduces features of internal recurrent connections h_prev\\\"\\\"\\\"\\n return a_reduce_recurrents(conv2d(h_prev, self.W_red_rec))\\n \\n self.reduce_recurrents = reduce_recurrents\\n \\n # Initialize bias for tickersteps\\n if tickerstep_biases is not None:\\n self.W_tickers = OrderedDict(zip_longest(self.lstm_inlets,\\n [tofov(tickerstep_biases, shape=[n_units],\\n var_params=dict(name='W_tickers_' + g,\\n trainable=learn_tickerstep_biases))\\n for g in self.lstm_inlets]))\\n else:\\n self.W_tickers = None\\n \\n #\\n # Create mask for output dropout\\n # apply dropout to n_units dimension of outputs, keeping dropout mask the same for all samples,\\n # sequence positions, and pixel coordinates\\n #\\n output_shape = self.get_output_shape()\\n if output_dropout:\\n out_do_mask = tf.ones(shape=[output_shape[0], output_shape[2], output_shape[3], output_shape[4]],\\n dtype=tf.float32, name='out_do_mask')\\n out_do_mask = tf.nn.dropout(out_do_mask, keep_prob=1. - output_dropout,\\n noise_shape=[1, 1, 1, output_shape[4]])\\n \\n def out_do(x):\\n \\\"\\\"\\\"Function for applying dropout mask to outputs\\\"\\\"\\\"\\n if output_dropout:\\n return out_do_mask * x\\n else:\\n return x\\n \\n # Redefine a_out to include dropout (sneaky, sneaky)\\n a_out_nodropout = a_out\\n \\n def a_out(x):\\n return a_out_nodropout(out_do(x))\\n \\n #\\n # Handle initializations for h (outputs) and c (cell states) as Variable if overwriteable or tensor if not\\n # shape=(samples, x, y, n_units)\\n #\\n h_init = out_do(tofov(h_init, shape=[output_shape[0], output_shape[2], output_shape[3], output_shape[4]],\\n var_params=dict(trainable=learn_h_init)))\\n c_init = tofov(c_init, shape=[output_shape[0], output_shape[2], output_shape[3], output_shape[4]],\\n var_params=dict(trainable=learn_c_init))\\n \\n # Initialize lists to store LSTM activations and cell states\\n h = [h_init] # [-1, x, y, n_units]\\n c = [c_init] # [-1, x, y, n_units]\\n \\n self.precomp_fwds = precomp_fwds\\n self.store_states = store_states\\n self.return_states = return_states\\n \\n self.W_fwd = OrderedDict(zip(self.lstm_inlets, [W[0] for W in [W_ci, W_ig, W_og, W_fg]]))\\n self.W_bwd = OrderedDict(zip(self.lstm_inlets, [W[1] for W in [W_ci, W_ig, W_og, W_fg]]))\\n \\n self.W_fwd_conc = W_fwd_conc\\n self.W_bwd_conc = W_bwd_conc\\n self.a = OrderedDict(ci=a_ci, ig=a_ig, og=a_og, fg=a_fg, out=a_out)\\n self.b = OrderedDict(ci=b_ci, ig=b_ig, og=b_og, fg=b_fg)\\n self.h = h\\n self.c = c\\n self.comb = comb\\n self.max_seq_len = None\\n self.external_rec = None\\n \\n self.dilation_rate = dilation_rate\\n \\n self.out = tf.expand_dims(h_init, 1)\\n self.name = name\",\n \"def _AffLayerRelu_Backprop(self, dscores, cache):\\n grads = {}\\n loss = None\\n #Last Softmax Layer\\n ##Add L2 Regularization loss\\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\\n ##Calculate grads for last Affine\\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\\\\n affine_backward(dscores, cache[-1])\\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\\n\\n for i in range(self.num_layers-1, 0, -1): #hidden layers\\n ##L2 Reg. loss\\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\\n ##Calculate grads for [{affine-Batchnorm-relu} X (L-1)]\\n dhid = relu_backward(dhid, cache[i]['relu'])\\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\\\\n layernorm_backward(dhid, cache[i]['layernorm'])\\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\\\\n affine_backward(dhid, cache[i]['affine']) \\n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\\n\\n return grads, loss\",\n \"def class_gradient(self, x, label=None, logits=False):\\n # Check value of label for computing gradients\\n if not (label is None or (isinstance(label, (int, np.integer)) and label in range(self.nb_classes))\\n or (isinstance(label, np.ndarray) and len(label.shape) == 1 and (label < self.nb_classes).all()\\n and label.shape[0] == x.shape[0])):\\n raise ValueError('Label %s is out of range.' % str(label))\\n\\n self._init_class_grads(label=label, logits=logits)\\n\\n x_preproc = self._apply_processing(x)\\n x_defences, _ = self._apply_defences(x_preproc, None)\\n\\n if label is None:\\n # Compute the gradients w.r.t. all classes\\n if logits:\\n grads = np.swapaxes(np.array(self._class_grads_logits([x_defences])), 0, 1)\\n else:\\n grads = np.swapaxes(np.array(self._class_grads([x_defences])), 0, 1)\\n\\n elif isinstance(label, (int, np.integer)):\\n # Compute the gradients only w.r.t. the provided label\\n if logits:\\n grads = np.swapaxes(np.array(self._class_grads_logits_idx[label]([x_defences])), 0, 1)\\n else:\\n grads = np.swapaxes(np.array(self._class_grads_idx[label]([x_defences])), 0, 1)\\n\\n assert grads.shape == (x_defences.shape[0], 1) + self.input_shape\\n\\n else:\\n # For each sample, compute the gradients w.r.t. the indicated target class (possibly distinct)\\n unique_label = list(np.unique(label))\\n if logits:\\n grads = np.array([self._class_grads_logits_idx[l]([x_defences]) for l in unique_label])\\n else:\\n grads = np.array([self._class_grads_idx[l]([x_defences]) for l in unique_label])\\n grads = np.swapaxes(np.squeeze(grads, axis=1), 0, 1)\\n lst = [unique_label.index(i) for i in label]\\n grads = np.expand_dims(grads[np.arange(len(grads)), lst], axis=1)\\n\\n grads = self._apply_defences_gradient(x_preproc, grads)\\n grads = self._apply_processing_gradient(grads)\\n\\n return grads\",\n \"def TK_TCN_resnet(\\n n_classes, \\n feat_dim,\\n max_len,\\n gap=1,\\n dropout=0.0,\\n activation=\\\"relu\\\"):\\n ROW_AXIS = 1\\n CHANNEL_AXIS = 2\\n \\n initial_conv_len = 8\\n initial_conv_num = 64\\n\\n config = [ \\n [(1,8,64)],\\n [(1,8,64)],\\n [(1,8,64)],\\n [(2,8,128)],\\n [(1,8,128)],\\n [(1,8,128)],\\n ]\\n\\n input = Input(shape=(max_len,feat_dim))\\n model = input\\n\\n model = Convolution1D(initial_conv_num, \\n initial_conv_len,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=1)(model)\\n\\n for depth in range(0,len(config)):\\n blocks = []\\n for stride,filter_dim,num in config[depth]:\\n ## residual block\\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\\n relu = Activation(activation)(bn)\\n dr = Dropout(dropout)(relu)\\n conv = Convolution1D(num, \\n filter_dim,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=stride)(dr)\\n #dr = Dropout(dropout)(conv)\\n\\n\\n ## potential downsample\\n conv_shape = K.int_shape(conv)\\n model_shape = K.int_shape(model)\\n if conv_shape[CHANNEL_AXIS] != model_shape[CHANNEL_AXIS]:\\n model = Convolution1D(num, \\n 1,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=2)(model)\\n\\n ## merge block\\n model = merge([model,conv],mode='sum',concat_axis=CHANNEL_AXIS)\\n\\n ## final bn+relu\\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\\n model = Activation(activation)(bn)\\n\\n\\n if gap:\\n pool_window_shape = K.int_shape(model)\\n gap = AveragePooling1D(pool_window_shape[ROW_AXIS],\\n stride=1)(model)\\n flatten = Flatten()(gap)\\n else:\\n flatten = Flatten()(model)\\n\\n dense = Dense(output_dim=n_classes,\\n init=\\\"he_normal\\\",\\n activation=\\\"softmax\\\")(flatten)\\n\\n model = Model(input=input, output=dense)\\n # optimizer = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=True) \\n # model.compile(loss='categorical_crossentropy', optimizer=optimizer,metrics=['accuracy'])\\n return model\",\n \"def optimize(nn_last_layer, correct_label, learning_rate, num_classes):\\n\\n logits = tf.reshape(nn_last_layer, (-1, num_classes))\\n labels = tf.reshape(correct_label, (-1, num_classes))\\n\\n loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels = labels))\\n\\n train_op = tf.train.AdamOptimizer(learning_rate).minimize(loss)\\n\\n return logits, train_op, loss\",\n \"def backward_G(self):\\n # Calculate regularzation loss to make transformed feature and target image feature in the same latent space\\n self.loss_reg_gen = self.loss_reg * self.opt.lambda_regularization\\n\\n # Calculate l1 loss \\n loss_app_gen = self.L1loss(self.img_gen, self.input_P2)\\n self.loss_app_gen = loss_app_gen * self.opt.lambda_rec \\n \\n # parsing loss\\n label_P2 = self.label_P2.squeeze(1).long()\\n #print(self.input_SPL2.min(), self.input_SPL2.max(), self.parsav.min(), self.parsav.max())\\n self.loss_par = self.parLoss(self.parsav,label_P2)# * 20. \\n self.loss_par1 = self.L1loss(self.parsav, self.input_SPL2) * 100 \\n\\n # Calculate GAN loss\\n base_function._freeze(self.net_D)\\n D_fake = self.net_D(self.img_gen)\\n self.loss_ad_gen = self.GANloss(D_fake, True, False) * self.opt.lambda_g\\n\\n # Calculate perceptual loss\\n loss_content_gen, loss_style_gen = self.Vggloss(self.img_gen, self.input_P2) \\n self.loss_style_gen = loss_style_gen*self.opt.lambda_style\\n self.loss_content_gen = loss_content_gen*self.opt.lambda_content\\n\\n total_loss = 0\\n\\n for name in self.loss_names:\\n if name != 'dis_img_gen':\\n #print(getattr(self, \\\"loss_\\\" + name))\\n total_loss += getattr(self, \\\"loss_\\\" + name)\\n total_loss.backward()\",\n \"def softmaxCostAndGradientTestWrapper(predictedandOutputVectors):\\n target = 1\\n\\n predicted = predictedandOutputVectors[:1,:].reshape([-1,])\\n outputVectors = predictedandOutputVectors[1:,:]\\n\\n cost, gradPred, gradOut = softmaxCostAndGradient(predicted, target, outputVectors, None)\\n\\n return cost, np.vstack([gradPred,gradOut])\",\n \"def calc_loss(self, outputs, labels):\\n information_loss = self.bottleneck.buffer_capacity.mean() # Taking the mean is equivalent of scaling with 1/K\\n cross_entropy = F.cross_entropy(outputs, target=labels)\\n total = cross_entropy + self.beta * information_loss\\n self.ce_loss.append(cross_entropy.cpu().detach().numpy())\\n self.info_loss.append(information_loss.cpu().detach().numpy())\\n self.total_loss.append(total.cpu().detach().numpy())\\n return total\",\n \"def forward(self, X, labels):\\n features = self.get_conv_feats(X)\\n W = self.W\\n T = self.T\\n log_prob = CRFautograd.apply(W, T, features, labels)\\n return log_prob\",\n \"def _AffReluDrop_Backprop(self, dscores, cache):\\n grads = {}\\n loss = None\\n #Last Softmax Layer\\n ##Add L2 Regularization loss\\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\\n ##Calculate grads for last Affine\\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\\\\n affine_backward(dscores, cache[-1])\\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\\n\\n for i in range(self.num_layers-1, 0, -1): #hidden layers\\n thiscache = cache[i]\\n ##L2 Reg. loss\\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\\n ##Calculate grads for [{affine-relu-drop} X (L-1)]\\n dhid = dropout_backward(dhid, thiscache['drop'])\\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\\\\n affine_relu_backward(dhid, thiscache['affine_relu']) \\n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\\n\\n return grads, loss\",\n \"def backward_step(activations, targets, layers):\\n param_grads = collections.deque() # List of parameter gradients for each layer\\n output_grad = None # The error gradient at the output of the current layer\\n # Propagate the error backwards through all the layers.\\n # Use reversed to iterate backwards over the list of layers.\\n for i, layer in enumerate(reversed(layers)):\\n cur_layer_idx = len(layers) - i - 1\\n if cur_layer_idx <= NUM_LAYERS_SKIP:\\n # implement short circuit here\\n if layer.is_fc_layer:\\n grads = [0.0 for _ in range(layer.W.shape[0]*layer.W.shape[1]+layer.W.shape[1])]\\n else:\\n # normal gradient computation \\n Y = activations.pop() # Get the activations of the last layer on the stack\\n # Compute the error at the output layer.\\n # The output layer error is calculated different then hidden layer error.\\n if output_grad is None:\\n input_grad = layer.get_input_grad(Y, targets)\\n else: # output_grad is not None (layer is not output layer)\\n input_grad = layer.get_input_grad(Y, output_grad)\\n # Get the input of this layer (activations of the previous layer)\\n X = activations[-1]\\n # Compute the layer parameter gradients used to update the parameters\\n grads = layer.get_params_grad(X, output_grad)\\n param_grads.appendleft(grads)\\n # Compute gradient at output of previous layer (input of current layer):\\n output_grad = input_grad\\n return list(param_grads) # Return the parameter gradients\",\n \"def backPropagate(self, targets):\\n if len(targets) != self.output:\\n raise ValueError('NOT MATCH ERROR -- output number!')\\n\\n # calculate error terms for output\\n # the delta tell you which direction to change the weights\\n output_deltas = [0.0] * self.output\\n for k in range(self.output):\\n error = -(targets[k] - self.ao[k])\\n output_deltas[k] = dsigmoid(self.ao[k]) * error\\n\\n # calculate error terms for hidden\\n # delta tells you which direction to change the weights\\n hidden_deltas = [0.0] * (self.hidden - 1)\\n for j in range(self.hidden - 1):\\n error = 0.0\\n for k in range(self.output):\\n error += output_deltas[k] * self.wo[j][k]\\n hidden_deltas[j] = dsigmoid(self.ah[j]) * error\\n\\n # update the weights connecting hidden to output\\n for j in range(self.hidden):\\n for k in range(self.output):\\n change = output_deltas[k] * self.ah[j]\\n self.wo[j][k] -= self.learning_rate * change + self.co[j][k] * self.momentum\\n self.co[j][k] = change\\n\\n # update the weights connecting input to hidden\\n for i in range(self.input):\\n for j in range(self.hidden - 1):\\n change = hidden_deltas[j] * self.ai[i]\\n self.wi[i][j] -= self.learning_rate * change + self.ci[i][j] * self.momentum\\n self.ci[i][j] = change\\n\\n # calculate error\\n error = 0.0\\n for k in range(len(targets)):\\n error += 0.5 * (targets[k] - self.ao[k]) ** 2\\n return error\",\n \"def calculate_maxL_gradient(y, tx, w):\\n sig=sigmoid(tx.dot(w))\\n grad=tx.T.dot(sig-y)\\n #divides with number of samples so that learning rate is not dependant on number of samples\\n grad=grad/len(y) \\n return grad\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70471126","0.6771997","0.6501649","0.6481051","0.6475507","0.64638615","0.645722","0.644719","0.6429101","0.6332298","0.6330999","0.6292698","0.622307","0.6192175","0.6190752","0.61711174","0.6128896","0.61129713","0.6112532","0.6099241","0.60904557","0.6080622","0.607248","0.6041186","0.6036952","0.6024581","0.6020475","0.59909457","0.59766996","0.59700483","0.59676075","0.59609103","0.595922","0.59576625","0.59551823","0.59336174","0.5931615","0.5930361","0.59302324","0.59244406","0.59210587","0.5919308","0.59176946","0.59174126","0.5904423","0.59031683","0.5899769","0.58977705","0.58809686","0.58763885","0.5872817","0.587096","0.58704853","0.5869048","0.58684146","0.5855641","0.58515334","0.58515334","0.5847898","0.58459777","0.5836146","0.58348215","0.5831949","0.5829865","0.5829535","0.58288825","0.5827514","0.5813939","0.5808943","0.5799423","0.57918","0.57904077","0.5786511","0.5785944","0.57798356","0.57758987","0.5775416","0.5767837","0.57353723","0.57328093","0.57299244","0.57291496","0.572731","0.5726743","0.57184297","0.57153386","0.57140726","0.57106274","0.5710573","0.570726","0.5705994","0.5705869","0.56977","0.5696958","0.5696802","0.5692369","0.56918126","0.56910294","0.56900257","0.56859285"],"string":"[\n \"0.70471126\",\n \"0.6771997\",\n \"0.6501649\",\n \"0.6481051\",\n \"0.6475507\",\n \"0.64638615\",\n \"0.645722\",\n \"0.644719\",\n \"0.6429101\",\n \"0.6332298\",\n \"0.6330999\",\n \"0.6292698\",\n \"0.622307\",\n \"0.6192175\",\n \"0.6190752\",\n \"0.61711174\",\n \"0.6128896\",\n \"0.61129713\",\n \"0.6112532\",\n \"0.6099241\",\n \"0.60904557\",\n \"0.6080622\",\n \"0.607248\",\n \"0.6041186\",\n \"0.6036952\",\n \"0.6024581\",\n \"0.6020475\",\n \"0.59909457\",\n \"0.59766996\",\n \"0.59700483\",\n \"0.59676075\",\n \"0.59609103\",\n \"0.595922\",\n \"0.59576625\",\n \"0.59551823\",\n \"0.59336174\",\n \"0.5931615\",\n \"0.5930361\",\n \"0.59302324\",\n \"0.59244406\",\n \"0.59210587\",\n \"0.5919308\",\n \"0.59176946\",\n \"0.59174126\",\n \"0.5904423\",\n \"0.59031683\",\n \"0.5899769\",\n \"0.58977705\",\n \"0.58809686\",\n \"0.58763885\",\n \"0.5872817\",\n \"0.587096\",\n \"0.58704853\",\n \"0.5869048\",\n \"0.58684146\",\n \"0.5855641\",\n \"0.58515334\",\n \"0.58515334\",\n \"0.5847898\",\n \"0.58459777\",\n \"0.5836146\",\n \"0.58348215\",\n \"0.5831949\",\n \"0.5829865\",\n \"0.5829535\",\n \"0.58288825\",\n \"0.5827514\",\n \"0.5813939\",\n \"0.5808943\",\n \"0.5799423\",\n \"0.57918\",\n \"0.57904077\",\n \"0.5786511\",\n \"0.5785944\",\n \"0.57798356\",\n \"0.57758987\",\n \"0.5775416\",\n \"0.5767837\",\n \"0.57353723\",\n \"0.57328093\",\n \"0.57299244\",\n \"0.57291496\",\n \"0.572731\",\n \"0.5726743\",\n \"0.57184297\",\n \"0.57153386\",\n \"0.57140726\",\n \"0.57106274\",\n \"0.5710573\",\n \"0.570726\",\n \"0.5705994\",\n \"0.5705869\",\n \"0.56977\",\n \"0.5696958\",\n \"0.5696802\",\n \"0.5692369\",\n \"0.56918126\",\n \"0.56910294\",\n \"0.56900257\",\n \"0.56859285\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7260533"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":22195,"cells":{"query":{"kind":"string","value":"would this part be timecomsuming?"},"document":{"kind":"string","value":"def __call__(self, rgbd_img_batch, color_id):\n color = vis.id2color[color_id]\n lower, upper = np.array(hsv_range[color])\n #print('debug: rgbd_img_batch shape: ', rgbd_img_batch.shape)\n\n color_imgs, depth_imgs = rgbd_img_batch[:, :3, :, :], rgbd_img_batch[:, 3, :, :]\n color_imgs = color_imgs.permute(0, 2, 3, 1) # NHWC\n color_imgs_np = color_imgs.cpu().numpy()\n\n n = color_imgs.shape[0]\n\n\n pcds = []\n for idx in range(n):\n depth_img = depth_imgs[idx]\n hsv_img = cv2.cvtColor(color_imgs_np[idx].astype('uint8'), cv2.COLOR_RGB2HSV)\n mask = cv2.inRange(hsv_img, lower, upper)\n mask = torch.from_numpy(mask)\n if self.use_cuda:\n mask = mask.cuda()\n mask_index = mask > 0\n \n #print('debug: {} points detected'.format(mask_index.sum().item()))\n if mask_index.sum() > 0:\n x_pcd = self.x_pix * depth_img / self.camera_f\n y_pcd = self.y_pix * depth_img / self.camera_f\n\n # apply mask\n x_pcd = -x_pcd[mask_index]\n y_pcd = -y_pcd[mask_index]\n z_pcd = -depth_img[mask_index]\n pcd = torch.stack([x_pcd, y_pcd, z_pcd], dim=0)\n pcd = self.camera_mat.mm(pcd) + self.camera_pos\n pcd = pcd.transpose(0, 1)\n pcd = sample_pcd(pcd, self.num_points)\n else:\n \"\"\"no points detected\"\"\"\n print('Debug: pix2pcd warning: no point detected')\n pcd = get_random_pcd(self.num_points)\n\n pcds.append(pcd)\n pcds = torch.stack(pcds, dim=0)\n return pcds"},"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 _optimise(self):\n pass","def process():","def apply(self) -> None:","def apply(self) -> None:","def process(self):","def process(self):","def process(self):","def apply(self):","def task4_1(self):\n\n pass","def task4(self):\n\n pass","def reduce_run():","def substantiate():","def slow(newETM): #Status: Done, not tested\r\n pass","def executor(self):","def exo2():","def use(self):","def task5(self):\n\n pass","def fn():","def query3() :","def algorithm_loop(self):","def task3(self):\n\n pass","def map():","def _collect_all(self):","def RUN(self):","def _postprocess(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def processing(self):\n pass","def g():","def merge_two_calls(self) -> None:","def oneIteration(self):\n\t\traise NotImplementedError","def ncore(self):","def exercise_b2_53():\r\n pass","def exercise_b2_106():\r\n pass","def task():","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 test_full_house_flush_ind(self):","def think(s):","def CL(self):","def call(self):","def _regr_basic():","def func():","def do_work(self):","def common(self):","def check():","def exercise_b2_113():\r\n pass","def result(self):","def result(self):","def iterate(self):","def exercise_b2_107():\r\n pass","def preprocess(self):","def compute_debug(self):","def ParallelToserial(self):\n pass","def task1(self):\n \n pass","def degibber(self):","def __call__():","def __call__():","def __call__():","def __call__():","def __call__():","def exercise_b2_69():\r\n pass","def regular(self):","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def _optimized(self):\n return False","def __call__(self) -> None:","def _run_query(self):","def exercise_b2_52():\r\n pass","def process_thread(self):","def count():","def apply(self):\n pass","def apply(self):\n pass","def compute_statistics(self):","def next():","def next():","def code():","def _do_iteration(self):\n return True","def cx():","def performance(self, id):","def main():\n \n #Loop through each validation and deployment\n initTime = time.time()\n deploymentIDArray = [57, 60, 61, 62]\n for i in range(10):\n for j in deploymentIDArray:\n insertResults(j, i)\n\n print time.time() - initTime","def think(self):\n pass","def probe(self):","def exercise_b2_70():\r\n pass","def execute(self):","def execute(self):","def execute(self):","def execute(self):","def _prepare(self):","def _prepare(self):","def precalculate():\n pass"],"string":"[\n \"def _optimise(self):\\n pass\",\n \"def process():\",\n \"def apply(self) -> None:\",\n \"def apply(self) -> None:\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def apply(self):\",\n \"def task4_1(self):\\n\\n pass\",\n \"def task4(self):\\n\\n pass\",\n \"def reduce_run():\",\n \"def substantiate():\",\n \"def slow(newETM): #Status: Done, not tested\\r\\n pass\",\n \"def executor(self):\",\n \"def exo2():\",\n \"def use(self):\",\n \"def task5(self):\\n\\n pass\",\n \"def fn():\",\n \"def query3() :\",\n \"def algorithm_loop(self):\",\n \"def task3(self):\\n\\n pass\",\n \"def map():\",\n \"def _collect_all(self):\",\n \"def RUN(self):\",\n \"def _postprocess(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def processing(self):\\n pass\",\n \"def g():\",\n \"def merge_two_calls(self) -> None:\",\n \"def oneIteration(self):\\n\\t\\traise NotImplementedError\",\n \"def ncore(self):\",\n \"def exercise_b2_53():\\r\\n pass\",\n \"def exercise_b2_106():\\r\\n pass\",\n \"def task():\",\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 test_full_house_flush_ind(self):\",\n \"def think(s):\",\n \"def CL(self):\",\n \"def call(self):\",\n \"def _regr_basic():\",\n \"def func():\",\n \"def do_work(self):\",\n \"def common(self):\",\n \"def check():\",\n \"def exercise_b2_113():\\r\\n pass\",\n \"def result(self):\",\n \"def result(self):\",\n \"def iterate(self):\",\n \"def exercise_b2_107():\\r\\n pass\",\n \"def preprocess(self):\",\n \"def compute_debug(self):\",\n \"def ParallelToserial(self):\\n pass\",\n \"def task1(self):\\n \\n pass\",\n \"def degibber(self):\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def exercise_b2_69():\\r\\n pass\",\n \"def regular(self):\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def _optimized(self):\\n return False\",\n \"def __call__(self) -> None:\",\n \"def _run_query(self):\",\n \"def exercise_b2_52():\\r\\n pass\",\n \"def process_thread(self):\",\n \"def count():\",\n \"def apply(self):\\n pass\",\n \"def apply(self):\\n pass\",\n \"def compute_statistics(self):\",\n \"def next():\",\n \"def next():\",\n \"def code():\",\n \"def _do_iteration(self):\\n return True\",\n \"def cx():\",\n \"def performance(self, id):\",\n \"def main():\\n \\n #Loop through each validation and deployment\\n initTime = time.time()\\n deploymentIDArray = [57, 60, 61, 62]\\n for i in range(10):\\n for j in deploymentIDArray:\\n insertResults(j, i)\\n\\n print time.time() - initTime\",\n \"def think(self):\\n pass\",\n \"def probe(self):\",\n \"def exercise_b2_70():\\r\\n pass\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def _prepare(self):\",\n \"def _prepare(self):\",\n \"def precalculate():\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6332494","0.57432336","0.56503594","0.56503594","0.55950046","0.55950046","0.55950046","0.5529664","0.5525137","0.5439686","0.54379976","0.53378075","0.5307097","0.5272914","0.5244519","0.52339005","0.52292556","0.52130395","0.5194305","0.51748556","0.5164487","0.5134321","0.5122957","0.5076166","0.5075339","0.50653714","0.50653714","0.50653714","0.50653714","0.50653714","0.50653714","0.50653714","0.50653714","0.50653714","0.50653714","0.5060729","0.50429","0.5041301","0.5036119","0.50358456","0.5033274","0.50273466","0.5023011","0.5022233","0.50094426","0.4988498","0.49845237","0.4978138","0.49735197","0.49683818","0.49622986","0.49567717","0.4944714","0.494326","0.4928668","0.4928668","0.4923614","0.49197155","0.49133906","0.49112153","0.48934963","0.48863345","0.48846385","0.48793402","0.48793402","0.48793402","0.48793402","0.48793402","0.48734567","0.48647654","0.4861103","0.4861103","0.4861103","0.4861103","0.4861103","0.4848091","0.4837674","0.48355684","0.48335898","0.48314378","0.4828688","0.48191106","0.48191106","0.48035425","0.47870132","0.47870132","0.47863442","0.4785182","0.47834298","0.4781993","0.47814283","0.47624844","0.47613552","0.47584307","0.47550797","0.47550797","0.47550797","0.47550797","0.47524107","0.47524107","0.47510692"],"string":"[\n \"0.6332494\",\n \"0.57432336\",\n \"0.56503594\",\n \"0.56503594\",\n \"0.55950046\",\n \"0.55950046\",\n \"0.55950046\",\n \"0.5529664\",\n \"0.5525137\",\n \"0.5439686\",\n \"0.54379976\",\n \"0.53378075\",\n \"0.5307097\",\n \"0.5272914\",\n \"0.5244519\",\n \"0.52339005\",\n \"0.52292556\",\n \"0.52130395\",\n \"0.5194305\",\n \"0.51748556\",\n \"0.5164487\",\n \"0.5134321\",\n \"0.5122957\",\n \"0.5076166\",\n \"0.5075339\",\n \"0.50653714\",\n \"0.50653714\",\n \"0.50653714\",\n \"0.50653714\",\n \"0.50653714\",\n \"0.50653714\",\n \"0.50653714\",\n \"0.50653714\",\n \"0.50653714\",\n \"0.50653714\",\n \"0.5060729\",\n \"0.50429\",\n \"0.5041301\",\n \"0.5036119\",\n \"0.50358456\",\n \"0.5033274\",\n \"0.50273466\",\n \"0.5023011\",\n \"0.5022233\",\n \"0.50094426\",\n \"0.4988498\",\n \"0.49845237\",\n \"0.4978138\",\n \"0.49735197\",\n \"0.49683818\",\n \"0.49622986\",\n \"0.49567717\",\n \"0.4944714\",\n \"0.494326\",\n \"0.4928668\",\n \"0.4928668\",\n \"0.4923614\",\n \"0.49197155\",\n \"0.49133906\",\n \"0.49112153\",\n \"0.48934963\",\n \"0.48863345\",\n \"0.48846385\",\n \"0.48793402\",\n \"0.48793402\",\n \"0.48793402\",\n \"0.48793402\",\n \"0.48793402\",\n \"0.48734567\",\n \"0.48647654\",\n \"0.4861103\",\n \"0.4861103\",\n \"0.4861103\",\n \"0.4861103\",\n \"0.4861103\",\n \"0.4848091\",\n \"0.4837674\",\n \"0.48355684\",\n \"0.48335898\",\n \"0.48314378\",\n \"0.4828688\",\n \"0.48191106\",\n \"0.48191106\",\n \"0.48035425\",\n \"0.47870132\",\n \"0.47870132\",\n \"0.47863442\",\n \"0.4785182\",\n \"0.47834298\",\n \"0.4781993\",\n \"0.47814283\",\n \"0.47624844\",\n \"0.47613552\",\n \"0.47584307\",\n \"0.47550797\",\n \"0.47550797\",\n \"0.47550797\",\n \"0.47550797\",\n \"0.47524107\",\n \"0.47524107\",\n \"0.47510692\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":22196,"cells":{"query":{"kind":"string","value":"Deletes text object file, database records and any keywords in the graph."},"document":{"kind":"string","value":"def TextDelete(texttitle):\n\n path = app.config['UPLOAD_FOLDER'] + \\\n '/objects/' + texttitle + '.txt'\n with Database() as database:\n database.deleteText(texttitle, session['id'])\n\n # Loads in the file to be deleted and the keyword graph\n with open(path, \"rb\") as objectfile:\n current_file = pickle.load(objectfile)\n keywords = current_file.stats['Key Words']\n with open(\"word_graph.txt\", \"rb\") as graphfile:\n word_graph = pickle.load(graphfile)\n\n # Reduces each edge connected to the current file keywords\n for keyword in keywords:\n word_graph.add_node(keyword[0])\n for k in keywords:\n if k[0] != keyword[0]:\n word_graph.reduce_edge(keyword[0], k[0])\n\n # Rewrites the graph object file\n with open(\"word_graph.txt\", \"wb\") as graphfile:\n pickle.dump(word_graph, graphfile)\n\n # Deletes the object file\n os.remove(path)"},"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 delete():","def clear_db():\n humans = Human4j.nodes.all()\n for h in humans:\n h.delete()\n binomes = Binome4j.nodes.all()\n for b in binomes:\n b.delete()\n projects = Project4j.nodes.all()\n for p in projects:\n p.delete()\n sherpas = Sherpa4j.nodes.all()\n for sh in sherpas:\n sh.delete()\n students = Pioupiou4j.nodes.all()\n for piou in students:\n piou.delete()\n partenaires = Partenaire4j.nodes.all()\n for part in partenaires:\n part.delete()\n ps = Planete_Solidaire.nodes.all()\n for misc in ps:\n misc.delete()","def delete_db(self):\n import os.path\n os.remove(self.filepath)","def delete(self):\n self.graph._del(handle=self.handle)","def delete_model(self):\n os.remove(self.filepath)\n self.cmodel = None","def _delete_all(self):\n logging.info(\"Remove all nodes and relations from database.\")\n self.graph.delete_all()\n return","def clear_data_base():\n\n\tcommand = 'rm object_models/*.json'\n\tos.system(command)\n\tprint(\"data base cleared\")","def deleteAll(self):\n self.db.execute(\"DELETE FROM MATCH;\", ())","def delete(self):\n if not pdbox._args.get(\"dryrun\"):\n result = execute(pdbox.dbx.files_delete_v2, self.path)\n pdbox.debug(\"Metadata response: %s\" % result.metadata)\n pdbox.info(\"Deleted %s\" % self.uri)","def delete_table_data():\n try:\n print 'delete existing data'\n sql = 'delete from document'\n sql1 = 'delete from clean_keywords'\n sql2 = 'delete from keywords'\n util.executeSQL(conn, sql) # delete the existing data.\n util.executeSQL(conn, sql1)\n util.executeSQL(conn, sql2)\n except Exception as e:\n print e","def clear_data():\n logger.info(\"Delete Structure instances\")\n Structure.objects.all().delete()\n logger.info(\"Delete StructureType instances\")\n StructureType.objects.all().delete()\n logger.info(\"Delete Industry instances\")\n Industry.objects.all().delete()\n logger.info(\"Delete Price instances\")\n PriceList.objects.all().delete()\n logger.info(\"Delete Stock instances\")\n Stock.objects.all().delete()\n logger.info(\"Delete News instances\")\n News.objects.all().delete()\n logger.info(\"Delete NewsImages instances\")\n NewsImage.objects.all().delete()\n logger.info(\"Delete News Sections instances\")\n NewsCategorySection.objects.all().delete()\n logger.info(\"Delete Analysis instances\")\n AnalysisOpinion.objects.all().delete()\n logger.info(\"Delete Analysis Images instances\")\n AnalysisImage.objects.all().delete()\n logger.info(\"Delete Analysis Sections instances\")\n AnalysisCategorySection.objects.all().delete()","def _delete_datafile(sender, instance, **kwargs):\n instance.delete_datafile(save_instance=False)","def remove(self):\n for ref_node in self.node.find_references():\n ref_node.destroy()\n File.remove(self)","def predio_delete(sender, instance, **kwargs):\n instance.dataFile.delete(False)","def delete(self):\n\n del self.parent_mirror_dir[self.cvs_path]","def db_remove():\n\n db.session.close()\n db.drop_all()\n\n path = current_app.config['SNER_VAR']\n for file_object in os.listdir(path):\n file_object_path = os.path.join(path, file_object)\n if os.path.isdir(file_object_path):\n shutil.rmtree(file_object_path)\n else:\n os.unlink(file_object_path)","def remove(self):\n \n dbpath, config = self._start() \n desc_file = check_file(config.model_descriptions, dbpath,\n \"model_descriptions\", allow_none=False) \n self.logger.msg1(\"Reading model ids\")\n ids = values_in_column(desc_file, \"id\")\n self.logger.msg1(\"Deleting models: \"+str(len(ids)))\n delete_models(dbpath, ids)\n self._end()","def __del__(self):\r\n self.save()\r\n self.close()","def clear_db():\n from example_data import ExampleDataLoader\n ExampleDataLoader.clean_db()","def delete_path():\n #TODO delete path from database\n pass","def delete(self):\n ...","def deleteDB():\n db = sqlite.connect(db_path)\n db.row_factory = sqlite.Row\n cursor = db.cursor()\n cursor.execute(\"DELETE from rooms\")\n\n cursor.execute(\"DELETE from users\")\n\n cursor.execute(\"DELETE from urls\")\n\n cursor.fetchall()\n db.commit()\n cursor.close()\n db.close()","def delete(self):\n\n\n try:\n db = getDatabase()\n connection = db.connect()\n\n connection.delete(self)\n except Exception as e:\n raise e\n finally:\n db.dispose()","def delete(self):\n self._vertex_list.delete()\n self._vertex_list = None","def do_destroy(self, arg):\n args = shlex.split(arg)\n stored_objects = models.storage.all()\n\n if self.basic_errs(args):\n '''check if instance exists'''\n instance = self.check_instance(args[0], args[1], stored_objects)\n if instance:\n \"\"\"delete from FileStorage.__objects\"\"\"\n del stored_objects[instance]\n \"\"\"overwrite the new data to file.json\"\"\"\n models.storage.save()","def tearDown(self):\n self.db.close()\n self.dbfile.close()\n os.unlink(self.path)","def clean(obj):\n clean_up_generated_files(obj)","def delete(self):\n if not hasattr(self, 'id'):\n raise BadReference('No matching issue on disk')\n shutil.rmtree(self.paths['root'])","def cleanup(self):\r\n for f in [i for d in self.data.values() for i in d[\"filenames\"]]:\r\n try:\r\n os.unlink(f)\r\n except Exception: pass\r\n self.Destroy()","def remove_all():\n storage = FileStorage()\n objects = storage.all()\n objects = list(objects.values())\n\n for element in objects:\n storage.delete(element)\n objects = storage.all()","def delete(self):\n pdbox._args.get(\"dryrun\") or os.remove(self.path)\n pdbox.info(\"Deleted %s\" % self.path)","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def main(self):\n self.delete_details()\n self.delete_cleaned()\n self.vacuum()","def clean(params):\n if tf.gfile.IsDirectory(params.ckpt_path):\n tf.gfile.DeleteRecursively(params.ckpt_path)\n\n if tf.gfile.IsDirectory(params.summary_path):\n tf.gfile.DeleteRecursively(params.summary_path)\n\n if tf.gfile.IsDirectory(params.result_path):\n tf.gfile.DeleteRecursively(params.result_path)\n\n if tf.gfile.IsDirectory(params.log_path):\n tf.gfile.DeleteRecursively(params.log_path)\n\n if tf.gfile.IsDirectory(\"__pycache__\"):\n tf.gfile.DeleteRecursively(\"__pycache__\")\n\n if tf.gfile.IsDirectory(params.config_path):\n tf.gfile.DeleteRecursively(params.config_path)","def __del__(self):\n self.evaler.db.flush()","def delete(self):\n self.dbm().model_delete(self)","def delete_objects(data,\n path = None,\n submode_adjustor = None):\n if debug.description(): # description debugging\n print 'delete_objects', data, path\n\n if not path:\n raise error.CommandDescriptionError(\"Need path to delete an object\")\n\n data = dict(data)\n bigdb = bigsh.bigdb\n bigdb.canonicalize_values_of_path(path, data)\n\n # if the node type under configuration is a LIST\n # (or LEAF_LIST), this likely wants to add a new\n # item to the list.\n (schema, items_matched) = bigdb.schema_of_path(path, {} )\n if schema == None:\n print 'Missing Schema for', path\n return\n node_type = schema['nodeType']\n if debug.description(): # description debugging\n print 'delete_objects:', path, node_type\n\n if node_type == 'LIST':\n list_nodes = schema['listElementSchemaNode']\n selection = {}\n for key in list_nodes.get('keyNodeNames', []):\n if key in data:\n full_path = '%s/%s' % (path, key)\n selection[full_path] = data[key]\n del data[key]\n # populate for fields which are key's\n for key in list_nodes.get('keyNodeNames', []):\n if not key in selection:\n for row in command.bigsh.mode_stack:\n if 'name' in row and row['name'] == key:\n if 'obj' in row:\n selection[key] = row['obj']\n bigdb.add_mode_stack_paths(selection)\n if submode_adjustor:\n command.submode_adjustor_invoke(submode_adjustor,\n path,\n selection,\n data,\n 'delete')\n\n oper = bigdb.canonicalize_values_for_delete(path,\n data,\n selection,\n list_nodes['childNodes'])\n if oper == 'POST':\n bigdb.post(path, data, selection)\n else:\n # bigdb.delete(path, data, selection) perhaps date <- {}\n bigdb.delete(path, data, selection)\n return\n if node_type == 'LEAF_LIST':\n if debug.description(): # description debugging\n print 'delete_object: leaf-list needs implementation:LEAF_LISTN'\n selection = {}\n bigdb.add_mode_stack_paths(selection)\n leaf_node = schema['leafSchemaNode']\n type_node = leaf_node['typeSchemaNode']\n split_path = path.split('/')\n item_name = split_path[-1]\n item = None\n if item_name in data:\n item = data[item_name]\n elif type_node['name'] in data:\n item = data[type_node['name']]\n del data[type_node['name']]\n if debug.description(): # description debugging\n print 'DATUM', data, 'SELECTUM', selection, 'ITEM', item\n # Currently, 'add/delete' for specific elements isn't\n # directly support in the BigDB REST API's. \n split_path = path.split('/')\n base_path = '/'.join(split_path[:-1])\n (schema, result) = bigdb.schema_and_result(base_path, selection)\n collection = result.expect_single_result(failed_result = [])\n item_name = split_path[-1]\n if item_name in collection:\n collection = collection[item_name]\n if debug.description(): # description debugging\n print 'COLLECTION', collection, ' REMOVE ', item\n if item in collection:\n collection = [x for x in collection if x != item]\n bigdb.put(path, collection, selection, 'query')\n return\n raise error.CommandSemanticError('%s \"%s\" '\n 'not currently configured' %\n (item_name, item))\n return\n if node_type == 'CONTAINER':\n container_nodes = schema.get('childNodes')\n\n selection = {}\n bigdb.add_mode_stack_paths(selection)\n\n for (n,v) in data.items():\n oper = bigdb.canonicalize_values_for_delete(path,\n data,\n selection,\n container_nodes)\n if oper == 'PATCH':\n bigdb.patch(path, data, selection)\n else:\n item_path = '%s/%s' % (path, n)\n bigdb.delete(item_path, {}, selection)\n return\n\n bigsh.bigdb.add_mode_stack_paths(data)\n bigsh.bigdb.delete(path, data)","def deleteAllModelsFromScene(self):\r\n # research\r\n self.deleteNeedleDetectionModelsFromScene()\r\n self.deleteNeedleValidationModelsFromScene()","def delete(self):\n pdbox._args.get(\"dryrun\") or shutil.rmtree(self.path)\n pdbox.info(\"Deleted %s/\" % self.path)","def clear_db(self):\n self.cursor.execute(\"DELETE FROM TrackPoint\")\n self.cursor.execute(\"DELETE FROM Activity\")\n self.cursor.execute(\"DELETE FROM User\")\n self.db_connection.commit()","def delete(self):\n\t\tif self.hasUdim:\n\t\t\tfor a in self.udimPaths:\n\t\t\t\ta.delete()\n\t\telse:\n\t\t\tsuper( textureFile, self ).delete()","def delete(self, filename):\n pass","def tearDown(self):\n self.comment.post.delete()\n self.user.delete()\n\n print('Deleting comment...')\n self.comment.delete()\n print('Deleted comment.')\n print('Deleting test_file...')\n if os.path.exists('test_file.txt'):\n os.remove('test_file.txt')\n print('Deleted file')\n print()\n print()","def delete_document(self):\n pass","def delete(self):\n\t\t#self.log.info(\"Deleting file {}\".format(self._filepath))\n\t\tos.remove(self._filepath)","def delete_dataset(dataset_path):\n force_rmtree(dataset_path)","def tearDown(self):\n os.remove(self._dbfile)","def delete_data(self):\n conn = self._connect_DB()\n cur = conn.cursor()\n cur.execute(\"DELETE FROM movie_table;\")\n self._close_connection(conn)","def cleanup():\n cat = CSVCatalog.CSVCatalog()\n cat.drop_table(\"people\", force_drop=True)\n cat.drop_table(\"batting\", force_drop=True)\n cat.drop_table(\"teams\", force_drop=True)","def delete():\n\n # Check the pipe setup.\n check_pipe_setup(sequence=True, j=True)\n\n # The interatomic data.\n for interatom in interatomic_loop():\n # The data.\n if hasattr(interatom, 'j_coupling'):\n del interatom.j_coupling\n\n # The error.\n if hasattr(interatom, 'j_coupling_err'):\n del interatom.j_coupling_err","def clean(self):\n # Delete vertices / faces / colors / normals :\n self._vert_buffer.delete()\n self._index_buffer.delete()\n self._normals_buffer.delete()\n self._xrange_buffer.delete()\n self._math_buffer.delete()","def tearDown(self):\n # Empty objects in engine\n FileStorage._FileStorage__objects = {}\n # Remove file.json if exists\n if os.path.exists(\"file.json\"):\n os.remove(\"file.json\")","def clearmodels(self):\n \n dbpath, config = self._start() \n ModelDescriptionTable(dbpath).empty()\n ModelPhenotypeTable(dbpath).empty()\n ModelScoreTable(dbpath).empty() \n self._end()","def deleteHistory(self):\n\t\tmc.delete( self.objects, ch = True )","def destroy(self):\n self.db = None\n self.gen_cursor = None\n self.map = None\n self.fmap = None\n self.smap = None\n FlatBaseModel.destroy(self)","def destroy(self):\n for node in self.find_references():\n node.destroy()\n self._bld.RemoveObject(self.get_sobj())","def destroy_datastore(paths):\r\n for path in paths.values():\r\n if not path:\r\n continue\r\n try:\r\n if os.path.isdir(path):\r\n shutil.rmtree(path)\r\n else:\r\n os.remove(path)\r\n except OSError, error:\r\n if error.errno != 2:\r\n logging.error(\"Failed to clear datastore: %s\" % error)","def clear_doc():\n for obj in DOC.Objects:\n DOC.removeObject(obj.Name)","def delete(self):\n\n try:\n remove(self.file)\n except OSError:\n pass","def delete_object(self, object):\n object.delete()","def delete(self):\n\n cursor = self._conn.cursor()\n cursor.execute(\"DELETE FROM saves\")\n self._conn.commit()","def delete():\n\n from slicr.extensions import db\n\n click.echo('deleting database...')\n\n db.drop_all()","def delete(self): # DirObj.delete\n self.deleted=True\n for name, d in self.subdirs.iteritems():\n d.delete()\n for name, f in self.files.iteritems():\n f.delete()","def cleanUp(self):\r\n remove_files(self._db_files_to_remove, error_on_missing=False)","def cleanup(self):\n if os.path.exists(f\"{self.save_path}{self.name}\"):\n shutil.rmtree(f\"{self.save_path}{self.name}\")","def delEvery():\n delMain()\n delFile()\n delPuls()\n delSat()\n delFreq()\n delTemp()\n delGly()\n delDlr()\n label['text'] = \"All json files have been deleted !\"","def close(self):\n\n self._lod_histories = None\n self._node_db.close()\n self._node_db = None","def cleanup(self):\n if os.path.exists(self._db):\n os.remove(self._db)","def cleanup():\n cat = CSVCatalog.CSVCatalog()\n cat.drop_table(\"people\")\n cat.drop_table(\"batting\")\n cat.drop_table(\"teams\")","def flush(self):\n cursor = self.db.cursor()\n cursor.execute(\"DELETE FROM triples\")\n self.db.commit()","def clean(cls, pdb_object):\n if not cls.computed(pdb_object):\n return\n for successor in cls.successors:\n successor.clean(pdb_object)\n pdb_object.uncomplete(cls.name)\n for file in cls.files(pdb_object):\n file.delete()","def clean_database(databasePathname):\n print '# loading database ' + databasePathname\n try:\n db = gdbm.open(databasePathname, 'w')\n except:\n print \"# \" + databasePathname + \" could not be loaded\"\n sys.exit(-1)\n\n # even though gdbm supports memory efficient iteration over\n # all keys, I want to order my traversal across similar\n # paths to leverage caching of directory files:\n allKeys=db.keys()\n print '# finished loaded keys from ' + databasePathname\n allKeys.sort()\n print '# finished sorting keys from ' + databasePathname\n print '# deleting dead nodes'\n count=0\n for currKey in allKeys:\n try:\n os.stat(currKey)\n sys.stdout.write('.')\n except OSError:\n del db[currKey]\n sys.stdout.write('*')\n count=count+1\n sys.stdout.flush()\n print \"\\n# reorganizing \" + databasePathname\n db.reorganize()\n db.sync()\n db.close()\n print '# done cleaning ' + databasePathname + ', removed ' + str(count) + ' dead nodes!'","def __deleteSave(self) -> None:\n os.remove(self.save_location)","def delete_relatives(self):\n category_ratings = list(self.category_ratings.all())\n self.category_ratings.clear()\n for category_rating in category_ratings:\n if category_rating.isOrphaned():\n category_rating.delete()\n\n word_counts = list(self.word_counts.all())\n self.word_counts.clear()\n for word_count in word_counts:\n if word_count.isOrphaned():\n word_count.delete()","def delete(self):\n self._instance.delete()\n self._instance = None\n self._data_defs = []","def erase_db(file):\n open(file, 'w').close()","def delete( self ):\n if os.path.exists(self.filename):\n os.remove(self.filename)","def delete(self, session):\n # ForeignKey constrains CASCADE on delete\n session.delete(self)\n session.commit()\n # Clean up any orphan CatalogStars\n session.query(CatalogStar)\\\n .filter(CatalogStar.catalog_id.is_(None))\\\n .delete(synchronize_session=False)\n session.commit()\n # Clean up any orphan Observations\n session.query(Observation)\\\n .filter(Observation.catalog_star_id.is_(None))\\\n .delete(synchronize_session=False)\n session.commit()","def delete_all(self):\n models.CourseLearningOutcome.objects.all().delete()\n #models.CoreLearningOutcome.objects.all().delete()\n #models.CreditType.objects.all().delete()\n models.Course.objects.all().delete()\n models.DegreeProgram.objects.all().delete()\n models.DPCourseSpecific.objects.all().delete()\n models.DPCourseGeneric.objects.all().delete()\n models.DPCourseSubstituteSpecific.objects.all().delete()\n models.DPCourseSubstituteGeneric.objects.all().delete()","def delete(id):\n db = core.connect()\n # FIXME: What happens to orphaned comments? - David 7/6/09\n del db[id]","def delete(self):\n\n lod_history = self.repo._get_lod_history(self.lod)\n assert lod_history.exists()\n lod_history.update(self.repo._youngest, None)\n self._mark_deleted()","def full_reset(self):\n for docid in self.iter_docids():\n self.delete(docid)\n self.client.delete(self.dbprefix + 'schema')\n self.client.delete(self.dbprefix + 'docs')\n self.client.delete(self.dbprefix + 'nextid')","def close(self):\n self.db.remove()\n self.engine.dispose()","def Delete(self):\n\n self.db.ExecuteSql('delete from tracks where id=%d;'\n % self.persistant['id'])\n self.db.ExecuteSql('commit;')","def delete(self):\n try:\n from_table = self.get_from_table(self.content_type.name)\n\n if from_table is not None:\n combined_obj = CombinedTeledata.objects.get(id=self.object_id, from_table=from_table)\n combined_obj.keywords_combined.remove(self)\n except:\n logger.warn('Cannot remove keywords_combined record for {0} - {1}. Record may not exist.'.format(self.phrase, self.content_object.name))\n combined_obj = None\n\n super(Keyword, self).delete()","def processDeleteCommand(self, objId):\n editor = self._parent\n obj = editor.findWithUUID(objId)\n if obj:\n print(\"DELETE FOR\",objId)\n # delete from object cache\n if objId in editor._total['objects']:\n del editor._total['objects'][objId]\n # clear uuid\n obj.opensim.uuid = \"\"\n scene = editor.get_current_scene()\n # unlink\n scene.objects.unlink(obj)\n editor.queueRedraw()","def delete_all(self):\n query = \"\"\"MATCH(n) DETACH DELETE n\"\"\"\n return self.create_tx(query)","def delete(self):\n os.system(\"rm \"+self._name)","def __del__(self):\n if self.__cur:\n self.__cur.close()\n if self.__db:\n self.save()\n self.__db.close()","def rm(self, paths):\n \n self.db_connect()\n\n # Expand and get the absolute paths\n expanded_paths = self.expand_paths(paths)\n \n query = \"DELETE FROM %s WHERE path=? AND doi IS NULL\" % PUBLICATIONS_TABLE\n with self.connection:\n c = self.connection.cursor()\n for f in expanded_paths:\n c.execute(query, [f])\n\n self.db_disconnect()\n \n return","def delete(self):\n if not self.isNew:\n #We do not check the hasData property, so we can use this function to delete records\n #without reading them first.\n #TODO: this is stupid and unclean, change it\n try:\n CFG.CX.delete ( CFG.DB.SCHEMA + \".object\", { 'objectid' : self._objectid } )\n self.clearRecord()\n self.raiseEvent ( \"record_deleted\", self )\n except pg.DatabaseError, e:\n raise Record.DataManipulationError ( \"Deleting record {1} of '{0}'\".format(self._table.name, self._objectid),\n \"\",\n e)","def _delete_tcs(self, testcases):\n\n delete_q = []\n\n # Find all the metadata files associated with all the testcases\n for testcase in testcases:\n metadata_files = nh.get_metadata_files(testcase)\n delete_q += metadata_files.values()\n\n # Write the placeholder file to indicate that this file is deleted\n placeholder_f \\\n = nh.get_metadata_files(testcase, deleted=True)['deleted']\n with open(placeholder_f, 'w') as obj:\n obj.write('Deleted at epoch=%d' % int(time.time()))\n\n remove_files(delete_q, self.verbose, warn=True, force=True)","def _delete_cuds_triples(self, cuds_object):\n del self._registry[cuds_object.uid]\n t = self.graph.value(cuds_object.iri, rdflib.RDF.type)\n self.graph.remove((cuds_object.iri, None, None))\n cuds_object._graph = rdflib.Graph()\n cuds_object._graph.set((cuds_object.iri, rdflib.RDF.type, t))\n self._notify_delete(cuds_object)","def empty_db(self):\n try:\n self.cur.execute(\"DELETE FROM Crashes;\")\n self.con.commit()\n print 'Deleted all records'\n\n except sqlite.Error, e:\n print 'Unable to delete all records.'\n print 'Exception follows:'\n print e","def delete(self):\n for i in set(self.instances.values()):\n i.delete()\n shutil.rmtree(self.dirpath, True)","def delFiles(self):\r\n \r\n logStr = \"{0:s}.{1:s}: \".format(self.__class__.__name__, sys._getframe().f_code.co_name)\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'Start.')) \r\n \r\n try: \r\n if os.path.exists(self.h5File): \r\n os.remove(self.h5File) \r\n logger.debug(\"{0:s} File {1:s} deleted.\".format(logStr,self.h5File)) \r\n except XmError:\r\n raise \r\n except Exception as e:\r\n logStrFinal=\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\r\n logger.error(logStrFinal) \r\n raise XmError(logStrFinal) \r\n finally:\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'_Done.'))","def cleanup(self):\n self.all_wav_to_mp3()\n self.past_songs_db.close()\n self.move_tracks_to_music_folder( )\n self.delete_leftovers()\n print \"Cleanup finished\""],"string":"[\n \"def delete():\",\n \"def clear_db():\\n humans = Human4j.nodes.all()\\n for h in humans:\\n h.delete()\\n binomes = Binome4j.nodes.all()\\n for b in binomes:\\n b.delete()\\n projects = Project4j.nodes.all()\\n for p in projects:\\n p.delete()\\n sherpas = Sherpa4j.nodes.all()\\n for sh in sherpas:\\n sh.delete()\\n students = Pioupiou4j.nodes.all()\\n for piou in students:\\n piou.delete()\\n partenaires = Partenaire4j.nodes.all()\\n for part in partenaires:\\n part.delete()\\n ps = Planete_Solidaire.nodes.all()\\n for misc in ps:\\n misc.delete()\",\n \"def delete_db(self):\\n import os.path\\n os.remove(self.filepath)\",\n \"def delete(self):\\n self.graph._del(handle=self.handle)\",\n \"def delete_model(self):\\n os.remove(self.filepath)\\n self.cmodel = None\",\n \"def _delete_all(self):\\n logging.info(\\\"Remove all nodes and relations from database.\\\")\\n self.graph.delete_all()\\n return\",\n \"def clear_data_base():\\n\\n\\tcommand = 'rm object_models/*.json'\\n\\tos.system(command)\\n\\tprint(\\\"data base cleared\\\")\",\n \"def deleteAll(self):\\n self.db.execute(\\\"DELETE FROM MATCH;\\\", ())\",\n \"def delete(self):\\n if not pdbox._args.get(\\\"dryrun\\\"):\\n result = execute(pdbox.dbx.files_delete_v2, self.path)\\n pdbox.debug(\\\"Metadata response: %s\\\" % result.metadata)\\n pdbox.info(\\\"Deleted %s\\\" % self.uri)\",\n \"def delete_table_data():\\n try:\\n print 'delete existing data'\\n sql = 'delete from document'\\n sql1 = 'delete from clean_keywords'\\n sql2 = 'delete from keywords'\\n util.executeSQL(conn, sql) # delete the existing data.\\n util.executeSQL(conn, sql1)\\n util.executeSQL(conn, sql2)\\n except Exception as e:\\n print e\",\n \"def clear_data():\\n logger.info(\\\"Delete Structure instances\\\")\\n Structure.objects.all().delete()\\n logger.info(\\\"Delete StructureType instances\\\")\\n StructureType.objects.all().delete()\\n logger.info(\\\"Delete Industry instances\\\")\\n Industry.objects.all().delete()\\n logger.info(\\\"Delete Price instances\\\")\\n PriceList.objects.all().delete()\\n logger.info(\\\"Delete Stock instances\\\")\\n Stock.objects.all().delete()\\n logger.info(\\\"Delete News instances\\\")\\n News.objects.all().delete()\\n logger.info(\\\"Delete NewsImages instances\\\")\\n NewsImage.objects.all().delete()\\n logger.info(\\\"Delete News Sections instances\\\")\\n NewsCategorySection.objects.all().delete()\\n logger.info(\\\"Delete Analysis instances\\\")\\n AnalysisOpinion.objects.all().delete()\\n logger.info(\\\"Delete Analysis Images instances\\\")\\n AnalysisImage.objects.all().delete()\\n logger.info(\\\"Delete Analysis Sections instances\\\")\\n AnalysisCategorySection.objects.all().delete()\",\n \"def _delete_datafile(sender, instance, **kwargs):\\n instance.delete_datafile(save_instance=False)\",\n \"def remove(self):\\n for ref_node in self.node.find_references():\\n ref_node.destroy()\\n File.remove(self)\",\n \"def predio_delete(sender, instance, **kwargs):\\n instance.dataFile.delete(False)\",\n \"def delete(self):\\n\\n del self.parent_mirror_dir[self.cvs_path]\",\n \"def db_remove():\\n\\n db.session.close()\\n db.drop_all()\\n\\n path = current_app.config['SNER_VAR']\\n for file_object in os.listdir(path):\\n file_object_path = os.path.join(path, file_object)\\n if os.path.isdir(file_object_path):\\n shutil.rmtree(file_object_path)\\n else:\\n os.unlink(file_object_path)\",\n \"def remove(self):\\n \\n dbpath, config = self._start() \\n desc_file = check_file(config.model_descriptions, dbpath,\\n \\\"model_descriptions\\\", allow_none=False) \\n self.logger.msg1(\\\"Reading model ids\\\")\\n ids = values_in_column(desc_file, \\\"id\\\")\\n self.logger.msg1(\\\"Deleting models: \\\"+str(len(ids)))\\n delete_models(dbpath, ids)\\n self._end()\",\n \"def __del__(self):\\r\\n self.save()\\r\\n self.close()\",\n \"def clear_db():\\n from example_data import ExampleDataLoader\\n ExampleDataLoader.clean_db()\",\n \"def delete_path():\\n #TODO delete path from database\\n pass\",\n \"def delete(self):\\n ...\",\n \"def deleteDB():\\n db = sqlite.connect(db_path)\\n db.row_factory = sqlite.Row\\n cursor = db.cursor()\\n cursor.execute(\\\"DELETE from rooms\\\")\\n\\n cursor.execute(\\\"DELETE from users\\\")\\n\\n cursor.execute(\\\"DELETE from urls\\\")\\n\\n cursor.fetchall()\\n db.commit()\\n cursor.close()\\n db.close()\",\n \"def delete(self):\\n\\n\\n try:\\n db = getDatabase()\\n connection = db.connect()\\n\\n connection.delete(self)\\n except Exception as e:\\n raise e\\n finally:\\n db.dispose()\",\n \"def delete(self):\\n self._vertex_list.delete()\\n self._vertex_list = None\",\n \"def do_destroy(self, arg):\\n args = shlex.split(arg)\\n stored_objects = models.storage.all()\\n\\n if self.basic_errs(args):\\n '''check if instance exists'''\\n instance = self.check_instance(args[0], args[1], stored_objects)\\n if instance:\\n \\\"\\\"\\\"delete from FileStorage.__objects\\\"\\\"\\\"\\n del stored_objects[instance]\\n \\\"\\\"\\\"overwrite the new data to file.json\\\"\\\"\\\"\\n models.storage.save()\",\n \"def tearDown(self):\\n self.db.close()\\n self.dbfile.close()\\n os.unlink(self.path)\",\n \"def clean(obj):\\n clean_up_generated_files(obj)\",\n \"def delete(self):\\n if not hasattr(self, 'id'):\\n raise BadReference('No matching issue on disk')\\n shutil.rmtree(self.paths['root'])\",\n \"def cleanup(self):\\r\\n for f in [i for d in self.data.values() for i in d[\\\"filenames\\\"]]:\\r\\n try:\\r\\n os.unlink(f)\\r\\n except Exception: pass\\r\\n self.Destroy()\",\n \"def remove_all():\\n storage = FileStorage()\\n objects = storage.all()\\n objects = list(objects.values())\\n\\n for element in objects:\\n storage.delete(element)\\n objects = storage.all()\",\n \"def delete(self):\\n pdbox._args.get(\\\"dryrun\\\") or os.remove(self.path)\\n pdbox.info(\\\"Deleted %s\\\" % self.path)\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def main(self):\\n self.delete_details()\\n self.delete_cleaned()\\n self.vacuum()\",\n \"def clean(params):\\n if tf.gfile.IsDirectory(params.ckpt_path):\\n tf.gfile.DeleteRecursively(params.ckpt_path)\\n\\n if tf.gfile.IsDirectory(params.summary_path):\\n tf.gfile.DeleteRecursively(params.summary_path)\\n\\n if tf.gfile.IsDirectory(params.result_path):\\n tf.gfile.DeleteRecursively(params.result_path)\\n\\n if tf.gfile.IsDirectory(params.log_path):\\n tf.gfile.DeleteRecursively(params.log_path)\\n\\n if tf.gfile.IsDirectory(\\\"__pycache__\\\"):\\n tf.gfile.DeleteRecursively(\\\"__pycache__\\\")\\n\\n if tf.gfile.IsDirectory(params.config_path):\\n tf.gfile.DeleteRecursively(params.config_path)\",\n \"def __del__(self):\\n self.evaler.db.flush()\",\n \"def delete(self):\\n self.dbm().model_delete(self)\",\n \"def delete_objects(data,\\n path = None,\\n submode_adjustor = None):\\n if debug.description(): # description debugging\\n print 'delete_objects', data, path\\n\\n if not path:\\n raise error.CommandDescriptionError(\\\"Need path to delete an object\\\")\\n\\n data = dict(data)\\n bigdb = bigsh.bigdb\\n bigdb.canonicalize_values_of_path(path, data)\\n\\n # if the node type under configuration is a LIST\\n # (or LEAF_LIST), this likely wants to add a new\\n # item to the list.\\n (schema, items_matched) = bigdb.schema_of_path(path, {} )\\n if schema == None:\\n print 'Missing Schema for', path\\n return\\n node_type = schema['nodeType']\\n if debug.description(): # description debugging\\n print 'delete_objects:', path, node_type\\n\\n if node_type == 'LIST':\\n list_nodes = schema['listElementSchemaNode']\\n selection = {}\\n for key in list_nodes.get('keyNodeNames', []):\\n if key in data:\\n full_path = '%s/%s' % (path, key)\\n selection[full_path] = data[key]\\n del data[key]\\n # populate for fields which are key's\\n for key in list_nodes.get('keyNodeNames', []):\\n if not key in selection:\\n for row in command.bigsh.mode_stack:\\n if 'name' in row and row['name'] == key:\\n if 'obj' in row:\\n selection[key] = row['obj']\\n bigdb.add_mode_stack_paths(selection)\\n if submode_adjustor:\\n command.submode_adjustor_invoke(submode_adjustor,\\n path,\\n selection,\\n data,\\n 'delete')\\n\\n oper = bigdb.canonicalize_values_for_delete(path,\\n data,\\n selection,\\n list_nodes['childNodes'])\\n if oper == 'POST':\\n bigdb.post(path, data, selection)\\n else:\\n # bigdb.delete(path, data, selection) perhaps date <- {}\\n bigdb.delete(path, data, selection)\\n return\\n if node_type == 'LEAF_LIST':\\n if debug.description(): # description debugging\\n print 'delete_object: leaf-list needs implementation:LEAF_LISTN'\\n selection = {}\\n bigdb.add_mode_stack_paths(selection)\\n leaf_node = schema['leafSchemaNode']\\n type_node = leaf_node['typeSchemaNode']\\n split_path = path.split('/')\\n item_name = split_path[-1]\\n item = None\\n if item_name in data:\\n item = data[item_name]\\n elif type_node['name'] in data:\\n item = data[type_node['name']]\\n del data[type_node['name']]\\n if debug.description(): # description debugging\\n print 'DATUM', data, 'SELECTUM', selection, 'ITEM', item\\n # Currently, 'add/delete' for specific elements isn't\\n # directly support in the BigDB REST API's. \\n split_path = path.split('/')\\n base_path = '/'.join(split_path[:-1])\\n (schema, result) = bigdb.schema_and_result(base_path, selection)\\n collection = result.expect_single_result(failed_result = [])\\n item_name = split_path[-1]\\n if item_name in collection:\\n collection = collection[item_name]\\n if debug.description(): # description debugging\\n print 'COLLECTION', collection, ' REMOVE ', item\\n if item in collection:\\n collection = [x for x in collection if x != item]\\n bigdb.put(path, collection, selection, 'query')\\n return\\n raise error.CommandSemanticError('%s \\\"%s\\\" '\\n 'not currently configured' %\\n (item_name, item))\\n return\\n if node_type == 'CONTAINER':\\n container_nodes = schema.get('childNodes')\\n\\n selection = {}\\n bigdb.add_mode_stack_paths(selection)\\n\\n for (n,v) in data.items():\\n oper = bigdb.canonicalize_values_for_delete(path,\\n data,\\n selection,\\n container_nodes)\\n if oper == 'PATCH':\\n bigdb.patch(path, data, selection)\\n else:\\n item_path = '%s/%s' % (path, n)\\n bigdb.delete(item_path, {}, selection)\\n return\\n\\n bigsh.bigdb.add_mode_stack_paths(data)\\n bigsh.bigdb.delete(path, data)\",\n \"def deleteAllModelsFromScene(self):\\r\\n # research\\r\\n self.deleteNeedleDetectionModelsFromScene()\\r\\n self.deleteNeedleValidationModelsFromScene()\",\n \"def delete(self):\\n pdbox._args.get(\\\"dryrun\\\") or shutil.rmtree(self.path)\\n pdbox.info(\\\"Deleted %s/\\\" % self.path)\",\n \"def clear_db(self):\\n self.cursor.execute(\\\"DELETE FROM TrackPoint\\\")\\n self.cursor.execute(\\\"DELETE FROM Activity\\\")\\n self.cursor.execute(\\\"DELETE FROM User\\\")\\n self.db_connection.commit()\",\n \"def delete(self):\\n\\t\\tif self.hasUdim:\\n\\t\\t\\tfor a in self.udimPaths:\\n\\t\\t\\t\\ta.delete()\\n\\t\\telse:\\n\\t\\t\\tsuper( textureFile, self ).delete()\",\n \"def delete(self, filename):\\n pass\",\n \"def tearDown(self):\\n self.comment.post.delete()\\n self.user.delete()\\n\\n print('Deleting comment...')\\n self.comment.delete()\\n print('Deleted comment.')\\n print('Deleting test_file...')\\n if os.path.exists('test_file.txt'):\\n os.remove('test_file.txt')\\n print('Deleted file')\\n print()\\n print()\",\n \"def delete_document(self):\\n pass\",\n \"def delete(self):\\n\\t\\t#self.log.info(\\\"Deleting file {}\\\".format(self._filepath))\\n\\t\\tos.remove(self._filepath)\",\n \"def delete_dataset(dataset_path):\\n force_rmtree(dataset_path)\",\n \"def tearDown(self):\\n os.remove(self._dbfile)\",\n \"def delete_data(self):\\n conn = self._connect_DB()\\n cur = conn.cursor()\\n cur.execute(\\\"DELETE FROM movie_table;\\\")\\n self._close_connection(conn)\",\n \"def cleanup():\\n cat = CSVCatalog.CSVCatalog()\\n cat.drop_table(\\\"people\\\", force_drop=True)\\n cat.drop_table(\\\"batting\\\", force_drop=True)\\n cat.drop_table(\\\"teams\\\", force_drop=True)\",\n \"def delete():\\n\\n # Check the pipe setup.\\n check_pipe_setup(sequence=True, j=True)\\n\\n # The interatomic data.\\n for interatom in interatomic_loop():\\n # The data.\\n if hasattr(interatom, 'j_coupling'):\\n del interatom.j_coupling\\n\\n # The error.\\n if hasattr(interatom, 'j_coupling_err'):\\n del interatom.j_coupling_err\",\n \"def clean(self):\\n # Delete vertices / faces / colors / normals :\\n self._vert_buffer.delete()\\n self._index_buffer.delete()\\n self._normals_buffer.delete()\\n self._xrange_buffer.delete()\\n self._math_buffer.delete()\",\n \"def tearDown(self):\\n # Empty objects in engine\\n FileStorage._FileStorage__objects = {}\\n # Remove file.json if exists\\n if os.path.exists(\\\"file.json\\\"):\\n os.remove(\\\"file.json\\\")\",\n \"def clearmodels(self):\\n \\n dbpath, config = self._start() \\n ModelDescriptionTable(dbpath).empty()\\n ModelPhenotypeTable(dbpath).empty()\\n ModelScoreTable(dbpath).empty() \\n self._end()\",\n \"def deleteHistory(self):\\n\\t\\tmc.delete( self.objects, ch = True )\",\n \"def destroy(self):\\n self.db = None\\n self.gen_cursor = None\\n self.map = None\\n self.fmap = None\\n self.smap = None\\n FlatBaseModel.destroy(self)\",\n \"def destroy(self):\\n for node in self.find_references():\\n node.destroy()\\n self._bld.RemoveObject(self.get_sobj())\",\n \"def destroy_datastore(paths):\\r\\n for path in paths.values():\\r\\n if not path:\\r\\n continue\\r\\n try:\\r\\n if os.path.isdir(path):\\r\\n shutil.rmtree(path)\\r\\n else:\\r\\n os.remove(path)\\r\\n except OSError, error:\\r\\n if error.errno != 2:\\r\\n logging.error(\\\"Failed to clear datastore: %s\\\" % error)\",\n \"def clear_doc():\\n for obj in DOC.Objects:\\n DOC.removeObject(obj.Name)\",\n \"def delete(self):\\n\\n try:\\n remove(self.file)\\n except OSError:\\n pass\",\n \"def delete_object(self, object):\\n object.delete()\",\n \"def delete(self):\\n\\n cursor = self._conn.cursor()\\n cursor.execute(\\\"DELETE FROM saves\\\")\\n self._conn.commit()\",\n \"def delete():\\n\\n from slicr.extensions import db\\n\\n click.echo('deleting database...')\\n\\n db.drop_all()\",\n \"def delete(self): # DirObj.delete\\n self.deleted=True\\n for name, d in self.subdirs.iteritems():\\n d.delete()\\n for name, f in self.files.iteritems():\\n f.delete()\",\n \"def cleanUp(self):\\r\\n remove_files(self._db_files_to_remove, error_on_missing=False)\",\n \"def cleanup(self):\\n if os.path.exists(f\\\"{self.save_path}{self.name}\\\"):\\n shutil.rmtree(f\\\"{self.save_path}{self.name}\\\")\",\n \"def delEvery():\\n delMain()\\n delFile()\\n delPuls()\\n delSat()\\n delFreq()\\n delTemp()\\n delGly()\\n delDlr()\\n label['text'] = \\\"All json files have been deleted !\\\"\",\n \"def close(self):\\n\\n self._lod_histories = None\\n self._node_db.close()\\n self._node_db = None\",\n \"def cleanup(self):\\n if os.path.exists(self._db):\\n os.remove(self._db)\",\n \"def cleanup():\\n cat = CSVCatalog.CSVCatalog()\\n cat.drop_table(\\\"people\\\")\\n cat.drop_table(\\\"batting\\\")\\n cat.drop_table(\\\"teams\\\")\",\n \"def flush(self):\\n cursor = self.db.cursor()\\n cursor.execute(\\\"DELETE FROM triples\\\")\\n self.db.commit()\",\n \"def clean(cls, pdb_object):\\n if not cls.computed(pdb_object):\\n return\\n for successor in cls.successors:\\n successor.clean(pdb_object)\\n pdb_object.uncomplete(cls.name)\\n for file in cls.files(pdb_object):\\n file.delete()\",\n \"def clean_database(databasePathname):\\n print '# loading database ' + databasePathname\\n try:\\n db = gdbm.open(databasePathname, 'w')\\n except:\\n print \\\"# \\\" + databasePathname + \\\" could not be loaded\\\"\\n sys.exit(-1)\\n\\n # even though gdbm supports memory efficient iteration over\\n # all keys, I want to order my traversal across similar\\n # paths to leverage caching of directory files:\\n allKeys=db.keys()\\n print '# finished loaded keys from ' + databasePathname\\n allKeys.sort()\\n print '# finished sorting keys from ' + databasePathname\\n print '# deleting dead nodes'\\n count=0\\n for currKey in allKeys:\\n try:\\n os.stat(currKey)\\n sys.stdout.write('.')\\n except OSError:\\n del db[currKey]\\n sys.stdout.write('*')\\n count=count+1\\n sys.stdout.flush()\\n print \\\"\\\\n# reorganizing \\\" + databasePathname\\n db.reorganize()\\n db.sync()\\n db.close()\\n print '# done cleaning ' + databasePathname + ', removed ' + str(count) + ' dead nodes!'\",\n \"def __deleteSave(self) -> None:\\n os.remove(self.save_location)\",\n \"def delete_relatives(self):\\n category_ratings = list(self.category_ratings.all())\\n self.category_ratings.clear()\\n for category_rating in category_ratings:\\n if category_rating.isOrphaned():\\n category_rating.delete()\\n\\n word_counts = list(self.word_counts.all())\\n self.word_counts.clear()\\n for word_count in word_counts:\\n if word_count.isOrphaned():\\n word_count.delete()\",\n \"def delete(self):\\n self._instance.delete()\\n self._instance = None\\n self._data_defs = []\",\n \"def erase_db(file):\\n open(file, 'w').close()\",\n \"def delete( self ):\\n if os.path.exists(self.filename):\\n os.remove(self.filename)\",\n \"def delete(self, session):\\n # ForeignKey constrains CASCADE on delete\\n session.delete(self)\\n session.commit()\\n # Clean up any orphan CatalogStars\\n session.query(CatalogStar)\\\\\\n .filter(CatalogStar.catalog_id.is_(None))\\\\\\n .delete(synchronize_session=False)\\n session.commit()\\n # Clean up any orphan Observations\\n session.query(Observation)\\\\\\n .filter(Observation.catalog_star_id.is_(None))\\\\\\n .delete(synchronize_session=False)\\n session.commit()\",\n \"def delete_all(self):\\n models.CourseLearningOutcome.objects.all().delete()\\n #models.CoreLearningOutcome.objects.all().delete()\\n #models.CreditType.objects.all().delete()\\n models.Course.objects.all().delete()\\n models.DegreeProgram.objects.all().delete()\\n models.DPCourseSpecific.objects.all().delete()\\n models.DPCourseGeneric.objects.all().delete()\\n models.DPCourseSubstituteSpecific.objects.all().delete()\\n models.DPCourseSubstituteGeneric.objects.all().delete()\",\n \"def delete(id):\\n db = core.connect()\\n # FIXME: What happens to orphaned comments? - David 7/6/09\\n del db[id]\",\n \"def delete(self):\\n\\n lod_history = self.repo._get_lod_history(self.lod)\\n assert lod_history.exists()\\n lod_history.update(self.repo._youngest, None)\\n self._mark_deleted()\",\n \"def full_reset(self):\\n for docid in self.iter_docids():\\n self.delete(docid)\\n self.client.delete(self.dbprefix + 'schema')\\n self.client.delete(self.dbprefix + 'docs')\\n self.client.delete(self.dbprefix + 'nextid')\",\n \"def close(self):\\n self.db.remove()\\n self.engine.dispose()\",\n \"def Delete(self):\\n\\n self.db.ExecuteSql('delete from tracks where id=%d;'\\n % self.persistant['id'])\\n self.db.ExecuteSql('commit;')\",\n \"def delete(self):\\n try:\\n from_table = self.get_from_table(self.content_type.name)\\n\\n if from_table is not None:\\n combined_obj = CombinedTeledata.objects.get(id=self.object_id, from_table=from_table)\\n combined_obj.keywords_combined.remove(self)\\n except:\\n logger.warn('Cannot remove keywords_combined record for {0} - {1}. Record may not exist.'.format(self.phrase, self.content_object.name))\\n combined_obj = None\\n\\n super(Keyword, self).delete()\",\n \"def processDeleteCommand(self, objId):\\n editor = self._parent\\n obj = editor.findWithUUID(objId)\\n if obj:\\n print(\\\"DELETE FOR\\\",objId)\\n # delete from object cache\\n if objId in editor._total['objects']:\\n del editor._total['objects'][objId]\\n # clear uuid\\n obj.opensim.uuid = \\\"\\\"\\n scene = editor.get_current_scene()\\n # unlink\\n scene.objects.unlink(obj)\\n editor.queueRedraw()\",\n \"def delete_all(self):\\n query = \\\"\\\"\\\"MATCH(n) DETACH DELETE n\\\"\\\"\\\"\\n return self.create_tx(query)\",\n \"def delete(self):\\n os.system(\\\"rm \\\"+self._name)\",\n \"def __del__(self):\\n if self.__cur:\\n self.__cur.close()\\n if self.__db:\\n self.save()\\n self.__db.close()\",\n \"def rm(self, paths):\\n \\n self.db_connect()\\n\\n # Expand and get the absolute paths\\n expanded_paths = self.expand_paths(paths)\\n \\n query = \\\"DELETE FROM %s WHERE path=? AND doi IS NULL\\\" % PUBLICATIONS_TABLE\\n with self.connection:\\n c = self.connection.cursor()\\n for f in expanded_paths:\\n c.execute(query, [f])\\n\\n self.db_disconnect()\\n \\n return\",\n \"def delete(self):\\n if not self.isNew:\\n #We do not check the hasData property, so we can use this function to delete records\\n #without reading them first.\\n #TODO: this is stupid and unclean, change it\\n try:\\n CFG.CX.delete ( CFG.DB.SCHEMA + \\\".object\\\", { 'objectid' : self._objectid } )\\n self.clearRecord()\\n self.raiseEvent ( \\\"record_deleted\\\", self )\\n except pg.DatabaseError, e:\\n raise Record.DataManipulationError ( \\\"Deleting record {1} of '{0}'\\\".format(self._table.name, self._objectid),\\n \\\"\\\",\\n e)\",\n \"def _delete_tcs(self, testcases):\\n\\n delete_q = []\\n\\n # Find all the metadata files associated with all the testcases\\n for testcase in testcases:\\n metadata_files = nh.get_metadata_files(testcase)\\n delete_q += metadata_files.values()\\n\\n # Write the placeholder file to indicate that this file is deleted\\n placeholder_f \\\\\\n = nh.get_metadata_files(testcase, deleted=True)['deleted']\\n with open(placeholder_f, 'w') as obj:\\n obj.write('Deleted at epoch=%d' % int(time.time()))\\n\\n remove_files(delete_q, self.verbose, warn=True, force=True)\",\n \"def _delete_cuds_triples(self, cuds_object):\\n del self._registry[cuds_object.uid]\\n t = self.graph.value(cuds_object.iri, rdflib.RDF.type)\\n self.graph.remove((cuds_object.iri, None, None))\\n cuds_object._graph = rdflib.Graph()\\n cuds_object._graph.set((cuds_object.iri, rdflib.RDF.type, t))\\n self._notify_delete(cuds_object)\",\n \"def empty_db(self):\\n try:\\n self.cur.execute(\\\"DELETE FROM Crashes;\\\")\\n self.con.commit()\\n print 'Deleted all records'\\n\\n except sqlite.Error, e:\\n print 'Unable to delete all records.'\\n print 'Exception follows:'\\n print e\",\n \"def delete(self):\\n for i in set(self.instances.values()):\\n i.delete()\\n shutil.rmtree(self.dirpath, True)\",\n \"def delFiles(self):\\r\\n \\r\\n logStr = \\\"{0:s}.{1:s}: \\\".format(self.__class__.__name__, sys._getframe().f_code.co_name)\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'Start.')) \\r\\n \\r\\n try: \\r\\n if os.path.exists(self.h5File): \\r\\n os.remove(self.h5File) \\r\\n logger.debug(\\\"{0:s} File {1:s} deleted.\\\".format(logStr,self.h5File)) \\r\\n except XmError:\\r\\n raise \\r\\n except Exception as e:\\r\\n logStrFinal=\\\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\\\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\\r\\n logger.error(logStrFinal) \\r\\n raise XmError(logStrFinal) \\r\\n finally:\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'_Done.'))\",\n \"def cleanup(self):\\n self.all_wav_to_mp3()\\n self.past_songs_db.close()\\n self.move_tracks_to_music_folder( )\\n self.delete_leftovers()\\n print \\\"Cleanup finished\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66543853","0.6603808","0.6559491","0.6447322","0.64100724","0.6389136","0.6299942","0.62388057","0.6218455","0.6199544","0.6175071","0.61286473","0.6114","0.6112866","0.6111774","0.6104314","0.60767096","0.6068975","0.60340655","0.6027067","0.60106134","0.6002575","0.6001822","0.59970397","0.59881383","0.59856457","0.59848326","0.5979064","0.5973471","0.59634006","0.59604424","0.5957104","0.5957104","0.5957104","0.5957104","0.594797","0.5942451","0.59414065","0.5934029","0.59320015","0.59166986","0.591544","0.591246","0.5906655","0.5890437","0.5886504","0.5883673","0.58804864","0.5877985","0.5877661","0.58706343","0.58680606","0.5862849","0.5855409","0.58543473","0.58537227","0.585247","0.5851741","0.58515376","0.58502054","0.584669","0.58418876","0.5823825","0.5823474","0.5821546","0.5821264","0.5816029","0.5815843","0.5812826","0.57972896","0.5797165","0.57916623","0.5788154","0.578001","0.5776494","0.5768246","0.57640153","0.57578665","0.5754604","0.57512903","0.575044","0.5742469","0.57346296","0.57327485","0.57298887","0.57277477","0.57226884","0.572102","0.5717107","0.5712467","0.5709718","0.5705691","0.57039326","0.57038414","0.5701749","0.57002383","0.5699717","0.569845","0.56968737","0.5689596"],"string":"[\n \"0.66543853\",\n \"0.6603808\",\n \"0.6559491\",\n \"0.6447322\",\n \"0.64100724\",\n \"0.6389136\",\n \"0.6299942\",\n \"0.62388057\",\n \"0.6218455\",\n \"0.6199544\",\n \"0.6175071\",\n \"0.61286473\",\n \"0.6114\",\n \"0.6112866\",\n \"0.6111774\",\n \"0.6104314\",\n \"0.60767096\",\n \"0.6068975\",\n \"0.60340655\",\n \"0.6027067\",\n \"0.60106134\",\n \"0.6002575\",\n \"0.6001822\",\n \"0.59970397\",\n \"0.59881383\",\n \"0.59856457\",\n \"0.59848326\",\n \"0.5979064\",\n \"0.5973471\",\n \"0.59634006\",\n \"0.59604424\",\n \"0.5957104\",\n \"0.5957104\",\n \"0.5957104\",\n \"0.5957104\",\n \"0.594797\",\n \"0.5942451\",\n \"0.59414065\",\n \"0.5934029\",\n \"0.59320015\",\n \"0.59166986\",\n \"0.591544\",\n \"0.591246\",\n \"0.5906655\",\n \"0.5890437\",\n \"0.5886504\",\n \"0.5883673\",\n \"0.58804864\",\n \"0.5877985\",\n \"0.5877661\",\n \"0.58706343\",\n \"0.58680606\",\n \"0.5862849\",\n \"0.5855409\",\n \"0.58543473\",\n \"0.58537227\",\n \"0.585247\",\n \"0.5851741\",\n \"0.58515376\",\n \"0.58502054\",\n \"0.584669\",\n \"0.58418876\",\n \"0.5823825\",\n \"0.5823474\",\n \"0.5821546\",\n \"0.5821264\",\n \"0.5816029\",\n \"0.5815843\",\n \"0.5812826\",\n \"0.57972896\",\n \"0.5797165\",\n \"0.57916623\",\n \"0.5788154\",\n \"0.578001\",\n \"0.5776494\",\n \"0.5768246\",\n \"0.57640153\",\n \"0.57578665\",\n \"0.5754604\",\n \"0.57512903\",\n \"0.575044\",\n \"0.5742469\",\n \"0.57346296\",\n \"0.57327485\",\n \"0.57298887\",\n \"0.57277477\",\n \"0.57226884\",\n \"0.572102\",\n \"0.5717107\",\n \"0.5712467\",\n \"0.5709718\",\n \"0.5705691\",\n \"0.57039326\",\n \"0.57038414\",\n \"0.5701749\",\n \"0.57002383\",\n \"0.5699717\",\n \"0.569845\",\n \"0.56968737\",\n \"0.5689596\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78041196"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":22197,"cells":{"query":{"kind":"string","value":"Formats the texts recived from a database search to the format used to display them in the users profile page."},"document":{"kind":"string","value":"def formatTexts(owned, shared):\n owned_texts = []\n shared_texts = []\n # Catches error if there is no score from the databse search\n try:\n for text in range(len(owned)):\n owned_texts.append(\n {'title': owned[text][0], 'body': owned[text][1], 'score': owned[text][2]})\n for text in range(len(shared)):\n shared_texts.append(\n {'title': shared[text][0], 'body': shared[text][1], 'score': shared[text][2]})\n except:\n for text in range(len(owned)):\n owned_texts.append(\n {'title': owned[text][0], 'body': owned[text][1]})\n for text in range(len(shared)):\n shared_texts.append(\n {'title': shared[text][0], 'body': shared[text][1]})\n # Adds False if the either of the text arrays are empty\n if len(owned_texts) == 0:\n owned_texts.append(False)\n if len(shared_texts) == 0:\n shared_texts.append(False)\n return owned_texts, shared_texts"},"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_search_content(self):\n words = [\",\".join(self.__get_property_from_all_views(\"resource_id\")),\n \",\".join(self.__get_property_from_all_views(\"text\"))]\n return \"\\n\".join(words)","def get_person_text(self, uid):\n words = \"\"\n\n query = \"\"\"\nSELECT ?overview ?researchO ?label\nWHERE\n{\n <%s> <http://vivoweb.org/ontology/core#overview> ?overview .\n <%s> <http://vivoweb.org/ontology/core#researchOverview> ?researchO .\n <%s> <http://www.w3.org/2000/01/rdf-schema#label> ?label .\n}\n \"\"\" % (uid, uid, uid)\n self.setQuery(query)\n try:\n rval = self.query()\n try:\n g = rval.convert()\n except:\n pass\n words = \"%s %s %s\" % (g['results']['bindings'][0]['overview']['value'], g['results']['bindings'][0]['researchO']['value'], g['results']['bindings'][0]['label']['value'])\n except:\n print \"Select failed: %s\" % query\n\n self.setQuery(\"\"\"\nPREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\nPREFIX vivo: <http://vivoweb.org/ontology/core#>\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\nSELECT ?name\nWHERE\n{\n ?auth vivo:relates <%s> .\n ?auth rdf:type vivo:Authorship .\n ?auth vivo:relates ?art .\n filter (?art!=<%s>) .\n ?art <http://vivoweb.org/ontology/core#dateTimeValue> ?date .\n ?date <http://vivoweb.org/ontology/core#dateTime> ?year .\n filter (?year>\"2009-01-01T00:00:00Z\"^^xsd:dateTime) .\n ?art rdfs:label ?name .\n}\nLIMIT 20\n\"\"\" % (uid, uid))\n try:\n rval = self.query()\n try:\n g = rval.convert()\n except:\n pass\n for t in g['results']['bindings']:\n words = words + \" \" + t['name']['value']\n\n except:\n print \"Select failed\"\n traceback.print_exc(file=sys.stdout)\n\n self.setQuery(\"\"\"\nPREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\nPREFIX vivo: <http://vivoweb.org/ontology/core#>\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\n\nSELECT ?name\nWHERE\n{\n ?grant vivo:relates <%s> .\n ?grant rdf:type vivo:Grant .\n ?grant <http://vivoweb.org/ontology/core#dateTimeInterval> ?date .\n ?date <http://vivoweb.org/ontology/core#end> ?end .\n ?end <http://vivoweb.org/ontology/core#dateTime> ?year .\n filter (?year>\"2009-01-01T00:00:00Z\"^^xsd:dateTime) .\n ?grant rdfs:label ?name .\n}\n\n \"\"\" % (uid))\n try:\n rval = self.query()\n try:\n g = rval.convert()\n except:\n pass\n\n for t in g['results']['bindings']:\n words = words + \" \" + t['name']['value']\n\n except:\n print \"Select failed\"\n traceback.print_exc(file=sys.stdout)\n\n\n\n\n return words","def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()","def get_db_format(text):\n db_text = \"\"\n for t in text.split(\" \"):\n db_text += t.title()\n return db_text","def parsingconvtext(retrievedtext,customtextlist):\r\n if not retrievedtext: #in case empty text \r\n retrievedtext=changenonetostr(retrievedtext)\r\n newtext=BeautifulSoup(retrievedtext).get_text() \r\n #newtext=changenonetostr(retrievedtext)\r\n #newtext=BeautifulSoup(newtext).get_text() \r\n #remove http links\r\n newtext=re.sub(r'http\\S+', '', newtext)\r\n newtext=re.sub(r'\\r\\r\\r\\n', ' ', newtext)\r\n #remove LL specific text\r\n if customtextlist:\r\n for i in customtextlist:\r\n newtext=re.sub(i, '', newtext)\r\n return newtext","def get_user_and_text(db):\n con = lite.connect(db)\n with con:\n cur = con.cursor()\n cur.execute(\"SELECT author, GROUP_CONCAT(text, ' ') FROM Comments GROUP BY author\")\n user_text_list = cur.fetchall() \n return user_text_list","def format_result(result):\n output = ''\n for item in result:\n text = item['text']\n date = item['date']\n status = item['status']\n author = item['author_name']\n line = (\n f'Кейс: {text}\\n'\n f'<code>Дата: {date}</code>\\n'\n f'Статус: <b>{status}</b>\\n'\n f'Автор: {author}\\n'\n '\\n'\n )\n output += line\n return output","def _format_response(self, response):\n texts = []\n for result in response.results: \n texts.append(result.alternatives[0].transcript)\n return texts","def query_texts():\n alloweds = {'author', 'is_prose', 'language', 'title'}\n filters = {}\n for allowed in alloweds:\n grabbed = flask.request.args.get(allowed, None)\n if grabbed:\n filters[allowed] = grabbed\n before_val = flask.request.args.get('before', None)\n after_val = flask.request.args.get('after', None)\n try:\n if before_val is not None:\n before_val = int(before_val)\n if after_val is not None:\n after_val = int(after_val)\n except ValueError:\n return tv5api.errors.error(\n 400,\n message='If used, \"before\" and \"after\" must have integer values.')\n\n if before_val is not None and after_val is not None:\n results = flask.g.db.find(\n tesserae.db.entities.Text.collection,\n year_not=(before_val, after_val),\n **filters)\n elif before_val is not None and after_val is None:\n results = flask.g.db.find(\n tesserae.db.entities.Text.collection,\n # Assuming that lower limit pre-dates all texts in database\n year=(-999999999999, before_val),\n **filters)\n elif not before_val is None and after_val is not None:\n results = flask.g.db.find(\n tesserae.db.entities.Text.collection,\n # Assuming that upper limit post-dates all texts in database\n year=(after_val, 999999999999),\n **filters)\n else:\n results = flask.g.db.find(\n tesserae.db.entities.Text.collection,\n **filters)\n return flask.jsonify(texts=[fix_id(r.json_encode()) for r in results])","def get_text(downgrade_titles=False):","def textdisplay(textTitle, analysis):\n try:\n global current_file\n with Database() as database:\n text_owner = database.getTextOwner(textTitle, session['username'])\n app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER + text_owner\n path = app.config['UPLOAD_FOLDER'] + '/objects/' + textTitle + '.txt'\n with open(path, 'rb') as f:\n current_file = pickle.load(f)\n analysed_texts = current_file.analysed_texts\n text_facts = current_file.stats\n keywords = ''\n for word in text_facts['Key Words']:\n keywords += word[0] + \", \"\n keywords = keywords[:-2]\n return render_template('textdisplay.html',\n title=current_file.title,\n texts=analysed_texts,\n text=analysed_texts[analysis],\n facts=text_facts,\n keywords=keywords,\n owner=text_owner,\n user=session['username'])\n except Exception as e:\n flash(\"Something went wrong, please try again\")\n return redirect(url_for('profile', username=session['username']))","def format_textbooks(self, data):\n textbooks = ', '.join([self.input['textbook%s'%i] for i in range(1,4) if self.input.get('textbook%s'%i)])\n return textbooks","def adjustText(cls, text):\n\t\t\n\t\t\"\"\"Adjust dates so to transform strings such as '21 August' to 'August\n\t\t 21' and have them recognized by the SCNLP tools\"\"\"\n\t\tmonths = (u'January|February|March|April|May|June|July'\n\t\t\t\t\t'August|September|October|November|December')\n\t\tdates = re.compile('(?P<day>\\d{1,2})\\s+(?P<month>%s)(\\s+(?P<year>(\\d{2,4})))?' % months)\n\t\ttext = dates.sub(cls.normalizeDate, text)\n\t\t# Strip any remaining HTML (WikiExtractor is not perfect)\n\t\thtmlTags = re.compile('<[^>]+>')\n\t\t\n\t\ttext = htmlTags.sub(\"\", text)\n\t\t\n\t\treturn text","def display_search_results(results):\n\n new_list = results.split(',')\n\n print('Date : {}'.format(new_list[0]))\n print('Title : {}'.format(new_list[1]))\n print('Time Spent : {}'.format(new_list[2]))\n print('Notes : {}'.format(new_list[3]))\n clear()","def search_titles(username):\n try:\n with Database() as database:\n user = database.checkForUser(username)\n if user == session['username']:\n if session['username'] == username:\n session['id'] = database.getID(session['username'])\n search_string = request.form['title']\n # Gets texts from db and formats them\n owned_texts, shared_texts = formatTexts(*database.getUsersTexts(session['id'], search_string))\n categories = database.loadCategories()\n return render_template('profile.html',\n owned_texts=owned_texts,\n shared_texts=shared_texts,\n username=username,\n categories=categories)\n flash(\"You cannot view other users profiles\")\n return redirect(url_for('index'))\n flash(\"User %s not found\" % username)\n return redirect(url_for('index'))\n except Exception as e:\n flash(\"Something went wrong, please try again\")\n return redirect(url_for('index'))","def SearchableText(self):\n ctool = getToolByName(self, 'portal_cpscalendar')\n if getattr(ctool, 'event_fulltext_index', False):\n return '%s %s' % (self.title, self.description)\n return ''","def get_clean_text(text: str) -> str:\n # Remove Lastname et al. \\ Keep group to potentially keep their name only.\n clean_text = re.sub(r\"\\(?([A-Za-z]+) et al.(, \\(?[0-9]{4}\\)?)?\", \"\", text)\n\n # Remove \"Lastname and Lastname (<year>)\"\n clean_text = re.sub(r\"\\(?[A-Z][A-Za-z\\-]+ and [A-Z][A-Za-z\\-]+,? \\(?[0-9]{4}\\)?\", \"\", clean_text)\n\n # TODO: Evaluate if replacing it with \"translated\" characters would be better?\n # Remove HTML special characters\n clean_text = re.sub(r\"\\&[a-z]{4};\", \"\", clean_text)\n\n # Clean up any left over duplicate spaces\n clean_text = re.sub(r\"\\s+\", \" \", clean_text)\n\n # Remove any non-ascii character from the query, according to\n # https://stackoverflow.com/a/18430817/3607203\n clean_text = clean_text.encode(\"ascii\", errors=\"ignore\").decode()\n\n # Don't mask the special characters here, since solr will take care of it.\n\n return clean_text","def format_ocr_text(self, page):\n \n #read out of the text file that tesseract made\n ocr_text = open(self.ocr_text, 'r')\n \n # write into this file\n djvu_text = open( self.djvu_text, 'w' )\n \n text = \"(page 0 0 1 1\\n\"\n \n self.out_text.write('\\n## Page %d ###\\n\\n' % page )\n \n for line in ocr_text:\n \n #write to the human readable file\n self.out_text.write(line)\n \n # add each line of text\n # escaping \" to \\\" as we go\n text += '(line 0 0 1 1 \"%s\")\\n' % line.replace('\"', r'\\\"').strip()\n \n text += \")\\n\"\n \n djvu_text.write( text )\n \n ocr_text.close()\n djvu_text.close()","def format_text(text):\n\n\ttext = ' '.join(text).lower()\n\ttext = re.sub(r\"[^a-zA-Z.?!]\", \" \", text)\n\ttext = re.sub(r' +', ' ', text)\n\ttext = word_tokenize(text)\n\ttext = pos_tag(text)\n\n\treturn text","def process_text(text):\n text = re.sub(r'<@>\\s+|<s>\\s+|</s>\\s+|<p>\\s+|</p>\\s+|\\s+\\,|\\'s|\\'|\\;|\\(|\\)|\\-\\-\\s+|\\s+\\.', '', text)\n text = re.sub(r'\\.\\,', '. ,', text)\n text = re.sub(r'\\,', '', text)\n text = re.sub(r'\\$', '$ ', text)\n text = re.sub(r'\\%', ' %', text)\n text = re.sub(r'\\s\\\"\\s', ' ', text)\n text = re.sub(r'\\.\\s+', '. ', text)\n text = text.lower()\n return text","def get_as_text(self):\n d = {\n 'user': self.user or self.name,\n 'date': self.submit_date,\n 'text': self.text,\n 'domain': self.site.domain,\n 'url': self.get_absolute_url()\n }\n return _('Posted by %(user)s at %(date)s\\n\\n%(review)s\\n\\nhttp://%(domain)s%(url)s') % d","def get_text(self):","def text_report(self):\n\n word_count = self.word_count()\n\n print(\"\\nThere are {} words in the text.\".format(word_count))\n mean, median, mode = self.average_word_length()\n\n print(\"\\nMean, median and mode word length is {}, {}, {}.\".format(mean, median, mode))\n\n if word_count < 10:\n print(\"\\nLongest words:\")\n else:\n print(\"\\n10 longest words:\")\n for s in self.longest_words():\n print(s)\n\n print(\"\\nMost common words:\")\n for s in self.common_words():\n print(\"{} x {}\".format(s[1], s[0]))\n\n longest_grams = []\n\n # find n_longest n-grams\n n_longest = 10\n # strongly doubt that there will be n-grams longer than 50\n for i in range(min(50, word_count), 1, -1):\n if len(longest_grams) >= n_longest:\n break\n grams = self.find_ngrams(i)\n grams_list = sorted(grams, key=grams.get, reverse=True)\n\n for g in grams_list:\n if grams[g] > 4:\n # do not want to include n-grams which are substrings of longer n-grams\n substring = False\n for s in longest_grams:\n if g in s[1]:\n substring = True\n break\n if not substring:\n longest_grams.append([grams[g], g])\n\n print(\"\\nLongest n-grams:\")\n for g in longest_grams:\n print(\"{} x {}\".format(g[0], g[1]))\n print('\\n')","def get_text_cleaned(status):\r\n \r\n #text = status['text']\r\n text = status['full_text']\r\n \r\n slices = []\r\n #Strip out the urls.\r\n if 'urls' in status['entities']:\r\n for url in status['entities']['urls']:\r\n slices += [{'start': url['indices'][0], 'stop': url['indices'][1]}]\r\n \r\n #Strip out the hashtags.\r\n if 'hashtags' in status['entities']:\r\n for tag in status['entities']['hashtags']:\r\n slices += [{'start': tag['indices'][0], 'stop': tag['indices'][1]}]\r\n \r\n #Strip out the user mentions.\r\n if 'user_mentions' in status['entities']:\r\n for men in status['entities']['user_mentions']:\r\n slices += [{'start': men['indices'][0], 'stop': men['indices'][1]}]\r\n \r\n #Strip out the media.\r\n if 'media' in status['entities']:\r\n for med in status['entities']['media']:\r\n slices += [{'start': med['indices'][0], 'stop': med['indices'][1]}]\r\n \r\n #Strip out the symbols.\r\n if 'symbols' in status['entities']:\r\n for sym in status['entities']['symbols']:\r\n slices += [{'start': sym['indices'][0], 'stop': sym['indices'][1]}]\r\n \r\n # Sort the slices from highest start to lowest.\r\n slices = sorted(slices, key=lambda x: -x['start'])\r\n \r\n #No offsets, since we're sorted from highest to lowest.\r\n for s in slices:\r\n text = text[:s['start']] + text[s['stop']:]\r\n \r\n return text","def _compute_fulltext(self):\n return ''","def text_json(request):\n query = str()\n\n if request.method == 'GET':\n query = request.GET.get('q')\n\n results = list()\n\n for c in search.tokenSearch(query):\n tmp = {'category':'課程代號','title':c.token}\n results.append(tmp)\n \n for c in search.zhNameSearch(query):\n tmp = {'category':'課程名稱','title':c.name_zh}\n results.append(tmp)\n\n \n for c in search.engNameSearch(query):\n tmp = {'category':'Course Name','title':c.name_eng}\n results.append(tmp)\n \n for t in Teacher.objects.filter(name_zh__icontains=query):\n tmp = {'category':'老師','title':t.name_zh}\n results.append(tmp)\n \n for d in Department.objects.filter(name_zh__icontains=query):\n tmp = {'category':'開課單位','title':d.name_zh}\n results.append(tmp)\n\n tmp = {'results':results}\n\n return HttpResponse(json.dumps(tmp))","def handleFormatText(paragraphContent):\n # We tokenize and remove the stop word\n words = tokenizeWord(paragraphContent) \n \n stemWords = []\n # We loop on each word.\n for word in words:\n stemWord = STEMMER.stem(word)\n \n # Selection on a part of string.\n stemWord = re.sub(\"[*\\'\\.+:,\\`:/]\", '', stemWord)\n if stemWord.isdigit() or len(stemWord) < 2:\n continue\n \n stemWords.append(stemWord)\n my_r_string = stemWords.pop(0)\n for word in stemWords:\n my_r_string += \" \"+str(word)\n return my_r_string","def search_values(username):\n try:\n with Database() as database:\n user = database.checkForUser(username)\n if user == session['username']:\n if session['username'] == username:\n features = [\"Alliteration\", \"Antithesis\", \"Juxtaposition\"]\n needs_feature = {}\n for feature in features:\n if request.form.get(feature) == \"on\":\n needs_feature[feature] = 1\n else:\n needs_feature[feature] = 0\n extra_query = \";\"\n for feature, has in needs_feature.items():\n if has == 1:\n extra = \"AND Text.\" + feature + \" = 1 \"\n extra_query = extra + extra_query\n sentiment_above = float(request.form[\"SSA\"])\n sentiment_below = float(request.form[\"SSB\"])\n reading_age_above = float(request.form[\"RAS\"])\n if sentiment_above >= sentiment_below:\n flash(\"Invalid Search...\")\n return redirect(request.referrer)\n data = [session['id'], reading_age_above,\n sentiment_above, sentiment_below]\n owned_texts, shared_texts = formatTexts(*database.searchTexts(data, extra_query))\n categories = database.loadCategories()\n return render_template('profile.html',\n owned_texts=owned_texts,\n shared_texts=shared_texts,\n username=username,\n categories=categories)\n flash(\"You cannot view other users profiles\")\n return redirect(url_for('index'))\n flash(\"User %s not found\" % username)\n return redirect(url_for('index'))\n except Exception as e:\n flash(\"Something went wrong, please try again\")\n return redirect(url_for('index'))","def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)","def raw_text(self):\n\t\t\n\t\t #eliminating more headers\n\t\traw_text = re.sub(r\".*OPERATIONS O[PF].*\",r\"\",self.doc)\n\t\traw_text = re.sub(r\"Page \\d+\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*B[lL]OCK.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*WEST GULF.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*NAVAL FORCES ON.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\"\\s\",r\" \", raw_text) #eliminating tabs etc. \t \t \n\t\treturn raw_text","def formatOutput(self, storedText, titleMode, altText='', internal=False):\n if titleMode:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = []\n for url in paths:\n path = url\n if not URLFormat.hasMethodRe.match(path):\n path = u'%s%s' % (self.URLMethod, path)\n path = u'<a href=\"%s\">%s</a>' % (escape(path, treedoc.escDict),\n altText or url)\n results.append(TextFormat.formatOutput(self, path, titleMode,\n internal))\n return u'<br />'.join(results)","def formatOutput(self, storedText, titleMode, internal=False):\n if titleMode:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = ['<img src=\"%s\">' % escape(url, treedoc.escDict) for url\n in paths]\n return u'<br />'.join(results)","def __filter( self, text ):\n return text","def getText():","def getText():","def getText():","def getText():","def getText():","def compute_full_text(row):\n full_text = row['full_text']\n # If needed, reconstruct the full tweet text from the original text, leaving the retweet header intact.\n if full_text.startswith('RT @') and full_text.endswith('\\u2026') and not pd.isnull(row['retweeted_status']):\n text_header = PTN_rt.search(row['full_text']).group()\n retweet_series = pd.read_json(json.dumps(row['retweeted_status']), typ='series')\n full_text = f'{text_header}{retweet_series[\"full_text\"]}'\n return clean_text(full_text)","def reformat_text(self, text):\n xml = BeautifulSoup(text)\n self.remove_header_and_footer(xml)\n self.process_superscripts(xml)\n self.remove_footnotes(xml)\n text = xml.get_text() # Strip XML tags.\n text = self.join_hyphenated_words(text)\n text = self.remove_linebreaks(text)\n return text","def get_parse_filter_text(conversation: Conversation):\n parse_op = gen_parse_op_text(conversation)\n if len(parse_op) > 0:\n intro_text = f\"For the data with <b>{parse_op}</b>,\"\n else:\n intro_text = \"For <b>all</b> the instances in the data,\"\n return intro_text","def rich(text):\n return full(text, False)","def _format_output(**values):\r\n return WEATHER_TEXT.format(**values)","def format_text(text):\n text = text.replace('to do ', '') \\\n .replace('to ', '') \\\n .replace(' at ', ' on ') \\\n .replace(' a ', ' 1 ') \\\n .replace(' an ', ' 1 ') \\\n .replace('minutes', '60') \\\n .replace('minute', '60') \\\n .replace('seconds', '1') \\\n .replace('second', '1') \\\n .replace('hours', '3600') \\\n .replace('hour', '3600')\n text = text.split(' ')\n pure_text = \"\"\n if text[-3] == 'in':\n for i in range(0, (len(text)-3)):\n pure_text += \" \" + text[i]\n final_text = [pure_text, text[-3], text[-2], text[-1]]\n else:\n for i in range(0, (len(text)-2)):\n pure_text += text[i]\n final_text = [pure_text, text[-2], text[-1]]\n if len(text) < 3:\n pprint(final_text)\n raise Exception(\"Bad remind request\")\n\n return final_text","def get_stats_texts(proj, action_type):\n first = _(\"(nog) geen\")\n if action_type == 'userwijz':\n all_objects = my.Userwijz.objects.filter(project=proj)\n second = _('ingediend')\n hlp = _(\"gerealiseerd\"), _('in behandeling via')\n elif action_type == 'probleem':\n all_objects = my.Userprob.objects.filter(project=proj)\n second = _(\"gemeld\")\n hlp = _('opgelost'), _('doorgekoppeld naar')\n elif action_type == 'bevinding':\n all_objects = my.Bevinding.objects.filter(project=proj)\n second = _(\"opgevoerd\")\n hlp = _('opgelost'), _('doorgekoppeld naar')\n else:\n return '', ''\n solved = all_objects.filter(gereed=True).count()\n working = all_objects.filter(gereed=False).filter(actie__isnull=False).count()\n if all_objects.count() != 0:\n first = all_objects.count()\n second = str(_(\"waarvan {} {} en {} {} Actiereg\").format(solved, hlp[0], working, hlp[1]))\n return first, second","def format_rich_text(rich_text_section):\n formatted_text = \"\"\n\n for elem in rich_text_section.get(\"elements\", []):\n elem_type = elem.get(\"type\")\n if elem_type == \"broadcast\":\n # Convert broadcasts to Discord-friendly pings:\n broadcast_range = elem.get(\"range\")\n if broadcast_range == \"channel\":\n elem_text = \"@everyone\"\n elif broadcast_range == \"here\":\n elem_text = \"@here\"\n elif elem_type == \"emoji\":\n emoji_list = app.client.emoji_list().get(\"emoji\", {})\n if emoji_list.get(elem.get(\"name\")):\n elem_text = f\":{elem.get('name')}:\"\n else:\n print(f\"Skipping over nonstandard emoji {elem.get('name', 'NO NAME')}\")\n continue\n elif elem_type == \"user\":\n # Convert @{user ID} to @{user name}:\n user_info = app.client.users_info(\n user=elem.get(\"user_id\")\n ).get(\"user\", {})\n user_name = user_info.get(\"profile\", {}).get(\"display_name\")\n if not user_name:\n # If user has no display_name (is a bot), use real_name:\n user_name = user_info.get(\"real_name\")\n if not user_name:\n # If user has no name, skip mention altogether:\n print(\"Skipping over user mention with no associated name.\")\n continue\n elem_text = f\"@{user_name}\"\n else:\n elem_text = elem.get(\"text\", \"\")\n \n style = elem.get(\"style\", {})\n\n # Prevent plain text from being rendered as markup:\n # (Code blocks by default have no markup)\n if not style.get(\"code\"):\n elem_text = elem_text.replace(\"_\", \"\\_\")\n elem_text = elem_text.replace(\"*\", \"\\*\")\n elem_text = elem_text.replace(\"`\", \"\\`\")\n elem_text = elem_text.replace(\">\", \"\\>\")\n\n # Apply appropriate styles to element's text:\n if style.get(\"bold\") or elem_type == \"user\":\n elem_text = f\"**{elem_text}**\"\n if style.get(\"italic\"):\n elem_text = f\"*{elem_text}*\"\n if style.get(\"strike\"):\n elem_text = f\"~~{elem_text}~~\"\n if style.get(\"code\"):\n elem_text = f\"`{elem_text}`\"\n\n # If element is a link, add the URL in Discord-friendly format:\n # \"[ hyperlink text ]( URL )\"\n if elem_type == \"link\":\n elem_text = f\"[{elem_text}]({elem.get('url')})\"\n\n # add formatted element's text to final markup string:\n formatted_text += elem_text\n\n # return final markup string:\n return formatted_text","def search():\n args = request.args.to_dict()\n query = QueryModel(args)\n result = repository.search_text(COLLECTION_NAME, query.value)\n return {\"texts\": result}","def market_search_formatter(search_results):\n headers = [\"id\", \"Details\", \"Creator\", \"Price\", \"Category\", \"Rating\"]\n rows = []\n for _, item in enumerate(search_results):\n if item[\"min_price\"] != item[\"max_price\"]:\n price_range = click.style(\"Variable\", fg=\"blue\")\n else:\n price_range = click.style(\"{} Satoshis\".format(item[\"min_price\"]),\n fg=\"blue\")\n category = click.style(\"{}\".format(item[\"category\"]), fg=\"blue\")\n creator = click.style(\"{}\".format(item[\"username\"]), fg=\"blue\")\n title = click.style(item[\"title\"], fg=\"blue\")\n rating = \"Not yet rated\"\n if item[\"rating_count\"] != 0:\n rating = \"{:.1f} ({} rating\".format(item[\"average_rating\"], int(item[\"rating_count\"]))\n if item[\"rating_count\"] > 1:\n rating += \"s\"\n rating += \")\"\n rating = click.style(rating, fg=\"blue\")\n rows.append([item[\"id\"], title, creator, price_range, category, rating])\n for _, l in enumerate(wrap(item[\"description\"])):\n rows.append([\"\", l, \"\", \"\", \"\", \"\"])\n rows.append([\"\", \"\", \"\", \"\", \"\", \"\"])\n\n return tabulate(rows, headers=headers, tablefmt=\"simple\")","def formatEditText(self, storedText):\n return (storedText, True)","def formatEditText(self, storedText):\n return (storedText, True)","def get_text(data):\n return \" \".join([item[\"words\"] for item in data])","def _html(self, text):\r\n html = URL_REGEX.sub(self._parse_urls, text)\r\n html = USERNAME_REGEX.sub(self._parse_users, html)\r\n html = LIST_REGEX.sub(self._parse_lists, html)\r\n return HASHTAG_REGEX.sub(self._parse_tags, html)","def formatOutput(self, storedText, titleMode, internal=False):\n choices, valid = self.sortedChoices(storedText)\n if valid:\n result = self.sep.join(choices)\n else:\n result = _errorStr\n return TextFormat.formatOutput(self, result, titleMode, internal)","def english2summary_name(english_query: str, use_cache: bool = True) -> str:\n\n prompt = '''Q: Show me all of the users\nQ: Show me all the users ordered by age ascending\nA: get all users ordered by age ascending\nQ: Who is the oldest user?\nA: get oldest user\nQ: What are the names of the 10 youngest users?\nA: get ten youngest users\nQ: Who is the oldest person?\nA: get oldest user\nQ: get all the users that are located in the United Kingdom\nA: get users from united kingdom\nQ: get users of ages between 30 and 40?\nA: get users ages between 30 and 40\nQ: How many users are there?\nA: get number users\nQ: Where does user Betty live?\nA: get betty location\nQ: What is Jennifer's age?\nA: get jennifer age\nQ: the average age\nA: get average user age\nQ: the age of the oldest user\nA: get age of oldest user\nQ: the name of the oldest person\nA: get name of oldest user\nQ: the top 10 oldest users\nA: get ten oldest users\nQ: how many admin users are there?\nA: get number admin users\nQ: retrieve the email of the youngest admin\nA: get email of youngest admin user\nQ: get a user by their email\nA: get user by email\nQ: get all users' emails that live at a certain location\nA: get users by location\nQ: '''\n\n prompt += english_query.strip()\n prompt += '\\nA:'\n\n def valid_char(c: str) -> bool:\n return c.isalnum() or c == ' ' or c == '_'\n\n result = cached_gpt3(prompt, use_cache=use_cache)\n result = ''.join(c for c in result if valid_char(c))\n while len(result) > 0 and result[0].isnumeric():\n result = result[1:]\n if len(result) == 0:\n result = 'untitled'\n return '_'.join(result.strip().lower().split(' '))","def standardize_text(df: pd.DataFrame,\r\n text_field: str,\r\n output_field: str) -> pd.DataFrame:\r\n\r\n # df[output_field] = df[text_field].apply(\r\n # lambda column: emoji.get_emoji_regexp().sub(u'', column)\r\n # )\r\n\r\n df[output_field] = df[text_field].str.replace(\"'m\", ' am')\r\n df[output_field] = df[output_field].str.replace(\"’m\", ' am')\r\n df[output_field] = df[output_field].str.replace(\"´m\", ' am')\r\n\r\n df[output_field] = df[output_field].str.replace(\"'ve\", ' have')\r\n df[output_field] = df[output_field].str.replace(\"’ve\", ' have')\r\n df[output_field] = df[output_field].str.replace(\"´ve\", ' have')\r\n\r\n df[output_field] = df[output_field].str.replace(\"'d\", ' would')\r\n df[output_field] = df[output_field].str.replace(\"’d\", ' would')\r\n df[output_field] = df[output_field].str.replace(\"´d\", ' would')\r\n\r\n df[output_field] = df[output_field].str.replace(\"n't\", ' not')\r\n df[output_field] = df[output_field].str.replace(\"n’t\", ' not')\r\n df[output_field] = df[output_field].str.replace(\"n´t\", ' not')\r\n\r\n df[output_field] = df[output_field].str.replace(\"'ll\", ' will')\r\n df[output_field] = df[output_field].str.replace(\"’ll\", ' will')\r\n df[output_field] = df[output_field].str.replace(\"´ll\", ' will')\r\n\r\n df[output_field] = df[output_field].str.replace(\"'s\", ' is')\r\n df[output_field] = df[output_field].str.replace(\"’\", ' is')\r\n df[output_field] = df[output_field].str.replace(\"´s\", ' is')\r\n\r\n df[output_field] = df[output_field].str.replace('/', ' ')\r\n df[output_field] = df[output_field].str.replace('\\.{2,}', '.')\r\n df[output_field] = df[output_field].str.replace('!{2,}', '!')\r\n df[output_field] = df[output_field].str.replace('\\?{2,}', '?')\r\n df[output_field] = df[output_field].str.replace('€+', '')\r\n df[output_field] = df[output_field].str.replace('[0-9$&~\\\\()[\\]{}<>%\\'\"“”‘’，;…+\\-_=*]+', '')\r\n df[output_field] = df[output_field].str.replace(r'http\\S+', '')\r\n df[output_field] = df[output_field].str.replace(r'http', '')\r\n df[output_field] = df[output_field].str.replace(r'@\\S+', '')\r\n df[output_field] = df[output_field].str.replace(r'@', 'at')\r\n df[output_field] = df[output_field].str.lower()\r\n df[output_field] = df[output_field].astype(str)\r\n\r\n return df","def get_text(self, caller):\n \n if caller == \"txt_search\":\n search_text = self.builder.get_object(\"txt_search\").get_text()\n return search_text\n elif caller == \"txt_tweet\":\n tweet_text = self.builder.get_object(\"txt_tweet\").get_text() \n return tweet_text","def process_text(self, text, language):","def score_display():\n data = score_reader()\n for index, datum in enumerate(data):\n score_format = \"%s ...... %s/%s\" % (datum[0].capitalize(), datum[1], datum[2])\n print(score_format)","def post_get_convert(self, site, getText):\n return getText","def format_item_display(self, obj):\n return u\"%s - %s\" % (escape(obj.nombre),obj.rfc)","def PROPER(text):\n return text.title()","def user_list(request):\r\n query = request.GET.get('q', '')\r\n # if query has 2 or more characters\r\n if len(query) >= 2:\r\n names = query.split(' ')\r\n # if query has a first and last name\r\n if len(names) == 2:\r\n first, last = names\r\n # if first and last name have 2 or more letters\r\n if len(first) >= 2 and len(last) >= 2:\r\n results = User.objects.filter(Q(\r\n first_name__icontains=first, \r\n last_name__icontains=last) | Q(first_name__icontains=last, \r\n last_name__icontains=first)).exclude(pk=request.user.pk)\r\n # if first name has 2 or more letters\r\n elif len(first) >= 2:\r\n results = User.objects.filter(Q(\r\n first_name__icontains=first) | Q(\r\n last_name__icontains=first)).exclude(pk=request.user.pk)\r\n # if last name has 2 or more letters\r\n elif len(last) >= 2:\r\n results = User.objects.filter(Q(\r\n first_name__icontains=last) | Q(\r\n last_name__icontains=last)).exclude(pk=request.user.pk)\r\n # if first and last name have less than 2 letters\r\n else:\r\n results = []\r\n # if query only has one name\r\n else:\r\n results = User.objects.filter(Q(\r\n username__icontains=query)).exclude(pk=request.user.pk)\r\n # if query has less than 2 letters\r\n else:\r\n results = []\r\n d = {\r\n 'results': results,\r\n }\r\n t = loader.get_template('usermessages/results.html')\r\n context = Context(d)\r\n data = {\r\n 'results': t.render(context),\r\n }\r\n return HttpResponse(json.dumps(data), mimetype='application/json')","def clean_user_desc(self):\n desc = self.data['user']['description']\n if desc is not None:\n desc = ' '.join(re.sub(\"(RT : )|(@[\\S]+)|(&\\S+)|(http\\S+)\", \" \", desc).split())\n desc = \" \".join(re.sub(\"(#\\S+)\", ' ', desc).split())\n desc = ''.join(list(filter(lambda x: x.isalpha() or x is ' ',\n desc))).replace(' ', ' ').replace(' ', ' ').lower().strip()\n return {'plain_desc': desc}","def get_full_text(self, item):\n text_content = self.db.plugin_text_text(item_id=item.unique_id)\n output = self.response.render(\n 'plugin_text/full_text.txt',\n dict(text_content=text_content, item=item))\n return unicode(output.decode('utf-8'))","def search_keywords(username):\n try:\n with Database() as database:\n user = database.checkForUser(username)\n if user == session['username']:\n if session['username'] == username:\n session['id'] = database.getID(session['username'])\n search_string = request.form['keyword']\n # Gets the graph from a file\n with open(\"word_graph.txt\", \"rb\") as f:\n G = pickle.load(f)\n owned_texts = []\n shared_texts = []\n if search_string in G.nodes:\n # Gets all nodes that are connected to your current word\n keywords = dijsktra(G, search_string)\n owned_texts = []\n shared_texts = []\n owned_titles = []\n for keyword, score in keywords.items():\n owned, shared = database.searchKeyword(keyword, session['id'])\n to_format_owned = []\n to_format_shared = []\n # Checks the text has not already been loaded\n for text in owned:\n if text[0] not in owned_titles:\n to_format_owned.append(text)\n owned_titles.append(text[0])\n for text in shared:\n if text[0] not in shared_titles:\n to_format_shared.append(text)\n shared_titles.append(text[0])\n owned, shared = formatTexts(to_format_owned, to_format_shared)\n owned_texts += owned\n shared_texts += shared\n # Makes sure there is only one false statement in array\n owned_texts = [text for text in owned_texts if text is not False]\n if len(owned_texts) == 0:\n owned_texts.append(False)\n shared_texts = [text for text in shared_texts if text is not False]\n if len(shared_texts) == 0:\n shared_texts.append(False)\n categories = database.loadCategories()\n return render_template('profile.html',\n owned_texts=owned_texts,\n shared_texts=shared_texts,\n username=username,\n categories=categories)\n else:\n flash(\"Keyword not found\")\n return redirect(request.referrer)\n flash(\"You cannot view other users profiles\")\n return redirect(url_for('index'))\n flash(\"User %s not found\" % username)\n return redirect(url_for('index'))\n except Exception as e:\n flash(\"Something went wrong, please try again\")\n return redirect(url_for('index'))","def make_haystack(self):\n journal_data = [\" \".join(self.format_authors(style=\"full\")),\n self.journal_long,\n self.journal_short,\n \"\".join(c for c in self.journal_short if c.isupper()),\n self.title]\n return [unidecode(data) for data in journal_data]","def _text_formatting(bs4_tag):\n return bs4_tag.get_text().replace('\\n', '')","def format_query_for_displaying(query):\n keys = query.keys()\n result = ''\n for k in keys:\n v = query[k]\n print(\"Checking v=%r and k=%r\" % (v, k))\n result += '[%s] ' % k\n if v and type(v) == dict:\n kk = v.keys()\n r = ''\n for l in kk:\n m = v[l]\n r += str(m)\n r += ' '\n result += r\n else:\n print(\"result: [%s] v:[%s]\" % (result, str(v)))\n result += str(v)\n result += '\\n'\n if result == '':\n result = 'JUST VISITED THE SEARCH PAGE.'\n return result","def search(request, template_name='congregation/search_results.html'):\n context = {}\n if request.GET:\n stop_word_list = re.compile(STOP_WORDS, re.IGNORECASE)\n search_term = '%s' % request.GET['findperson']\n cleaned_search_term = stop_word_list.sub('', search_term)\n cleaned_search_term = cleaned_search_term.strip()\n terms = cleaned_search_term.split(' ')\n if len(cleaned_search_term) != 0:\n people_list = Person.objects.filter(\n Q(first_name__icontains=cleaned_search_term) | \n Q(last_name__icontains=cleaned_search_term) | \n Q(preferred_first_name__icontains=cleaned_search_term) \n )\n if len(people_list) < 1:\n people_list = Person.objects.filter(\n Q(first_name__iregex=r'(' + '|'.join(terms) + ')') | Q(preferred_first_name__iregex=r'(' + '|'.join(terms) + ')')\n ).filter(last_name__iregex=r'(' + '|'.join(terms) + ')')\n if len(people_list)<1:\n message = 'no match found for '\n else:\n message = 'matches found for '\n else:\n message = 'matches found for '\n\n people_list = people_list.exclude(deceased__isnull=False).exclude(active=False).exclude(opt_in_directory=False)\n context = {'object_list': people_list, 'message': message, 'search_term':search_term, }\n else:\n message = 'Search term was too vague. Please try again.'\n context = {'message':message}\n return render_to_response(template_name, context, context_instance=RequestContext(request))","def get_text(self):\n text_complet = \"\"\n rez_dict = self.__results\n for i in range(0, len(rez_dict[\"text\"])):\n text = rez_dict[\"text\"][i]\n conf = int(rez_dict[\"conf\"][i])\n if conf > self.__min_confidence:\n text_complet += text + \" \"\n return text_complet","def search_results(self, results):\n for index, item in enumerate(results):\n print '[%s] %s (%s) {%s}' % (\n index, \n self._color(item.title), \n self._color(item.year, 'RED'), \n self._color(item.imdbid, 'GREEN'))","def highlight(search_me, word, userid):\n if db_is_loggedin.find_one({\"user\": userid}).get(\"is_loggedin\") == True:\n word = word.strip()\n results = wisdomaiengine.highlighter(word)\n search_term = db_search_terms.find_one({\"value\": search_me.lower()})\n search_id = search_term.get(\"_id\")\n data = {\"user\": userid,\n \"search_id\": search_id,\n \"highlighted_word\": word,\n \"results\": results,\n \"date_saved\": datetime.utcnow()}\n x = db_highlights.insert(data, check_keys=False)\n jsonob = jsonify(results=results)\n return jsonob\n else:\n msg = {\"status\" : { \"type\" : \"fail\" , \"message\" : \"Please log in\"}}\n return jsonify(msg)","def search_command():\n listing.delete(0, END)\n for row in backend.search(title_text.get(), \n author_text.get(), \n year_text.get(), \n isbn_text.get()):\n listing.insert(END, row)","def internetSearch(userInput):\n try:\n result = \"\"\n content = userInput.split(\" \")\n tmp = content.copy()\n for word in badsearchDb:\n if word in content:\n tmp.remove(word)\n content = \" \".join(tmp)\n result = \"\\n: \"+content\n try:\n info = str(wikipedia.summary(content, sentences=5))\n except wikipedia.exceptions.DisambiguationError as e:\n return \"... \\nCan you please be less ambiguous?\"\n except wikipedia.exceptions.PageError as e:\n return \"... \\n So I was checking on wikipedia, and their page crashed.\"\n result += \"... \\nFound: \"+info[:200]\n return str(result)\n except Exception as e:\n return \"Failed \" + e # interconnection problems e.g.?","def extract_text(self, categories, entries):\n text = \" \".join(\n [\n self.podcast.title,\n self.podcast.description,\n self.podcast.keywords,\n self.podcast.authors,\n ]\n + [c.name for c in categories]\n + [e[\"title\"] for e in entries][:6]\n )\n return \" \".join([kw for kw in extract_keywords(self.podcast.language, text)])","def profile(userid):\n # get bookmarked content\n bookmarks = db_bookmarks.find({\"user\": userid})\n bookmarks = [{\"search_term\": db_search_terms.find_one({\"_id\": b[\"search_id\"]}).get(\"value\"), \"source\": b[\"source\"], \"url\": b[\"url\"], \"date_saved\": b[\"date_saved\"].strftime(\"%H:%M %B %d, %Y\")} for b in bookmarks]\n # get previous searches\n searches = db_searches.find({\"user\": userid})\n searches = [{\"search_term\": db_search_terms.find_one({\"_id\": s[\"search_id\"]}).get(\"value\"), \"category\": s[\"category\"], \"datetime\": s[\"datetime\"].strftime(\"%H:%M %B %d, %Y\")} for s in searches]\n # get byod\n byod = db_byod.find({\"user\": userid})\n byod = [{\"content_type\": b[\"content_type\"], \"doc_name\": b[\"doc_name\"], \"text\": b[\"text\"], \"key_points\": b[\"key_points\"], \"datetime_uploaded\": b[\"datetime_uploaded\"].strftime(\"%H:%M %B %d, %Y\")} for b in byod]\n # get highlightds\n # highlights = db_highlights.find({\"user\": userid})\n # highlights = [{\"search_term\": db_search_terms.find_one({\"_id\": h[\"search_id\"]}).get(\"value\"), \"highlighted_word\": h[\"highlighted_word\"], \"results\": h[\"results\"], \"date_saved\": h[\"date_saved\"].strftime(\"%H:%M %B %d, %Y\")} for h in highlights]\n jsonob = jsonify(bookmarks=bookmarks,\n searches=searches,\n byod=byod)\n return jsonob","def update_text(self):\n\n def update_by_filter(all_text, widget, text_filters):\n new_text = \"\\n\".join([line for line in all_text.split(\"\\n\") if any(s in line for s in text_filters)])\n widget.setPlainText(new_text)\n widget.verticalScrollBar().setValue(widget.verticalScrollBar().maximum())\n\n with open(self.log_file, \"r\", encoding='utf-8') as log_file:\n text = log_file.read()\n text_len = len(text)\n if text_len > self._old_txt_len:\n self._old_txt_len = text_len\n self.all_widget.setPlainText(text)\n self.all_widget.verticalScrollBar().setValue(self.all_widget.verticalScrollBar().maximum())\n update_by_filter(all_text=text, widget=self.info_widget, text_filters=(\"- INFO - \",))\n update_by_filter(all_text=text, widget=self.error_widget, text_filters=(\"- ERROR - \", \"- WARNING -\"))","def findText(self):\n\n # Prompts user for find regex\n findText,_ = Model.FindAndReplaceDialogBox.getResults(self)\n model = self.getCurrentPanda()\n start = model.index(0, 0)\n matches = model.match(\n start, QtCore.Qt.DisplayRole,\n findText, -1, QtCore.Qt.MatchContains)\n if matches:\n index = matches[0]\n self.getCurrentView().clearSelection()\n self.getCurrentView().selectionModel().select(\n index, QtCore.QItemSelectionModel.Select)\n self.getCurrentView().scrollTo(index)\n else:\n self.notifyUser(\"No matches found.\")","def return_user_text(self, id_user:int) -> str:\n try:\n name_default = self.cursor.execute(f\"SELECT text_sending FROM {table_users_settings} WHERE id_user={id_user};\").fetchone()\n if not name_default:\n self.insert_settings(id_user)\n return self.return_user_text(id_user)\n return name_default[0]\n except Exception as e:\n msg = f\"We faced problems with return default text. Mistake: {e}\"\n self.proceed_error(msg)\n return entrance_bot_usage","def _transform_search_database(self):\n # TODO: Create this and link with protein object when fasta file is provided\n return {\n \"file_format\": \"fasta format\",\n \"name\": \"\",\n \"id\": 1,\n \"location\": \"\",\n \"params\": [],\n }","def text(self):\n parts = [(\"%s\" if isinstance(p, Insert) else p) for p in self.parts]\n parts = [(\"%%\" if p == \"%\" else p) for p in parts] # escape percent\n return \"\".join(parts)","def format_item_display(self, item):\r\n return u\"<span class='tag'>%s</span>\" % item.filter","def search_people_2(search_type, search_value):\n try:\n # Search Types:\n # First Name, Last Name, Address 1, Address 2, City, State, Zip Code, Phone, Email, Identification\n query_string_name =\\\n \"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname, \"\\\n \"p.dateofbirth, p.dateofdeath \"\\\n \"FROM person p \"\\\n \"WHERE {0} LIKE ? COLLATE NOCASE;\"\n query_string_address =\\\n \"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname, \"\\\n \"p.dateofbirth, p.dateofdeath \"\\\n \"FROM person p \"\\\n \"LEFT JOIN address a on a.personid = p.personid \"\\\n \"WHERE {0} LIKE ? COLLATE NOCASE \"\n\n conn = sqlite3.connect(settings.database_name)\n conn.row_factory = sqlite3.Row\n c = conn.cursor()\n c.execute(\"PRAGMA foreign_keys = ON\")\n final_query = \"\"\n if search_type in {\"First Name\", \"Last Name\"}:\n if search_type == \"First Name\":\n final_query = query_string_name.format(\"p.firstname\")\n if search_type == \"Last Name\":\n final_query = query_string_name.format(\"p.lastname\")\n c.execute(final_query, (\"%\"+search_value+\"%\",))\n\n if search_type in {\"Address 1\", \"Address 2\", \"City\", \"State\", \"Zip Code\"}:\n if search_type == \"Address 1\":\n final_query = query_string_address.format(\"a.addressline1\")\n c.execute(final_query, (\"%\"+search_value+\"%\",))\n if search_type == \"Address 2\":\n final_query = query_string_address.format(\"a.addressline2\")\n c.execute(final_query, (\"%\"+search_value+\"%\",))\n if search_type == \"City\":\n final_query = query_string_address.format(\"a.city\")\n c.execute(final_query, (\"%\"+search_value+\"%\",))\n if search_type == \"State\":\n final_query = query_string_address.format(\"a.state\")\n c.execute(final_query, (\"%\"+search_value+\"%\",))\n if search_type == \"Zip Code\":\n final_query = query_string_address.format(\"a.zipcode\")\n c.execute(final_query, (\"%\"+search_value+\"%\",))\n\n if search_type == \"Phone\":\n c.execute(\"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname, \"\n \"p.dateofbirth, p.dateofdeath \"\n \"FROM person p \"\n \"JOIN contact c on c.personid = p.personid \"\n \"JOIN phone ph on ph.contactid = c.contactid \"\n \"WHERE ph.areacode || ph.exchange || ph.trunk LIKE ?;\", (\"%\"+search_value+\"%\",))\n\n if search_type == \"Email\":\n c.execute(\"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname,\"\n \"p.dateofbirth, p.dateofdeath \"\n \"FROM person p \"\n \"JOIN contact c on c.personid = p.personid \"\n \"JOIN email e on e.contactid = c.contactid \"\n \"WHERE e.emailaddress LIKE ? COLLATE NOCASE;\", (\"%\"+search_value+\"%\",))\n\n if search_type == \"Identification\":\n c.execute(\"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname, \"\n \"p.dateofbirth, p.dateofdeath \"\n \"FROM person p \"\n \"JOIN identification i on i.personid = p.personid \"\n \"WHERE i.identificationnumber LIKE ? COLLATE NOCASE;\", (\"%\"+search_value+\"%\",))\n\n p = []\n if search_type == \"All\":\n p = read_people()\n else:\n for row in c:\n _person = Person()\n _person.person_id = row[\"personid\"]\n _person.first_name = row[\"firstname\"]\n _person.last_name = row[\"lastname\"]\n _person.middle_initial = row[\"middleinitial\"]\n _person.nick_name = row[\"nickname\"]\n _person.date_of_birth = row[\"dateofbirth\"]\n _person.date_of_death = row[\"dateofdeath\"]\n p.append(_person)\n conn.close()\n return p\n except Exception as exc:\n aexc = exc\n return []","def get_highlight_text(start, start_index, end, end_index):\n #TODO: this has nothing to do with highlights, whatever those are\n #TODO: this method is ridiculous, how is it usable? the arguments could\n # mean two different things.\n text = \"\"\n words = WordInSentence.query.filter(\n (WordInSentence.sentence_id > start) &\n (WordInSentence.sentence_id < end) |\n (WordInSentence.sentence_id == start) &\n (WordInSentence.position >= start_index) |\n (WordInSentence.sentence_id == end) &\n (WordInSentence.position <= end_index)).\\\n order_by(WordInSentence.sentence_id).\\\n order_by(WordInSentence.position).all()\n\n for word in words:\n if not app.config[\"PUNCTUATION_ALL\"] in word.surface:\n text += \" \" # Don't put spaces in front of punctuation.\n\n text += word.surface\n\n return text","def get_text(listing_id):\n conn = None\n try:\n params = config()\n conn = psycopg2.connect(**params)\n cur = conn.cursor()\n cur.execute(\"SELECT reviews FROM listingid_to_text WHERE listing_id IN (%s)\", [listing_id])\n rows = cur.fetchall()\n print(rows)\n cur.close()\n except (Exception, psycopg2.DatabaseError) as error:\n print(error)\n finally:\n if conn is not None:\n conn.close()","def criteria_prettified(self, instance):\n\n # Convert the data to sorted, indented JSON\n response = json.dumps(instance.criteria, sort_keys=True, indent=2)\n\n # Truncate the data. Alter as needed\n response = response\n\n # Get the Pygments formatter\n formatter = HtmlFormatter(style='colorful')\n\n # Highlight the data\n response = highlight(response, JsonLexer(), formatter)\n\n # Get the stylesheet\n style = \"<style>\" + formatter.get_style_defs() + \"</style><br>\"\n\n # Safe the output\n return mark_safe(style + response)","def textify(read_pdf,spage,epage):\n\n page_text = \"\"\n for page in range(spage, epage):\n page_content = read_pdf.getPage(page)\n page_text += page_content.extractText()\n\n full_text = page_text #.encode('utf-8')\n return full_text","def get_full_text(self, item):\n photoset_content = self.db.plugin_photoset_content(\n item_id=item.unique_id)\n output = self.response.render(\n 'plugin_photoset/full_text.txt',\n dict(photoset_content=photoset_content, item=item))\n return unicode(output.decode('utf-8'))","def convert_search_to_scopus_search_string(search):\n search_string = \"\"\n if search[\"author_name\"]:\n if search_string != \"\":\n search_string += \" AND \"\n search_string += \"AUTH(\" + search[\"author_name\"] + \")\"\n if search[\"topic\"]:\n if search_string != \"\":\n search_string += \" AND \"\n search_string += \"TITLE-ABS-KEY(\" + search[\"topic\"] + \")\"\n if search[\"start_year\"]:\n if search_string != \"\":\n search_string += \" AND \"\n search_string += \"PUBYEAR AFT \" + search[\"start_year\"] + \"\"\n if search[\"end_year\"]:\n if search_string != \"\":\n search_string += \" AND \"\n search_string += \"PUBYEAR BEF \" + search[\"end_year\"] + \"\"\n if search[\"title\"]:\n if search_string != \"\":\n search_string += \" AND \"\n search_string += \"TITLE(\" + search[\"title\"] + \")\"\n if search[\"subject\"]:\n if search_string != \"\":\n search_string += \" AND \"\n search_string += \"SUBJAREA(\" + search[\"subject\"] + \")\"\n if search[\"author_id\"]:\n if search_string != \"\":\n search_string += \" AND \"\n search_string += \"AU-ID(\" + search[\"author_id\"] + \")\"\n if search[\"affiliation_id\"]:\n if search_string != \"\":\n search_string += \" AND \"\n affil_search = '(AF-ID(' + search[\"affiliation_id\"].replace(\"\\n\", \"\") + '))'\n affil_search = affil_search.replace(\" OR \", \") OR AF-ID(\")\n affil_search = affil_search.replace(\" OR\", \") OR AF-ID(\")\n affil_search = affil_search.replace(\" AND \", \") AND AF-ID(\")\n search_string += affil_search\n return search_string","def display_fields(self):\r\n\r\n field_text = self.show_fields()\r\n field_text_list = field_text.split(EOL)[0:-1]\r\n\r\n def fld_format (x_temp):\r\n\r\n x_temp = x_temp.split(COLON)[0], x_temp.split(COLON)[1]\r\n\r\n \"\"\"formats output of the list of search results\"\"\"\r\n\r\n if not isinstance(x_temp[1],str):\r\n shown_indexes = rangelist.range_find([int(Index(a_temp))\r\n for a_temp in x_temp[1]],reduce=True)\r\n else:\r\n shown_indexes = x_temp[1]\r\n\r\n if len(shown_indexes) < 20:\r\n return (abridge(x_temp[0]).replace(VERTLINE,SLASH)\r\n +VERTLINE\r\n +shown_indexes)\r\n\r\n\r\n returnlist = []\r\n sp_temp = rangelist.split_up_range(shown_indexes)\r\n\r\n\r\n returnlist.append(x_temp[0].replace(VERTLINE,SLASH)[0:min([60,len(x_temp[0])])]\r\n +VERTLINE+sp_temp[0])\r\n for s_temp in sp_temp[1:]:\r\n returnlist.append(VERTLINE+s_temp)\r\n\r\n return returnlist\r\n\r\n show_list(field_text_list,\r\n alerts.FIELDS[3:],0,40,\r\n func=fld_format,\r\n present=True,\r\n display=display)","def text(self, tid, lang):\n csv_paths = [\n os.path.join(self.config.csv.base, self.config.csv.path.texts),\n os.path.join(self.config.csv.base, self.config.csv.path.texts_patch)\n ]\n _text = None\n while _text is None:\n for csv_path in csv_paths:\n with open(csv_path, encoding=\"utf8\") as f:\n texts_reader = csv.DictReader(f)\n for row in texts_reader:\n keys = ['v', ' ']\n for key in keys:\n if key in row.keys():\n if row.get(key) == tid:\n s = row[lang]\n _text = s.replace('\\q', '\\\"')\n if _text is None:\n _text = ''\n\n return _text","def load_texts(self):\n\n db = mongo(self.text_dbname)\n\n print(\"Loading texts:\")\n # For each other, query the text database and add their works to texts to compare\n for author in self.authors:\n for text in db.texts.find({'author':author, 'language':\"latin\"}, no_cursor_timeout=True):\n self.texts_to_compare.append(text)\n print(\" -- loaded texts for\", author)\n\n return","def PersonSearch(self, searchtext=None, **kw):\n\t\thtml = \"<ul><h4>Results:</h4>\"\n\t\tif searchtext:\n\t\t\tsearch = model.Person.select(OR (model.Person.q.NameFirst.contains(str(searchtext)), \n\t\t\t\t\t\t\tmodel.Person.q.NameLast.contains(str(searchtext))))\n\t\t\tif search.count() > 0:\n\t\t\t\tfor person in search:\n\t\t\t\t\thtml += '<li><a href=\"?PersonID=%s\">%s</a></li>' % (str(person.id), person.DisplayName())\n\t\t#log.debug(html)\n\t\thtml += \"</ul>\"\n\t\treturn html","def get_search_results_html(search_query=None):\n\n if search_query:\n # Insert the search term into the database\n insert_query(search_query)\n\n # Format results as HTML\n search_results = f'<p>You searched for: {search_query}</p>'\n search_results += '<p>No results found.</p>'\n return search_results\n\n # No search term specified, so return an empty string\n return \"\"","def formatOutput(self, storedText, titleMode, altText='', internal=False):\n if titleMode or not internal:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = []\n for url in paths:\n # add prefix/suffix within the executable path:\n url = TextFormat.formatOutput(self, url, titleMode, internal)\n path = url\n if not URLFormat.hasMethodRe.match(path):\n path = u'%s%s' % (self.URLMethod, path)\n results.append(u'<a href=\"%s\">%s</a>' %\n (escape(path, treedoc.escDict), altText or url))\n return u'<br />'.join(results)","def search_results(request):\n #key\n\n user_input = request.GET['q']\n\n people_objs = Person.objects.filter(Q(last__contains=user_input) | Q(\n first__contains=user_input))\n document_objs = Document.objects.filter(title__contains=user_input)\n folder_objs = Folder.objects.filter(full__contains=user_input)\n organization_objs = Organization.objects.filter(Q(name__contains=user_input)|Q(\n location__contains=user_input))\n obj_dict = {\n 'people_objs': people_objs,\n 'document_objs': document_objs,\n 'folder_objs': folder_objs,\n 'organization_objs': organization_objs,\n 'query': user_input,\n }\n response = render(request, 'search_results.jinja2', obj_dict)\n return response","def queryToMessage(queryCombo):\n colunas = queryCombo[0]\n query = queryCombo[1]\n if len(query) != 0:\n result = \"\"\n for row in query:\n for i, data in enumerate(row):\n result += f'<b>{colunas[i].capitalize()}:</b> {data}\\n'\n result += f'{\"-\"*20}\\n'\n return result\n else:\n return \"Nenhuma entrada encontrada usando esse parâmetro de busca.\"","def formatEditText(self, storedText):\n for choice in self.splitText(storedText):\n if choice not in self.formatList:\n return (storedText, not storedText)\n return (storedText, True)","def _get_text_rendering(self, table):\n text_table = ''\n base_variable = table.get_variable().replace(\"'\", '')\n\n if base_variable == self._system.get_settings().user_input:\n text_table += '\\n[user]\\t'\n elif base_variable == self._system.get_settings().system_output:\n text_table += '[system]\\t'\n else:\n text_table += '[' + base_variable + ']\\t'\n\n for value in table.get_values():\n if not isinstance(value, NoneVal):\n content = str(value)\n if table.get_prob(value) < 0.98:\n content += ' (' + StringUtils.get_short_form(table.get_prob(value)) + ')'\n\n text_table += content + '\\n\\t\\t'\n\n if base_variable == self._system.get_settings().user_input:\n text_table += '\\n'\n\n text_table = text_table[0:-3]\n return text_table","def search(request):\n # Get data form request\n name = request.DATA.get('first_name', \"''\")\n if name == \"\":\n\n first_names = request.DATA.get('first_name', \"''\")\n last_names = request.DATA.get('last_name', \"''\")\n display_names = request.DATA.get('display_name', \"''\")\n else:\n first_names = name\n last_names = name\n display_names = name\n genders = request.DATA.get('gender', \"''\")\n\n handicaps = request.DATA.get('handicap', \"''\")\n business_area = request.DATA.get('business_area', \"''\")\n city = request.DATA.get('city', \"''\")\n district = request.DATA.get('district', \"''\")\n age = request.POST.get('age', 0)\n dob_year = int(datetime.now().year) - int(age)\n min_dob = datetime.strptime(str(dob_year) + '-01-1', '%Y-%m-%d')\n max_dob = datetime.strptime(str(dob_year) + '-12-30', '%Y-%m-%d')\n\n # Search by single properties\n results = SearchQuerySet().filter(first_name=first_names).filter(last_name=last_names\n ).filter(gender=genders).filter(\n display_name=display_names).filter(handicap_us=handicaps\n ).filter(handicap_36=handicaps\n ).filter(business_area=business_area).filter(city=city\n ).filter(\n district=district)\n\n if age is not 0:\n results.filter(dob__gte=min_dob, dob__lte=max_dob)\n # Get List user\n queryset = User.objects.all()\n # Create result list\n results_list = []\n # Get User to list by id\n max_loop = results.count()\n for x in range(0, max_loop):\n user = get_object_or_404(queryset, pk=results[x].object.id)\n results_list.append(user)\n # Convert to serializer\n serializer = UserSerializer(results_list, many=True)\n if serializer.is_valid:\n return Response({'status': '200', 'code': 'OK_SEARCH',\n 'detail': serializer.data}, status=200)\n else:\n return Response({'status': '400', 'code': 'E_INVALID_PARAMETER_VALUES',\n 'detail': serializer.errors}, status=400)"],"string":"[\n \"def __get_search_content(self):\\n words = [\\\",\\\".join(self.__get_property_from_all_views(\\\"resource_id\\\")),\\n \\\",\\\".join(self.__get_property_from_all_views(\\\"text\\\"))]\\n return \\\"\\\\n\\\".join(words)\",\n \"def get_person_text(self, uid):\\n words = \\\"\\\"\\n\\n query = \\\"\\\"\\\"\\nSELECT ?overview ?researchO ?label\\nWHERE\\n{\\n <%s> <http://vivoweb.org/ontology/core#overview> ?overview .\\n <%s> <http://vivoweb.org/ontology/core#researchOverview> ?researchO .\\n <%s> <http://www.w3.org/2000/01/rdf-schema#label> ?label .\\n}\\n \\\"\\\"\\\" % (uid, uid, uid)\\n self.setQuery(query)\\n try:\\n rval = self.query()\\n try:\\n g = rval.convert()\\n except:\\n pass\\n words = \\\"%s %s %s\\\" % (g['results']['bindings'][0]['overview']['value'], g['results']['bindings'][0]['researchO']['value'], g['results']['bindings'][0]['label']['value'])\\n except:\\n print \\\"Select failed: %s\\\" % query\\n\\n self.setQuery(\\\"\\\"\\\"\\nPREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\\nPREFIX vivo: <http://vivoweb.org/ontology/core#>\\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\\nSELECT ?name\\nWHERE\\n{\\n ?auth vivo:relates <%s> .\\n ?auth rdf:type vivo:Authorship .\\n ?auth vivo:relates ?art .\\n filter (?art!=<%s>) .\\n ?art <http://vivoweb.org/ontology/core#dateTimeValue> ?date .\\n ?date <http://vivoweb.org/ontology/core#dateTime> ?year .\\n filter (?year>\\\"2009-01-01T00:00:00Z\\\"^^xsd:dateTime) .\\n ?art rdfs:label ?name .\\n}\\nLIMIT 20\\n\\\"\\\"\\\" % (uid, uid))\\n try:\\n rval = self.query()\\n try:\\n g = rval.convert()\\n except:\\n pass\\n for t in g['results']['bindings']:\\n words = words + \\\" \\\" + t['name']['value']\\n\\n except:\\n print \\\"Select failed\\\"\\n traceback.print_exc(file=sys.stdout)\\n\\n self.setQuery(\\\"\\\"\\\"\\nPREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\\nPREFIX vivo: <http://vivoweb.org/ontology/core#>\\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\\n\\nSELECT ?name\\nWHERE\\n{\\n ?grant vivo:relates <%s> .\\n ?grant rdf:type vivo:Grant .\\n ?grant <http://vivoweb.org/ontology/core#dateTimeInterval> ?date .\\n ?date <http://vivoweb.org/ontology/core#end> ?end .\\n ?end <http://vivoweb.org/ontology/core#dateTime> ?year .\\n filter (?year>\\\"2009-01-01T00:00:00Z\\\"^^xsd:dateTime) .\\n ?grant rdfs:label ?name .\\n}\\n\\n \\\"\\\"\\\" % (uid))\\n try:\\n rval = self.query()\\n try:\\n g = rval.convert()\\n except:\\n pass\\n\\n for t in g['results']['bindings']:\\n words = words + \\\" \\\" + t['name']['value']\\n\\n except:\\n print \\\"Select failed\\\"\\n traceback.print_exc(file=sys.stdout)\\n\\n\\n\\n\\n return words\",\n \"def format_text(self):\\n\\n return \\\"{}{}{}\\\".format(self.get_text(),\\n Message.format_performers(self.get_performers()),\\n Message.format_keywords(self.get_keywords())).strip()\",\n \"def get_db_format(text):\\n db_text = \\\"\\\"\\n for t in text.split(\\\" \\\"):\\n db_text += t.title()\\n return db_text\",\n \"def parsingconvtext(retrievedtext,customtextlist):\\r\\n if not retrievedtext: #in case empty text \\r\\n retrievedtext=changenonetostr(retrievedtext)\\r\\n newtext=BeautifulSoup(retrievedtext).get_text() \\r\\n #newtext=changenonetostr(retrievedtext)\\r\\n #newtext=BeautifulSoup(newtext).get_text() \\r\\n #remove http links\\r\\n newtext=re.sub(r'http\\\\S+', '', newtext)\\r\\n newtext=re.sub(r'\\\\r\\\\r\\\\r\\\\n', ' ', newtext)\\r\\n #remove LL specific text\\r\\n if customtextlist:\\r\\n for i in customtextlist:\\r\\n newtext=re.sub(i, '', newtext)\\r\\n return newtext\",\n \"def get_user_and_text(db):\\n con = lite.connect(db)\\n with con:\\n cur = con.cursor()\\n cur.execute(\\\"SELECT author, GROUP_CONCAT(text, ' ') FROM Comments GROUP BY author\\\")\\n user_text_list = cur.fetchall() \\n return user_text_list\",\n \"def format_result(result):\\n output = ''\\n for item in result:\\n text = item['text']\\n date = item['date']\\n status = item['status']\\n author = item['author_name']\\n line = (\\n f'Кейс: {text}\\\\n'\\n f'<code>Дата: {date}</code>\\\\n'\\n f'Статус: <b>{status}</b>\\\\n'\\n f'Автор: {author}\\\\n'\\n '\\\\n'\\n )\\n output += line\\n return output\",\n \"def _format_response(self, response):\\n texts = []\\n for result in response.results: \\n texts.append(result.alternatives[0].transcript)\\n return texts\",\n \"def query_texts():\\n alloweds = {'author', 'is_prose', 'language', 'title'}\\n filters = {}\\n for allowed in alloweds:\\n grabbed = flask.request.args.get(allowed, None)\\n if grabbed:\\n filters[allowed] = grabbed\\n before_val = flask.request.args.get('before', None)\\n after_val = flask.request.args.get('after', None)\\n try:\\n if before_val is not None:\\n before_val = int(before_val)\\n if after_val is not None:\\n after_val = int(after_val)\\n except ValueError:\\n return tv5api.errors.error(\\n 400,\\n message='If used, \\\"before\\\" and \\\"after\\\" must have integer values.')\\n\\n if before_val is not None and after_val is not None:\\n results = flask.g.db.find(\\n tesserae.db.entities.Text.collection,\\n year_not=(before_val, after_val),\\n **filters)\\n elif before_val is not None and after_val is None:\\n results = flask.g.db.find(\\n tesserae.db.entities.Text.collection,\\n # Assuming that lower limit pre-dates all texts in database\\n year=(-999999999999, before_val),\\n **filters)\\n elif not before_val is None and after_val is not None:\\n results = flask.g.db.find(\\n tesserae.db.entities.Text.collection,\\n # Assuming that upper limit post-dates all texts in database\\n year=(after_val, 999999999999),\\n **filters)\\n else:\\n results = flask.g.db.find(\\n tesserae.db.entities.Text.collection,\\n **filters)\\n return flask.jsonify(texts=[fix_id(r.json_encode()) for r in results])\",\n \"def get_text(downgrade_titles=False):\",\n \"def textdisplay(textTitle, analysis):\\n try:\\n global current_file\\n with Database() as database:\\n text_owner = database.getTextOwner(textTitle, session['username'])\\n app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER + text_owner\\n path = app.config['UPLOAD_FOLDER'] + '/objects/' + textTitle + '.txt'\\n with open(path, 'rb') as f:\\n current_file = pickle.load(f)\\n analysed_texts = current_file.analysed_texts\\n text_facts = current_file.stats\\n keywords = ''\\n for word in text_facts['Key Words']:\\n keywords += word[0] + \\\", \\\"\\n keywords = keywords[:-2]\\n return render_template('textdisplay.html',\\n title=current_file.title,\\n texts=analysed_texts,\\n text=analysed_texts[analysis],\\n facts=text_facts,\\n keywords=keywords,\\n owner=text_owner,\\n user=session['username'])\\n except Exception as e:\\n flash(\\\"Something went wrong, please try again\\\")\\n return redirect(url_for('profile', username=session['username']))\",\n \"def format_textbooks(self, data):\\n textbooks = ', '.join([self.input['textbook%s'%i] for i in range(1,4) if self.input.get('textbook%s'%i)])\\n return textbooks\",\n \"def adjustText(cls, text):\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Adjust dates so to transform strings such as '21 August' to 'August\\n\\t\\t 21' and have them recognized by the SCNLP tools\\\"\\\"\\\"\\n\\t\\tmonths = (u'January|February|March|April|May|June|July'\\n\\t\\t\\t\\t\\t'August|September|October|November|December')\\n\\t\\tdates = re.compile('(?P<day>\\\\d{1,2})\\\\s+(?P<month>%s)(\\\\s+(?P<year>(\\\\d{2,4})))?' % months)\\n\\t\\ttext = dates.sub(cls.normalizeDate, text)\\n\\t\\t# Strip any remaining HTML (WikiExtractor is not perfect)\\n\\t\\thtmlTags = re.compile('<[^>]+>')\\n\\t\\t\\n\\t\\ttext = htmlTags.sub(\\\"\\\", text)\\n\\t\\t\\n\\t\\treturn text\",\n \"def display_search_results(results):\\n\\n new_list = results.split(',')\\n\\n print('Date : {}'.format(new_list[0]))\\n print('Title : {}'.format(new_list[1]))\\n print('Time Spent : {}'.format(new_list[2]))\\n print('Notes : {}'.format(new_list[3]))\\n clear()\",\n \"def search_titles(username):\\n try:\\n with Database() as database:\\n user = database.checkForUser(username)\\n if user == session['username']:\\n if session['username'] == username:\\n session['id'] = database.getID(session['username'])\\n search_string = request.form['title']\\n # Gets texts from db and formats them\\n owned_texts, shared_texts = formatTexts(*database.getUsersTexts(session['id'], search_string))\\n categories = database.loadCategories()\\n return render_template('profile.html',\\n owned_texts=owned_texts,\\n shared_texts=shared_texts,\\n username=username,\\n categories=categories)\\n flash(\\\"You cannot view other users profiles\\\")\\n return redirect(url_for('index'))\\n flash(\\\"User %s not found\\\" % username)\\n return redirect(url_for('index'))\\n except Exception as e:\\n flash(\\\"Something went wrong, please try again\\\")\\n return redirect(url_for('index'))\",\n \"def SearchableText(self):\\n ctool = getToolByName(self, 'portal_cpscalendar')\\n if getattr(ctool, 'event_fulltext_index', False):\\n return '%s %s' % (self.title, self.description)\\n return ''\",\n \"def get_clean_text(text: str) -> str:\\n # Remove Lastname et al. \\\\ Keep group to potentially keep their name only.\\n clean_text = re.sub(r\\\"\\\\(?([A-Za-z]+) et al.(, \\\\(?[0-9]{4}\\\\)?)?\\\", \\\"\\\", text)\\n\\n # Remove \\\"Lastname and Lastname (<year>)\\\"\\n clean_text = re.sub(r\\\"\\\\(?[A-Z][A-Za-z\\\\-]+ and [A-Z][A-Za-z\\\\-]+,? \\\\(?[0-9]{4}\\\\)?\\\", \\\"\\\", clean_text)\\n\\n # TODO: Evaluate if replacing it with \\\"translated\\\" characters would be better?\\n # Remove HTML special characters\\n clean_text = re.sub(r\\\"\\\\&[a-z]{4};\\\", \\\"\\\", clean_text)\\n\\n # Clean up any left over duplicate spaces\\n clean_text = re.sub(r\\\"\\\\s+\\\", \\\" \\\", clean_text)\\n\\n # Remove any non-ascii character from the query, according to\\n # https://stackoverflow.com/a/18430817/3607203\\n clean_text = clean_text.encode(\\\"ascii\\\", errors=\\\"ignore\\\").decode()\\n\\n # Don't mask the special characters here, since solr will take care of it.\\n\\n return clean_text\",\n \"def format_ocr_text(self, page):\\n \\n #read out of the text file that tesseract made\\n ocr_text = open(self.ocr_text, 'r')\\n \\n # write into this file\\n djvu_text = open( self.djvu_text, 'w' )\\n \\n text = \\\"(page 0 0 1 1\\\\n\\\"\\n \\n self.out_text.write('\\\\n## Page %d ###\\\\n\\\\n' % page )\\n \\n for line in ocr_text:\\n \\n #write to the human readable file\\n self.out_text.write(line)\\n \\n # add each line of text\\n # escaping \\\" to \\\\\\\" as we go\\n text += '(line 0 0 1 1 \\\"%s\\\")\\\\n' % line.replace('\\\"', r'\\\\\\\"').strip()\\n \\n text += \\\")\\\\n\\\"\\n \\n djvu_text.write( text )\\n \\n ocr_text.close()\\n djvu_text.close()\",\n \"def format_text(text):\\n\\n\\ttext = ' '.join(text).lower()\\n\\ttext = re.sub(r\\\"[^a-zA-Z.?!]\\\", \\\" \\\", text)\\n\\ttext = re.sub(r' +', ' ', text)\\n\\ttext = word_tokenize(text)\\n\\ttext = pos_tag(text)\\n\\n\\treturn text\",\n \"def process_text(text):\\n text = re.sub(r'<@>\\\\s+|<s>\\\\s+|</s>\\\\s+|<p>\\\\s+|</p>\\\\s+|\\\\s+\\\\,|\\\\'s|\\\\'|\\\\;|\\\\(|\\\\)|\\\\-\\\\-\\\\s+|\\\\s+\\\\.', '', text)\\n text = re.sub(r'\\\\.\\\\,', '. ,', text)\\n text = re.sub(r'\\\\,', '', text)\\n text = re.sub(r'\\\\$', '$ ', text)\\n text = re.sub(r'\\\\%', ' %', text)\\n text = re.sub(r'\\\\s\\\\\\\"\\\\s', ' ', text)\\n text = re.sub(r'\\\\.\\\\s+', '. ', text)\\n text = text.lower()\\n return text\",\n \"def get_as_text(self):\\n d = {\\n 'user': self.user or self.name,\\n 'date': self.submit_date,\\n 'text': self.text,\\n 'domain': self.site.domain,\\n 'url': self.get_absolute_url()\\n }\\n return _('Posted by %(user)s at %(date)s\\\\n\\\\n%(review)s\\\\n\\\\nhttp://%(domain)s%(url)s') % d\",\n \"def get_text(self):\",\n \"def text_report(self):\\n\\n word_count = self.word_count()\\n\\n print(\\\"\\\\nThere are {} words in the text.\\\".format(word_count))\\n mean, median, mode = self.average_word_length()\\n\\n print(\\\"\\\\nMean, median and mode word length is {}, {}, {}.\\\".format(mean, median, mode))\\n\\n if word_count < 10:\\n print(\\\"\\\\nLongest words:\\\")\\n else:\\n print(\\\"\\\\n10 longest words:\\\")\\n for s in self.longest_words():\\n print(s)\\n\\n print(\\\"\\\\nMost common words:\\\")\\n for s in self.common_words():\\n print(\\\"{} x {}\\\".format(s[1], s[0]))\\n\\n longest_grams = []\\n\\n # find n_longest n-grams\\n n_longest = 10\\n # strongly doubt that there will be n-grams longer than 50\\n for i in range(min(50, word_count), 1, -1):\\n if len(longest_grams) >= n_longest:\\n break\\n grams = self.find_ngrams(i)\\n grams_list = sorted(grams, key=grams.get, reverse=True)\\n\\n for g in grams_list:\\n if grams[g] > 4:\\n # do not want to include n-grams which are substrings of longer n-grams\\n substring = False\\n for s in longest_grams:\\n if g in s[1]:\\n substring = True\\n break\\n if not substring:\\n longest_grams.append([grams[g], g])\\n\\n print(\\\"\\\\nLongest n-grams:\\\")\\n for g in longest_grams:\\n print(\\\"{} x {}\\\".format(g[0], g[1]))\\n print('\\\\n')\",\n \"def get_text_cleaned(status):\\r\\n \\r\\n #text = status['text']\\r\\n text = status['full_text']\\r\\n \\r\\n slices = []\\r\\n #Strip out the urls.\\r\\n if 'urls' in status['entities']:\\r\\n for url in status['entities']['urls']:\\r\\n slices += [{'start': url['indices'][0], 'stop': url['indices'][1]}]\\r\\n \\r\\n #Strip out the hashtags.\\r\\n if 'hashtags' in status['entities']:\\r\\n for tag in status['entities']['hashtags']:\\r\\n slices += [{'start': tag['indices'][0], 'stop': tag['indices'][1]}]\\r\\n \\r\\n #Strip out the user mentions.\\r\\n if 'user_mentions' in status['entities']:\\r\\n for men in status['entities']['user_mentions']:\\r\\n slices += [{'start': men['indices'][0], 'stop': men['indices'][1]}]\\r\\n \\r\\n #Strip out the media.\\r\\n if 'media' in status['entities']:\\r\\n for med in status['entities']['media']:\\r\\n slices += [{'start': med['indices'][0], 'stop': med['indices'][1]}]\\r\\n \\r\\n #Strip out the symbols.\\r\\n if 'symbols' in status['entities']:\\r\\n for sym in status['entities']['symbols']:\\r\\n slices += [{'start': sym['indices'][0], 'stop': sym['indices'][1]}]\\r\\n \\r\\n # Sort the slices from highest start to lowest.\\r\\n slices = sorted(slices, key=lambda x: -x['start'])\\r\\n \\r\\n #No offsets, since we're sorted from highest to lowest.\\r\\n for s in slices:\\r\\n text = text[:s['start']] + text[s['stop']:]\\r\\n \\r\\n return text\",\n \"def _compute_fulltext(self):\\n return ''\",\n \"def text_json(request):\\n query = str()\\n\\n if request.method == 'GET':\\n query = request.GET.get('q')\\n\\n results = list()\\n\\n for c in search.tokenSearch(query):\\n tmp = {'category':'課程代號','title':c.token}\\n results.append(tmp)\\n \\n for c in search.zhNameSearch(query):\\n tmp = {'category':'課程名稱','title':c.name_zh}\\n results.append(tmp)\\n\\n \\n for c in search.engNameSearch(query):\\n tmp = {'category':'Course Name','title':c.name_eng}\\n results.append(tmp)\\n \\n for t in Teacher.objects.filter(name_zh__icontains=query):\\n tmp = {'category':'老師','title':t.name_zh}\\n results.append(tmp)\\n \\n for d in Department.objects.filter(name_zh__icontains=query):\\n tmp = {'category':'開課單位','title':d.name_zh}\\n results.append(tmp)\\n\\n tmp = {'results':results}\\n\\n return HttpResponse(json.dumps(tmp))\",\n \"def handleFormatText(paragraphContent):\\n # We tokenize and remove the stop word\\n words = tokenizeWord(paragraphContent) \\n \\n stemWords = []\\n # We loop on each word.\\n for word in words:\\n stemWord = STEMMER.stem(word)\\n \\n # Selection on a part of string.\\n stemWord = re.sub(\\\"[*\\\\'\\\\.+:,\\\\`:/]\\\", '', stemWord)\\n if stemWord.isdigit() or len(stemWord) < 2:\\n continue\\n \\n stemWords.append(stemWord)\\n my_r_string = stemWords.pop(0)\\n for word in stemWords:\\n my_r_string += \\\" \\\"+str(word)\\n return my_r_string\",\n \"def search_values(username):\\n try:\\n with Database() as database:\\n user = database.checkForUser(username)\\n if user == session['username']:\\n if session['username'] == username:\\n features = [\\\"Alliteration\\\", \\\"Antithesis\\\", \\\"Juxtaposition\\\"]\\n needs_feature = {}\\n for feature in features:\\n if request.form.get(feature) == \\\"on\\\":\\n needs_feature[feature] = 1\\n else:\\n needs_feature[feature] = 0\\n extra_query = \\\";\\\"\\n for feature, has in needs_feature.items():\\n if has == 1:\\n extra = \\\"AND Text.\\\" + feature + \\\" = 1 \\\"\\n extra_query = extra + extra_query\\n sentiment_above = float(request.form[\\\"SSA\\\"])\\n sentiment_below = float(request.form[\\\"SSB\\\"])\\n reading_age_above = float(request.form[\\\"RAS\\\"])\\n if sentiment_above >= sentiment_below:\\n flash(\\\"Invalid Search...\\\")\\n return redirect(request.referrer)\\n data = [session['id'], reading_age_above,\\n sentiment_above, sentiment_below]\\n owned_texts, shared_texts = formatTexts(*database.searchTexts(data, extra_query))\\n categories = database.loadCategories()\\n return render_template('profile.html',\\n owned_texts=owned_texts,\\n shared_texts=shared_texts,\\n username=username,\\n categories=categories)\\n flash(\\\"You cannot view other users profiles\\\")\\n return redirect(url_for('index'))\\n flash(\\\"User %s not found\\\" % username)\\n return redirect(url_for('index'))\\n except Exception as e:\\n flash(\\\"Something went wrong, please try again\\\")\\n return redirect(url_for('index'))\",\n \"def formatOutput(self, storedText, titleMode, internal=False):\\n prefix = self.prefix\\n suffix = self.suffix\\n if titleMode:\\n if self.html:\\n storedText = self.removeMarkup(storedText)\\n if globalref.docRef.formHtml:\\n prefix = self.removeMarkup(prefix)\\n suffix = self.removeMarkup(suffix)\\n else:\\n if not self.html:\\n storedText = escape(storedText).replace('\\\\n', '<br />')\\n if not globalref.docRef.formHtml:\\n prefix = escape(prefix)\\n suffix = escape(suffix)\\n return u'%s%s%s' % (prefix, storedText, suffix)\",\n \"def raw_text(self):\\n\\t\\t\\n\\t\\t #eliminating more headers\\n\\t\\traw_text = re.sub(r\\\".*OPERATIONS O[PF].*\\\",r\\\"\\\",self.doc)\\n\\t\\traw_text = re.sub(r\\\"Page \\\\d+\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\".*B[lL]OCK.*\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\".*WEST GULF.*\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\".*NAVAL FORCES ON.*\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\"\\\\s\\\",r\\\" \\\", raw_text) #eliminating tabs etc. \\t \\t \\n\\t\\treturn raw_text\",\n \"def formatOutput(self, storedText, titleMode, altText='', internal=False):\\n if titleMode:\\n return TextFormat.formatOutput(self, storedText, titleMode,\\n internal)\\n paths = storedText.split('\\\\n')\\n results = []\\n for url in paths:\\n path = url\\n if not URLFormat.hasMethodRe.match(path):\\n path = u'%s%s' % (self.URLMethod, path)\\n path = u'<a href=\\\"%s\\\">%s</a>' % (escape(path, treedoc.escDict),\\n altText or url)\\n results.append(TextFormat.formatOutput(self, path, titleMode,\\n internal))\\n return u'<br />'.join(results)\",\n \"def formatOutput(self, storedText, titleMode, internal=False):\\n if titleMode:\\n return TextFormat.formatOutput(self, storedText, titleMode,\\n internal)\\n paths = storedText.split('\\\\n')\\n results = ['<img src=\\\"%s\\\">' % escape(url, treedoc.escDict) for url\\n in paths]\\n return u'<br />'.join(results)\",\n \"def __filter( self, text ):\\n return text\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def compute_full_text(row):\\n full_text = row['full_text']\\n # If needed, reconstruct the full tweet text from the original text, leaving the retweet header intact.\\n if full_text.startswith('RT @') and full_text.endswith('\\\\u2026') and not pd.isnull(row['retweeted_status']):\\n text_header = PTN_rt.search(row['full_text']).group()\\n retweet_series = pd.read_json(json.dumps(row['retweeted_status']), typ='series')\\n full_text = f'{text_header}{retweet_series[\\\"full_text\\\"]}'\\n return clean_text(full_text)\",\n \"def reformat_text(self, text):\\n xml = BeautifulSoup(text)\\n self.remove_header_and_footer(xml)\\n self.process_superscripts(xml)\\n self.remove_footnotes(xml)\\n text = xml.get_text() # Strip XML tags.\\n text = self.join_hyphenated_words(text)\\n text = self.remove_linebreaks(text)\\n return text\",\n \"def get_parse_filter_text(conversation: Conversation):\\n parse_op = gen_parse_op_text(conversation)\\n if len(parse_op) > 0:\\n intro_text = f\\\"For the data with <b>{parse_op}</b>,\\\"\\n else:\\n intro_text = \\\"For <b>all</b> the instances in the data,\\\"\\n return intro_text\",\n \"def rich(text):\\n return full(text, False)\",\n \"def _format_output(**values):\\r\\n return WEATHER_TEXT.format(**values)\",\n \"def format_text(text):\\n text = text.replace('to do ', '') \\\\\\n .replace('to ', '') \\\\\\n .replace(' at ', ' on ') \\\\\\n .replace(' a ', ' 1 ') \\\\\\n .replace(' an ', ' 1 ') \\\\\\n .replace('minutes', '60') \\\\\\n .replace('minute', '60') \\\\\\n .replace('seconds', '1') \\\\\\n .replace('second', '1') \\\\\\n .replace('hours', '3600') \\\\\\n .replace('hour', '3600')\\n text = text.split(' ')\\n pure_text = \\\"\\\"\\n if text[-3] == 'in':\\n for i in range(0, (len(text)-3)):\\n pure_text += \\\" \\\" + text[i]\\n final_text = [pure_text, text[-3], text[-2], text[-1]]\\n else:\\n for i in range(0, (len(text)-2)):\\n pure_text += text[i]\\n final_text = [pure_text, text[-2], text[-1]]\\n if len(text) < 3:\\n pprint(final_text)\\n raise Exception(\\\"Bad remind request\\\")\\n\\n return final_text\",\n \"def get_stats_texts(proj, action_type):\\n first = _(\\\"(nog) geen\\\")\\n if action_type == 'userwijz':\\n all_objects = my.Userwijz.objects.filter(project=proj)\\n second = _('ingediend')\\n hlp = _(\\\"gerealiseerd\\\"), _('in behandeling via')\\n elif action_type == 'probleem':\\n all_objects = my.Userprob.objects.filter(project=proj)\\n second = _(\\\"gemeld\\\")\\n hlp = _('opgelost'), _('doorgekoppeld naar')\\n elif action_type == 'bevinding':\\n all_objects = my.Bevinding.objects.filter(project=proj)\\n second = _(\\\"opgevoerd\\\")\\n hlp = _('opgelost'), _('doorgekoppeld naar')\\n else:\\n return '', ''\\n solved = all_objects.filter(gereed=True).count()\\n working = all_objects.filter(gereed=False).filter(actie__isnull=False).count()\\n if all_objects.count() != 0:\\n first = all_objects.count()\\n second = str(_(\\\"waarvan {} {} en {} {} Actiereg\\\").format(solved, hlp[0], working, hlp[1]))\\n return first, second\",\n \"def format_rich_text(rich_text_section):\\n formatted_text = \\\"\\\"\\n\\n for elem in rich_text_section.get(\\\"elements\\\", []):\\n elem_type = elem.get(\\\"type\\\")\\n if elem_type == \\\"broadcast\\\":\\n # Convert broadcasts to Discord-friendly pings:\\n broadcast_range = elem.get(\\\"range\\\")\\n if broadcast_range == \\\"channel\\\":\\n elem_text = \\\"@everyone\\\"\\n elif broadcast_range == \\\"here\\\":\\n elem_text = \\\"@here\\\"\\n elif elem_type == \\\"emoji\\\":\\n emoji_list = app.client.emoji_list().get(\\\"emoji\\\", {})\\n if emoji_list.get(elem.get(\\\"name\\\")):\\n elem_text = f\\\":{elem.get('name')}:\\\"\\n else:\\n print(f\\\"Skipping over nonstandard emoji {elem.get('name', 'NO NAME')}\\\")\\n continue\\n elif elem_type == \\\"user\\\":\\n # Convert @{user ID} to @{user name}:\\n user_info = app.client.users_info(\\n user=elem.get(\\\"user_id\\\")\\n ).get(\\\"user\\\", {})\\n user_name = user_info.get(\\\"profile\\\", {}).get(\\\"display_name\\\")\\n if not user_name:\\n # If user has no display_name (is a bot), use real_name:\\n user_name = user_info.get(\\\"real_name\\\")\\n if not user_name:\\n # If user has no name, skip mention altogether:\\n print(\\\"Skipping over user mention with no associated name.\\\")\\n continue\\n elem_text = f\\\"@{user_name}\\\"\\n else:\\n elem_text = elem.get(\\\"text\\\", \\\"\\\")\\n \\n style = elem.get(\\\"style\\\", {})\\n\\n # Prevent plain text from being rendered as markup:\\n # (Code blocks by default have no markup)\\n if not style.get(\\\"code\\\"):\\n elem_text = elem_text.replace(\\\"_\\\", \\\"\\\\_\\\")\\n elem_text = elem_text.replace(\\\"*\\\", \\\"\\\\*\\\")\\n elem_text = elem_text.replace(\\\"`\\\", \\\"\\\\`\\\")\\n elem_text = elem_text.replace(\\\">\\\", \\\"\\\\>\\\")\\n\\n # Apply appropriate styles to element's text:\\n if style.get(\\\"bold\\\") or elem_type == \\\"user\\\":\\n elem_text = f\\\"**{elem_text}**\\\"\\n if style.get(\\\"italic\\\"):\\n elem_text = f\\\"*{elem_text}*\\\"\\n if style.get(\\\"strike\\\"):\\n elem_text = f\\\"~~{elem_text}~~\\\"\\n if style.get(\\\"code\\\"):\\n elem_text = f\\\"`{elem_text}`\\\"\\n\\n # If element is a link, add the URL in Discord-friendly format:\\n # \\\"[ hyperlink text ]( URL )\\\"\\n if elem_type == \\\"link\\\":\\n elem_text = f\\\"[{elem_text}]({elem.get('url')})\\\"\\n\\n # add formatted element's text to final markup string:\\n formatted_text += elem_text\\n\\n # return final markup string:\\n return formatted_text\",\n \"def search():\\n args = request.args.to_dict()\\n query = QueryModel(args)\\n result = repository.search_text(COLLECTION_NAME, query.value)\\n return {\\\"texts\\\": result}\",\n \"def market_search_formatter(search_results):\\n headers = [\\\"id\\\", \\\"Details\\\", \\\"Creator\\\", \\\"Price\\\", \\\"Category\\\", \\\"Rating\\\"]\\n rows = []\\n for _, item in enumerate(search_results):\\n if item[\\\"min_price\\\"] != item[\\\"max_price\\\"]:\\n price_range = click.style(\\\"Variable\\\", fg=\\\"blue\\\")\\n else:\\n price_range = click.style(\\\"{} Satoshis\\\".format(item[\\\"min_price\\\"]),\\n fg=\\\"blue\\\")\\n category = click.style(\\\"{}\\\".format(item[\\\"category\\\"]), fg=\\\"blue\\\")\\n creator = click.style(\\\"{}\\\".format(item[\\\"username\\\"]), fg=\\\"blue\\\")\\n title = click.style(item[\\\"title\\\"], fg=\\\"blue\\\")\\n rating = \\\"Not yet rated\\\"\\n if item[\\\"rating_count\\\"] != 0:\\n rating = \\\"{:.1f} ({} rating\\\".format(item[\\\"average_rating\\\"], int(item[\\\"rating_count\\\"]))\\n if item[\\\"rating_count\\\"] > 1:\\n rating += \\\"s\\\"\\n rating += \\\")\\\"\\n rating = click.style(rating, fg=\\\"blue\\\")\\n rows.append([item[\\\"id\\\"], title, creator, price_range, category, rating])\\n for _, l in enumerate(wrap(item[\\\"description\\\"])):\\n rows.append([\\\"\\\", l, \\\"\\\", \\\"\\\", \\\"\\\", \\\"\\\"])\\n rows.append([\\\"\\\", \\\"\\\", \\\"\\\", \\\"\\\", \\\"\\\", \\\"\\\"])\\n\\n return tabulate(rows, headers=headers, tablefmt=\\\"simple\\\")\",\n \"def formatEditText(self, storedText):\\n return (storedText, True)\",\n \"def formatEditText(self, storedText):\\n return (storedText, True)\",\n \"def get_text(data):\\n return \\\" \\\".join([item[\\\"words\\\"] for item in data])\",\n \"def _html(self, text):\\r\\n html = URL_REGEX.sub(self._parse_urls, text)\\r\\n html = USERNAME_REGEX.sub(self._parse_users, html)\\r\\n html = LIST_REGEX.sub(self._parse_lists, html)\\r\\n return HASHTAG_REGEX.sub(self._parse_tags, html)\",\n \"def formatOutput(self, storedText, titleMode, internal=False):\\n choices, valid = self.sortedChoices(storedText)\\n if valid:\\n result = self.sep.join(choices)\\n else:\\n result = _errorStr\\n return TextFormat.formatOutput(self, result, titleMode, internal)\",\n \"def english2summary_name(english_query: str, use_cache: bool = True) -> str:\\n\\n prompt = '''Q: Show me all of the users\\nQ: Show me all the users ordered by age ascending\\nA: get all users ordered by age ascending\\nQ: Who is the oldest user?\\nA: get oldest user\\nQ: What are the names of the 10 youngest users?\\nA: get ten youngest users\\nQ: Who is the oldest person?\\nA: get oldest user\\nQ: get all the users that are located in the United Kingdom\\nA: get users from united kingdom\\nQ: get users of ages between 30 and 40?\\nA: get users ages between 30 and 40\\nQ: How many users are there?\\nA: get number users\\nQ: Where does user Betty live?\\nA: get betty location\\nQ: What is Jennifer's age?\\nA: get jennifer age\\nQ: the average age\\nA: get average user age\\nQ: the age of the oldest user\\nA: get age of oldest user\\nQ: the name of the oldest person\\nA: get name of oldest user\\nQ: the top 10 oldest users\\nA: get ten oldest users\\nQ: how many admin users are there?\\nA: get number admin users\\nQ: retrieve the email of the youngest admin\\nA: get email of youngest admin user\\nQ: get a user by their email\\nA: get user by email\\nQ: get all users' emails that live at a certain location\\nA: get users by location\\nQ: '''\\n\\n prompt += english_query.strip()\\n prompt += '\\\\nA:'\\n\\n def valid_char(c: str) -> bool:\\n return c.isalnum() or c == ' ' or c == '_'\\n\\n result = cached_gpt3(prompt, use_cache=use_cache)\\n result = ''.join(c for c in result if valid_char(c))\\n while len(result) > 0 and result[0].isnumeric():\\n result = result[1:]\\n if len(result) == 0:\\n result = 'untitled'\\n return '_'.join(result.strip().lower().split(' '))\",\n \"def standardize_text(df: pd.DataFrame,\\r\\n text_field: str,\\r\\n output_field: str) -> pd.DataFrame:\\r\\n\\r\\n # df[output_field] = df[text_field].apply(\\r\\n # lambda column: emoji.get_emoji_regexp().sub(u'', column)\\r\\n # )\\r\\n\\r\\n df[output_field] = df[text_field].str.replace(\\\"'m\\\", ' am')\\r\\n df[output_field] = df[output_field].str.replace(\\\"’m\\\", ' am')\\r\\n df[output_field] = df[output_field].str.replace(\\\"´m\\\", ' am')\\r\\n\\r\\n df[output_field] = df[output_field].str.replace(\\\"'ve\\\", ' have')\\r\\n df[output_field] = df[output_field].str.replace(\\\"’ve\\\", ' have')\\r\\n df[output_field] = df[output_field].str.replace(\\\"´ve\\\", ' have')\\r\\n\\r\\n df[output_field] = df[output_field].str.replace(\\\"'d\\\", ' would')\\r\\n df[output_field] = df[output_field].str.replace(\\\"’d\\\", ' would')\\r\\n df[output_field] = df[output_field].str.replace(\\\"´d\\\", ' would')\\r\\n\\r\\n df[output_field] = df[output_field].str.replace(\\\"n't\\\", ' not')\\r\\n df[output_field] = df[output_field].str.replace(\\\"n’t\\\", ' not')\\r\\n df[output_field] = df[output_field].str.replace(\\\"n´t\\\", ' not')\\r\\n\\r\\n df[output_field] = df[output_field].str.replace(\\\"'ll\\\", ' will')\\r\\n df[output_field] = df[output_field].str.replace(\\\"’ll\\\", ' will')\\r\\n df[output_field] = df[output_field].str.replace(\\\"´ll\\\", ' will')\\r\\n\\r\\n df[output_field] = df[output_field].str.replace(\\\"'s\\\", ' is')\\r\\n df[output_field] = df[output_field].str.replace(\\\"’\\\", ' is')\\r\\n df[output_field] = df[output_field].str.replace(\\\"´s\\\", ' is')\\r\\n\\r\\n df[output_field] = df[output_field].str.replace('/', ' ')\\r\\n df[output_field] = df[output_field].str.replace('\\\\.{2,}', '.')\\r\\n df[output_field] = df[output_field].str.replace('!{2,}', '!')\\r\\n df[output_field] = df[output_field].str.replace('\\\\?{2,}', '?')\\r\\n df[output_field] = df[output_field].str.replace('€+', '')\\r\\n df[output_field] = df[output_field].str.replace('[0-9$&~\\\\\\\\()[\\\\]{}<>%\\\\'\\\"“”‘’，;…+\\\\-_=*]+', '')\\r\\n df[output_field] = df[output_field].str.replace(r'http\\\\S+', '')\\r\\n df[output_field] = df[output_field].str.replace(r'http', '')\\r\\n df[output_field] = df[output_field].str.replace(r'@\\\\S+', '')\\r\\n df[output_field] = df[output_field].str.replace(r'@', 'at')\\r\\n df[output_field] = df[output_field].str.lower()\\r\\n df[output_field] = df[output_field].astype(str)\\r\\n\\r\\n return df\",\n \"def get_text(self, caller):\\n \\n if caller == \\\"txt_search\\\":\\n search_text = self.builder.get_object(\\\"txt_search\\\").get_text()\\n return search_text\\n elif caller == \\\"txt_tweet\\\":\\n tweet_text = self.builder.get_object(\\\"txt_tweet\\\").get_text() \\n return tweet_text\",\n \"def process_text(self, text, language):\",\n \"def score_display():\\n data = score_reader()\\n for index, datum in enumerate(data):\\n score_format = \\\"%s ...... %s/%s\\\" % (datum[0].capitalize(), datum[1], datum[2])\\n print(score_format)\",\n \"def post_get_convert(self, site, getText):\\n return getText\",\n \"def format_item_display(self, obj):\\n return u\\\"%s - %s\\\" % (escape(obj.nombre),obj.rfc)\",\n \"def PROPER(text):\\n return text.title()\",\n \"def user_list(request):\\r\\n query = request.GET.get('q', '')\\r\\n # if query has 2 or more characters\\r\\n if len(query) >= 2:\\r\\n names = query.split(' ')\\r\\n # if query has a first and last name\\r\\n if len(names) == 2:\\r\\n first, last = names\\r\\n # if first and last name have 2 or more letters\\r\\n if len(first) >= 2 and len(last) >= 2:\\r\\n results = User.objects.filter(Q(\\r\\n first_name__icontains=first, \\r\\n last_name__icontains=last) | Q(first_name__icontains=last, \\r\\n last_name__icontains=first)).exclude(pk=request.user.pk)\\r\\n # if first name has 2 or more letters\\r\\n elif len(first) >= 2:\\r\\n results = User.objects.filter(Q(\\r\\n first_name__icontains=first) | Q(\\r\\n last_name__icontains=first)).exclude(pk=request.user.pk)\\r\\n # if last name has 2 or more letters\\r\\n elif len(last) >= 2:\\r\\n results = User.objects.filter(Q(\\r\\n first_name__icontains=last) | Q(\\r\\n last_name__icontains=last)).exclude(pk=request.user.pk)\\r\\n # if first and last name have less than 2 letters\\r\\n else:\\r\\n results = []\\r\\n # if query only has one name\\r\\n else:\\r\\n results = User.objects.filter(Q(\\r\\n username__icontains=query)).exclude(pk=request.user.pk)\\r\\n # if query has less than 2 letters\\r\\n else:\\r\\n results = []\\r\\n d = {\\r\\n 'results': results,\\r\\n }\\r\\n t = loader.get_template('usermessages/results.html')\\r\\n context = Context(d)\\r\\n data = {\\r\\n 'results': t.render(context),\\r\\n }\\r\\n return HttpResponse(json.dumps(data), mimetype='application/json')\",\n \"def clean_user_desc(self):\\n desc = self.data['user']['description']\\n if desc is not None:\\n desc = ' '.join(re.sub(\\\"(RT : )|(@[\\\\S]+)|(&\\\\S+)|(http\\\\S+)\\\", \\\" \\\", desc).split())\\n desc = \\\" \\\".join(re.sub(\\\"(#\\\\S+)\\\", ' ', desc).split())\\n desc = ''.join(list(filter(lambda x: x.isalpha() or x is ' ',\\n desc))).replace(' ', ' ').replace(' ', ' ').lower().strip()\\n return {'plain_desc': desc}\",\n \"def get_full_text(self, item):\\n text_content = self.db.plugin_text_text(item_id=item.unique_id)\\n output = self.response.render(\\n 'plugin_text/full_text.txt',\\n dict(text_content=text_content, item=item))\\n return unicode(output.decode('utf-8'))\",\n \"def search_keywords(username):\\n try:\\n with Database() as database:\\n user = database.checkForUser(username)\\n if user == session['username']:\\n if session['username'] == username:\\n session['id'] = database.getID(session['username'])\\n search_string = request.form['keyword']\\n # Gets the graph from a file\\n with open(\\\"word_graph.txt\\\", \\\"rb\\\") as f:\\n G = pickle.load(f)\\n owned_texts = []\\n shared_texts = []\\n if search_string in G.nodes:\\n # Gets all nodes that are connected to your current word\\n keywords = dijsktra(G, search_string)\\n owned_texts = []\\n shared_texts = []\\n owned_titles = []\\n for keyword, score in keywords.items():\\n owned, shared = database.searchKeyword(keyword, session['id'])\\n to_format_owned = []\\n to_format_shared = []\\n # Checks the text has not already been loaded\\n for text in owned:\\n if text[0] not in owned_titles:\\n to_format_owned.append(text)\\n owned_titles.append(text[0])\\n for text in shared:\\n if text[0] not in shared_titles:\\n to_format_shared.append(text)\\n shared_titles.append(text[0])\\n owned, shared = formatTexts(to_format_owned, to_format_shared)\\n owned_texts += owned\\n shared_texts += shared\\n # Makes sure there is only one false statement in array\\n owned_texts = [text for text in owned_texts if text is not False]\\n if len(owned_texts) == 0:\\n owned_texts.append(False)\\n shared_texts = [text for text in shared_texts if text is not False]\\n if len(shared_texts) == 0:\\n shared_texts.append(False)\\n categories = database.loadCategories()\\n return render_template('profile.html',\\n owned_texts=owned_texts,\\n shared_texts=shared_texts,\\n username=username,\\n categories=categories)\\n else:\\n flash(\\\"Keyword not found\\\")\\n return redirect(request.referrer)\\n flash(\\\"You cannot view other users profiles\\\")\\n return redirect(url_for('index'))\\n flash(\\\"User %s not found\\\" % username)\\n return redirect(url_for('index'))\\n except Exception as e:\\n flash(\\\"Something went wrong, please try again\\\")\\n return redirect(url_for('index'))\",\n \"def make_haystack(self):\\n journal_data = [\\\" \\\".join(self.format_authors(style=\\\"full\\\")),\\n self.journal_long,\\n self.journal_short,\\n \\\"\\\".join(c for c in self.journal_short if c.isupper()),\\n self.title]\\n return [unidecode(data) for data in journal_data]\",\n \"def _text_formatting(bs4_tag):\\n return bs4_tag.get_text().replace('\\\\n', '')\",\n \"def format_query_for_displaying(query):\\n keys = query.keys()\\n result = ''\\n for k in keys:\\n v = query[k]\\n print(\\\"Checking v=%r and k=%r\\\" % (v, k))\\n result += '[%s] ' % k\\n if v and type(v) == dict:\\n kk = v.keys()\\n r = ''\\n for l in kk:\\n m = v[l]\\n r += str(m)\\n r += ' '\\n result += r\\n else:\\n print(\\\"result: [%s] v:[%s]\\\" % (result, str(v)))\\n result += str(v)\\n result += '\\\\n'\\n if result == '':\\n result = 'JUST VISITED THE SEARCH PAGE.'\\n return result\",\n \"def search(request, template_name='congregation/search_results.html'):\\n context = {}\\n if request.GET:\\n stop_word_list = re.compile(STOP_WORDS, re.IGNORECASE)\\n search_term = '%s' % request.GET['findperson']\\n cleaned_search_term = stop_word_list.sub('', search_term)\\n cleaned_search_term = cleaned_search_term.strip()\\n terms = cleaned_search_term.split(' ')\\n if len(cleaned_search_term) != 0:\\n people_list = Person.objects.filter(\\n Q(first_name__icontains=cleaned_search_term) | \\n Q(last_name__icontains=cleaned_search_term) | \\n Q(preferred_first_name__icontains=cleaned_search_term) \\n )\\n if len(people_list) < 1:\\n people_list = Person.objects.filter(\\n Q(first_name__iregex=r'(' + '|'.join(terms) + ')') | Q(preferred_first_name__iregex=r'(' + '|'.join(terms) + ')')\\n ).filter(last_name__iregex=r'(' + '|'.join(terms) + ')')\\n if len(people_list)<1:\\n message = 'no match found for '\\n else:\\n message = 'matches found for '\\n else:\\n message = 'matches found for '\\n\\n people_list = people_list.exclude(deceased__isnull=False).exclude(active=False).exclude(opt_in_directory=False)\\n context = {'object_list': people_list, 'message': message, 'search_term':search_term, }\\n else:\\n message = 'Search term was too vague. Please try again.'\\n context = {'message':message}\\n return render_to_response(template_name, context, context_instance=RequestContext(request))\",\n \"def get_text(self):\\n text_complet = \\\"\\\"\\n rez_dict = self.__results\\n for i in range(0, len(rez_dict[\\\"text\\\"])):\\n text = rez_dict[\\\"text\\\"][i]\\n conf = int(rez_dict[\\\"conf\\\"][i])\\n if conf > self.__min_confidence:\\n text_complet += text + \\\" \\\"\\n return text_complet\",\n \"def search_results(self, results):\\n for index, item in enumerate(results):\\n print '[%s] %s (%s) {%s}' % (\\n index, \\n self._color(item.title), \\n self._color(item.year, 'RED'), \\n self._color(item.imdbid, 'GREEN'))\",\n \"def highlight(search_me, word, userid):\\n if db_is_loggedin.find_one({\\\"user\\\": userid}).get(\\\"is_loggedin\\\") == True:\\n word = word.strip()\\n results = wisdomaiengine.highlighter(word)\\n search_term = db_search_terms.find_one({\\\"value\\\": search_me.lower()})\\n search_id = search_term.get(\\\"_id\\\")\\n data = {\\\"user\\\": userid,\\n \\\"search_id\\\": search_id,\\n \\\"highlighted_word\\\": word,\\n \\\"results\\\": results,\\n \\\"date_saved\\\": datetime.utcnow()}\\n x = db_highlights.insert(data, check_keys=False)\\n jsonob = jsonify(results=results)\\n return jsonob\\n else:\\n msg = {\\\"status\\\" : { \\\"type\\\" : \\\"fail\\\" , \\\"message\\\" : \\\"Please log in\\\"}}\\n return jsonify(msg)\",\n \"def search_command():\\n listing.delete(0, END)\\n for row in backend.search(title_text.get(), \\n author_text.get(), \\n year_text.get(), \\n isbn_text.get()):\\n listing.insert(END, row)\",\n \"def internetSearch(userInput):\\n try:\\n result = \\\"\\\"\\n content = userInput.split(\\\" \\\")\\n tmp = content.copy()\\n for word in badsearchDb:\\n if word in content:\\n tmp.remove(word)\\n content = \\\" \\\".join(tmp)\\n result = \\\"\\\\n: \\\"+content\\n try:\\n info = str(wikipedia.summary(content, sentences=5))\\n except wikipedia.exceptions.DisambiguationError as e:\\n return \\\"... \\\\nCan you please be less ambiguous?\\\"\\n except wikipedia.exceptions.PageError as e:\\n return \\\"... \\\\n So I was checking on wikipedia, and their page crashed.\\\"\\n result += \\\"... \\\\nFound: \\\"+info[:200]\\n return str(result)\\n except Exception as e:\\n return \\\"Failed \\\" + e # interconnection problems e.g.?\",\n \"def extract_text(self, categories, entries):\\n text = \\\" \\\".join(\\n [\\n self.podcast.title,\\n self.podcast.description,\\n self.podcast.keywords,\\n self.podcast.authors,\\n ]\\n + [c.name for c in categories]\\n + [e[\\\"title\\\"] for e in entries][:6]\\n )\\n return \\\" \\\".join([kw for kw in extract_keywords(self.podcast.language, text)])\",\n \"def profile(userid):\\n # get bookmarked content\\n bookmarks = db_bookmarks.find({\\\"user\\\": userid})\\n bookmarks = [{\\\"search_term\\\": db_search_terms.find_one({\\\"_id\\\": b[\\\"search_id\\\"]}).get(\\\"value\\\"), \\\"source\\\": b[\\\"source\\\"], \\\"url\\\": b[\\\"url\\\"], \\\"date_saved\\\": b[\\\"date_saved\\\"].strftime(\\\"%H:%M %B %d, %Y\\\")} for b in bookmarks]\\n # get previous searches\\n searches = db_searches.find({\\\"user\\\": userid})\\n searches = [{\\\"search_term\\\": db_search_terms.find_one({\\\"_id\\\": s[\\\"search_id\\\"]}).get(\\\"value\\\"), \\\"category\\\": s[\\\"category\\\"], \\\"datetime\\\": s[\\\"datetime\\\"].strftime(\\\"%H:%M %B %d, %Y\\\")} for s in searches]\\n # get byod\\n byod = db_byod.find({\\\"user\\\": userid})\\n byod = [{\\\"content_type\\\": b[\\\"content_type\\\"], \\\"doc_name\\\": b[\\\"doc_name\\\"], \\\"text\\\": b[\\\"text\\\"], \\\"key_points\\\": b[\\\"key_points\\\"], \\\"datetime_uploaded\\\": b[\\\"datetime_uploaded\\\"].strftime(\\\"%H:%M %B %d, %Y\\\")} for b in byod]\\n # get highlightds\\n # highlights = db_highlights.find({\\\"user\\\": userid})\\n # highlights = [{\\\"search_term\\\": db_search_terms.find_one({\\\"_id\\\": h[\\\"search_id\\\"]}).get(\\\"value\\\"), \\\"highlighted_word\\\": h[\\\"highlighted_word\\\"], \\\"results\\\": h[\\\"results\\\"], \\\"date_saved\\\": h[\\\"date_saved\\\"].strftime(\\\"%H:%M %B %d, %Y\\\")} for h in highlights]\\n jsonob = jsonify(bookmarks=bookmarks,\\n searches=searches,\\n byod=byod)\\n return jsonob\",\n \"def update_text(self):\\n\\n def update_by_filter(all_text, widget, text_filters):\\n new_text = \\\"\\\\n\\\".join([line for line in all_text.split(\\\"\\\\n\\\") if any(s in line for s in text_filters)])\\n widget.setPlainText(new_text)\\n widget.verticalScrollBar().setValue(widget.verticalScrollBar().maximum())\\n\\n with open(self.log_file, \\\"r\\\", encoding='utf-8') as log_file:\\n text = log_file.read()\\n text_len = len(text)\\n if text_len > self._old_txt_len:\\n self._old_txt_len = text_len\\n self.all_widget.setPlainText(text)\\n self.all_widget.verticalScrollBar().setValue(self.all_widget.verticalScrollBar().maximum())\\n update_by_filter(all_text=text, widget=self.info_widget, text_filters=(\\\"- INFO - \\\",))\\n update_by_filter(all_text=text, widget=self.error_widget, text_filters=(\\\"- ERROR - \\\", \\\"- WARNING -\\\"))\",\n \"def findText(self):\\n\\n # Prompts user for find regex\\n findText,_ = Model.FindAndReplaceDialogBox.getResults(self)\\n model = self.getCurrentPanda()\\n start = model.index(0, 0)\\n matches = model.match(\\n start, QtCore.Qt.DisplayRole,\\n findText, -1, QtCore.Qt.MatchContains)\\n if matches:\\n index = matches[0]\\n self.getCurrentView().clearSelection()\\n self.getCurrentView().selectionModel().select(\\n index, QtCore.QItemSelectionModel.Select)\\n self.getCurrentView().scrollTo(index)\\n else:\\n self.notifyUser(\\\"No matches found.\\\")\",\n \"def return_user_text(self, id_user:int) -> str:\\n try:\\n name_default = self.cursor.execute(f\\\"SELECT text_sending FROM {table_users_settings} WHERE id_user={id_user};\\\").fetchone()\\n if not name_default:\\n self.insert_settings(id_user)\\n return self.return_user_text(id_user)\\n return name_default[0]\\n except Exception as e:\\n msg = f\\\"We faced problems with return default text. Mistake: {e}\\\"\\n self.proceed_error(msg)\\n return entrance_bot_usage\",\n \"def _transform_search_database(self):\\n # TODO: Create this and link with protein object when fasta file is provided\\n return {\\n \\\"file_format\\\": \\\"fasta format\\\",\\n \\\"name\\\": \\\"\\\",\\n \\\"id\\\": 1,\\n \\\"location\\\": \\\"\\\",\\n \\\"params\\\": [],\\n }\",\n \"def text(self):\\n parts = [(\\\"%s\\\" if isinstance(p, Insert) else p) for p in self.parts]\\n parts = [(\\\"%%\\\" if p == \\\"%\\\" else p) for p in parts] # escape percent\\n return \\\"\\\".join(parts)\",\n \"def format_item_display(self, item):\\r\\n return u\\\"<span class='tag'>%s</span>\\\" % item.filter\",\n \"def search_people_2(search_type, search_value):\\n try:\\n # Search Types:\\n # First Name, Last Name, Address 1, Address 2, City, State, Zip Code, Phone, Email, Identification\\n query_string_name =\\\\\\n \\\"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname, \\\"\\\\\\n \\\"p.dateofbirth, p.dateofdeath \\\"\\\\\\n \\\"FROM person p \\\"\\\\\\n \\\"WHERE {0} LIKE ? COLLATE NOCASE;\\\"\\n query_string_address =\\\\\\n \\\"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname, \\\"\\\\\\n \\\"p.dateofbirth, p.dateofdeath \\\"\\\\\\n \\\"FROM person p \\\"\\\\\\n \\\"LEFT JOIN address a on a.personid = p.personid \\\"\\\\\\n \\\"WHERE {0} LIKE ? COLLATE NOCASE \\\"\\n\\n conn = sqlite3.connect(settings.database_name)\\n conn.row_factory = sqlite3.Row\\n c = conn.cursor()\\n c.execute(\\\"PRAGMA foreign_keys = ON\\\")\\n final_query = \\\"\\\"\\n if search_type in {\\\"First Name\\\", \\\"Last Name\\\"}:\\n if search_type == \\\"First Name\\\":\\n final_query = query_string_name.format(\\\"p.firstname\\\")\\n if search_type == \\\"Last Name\\\":\\n final_query = query_string_name.format(\\\"p.lastname\\\")\\n c.execute(final_query, (\\\"%\\\"+search_value+\\\"%\\\",))\\n\\n if search_type in {\\\"Address 1\\\", \\\"Address 2\\\", \\\"City\\\", \\\"State\\\", \\\"Zip Code\\\"}:\\n if search_type == \\\"Address 1\\\":\\n final_query = query_string_address.format(\\\"a.addressline1\\\")\\n c.execute(final_query, (\\\"%\\\"+search_value+\\\"%\\\",))\\n if search_type == \\\"Address 2\\\":\\n final_query = query_string_address.format(\\\"a.addressline2\\\")\\n c.execute(final_query, (\\\"%\\\"+search_value+\\\"%\\\",))\\n if search_type == \\\"City\\\":\\n final_query = query_string_address.format(\\\"a.city\\\")\\n c.execute(final_query, (\\\"%\\\"+search_value+\\\"%\\\",))\\n if search_type == \\\"State\\\":\\n final_query = query_string_address.format(\\\"a.state\\\")\\n c.execute(final_query, (\\\"%\\\"+search_value+\\\"%\\\",))\\n if search_type == \\\"Zip Code\\\":\\n final_query = query_string_address.format(\\\"a.zipcode\\\")\\n c.execute(final_query, (\\\"%\\\"+search_value+\\\"%\\\",))\\n\\n if search_type == \\\"Phone\\\":\\n c.execute(\\\"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname, \\\"\\n \\\"p.dateofbirth, p.dateofdeath \\\"\\n \\\"FROM person p \\\"\\n \\\"JOIN contact c on c.personid = p.personid \\\"\\n \\\"JOIN phone ph on ph.contactid = c.contactid \\\"\\n \\\"WHERE ph.areacode || ph.exchange || ph.trunk LIKE ?;\\\", (\\\"%\\\"+search_value+\\\"%\\\",))\\n\\n if search_type == \\\"Email\\\":\\n c.execute(\\\"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname,\\\"\\n \\\"p.dateofbirth, p.dateofdeath \\\"\\n \\\"FROM person p \\\"\\n \\\"JOIN contact c on c.personid = p.personid \\\"\\n \\\"JOIN email e on e.contactid = c.contactid \\\"\\n \\\"WHERE e.emailaddress LIKE ? COLLATE NOCASE;\\\", (\\\"%\\\"+search_value+\\\"%\\\",))\\n\\n if search_type == \\\"Identification\\\":\\n c.execute(\\\"SELECT DISTINCT p.personid, p.firstname, p.lastname, p.middleinitial, p.nickname, \\\"\\n \\\"p.dateofbirth, p.dateofdeath \\\"\\n \\\"FROM person p \\\"\\n \\\"JOIN identification i on i.personid = p.personid \\\"\\n \\\"WHERE i.identificationnumber LIKE ? COLLATE NOCASE;\\\", (\\\"%\\\"+search_value+\\\"%\\\",))\\n\\n p = []\\n if search_type == \\\"All\\\":\\n p = read_people()\\n else:\\n for row in c:\\n _person = Person()\\n _person.person_id = row[\\\"personid\\\"]\\n _person.first_name = row[\\\"firstname\\\"]\\n _person.last_name = row[\\\"lastname\\\"]\\n _person.middle_initial = row[\\\"middleinitial\\\"]\\n _person.nick_name = row[\\\"nickname\\\"]\\n _person.date_of_birth = row[\\\"dateofbirth\\\"]\\n _person.date_of_death = row[\\\"dateofdeath\\\"]\\n p.append(_person)\\n conn.close()\\n return p\\n except Exception as exc:\\n aexc = exc\\n return []\",\n \"def get_highlight_text(start, start_index, end, end_index):\\n #TODO: this has nothing to do with highlights, whatever those are\\n #TODO: this method is ridiculous, how is it usable? the arguments could\\n # mean two different things.\\n text = \\\"\\\"\\n words = WordInSentence.query.filter(\\n (WordInSentence.sentence_id > start) &\\n (WordInSentence.sentence_id < end) |\\n (WordInSentence.sentence_id == start) &\\n (WordInSentence.position >= start_index) |\\n (WordInSentence.sentence_id == end) &\\n (WordInSentence.position <= end_index)).\\\\\\n order_by(WordInSentence.sentence_id).\\\\\\n order_by(WordInSentence.position).all()\\n\\n for word in words:\\n if not app.config[\\\"PUNCTUATION_ALL\\\"] in word.surface:\\n text += \\\" \\\" # Don't put spaces in front of punctuation.\\n\\n text += word.surface\\n\\n return text\",\n \"def get_text(listing_id):\\n conn = None\\n try:\\n params = config()\\n conn = psycopg2.connect(**params)\\n cur = conn.cursor()\\n cur.execute(\\\"SELECT reviews FROM listingid_to_text WHERE listing_id IN (%s)\\\", [listing_id])\\n rows = cur.fetchall()\\n print(rows)\\n cur.close()\\n except (Exception, psycopg2.DatabaseError) as error:\\n print(error)\\n finally:\\n if conn is not None:\\n conn.close()\",\n \"def criteria_prettified(self, instance):\\n\\n # Convert the data to sorted, indented JSON\\n response = json.dumps(instance.criteria, sort_keys=True, indent=2)\\n\\n # Truncate the data. Alter as needed\\n response = response\\n\\n # Get the Pygments formatter\\n formatter = HtmlFormatter(style='colorful')\\n\\n # Highlight the data\\n response = highlight(response, JsonLexer(), formatter)\\n\\n # Get the stylesheet\\n style = \\\"<style>\\\" + formatter.get_style_defs() + \\\"</style><br>\\\"\\n\\n # Safe the output\\n return mark_safe(style + response)\",\n \"def textify(read_pdf,spage,epage):\\n\\n page_text = \\\"\\\"\\n for page in range(spage, epage):\\n page_content = read_pdf.getPage(page)\\n page_text += page_content.extractText()\\n\\n full_text = page_text #.encode('utf-8')\\n return full_text\",\n \"def get_full_text(self, item):\\n photoset_content = self.db.plugin_photoset_content(\\n item_id=item.unique_id)\\n output = self.response.render(\\n 'plugin_photoset/full_text.txt',\\n dict(photoset_content=photoset_content, item=item))\\n return unicode(output.decode('utf-8'))\",\n \"def convert_search_to_scopus_search_string(search):\\n search_string = \\\"\\\"\\n if search[\\\"author_name\\\"]:\\n if search_string != \\\"\\\":\\n search_string += \\\" AND \\\"\\n search_string += \\\"AUTH(\\\" + search[\\\"author_name\\\"] + \\\")\\\"\\n if search[\\\"topic\\\"]:\\n if search_string != \\\"\\\":\\n search_string += \\\" AND \\\"\\n search_string += \\\"TITLE-ABS-KEY(\\\" + search[\\\"topic\\\"] + \\\")\\\"\\n if search[\\\"start_year\\\"]:\\n if search_string != \\\"\\\":\\n search_string += \\\" AND \\\"\\n search_string += \\\"PUBYEAR AFT \\\" + search[\\\"start_year\\\"] + \\\"\\\"\\n if search[\\\"end_year\\\"]:\\n if search_string != \\\"\\\":\\n search_string += \\\" AND \\\"\\n search_string += \\\"PUBYEAR BEF \\\" + search[\\\"end_year\\\"] + \\\"\\\"\\n if search[\\\"title\\\"]:\\n if search_string != \\\"\\\":\\n search_string += \\\" AND \\\"\\n search_string += \\\"TITLE(\\\" + search[\\\"title\\\"] + \\\")\\\"\\n if search[\\\"subject\\\"]:\\n if search_string != \\\"\\\":\\n search_string += \\\" AND \\\"\\n search_string += \\\"SUBJAREA(\\\" + search[\\\"subject\\\"] + \\\")\\\"\\n if search[\\\"author_id\\\"]:\\n if search_string != \\\"\\\":\\n search_string += \\\" AND \\\"\\n search_string += \\\"AU-ID(\\\" + search[\\\"author_id\\\"] + \\\")\\\"\\n if search[\\\"affiliation_id\\\"]:\\n if search_string != \\\"\\\":\\n search_string += \\\" AND \\\"\\n affil_search = '(AF-ID(' + search[\\\"affiliation_id\\\"].replace(\\\"\\\\n\\\", \\\"\\\") + '))'\\n affil_search = affil_search.replace(\\\" OR \\\", \\\") OR AF-ID(\\\")\\n affil_search = affil_search.replace(\\\" OR\\\", \\\") OR AF-ID(\\\")\\n affil_search = affil_search.replace(\\\" AND \\\", \\\") AND AF-ID(\\\")\\n search_string += affil_search\\n return search_string\",\n \"def display_fields(self):\\r\\n\\r\\n field_text = self.show_fields()\\r\\n field_text_list = field_text.split(EOL)[0:-1]\\r\\n\\r\\n def fld_format (x_temp):\\r\\n\\r\\n x_temp = x_temp.split(COLON)[0], x_temp.split(COLON)[1]\\r\\n\\r\\n \\\"\\\"\\\"formats output of the list of search results\\\"\\\"\\\"\\r\\n\\r\\n if not isinstance(x_temp[1],str):\\r\\n shown_indexes = rangelist.range_find([int(Index(a_temp))\\r\\n for a_temp in x_temp[1]],reduce=True)\\r\\n else:\\r\\n shown_indexes = x_temp[1]\\r\\n\\r\\n if len(shown_indexes) < 20:\\r\\n return (abridge(x_temp[0]).replace(VERTLINE,SLASH)\\r\\n +VERTLINE\\r\\n +shown_indexes)\\r\\n\\r\\n\\r\\n returnlist = []\\r\\n sp_temp = rangelist.split_up_range(shown_indexes)\\r\\n\\r\\n\\r\\n returnlist.append(x_temp[0].replace(VERTLINE,SLASH)[0:min([60,len(x_temp[0])])]\\r\\n +VERTLINE+sp_temp[0])\\r\\n for s_temp in sp_temp[1:]:\\r\\n returnlist.append(VERTLINE+s_temp)\\r\\n\\r\\n return returnlist\\r\\n\\r\\n show_list(field_text_list,\\r\\n alerts.FIELDS[3:],0,40,\\r\\n func=fld_format,\\r\\n present=True,\\r\\n display=display)\",\n \"def text(self, tid, lang):\\n csv_paths = [\\n os.path.join(self.config.csv.base, self.config.csv.path.texts),\\n os.path.join(self.config.csv.base, self.config.csv.path.texts_patch)\\n ]\\n _text = None\\n while _text is None:\\n for csv_path in csv_paths:\\n with open(csv_path, encoding=\\\"utf8\\\") as f:\\n texts_reader = csv.DictReader(f)\\n for row in texts_reader:\\n keys = ['v', ' ']\\n for key in keys:\\n if key in row.keys():\\n if row.get(key) == tid:\\n s = row[lang]\\n _text = s.replace('\\\\q', '\\\\\\\"')\\n if _text is None:\\n _text = ''\\n\\n return _text\",\n \"def load_texts(self):\\n\\n db = mongo(self.text_dbname)\\n\\n print(\\\"Loading texts:\\\")\\n # For each other, query the text database and add their works to texts to compare\\n for author in self.authors:\\n for text in db.texts.find({'author':author, 'language':\\\"latin\\\"}, no_cursor_timeout=True):\\n self.texts_to_compare.append(text)\\n print(\\\" -- loaded texts for\\\", author)\\n\\n return\",\n \"def PersonSearch(self, searchtext=None, **kw):\\n\\t\\thtml = \\\"<ul><h4>Results:</h4>\\\"\\n\\t\\tif searchtext:\\n\\t\\t\\tsearch = model.Person.select(OR (model.Person.q.NameFirst.contains(str(searchtext)), \\n\\t\\t\\t\\t\\t\\t\\tmodel.Person.q.NameLast.contains(str(searchtext))))\\n\\t\\t\\tif search.count() > 0:\\n\\t\\t\\t\\tfor person in search:\\n\\t\\t\\t\\t\\thtml += '<li><a href=\\\"?PersonID=%s\\\">%s</a></li>' % (str(person.id), person.DisplayName())\\n\\t\\t#log.debug(html)\\n\\t\\thtml += \\\"</ul>\\\"\\n\\t\\treturn html\",\n \"def get_search_results_html(search_query=None):\\n\\n if search_query:\\n # Insert the search term into the database\\n insert_query(search_query)\\n\\n # Format results as HTML\\n search_results = f'<p>You searched for: {search_query}</p>'\\n search_results += '<p>No results found.</p>'\\n return search_results\\n\\n # No search term specified, so return an empty string\\n return \\\"\\\"\",\n \"def formatOutput(self, storedText, titleMode, altText='', internal=False):\\n if titleMode or not internal:\\n return TextFormat.formatOutput(self, storedText, titleMode,\\n internal)\\n paths = storedText.split('\\\\n')\\n results = []\\n for url in paths:\\n # add prefix/suffix within the executable path:\\n url = TextFormat.formatOutput(self, url, titleMode, internal)\\n path = url\\n if not URLFormat.hasMethodRe.match(path):\\n path = u'%s%s' % (self.URLMethod, path)\\n results.append(u'<a href=\\\"%s\\\">%s</a>' %\\n (escape(path, treedoc.escDict), altText or url))\\n return u'<br />'.join(results)\",\n \"def search_results(request):\\n #key\\n\\n user_input = request.GET['q']\\n\\n people_objs = Person.objects.filter(Q(last__contains=user_input) | Q(\\n first__contains=user_input))\\n document_objs = Document.objects.filter(title__contains=user_input)\\n folder_objs = Folder.objects.filter(full__contains=user_input)\\n organization_objs = Organization.objects.filter(Q(name__contains=user_input)|Q(\\n location__contains=user_input))\\n obj_dict = {\\n 'people_objs': people_objs,\\n 'document_objs': document_objs,\\n 'folder_objs': folder_objs,\\n 'organization_objs': organization_objs,\\n 'query': user_input,\\n }\\n response = render(request, 'search_results.jinja2', obj_dict)\\n return response\",\n \"def queryToMessage(queryCombo):\\n colunas = queryCombo[0]\\n query = queryCombo[1]\\n if len(query) != 0:\\n result = \\\"\\\"\\n for row in query:\\n for i, data in enumerate(row):\\n result += f'<b>{colunas[i].capitalize()}:</b> {data}\\\\n'\\n result += f'{\\\"-\\\"*20}\\\\n'\\n return result\\n else:\\n return \\\"Nenhuma entrada encontrada usando esse parâmetro de busca.\\\"\",\n \"def formatEditText(self, storedText):\\n for choice in self.splitText(storedText):\\n if choice not in self.formatList:\\n return (storedText, not storedText)\\n return (storedText, True)\",\n \"def _get_text_rendering(self, table):\\n text_table = ''\\n base_variable = table.get_variable().replace(\\\"'\\\", '')\\n\\n if base_variable == self._system.get_settings().user_input:\\n text_table += '\\\\n[user]\\\\t'\\n elif base_variable == self._system.get_settings().system_output:\\n text_table += '[system]\\\\t'\\n else:\\n text_table += '[' + base_variable + ']\\\\t'\\n\\n for value in table.get_values():\\n if not isinstance(value, NoneVal):\\n content = str(value)\\n if table.get_prob(value) < 0.98:\\n content += ' (' + StringUtils.get_short_form(table.get_prob(value)) + ')'\\n\\n text_table += content + '\\\\n\\\\t\\\\t'\\n\\n if base_variable == self._system.get_settings().user_input:\\n text_table += '\\\\n'\\n\\n text_table = text_table[0:-3]\\n return text_table\",\n \"def search(request):\\n # Get data form request\\n name = request.DATA.get('first_name', \\\"''\\\")\\n if name == \\\"\\\":\\n\\n first_names = request.DATA.get('first_name', \\\"''\\\")\\n last_names = request.DATA.get('last_name', \\\"''\\\")\\n display_names = request.DATA.get('display_name', \\\"''\\\")\\n else:\\n first_names = name\\n last_names = name\\n display_names = name\\n genders = request.DATA.get('gender', \\\"''\\\")\\n\\n handicaps = request.DATA.get('handicap', \\\"''\\\")\\n business_area = request.DATA.get('business_area', \\\"''\\\")\\n city = request.DATA.get('city', \\\"''\\\")\\n district = request.DATA.get('district', \\\"''\\\")\\n age = request.POST.get('age', 0)\\n dob_year = int(datetime.now().year) - int(age)\\n min_dob = datetime.strptime(str(dob_year) + '-01-1', '%Y-%m-%d')\\n max_dob = datetime.strptime(str(dob_year) + '-12-30', '%Y-%m-%d')\\n\\n # Search by single properties\\n results = SearchQuerySet().filter(first_name=first_names).filter(last_name=last_names\\n ).filter(gender=genders).filter(\\n display_name=display_names).filter(handicap_us=handicaps\\n ).filter(handicap_36=handicaps\\n ).filter(business_area=business_area).filter(city=city\\n ).filter(\\n district=district)\\n\\n if age is not 0:\\n results.filter(dob__gte=min_dob, dob__lte=max_dob)\\n # Get List user\\n queryset = User.objects.all()\\n # Create result list\\n results_list = []\\n # Get User to list by id\\n max_loop = results.count()\\n for x in range(0, max_loop):\\n user = get_object_or_404(queryset, pk=results[x].object.id)\\n results_list.append(user)\\n # Convert to serializer\\n serializer = UserSerializer(results_list, many=True)\\n if serializer.is_valid:\\n return Response({'status': '200', 'code': 'OK_SEARCH',\\n 'detail': serializer.data}, status=200)\\n else:\\n return Response({'status': '400', 'code': 'E_INVALID_PARAMETER_VALUES',\\n 'detail': serializer.errors}, status=400)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62584585","0.57925856","0.56610876","0.5613524","0.55420005","0.55332226","0.5522507","0.55062926","0.54419696","0.54157835","0.54024386","0.5361505","0.53395677","0.52929306","0.5253612","0.52431804","0.52359235","0.5234747","0.523413","0.5231484","0.52294874","0.52202946","0.5204569","0.5197975","0.5196244","0.5195898","0.5185391","0.51832116","0.51552904","0.51443917","0.51426464","0.51107895","0.5107819","0.51026565","0.51026565","0.51026565","0.51026565","0.51026565","0.50984216","0.5087617","0.50798684","0.50752497","0.5070513","0.5061284","0.5058509","0.5049876","0.502932","0.5023868","0.5021757","0.5021757","0.50172466","0.5001167","0.5001087","0.49996662","0.49850172","0.49712294","0.49678996","0.49629876","0.4962437","0.49620157","0.49583077","0.49568594","0.4953382","0.49529234","0.4950835","0.49427474","0.4929517","0.49241152","0.49234954","0.4921228","0.4918518","0.491534","0.49133503","0.4907924","0.48970994","0.48834884","0.4863636","0.4861707","0.48606622","0.485818","0.48575705","0.4854559","0.48526326","0.4849324","0.48469654","0.48445618","0.48430908","0.48407245","0.48329252","0.48324794","0.48312762","0.4829695","0.48262742","0.48230106","0.48182604","0.48172134","0.48133278","0.48085025","0.48070535","0.48068303"],"string":"[\n \"0.62584585\",\n \"0.57925856\",\n \"0.56610876\",\n \"0.5613524\",\n \"0.55420005\",\n \"0.55332226\",\n \"0.5522507\",\n \"0.55062926\",\n \"0.54419696\",\n \"0.54157835\",\n \"0.54024386\",\n \"0.5361505\",\n \"0.53395677\",\n \"0.52929306\",\n \"0.5253612\",\n \"0.52431804\",\n \"0.52359235\",\n \"0.5234747\",\n \"0.523413\",\n \"0.5231484\",\n \"0.52294874\",\n \"0.52202946\",\n \"0.5204569\",\n \"0.5197975\",\n \"0.5196244\",\n \"0.5195898\",\n \"0.5185391\",\n \"0.51832116\",\n \"0.51552904\",\n \"0.51443917\",\n \"0.51426464\",\n \"0.51107895\",\n \"0.5107819\",\n \"0.51026565\",\n \"0.51026565\",\n \"0.51026565\",\n \"0.51026565\",\n \"0.51026565\",\n \"0.50984216\",\n \"0.5087617\",\n \"0.50798684\",\n \"0.50752497\",\n \"0.5070513\",\n \"0.5061284\",\n \"0.5058509\",\n \"0.5049876\",\n \"0.502932\",\n \"0.5023868\",\n \"0.5021757\",\n \"0.5021757\",\n \"0.50172466\",\n \"0.5001167\",\n \"0.5001087\",\n \"0.49996662\",\n \"0.49850172\",\n \"0.49712294\",\n \"0.49678996\",\n \"0.49629876\",\n \"0.4962437\",\n \"0.49620157\",\n \"0.49583077\",\n \"0.49568594\",\n \"0.4953382\",\n \"0.49529234\",\n \"0.4950835\",\n \"0.49427474\",\n \"0.4929517\",\n \"0.49241152\",\n \"0.49234954\",\n \"0.4921228\",\n \"0.4918518\",\n \"0.491534\",\n \"0.49133503\",\n \"0.4907924\",\n \"0.48970994\",\n \"0.48834884\",\n \"0.4863636\",\n \"0.4861707\",\n \"0.48606622\",\n \"0.485818\",\n \"0.48575705\",\n \"0.4854559\",\n \"0.48526326\",\n \"0.4849324\",\n \"0.48469654\",\n \"0.48445618\",\n \"0.48430908\",\n \"0.48407245\",\n \"0.48329252\",\n \"0.48324794\",\n \"0.48312762\",\n \"0.4829695\",\n \"0.48262742\",\n \"0.48230106\",\n \"0.48182604\",\n \"0.48172134\",\n \"0.48133278\",\n \"0.48085025\",\n \"0.48070535\",\n \"0.48068303\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55189323"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":22198,"cells":{"query":{"kind":"string","value":"Gets the extension of the submitted file"},"document":{"kind":"string","value":"def check_extension(f):\n parts = f.split('.')\n last = parts[len(parts) - 1]\n return last in allowed_extensions"},"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 extension(self):\n return os.path.splitext(self.fname)[1]","def extension(self):\n name, ext = os.path.splitext(self.original_filename)\n return ext","def extension(self):\n #type: ()->Text\n return os.path.splitext(os.path.basename(self.fileName))[1]","def get_file_extension(self):\n return self._ext[:]","def getExtension(self, fileName):\r\n print 'getExtension():' \r\n extension = split(basename(fileName), '.')[1]\r\n return extension","def ext(self):\n return os.path.splitext(self.path)[1]","def get_file_ext(self):\n return self.archive.url.split('.')[-1].lower()","def extension_file(self) -> str:\n return self.options[\"extensions\"][\"file\"]","def ext(self):\n import os, string\n (base,ext) = os.path.splitext(self.filename())\n if ext == '':\n return None\n else:\n return string.lstrip(ext, '\\.')","def get_extension(file: Union[str, FileStorage]) -> str:\n filename = _retrieve_filename(file)\n return os.path.splitext(filename)[1]","def get_extension(filename: str) -> str:\n return filename.split(\".\")[-1]","def get_extension(self) -> str:\n return self._extension","def get_file_extension(self, filename):\n if not isinstance(filename, str):\n return None\n\n # Get extension with `.`\n extension = pathlib.Path(filename).suffix\n\n # If empty string return None\n if not extension:\n return None\n else:\n return extension.replace('.', '')","def get_file_ext(filename):\n return filename.rsplit('.', 1)[1]","def _get_ext(self, path):\n return os.path.splitext(path)[1][1:]","def get_file_extension(fname):\n _, ext = os.path.splitext(fname)\n return ext","def get_extension(filename: str) -> str:\n return Path(filename).suffix[1:]","def get_extension(filename):\n extension = splitext(filename)[1].encode()\n return pad(extension, 16)","def get_file_extension(fpath):\n return str(fpath).split(\".\")[-1]","def getExtension(filename):\n return filename[filename.rfind('.'):]","def get_extension(self) -> Optional[str]:\n return self.extension","def get_file_extension(file_path):\n _ext = os.path.splitext(file_path)[-1]\n if _ext:\n return _ext[1:] if _ext.startswith('.') else _ext\n else:\n return \"\"","def get_file_ext(path: str) -> str:\n return os.path.splitext(os.path.basename(path))[1]","def get_file_extension(self, sql_file):\n return os.path.splitext(sql_file)[1]","def get_doc_file_extension(self):\n return os.path.splitext(self.doc_file.name)[-1][1:].lower()","def auto_get_file_extension(self):\n self.resolve_what_url()\n self.guess_ext_from_content_disposition()\n # guess ext from content_disposition success\n if None != self.save_file_ext:\n return\n else:\n self.guess_ext_from_url()","def get_save_extension(self):\n _, asset_ext = os.path.splitext(self.get_name())\n return asset_ext.lower()","def path_extension(self):\r\n return self.path.split('/')[-1].split('.')[-1]","def file_ext(path):\n result = os.path.splitext(path)[1]\n return result","def get_filename(self):\n name, ext = self.fkit.filename.rsplit('.', 1)\n if self._field.extension():\n ext = self._field.extension()\n return '.'.join((name, ext))","def get_filename_extension(filename):\n m = FILENAME_EXTENSION_RE.search(filename)\n return m.group(1) if m else None","def get_fname_ext(fname):\n splitext = os.path.splitext(fname)\n\n return splitext[-1]","def get_file_extension(filename):\n if not filename:\n return \"\"\n\n dotpos = filename.rfind(\".\")\n return filename[dotpos + 1:].lower() if dotpos != -1 else \"\"","def _getFileExtension( filepath ):\r\n file = os.path.splitext(filepath.lower())\r\n if len( file ):\r\n return file[1].replace( '.', '' )\r\n else:\r\n return filepath","def filename_ext(filename):\n base = os.path.basename(filename)\n return os.path.splitext(base)[1][1:]","def fextension(filename):\n filename = os.path.normpath(filename)\n return os.path.splitext(filename)[1]","def get_fileext(file_path):\n\n # Get rid of directories and etc\n just_file = os.path.basename(file_path)\n\n # Now we return just the base name\n return os.path.splitext(just_file)[1]","def get_file_ext(filename):\n p = pathlib.Path(filename)\n if len(p.suffixes) <= 1:\n return p.suffix\n elif p.suffixes[-2] in include_subexts:\n return ''.join(p.suffixes[-2:])\n else:\n return p.suffix","def get_file_extension(filename):\n # Find the first match from the list of supported file extensions\n extension = next((ext for ext in EXT_LST if filename.lower().endswith(ext)), None)\n return extension","def name_woext(self):\n return os.path.splitext(self._job)[0]","def extension(self, file_type='text'):\n k = file_type.lower()\n return self.random.choice(EXTENSIONS[k])","def filename(self):\n filename, ext = os.path.splitext(self.file.name)\n return filename.split('/')[-1]","def file_check(file):\n # unpacking the tuple\n file_name, file_extension = os.path.splitext(file)\n return file_extension","def get_file_extension(self):\n if self.datafile.name:\n extension = _get_extension_from_string(self.datafile.name)\n else:\n extension = _get_extension_from_string(self.source)\n try:\n return FileExtension.objects.get(name=extension)\n except FileExtension.DoesNotExist:\n extension = _get_extension_from_string(extension)\n try:\n return FileExtension.objects.get(name=extension)\n except FileExtension.DoesNotExist as exc:\n raise RuntimeError(\n \"Extension '{}' is not valid: {}\".format(extension, exc)\n )\n except FileExtension.MultipleObjectsReturned as exc:\n raise RuntimeError(exc)\n except FileExtension.MultipleObjectsReturned as exc:\n raise RuntimeError(exc)","def _extr_ext(p: str) -> str:\n file_name = os.path.basename(p)\n _, ext = os.path.splitext(file_name)\n return ext","def get_extension_from_filename(filename):\n return filename[-4:]","def getExtension(path):\n\tfrom os.path import splitext\n\treturn splitext(path)[1]","def get_ext(self):\n\n if self.ext: return self.ext\n self.get_title()","def detFileExt(page):\n fileExt = pubConf.MIMEMAP.get(page['mimeType'], None)\n linkUrl = page['url']\n if fileExt != None:\n logging.debug('Determined filetype as %s based on mime type' % fileExt)\n else:\n urlPath = urlparse.urlparse(linkUrl)[2]\n fileExt = os.path.splitext(urlPath)[1]\n logging.debug('Using extension %s based on URL %s' % (fileExt, linkUrl))\n fileExt = fileExt.strip('.')\n return fileExt","def extract_file_extension(url_file):\n pattern = re.split(\"\\.\",url_file)\n return pattern[-1]","def find_extension(file):\n\n index_ext = file.name.rfind('.')\n if index_ext != -1:\n return file.name[index_ext+1:]\n # else: we raise an exception because\n # we can't find any extension","def getFilenameExtension(path):\n return os.path.splitext(os.path.normcase(path))[1]","def test_get_file_extension(self) -> None:\n path = \"/home/user/file.ext\"\n result = get_file_extension(path)\n self.assertEqual(result, \"ext\")","def ambil_ext_file(filename):\n '''mengambil ekstensi file, return String ekstensi file'''\n ext = os.path.splitext(filename)\n return ext[1]","def get_vulnerability_extension(vulnerability_file):\n regex = re.search(r'\\.(?P<extension>\\w+)', vulnerability_file)\n extension = '.' + regex.group('extension')\n return extension","def get_vulnerability_extension(vulnerability_file):\n regex = re.search(r'\\.(?P<extension>\\w+)', vulnerability_file)\n extension = '.' + regex.group('extension')\n return extension","def get_target_file_extension(self) -> str:\n\n try:\n return lvp_tar_file_extension_map[self.lvp]\n except:\n raise Exception(\n f'No target file extension mapping for LVP \"{self.lvp.value}\".')","def get_ext(f_name):\n \n for i in range(len(f_name)-1,-1,-1):\n if f_name[i]=='.':\n return f_name[i:]\n return None","def extension_from_path(path):\n extension = path.split(\".\")[-1]\n return extension","def get_ext(url):\n\n path = urlparse(url).path\n ext = splitext(path)[1]\n return ext","def find_file_extention(file_name):\n \n index = file_name.rfind(\".\")\n ext = file_name[index:].lower()\n \n return ext","def test_get_filename_extension(self):\r\n u = Uploader()\r\n filename = \"image.png\"\r\n err_msg = \"The extension should be PNG\"\r\n assert u.get_filename_extension(filename) == 'png', err_msg\r\n filename = \"image.jpg\"\r\n err_msg = \"The extension should be JPEG\"\r\n assert u.get_filename_extension(filename) == 'jpeg', err_msg\r\n filename = \"imagenoextension\"\r\n err_msg = \"The extension should be None\"\r\n assert u.get_filename_extension(filename) == None, err_msg","def getMimeType(self, extension): #$NON-NLS-1$\r","def get_file_ext(path):\n # Test if the path exist and if it is a file (not a directory):\n if not os.path.isfile(path):\n # If it is a directory, check if it is a mff directory\n if path[-3:].lower() != \"mff\":\n raise ValueError(\"The provided path (\" + path + \") is not valid.\")\n # Find file extension :\n file, ext = os.path.splitext(path)\n # Be sure to be in lowercase :\n ext = ext.lower()\n return file, ext","def defaultExtension(self):\n result = self.EXTERNAL_TYPES[self.typ]\n if not self.fileExtensions:\n return result\n if result in self.fileExtensions:\n return result\n return self.fileExtensions[0]","def get_extention(full_path: str) -> str:\n file_extention_obj = re.search(\n FILE_EXT_RE_PATTERN,\n full_path,\n flags=re.IGNORECASE,\n )\n if file_extention_obj is None:\n file_extention = '.html'\n else:\n file_extention = file_extention_obj.group(0)\n return file_extention","def filepath_ext(filepath: str) -> str:\n return pathlib.Path(filepath).suffix","def ext(self):\n return self._getbyspec(\"ext\")[0]","def ext(self):\n return self._ext","def extension(self) -> str:","def get_file_name_with_ext(path: str) -> str:\n return os.path.basename(path)","def get_filename(self) -> str:\n fname = self.url.split(\"/\")[-1]\n if \",\" in fname:\n _fname, _i = fname.split(\",\")\n _split_fname = _fname.split(\".\")\n _name = _split_fname[0]\n _extension = _split_fname[-1]\n return _name + _i + \".\" + _extension\n else:\n return fname","def get_file_extention(file_path):\n # http://domain.tld/foo.bar -> foo.bar\n filename = os.path.basename(file_path)# Make sure we don't include domain names\n # foo.bar -> bar\n # foo.bar?baz -> bar\n # foobar/baz -> None\n # foobar/baz?fizz -> None\n file_extention_regex = \"\"\"\\.([a-zA-Z0-9]+)[?]?\"\"\"\n file_extention_search = re.search(file_extention_regex, filename, re.IGNORECASE)\n if file_extention_search:\n file_extention = file_extention_search.group(1)\n return file_extention","def get_ext(url):\r\n root, ext = splitext(url)\r\n return ext","def _get_extension_from_string(path):\n file_name_parts = os.path.basename(path).split('.')\n if len(file_name_parts) == 1: # no periods in file name\n return ''\n if len(file_name_parts) > 2: # two or more periods in file name\n return '.'.join(file_name_parts[-2:])\n return file_name_parts[-1] # one period in file name","def filepath_name_ext(filepath: str) -> str:\n return pathlib.Path(filepath).name","def get_output_file_type(self):\n file_name = '.' + self.template_file_name.split('.')[-2]\n return file_name","def extension(self):\n return self.extensions[0]","def get_filename(file_extension=False) -> str:\n if file_extension == False:\n return filename[0:filename.find(\".json\")]\n else:\n return filename","def method_safe_filetype(self):\n file_type = self.get_filetype(self.file)\n\n if file_type:\n return file_type.replace('.', '')","def guess_ext_from_url(self):\n # http://docs.python.org/2.7/library/urlparse.html#urlparse.urlsplit\n # 0:scheme,1:netloc,2:path,3:query\n url_path = urlparse.urlsplit(self.what_url)[2]\n # path index is 2,Hierarchical path,may be empty string\n if '' == url_path:\n self.save_file_ext = None\n else:\n # 0: root 1: .ext\n file_name_info = os.path.splitext(url_path)\n # '.exe', contain .\n self.save_file_ext = file_name_info[1]","def guess_ext_from_content_disposition(self):\n # may be bug, Content-Disposition attachment; filename=\"MyspacePasswordDecryptor.zip\";\n if self.content_disposition:\n file_name = self.content_disposition.split('filename=')[1]\n # \"MyspacePasswordDecryptor.zip\"; maybe like this,so rstrip semicolon\n file_name = file_name.rstrip(';')\n # web server can pass wrong formatted name as [\"file.ext] or [file.ext'] or even be empty\n file_name = file_name.replace('\"', '').replace(\"'\", \"\")\n if '' == file_name:\n self.save_file_ext = None\n else:\n if -1 != file_name.find('.'):\n file_name_list = file_name.split('.')\n self.save_file_ext = '.' + file_name_list[-1]\n else:\n self.save_file_ext = ''","def get_file_name(filepath): # need pytest\n filename, extension = os.path.splitext(filepath.split('/')[-1])\n return filename, extension","def out_extension(self) -> str:\n return self._out_extension","def get_file_type(filename):\n return filename[filename.rfind('.')+1:].lower()","def filename(self):\n return '%s%s' % (self.identifier, self.extension)","def get_file_name_with_extension(file_name: str):\n return file_name + '.txt'","def get_file_name(self):\n return self.upload.name[6:]","def name(self):\n #type: ()->Text\n return (\n os.path.splitext(os.path.basename(self.fileName))[0])","def getExtension(path: unicode, extLevel: int) -> unicode:\n ...","def name_sans_ext(self) -> str:\n return os.path.splitext(self.path)[0]","def get_file_name(file):\n return os.path.splitext(os.path.basename(file))[0]","def test_get_file_with_dots_extension(self) -> None:\n path = \"/home/user/file.name.ext2\"\n result = get_file_extension(path)\n self.assertEqual(result, \"ext2\")","def getFileName(filepath):\n return os.path.splitext(os.path.basename(filepath))[0]","def detect_extension(name: Union[str, Path]):\n\n filename = name if isinstance(name, str) else name.name\n parts = filename.split('.')\n ext = parts[-1]\n if ext in COMPRESS_EXT:\n ext = '.'.join(parts[-2:])\n return ext","def genomic_file_ext(x):\n matches = [\n file_ext for file_ext in FILE_EXT_FORMAT_MAP if x.endswith(file_ext)\n ]\n if matches:\n file_ext = max(matches, key=len)\n else:\n file_ext = None\n\n return file_ext","def extension (self):\n return 'mp4'","def ext(self):\n assert self.__ext, \"Image.__ext referenced before assigned\"\n return self.__ext","def get_extension_param(self):\n if 'frame' in self.disp_parameters['extension']:\n exten = 'all'\n elif 'cube' in self.disp_parameters['extension']:\n exten = 'all'\n elif 'first' in self.disp_parameters['extension']:\n exten = 0\n else:\n try:\n exten = int(self.disp_parameters['extension'])\n except ValueError:\n exten = str(self.disp_parameters['extension']).strip()\n return exten","def get_filename(self, latex_doc=None):\n if not self.filename:\n if latex_doc is None:\n filename = 'file'\n else:\n filename = latex_doc.filename\n else:\n filename = self.filename\n return self.fix_filename_extension(filename)","def get_file(self):\n return self.dir + self.file_name + self.extension"],"string":"[\n \"def extension(self):\\n return os.path.splitext(self.fname)[1]\",\n \"def extension(self):\\n name, ext = os.path.splitext(self.original_filename)\\n return ext\",\n \"def extension(self):\\n #type: ()->Text\\n return os.path.splitext(os.path.basename(self.fileName))[1]\",\n \"def get_file_extension(self):\\n return self._ext[:]\",\n \"def getExtension(self, fileName):\\r\\n print 'getExtension():' \\r\\n extension = split(basename(fileName), '.')[1]\\r\\n return extension\",\n \"def ext(self):\\n return os.path.splitext(self.path)[1]\",\n \"def get_file_ext(self):\\n return self.archive.url.split('.')[-1].lower()\",\n \"def extension_file(self) -> str:\\n return self.options[\\\"extensions\\\"][\\\"file\\\"]\",\n \"def ext(self):\\n import os, string\\n (base,ext) = os.path.splitext(self.filename())\\n if ext == '':\\n return None\\n else:\\n return string.lstrip(ext, '\\\\.')\",\n \"def get_extension(file: Union[str, FileStorage]) -> str:\\n filename = _retrieve_filename(file)\\n return os.path.splitext(filename)[1]\",\n \"def get_extension(filename: str) -> str:\\n return filename.split(\\\".\\\")[-1]\",\n \"def get_extension(self) -> str:\\n return self._extension\",\n \"def get_file_extension(self, filename):\\n if not isinstance(filename, str):\\n return None\\n\\n # Get extension with `.`\\n extension = pathlib.Path(filename).suffix\\n\\n # If empty string return None\\n if not extension:\\n return None\\n else:\\n return extension.replace('.', '')\",\n \"def get_file_ext(filename):\\n return filename.rsplit('.', 1)[1]\",\n \"def _get_ext(self, path):\\n return os.path.splitext(path)[1][1:]\",\n \"def get_file_extension(fname):\\n _, ext = os.path.splitext(fname)\\n return ext\",\n \"def get_extension(filename: str) -> str:\\n return Path(filename).suffix[1:]\",\n \"def get_extension(filename):\\n extension = splitext(filename)[1].encode()\\n return pad(extension, 16)\",\n \"def get_file_extension(fpath):\\n return str(fpath).split(\\\".\\\")[-1]\",\n \"def getExtension(filename):\\n return filename[filename.rfind('.'):]\",\n \"def get_extension(self) -> Optional[str]:\\n return self.extension\",\n \"def get_file_extension(file_path):\\n _ext = os.path.splitext(file_path)[-1]\\n if _ext:\\n return _ext[1:] if _ext.startswith('.') else _ext\\n else:\\n return \\\"\\\"\",\n \"def get_file_ext(path: str) -> str:\\n return os.path.splitext(os.path.basename(path))[1]\",\n \"def get_file_extension(self, sql_file):\\n return os.path.splitext(sql_file)[1]\",\n \"def get_doc_file_extension(self):\\n return os.path.splitext(self.doc_file.name)[-1][1:].lower()\",\n \"def auto_get_file_extension(self):\\n self.resolve_what_url()\\n self.guess_ext_from_content_disposition()\\n # guess ext from content_disposition success\\n if None != self.save_file_ext:\\n return\\n else:\\n self.guess_ext_from_url()\",\n \"def get_save_extension(self):\\n _, asset_ext = os.path.splitext(self.get_name())\\n return asset_ext.lower()\",\n \"def path_extension(self):\\r\\n return self.path.split('/')[-1].split('.')[-1]\",\n \"def file_ext(path):\\n result = os.path.splitext(path)[1]\\n return result\",\n \"def get_filename(self):\\n name, ext = self.fkit.filename.rsplit('.', 1)\\n if self._field.extension():\\n ext = self._field.extension()\\n return '.'.join((name, ext))\",\n \"def get_filename_extension(filename):\\n m = FILENAME_EXTENSION_RE.search(filename)\\n return m.group(1) if m else None\",\n \"def get_fname_ext(fname):\\n splitext = os.path.splitext(fname)\\n\\n return splitext[-1]\",\n \"def get_file_extension(filename):\\n if not filename:\\n return \\\"\\\"\\n\\n dotpos = filename.rfind(\\\".\\\")\\n return filename[dotpos + 1:].lower() if dotpos != -1 else \\\"\\\"\",\n \"def _getFileExtension( filepath ):\\r\\n file = os.path.splitext(filepath.lower())\\r\\n if len( file ):\\r\\n return file[1].replace( '.', '' )\\r\\n else:\\r\\n return filepath\",\n \"def filename_ext(filename):\\n base = os.path.basename(filename)\\n return os.path.splitext(base)[1][1:]\",\n \"def fextension(filename):\\n filename = os.path.normpath(filename)\\n return os.path.splitext(filename)[1]\",\n \"def get_fileext(file_path):\\n\\n # Get rid of directories and etc\\n just_file = os.path.basename(file_path)\\n\\n # Now we return just the base name\\n return os.path.splitext(just_file)[1]\",\n \"def get_file_ext(filename):\\n p = pathlib.Path(filename)\\n if len(p.suffixes) <= 1:\\n return p.suffix\\n elif p.suffixes[-2] in include_subexts:\\n return ''.join(p.suffixes[-2:])\\n else:\\n return p.suffix\",\n \"def get_file_extension(filename):\\n # Find the first match from the list of supported file extensions\\n extension = next((ext for ext in EXT_LST if filename.lower().endswith(ext)), None)\\n return extension\",\n \"def name_woext(self):\\n return os.path.splitext(self._job)[0]\",\n \"def extension(self, file_type='text'):\\n k = file_type.lower()\\n return self.random.choice(EXTENSIONS[k])\",\n \"def filename(self):\\n filename, ext = os.path.splitext(self.file.name)\\n return filename.split('/')[-1]\",\n \"def file_check(file):\\n # unpacking the tuple\\n file_name, file_extension = os.path.splitext(file)\\n return file_extension\",\n \"def get_file_extension(self):\\n if self.datafile.name:\\n extension = _get_extension_from_string(self.datafile.name)\\n else:\\n extension = _get_extension_from_string(self.source)\\n try:\\n return FileExtension.objects.get(name=extension)\\n except FileExtension.DoesNotExist:\\n extension = _get_extension_from_string(extension)\\n try:\\n return FileExtension.objects.get(name=extension)\\n except FileExtension.DoesNotExist as exc:\\n raise RuntimeError(\\n \\\"Extension '{}' is not valid: {}\\\".format(extension, exc)\\n )\\n except FileExtension.MultipleObjectsReturned as exc:\\n raise RuntimeError(exc)\\n except FileExtension.MultipleObjectsReturned as exc:\\n raise RuntimeError(exc)\",\n \"def _extr_ext(p: str) -> str:\\n file_name = os.path.basename(p)\\n _, ext = os.path.splitext(file_name)\\n return ext\",\n \"def get_extension_from_filename(filename):\\n return filename[-4:]\",\n \"def getExtension(path):\\n\\tfrom os.path import splitext\\n\\treturn splitext(path)[1]\",\n \"def get_ext(self):\\n\\n if self.ext: return self.ext\\n self.get_title()\",\n \"def detFileExt(page):\\n fileExt = pubConf.MIMEMAP.get(page['mimeType'], None)\\n linkUrl = page['url']\\n if fileExt != None:\\n logging.debug('Determined filetype as %s based on mime type' % fileExt)\\n else:\\n urlPath = urlparse.urlparse(linkUrl)[2]\\n fileExt = os.path.splitext(urlPath)[1]\\n logging.debug('Using extension %s based on URL %s' % (fileExt, linkUrl))\\n fileExt = fileExt.strip('.')\\n return fileExt\",\n \"def extract_file_extension(url_file):\\n pattern = re.split(\\\"\\\\.\\\",url_file)\\n return pattern[-1]\",\n \"def find_extension(file):\\n\\n index_ext = file.name.rfind('.')\\n if index_ext != -1:\\n return file.name[index_ext+1:]\\n # else: we raise an exception because\\n # we can't find any extension\",\n \"def getFilenameExtension(path):\\n return os.path.splitext(os.path.normcase(path))[1]\",\n \"def test_get_file_extension(self) -> None:\\n path = \\\"/home/user/file.ext\\\"\\n result = get_file_extension(path)\\n self.assertEqual(result, \\\"ext\\\")\",\n \"def ambil_ext_file(filename):\\n '''mengambil ekstensi file, return String ekstensi file'''\\n ext = os.path.splitext(filename)\\n return ext[1]\",\n \"def get_vulnerability_extension(vulnerability_file):\\n regex = re.search(r'\\\\.(?P<extension>\\\\w+)', vulnerability_file)\\n extension = '.' + regex.group('extension')\\n return extension\",\n \"def get_vulnerability_extension(vulnerability_file):\\n regex = re.search(r'\\\\.(?P<extension>\\\\w+)', vulnerability_file)\\n extension = '.' + regex.group('extension')\\n return extension\",\n \"def get_target_file_extension(self) -> str:\\n\\n try:\\n return lvp_tar_file_extension_map[self.lvp]\\n except:\\n raise Exception(\\n f'No target file extension mapping for LVP \\\"{self.lvp.value}\\\".')\",\n \"def get_ext(f_name):\\n \\n for i in range(len(f_name)-1,-1,-1):\\n if f_name[i]=='.':\\n return f_name[i:]\\n return None\",\n \"def extension_from_path(path):\\n extension = path.split(\\\".\\\")[-1]\\n return extension\",\n \"def get_ext(url):\\n\\n path = urlparse(url).path\\n ext = splitext(path)[1]\\n return ext\",\n \"def find_file_extention(file_name):\\n \\n index = file_name.rfind(\\\".\\\")\\n ext = file_name[index:].lower()\\n \\n return ext\",\n \"def test_get_filename_extension(self):\\r\\n u = Uploader()\\r\\n filename = \\\"image.png\\\"\\r\\n err_msg = \\\"The extension should be PNG\\\"\\r\\n assert u.get_filename_extension(filename) == 'png', err_msg\\r\\n filename = \\\"image.jpg\\\"\\r\\n err_msg = \\\"The extension should be JPEG\\\"\\r\\n assert u.get_filename_extension(filename) == 'jpeg', err_msg\\r\\n filename = \\\"imagenoextension\\\"\\r\\n err_msg = \\\"The extension should be None\\\"\\r\\n assert u.get_filename_extension(filename) == None, err_msg\",\n \"def getMimeType(self, extension): #$NON-NLS-1$\\r\",\n \"def get_file_ext(path):\\n # Test if the path exist and if it is a file (not a directory):\\n if not os.path.isfile(path):\\n # If it is a directory, check if it is a mff directory\\n if path[-3:].lower() != \\\"mff\\\":\\n raise ValueError(\\\"The provided path (\\\" + path + \\\") is not valid.\\\")\\n # Find file extension :\\n file, ext = os.path.splitext(path)\\n # Be sure to be in lowercase :\\n ext = ext.lower()\\n return file, ext\",\n \"def defaultExtension(self):\\n result = self.EXTERNAL_TYPES[self.typ]\\n if not self.fileExtensions:\\n return result\\n if result in self.fileExtensions:\\n return result\\n return self.fileExtensions[0]\",\n \"def get_extention(full_path: str) -> str:\\n file_extention_obj = re.search(\\n FILE_EXT_RE_PATTERN,\\n full_path,\\n flags=re.IGNORECASE,\\n )\\n if file_extention_obj is None:\\n file_extention = '.html'\\n else:\\n file_extention = file_extention_obj.group(0)\\n return file_extention\",\n \"def filepath_ext(filepath: str) -> str:\\n return pathlib.Path(filepath).suffix\",\n \"def ext(self):\\n return self._getbyspec(\\\"ext\\\")[0]\",\n \"def ext(self):\\n return self._ext\",\n \"def extension(self) -> str:\",\n \"def get_file_name_with_ext(path: str) -> str:\\n return os.path.basename(path)\",\n \"def get_filename(self) -> str:\\n fname = self.url.split(\\\"/\\\")[-1]\\n if \\\",\\\" in fname:\\n _fname, _i = fname.split(\\\",\\\")\\n _split_fname = _fname.split(\\\".\\\")\\n _name = _split_fname[0]\\n _extension = _split_fname[-1]\\n return _name + _i + \\\".\\\" + _extension\\n else:\\n return fname\",\n \"def get_file_extention(file_path):\\n # http://domain.tld/foo.bar -> foo.bar\\n filename = os.path.basename(file_path)# Make sure we don't include domain names\\n # foo.bar -> bar\\n # foo.bar?baz -> bar\\n # foobar/baz -> None\\n # foobar/baz?fizz -> None\\n file_extention_regex = \\\"\\\"\\\"\\\\.([a-zA-Z0-9]+)[?]?\\\"\\\"\\\"\\n file_extention_search = re.search(file_extention_regex, filename, re.IGNORECASE)\\n if file_extention_search:\\n file_extention = file_extention_search.group(1)\\n return file_extention\",\n \"def get_ext(url):\\r\\n root, ext = splitext(url)\\r\\n return ext\",\n \"def _get_extension_from_string(path):\\n file_name_parts = os.path.basename(path).split('.')\\n if len(file_name_parts) == 1: # no periods in file name\\n return ''\\n if len(file_name_parts) > 2: # two or more periods in file name\\n return '.'.join(file_name_parts[-2:])\\n return file_name_parts[-1] # one period in file name\",\n \"def filepath_name_ext(filepath: str) -> str:\\n return pathlib.Path(filepath).name\",\n \"def get_output_file_type(self):\\n file_name = '.' + self.template_file_name.split('.')[-2]\\n return file_name\",\n \"def extension(self):\\n return self.extensions[0]\",\n \"def get_filename(file_extension=False) -> str:\\n if file_extension == False:\\n return filename[0:filename.find(\\\".json\\\")]\\n else:\\n return filename\",\n \"def method_safe_filetype(self):\\n file_type = self.get_filetype(self.file)\\n\\n if file_type:\\n return file_type.replace('.', '')\",\n \"def guess_ext_from_url(self):\\n # http://docs.python.org/2.7/library/urlparse.html#urlparse.urlsplit\\n # 0:scheme,1:netloc,2:path,3:query\\n url_path = urlparse.urlsplit(self.what_url)[2]\\n # path index is 2,Hierarchical path,may be empty string\\n if '' == url_path:\\n self.save_file_ext = None\\n else:\\n # 0: root 1: .ext\\n file_name_info = os.path.splitext(url_path)\\n # '.exe', contain .\\n self.save_file_ext = file_name_info[1]\",\n \"def guess_ext_from_content_disposition(self):\\n # may be bug, Content-Disposition attachment; filename=\\\"MyspacePasswordDecryptor.zip\\\";\\n if self.content_disposition:\\n file_name = self.content_disposition.split('filename=')[1]\\n # \\\"MyspacePasswordDecryptor.zip\\\"; maybe like this,so rstrip semicolon\\n file_name = file_name.rstrip(';')\\n # web server can pass wrong formatted name as [\\\"file.ext] or [file.ext'] or even be empty\\n file_name = file_name.replace('\\\"', '').replace(\\\"'\\\", \\\"\\\")\\n if '' == file_name:\\n self.save_file_ext = None\\n else:\\n if -1 != file_name.find('.'):\\n file_name_list = file_name.split('.')\\n self.save_file_ext = '.' + file_name_list[-1]\\n else:\\n self.save_file_ext = ''\",\n \"def get_file_name(filepath): # need pytest\\n filename, extension = os.path.splitext(filepath.split('/')[-1])\\n return filename, extension\",\n \"def out_extension(self) -> str:\\n return self._out_extension\",\n \"def get_file_type(filename):\\n return filename[filename.rfind('.')+1:].lower()\",\n \"def filename(self):\\n return '%s%s' % (self.identifier, self.extension)\",\n \"def get_file_name_with_extension(file_name: str):\\n return file_name + '.txt'\",\n \"def get_file_name(self):\\n return self.upload.name[6:]\",\n \"def name(self):\\n #type: ()->Text\\n return (\\n os.path.splitext(os.path.basename(self.fileName))[0])\",\n \"def getExtension(path: unicode, extLevel: int) -> unicode:\\n ...\",\n \"def name_sans_ext(self) -> str:\\n return os.path.splitext(self.path)[0]\",\n \"def get_file_name(file):\\n return os.path.splitext(os.path.basename(file))[0]\",\n \"def test_get_file_with_dots_extension(self) -> None:\\n path = \\\"/home/user/file.name.ext2\\\"\\n result = get_file_extension(path)\\n self.assertEqual(result, \\\"ext2\\\")\",\n \"def getFileName(filepath):\\n return os.path.splitext(os.path.basename(filepath))[0]\",\n \"def detect_extension(name: Union[str, Path]):\\n\\n filename = name if isinstance(name, str) else name.name\\n parts = filename.split('.')\\n ext = parts[-1]\\n if ext in COMPRESS_EXT:\\n ext = '.'.join(parts[-2:])\\n return ext\",\n \"def genomic_file_ext(x):\\n matches = [\\n file_ext for file_ext in FILE_EXT_FORMAT_MAP if x.endswith(file_ext)\\n ]\\n if matches:\\n file_ext = max(matches, key=len)\\n else:\\n file_ext = None\\n\\n return file_ext\",\n \"def extension (self):\\n return 'mp4'\",\n \"def ext(self):\\n assert self.__ext, \\\"Image.__ext referenced before assigned\\\"\\n return self.__ext\",\n \"def get_extension_param(self):\\n if 'frame' in self.disp_parameters['extension']:\\n exten = 'all'\\n elif 'cube' in self.disp_parameters['extension']:\\n exten = 'all'\\n elif 'first' in self.disp_parameters['extension']:\\n exten = 0\\n else:\\n try:\\n exten = int(self.disp_parameters['extension'])\\n except ValueError:\\n exten = str(self.disp_parameters['extension']).strip()\\n return exten\",\n \"def get_filename(self, latex_doc=None):\\n if not self.filename:\\n if latex_doc is None:\\n filename = 'file'\\n else:\\n filename = latex_doc.filename\\n else:\\n filename = self.filename\\n return self.fix_filename_extension(filename)\",\n \"def get_file(self):\\n return self.dir + self.file_name + self.extension\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.85816354","0.8499633","0.84875196","0.8477434","0.8317361","0.82983124","0.7956723","0.79486096","0.79430157","0.79303133","0.786467","0.78199774","0.7804541","0.77982265","0.77892864","0.7778937","0.7774032","0.77076656","0.769469","0.7674665","0.76132494","0.7586847","0.755116","0.7530712","0.7526752","0.7523533","0.7513227","0.7478889","0.7469069","0.7457313","0.74570984","0.74337804","0.7369632","0.7360071","0.733861","0.7320642","0.73052096","0.729503","0.7289895","0.72887003","0.72770596","0.72473705","0.7222387","0.7208044","0.719235","0.71679604","0.7153526","0.7150469","0.710654","0.706295","0.70348233","0.7011982","0.70065165","0.70028466","0.6996006","0.6996006","0.69649893","0.6933982","0.69303685","0.69167125","0.69065577","0.6887639","0.68863595","0.686641","0.68604296","0.6856356","0.68470645","0.6837486","0.6817671","0.6786448","0.6783264","0.6772449","0.6771106","0.6740455","0.66939646","0.6689156","0.6679865","0.66773635","0.6639536","0.6638845","0.6628173","0.66155916","0.65965223","0.65707946","0.6570739","0.65279603","0.65203416","0.64853996","0.6475916","0.6473146","0.6470918","0.6467833","0.64539677","0.64515173","0.6420893","0.64185876","0.6411688","0.6407275","0.63988215","0.63951427","0.63759446"],"string":"[\n \"0.85816354\",\n \"0.8499633\",\n \"0.84875196\",\n \"0.8477434\",\n \"0.8317361\",\n \"0.82983124\",\n \"0.7956723\",\n \"0.79486096\",\n \"0.79430157\",\n \"0.79303133\",\n \"0.786467\",\n \"0.78199774\",\n \"0.7804541\",\n \"0.77982265\",\n \"0.77892864\",\n \"0.7778937\",\n \"0.7774032\",\n \"0.77076656\",\n \"0.769469\",\n \"0.7674665\",\n \"0.76132494\",\n \"0.7586847\",\n \"0.755116\",\n \"0.7530712\",\n \"0.7526752\",\n \"0.7523533\",\n \"0.7513227\",\n \"0.7478889\",\n \"0.7469069\",\n \"0.7457313\",\n \"0.74570984\",\n \"0.74337804\",\n \"0.7369632\",\n \"0.7360071\",\n \"0.733861\",\n \"0.7320642\",\n \"0.73052096\",\n \"0.729503\",\n \"0.7289895\",\n \"0.72887003\",\n \"0.72770596\",\n \"0.72473705\",\n \"0.7222387\",\n \"0.7208044\",\n \"0.719235\",\n \"0.71679604\",\n \"0.7153526\",\n \"0.7150469\",\n \"0.710654\",\n \"0.706295\",\n \"0.70348233\",\n \"0.7011982\",\n \"0.70065165\",\n \"0.70028466\",\n \"0.6996006\",\n \"0.6996006\",\n \"0.69649893\",\n \"0.6933982\",\n \"0.69303685\",\n \"0.69167125\",\n \"0.69065577\",\n \"0.6887639\",\n \"0.68863595\",\n \"0.686641\",\n \"0.68604296\",\n \"0.6856356\",\n \"0.68470645\",\n \"0.6837486\",\n \"0.6817671\",\n \"0.6786448\",\n \"0.6783264\",\n \"0.6772449\",\n \"0.6771106\",\n \"0.6740455\",\n \"0.66939646\",\n \"0.6689156\",\n \"0.6679865\",\n \"0.66773635\",\n \"0.6639536\",\n \"0.6638845\",\n \"0.6628173\",\n \"0.66155916\",\n \"0.65965223\",\n \"0.65707946\",\n \"0.6570739\",\n \"0.65279603\",\n \"0.65203416\",\n \"0.64853996\",\n \"0.6475916\",\n \"0.6473146\",\n \"0.6470918\",\n \"0.6467833\",\n \"0.64539677\",\n \"0.64515173\",\n \"0.6420893\",\n \"0.64185876\",\n \"0.6411688\",\n \"0.6407275\",\n \"0.63988215\",\n \"0.63951427\",\n \"0.63759446\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":22199,"cells":{"query":{"kind":"string","value":"Wrapper for function that require the user to be logged in to access the function"},"document":{"kind":"string","value":"def login_required(f):\n @wraps(f)\n def wrap(*args, **kwargs):\n if 'logged_in' in session:\n return f(*args, **kwargs)\n else:\n flash(\"You need to login first\")\n return redirect(url_for('login_page'))\n return wrap"},"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 dnzo_login_required(fn):\n def logged_in_wrapper(self, *args):\n from google.appengine.api.users import get_current_user\n dnzo_user = get_dnzo_user()\n \n if not dnzo_user and get_current_user():\n from tasks_data.users import create_user\n dnzo_user = create_user(get_current_user())\n \n if dnzo_user:\n fn(self, dnzo_user, *args)\n else:\n self.login_required()\n \n return logged_in_wrapper","def anonymous_required(func):\n\n async def wrapped(self, *args, **kwargs):\n if self.request.user is not None:\n print(\"Login please.\")\n # redirect(self.request, 'index')\n\n return await func(self, *args, **kwargs)\n\n return wrapped","def user_required(func):\n def check_login(self, *args, **kwargs):\n if not get_current_user():\n raise endpoints.UnauthorizedException('Invalid token.')\n else:\n return func(self, *args, **kwargs)\n return check_login","def login_required(function):\n def inner(request,*args,**kwargs):\n if not request.user.is_authenticated():\n return render(request,\"login.html\")\n return function(request,*args,**kwargs)\n return inner","def anonymous_required(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n if g.user:\n flash('You have been already logged in')\n return redirect(url_for('view.index'))\n return func(*args, **kwargs)\n return wrapper","def login_required(fn):\n\n def _dec(view_func):\n def _checklogin(request, *args, **kwargs):\n\n user = users.get_current_user()\n if user:\n return view_func(request, *args, **kwargs)\n\n else:\n return HttpResponseRedirect(users.create_login_url(request.get_full_path()))\n\n _checklogin.__doc__ = view_func.__doc__\n _checklogin.__dict__ = view_func.__dict__\n\n return _checklogin\n\n return _dec(fn)","def login_required(func):\n # def wrapper(*args):\n def wrapper(*args, **kwargs):\n \"\"\"\n Wrapper function is a must in decorators. This function does all\n the work, so we have to write TODO code implementation here.\n\n *args -> unnamed arguments passed in de function, avoid us to know\n every param for differet functions.\n \"\"\"\n if 'user' in args[0].session:\n return func(*args, **kwargs)\n else:\n return redirect('usuarios:render_login')\n\n return wrapper","def login_required(function):\n\n @wraps(function)\n def wrapper(self, *args, **kw):\n \"\"\"Redirect to main if user doesn't logged in. \"\"\"\n\n if not self.user:\n return self.redirect('/blog/login')\n return function(self, *args, **kw)\n return wrapper","def require_logged_in():\n def handler(f, *args, **kwargs):\n if args[0].current_user is not None:\n return f(*args, **kwargs)\n else:\n raise HTTPFound(args[0].route_url('user.login', _query={'redirect': encode_route(args[0])}))\n return decorator(handler)","def anonymous_required(func):\n\n async def wrapped(self, *args, **kwargs):\n if self.request.user is not None:\n add_message(self.request, \"Please log-out to continue.\")\n redirect(self.request, \"index\")\n return await func(self, *args, **kwargs)\n\n return wrapped","def require_auth(view):\n def wrapper(request, *args):\n \n if not request.session.get('user_id', False):\n return HttpResponseRedirect(\"/clanovi/login/\")\n \n return view(request, *args) \n return wrapper","def login_required(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n if 'username' in session:\n return func(*args, **kwargs)\n else:\n flash(\"You must be logged in to access that page.\", 'danger')\n return redirect(url_for('login'))\n return wrapper","def login_required(func):\n @functools.wraps(func)\n @private_cache_headers\n def is_user_logged_in(*args, **kwargs):\n if not authentication.is_authenticated(flask.session):\n return flask.redirect('login?next=' + flask.request.path)\n\n return func(*args, **kwargs)\n return is_user_logged_in","def require_user(func):\n\n @wraps(func)\n def decorator(*args, **kwargs):\n if not g.user:\n # flash('此操作需要登录账户')\n return render_template('account/error.html', error='抱歉，您无权进行该操作！')\n # return redirect(url_for('site.login'))\n return func(*args, **kwargs)\n\n return decorator","def login_required(func):\n def wrapper(self, request, *args, **kwargs):\n if not request.user.is_authenticated():\n raise ApiLoginRequired\n return func(self, request, *args, **kwargs)\n\n wrapper.requires_login = True\n return wraps(func, wrapper)","def login_required(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n if g.user is None:\n flash('You have to log in first')\n return redirect(url_for('authentication.login', next=url_for(request.endpoint)))\n return func(*args, **kwargs)\n return wrapper","def login_required(func):\n\n async def wrapped(self, *args, **kwargs):\n if self.request.user is None:\n add_message(self.request, \"LogIn to continue.\")\n redirect(self.request, \"sign_in\")\n return await func(self, *args, **kwargs)\n\n return wrapped","def loginrequired(f):\n def securedf(request, *args, **kwargs):\n if request.user.is_authenticated():\n return f(request, *args, **kwargs)\n else:\n return HttpResponseRedirect(ADMINURL)\n return securedf","def check_logged_in(function):\n @wraps(function)\n def wrapper(*args, **kwargs):\n if 'username' in login_session:\n return function(*args, **kwargs)\n else:\n return redirect(url_for('category_list_handler'))\n return wrapper","def login_required(func):\n @wraps(func)\n def wrapped(*args, **kwargs):\n if not session.get('logged_in', False):\n abort(401)\n return func(*args, **kwargs)\n return wrapped","def fn_wrapper(request, *args, **kwargs):\n user = get_user(request.user.username)\n if not user:\n return HttpResponseForbidden()\n if not user.seen_welcome:\n return HttpResponseRedirect('/about/')\n request.rooms_user = user\n return fn(request, *args, **kwargs)","def login_required(view_func):\r\n @wraps(view_func, assigned=available_attrs(view_func))\r\n def _wrapped_view_func(request, *args, **kwargs):\r\n if hasattr(request, \"session\") and request.session.get('is_logon', False) and request.user.is_active:\r\n return view_func(request, *args, **kwargs)\r\n else:\r\n return FailResponse(u'请先登录')\r\n return _wrapped_view_func","def wrapper(self, *args, **kw):\n\n if not self.user:\n return self.redirect('/blog/login')\n return function(self, *args, **kw)","def require_auth(function):\n @functools.wraps(function)\n def wrapper(self, *args, **kwargs):\n if not self.headers:\n raise LoginRequiredError\n return function(self, *args, **kwargs)\n return wrapper","def login_required(view_func):\n\n @wraps(view_func)\n def func(request, *args, **kwargs):\n if 'username' not in request.session:\n return redirect('portfolio.views.login')\n\n # to make this project simple\n # we do not save Account instance in context processor\n try:\n request.account = Account.objects.get(\n username=request.session['username'])\n except Account.DoesNotExist:\n pass\n\n return view_func(request, *args, **kwargs)\n\n return func","def authenticated(function):\n def wrapped(*args):\n \"\"\"Wrap function.\"\"\"\n try:\n return function(*args)\n except AESOPError:\n _LOGGER.debug(\"attempted to access page before login\")\n _LOGGER.debug(args[0])\n _login(args[0])\n return function(*args)\n return wrapped","def check_login_required(views_func):\n @wraps(views_func)\n def wrapper(request, *args, **kwargs):\n if request.user.is_authenticated:\n return views_func(request, *args, **kwargs)\n else:\n return HttpResponse(status=401)\n return wrapper","def user(func) :\n def redirectlogin(session, self) :\n setSessionMessage(session, \"Student Login required\", True)\n return self.redirect('/login')\n\n def checkauth(*args, **kwargs) : \n self = args[0]\n session = getSessionByRequest(self)\n user = getSessionUser(session)\n\n if not user :\n return redirectlogin(session, self)\n\n if user.userType == 'STUDENT' : \n return func(*args, **kwargs)\n\n return redirectlogin(session, self)\n return checkauth","def login_required(func):\n @wraps(func)\n def decorated_view(*args, **kwargs):\n current = users.get_current_user()\n if not current:\n return redirect(users.create_login_url(request.url))\n elif current.email() == 'akshayubhat@gmail.com':\n return func(*args, **kwargs)\n else:\n return redirect(users.create_logout_url(request.url))\n return decorated_view","def octp_require_auth(f):\n\n @functools.wraps(f)\n def authed_only_wrapper(*args, **kwargs):\n if authed():\n return f(*args, **kwargs)\n else:\n if request.content_type == 'application/json':\n abort(403)\n else:\n # return redirect(url_for('auth.login', next=request.full_path))\n return render_template('page.html', content=\"You need to be logged in to access this page!\")\n\n return authed_only_wrapper","def require_login_or_401(function):\n def wrap(request, *args, **kwargs):\n if request.user.is_anonymous:\n return Response({\"detail\": \"Must be logged in.\"}, status=401)\n return function(request, *args, **kwargs)\n return wrap","def login_required(func):\n\n def login_wrapper(request, *args, **kwds):\n if request.login_user is None:\n request.session['nextUrl'] = request.get_full_path().encode('utf-8')\n\n return HttpResponseRedirect(\n 'https://rdict.rpxnow.com/openid/v2/signin?token_url=http://localhost:8000/user/rpx' )\n return func(request, *args, **kwds)\n\n return login_wrapper","def login_required(func):\n @wraps(func)\n def f(*args, **kwargs):\n if g.user is None:\n app.logger.info('redirecting not logged in user')\n return redirect(url_for('index'))\n elif not g.user.initialized and f.__name__ not in ['profile_create','logout']:\n return redirect(url_for('profile_create'))\n else:\n return func(*args, **kwargs)\n return f","def login_required(func):\n\t@wraps(func)\n\tdef decorated_view(*args, **kwargs):\n\t\tif not users.get_current_user():\n\t\t\treturn redirect(users.create_login_url(request.url))\n\t\treturn func(*args, **kwargs)\n\treturn decorated_view","def login_required(f):\r\n @wraps(f)\r\n def decorated_function(*args, **kwargs):\r\n if session.get(\"user_id\") is None:\r\n flash(\"You must log in to view that page.\")\r\n return redirect(url_for(\"login\"))\r\n return f(*args, **kwargs)\r\n return decorated_function","def login_required(view_func):\n @wraps(view_func)\n def _checklogin(request, *args, **kwargs):\n if request.user.is_active:\n # The user is valid. Continue to the admin page.\n return view_func(request, *args, **kwargs)\n return site.login(request)\n return _checklogin","def auth_required(func):\n @wraps(func)\n def wrapper(request):\n if not request.user:\n return web.json_response({'status': 'error', 'message': 'auth required'}, status=401)\n return func(request)\n return wrapper","def login_required(f):\n @functools.wraps(f)\n def wrap(*args, **kwargs):\n if not user_session.is_auth:\n raise Forbidden()\n return f(*args, **kwargs)\n return wrap","def require_login(f):\n\n @wraps(f)\n def wrapper(*args, **kwds):\n if not api.user.is_logged_in():\n raise PicoException(\"You must be logged in\", 401)\n return f(*args, **kwds)\n\n return wrapper","def login_required(func):\n @wraps(func)\n def login(*args, **kwargs):\n # Redirect to login if user not logged in, else execute func.\n if 'username' not in login_session:\n return redirect('/login')\n return func(*args, **kwargs)\n return login","def login_user():\n pass","def login_required(f):\r\n @wraps(f)\r\n def decorated_function(*args, **kwargs):\r\n if session.get(\"user_id\") is None:\r\n return redirect(\"/login\")\r\n return f(*args, **kwargs)\r\n return decorated_function","def login_required(func):\n @wraps(func)\n def check_login(*args, **kwargs):\n # Redirect to login if user not logged in, else execute func.\n if 'username' not in login_session:\n return redirect('/login')\n else:\n return func(*args, **kwargs)\n return check_login","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(url_for(\"index\"))\n return f(*args, **kwargs)\n return decorated_function","def __wrapper(request, *args, **kwds):\n if request.user_is_admin:\n return func(request, *args, **kwds) # pylint: disable-msg=W0142\n else:\n return utility.forbidden(\n request,\n error_message='You must be an administrator to view this page.')","def login_required(func):\n @wraps(func)\n def decorated_view(*args, **kwargs):\n if current_app.login_manager._login_disabled:\n return func(*args, **kwargs)\n elif not current_user.is_authenticated and not current_user.is_active:\n return current_app.login_manager.unauthorized()\n return func(*args, **kwargs)\n\n return decorated_view","def login_required(view_function):\n\t@wraps(view_function) # Tells debuggers that is is a function wrapper\n\tdef decorator(*args, **kwargs):\n\t\tauth = current_app.auth\n\t\tallowed = False\n\t\t# User must be logged in\n\t\tif current_user.is_authenticated:\n\t\t\t# User must be verified (if required)\n\t\t\tif auth.AUTH_ENABLE_CONFIRM_ACCOUNT and current_user.verified:\n\t\t\t\tallowed=True\n\t\t\t# User can be not verified (if allowed)\n\t\t\telif not auth.AUTH_ENABLE_CONFIRM_ACCOUNT:\n\t\t\t\tallowed=True\n\t\tif not allowed:\n\t\t\t# Redirect to unauthenticated page\n\t\t\treturn auth.unauthenticated()\n\t\t# It's OK to call the view\n\t\treturn view_function(*args, **kwargs)\n\treturn decorator","def requires_auth(f):\n @functools.wraps(f)\n def wrapper(self, *args, **kwargs):\n if not users.get_current_user():\n try:\n self.DenyAccess()\n except Exception, e:\n self.handle_exception(e, self.app.debug)\n finally:\n self.session_store.save_sessions(self.response)\n else:\n return f(self, *args, **kwargs)\n return wrapper","def login_required(f):\r\n @wraps(f)\r\n def wrap(*args, **kwargs):\r\n if \"logged_in\" in session:\r\n return f(*args, **kwargs)\r\n return redirect(\"/user/login\")\r\n return wrap","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/sign_in\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def __wrapper(request, *args, **kwds):\n if request.profile.is_superuser:\n return func(request, *args, **kwds) # pylint: disable-msg=W0142\n else:\n return utility.forbidden(\n request,\n error_message='You must be a superuser to view this page.')","def anonymous_required(function=None):\n def _dec(view_func):\n def _view(request, *args, **kwargs):\n if request.user.is_authenticated():\n return redirect(reverse('core:home'))\n else:\n return view_func(request, *args, **kwargs)\n\n return _view\n\n if function is None:\n return _dec\n else:\n return _dec(function)","def check_user(fn):\n @wraps(fn)\n def fn_wrapper(request, *args, **kwargs):\n \"\"\"Redirect to welcome if not seen, add Rooms user to request.\"\"\"\n user = get_user(request.user.username)\n if not user:\n return HttpResponseForbidden()\n if not user.seen_welcome:\n return HttpResponseRedirect('/about/')\n request.rooms_user = user\n return fn(request, *args, **kwargs)\n\n return login_required(fn_wrapper)","def login_required(f):\n\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/login\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(func):\n def wrapper(*args, **kwargs):\n self = list(args)[0]\n if self.__logged:\n response = func(*args, **kwargs)\n else:\n return (self.__class__.error_value[\"NOT_CONNECTED\"], {\"status\": \"not connected\"})\n # post if needed\n return response\n return wrapper","def account_login_required(fn):\n @wraps(fn)\n def _wrapper(request, *args, **kwargs):\n if request.user is None:\n return HTTPFound(request.route_url(\"login\"))\n\n return fn(request, *args, **kwargs)\n\n return _wrapper","def require_login(func):\n @wraps(func)\n def wrapper(*args, **kwrds):\n try:\n user = get_user()\n if user:\n setattr(g, 'user', user)\n return func(*args, **kwrds)\n else:\n url = url_for('auth.login', redir=request.url)\n return redirect(url)\n except:\n exc_type, exc_value, exc_traceback = sys.exc_info()\n log = app_logger()\n log.warning(\"Unexpected error: %s\", exc_value)\n log.error(''.join(traceback.format_exception(\n exc_type, exc_value, exc_traceback\n )))\n return abort(500)\n\n return wrapper","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n # checks is user login\n if session.get(\"user_id\") is None:\n return redirect(url_for(\"login\", next=request.url))\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n\n @wraps(f)\n def wrapper(*args, **kwargs):\n if \"user_id\" in session:\n return f(*args, **kwargs)\n else:\n flash(\"Please login to access this page.\")\n return redirect('/login')\n\n return wrapper","def login_required(func):\n\n async def wrapped(self, *args, **kwargs):\n if self.request.user is None:\n await self.request.app.websocket.send_json({\n \"Type\": \"login\",\n \"Status\": \"error\"\n })\n await self.request.app.websocket.close()\n else:\n return await func(self, *args, **kwargs)\n\n return wrapped","def wrapper(*args, **kwargs):\n if 'user' in args[0].session:\n return func(*args, **kwargs)\n else:\n return redirect('usuarios:render_login')","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/\")\n return f(*args, **kwargs)\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"user_id\") is None:\n return redirect(\"/\")\n return f(*args, **kwargs)\n return decorated_function","def guest_access(func):\n def decorated(*_, **kwargs):\n public_profiles = current_app.config['USER_PUBLIC_PROFILES']\n if not public_profiles:\n if not current_user.is_authenticated:\n abort(401)\n elif current_user.id != kwargs['id']:\n abort(403)\n return func(**kwargs)\n\n return decorated","def inject_and_run(self,func,**kw):\r\n args=inspect.getargspec(func).args\r\n if 'request' in args:\r\n kw['request']=self.request\r\n if 'user' in args:\r\n user=self._get_user()\r\n if user:\r\n kw['user']=user\r\n else:\r\n raise UserWarning,'function need login ,but you are not login'\r\n \r\n return func(**kw)","def authenticated(func):\n\n def check_access_token(alexafied_request):\n \"\"\" :type alexafied_request AlexaRequest\"\"\"\n try:\n access_token = alexafied_request.access_token()\n except KeyError as e:\n print(\"User is probably not authenticated. error: \" + str(e) + \"missing\")\n return handle_error_states \\\n .handle_not_authenticated(alexafied_request)\n\n _remember_user_id(alexafied_request, access_token)\n return func(alexafied_request)\n\n return check_access_token","def user_required(f):\n def decorator(*args, **kwargs):\n if \"user\" not in g:\n abort(401)\n return f(*args, **kwargs)\n return decorator","def require_registered(function):\n\n @wraps(function)\n def wrap(request, *args, **kwargs):\n decorated_view_func = login_required(request)\n if not decorated_view_func.user.is_authenticated:\n return decorated_view_func(request) # return redirect to login\n\n if request.user.password_disposition != User.FULL:\n return redirect('set-password')\n else:\n return function(request, *args, **kwargs)\n\n return wrap","def user_required(handler):\n def check_login(self, *args, **kwargs):\n auth = self.auth\n if not auth.get_user_by_session():\n self.redirect(self.uri_for('login'), abort=True)\n else:\n return handler(self, *args, **kwargs)\n \n return check_login","def login_required(func):\n @wraps(func)\n def decorated_function(*args, **kwargs):\n \"\"\" Modified descriprition of the decorated function \"\"\"\n if not session.get('username'):\n flash('Login to continue', 'warning')\n return redirect(url_for('sign_in', next=request.url))\n return func(*args, **kwargs)\n return decorated_function","def fas_login_required(function):\n @wraps(function)\n def decorated_function(*args, **kwargs):\n if flask.g.fas_user is None:\n return flask.redirect(flask.url_for('auth_login',\n next=flask.request.url))\n return function(*args, **kwargs)\n return decorated_function","def same_user_from_request_required(function):\n def wrapper(request, *args, **kwargs):\n if int(request.user.id) == int(kwargs['pk']):\n return function(request, *args, **kwargs)\n else:\n return HttpResponse(\"Your Jedi tricks don't work on me\",\n status=403)\n\n return wrapper","def login_required_api(view_fn):\n @wraps(view_fn)\n def _wrapped_view_fn(request, *args, **kwargs):\n if request.user.is_authenticated():\n # id user is logged in, return the function\n return view_fn(request, *args, **kwargs)\n else:\n # if user is not logged in send a failure response\n response = {\n 'status': 400,\n 'message': 'Please login to view this page'\n }\n return JsonResponse(response, status=401)\n return _wrapped_view_fn","def decorated_function(*args, **kwargs):\n if not session.get('username'):\n flash('Login to continue', 'warning')\n return redirect(url_for('sign_in', next=request.url))\n return func(*args, **kwargs)","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if 'user_id' not in login_session:\n flash('User not allowed to access')\n return redirect('/login')\n return f(*args, **kwargs)\n return decorated_function","def login_required(func):\n\n @wraps(func)\n def wrapper(*args, **kwargs):\n if 'username' not in login_session:\n return redirect('login')\n else:\n return func(*args, **kwargs)\n return wrapper","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n try:\n if session['user_id']:\n pass\n except KeyError:\n return redirect(url_for('users.login', next=request.url))\n return f(*args, **kwargs)\n return decorated_function","def user_required(handler):\n def check_login(self, *args, **kwargs):\n auth = self.auth\n if not auth.get_user_by_session():\n self.redirect(self.uri_for('login'), abort=True)\n else:\n return handler(self, *args, **kwargs)\n\n return check_login","def logged_in(request):\n return request.current_user is not None","def token_required(func):\n @wraps(func)\n def wrapper(self, *args, **kwargs):\n #wrapper of current func\n\n #take csrf-token from cookies\n token = request.cookies.get('token')\n if not token:\n #returning login page\n flash(\"Authentication required\", category='danger')\n return redirect(url_for('login'))\n #decoding token\n try:\n uuid = jwt.decode(token, app.config['SECRET_KEY'], algorithms=[\"HS256\"])['user_id']\n except:\n #returning login page\n flash(\"Token timeout\", category='danger')\n return redirect(url_for('login'))\n #get current user\n user = User.query.filter_by(uuid=uuid).first()\n if not user:\n #returning login page\n flash(\"Profile error\", category='danger')\n return redirect(url_for('login'))\n return func(self, *args, **kwargs)\n\n return wrapper","def check_authentication(function_to_decorate):\r\n @wraps(function_to_decorate)\r\n def decorated_function(*args, **kwargs):\r\n if not hasattr(g, \"my\"):\r\n abort(401)\r\n return function_to_decorate(*args, **kwargs)\r\n return decorated_function","def login_web_required(view_func):\r\n @wraps(view_func, assigned=available_attrs(view_func))\r\n def _wrapped_view_func(request, *args, **kwargs):\r\n if hasattr(request, \"session\") and request.session.get('is_logon', False) and request.user.is_active:\r\n return view_func(request, *args, **kwargs)\r\n else:\r\n return HttpResponse(FailResponse(u'请先登录'))\r\n return _wrapped_view_func","def requires_admin(method):\r\n def wrapper(self, *args, **kwargs):\r\n user = users.get_current_user()\r\n if not user:\r\n if web.ctx.method == \"GET\":\r\n raise web.seeother(users.create_login_url(web.ctx.fullpath))\r\n raise web.forbidden()\r\n elif not (users.is_current_user_admin()):\r\n raise web.forbidden()\r\n else:\r\n return method(self, *args, **kwargs)\r\n return wrapper","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if session.get(\"username\") is None:\n return redirect(\"/signin\")\n return f(*args, **kwargs)\n return decorated_function","def user_login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if not current_user.is_authenticated:\n # Flash warning that user login is required\n flash(\"Logged in user only.\", category=\"error\")\n # Return redirect to login\n return redirect(url_for('main.login'))\n if current_user.banned:\n # Log user out so they can't access their account\n logout_user()\n # Flash warning that user has been banned\n flash(\"You have been banned, please contact an admin.\",\n category=\"error\")\n # Return redirect to index\n return redirect(url_for('main.index'))\n return f(*args, **kwargs)\n return decorated_function","def wrapper(self, *args, **kwargs):\n user = users.get_current_user()\n if not user:\n self.write_error(401)\n elif not users.is_current_user_admin():\n self.write_error(403)\n else:\n handler_method(self, *args, **kwargs)","def login_required(f):\n\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if g.USER is None:\n return redirect(\n url_for(\"home\", force_login=True, next=request.url)\n )\n\n return f(*args, **kwargs)\n\n return decorated_function","def login_required(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if 'username' in login_session:\n return f(*args, **kwargs)\n else:\n flash(\"You are not allowed to access there\")\n return redirect('/login')\n return decorated_function","def function_call(f):\n def args_call(*args, **kw):\n handler = args[0]\n helper = RequestHelper(handler)\n if not users.get_current_user():\n helper.header(error_header, error_msg)\n helper.error(403)\n else:\n f(*args, **kw)\n return args_call"],"string":"[\n \"def dnzo_login_required(fn):\\n def logged_in_wrapper(self, *args):\\n from google.appengine.api.users import get_current_user\\n dnzo_user = get_dnzo_user()\\n \\n if not dnzo_user and get_current_user():\\n from tasks_data.users import create_user\\n dnzo_user = create_user(get_current_user())\\n \\n if dnzo_user:\\n fn(self, dnzo_user, *args)\\n else:\\n self.login_required()\\n \\n return logged_in_wrapper\",\n \"def anonymous_required(func):\\n\\n async def wrapped(self, *args, **kwargs):\\n if self.request.user is not None:\\n print(\\\"Login please.\\\")\\n # redirect(self.request, 'index')\\n\\n return await func(self, *args, **kwargs)\\n\\n return wrapped\",\n \"def user_required(func):\\n def check_login(self, *args, **kwargs):\\n if not get_current_user():\\n raise endpoints.UnauthorizedException('Invalid token.')\\n else:\\n return func(self, *args, **kwargs)\\n return check_login\",\n \"def login_required(function):\\n def inner(request,*args,**kwargs):\\n if not request.user.is_authenticated():\\n return render(request,\\\"login.html\\\")\\n return function(request,*args,**kwargs)\\n return inner\",\n \"def anonymous_required(func):\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n if g.user:\\n flash('You have been already logged in')\\n return redirect(url_for('view.index'))\\n return func(*args, **kwargs)\\n return wrapper\",\n \"def login_required(fn):\\n\\n def _dec(view_func):\\n def _checklogin(request, *args, **kwargs):\\n\\n user = users.get_current_user()\\n if user:\\n return view_func(request, *args, **kwargs)\\n\\n else:\\n return HttpResponseRedirect(users.create_login_url(request.get_full_path()))\\n\\n _checklogin.__doc__ = view_func.__doc__\\n _checklogin.__dict__ = view_func.__dict__\\n\\n return _checklogin\\n\\n return _dec(fn)\",\n \"def login_required(func):\\n # def wrapper(*args):\\n def wrapper(*args, **kwargs):\\n \\\"\\\"\\\"\\n Wrapper function is a must in decorators. This function does all\\n the work, so we have to write TODO code implementation here.\\n\\n *args -> unnamed arguments passed in de function, avoid us to know\\n every param for differet functions.\\n \\\"\\\"\\\"\\n if 'user' in args[0].session:\\n return func(*args, **kwargs)\\n else:\\n return redirect('usuarios:render_login')\\n\\n return wrapper\",\n \"def login_required(function):\\n\\n @wraps(function)\\n def wrapper(self, *args, **kw):\\n \\\"\\\"\\\"Redirect to main if user doesn't logged in. \\\"\\\"\\\"\\n\\n if not self.user:\\n return self.redirect('/blog/login')\\n return function(self, *args, **kw)\\n return wrapper\",\n \"def require_logged_in():\\n def handler(f, *args, **kwargs):\\n if args[0].current_user is not None:\\n return f(*args, **kwargs)\\n else:\\n raise HTTPFound(args[0].route_url('user.login', _query={'redirect': encode_route(args[0])}))\\n return decorator(handler)\",\n \"def anonymous_required(func):\\n\\n async def wrapped(self, *args, **kwargs):\\n if self.request.user is not None:\\n add_message(self.request, \\\"Please log-out to continue.\\\")\\n redirect(self.request, \\\"index\\\")\\n return await func(self, *args, **kwargs)\\n\\n return wrapped\",\n \"def require_auth(view):\\n def wrapper(request, *args):\\n \\n if not request.session.get('user_id', False):\\n return HttpResponseRedirect(\\\"/clanovi/login/\\\")\\n \\n return view(request, *args) \\n return wrapper\",\n \"def login_required(func):\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n if 'username' in session:\\n return func(*args, **kwargs)\\n else:\\n flash(\\\"You must be logged in to access that page.\\\", 'danger')\\n return redirect(url_for('login'))\\n return wrapper\",\n \"def login_required(func):\\n @functools.wraps(func)\\n @private_cache_headers\\n def is_user_logged_in(*args, **kwargs):\\n if not authentication.is_authenticated(flask.session):\\n return flask.redirect('login?next=' + flask.request.path)\\n\\n return func(*args, **kwargs)\\n return is_user_logged_in\",\n \"def require_user(func):\\n\\n @wraps(func)\\n def decorator(*args, **kwargs):\\n if not g.user:\\n # flash('此操作需要登录账户')\\n return render_template('account/error.html', error='抱歉，您无权进行该操作！')\\n # return redirect(url_for('site.login'))\\n return func(*args, **kwargs)\\n\\n return decorator\",\n \"def login_required(func):\\n def wrapper(self, request, *args, **kwargs):\\n if not request.user.is_authenticated():\\n raise ApiLoginRequired\\n return func(self, request, *args, **kwargs)\\n\\n wrapper.requires_login = True\\n return wraps(func, wrapper)\",\n \"def login_required(func):\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n if g.user is None:\\n flash('You have to log in first')\\n return redirect(url_for('authentication.login', next=url_for(request.endpoint)))\\n return func(*args, **kwargs)\\n return wrapper\",\n \"def login_required(func):\\n\\n async def wrapped(self, *args, **kwargs):\\n if self.request.user is None:\\n add_message(self.request, \\\"LogIn to continue.\\\")\\n redirect(self.request, \\\"sign_in\\\")\\n return await func(self, *args, **kwargs)\\n\\n return wrapped\",\n \"def loginrequired(f):\\n def securedf(request, *args, **kwargs):\\n if request.user.is_authenticated():\\n return f(request, *args, **kwargs)\\n else:\\n return HttpResponseRedirect(ADMINURL)\\n return securedf\",\n \"def check_logged_in(function):\\n @wraps(function)\\n def wrapper(*args, **kwargs):\\n if 'username' in login_session:\\n return function(*args, **kwargs)\\n else:\\n return redirect(url_for('category_list_handler'))\\n return wrapper\",\n \"def login_required(func):\\n @wraps(func)\\n def wrapped(*args, **kwargs):\\n if not session.get('logged_in', False):\\n abort(401)\\n return func(*args, **kwargs)\\n return wrapped\",\n \"def fn_wrapper(request, *args, **kwargs):\\n user = get_user(request.user.username)\\n if not user:\\n return HttpResponseForbidden()\\n if not user.seen_welcome:\\n return HttpResponseRedirect('/about/')\\n request.rooms_user = user\\n return fn(request, *args, **kwargs)\",\n \"def login_required(view_func):\\r\\n @wraps(view_func, assigned=available_attrs(view_func))\\r\\n def _wrapped_view_func(request, *args, **kwargs):\\r\\n if hasattr(request, \\\"session\\\") and request.session.get('is_logon', False) and request.user.is_active:\\r\\n return view_func(request, *args, **kwargs)\\r\\n else:\\r\\n return FailResponse(u'请先登录')\\r\\n return _wrapped_view_func\",\n \"def wrapper(self, *args, **kw):\\n\\n if not self.user:\\n return self.redirect('/blog/login')\\n return function(self, *args, **kw)\",\n \"def require_auth(function):\\n @functools.wraps(function)\\n def wrapper(self, *args, **kwargs):\\n if not self.headers:\\n raise LoginRequiredError\\n return function(self, *args, **kwargs)\\n return wrapper\",\n \"def login_required(view_func):\\n\\n @wraps(view_func)\\n def func(request, *args, **kwargs):\\n if 'username' not in request.session:\\n return redirect('portfolio.views.login')\\n\\n # to make this project simple\\n # we do not save Account instance in context processor\\n try:\\n request.account = Account.objects.get(\\n username=request.session['username'])\\n except Account.DoesNotExist:\\n pass\\n\\n return view_func(request, *args, **kwargs)\\n\\n return func\",\n \"def authenticated(function):\\n def wrapped(*args):\\n \\\"\\\"\\\"Wrap function.\\\"\\\"\\\"\\n try:\\n return function(*args)\\n except AESOPError:\\n _LOGGER.debug(\\\"attempted to access page before login\\\")\\n _LOGGER.debug(args[0])\\n _login(args[0])\\n return function(*args)\\n return wrapped\",\n \"def check_login_required(views_func):\\n @wraps(views_func)\\n def wrapper(request, *args, **kwargs):\\n if request.user.is_authenticated:\\n return views_func(request, *args, **kwargs)\\n else:\\n return HttpResponse(status=401)\\n return wrapper\",\n \"def user(func) :\\n def redirectlogin(session, self) :\\n setSessionMessage(session, \\\"Student Login required\\\", True)\\n return self.redirect('/login')\\n\\n def checkauth(*args, **kwargs) : \\n self = args[0]\\n session = getSessionByRequest(self)\\n user = getSessionUser(session)\\n\\n if not user :\\n return redirectlogin(session, self)\\n\\n if user.userType == 'STUDENT' : \\n return func(*args, **kwargs)\\n\\n return redirectlogin(session, self)\\n return checkauth\",\n \"def login_required(func):\\n @wraps(func)\\n def decorated_view(*args, **kwargs):\\n current = users.get_current_user()\\n if not current:\\n return redirect(users.create_login_url(request.url))\\n elif current.email() == 'akshayubhat@gmail.com':\\n return func(*args, **kwargs)\\n else:\\n return redirect(users.create_logout_url(request.url))\\n return decorated_view\",\n \"def octp_require_auth(f):\\n\\n @functools.wraps(f)\\n def authed_only_wrapper(*args, **kwargs):\\n if authed():\\n return f(*args, **kwargs)\\n else:\\n if request.content_type == 'application/json':\\n abort(403)\\n else:\\n # return redirect(url_for('auth.login', next=request.full_path))\\n return render_template('page.html', content=\\\"You need to be logged in to access this page!\\\")\\n\\n return authed_only_wrapper\",\n \"def require_login_or_401(function):\\n def wrap(request, *args, **kwargs):\\n if request.user.is_anonymous:\\n return Response({\\\"detail\\\": \\\"Must be logged in.\\\"}, status=401)\\n return function(request, *args, **kwargs)\\n return wrap\",\n \"def login_required(func):\\n\\n def login_wrapper(request, *args, **kwds):\\n if request.login_user is None:\\n request.session['nextUrl'] = request.get_full_path().encode('utf-8')\\n\\n return HttpResponseRedirect(\\n 'https://rdict.rpxnow.com/openid/v2/signin?token_url=http://localhost:8000/user/rpx' )\\n return func(request, *args, **kwds)\\n\\n return login_wrapper\",\n \"def login_required(func):\\n @wraps(func)\\n def f(*args, **kwargs):\\n if g.user is None:\\n app.logger.info('redirecting not logged in user')\\n return redirect(url_for('index'))\\n elif not g.user.initialized and f.__name__ not in ['profile_create','logout']:\\n return redirect(url_for('profile_create'))\\n else:\\n return func(*args, **kwargs)\\n return f\",\n \"def login_required(func):\\n\\t@wraps(func)\\n\\tdef decorated_view(*args, **kwargs):\\n\\t\\tif not users.get_current_user():\\n\\t\\t\\treturn redirect(users.create_login_url(request.url))\\n\\t\\treturn func(*args, **kwargs)\\n\\treturn decorated_view\",\n \"def login_required(f):\\r\\n @wraps(f)\\r\\n def decorated_function(*args, **kwargs):\\r\\n if session.get(\\\"user_id\\\") is None:\\r\\n flash(\\\"You must log in to view that page.\\\")\\r\\n return redirect(url_for(\\\"login\\\"))\\r\\n return f(*args, **kwargs)\\r\\n return decorated_function\",\n \"def login_required(view_func):\\n @wraps(view_func)\\n def _checklogin(request, *args, **kwargs):\\n if request.user.is_active:\\n # The user is valid. Continue to the admin page.\\n return view_func(request, *args, **kwargs)\\n return site.login(request)\\n return _checklogin\",\n \"def auth_required(func):\\n @wraps(func)\\n def wrapper(request):\\n if not request.user:\\n return web.json_response({'status': 'error', 'message': 'auth required'}, status=401)\\n return func(request)\\n return wrapper\",\n \"def login_required(f):\\n @functools.wraps(f)\\n def wrap(*args, **kwargs):\\n if not user_session.is_auth:\\n raise Forbidden()\\n return f(*args, **kwargs)\\n return wrap\",\n \"def require_login(f):\\n\\n @wraps(f)\\n def wrapper(*args, **kwds):\\n if not api.user.is_logged_in():\\n raise PicoException(\\\"You must be logged in\\\", 401)\\n return f(*args, **kwds)\\n\\n return wrapper\",\n \"def login_required(func):\\n @wraps(func)\\n def login(*args, **kwargs):\\n # Redirect to login if user not logged in, else execute func.\\n if 'username' not in login_session:\\n return redirect('/login')\\n return func(*args, **kwargs)\\n return login\",\n \"def login_user():\\n pass\",\n \"def login_required(f):\\r\\n @wraps(f)\\r\\n def decorated_function(*args, **kwargs):\\r\\n if session.get(\\\"user_id\\\") is None:\\r\\n return redirect(\\\"/login\\\")\\r\\n return f(*args, **kwargs)\\r\\n return decorated_function\",\n \"def login_required(func):\\n @wraps(func)\\n def check_login(*args, **kwargs):\\n # Redirect to login if user not logged in, else execute func.\\n if 'username' not in login_session:\\n return redirect('/login')\\n else:\\n return func(*args, **kwargs)\\n return check_login\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(url_for(\\\"index\\\"))\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def __wrapper(request, *args, **kwds):\\n if request.user_is_admin:\\n return func(request, *args, **kwds) # pylint: disable-msg=W0142\\n else:\\n return utility.forbidden(\\n request,\\n error_message='You must be an administrator to view this page.')\",\n \"def login_required(func):\\n @wraps(func)\\n def decorated_view(*args, **kwargs):\\n if current_app.login_manager._login_disabled:\\n return func(*args, **kwargs)\\n elif not current_user.is_authenticated and not current_user.is_active:\\n return current_app.login_manager.unauthorized()\\n return func(*args, **kwargs)\\n\\n return decorated_view\",\n \"def login_required(view_function):\\n\\t@wraps(view_function) # Tells debuggers that is is a function wrapper\\n\\tdef decorator(*args, **kwargs):\\n\\t\\tauth = current_app.auth\\n\\t\\tallowed = False\\n\\t\\t# User must be logged in\\n\\t\\tif current_user.is_authenticated:\\n\\t\\t\\t# User must be verified (if required)\\n\\t\\t\\tif auth.AUTH_ENABLE_CONFIRM_ACCOUNT and current_user.verified:\\n\\t\\t\\t\\tallowed=True\\n\\t\\t\\t# User can be not verified (if allowed)\\n\\t\\t\\telif not auth.AUTH_ENABLE_CONFIRM_ACCOUNT:\\n\\t\\t\\t\\tallowed=True\\n\\t\\tif not allowed:\\n\\t\\t\\t# Redirect to unauthenticated page\\n\\t\\t\\treturn auth.unauthenticated()\\n\\t\\t# It's OK to call the view\\n\\t\\treturn view_function(*args, **kwargs)\\n\\treturn decorator\",\n \"def requires_auth(f):\\n @functools.wraps(f)\\n def wrapper(self, *args, **kwargs):\\n if not users.get_current_user():\\n try:\\n self.DenyAccess()\\n except Exception, e:\\n self.handle_exception(e, self.app.debug)\\n finally:\\n self.session_store.save_sessions(self.response)\\n else:\\n return f(self, *args, **kwargs)\\n return wrapper\",\n \"def login_required(f):\\r\\n @wraps(f)\\r\\n def wrap(*args, **kwargs):\\r\\n if \\\"logged_in\\\" in session:\\r\\n return f(*args, **kwargs)\\r\\n return redirect(\\\"/user/login\\\")\\r\\n return wrap\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/sign_in\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def __wrapper(request, *args, **kwds):\\n if request.profile.is_superuser:\\n return func(request, *args, **kwds) # pylint: disable-msg=W0142\\n else:\\n return utility.forbidden(\\n request,\\n error_message='You must be a superuser to view this page.')\",\n \"def anonymous_required(function=None):\\n def _dec(view_func):\\n def _view(request, *args, **kwargs):\\n if request.user.is_authenticated():\\n return redirect(reverse('core:home'))\\n else:\\n return view_func(request, *args, **kwargs)\\n\\n return _view\\n\\n if function is None:\\n return _dec\\n else:\\n return _dec(function)\",\n \"def check_user(fn):\\n @wraps(fn)\\n def fn_wrapper(request, *args, **kwargs):\\n \\\"\\\"\\\"Redirect to welcome if not seen, add Rooms user to request.\\\"\\\"\\\"\\n user = get_user(request.user.username)\\n if not user:\\n return HttpResponseForbidden()\\n if not user.seen_welcome:\\n return HttpResponseRedirect('/about/')\\n request.rooms_user = user\\n return fn(request, *args, **kwargs)\\n\\n return login_required(fn_wrapper)\",\n \"def login_required(f):\\n\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/login\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(func):\\n def wrapper(*args, **kwargs):\\n self = list(args)[0]\\n if self.__logged:\\n response = func(*args, **kwargs)\\n else:\\n return (self.__class__.error_value[\\\"NOT_CONNECTED\\\"], {\\\"status\\\": \\\"not connected\\\"})\\n # post if needed\\n return response\\n return wrapper\",\n \"def account_login_required(fn):\\n @wraps(fn)\\n def _wrapper(request, *args, **kwargs):\\n if request.user is None:\\n return HTTPFound(request.route_url(\\\"login\\\"))\\n\\n return fn(request, *args, **kwargs)\\n\\n return _wrapper\",\n \"def require_login(func):\\n @wraps(func)\\n def wrapper(*args, **kwrds):\\n try:\\n user = get_user()\\n if user:\\n setattr(g, 'user', user)\\n return func(*args, **kwrds)\\n else:\\n url = url_for('auth.login', redir=request.url)\\n return redirect(url)\\n except:\\n exc_type, exc_value, exc_traceback = sys.exc_info()\\n log = app_logger()\\n log.warning(\\\"Unexpected error: %s\\\", exc_value)\\n log.error(''.join(traceback.format_exception(\\n exc_type, exc_value, exc_traceback\\n )))\\n return abort(500)\\n\\n return wrapper\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n # checks is user login\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(url_for(\\\"login\\\", next=request.url))\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n\\n @wraps(f)\\n def wrapper(*args, **kwargs):\\n if \\\"user_id\\\" in session:\\n return f(*args, **kwargs)\\n else:\\n flash(\\\"Please login to access this page.\\\")\\n return redirect('/login')\\n\\n return wrapper\",\n \"def login_required(func):\\n\\n async def wrapped(self, *args, **kwargs):\\n if self.request.user is None:\\n await self.request.app.websocket.send_json({\\n \\\"Type\\\": \\\"login\\\",\\n \\\"Status\\\": \\\"error\\\"\\n })\\n await self.request.app.websocket.close()\\n else:\\n return await func(self, *args, **kwargs)\\n\\n return wrapped\",\n \"def wrapper(*args, **kwargs):\\n if 'user' in args[0].session:\\n return func(*args, **kwargs)\\n else:\\n return redirect('usuarios:render_login')\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"user_id\\\") is None:\\n return redirect(\\\"/\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def guest_access(func):\\n def decorated(*_, **kwargs):\\n public_profiles = current_app.config['USER_PUBLIC_PROFILES']\\n if not public_profiles:\\n if not current_user.is_authenticated:\\n abort(401)\\n elif current_user.id != kwargs['id']:\\n abort(403)\\n return func(**kwargs)\\n\\n return decorated\",\n \"def inject_and_run(self,func,**kw):\\r\\n args=inspect.getargspec(func).args\\r\\n if 'request' in args:\\r\\n kw['request']=self.request\\r\\n if 'user' in args:\\r\\n user=self._get_user()\\r\\n if user:\\r\\n kw['user']=user\\r\\n else:\\r\\n raise UserWarning,'function need login ,but you are not login'\\r\\n \\r\\n return func(**kw)\",\n \"def authenticated(func):\\n\\n def check_access_token(alexafied_request):\\n \\\"\\\"\\\" :type alexafied_request AlexaRequest\\\"\\\"\\\"\\n try:\\n access_token = alexafied_request.access_token()\\n except KeyError as e:\\n print(\\\"User is probably not authenticated. error: \\\" + str(e) + \\\"missing\\\")\\n return handle_error_states \\\\\\n .handle_not_authenticated(alexafied_request)\\n\\n _remember_user_id(alexafied_request, access_token)\\n return func(alexafied_request)\\n\\n return check_access_token\",\n \"def user_required(f):\\n def decorator(*args, **kwargs):\\n if \\\"user\\\" not in g:\\n abort(401)\\n return f(*args, **kwargs)\\n return decorator\",\n \"def require_registered(function):\\n\\n @wraps(function)\\n def wrap(request, *args, **kwargs):\\n decorated_view_func = login_required(request)\\n if not decorated_view_func.user.is_authenticated:\\n return decorated_view_func(request) # return redirect to login\\n\\n if request.user.password_disposition != User.FULL:\\n return redirect('set-password')\\n else:\\n return function(request, *args, **kwargs)\\n\\n return wrap\",\n \"def user_required(handler):\\n def check_login(self, *args, **kwargs):\\n auth = self.auth\\n if not auth.get_user_by_session():\\n self.redirect(self.uri_for('login'), abort=True)\\n else:\\n return handler(self, *args, **kwargs)\\n \\n return check_login\",\n \"def login_required(func):\\n @wraps(func)\\n def decorated_function(*args, **kwargs):\\n \\\"\\\"\\\" Modified descriprition of the decorated function \\\"\\\"\\\"\\n if not session.get('username'):\\n flash('Login to continue', 'warning')\\n return redirect(url_for('sign_in', next=request.url))\\n return func(*args, **kwargs)\\n return decorated_function\",\n \"def fas_login_required(function):\\n @wraps(function)\\n def decorated_function(*args, **kwargs):\\n if flask.g.fas_user is None:\\n return flask.redirect(flask.url_for('auth_login',\\n next=flask.request.url))\\n return function(*args, **kwargs)\\n return decorated_function\",\n \"def same_user_from_request_required(function):\\n def wrapper(request, *args, **kwargs):\\n if int(request.user.id) == int(kwargs['pk']):\\n return function(request, *args, **kwargs)\\n else:\\n return HttpResponse(\\\"Your Jedi tricks don't work on me\\\",\\n status=403)\\n\\n return wrapper\",\n \"def login_required_api(view_fn):\\n @wraps(view_fn)\\n def _wrapped_view_fn(request, *args, **kwargs):\\n if request.user.is_authenticated():\\n # id user is logged in, return the function\\n return view_fn(request, *args, **kwargs)\\n else:\\n # if user is not logged in send a failure response\\n response = {\\n 'status': 400,\\n 'message': 'Please login to view this page'\\n }\\n return JsonResponse(response, status=401)\\n return _wrapped_view_fn\",\n \"def decorated_function(*args, **kwargs):\\n if not session.get('username'):\\n flash('Login to continue', 'warning')\\n return redirect(url_for('sign_in', next=request.url))\\n return func(*args, **kwargs)\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if 'user_id' not in login_session:\\n flash('User not allowed to access')\\n return redirect('/login')\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def login_required(func):\\n\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n if 'username' not in login_session:\\n return redirect('login')\\n else:\\n return func(*args, **kwargs)\\n return wrapper\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n try:\\n if session['user_id']:\\n pass\\n except KeyError:\\n return redirect(url_for('users.login', next=request.url))\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def user_required(handler):\\n def check_login(self, *args, **kwargs):\\n auth = self.auth\\n if not auth.get_user_by_session():\\n self.redirect(self.uri_for('login'), abort=True)\\n else:\\n return handler(self, *args, **kwargs)\\n\\n return check_login\",\n \"def logged_in(request):\\n return request.current_user is not None\",\n \"def token_required(func):\\n @wraps(func)\\n def wrapper(self, *args, **kwargs):\\n #wrapper of current func\\n\\n #take csrf-token from cookies\\n token = request.cookies.get('token')\\n if not token:\\n #returning login page\\n flash(\\\"Authentication required\\\", category='danger')\\n return redirect(url_for('login'))\\n #decoding token\\n try:\\n uuid = jwt.decode(token, app.config['SECRET_KEY'], algorithms=[\\\"HS256\\\"])['user_id']\\n except:\\n #returning login page\\n flash(\\\"Token timeout\\\", category='danger')\\n return redirect(url_for('login'))\\n #get current user\\n user = User.query.filter_by(uuid=uuid).first()\\n if not user:\\n #returning login page\\n flash(\\\"Profile error\\\", category='danger')\\n return redirect(url_for('login'))\\n return func(self, *args, **kwargs)\\n\\n return wrapper\",\n \"def check_authentication(function_to_decorate):\\r\\n @wraps(function_to_decorate)\\r\\n def decorated_function(*args, **kwargs):\\r\\n if not hasattr(g, \\\"my\\\"):\\r\\n abort(401)\\r\\n return function_to_decorate(*args, **kwargs)\\r\\n return decorated_function\",\n \"def login_web_required(view_func):\\r\\n @wraps(view_func, assigned=available_attrs(view_func))\\r\\n def _wrapped_view_func(request, *args, **kwargs):\\r\\n if hasattr(request, \\\"session\\\") and request.session.get('is_logon', False) and request.user.is_active:\\r\\n return view_func(request, *args, **kwargs)\\r\\n else:\\r\\n return HttpResponse(FailResponse(u'请先登录'))\\r\\n return _wrapped_view_func\",\n \"def requires_admin(method):\\r\\n def wrapper(self, *args, **kwargs):\\r\\n user = users.get_current_user()\\r\\n if not user:\\r\\n if web.ctx.method == \\\"GET\\\":\\r\\n raise web.seeother(users.create_login_url(web.ctx.fullpath))\\r\\n raise web.forbidden()\\r\\n elif not (users.is_current_user_admin()):\\r\\n raise web.forbidden()\\r\\n else:\\r\\n return method(self, *args, **kwargs)\\r\\n return wrapper\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if session.get(\\\"username\\\") is None:\\n return redirect(\\\"/signin\\\")\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def user_login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if not current_user.is_authenticated:\\n # Flash warning that user login is required\\n flash(\\\"Logged in user only.\\\", category=\\\"error\\\")\\n # Return redirect to login\\n return redirect(url_for('main.login'))\\n if current_user.banned:\\n # Log user out so they can't access their account\\n logout_user()\\n # Flash warning that user has been banned\\n flash(\\\"You have been banned, please contact an admin.\\\",\\n category=\\\"error\\\")\\n # Return redirect to index\\n return redirect(url_for('main.index'))\\n return f(*args, **kwargs)\\n return decorated_function\",\n \"def wrapper(self, *args, **kwargs):\\n user = users.get_current_user()\\n if not user:\\n self.write_error(401)\\n elif not users.is_current_user_admin():\\n self.write_error(403)\\n else:\\n handler_method(self, *args, **kwargs)\",\n \"def login_required(f):\\n\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if g.USER is None:\\n return redirect(\\n url_for(\\\"home\\\", force_login=True, next=request.url)\\n )\\n\\n return f(*args, **kwargs)\\n\\n return decorated_function\",\n \"def login_required(f):\\n @wraps(f)\\n def decorated_function(*args, **kwargs):\\n if 'username' in login_session:\\n return f(*args, **kwargs)\\n else:\\n flash(\\\"You are not allowed to access there\\\")\\n return redirect('/login')\\n return decorated_function\",\n \"def function_call(f):\\n def args_call(*args, **kw):\\n handler = args[0]\\n helper = RequestHelper(handler)\\n if not users.get_current_user():\\n helper.header(error_header, error_msg)\\n helper.error(403)\\n else:\\n f(*args, **kw)\\n return args_call\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79133797","0.7734768","0.77311295","0.7664327","0.76305085","0.75790405","0.7569456","0.7517191","0.75057024","0.74649686","0.7450219","0.7421285","0.7417829","0.74123853","0.7400424","0.73878455","0.73771745","0.7367976","0.7355343","0.7328803","0.73203635","0.7319892","0.73013675","0.7288286","0.7247976","0.7234542","0.72338086","0.72296673","0.7214365","0.72043824","0.71994984","0.71839905","0.7179624","0.71704173","0.71615833","0.7157073","0.7149749","0.71470165","0.7140625","0.7133151","0.7120083","0.7114402","0.7109639","0.71044534","0.70959955","0.709027","0.70902675","0.7085632","0.7079105","0.7070866","0.7057044","0.7057044","0.7057044","0.7057044","0.7057044","0.7057044","0.7057044","0.7057044","0.7057044","0.7057044","0.7057044","0.70523477","0.70441055","0.7042549","0.70386785","0.70359087","0.7029318","0.70242536","0.7019811","0.701278","0.701262","0.6991733","0.6988416","0.6988416","0.69814336","0.69769984","0.69741446","0.69718087","0.69619185","0.69602937","0.69483894","0.69421685","0.6937949","0.69375515","0.6936341","0.692486","0.6919412","0.6904853","0.68948066","0.68945956","0.6892712","0.6880791","0.6873712","0.6872888","0.6856929","0.6852755","0.68396425","0.68359476","0.6835912","0.6829229"],"string":"[\n \"0.79133797\",\n \"0.7734768\",\n \"0.77311295\",\n \"0.7664327\",\n \"0.76305085\",\n \"0.75790405\",\n \"0.7569456\",\n \"0.7517191\",\n \"0.75057024\",\n \"0.74649686\",\n \"0.7450219\",\n \"0.7421285\",\n \"0.7417829\",\n \"0.74123853\",\n \"0.7400424\",\n \"0.73878455\",\n \"0.73771745\",\n \"0.7367976\",\n \"0.7355343\",\n \"0.7328803\",\n \"0.73203635\",\n \"0.7319892\",\n \"0.73013675\",\n \"0.7288286\",\n \"0.7247976\",\n \"0.7234542\",\n \"0.72338086\",\n \"0.72296673\",\n \"0.7214365\",\n \"0.72043824\",\n \"0.71994984\",\n \"0.71839905\",\n \"0.7179624\",\n \"0.71704173\",\n \"0.71615833\",\n \"0.7157073\",\n \"0.7149749\",\n \"0.71470165\",\n \"0.7140625\",\n \"0.7133151\",\n \"0.7120083\",\n \"0.7114402\",\n \"0.7109639\",\n \"0.71044534\",\n \"0.70959955\",\n \"0.709027\",\n \"0.70902675\",\n \"0.7085632\",\n \"0.7079105\",\n \"0.7070866\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.7057044\",\n \"0.70523477\",\n \"0.70441055\",\n \"0.7042549\",\n \"0.70386785\",\n \"0.70359087\",\n \"0.7029318\",\n \"0.70242536\",\n \"0.7019811\",\n \"0.701278\",\n \"0.701262\",\n \"0.6991733\",\n \"0.6988416\",\n \"0.6988416\",\n \"0.69814336\",\n \"0.69769984\",\n \"0.69741446\",\n \"0.69718087\",\n \"0.69619185\",\n \"0.69602937\",\n \"0.69483894\",\n \"0.69421685\",\n \"0.6937949\",\n \"0.69375515\",\n \"0.6936341\",\n \"0.692486\",\n \"0.6919412\",\n \"0.6904853\",\n \"0.68948066\",\n \"0.68945956\",\n \"0.6892712\",\n \"0.6880791\",\n \"0.6873712\",\n \"0.6872888\",\n \"0.6856929\",\n \"0.6852755\",\n \"0.68396425\",\n \"0.68359476\",\n \"0.6835912\",\n \"0.6829229\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68923974"},"document_rank":{"kind":"string","value":"91"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":221,"numItemsPerPage":100,"numTotalItems":95772,"offset":22100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjY0MTQ5NywianRpIjoiYzZlNWI3MTQtZTdjOS00NzE3LWJjMjMtMDUzNTNjNDJlMWY5Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY2NDUwOTcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.y5Ywf70pBTiQF5j9Ai_pSAEDKE2043pYrnbnxezoKJDzJkvspVkXPOHqcAlIWyBAe07OLPDTUy99Lwgl_6AdCA","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 |
|---|---|---|---|---|---|---|
r""" Calculate partial derivatives for all mass flow balance equations. Returns | def pressure_equality_deriv(self):
deriv = np.zeros((
self.num_i,
self.num_i + self.num_o + self.num_vars,
self.num_nw_vars))
for i in range(self.num_i):
deriv[i, i, 1] = 1
for j in range(self.num_o):
deriv[j, j + i + 1, 1] = -1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_partial_derivatives(self) -> List[Callable]:\n return [self.dfdm, self.dfdc]",
"def get_partial_derivatives(self) -> List[Callable]:\n return [self.dfda, self.dfdb, self.dfdc]",
"def get_partial_derivatives(self) -> List[Callable]:\n pass",
"def get_partial_derivatives(self) -> L... | [
"0.69162154",
"0.6853647",
"0.67594445",
"0.6673241",
"0.6545024",
"0.64935243",
"0.62200797",
"0.620985",
"0.6177202",
"0.6167387",
"0.61136556",
"0.6039098",
"0.6008735",
"0.59830254",
"0.58655566",
"0.5859061",
"0.5858246",
"0.5791166",
"0.5747807",
"0.57467055",
"0.571906... | 0.0 | -1 |
r""" Equation for enthalpy equality. Returns | def enthalpy_equality_func(self):
residual = []
for i in range(self.num_i):
residual += [self.inl[i].h.val_SI - self.outl[i].h.val_SI]
return residual | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eq(self, y):\n return 1 - self.ne(y)",
"def test_eq():\n x, y = fwd.Variable(), fwd.Variable()\n f = fwd.sin(x) + fwd.cos(y)\n g = fwd.sin(x) + fwd.cos(y)\n h = fwd.sin(y) + fwd.cos(x)\n assert f == g\n assert f != h",
"def eq(w, x):\n return (-w[1]*x - w[0]) / w[2]",
"def app... | [
"0.72163594",
"0.6572929",
"0.64220047",
"0.6372147",
"0.63588005",
"0.63034874",
"0.63034415",
"0.6296396",
"0.61809176",
"0.61430204",
"0.6112071",
"0.6105242",
"0.6103117",
"0.59963846",
"0.59832895",
"0.5966638",
"0.5931339",
"0.5931339",
"0.59277314",
"0.59069747",
"0.58... | 0.552821 | 57 |
r""" Equation for enthalpy equality. | def enthalpy_equality_func_doc(self, label):
indices = list(range(1, self.num_i + 1))
if len(indices) > 1:
indices = ', '.join(str(idx) for idx in indices)
else:
indices = str(indices[0])
latex = (
r'0=h_{\mathrm{in,}i}-h_{\mathrm{out,}i}'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eq(self, y):\n return 1 - self.ne(y)",
"def test_eq():\n x, y = fwd.Variable(), fwd.Variable()\n f = fwd.sin(x) + fwd.cos(y)\n g = fwd.sin(x) + fwd.cos(y)\n h = fwd.sin(y) + fwd.cos(x)\n assert f == g\n assert f != h",
"def approx_eq(a, b):\n return abs(a-b) < approx_eq.eps",
"def... | [
"0.7227859",
"0.68298554",
"0.65850955",
"0.6529753",
"0.6415574",
"0.6413417",
"0.6253247",
"0.6227349",
"0.622424",
"0.6195919",
"0.61716175",
"0.61604255",
"0.6095463",
"0.6074481",
"0.60640705",
"0.60602427",
"0.6055815",
"0.60390425",
"0.6030247",
"0.5979934",
"0.5963339... | 0.5910232 | 27 |
r""" Calculate partial derivatives for all mass flow balance equations. Returns | def enthalpy_equality_deriv(self):
deriv = np.zeros((
self.num_i,
self.num_i + self.num_o + self.num_vars,
self.num_nw_vars))
for i in range(self.num_i):
deriv[i, i, 2] = 1
for j in range(self.num_o):
deriv[j, j + i + 1, 2] = -1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_partial_derivatives(self) -> List[Callable]:\n return [self.dfdm, self.dfdc]",
"def get_partial_derivatives(self) -> List[Callable]:\n return [self.dfda, self.dfdb, self.dfdc]",
"def get_partial_derivatives(self) -> List[Callable]:\n pass",
"def get_partial_derivatives(self) -> L... | [
"0.69166714",
"0.6854371",
"0.67591727",
"0.6673994",
"0.6546838",
"0.6495122",
"0.6223377",
"0.6213386",
"0.61802274",
"0.61696965",
"0.61169827",
"0.603798",
"0.60112125",
"0.5985211",
"0.5868262",
"0.5861571",
"0.58611006",
"0.57943255",
"0.57502186",
"0.5747824",
"0.57195... | 0.0 | -1 |
r""" Calculate partial derivative of the function func to dx. | def numeric_deriv(self, func, dx, pos, **kwargs):
if dx == 'fluid':
d = 1e-5
conns = self.inl + self.outl
deriv = []
for f in conns[0].fluid.val.keys():
val = conns[pos].fluid.val[f]
if conns[pos].fluid.val[f] + d <= 1:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def derivative(func: Callable, x: float, delta: float) -> float:\n return (func(x + delta) - func(x - delta)) / (2.0 * delta)",
"def partial ( index , func , x , h = 0 , I = 2 , err = False ) :\n \n if len(x) <= index :\n raise AttributeError(\"Invalid argument length/index %d/%d\" % ( len(x) ,... | [
"0.74434185",
"0.7060871",
"0.68484694",
"0.6697642",
"0.668096",
"0.6528208",
"0.65230405",
"0.64844745",
"0.6433414",
"0.6405804",
"0.6405804",
"0.6385867",
"0.63094604",
"0.6278588",
"0.6277184",
"0.625846",
"0.62240064",
"0.6217861",
"0.6195724",
"0.6194013",
"0.6184296",... | 0.6718723 | 3 |
r""" Calculate residual value of pressure ratio function. | def pr_func(self, pr='', inconn=0, outconn=0):
pr = self.get_attr(pr)
return (self.inl[inconn].p.val_SI * pr.val -
self.outl[outconn].p.val_SI) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _residual(function, p, x, y, y_err):\n return (y - function(p, x)) / y_err",
"def _residual_edp(self, params):\n data = self.F**2\n model = np.absolute(self._model())**2\n sigma = self.sigma\n return (data[self.mask]-model[self.mask]) / sigma[self.mask] \n \n # The following thre... | [
"0.7320426",
"0.7242871",
"0.7097744",
"0.7031296",
"0.6963993",
"0.67645216",
"0.67397034",
"0.67394376",
"0.6636221",
"0.66181105",
"0.65203583",
"0.64543605",
"0.6426633",
"0.6420456",
"0.6416985",
"0.6415228",
"0.6405344",
"0.6398041",
"0.6379706",
"0.63678235",
"0.635110... | 0.0 | -1 |
r""" Calculate residual value of pressure ratio function. | def pr_func_doc(self, label, pr='', inconn=0, outconn=0):
latex = (
r'0=p_\mathrm{in,' + str(inconn + 1) + r'}\cdot ' + pr +
r' - p_\mathrm{out,' + str(outconn + 1) + r'}'
)
return generate_latex_eq(self, latex, label) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _residual(function, p, x, y, y_err):\n return (y - function(p, x)) / y_err",
"def _residual_edp(self, params):\n data = self.F**2\n model = np.absolute(self._model())**2\n sigma = self.sigma\n return (data[self.mask]-model[self.mask]) / sigma[self.mask] \n \n # The following thre... | [
"0.7316333",
"0.72417086",
"0.7095481",
"0.7029726",
"0.69612294",
"0.6761161",
"0.6738927",
"0.67381686",
"0.6632527",
"0.66165334",
"0.65197164",
"0.64523154",
"0.6423218",
"0.6419319",
"0.6416038",
"0.64138085",
"0.64055014",
"0.63972145",
"0.63791317",
"0.6365383",
"0.634... | 0.0 | -1 |
r""" Calculate residual value of pressure ratio function. | def pr_deriv(self, increment_filter, k, pr='', inconn=0, outconn=0):
pr = self.get_attr(pr)
self.jacobian[k, inconn, 1] = pr.val
self.jacobian[k, self.num_i + outconn, 1] = -1
if pr.is_var:
pos = self.num_i + self.num_o + pr.var_pos
self.jacobian[k, pos, 0] = self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _residual(function, p, x, y, y_err):\n return (y - function(p, x)) / y_err",
"def _residual_edp(self, params):\n data = self.F**2\n model = np.absolute(self._model())**2\n sigma = self.sigma\n return (data[self.mask]-model[self.mask]) / sigma[self.mask] \n \n # The following thre... | [
"0.7317166",
"0.7241593",
"0.7096314",
"0.70310277",
"0.696248",
"0.6761167",
"0.67380136",
"0.6737368",
"0.66329026",
"0.66160154",
"0.6517937",
"0.64518714",
"0.64236796",
"0.6417426",
"0.64142925",
"0.6412702",
"0.64039814",
"0.63953936",
"0.6378967",
"0.6367071",
"0.63486... | 0.0 | -1 |
r""" Calculate partial derivatives of zeta function. | def zeta_deriv(self, increment_filter, k, zeta='', inconn=0, outconn=0):
data = self.get_attr(zeta)
f = self.zeta_func
outpos = self.num_i + outconn
if not increment_filter[inconn, 0]:
self.jacobian[k, inconn, 0] = self.numeric_deriv(
f, 'm', inconn, zeta=zeta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zeta_function(s,a = 1,derivative = 0):\n return mp.zeta(s,a,derivative)",
"def zeta(z, x, beta2):\n return 3 * (4* z**2 - beta2 * x**2) / 4 / beta2 / (1+x)",
"def get_partial_derivatives(self) -> List[Callable]:\n return [self.dfda, self.dfdb, self.dfdc]",
"def get_partial_derivatives(self) ... | [
"0.69251996",
"0.65251493",
"0.6342588",
"0.63092345",
"0.6277536",
"0.62325907",
"0.622904",
"0.6221183",
"0.62180126",
"0.6203884",
"0.6199135",
"0.6153695",
"0.61268854",
"0.61135817",
"0.6100138",
"0.60925937",
"0.60837436",
"0.6048938",
"0.60380226",
"0.60230154",
"0.601... | 0.56824744 | 36 |
Return the name of the function (by default ``cls.__name__``). | def get_name(cls):
return cls.__name__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def function_name(cls):\n function_name = String(cls.__name__).snakecase().lower()\n return function_name",
"def name(cls):\n return arg.s()(cls.func).func.__name__",
"def name(self) -> str:\n return f\"{self.class_object.__name__}.{self.method_str}\"",
"def name(self):\n\t\tretur... | [
"0.8982793",
"0.89001125",
"0.8251001",
"0.81543905",
"0.80965793",
"0.80046344",
"0.79779893",
"0.7962162",
"0.7913996",
"0.77748555",
"0.7666854",
"0.7648686",
"0.76190066",
"0.75459355",
"0.7543037",
"0.7542202",
"0.7538365",
"0.7538365",
"0.7520372",
"0.7520372",
"0.75094... | 0.80846125 | 5 |
Return an executable string representation. This method returns a string so that ``eval(cls.vrepr())`` returns a new `BvFunction` object with the same content. | def vrepr(cls):
return cls.__name__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self) -> str:\n return f\"<Function[{self.name}](line:{self.line})>\"",
"def __repr__(self):\n klass = self.__class__.__qualname__\n cmd = \" \".join(sys.argv)\n cmd_ = f\"$ {cmd}\"\n args = pformat(self.get_args())\n repr_ = \"\\n\".join((klass, cmd_, args)... | [
"0.62824535",
"0.6251113",
"0.5906001",
"0.5871243",
"0.58202857",
"0.5671611",
"0.56357455",
"0.5634955",
"0.5599026",
"0.5592916",
"0.5587618",
"0.5570723",
"0.5525011",
"0.5512445",
"0.5512445",
"0.5512445",
"0.5488936",
"0.54781395",
"0.547464",
"0.54700714",
"0.5468626",... | 0.60587823 | 2 |
Evaluate the function (internal method). | def eval(cls, *args):
raise NotImplementedError("subclasses need to override this method") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate():\n\t\t\t\tif not hasattr(evaluate, 'value'):\n\t\t\t\t\tevaluate.value = func()\n\t\t\t\treturn evaluate.value",
"def evaluate(self):\n\t\t\t\tif not hasattr(evaluate, 'value'):\n\t\t\t\t\tevaluate.value = func(self)\n\t\t\t\treturn evaluate.value",
"def evaluateFunction(self):\n self.fun... | [
"0.8363948",
"0.78347844",
"0.7824756",
"0.7722459",
"0.7700503",
"0.76522034",
"0.76522034",
"0.7525874",
"0.7351423",
"0.7336749",
"0.72013867",
"0.7196898",
"0.7179211",
"0.70989",
"0.708847",
"0.70747817",
"0.6979192",
"0.6976476",
"0.692613",
"0.68623143",
"0.6814982",
... | 0.0 | -1 |
Return the `SSA` object of the bitvector function. | def to_ssa(cls, input_names, id_prefix, decompose_sec_ops=False, **ssa_options):
assert len(input_names) == len(cls.input_widths), \
f"len({input_names}) != len({cls.input_widths})"
for name in input_names:
if name.startswith(id_prefix):
raise ValueError(f"input_n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_function(self):\n return SSAFunction(self.get_graph())",
"def get_ssa(self):\n return copy.deepcopy(self.ssa)",
"def scalar():\n # noinspection PyUnusedLocal\n def sf(x, params, const_list, const_dict):\n a = params[0]\n return a\n return FitFunction(func=sf, num_fi... | [
"0.59186536",
"0.5916549",
"0.54296654",
"0.54059696",
"0.51643413",
"0.5145664",
"0.5135719",
"0.51271075",
"0.5097717",
"0.5081484",
"0.50415355",
"0.49774262",
"0.49741253",
"0.49423516",
"0.48969316",
"0.4870019",
"0.48033428",
"0.4800495",
"0.4792813",
"0.4789164",
"0.47... | 0.0 | -1 |
Log a message during the evaluation of the bitvector function. This method is meant to be used within `eval` to log the values of internal variables. At the beggining of each evaluation, messages logged from the last evaluation are automatically removed. >>> from cascada.bitvector.ssa import BvFunction | def log_msg(cls, format_string, format_field_objects=None):
if cls._logger is None:
cls._logger = []
assert isinstance(format_string, str)
if format_field_objects is None:
format_field_objects = []
elif isinstance(format_field_objects, core.Term):
form... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vlog(self, msg, *args):\n if self.verbose:\n self.log(msg, *args)",
"def vlog(self, msg, *args):\n if self.verbose:\n self.log(msg, *args)",
"def log(self, message):\n if VERBOSE:\n print self, message",
"def log(a):",
"def _log_bessel_ive_fwd(v, z):\n out... | [
"0.62713313",
"0.62713313",
"0.6053605",
"0.6013692",
"0.594068",
"0.58749473",
"0.5814132",
"0.57811236",
"0.57482165",
"0.5680488",
"0.5664882",
"0.5664408",
"0.56519717",
"0.5640365",
"0.56122565",
"0.556684",
"0.5513507",
"0.5511428",
"0.5496824",
"0.546377",
"0.54475796"... | 0.0 | -1 |
Return the list of logged messages. If the bitvector function includes `log_msg` calls in its ``eval``, this method return the list of messages logged in the last evaluation with the format field objects applied. Otherwise, an exception is raised. See also `log_msg`. | def get_formatted_logged_msgs(cls):
if cls._logger is None:
raise ValueError("eval must be called before get_formatted_logged_msgs")
list_msgs = []
for format_string, format_field_objects in cls._logger:
list_msgs.append(format_string.format(*format_field_objects))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetchLogs(self):\n return [record.msg for record in self.handler.buffer]",
"def logged_messages(self):\n return self._logged_messages",
"def get_log_messages(self, instance):\n return LogMessageSerializer(instance.log_messages, many=True).data",
"def getLogs():\n # in flux, it... | [
"0.6443969",
"0.6088012",
"0.59338963",
"0.5926019",
"0.5836273",
"0.58012664",
"0.5783213",
"0.5783213",
"0.5766307",
"0.5717272",
"0.57159305",
"0.5616483",
"0.55946606",
"0.5492802",
"0.5484665",
"0.5484665",
"0.5435299",
"0.54241",
"0.53707105",
"0.5340541",
"0.5327934",
... | 0.7781618 | 0 |
Return the DOT description of the expression tree of the function. See also `printing.dotprinting`. | def dotprinting(cls, input_names, repeat=True, vrepr_label=False, **kwargs):
from cascada.bitvector.printing import dotprinting
from sympy import Tuple
assert len(input_names) == len(cls.input_widths), \
f"len({input_names}) != len({cls.input_widths})"
input_vars = []
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _print_dot(_self, expr):\r\n return r'{((%s) \\cdot (%s))}' % (expr.args[0], expr.args[1])",
"def get_dot(self):\n return \"digraph G{\\n%s}\" % (\"\" if self.val is None else (\n \"\\t%s;\\n%s\\n\" % (\n self.val,\n \"\\n\".join(self._get_dot())\n ... | [
"0.7274833",
"0.6839633",
"0.6839633",
"0.6806022",
"0.6744544",
"0.6415222",
"0.62801",
"0.6089003",
"0.6071469",
"0.6069807",
"0.6057924",
"0.60115856",
"0.5987226",
"0.5931708",
"0.59149814",
"0.5914613",
"0.5905294",
"0.5896731",
"0.5862462",
"0.58334196",
"0.5823697",
... | 0.0 | -1 |
Return the class name and the current number of rounds. | def get_name(cls):
return f"{super().get_name()}_{cls.num_rounds}R" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def report_rounds(self):\n return print(f\"Total Rounds played: {sum([self.wins, self.draws, self.losses])}\")",
"def vrepr(cls):\n return f\"{super().vrepr()}.set_num_rounds_and_return({cls.num_rounds})\"",
"def count_one_round(self):\n\t\tself.round_count+=1\n\t\treturn self.round_count",
"de... | [
"0.6289936",
"0.6277111",
"0.61140394",
"0.59419346",
"0.585802",
"0.5823698",
"0.58067185",
"0.57185745",
"0.5677853",
"0.5667394",
"0.56487215",
"0.559757",
"0.5528206",
"0.54875326",
"0.5471102",
"0.5463627",
"0.5463372",
"0.5451482",
"0.5443987",
"0.54125917",
"0.54034907... | 0.72071 | 0 |
Return the `SSA` object of the roundbased bitvector function. This method calls `BvFunction.to_ssa` with the same argument list, and stores the round outputs in the `SSA` object if `add_round_outputs` calls were added in ``eval``. | def to_ssa(cls, input_names, id_prefix, decompose_sec_ops=False, **ssa_options):
my_ssa = super().to_ssa(input_names, id_prefix, decompose_sec_ops=decompose_sec_ops, **ssa_options)
if cls._rounds_outputs is not None:
my_ssa._rounds_outputs = cls._rounds_outputs[:]
return my_ssa | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_bvfunction(self):\n _input_widths = [v.width for v in self.input_vars]\n _output_widths = [v.width for v in self.output_vars]\n\n class MyBvFunction(BvFunction):\n input_widths = _input_widths\n output_widths = _output_widths\n _ssa = self\n\n ... | [
"0.5443392",
"0.4841223",
"0.48364985",
"0.48349917",
"0.4701788",
"0.4483575",
"0.44465578",
"0.44207594",
"0.4366836",
"0.43557042",
"0.4316889",
"0.43090743",
"0.42799342",
"0.4275801",
"0.42707747",
"0.4246866",
"0.42396498",
"0.41845697",
"0.41824216",
"0.4165671",
"0.41... | 0.5147074 | 1 |
Set `RoundBasedFunction.num_rounds` and update `input_widths` and ``output_widths`` if necessary. | def set_num_rounds(cls, new_num_rounds):
raise NotImplementedError("subclasses need to override this method") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_num_rounds_and_return(cls, new_num_rounds):\n cls.set_num_rounds(new_num_rounds)\n return cls",
"def roundParameters(self, roundNum):\n ruleName = random.choice(self.state.ruleNames)\n return SupportedRules[ruleName].makeRoundParameters(self, roundNum)",
"def _refresh_width(... | [
"0.5804964",
"0.5515761",
"0.5343894",
"0.5200584",
"0.5151792",
"0.49409455",
"0.49409455",
"0.49409455",
"0.49409455",
"0.49409455",
"0.49409455",
"0.49409455",
"0.49409455",
"0.49409455",
"0.49409455",
"0.49409455",
"0.4925701",
"0.4892504",
"0.48858312",
"0.48690236",
"0.... | 0.66365224 | 0 |
Call `set_num_rounds` and return ``cls``. | def set_num_rounds_and_return(cls, new_num_rounds):
cls.set_num_rounds(new_num_rounds)
return cls | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_num_rounds(cls, new_num_rounds):\n raise NotImplementedError(\"subclasses need to override this method\")",
"def vrepr(cls):\n return f\"{super().vrepr()}.set_num_rounds_and_return({cls.num_rounds})\"",
"def newRound():\r\n pass",
"def rounds(self):\n if self.round_number > 0:... | [
"0.7139906",
"0.58930886",
"0.5714936",
"0.53902805",
"0.5324967",
"0.52531534",
"0.5185726",
"0.50927013",
"0.4869179",
"0.48575476",
"0.485736",
"0.48567307",
"0.4828904",
"0.48038808",
"0.47967023",
"0.4774418",
"0.47364053",
"0.47306034",
"0.47172225",
"0.47037777",
"0.46... | 0.728035 | 0 |
Return an executable string representation. This method returns a string so that ``eval(cls.vrepr())`` returns a new `RoundBasedFunction` object with the same content. | def vrepr(cls):
return f"{super().vrepr()}.set_num_rounds_and_return({cls.num_rounds})" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self) -> str:\n return f\"<Function[{self.name}](line:{self.line})>\"",
"def __repr__(self):\n klass = self.__class__.__qualname__\n cmd = \" \".join(sys.argv)\n cmd_ = f\"$ {cmd}\"\n args = pformat(self.get_args())\n repr_ = \"\\n\".join((klass, cmd_, args)... | [
"0.6381232",
"0.62576866",
"0.6033041",
"0.5931942",
"0.5882333",
"0.5824581",
"0.5792414",
"0.5779144",
"0.5772641",
"0.5750893",
"0.5713249",
"0.57122695",
"0.56870997",
"0.56870997",
"0.56870997",
"0.5680717",
"0.56408143",
"0.56408143",
"0.5618542",
"0.56091654",
"0.55859... | 0.53370327 | 50 |
Store the current round outputs in the evaluation of the roundbased function. This method is meant to be used within ``eval`` to store the outputs of each round. At the beggining of each evaluation, round ouputs stored in the last evaluation are automatically removed. >>> from cascada.bitvector.core import Variable >>>... | def add_round_outputs(cls, *args):
if len(args) == 1 and isinstance(args[0], collections.abc.Sequence):
args = args[0]
if not all(isinstance(bv, core.Term) for bv in args):
raise ValueError("the arguments of add_round_outputs must be a bit-vectors")
if cls._rounds_outputs... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_rounds_outputs(cls):\n if cls._rounds_outputs is None:\n raise ValueError(\"eval must be called before get_rounds_outputs\")\n return cls._rounds_outputs",
"def finish_online_evaluation_extended(self, task):\n # -- Get current True-Positive, False-Positive and False-Negati... | [
"0.59688175",
"0.50948775",
"0.50851893",
"0.5033911",
"0.5004858",
"0.49138117",
"0.49109364",
"0.4891425",
"0.48766336",
"0.48639855",
"0.4859146",
"0.4850809",
"0.48478952",
"0.48452222",
"0.48435432",
"0.4841556",
"0.48407587",
"0.48317122",
"0.48224238",
"0.48160973",
"0... | 0.49290508 | 5 |
Return the list of round outputs obtained in the last evaluation. See also `add_round_outputs`. | def get_rounds_outputs(cls):
if cls._rounds_outputs is None:
raise ValueError("eval must be called before get_rounds_outputs")
return cls._rounds_outputs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_round_separators(self):\n if getattr(self, \"_rounds_outputs\", None) is None:\n return None\n if len(self._rounds_outputs) == 0:\n return None\n return self._rounds_outputs[:-1]",
"def outputs(self):\n return self._outputs if self._outputs else [self.uto... | [
"0.6637656",
"0.6438899",
"0.62058717",
"0.61304086",
"0.61035067",
"0.6090151",
"0.6051942",
"0.600966",
"0.59717953",
"0.59507537",
"0.59507537",
"0.59088373",
"0.59074545",
"0.5906354",
"0.5867009",
"0.57934654",
"0.57923913",
"0.5694699",
"0.5679354",
"0.5678499",
"0.5628... | 0.77957076 | 0 |
Check whether the last assignments are SSAReturn of the output variables. | def _are_last_assignments_valid(assignments, output_vars, ignore_exception=True):
assert isinstance(assignments, collections.OrderedDict)
if len(assignments) == 0:
return False
last_assignments = []
for assign_outvar in reversed(assignments):
last_assignments.appe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_return(\n ret_type: None | IntType | ReferenceType, returned: Sequence[BitString]\n) -> None:\n if len(returned) > 1:\n raise ValueError(\"code block returns multiple values\")\n\n if ret_type is None:\n if len(returned) != 0:\n raise ValueError(\n 'funct... | [
"0.5993794",
"0.5920944",
"0.5595559",
"0.5568826",
"0.55436",
"0.54635245",
"0.5395138",
"0.5378417",
"0.53685534",
"0.5290771",
"0.52233475",
"0.5216341",
"0.5209409",
"0.5198429",
"0.5192773",
"0.51814836",
"0.5171536",
"0.51640624",
"0.51598394",
"0.5133761",
"0.51216966"... | 0.751274 | 0 |
Return an executable string representation. This method returns a string so that ``eval(self.vrepr())`` returns a new `SSA` object with the same content. >>> from cascada.bitvector.core import Variable >>> from cascada.bitvector.operation import BvXor, BvIdentity >>> from cascada.bitvector.ssa import BvFunction >>> z =... | def vrepr(self):
return "{}(input_vars={}, output_vars={}, assignments={}{})".format(
type(self).__name__,
f"[{', '.join([v.vrepr() for v in self.input_vars])}]",
f"[{', '.join([v.vrepr() for v in self.output_vars])}]",
f"[{', '.join([f'({v.vrepr()}, {e.vrepr()})'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _repr_(self):\n s = 'An equation '\n have_A = not self.A().is_zero()\n if have_A:\n s += repr(self.A()) + ' x '\n if self.b()>=0:\n if have_A:\n s += '+'\n else:\n s += '-'\n if have_A:\n s += ' '\n s +=... | [
"0.61188376",
"0.61188376",
"0.60854304",
"0.6069777",
"0.6012829",
"0.5928467",
"0.5817199",
"0.58145636",
"0.5814443",
"0.5811863",
"0.57879734",
"0.5767751",
"0.57263815",
"0.5706116",
"0.5697784",
"0.5687782",
"0.5685565",
"0.56687975",
"0.5661975",
"0.56314254",
"0.56243... | 0.6500199 | 0 |
Return two strings (header and body) of a C function evalauting the SSA. This method returns two strings (the function header and the function body) of a function in the C programming language that computes the SSA. The C function is of ``void`` type and its list of arguments consists of the input variables, the extern... | def get_C_code(self, C_function_name):
from cascada.bitvector.printing import BvCCodePrinter
width2type = BvCCodePrinter._width2C_type
# in C, * binds to the declarator, not the type specifier
input_vars_c = ', '.join(["{} {}".format(width2type(v.width), v.name) for v in self.input_var... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_func_body(func_name, arg_dict, return_type):\n body = \"\"\n arg_list = \"\"\n\n # the following are pointers to scalar outputs\n # Note: pBufferSize was renamed pBufferSizeInBytes in v6.5\n scalar_ptr_outputs = ['nnzTotalDevHostPtr',\n 'pBufferSize',\n ... | [
"0.6069087",
"0.5914765",
"0.57788587",
"0.562777",
"0.56116414",
"0.56074697",
"0.56074697",
"0.5592773",
"0.5562327",
"0.55166125",
"0.5506797",
"0.5430662",
"0.53873694",
"0.5343953",
"0.5333583",
"0.5295312",
"0.5277339",
"0.527095",
"0.5228903",
"0.522377",
"0.51906025",... | 0.67547506 | 0 |
Evaluate the SSA with `Constant` inputs and return the `Constant` outputs. If some external variable is not given, it is replaced by the zero bitvector. >>> from cascada.bitvector.core import Variable, Constant >>> from cascada.bitvector.ssa import BvFunction >>> z = Variable("z", 8) | def eval(self, input_vals, external_var2val=None, C_code=False, **kwargs):
if external_var2val is None:
external_var2val = {}
if C_code:
# avoid extra asserts in C_code
header, body = self.get_C_code("eval_ssa")
pymod, tmpdir = _compile_C_code(header, bod... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_constant_as_input():\n\n def get_graph():\n dtype = \"uint8\"\n ifm = relay.var(\"ifm\", shape=(1, 16, 16, 32), dtype=dtype)\n conv1 = make_ethosu_conv2d(\n ifm,\n 32,\n 16,\n (1, 1),\n (0, 0),\n (1, 1),\n ... | [
"0.6012145",
"0.5996732",
"0.55745286",
"0.53239137",
"0.53122634",
"0.52333456",
"0.515926",
"0.51506853",
"0.5062008",
"0.50229603",
"0.49808976",
"0.4980357",
"0.49650252",
"0.4947497",
"0.4945761",
"0.49244228",
"0.48902893",
"0.4867831",
"0.48487085",
"0.48447675",
"0.48... | 0.546965 | 3 |
Return a `BvFunction` that evaluates ``self``. The returned `BvFunction` stores ``self`` in the ``_ssa`` attribute. Moreover, the method `BvFunction.to_ssa` of the returned `BvFunction` raises an exception unless it is called with the same arguments that were used to create ``_ssa`` (in this case ``_ssa`` is returned).... | def to_bvfunction(self):
_input_widths = [v.width for v in self.input_vars]
_output_widths = [v.width for v in self.output_vars]
class MyBvFunction(BvFunction):
input_widths = _input_widths
output_widths = _output_widths
_ssa = self
@classmethod
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_function(self):\n return SSAFunction(self.get_graph())",
"def get_ssa(self, name='main'):\n\n ssa = NetworkEnsemble()\n ssa.add_function(name, self.get_function())\n return ssa",
"def Avv_func(f):\n\n def Avv(x, v):\n def F(s):\n return f(x + v * s)\n\n ... | [
"0.6440057",
"0.57623315",
"0.54604423",
"0.52078617",
"0.50013286",
"0.47485492",
"0.46421528",
"0.46381408",
"0.46227366",
"0.46155635",
"0.46057883",
"0.4594721",
"0.4532908",
"0.45137742",
"0.45113122",
"0.45107594",
"0.45080462",
"0.45050156",
"0.44994885",
"0.4497978",
... | 0.75143814 | 0 |
Return a deep copy of ``self``. >>> from cascada.bitvector.ssa import BvFunction | def copy(self):
import copy as python_copy
my_ssa = python_copy.copy(self) # fast shallow copy (avoid __init__)
my_ssa.input_vars = my_ssa.input_vars[:]
my_ssa.output_vars = my_ssa.output_vars[:]
my_ssa.assignments = my_ssa.assignments.copy()
return my_ssa | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Copy(self) -> BaseVector:",
"def to_bvfunction(self):\n _input_widths = [v.width for v in self.input_vars]\n _output_widths = [v.width for v in self.output_vars]\n\n class MyBvFunction(BvFunction):\n input_widths = _input_widths\n output_widths = _output_widths\n ... | [
"0.6680502",
"0.6603158",
"0.63798916",
"0.6298044",
"0.6291777",
"0.62572414",
"0.62291664",
"0.62118846",
"0.61597526",
"0.6136885",
"0.6132493",
"0.61314845",
"0.6107561",
"0.6104375",
"0.6088346",
"0.6081889",
"0.6073604",
"0.60660833",
"0.60660833",
"0.60359776",
"0.6012... | 0.63188934 | 3 |
Split into multiple `SSA` objects given the list of variable separators. | def split(self, var_separators):
assert len(var_separators) >= 1
_listify = lambda s: list(s) if isinstance(s, collections.abc.Sequence) else [s]
input_vars_set = set(self.input_vars)
external_vars_set = set(self.external_vars)
# remove input and external vars from var_separat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multi_split(text, seps):\n if not seps: # split by whitespaces\n return text.split()\n else: # split by separators in `seps`\n\n ##### Topics on Stack Overflow\n # http://stackoverflow.com/questions/1059559/python-strings-split-with-multiple-separators\n\n ## Method 1: use `re... | [
"0.58263",
"0.5815856",
"0.57184464",
"0.5663677",
"0.5640506",
"0.5351031",
"0.53371066",
"0.530127",
"0.52853507",
"0.526529",
"0.5252852",
"0.52451015",
"0.52377874",
"0.5202907",
"0.52014166",
"0.5190723",
"0.5180124",
"0.5155712",
"0.51366144",
"0.51366144",
"0.51365817"... | 0.623241 | 0 |
Return the round separators if the SSA was obtained from a `RoundBasedFunction`. If the `SSA` object was obtained from `RoundBasedFunction.to_ssa` of a `RoundBasedFunction` including `add_round_outputs` calls in its ``eval``, this method returns a list with the round outputs delimiting the rounds. Otherwise, ``None`` i... | def get_round_separators(self):
if getattr(self, "_rounds_outputs", None) is None:
return None
if len(self._rounds_outputs) == 0:
return None
return self._rounds_outputs[:-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rounds(self) -> List[Round]:\n return self._rounds",
"def get_rounds_outputs(cls):\n if cls._rounds_outputs is None:\n raise ValueError(\"eval must be called before get_rounds_outputs\")\n return cls._rounds_outputs",
"def roundParameters(self, roundNum):\n ruleName =... | [
"0.5567383",
"0.5464221",
"0.5120953",
"0.511039",
"0.5052884",
"0.48159716",
"0.46500137",
"0.46258867",
"0.45040205",
"0.44882062",
"0.4462644",
"0.4399613",
"0.43700054",
"0.43601322",
"0.43520933",
"0.42661065",
"0.42626894",
"0.4245764",
"0.42430812",
"0.42364082",
"0.42... | 0.6987893 | 0 |
Return the DOT description of the expression tree of the assignments. See also `printing.dotprinting`. | def dotprinting(self, repeat=True, vrepr_label=False, **kwargs):
from cascada.bitvector.printing import dotprinting
from sympy.core.containers import Tuple
expr = Tuple(*self.assignments.items())
return dotprinting(expr, repeat=repeat, vrepr_label=vrepr_label, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_dot(self):\n return \"digraph G{\\n%s}\" % (\"\" if self.val is None else (\n \"\\t%s;\\n%s\\n\" % (\n self.val,\n \"\\n\".join(self._get_dot())\n )\n ))",
"def get_dot(self):\n return \"digraph G{\\n%s}\" % (\"\" if self.val is Non... | [
"0.684507",
"0.684507",
"0.676799",
"0.67229974",
"0.66039073",
"0.64485973",
"0.6420611",
"0.6315337",
"0.62731916",
"0.6222227",
"0.6212272",
"0.61359996",
"0.6120097",
"0.6057643",
"0.6020347",
"0.5955078",
"0.5942951",
"0.5939027",
"0.593326",
"0.59245104",
"0.587527",
... | 0.62478375 | 9 |
Return a random `BvFunction` with given shape. | def get_random_bvfunction(width, num_inputs, num_outputs, num_assignments, seed,
external_variable_prefix=None, operation_set_index=0, num_rounds=None,
extra_operations=None):
assert num_inputs + num_assignments >= num_outputs
import random
import functoo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def b_init(shape, name=None):\n values = np.random.normal(loc=0.5, scale=1e-2, size=shape)\n return K.variable(values, name=name)",
"def __call__(self, shape):\n return np.random.uniform(low=self.minval, high=self.maxval, size=shape)",
"def b_init(shape, name=None):\n values = rng.norma... | [
"0.60691446",
"0.6022296",
"0.5954505",
"0.57499504",
"0.57022244",
"0.5671044",
"0.5671044",
"0.5621131",
"0.56195396",
"0.5616216",
"0.5603668",
"0.55633956",
"0.5560976",
"0.5538763",
"0.55148214",
"0.5467586",
"0.54356635",
"0.54152143",
"0.53970236",
"0.53505164",
"0.532... | 0.5444272 | 16 |
Compile a C function given its C code as two strings (function header and body). | def _compile_C_code(header, body, return_unloaded=False, verbose=False):
import importlib
import tempfile
import uuid
import cffi
module_name = "module_" + uuid.uuid4().hex
if "__uint128" in header:
raise ValueError("_compile_C_code does not support bit-vector widths "
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compile(self, filename, source):\n \n if source and source[-1] != '\\n':\n source = source + '\\n'\n code = __builtin__.compile(source, filename.cStr(), 'exec')\n\n # try to cache the compiled code\n pycFilename = Filename(filename)\n pycFilename.setExtensi... | [
"0.7229262",
"0.6958879",
"0.68127483",
"0.663641",
"0.6623606",
"0.6555563",
"0.6529795",
"0.63210225",
"0.6301976",
"0.6199189",
"0.61737925",
"0.61382604",
"0.60743004",
"0.60626096",
"0.6054126",
"0.60315853",
"0.60043836",
"0.59953725",
"0.59876066",
"0.59520745",
"0.592... | 0.71571857 | 1 |
A modification of the Dijkstra algorithm | def solution(map):
# length[i][j] = the length of the shortest path from (i,j) to (w-1,h-1).
# Modify the current location to -1 and continue searching from adjacent spaces.
return Maze(map).shortest_length() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def djikstra(nodes,links,source,dest):\n route = []\n vertexes = []\n for v in nodes:\n v.set_dist(float(\"inf\"))\n v.set_prev(None)\n heappush(vertexes, v)\n source.set_dist(0)\n heapify(vertexes)\n while vertexes:\n unsorted = False\n u = heappop(vertexes)\n ... | [
"0.7872492",
"0.7555279",
"0.7497173",
"0.7463082",
"0.7290284",
"0.7236829",
"0.7224564",
"0.72027636",
"0.7160234",
"0.7055264",
"0.7048513",
"0.7043256",
"0.704258",
"0.70190734",
"0.70090604",
"0.6993872",
"0.6993811",
"0.69754803",
"0.69566625",
"0.69531214",
"0.69526106... | 0.0 | -1 |
direct print statement that can be overritten to silence output | def printc(txt):
sys.stdout.write(txt)
sys.stdout.write('\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def blockPrint():\n sys.stdout = open(os.devnull, 'w')",
"def hook_print():\n sys.stdout = PrintHook()",
"def disable_print_statements_on_console(func):\n\n @wraps(func)\n def wrap(*args, **kw):\n suppress_text = io.StringIO()\n sys.stdout = suppress_text\n result = func(*args,... | [
"0.733117",
"0.70476305",
"0.7041148",
"0.6995482",
"0.6975923",
"0.6964246",
"0.6914346",
"0.6895462",
"0.6827461",
"0.6757986",
"0.666872",
"0.65437067",
"0.65259236",
"0.65141696",
"0.6512715",
"0.6506051",
"0.6505484",
"0.64867496",
"0.6480485",
"0.6461684",
"0.64198947",... | 0.0 | -1 |
returns progress as a number between 0 and 100 | def progress(self):
return self.progressValue | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def progress(self) -> int:\n return int(round(100 * self.somme() / self.finances))",
"def percentage_progress(self):\n\n if self.total_progress != 0:\n return float(self.progress) / self.total_progress\n return self.progress",
"def percentage_progress(self):\n\n if self.t... | [
"0.79426646",
"0.7889467",
"0.7889467",
"0.7813299",
"0.7813299",
"0.7813299",
"0.7813299",
"0.7616806",
"0.755221",
"0.74852914",
"0.74636984",
"0.73992074",
"0.7360572",
"0.73133385",
"0.7295597",
"0.726702",
"0.7258826",
"0.71958226",
"0.71958226",
"0.71958226",
"0.7195822... | 0.79399526 | 1 |
Parse a file from Dunbrack's PICSE server. This will iterate all lines in the file and extract the list of proteins that match the resolution criteria. | def parse_file(self, path, max_resolution, threshold, proteins={}):
"""
create regex pattern here so it is not done repeatedly while parsing file
groups:
0 - Protein ID
1 - Chain ID
2 - Length of protein chain
3 - Exptl.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iter_protenn_matches(file: str):\n with open(file, \"rt\") as fh:\n for line in fh:\n sequence_id, pfam_acc, start, end = line.rstrip().split(\"\\t\")\n if re.fullmatch(r\"PF\\d+\", pfam_acc):\n yield sequence_id, pfam_acc, int(start), int(end)",
"def read(read_... | [
"0.5723123",
"0.5713342",
"0.56971914",
"0.5693488",
"0.5667087",
"0.56034213",
"0.5589402",
"0.5556643",
"0.55423754",
"0.55163777",
"0.54881227",
"0.5454614",
"0.5442599",
"0.5424246",
"0.542282",
"0.5417614",
"0.5411043",
"0.5402362",
"0.539387",
"0.53841794",
"0.5367232",... | 0.5888745 | 0 |
Download files from the given url that match the input properties. | def get_files(url, thresholds, resolution, r_factor):
selection_page = urllib.urlopen(url).read()
threshold = '|'.join(['%s'% t for t in thresholds])
pattern = '\s(cullpdb_pc(%s)_res%s_R%s_.*\d\.gz)' % (threshold, resolution, r_factor)
files = re.findall(pattern, selection_page)
output = None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _download_from_url(self, url):\n target_file_name = self.dir + \"/\" + url.split('/')[-1].split('?')[0]\n urllib.urlretrieve (url, target_file_name)",
"def download_file():\n for lines in urls:\n try:\n req.urlretrieve(lines, '{0}/{1}'.format(folder_path, lines.split('/')[-... | [
"0.72419274",
"0.6964805",
"0.6902224",
"0.687781",
"0.68698674",
"0.6854977",
"0.6767678",
"0.66414696",
"0.6622179",
"0.66141295",
"0.6612454",
"0.6584942",
"0.657195",
"0.6559492",
"0.6533447",
"0.65309846",
"0.65219647",
"0.6515233",
"0.6503059",
"0.6503059",
"0.6498818",... | 0.0 | -1 |
Create an instance by evaluating all constraints in the problem. The ``problem`` is a DnaChisel DnaOptimizationProblem. | def from_problem(problem, autopass_constraints=True):
def evaluate(constraint):
if (
autopass_constraints
and constraint.enforced_by_nucleotide_restrictions
):
return SpecEvaluation(
constraint,
prob... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def phase_I_problem_from(cls, problem: LinearConstraintsProblem) -> LinearProblem:\n n = problem.n\n m = len(problem.constraints)\n\n e_x = np.zeros(shape=n)\n e_z = np.ones(shape=m)\n e = np.concatenate((e_x, e_z))\n\n x0 = np.zeros(n)\n # we dont need to look at s... | [
"0.6295126",
"0.60471386",
"0.5886922",
"0.5765422",
"0.5730006",
"0.5707503",
"0.565367",
"0.5576092",
"0.5528963",
"0.54968774",
"0.5491965",
"0.54807454",
"0.5393297",
"0.53774476",
"0.53702635",
"0.5276206",
"0.52658254",
"0.5262188",
"0.5253071",
"0.5241584",
"0.52301854... | 0.6974452 | 0 |
Return color 60f979 if evaluation.passes else f96c60. | def success_failure_color(self, evaluation):
return "#60f979" if evaluation.passes else "#f96c60" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_color(self):\r\n if self.color:\r\n return \"RED\"\r\n else:\r\n return \"BLACK\"",
"def color(self):\n return 0x2f3136",
"def color_negative_red_positive_green(val):\n if val < 0:\n color = 'red'\n elif val > 0:\n color = '... | [
"0.7141954",
"0.6812762",
"0.6681384",
"0.66602385",
"0.66393065",
"0.65938675",
"0.65505564",
"0.64515567",
"0.64472324",
"0.6438781",
"0.6421074",
"0.6412371",
"0.6412371",
"0.6412371",
"0.6412371",
"0.64005363",
"0.6387426",
"0.63748986",
"0.6365186",
"0.6347126",
"0.63348... | 0.722408 | 0 |
Return a global SUCCESS or FAILURE message for all evaluations. | def text_summary_message(self):
failed = [e for e in self.evaluations if not e.passes]
if failed == []:
return "SUCCESS - all constraints evaluations pass"
else:
return "FAILURE: %d constraints evaluations failed" % len(failed) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def success_failure_color(self, evaluation):\n return \"#60f979\" if evaluation.passes else \"#f96c60\"",
"def get_error_message(self):\n msg = 'Test case: ' + self.benchmark + '.yaml + ' + self.producer + '.yaml failed. '\n info = ''\n if not self.directory:\n info = 'No r... | [
"0.602707",
"0.6026309",
"0.575857",
"0.57070476",
"0.56101066",
"0.55959904",
"0.5554432",
"0.5525771",
"0.55251604",
"0.54986006",
"0.54985416",
"0.5497898",
"0.54954153",
"0.5488641",
"0.54584396",
"0.5451354",
"0.5448297",
"0.54367286",
"0.54192775",
"0.5412327",
"0.53970... | 0.73922765 | 0 |
Returns a Collection of Opportunities. | def index(self):
args = index_reqparse.parse_args()
args.api_key = "8l3xbEmsQMq7AG7mXoSy3IuJAqehmWGRC754Otx7"
url = 'http://api.data.gov/gsa/fbopen/v0/opps?%s' % urlencode(query=args)
return json.loads(urlopen(url=url).read()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iter_all(self):\n return self.opportunities.find()",
"def get_opportunities_for_maintenance(self, limit=None,\n batch_size=None):\n cursor = self.iter_all()\n\n if limit:\n limit = int(limit)\n cursor = cursor.limit(limit)\n\... | [
"0.75928587",
"0.6055248",
"0.56843185",
"0.5382803",
"0.5341676",
"0.52663434",
"0.5257113",
"0.5237074",
"0.51992303",
"0.5176973",
"0.5175872",
"0.51342726",
"0.51293606",
"0.5111544",
"0.50776553",
"0.50687754",
"0.5067086",
"0.5067079",
"0.5047134",
"0.5043661",
"0.50391... | 0.0 | -1 |
Synchronously sends a button one time. | def send_one(self, remote, button):
if lirc_client.lirc_send_one(self.fd, remote, button) == -1:
raise RuntimeError("Error while communicating with LIRC daemon!") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_one(self, button):\n self.client.send_one(self.name, button)",
"def background_thread():\n state = True\n while True:\n newstate = False if GPIO.input(18) else True\n if state != newstate:\n state = newstate \n print('Button', state)\n socketio... | [
"0.7280409",
"0.62338156",
"0.60761607",
"0.605578",
"0.5945966",
"0.59420735",
"0.5936507",
"0.58793426",
"0.5785086",
"0.5780414",
"0.57774216",
"0.5766327",
"0.558829",
"0.55684954",
"0.55346733",
"0.55283284",
"0.55037683",
"0.54426235",
"0.54423636",
"0.5441076",
"0.5415... | 0.61962545 | 2 |
Synchronously sends a button one time. | def send_one(self, button):
self.client.send_one(self.name, button) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def background_thread():\n state = True\n while True:\n newstate = False if GPIO.input(18) else True\n if state != newstate:\n state = newstate \n print('Button', state)\n socketio.emit('button', {'state': state}, namespace='/test')\n time.sleep(.1)",
"... | [
"0.62327343",
"0.6195085",
"0.6072948",
"0.60537666",
"0.59465384",
"0.59400034",
"0.5935611",
"0.5875449",
"0.578244",
"0.57768023",
"0.57764006",
"0.5765144",
"0.5585602",
"0.55646986",
"0.55332255",
"0.5523995",
"0.5501173",
"0.5440503",
"0.5439348",
"0.5438772",
"0.541685... | 0.72782546 | 0 |
initializes id and title | def __init__(self,
id = 'abbrev',
title = "Abbreviation Bibliography ID Cooker"):
self.id = id
self.title = title | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, id=\"\", title=\"\", arguments=\"\"):\n\t\tself.id= id\n\t\tself.title= title\n\t\tself.arguments= arguments",
"def __init__(self, id_, name):\n self._id = id_\n\n self._name = name\n self._name = self._name.title()",
"def __init__(self, title):\n self._title = ti... | [
"0.78083724",
"0.73984087",
"0.7277978",
"0.7061586",
"0.686914",
"0.6863247",
"0.6813077",
"0.6807725",
"0.67897606",
"0.666484",
"0.666484",
"0.666484",
"0.666484",
"0.66423106",
"0.6562245",
"0.6524675",
"0.6524675",
"0.6489632",
"0.64539367",
"0.64539367",
"0.642176",
"... | 0.7662275 | 1 |
cooks a bibref id for one reference entry dict | def _cookIdCore(self, ref, **kwargs):
# AUTHORS
namepart='nobody'
if self._refHasAuthorNames(ref):
lastnames = []
for each in ref['authors']:
if each.get('lastname', None):
lastnames.append(each['lastname'])
if len(lastnam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_cff_reference(bib_entry: pybtex.database.Entry) -> dict:\n\n def _cff_transform(cff_field, bib_value):\n if cff_field == \"type\":\n if bib_value == \"inproceedings\":\n return \"article\"\n elif bib_value == \"incollection\":\n return \"article\... | [
"0.6515439",
"0.59412706",
"0.5690313",
"0.5684403",
"0.56685394",
"0.56310415",
"0.5598006",
"0.5590219",
"0.55857784",
"0.5583656",
"0.55488837",
"0.55436593",
"0.54998034",
"0.54959476",
"0.54939634",
"0.5449776",
"0.5437612",
"0.5418777",
"0.5413845",
"0.5396753",
"0.5389... | 0.61811495 | 1 |
Test for when clone lun is not passed a block count. | def test_clone_lun_zero_block_count(self):
lun = netapp_api.NaElement.create_node_with_children(
'lun-info',
**{'alignment': 'indeterminate',
'block-size': '512',
'comment': '',
'creation-timestamp': '1354536362',
'is-space-all... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def corrected_clump_tester(clump):\n tester = True\n for block in clump:\n if len(block) >= 3: # Fixed block!\n tester = False\n break\n return tester",
"def org_clump_tester(clump):\n tester = True\n for block in clump:\n if len(clump) >= 3: # clump should be... | [
"0.5885451",
"0.5682751",
"0.56746435",
"0.5612983",
"0.5546021",
"0.5530416",
"0.55098057",
"0.5433039",
"0.54293126",
"0.5397168",
"0.536836",
"0.5333882",
"0.53137195",
"0.530228",
"0.52823144",
"0.5272673",
"0.52483624",
"0.5217936",
"0.5197577",
"0.51798713",
"0.5166777"... | 0.7056724 | 0 |
Initialize modified GRU cell. | def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias):
super(ModGRUCell, self).__init__()
self.height, self.width = input_size
self.input_dim = input_dim
self.hidden_dim = hidden_dim
self.kernel_size = kernel_size
self.padding = kernel_size[0] //... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _initialize_gru_cell(self, num_units):\n return gru_cell.LayerNormGRUCell(\n num_units,\n w_initializer=self.uniform_initializer,\n u_initializer=random_orthonormal_initializer,\n b_initializer=tf.constant_initializer(0.0))",
"def initialize_cell_cycles(self,g_av=1,g_sig=0.2):\... | [
"0.7468389",
"0.62160295",
"0.61595106",
"0.61388946",
"0.6088923",
"0.6070395",
"0.595316",
"0.59318763",
"0.59082144",
"0.5905371",
"0.585891",
"0.58529335",
"0.5845387",
"0.58402777",
"0.5813198",
"0.5757071",
"0.5716906",
"0.56996626",
"0.5678049",
"0.5640501",
"0.5639719... | 0.5497019 | 39 |
Parse the circuit definition file. | def parse_network(self):
self._check_fixed_start()
self._check_fixed_others(self.scanner.DEVICES_ID)
self._check_devicelist()
self._check_fixed_others(self.scanner.DEVICES_ID)
self._check_fixed_start()
self._check_fixed_others(self.scanner.CONNECTIONS_ID)
self._ch... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_file(self):\n for num, line in enumerate(self._text):\n if \"CRYSTAL STRUCTURE SOLUTION\" in line:\n line = line.strip().strip('+').strip()\n if 'SHELXTL' in line:\n self.version = 'SHELXT ' + line.split()[-1]\n if line.strip()... | [
"0.6225297",
"0.61288214",
"0.6015567",
"0.6008988",
"0.5940226",
"0.59268165",
"0.5896686",
"0.58951074",
"0.58671474",
"0.58663946",
"0.58653283",
"0.58582795",
"0.58579344",
"0.5810102",
"0.5686838",
"0.56725323",
"0.56548876",
"0.56428576",
"0.56192803",
"0.55996054",
"0.... | 0.0 | -1 |
Checks if device name is valid | def _check_name(self, symbol):
if symbol.type == self.scanner.NAME:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_dev_name_valid(self):\n return self._name_re.match(self.dev_name) is not None",
"def _validate_name(name):\r\n\tif HOST_NAME != name and len(name) > 0 and ZOOM_PHRASES[0] not in name and name not in WAITING_ROOM:\r\n\t\treturn True\r\n\treturn False",
"def validname(name):\r\n return len(n... | [
"0.8281383",
"0.7181085",
"0.7058277",
"0.6907663",
"0.68601716",
"0.6770678",
"0.6747763",
"0.6730695",
"0.6681097",
"0.6627635",
"0.6570866",
"0.65404034",
"0.6518061",
"0.65087",
"0.6499738",
"0.64887094",
"0.6470892",
"0.6418953",
"0.64112616",
"0.6360881",
"0.6354566",
... | 0.6163687 | 33 |
Checks if symbol is a valid device | def _check_validdevice(self, symbol):
if symbol.type == self.scanner.KEYWORD and \
symbol.id in self.validdeviceids:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_deviceline(self):\n # Check if device name is valid\n if self._check_name(self.symbol):\n self.device_name = self.symbol\n self.symbol = self.scanner.get_symbol()\n # Check if '=' is used\n if self._is_equal(self.symbol):\n # Get n... | [
"0.75342447",
"0.6746497",
"0.65169084",
"0.64804757",
"0.63896406",
"0.63296634",
"0.6282044",
"0.6268811",
"0.62086785",
"0.6193023",
"0.61705214",
"0.6164332",
"0.615052",
"0.6144333",
"0.61336094",
"0.6121036",
"0.6086974",
"0.6019076",
"0.6016493",
"0.59963256",
"0.59561... | 0.8153207 | 0 |
Checks if symbol is a valid parameter | def _check_validparam(self, symbol):
if symbol.type == self.scanner.KEYWORD and \
symbol.id in self.validparamids:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_name(self, symbol):\n if symbol.type == self.scanner.NAME:\n return True\n else:\n return False",
"def _is_valid_input(self, parameter_name):\n raise NotImplementedError()",
"def _check_paramindevice(self):\n if self._check_validparam(self.symbol):\n... | [
"0.6862855",
"0.6799891",
"0.6653889",
"0.65039194",
"0.64729655",
"0.64628637",
"0.6461699",
"0.64211375",
"0.6384333",
"0.6335811",
"0.63166904",
"0.6274853",
"0.62189996",
"0.62188965",
"0.61966276",
"0.6187289",
"0.6160707",
"0.6061646",
"0.6057763",
"0.60409635",
"0.6040... | 0.82193774 | 0 |
Check correctness of the symbol START | def _check_fixed_start(self):
self.symbol = self.scanner.get_symbol()
if self.symbol.type == self.scanner.KEYWORD and \
self.symbol.id == self.scanner.START_ID:
pass
elif self._is_eof(self.symbol):
# In case file ends prematurely
pass
e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valid_start(start, lines):\r\n if start.isalpha(): # start word must be alphabetic\r\n if len(start) > 1: # start word must be larger than 1 character\r\n if start in lines: # start word must be in the list of words\r\n return \"0\"\r\n else:\r\n ... | [
"0.71219003",
"0.6362785",
"0.63464314",
"0.63366246",
"0.6255174",
"0.6188901",
"0.6157201",
"0.6143468",
"0.60610247",
"0.6050532",
"0.5992676",
"0.59828264",
"0.59446603",
"0.59429526",
"0.5934591",
"0.59285474",
"0.5921997",
"0.5911821",
"0.5889964",
"0.5861589",
"0.58428... | 0.77844435 | 0 |
Check correctness of other fixed symbols, e.g. DEVICES | def _check_fixed_others(self, symbol_id):
# Get the next symbol
self.symbol = self.scanner.get_symbol()
if self.symbol.type == self.scanner.KEYWORD and \
self.symbol.id == symbol_id:
self.symbol = self.scanner.get_symbol()
self._check_semicolon_else_skip(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_kyc_get_validation_legal(self):\n pass",
"def validate_entered_symbol(self, existing_symbols):\n print(\"Consultando símbolo\")\n if self.symbol in existing_symbols:\n print(\"Símbolo validado\")\n validated_symbol = self.symbol\n return validated_sy... | [
"0.6116707",
"0.6059896",
"0.6044129",
"0.5927608",
"0.586123",
"0.5858872",
"0.58061266",
"0.5715343",
"0.57108855",
"0.5709121",
"0.56695735",
"0.5662229",
"0.5651855",
"0.56507117",
"0.5647858",
"0.5638892",
"0.56259936",
"0.5609222",
"0.55763483",
"0.55747074",
"0.5555086... | 0.0 | -1 |
Check if symbol is a valid DType input | def _check_validdtypeinput(self, symbol):
if symbol.type == self.scanner.KEYWORD and \
symbol.id in self.validdtypeinputs:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_validdtypeoutput(self, symbol):\n if symbol.type == self.scanner.KEYWORD and \\\n symbol.id in self.validdtypeoutputs:\n return True\n else:\n return False",
"def is_symbol(obj):\n return isinstance(obj, Symbol)",
"def isValidDataTypeName(name: u... | [
"0.7286696",
"0.66887015",
"0.6577127",
"0.6570027",
"0.64245325",
"0.6364817",
"0.6271129",
"0.6229207",
"0.6214596",
"0.61741644",
"0.6168954",
"0.6150034",
"0.6127641",
"0.607109",
"0.60133564",
"0.59820586",
"0.5958963",
"0.5928896",
"0.59214616",
"0.5874561",
"0.5868875"... | 0.7812703 | 0 |
Check if symbol is a valid DType output | def _check_validdtypeoutput(self, symbol):
if symbol.type == self.scanner.KEYWORD and \
symbol.id in self.validdtypeoutputs:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_validdtypeinput(self, symbol):\n if symbol.type == self.scanner.KEYWORD and \\\n symbol.id in self.validdtypeinputs:\n return True\n else:\n return False",
"def is_symbol(obj):\n return isinstance(obj, Symbol)",
"def _want_sym(sym):\n if s... | [
"0.7144111",
"0.62963384",
"0.612206",
"0.60689634",
"0.6064693",
"0.5982979",
"0.5965407",
"0.5920263",
"0.5882332",
"0.58719504",
"0.58253753",
"0.5759133",
"0.57490194",
"0.5722805",
"0.57056916",
"0.5703249",
"0.5655178",
"0.56458294",
"0.5625231",
"0.56242913",
"0.562355... | 0.7976685 | 0 |
Checks for a semicolon | def _is_semicolon(self, symbol):
if symbol.type == self.scanner.SEMICOLON:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_semicolon_else_skip(self, symbol):\n if symbol.type == self.scanner.SEMICOLON:\n pass\n else:\n self._display_syntax_error(\"semicolon\")\n # Skip to semicolon at end of line\n self._semicolon_skipper()",
"def _check_semicolon(line_index, input... | [
"0.77693564",
"0.7576656",
"0.73017335",
"0.7250093",
"0.67261046",
"0.63885087",
"0.63797534",
"0.635322",
"0.6284039",
"0.615116",
"0.6051766",
"0.6046793",
"0.60242265",
"0.58955777",
"0.5878949",
"0.585406",
"0.58402747",
"0.57678705",
"0.5749202",
"0.5675741",
"0.5645079... | 0.7972013 | 0 |
When error found, skips to end of line by identifying semicolon | def _semicolon_skipper(self):
while (
not self._is_semicolon(
self.symbol)) and (
not self._is_eof(
self.symbol)):
self.symbol = self.scanner.get_symbol()
if self._is_eof(self.symbol):
# In case file ends prematurely
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_semicolon_else_skip(self, symbol):\n if symbol.type == self.scanner.SEMICOLON:\n pass\n else:\n self._display_syntax_error(\"semicolon\")\n # Skip to semicolon at end of line\n self._semicolon_skipper()",
"def _check_semicolon(line_index, input... | [
"0.7086357",
"0.66036904",
"0.64966756",
"0.6311523",
"0.6219263",
"0.60868347",
"0.6043285",
"0.60312366",
"0.59458333",
"0.5931774",
"0.5893653",
"0.58929294",
"0.58747315",
"0.5836142",
"0.57985604",
"0.5744275",
"0.57366985",
"0.5712483",
"0.56762767",
"0.56374615",
"0.56... | 0.64809066 | 3 |
Check for a semicolon, otherwise skip to end of line | def _check_semicolon_else_skip(self, symbol):
if symbol.type == self.scanner.SEMICOLON:
pass
else:
self._display_syntax_error("semicolon")
# Skip to semicolon at end of line
self._semicolon_skipper() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _semicolon_skipper(self):\n while (\n not self._is_semicolon(\n self.symbol)) and (\n not self._is_eof(\n self.symbol)):\n self.symbol = self.scanner.get_symbol()\n if self._is_eof(self.symbol):\n # In case file ends premat... | [
"0.78582406",
"0.76281416",
"0.73624676",
"0.7034011",
"0.6740908",
"0.65985113",
"0.6566954",
"0.649407",
"0.62372047",
"0.60137314",
"0.60137314",
"0.60137314",
"0.5960441",
"0.5945319",
"0.58354354",
"0.5831994",
"0.58205914",
"0.5817536",
"0.5817003",
"0.5816331",
"0.5751... | 0.7773585 | 1 |
Checks for a comma | def _is_comma(self, symbol):
if symbol.type == self.scanner.COMMA:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_comma(text):\n err = \"style-guide.serial-comma\"\n msg = \"Use serial comma after penultimate item.\"\n regex = \"\\,\\s[a-zA-Z0-9]*\\sand\\s\"\n\n return existence_check(text, [regex], err, msg, require_padding=False)",
"def contains_comma(self, *args):\n return _ida_hexrays.cexpr_... | [
"0.78176993",
"0.7652777",
"0.75575286",
"0.739962",
"0.6958344",
"0.68487954",
"0.67709404",
"0.6737014",
"0.654276",
"0.6426066",
"0.6025317",
"0.60239697",
"0.590207",
"0.5873435",
"0.5853992",
"0.58382696",
"0.5835906",
"0.579905",
"0.579905",
"0.5768135",
"0.5726377",
... | 0.78183836 | 0 |
Checks if symbol is = | def _is_equal(self, symbol):
if symbol.type == self.scanner.EQUALS:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_equality(s):\n return s == \"=\"",
"def have_equal_symbol(l):\r\n if \"=\" in str(l):\r\n return 1\r\n else:\r\n return 0",
"def __eq__(self, other):\n if isinstance(other, Symbol):\n return self.arg == other.arg\n else:\n return False",
"def ... | [
"0.7069563",
"0.7053939",
"0.6365846",
"0.6041129",
"0.6032814",
"0.6008303",
"0.5979109",
"0.5968912",
"0.59604686",
"0.5947024",
"0.5919421",
"0.5879708",
"0.5776344",
"0.56683415",
"0.5635651",
"0.5520605",
"0.5435992",
"0.5415546",
"0.54125285",
"0.5401831",
"0.5359267",
... | 0.7887802 | 0 |
Checks if symbol is a number | def _is_number(self, symbol):
if symbol.type == self.scanner.NUMBER:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_numeral(self, symbol: str) -> bool:\n return symbol in self.numerals",
"def is_number(symbol):\n return isa(symbol, complex) or is_rational(symbol)",
"def is_int(symbol):\n return isa(symbol, int)",
"def _is_num(w):\n symbols = list(w)\n for s in symbols:\n ... | [
"0.7981778",
"0.796459",
"0.7456952",
"0.71271473",
"0.7109606",
"0.7074188",
"0.7070969",
"0.70643014",
"0.7049879",
"0.70249534",
"0.7018031",
"0.701756",
"0.701756",
"0.701756",
"0.7005208",
"0.69720167",
"0.6957312",
"0.69454503",
"0.69375134",
"0.6913471",
"0.6888762",
... | 0.87825435 | 0 |
Checks if symbol is END | def _is_end(self, symbol):
if symbol.id == self.scanner.END_ID:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_eof(self, symbol):\n if symbol.type == self.scanner.EOF:\n return True\n else:\n return False",
"def is_eof(eof):\n return eof == Symbol('#!eof')",
"def _is_at_end(self):\n return self._peek().token_type == scanner.TokenType.EOF",
"def end_marker(data... | [
"0.7342705",
"0.7149009",
"0.70896596",
"0.70774",
"0.67542297",
"0.6487307",
"0.63351965",
"0.6282967",
"0.6278268",
"0.6223454",
"0.6220154",
"0.6128539",
"0.6115099",
"0.6088857",
"0.60728556",
"0.60151976",
"0.5978687",
"0.5965214",
"0.5928278",
"0.5921364",
"0.5912482",
... | 0.8258185 | 0 |
Checks if symbol is period | def _is_period(self, symbol):
if symbol.type == self.scanner.PERIOD:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_dot(f):\n return f.startswith('.')",
"def contains_only_digit_period(cell):\n # Check if empty\n if check_empty(cell):\n return True\n return not bool(re.match(\"^[\\d\\.]+$\", str(cell)))",
"def test_assert_does_not_contain_period(self):\n\n with self.assertRaisesRegexp(Except... | [
"0.67990226",
"0.66136557",
"0.6595603",
"0.6524375",
"0.65057904",
"0.62380713",
"0.6233876",
"0.61981905",
"0.6056237",
"0.6032704",
"0.5983063",
"0.59301597",
"0.5924762",
"0.57949024",
"0.57834405",
"0.5684264",
"0.5677624",
"0.56559867",
"0.5553411",
"0.55044025",
"0.549... | 0.84950036 | 0 |
Checks if symbol is arrow | def _is_arrow(self, symbol):
if symbol.type == self.scanner.ARROW:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_arrow(arrow):\r\n if arrow == '->':\r\n return u'\\u2192'\r\n if arrow == '<->':\r\n return u'\\u2194'\r\n\r\n # this won't be reached unless we add more arrow types, but keep it to avoid explosions when\r\n # that happens.\r\n return arrow",
"d... | [
"0.6579438",
"0.62176615",
"0.6158133",
"0.61140186",
"0.56991667",
"0.56856215",
"0.5675952",
"0.56478024",
"0.56177944",
"0.56067",
"0.5604297",
"0.55857825",
"0.5528179",
"0.549328",
"0.549197",
"0.5484557",
"0.54716647",
"0.5453517",
"0.54349774",
"0.54213643",
"0.5419489... | 0.8980897 | 0 |
Checks if symbol is EOF | def _is_eof(self, symbol):
if symbol.type == self.scanner.EOF:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_eof(eof):\n return eof == Symbol('#!eof')",
"def _is_end(self, symbol):\n if symbol.id == self.scanner.END_ID:\n return True\n else:\n return False",
"def isEOF(self):\n return _libsbml.XMLToken_isEOF(self)",
"def is_eof(self) -> bool:\n ...",
"de... | [
"0.81757635",
"0.75523627",
"0.72510964",
"0.7247274",
"0.72082675",
"0.6746605",
"0.6746605",
"0.6746605",
"0.6746605",
"0.6720954",
"0.6688368",
"0.6590599",
"0.6573672",
"0.6370021",
"0.62316614",
"0.62316614",
"0.62316614",
"0.6191076",
"0.61427915",
"0.6137312",
"0.61229... | 0.89874196 | 0 |
Returns the correct device type to input into Devices module. | def _device_type_returner(self, symbol):
if self.names.get_name_string(symbol.id) == "AND":
return self.devices.AND
if self.names.get_name_string(symbol.id) == "OR":
return self.devices.OR
if self.names.get_name_string(symbol.id) == "NAND":
return self.devices... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def device_type(self):\n return Context.devtype2str[self.device_typeid]",
"def device_type(self):\n return Context.devtype2str[self.device_typeid]",
"def device_type(self):\n return self._meta['device_type']",
"def device_type(self):\r\n return self._arm.device_type",
"def devic... | [
"0.8152535",
"0.8152535",
"0.81299514",
"0.8082578",
"0.79667145",
"0.7923392",
"0.78032374",
"0.78032374",
"0.78032374",
"0.7714159",
"0.7676494",
"0.7660527",
"0.75814134",
"0.7581327",
"0.7559037",
"0.7544125",
"0.75318646",
"0.747006",
"0.7458651",
"0.7447082",
"0.7422269... | 0.76428765 | 12 |
Checks the entire devices list until END DEVICE is reached | def _check_devicelist(self):
self.symbol = self.scanner.get_symbol()
# Repeatedly call _check_deviceline() until END DEVICE
while (
not self._is_end(
self.symbol)) and (
not self._is_eof(
self.symbol)):
self._check_deviceline()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scan_devices(self):\n _LOGGER.debug(\"Scan_devices invoked.\")\n if self._update_info() == False:\n # self.hass.data[DOMAIN]['devices'] = None\n self.hass.data[DOMAIN]['scanning'] = False\n _LOGGER.warning(\"Can't update device list\")\n return []\n ... | [
"0.6879687",
"0.660112",
"0.65719104",
"0.6563505",
"0.6508826",
"0.6344587",
"0.62265825",
"0.6206864",
"0.6176136",
"0.61714685",
"0.61622983",
"0.61597127",
"0.61597127",
"0.6158857",
"0.61501837",
"0.6118743",
"0.6103006",
"0.6098765",
"0.60909706",
"0.6088176",
"0.606403... | 0.7390407 | 0 |
Checks validity of each line in the devices list | def _check_deviceline(self):
# Check if device name is valid
if self._check_name(self.symbol):
self.device_name = self.symbol
self.symbol = self.scanner.get_symbol()
# Check if '=' is used
if self._is_equal(self.symbol):
# Get next symbol
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_devicelist(self):\n self.symbol = self.scanner.get_symbol()\n # Repeatedly call _check_deviceline() until END DEVICE\n while (\n not self._is_end(\n self.symbol)) and (\n not self._is_eof(\n self.symbol)):\n self._check_... | [
"0.6986171",
"0.6586238",
"0.65168226",
"0.62669855",
"0.62519085",
"0.6203432",
"0.6027403",
"0.60036016",
"0.59288603",
"0.5895239",
"0.5868172",
"0.5850635",
"0.58464867",
"0.5836811",
"0.5769996",
"0.5757243",
"0.5722997",
"0.57227445",
"0.5712627",
"0.56969523",
"0.56966... | 0.6070535 | 6 |
Returns the parameter of a device | def _check_paramindevice(self):
if self._check_validparam(self.symbol):
param = self.symbol
self.symbol = self.scanner.get_symbol()
# Check if '=' is used
if self._is_equal(self.symbol):
self.symbol = self.scanner.get_symbol()
# Che... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def device(self):\n return self._vars[0].device",
"def device(self):\n return next(self.parameters()).device",
"def device(self):\n return next(self.parameters()).device",
"def device(self):\n return next(self.parameters()).device",
"def device(self):\n return next(self.param... | [
"0.7553473",
"0.75376445",
"0.75376445",
"0.75376445",
"0.75376445",
"0.75376445",
"0.6938174",
"0.6857107",
"0.6755491",
"0.671194",
"0.66910404",
"0.66624725",
"0.665847",
"0.6608585",
"0.65402085",
"0.6533321",
"0.6515314",
"0.64927495",
"0.64355874",
"0.6423849",
"0.64109... | 0.0 | -1 |
Checks the entire connections list until END CONNECTIONS is reached | def _check_connectionlist(self):
self.symbol = self.scanner.get_symbol()
# Repeatedly call _check_connectionline() until END CONNECTIONS
while (
not self._is_end(
self.symbol)) and (
not self._is_eof(
self.symbol)):
self._check_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def check_connection_status(self):\n while True:\n if not self.connected:\n self.log.error(\"Lost connection to spa, attempting reconnect.\")\n await self.connect()\n await asyncio.sleep(10)\n continue\n if (self.lastupd... | [
"0.6651885",
"0.66485655",
"0.658435",
"0.65760034",
"0.65238696",
"0.65040714",
"0.645094",
"0.63097805",
"0.63036615",
"0.628794",
"0.6277836",
"0.6257548",
"0.6239977",
"0.62278676",
"0.6214399",
"0.61141676",
"0.61134064",
"0.6110468",
"0.6097771",
"0.60918623",
"0.606363... | 0.7198108 | 0 |
Checks validity of each line in the connections list | def _check_connectionline(self):
self.connection_first_device, \
self.connection_first_port \
= self._check_validconnectionoutput()
if self._is_arrow(self.symbol):
# Get next symbol
self.symbol = self.scanner.get_symbol()
self.connection_second... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_connectionlist(self):\n self.symbol = self.scanner.get_symbol()\n # Repeatedly call _check_connectionline() until END CONNECTIONS\n while (\n not self._is_end(\n self.symbol)) and (\n not self._is_eof(\n self.symbol)):\n ... | [
"0.68231344",
"0.6541388",
"0.62784106",
"0.6260675",
"0.60896343",
"0.60538226",
"0.60501355",
"0.597213",
"0.59351665",
"0.5903994",
"0.58946735",
"0.58336484",
"0.5699847",
"0.5687605",
"0.567442",
"0.5646546",
"0.56359893",
"0.56153196",
"0.56123793",
"0.5572138",
"0.5549... | 0.6729478 | 1 |
Return device and port for input in connections | def _check_validconnectioninput(self):
# Check if name is valid
if self._check_name(self.symbol):
second_device = self.symbol
self.symbol = self.scanner.get_symbol()
# Check if '.' is used:
if self._is_period(self.symbol):
self.symbol = sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def port(self) -> int:",
"def Port(self) -> int:",
"def port():",
"def _get_port(self):\n return self.__port",
"def port(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"port\")",
"def port(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"port\")",
"def get_connection_par... | [
"0.6928063",
"0.687995",
"0.6807471",
"0.67646015",
"0.6670902",
"0.6670902",
"0.6477284",
"0.6463667",
"0.643938",
"0.6325044",
"0.6325044",
"0.6325044",
"0.63062704",
"0.6298597",
"0.6233679",
"0.6232649",
"0.62299055",
"0.62299055",
"0.62299055",
"0.62299055",
"0.62299055"... | 0.0 | -1 |
Return device and port for output in connections | def _check_validconnectionoutput(self):
# Check if name is valid and has been initialised
if self._check_name(self.symbol):
first_device = self.symbol
self.symbol = self.scanner.get_symbol()
# Check if '->' is used
if self._is_arrow(self.symbol):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_port(self):\n return self.__port",
"def Port(self) -> int:",
"def port(self) -> int:",
"def port():",
"def port(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"port\")",
"def port(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"port\")",
"def port(self) -> pu... | [
"0.6802253",
"0.67266244",
"0.6721623",
"0.6662639",
"0.65889335",
"0.65889335",
"0.65889335",
"0.645466",
"0.645466",
"0.6440994",
"0.6411583",
"0.63504773",
"0.63436085",
"0.6334871",
"0.63180554",
"0.6315307",
"0.62884665",
"0.62757933",
"0.62696934",
"0.62477916",
"0.6229... | 0.0 | -1 |
Create own make_connection to handle the fact that first device may sometimes not have a port specified. | def _connection_maker(
self,
first_device,
first_port,
second_device,
second_port):
if first_port is None:
return self.network.make_connection(
first_device.id, None,
second_device.id, second_port.id)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_connection( hostname, port = 4663 ):\n \tconnection = socket.socket();",
"def connect(self, device_ip, device_port=DEFAULT_PORT):\n return",
"def init_tcp_conn(target: str, port: int) -> socket.socket:\n conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n conn.settimeout(5)... | [
"0.6627861",
"0.6501172",
"0.63174254",
"0.6263077",
"0.6138852",
"0.6062171",
"0.6033618",
"0.6004392",
"0.59724677",
"0.59683317",
"0.5954122",
"0.5947945",
"0.59181684",
"0.59173775",
"0.58790517",
"0.58762664",
"0.58634245",
"0.58634245",
"0.5857357",
"0.5852349",
"0.5844... | 0.79061735 | 0 |
Use network's check_network() to test all connections. | def _check_whole_network(self):
if not self.network.check_network():
# check_network has failed, issue error
self._display_semantic_error("network") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_check_network(network_with_devices):\n network = network_with_devices\n devices = network.devices\n names = devices.names\n\n [SW1_ID, SW2_ID, OR1_ID, I1, I2] = names.lookup([\"Sw1\", \"Sw2\", \"Or1\", \"I1\",\n \"I2\"])\n\n # Inputs are u... | [
"0.77178425",
"0.6734853",
"0.67199486",
"0.66826373",
"0.6626964",
"0.6584825",
"0.65507597",
"0.649634",
"0.6491266",
"0.6462607",
"0.6385012",
"0.6379867",
"0.6345907",
"0.6305116",
"0.6298622",
"0.6279326",
"0.6273643",
"0.62547606",
"0.62362325",
"0.6226283",
"0.62199765... | 0.7808896 | 0 |
Checks the entire monitors list until END MONITORS is reached | def _check_monitorlist(self):
self.symbol = self.scanner.get_symbol()
# Repeatedly call _check_monitorline() until END MONITORS
while (
not self._is_end(
self.symbol)) and (
not self._is_eof(
self.symbol)):
self._check_monitorli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reDetectMonitors(self):\n if self.os_type == 'Windows8':\n try:\n self.notifyPut('Running a quick monitor detect')\n self.checkMetrics()\n pythoncom.CoInitialize() # Initialize COM lib on thread\n ... | [
"0.64343464",
"0.64005023",
"0.636382",
"0.6222358",
"0.61567485",
"0.61138576",
"0.6028731",
"0.590527",
"0.5892099",
"0.58482844",
"0.58335686",
"0.57457507",
"0.5730217",
"0.56420094",
"0.56305265",
"0.5628375",
"0.55960834",
"0.5589741",
"0.5579765",
"0.5569071",
"0.55687... | 0.68545663 | 0 |
Checks validity of each line in the monitors list | def _check_monitorline(self):
# Check if device name is valid
if self._check_name(self.symbol):
self.monitor_device = self.symbol
self.symbol = self.scanner.get_symbol()
# Check if ';' is used
if self._is_semicolon(self.symbol):
# End of li... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_monitorlist(self):\n self.symbol = self.scanner.get_symbol()\n # Repeatedly call _check_monitorline() until END MONITORS\n while (\n not self._is_end(\n self.symbol)) and (\n not self._is_eof(\n self.symbol)):\n self._ch... | [
"0.6970177",
"0.63498",
"0.6320208",
"0.6103991",
"0.5746999",
"0.57255924",
"0.57018095",
"0.5678772",
"0.5599603",
"0.5562899",
"0.5547567",
"0.55106187",
"0.5462433",
"0.5437228",
"0.5424427",
"0.5421003",
"0.54081196",
"0.5394835",
"0.5394079",
"0.53939563",
"0.5375676",
... | 0.59255034 | 4 |
Handles syntax error reporting | def _display_syntax_error(self, errorid):
# For total error count
self.syntax_errors_list.append(errorid)
if errorid == "start":
self.scanner.print_error(self.symbol, self.symbol)
print("Expected START.")
elif errorid == self.scanner.END_ID:
self.sca... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def syntaxError (self, s) :\r\n report = self.generateReport() + s\r\n raise Exception, report",
"def _syntax_error(self, msg, thing):\n raise TempliteSyntaxError(f\"{msg}: {thing!r}\")",
"def handle_syntax_error(self, resp, main_line):\r\n errline = '\\n'.join(resp.splitlines()[:])... | [
"0.7382525",
"0.7190607",
"0.69247794",
"0.6854462",
"0.67530197",
"0.65800965",
"0.6368778",
"0.62244797",
"0.61815715",
"0.61032015",
"0.6100613",
"0.6045247",
"0.5933183",
"0.5931459",
"0.59106696",
"0.5896602",
"0.5807411",
"0.5796591",
"0.5784517",
"0.5777859",
"0.574586... | 0.6147594 | 9 |
Handles semantic error reporting | def _display_semantic_error(self, errorid):
# For total error count
self.semantic_errors_list.append(errorid)
if errorid == self.devices.NO_ERROR:
self.semantic_errors_list.pop()
elif errorid == self.devices.INVALID_QUALIFIER:
self.scanner.print_error(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unexpected_error(self, exception):",
"def error(self):\n ...",
"def handle_err(self):\n pass",
"def indicate_error(self):\n pass",
"def error(self):\n pass",
"def error(self, message):\r\n self._construct_partial_parser().error(message)",
"def parse_error(self, messag... | [
"0.6544442",
"0.65083706",
"0.6467027",
"0.6352676",
"0.6273643",
"0.620587",
"0.6178558",
"0.61727536",
"0.60975116",
"0.6053544",
"0.60504293",
"0.60452014",
"0.6009354",
"0.5986167",
"0.59670675",
"0.59147745",
"0.5870487",
"0.5786879",
"0.5768157",
"0.57681406",
"0.572763... | 0.56756324 | 23 |
Processes the work for the given job. If the job fails and should be retried, this method should raise a WorkerUnhealthyException. If the job should be marked as permanently failed, it should raise a JobException. Otherwise, a successful return of this method will remove the job from the queue as completed. | def process_queue_item(self, job_details):
raise NotImplementedError("Workers must implement run.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kill_job(self, job):\n\n if job.status == Job.STATUS_QUEUED:\n # case 1: job is in QUEUED state\n # remove it from the queue and mark as killed\n\n job_queue = job_queue_name(job.model)\n logger.info(\n \"killing job {} by removing fro... | [
"0.69394755",
"0.6466214",
"0.63333684",
"0.61836",
"0.6147585",
"0.6133385",
"0.6098039",
"0.608371",
"0.6065368",
"0.6055274",
"0.59466046",
"0.5915261",
"0.59074247",
"0.58784455",
"0.5871675",
"0.5847603",
"0.58380884",
"0.58358115",
"0.583498",
"0.58286256",
"0.5812824",... | 0.63801795 | 2 |
Function that gets run once every watchdog_period_seconds. | def watchdog(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def AutonomousPeriodic(self):\n Scheduler.GetInstance().Run()",
"def reset_timer(self, *_) -> \"ALL\":\n self.last = time.time()\n delta = time.time() - self.last\n if delta > 180:\n print(\n \"!!! Warning: Watchdog failure detected, spawning a fallback \"\n ... | [
"0.64125323",
"0.63243026",
"0.62250376",
"0.61276174",
"0.60985696",
"0.6009293",
"0.59422404",
"0.58473533",
"0.57617235",
"0.5760029",
"0.563189",
"0.56076306",
"0.55893135",
"0.5549261",
"0.5547748",
"0.5533392",
"0.5522406",
"0.551928",
"0.54789424",
"0.54440325",
"0.542... | 0.69782615 | 0 |
... expliquer l'utilisation du foo | def encode_details(*trees):
def single_tree_function(tree):
tree_indexes = tree.tree_nodes.keys()
for index_parent in tree_indexes:
if not tree.nisleaf[index_parent]:
tree.nnorm_details[index_parent] = 0
foo = []
for index_chil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def util():\n pass",
"def util():\n pass",
"def builtin_utility(func):\n func.is_utility = True\n return func",
"def fptoui(self, typ):",
"def fptosi(self, typ):",
"def foo(x, y):",
"def foo(x, y):",
"def foo(x, y):",
"def ustvari(self):\n raise NotImplementedError",
"def uitof... | [
"0.593064",
"0.593064",
"0.5369165",
"0.50348413",
"0.49899554",
"0.49625203",
"0.49625203",
"0.49625203",
"0.48502257",
"0.47876418",
"0.4764313",
"0.47458068",
"0.47448164",
"0.47011545",
"0.46468446",
"0.46424177",
"0.4555988",
"0.454327",
"0.45408794",
"0.45337006",
"0.45... | 0.0 | -1 |
Computes the L2 error of the adapted solution compared to the solution on the finest grid. The tree_adapted must have been projected to the finest grid first. | def global_error_to_finest_grid(tree_adapted, tree_finest):
error = 0
for index in tree_finest.tree_leaves:
error += (tree_finest.nvalue[index] - tree_adapted.nvalue[index])**2
error = math.sqrt(error)
if tree_finest.dimension == 1:
dx = mesh.space_step(tree_finest, tree_fine... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def potentialSolver2(self, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n \n # solve potential\n ... | [
"0.5702751",
"0.56921744",
"0.564493",
"0.5359636",
"0.5309151",
"0.5170774",
"0.51317436",
"0.51264113",
"0.50781935",
"0.50201297",
"0.49748135",
"0.49748135",
"0.4940611",
"0.48971447",
"0.48584917",
"0.48562384",
"0.48285002",
"0.48250198",
"0.48124108",
"0.48025668",
"0.... | 0.6766839 | 0 |
Retrieves an updated list of tickers for companies included in the S&P 500. Saves to a pickle file. | def retrieve_sp500():
source = 'https://en.wikipedia.org/wiki/List_of_S%26P_500_companies'
resp = requests.get(source)
soup = bs.BeautifulSoup(resp.text, 'lxml')
table = soup.find('table', {'class': 'wikitable sortable'})
tickers = []
for row in table.findAll('tr')[1:]:
ticker = r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retrieve_company_data(self):\n self.set_stock_sym_append_str('')\n self.set_stock_retrieval_type('all') #'all', watcher\n self.load_stock_symbol_fr_file()",
"def Save(self, filename = 'tickers.dat'):\n if not self.changed:\n if not self.silent:\n print('n... | [
"0.6478883",
"0.64458394",
"0.6418934",
"0.63052785",
"0.6192895",
"0.61889976",
"0.6067577",
"0.5903302",
"0.58534765",
"0.5844709",
"0.5843255",
"0.5743359",
"0.56932896",
"0.55991876",
"0.55669063",
"0.5554215",
"0.5516616",
"0.5503813",
"0.5497355",
"0.5488232",
"0.544957... | 0.74970037 | 0 |
Uses the most recent pickle file of stock tickers and retrieves the stock data for each ticker via the pandasdatreader get_yahoo_data() method. It saves each stock ticker as it's own csv file. The default time period | def get_data(retrieve = False, start='2019-01-01', comp = False):
if retrieve == True:
tickers = retrieve_sp500()
else:
with open('sp500_tickers.pickle', 'rb') as file:
tickers = pickle.load(file)
if not os.path.exists('sp500_data'):
os.mkdir('sp500_data')
exc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gather_stock_data(tickers, save=True):\n prices = pd.DataFrame()\n ts = TimeSeries(key='EY2QBMV6MD9FX9CP', output_format='pandas')\n\n for ticker in tickers:\n successful_grab = False\n ticker_daily_adj = None\n\n while successful_grab is not True:\n try:\n ... | [
"0.76792085",
"0.72361547",
"0.7161389",
"0.7098405",
"0.7028392",
"0.69908875",
"0.6981615",
"0.6946397",
"0.693942",
"0.6844427",
"0.6666727",
"0.6640161",
"0.66182846",
"0.6592676",
"0.65387475",
"0.65368146",
"0.64699507",
"0.64421386",
"0.64387715",
"0.6434986",
"0.63859... | 0.6820036 | 10 |
Formats and joins each individual stock's csv file into one large dataframe and writes it to a csv file. This can be automatically done during the initial data downloaded of the stock data within the | def compile_data():
with open('sp500_tickers.pickle', 'rb') as file:
tickers = pickle.load(file)
metasp = pd.DataFrame()
for count, ticker in enumerate(tickers):
df = pd.read_csv('sp500_data\{}.csv'.format(ticker))
df.set_index('Date', inplace=True)
df.rename(columns={'A... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_all_stocks():\n stocks = get_stocklist()\n dfs = {}\n for i, r in stocks.iterrows():\n start = time.time()\n s = r['Ticker']\n stockfile = '../stockdata/' + s + '.csv.gz'\n print('downloading', s)\n stock = quandl.get('EOD/' + s)\n stock.to_csv(stockf... | [
"0.6775382",
"0.6692272",
"0.6692215",
"0.6538182",
"0.6466794",
"0.6376456",
"0.6124688",
"0.6119177",
"0.6101064",
"0.6098649",
"0.6085523",
"0.60598516",
"0.60460734",
"0.60454655",
"0.59980625",
"0.5981653",
"0.59612113",
"0.59581226",
"0.592608",
"0.5909132",
"0.5907462"... | 0.6518698 | 4 |
add department data to database | def populate_db():
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
database = SqliteDatabase('../data/personjob.db') # navigate relative path to the db
logger.info('Working with Department class')
logger.info('Creating department records')
department_number = 0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _insert_department(self):\n # Insert\n if db_department.idx_department_exists(1) is False:\n record = Department(\n code=general.encode(self.reserved),\n name=general.encode(self.reserved))\n database = db.Database()\n database.add(re... | [
"0.7858063",
"0.72022516",
"0.7131679",
"0.71278006",
"0.7065719",
"0.7033584",
"0.7022429",
"0.68791884",
"0.6771128",
"0.6763694",
"0.646529",
"0.6310322",
"0.62592626",
"0.62209487",
"0.6152551",
"0.61301434",
"0.6085409",
"0.5994632",
"0.5987936",
"0.5961638",
"0.5939347"... | 0.6361228 | 11 |
Test if values that are set, then the configuration is saved and then loaded again, are the same. | def test_save_and_load(self, tmpdir, create_configuration):
global example_data
tmp_file = tmpdir.join("configuration.ini")
# create the configuration
configuration, load_args, save_args = create_configuration(tmp_file)
# set the values
for group, key, value, args in ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_config_save_restore1(self):\n\n config_filename_initial = 'test_configuration2'\n config_filename_save = 'save_configuration2'\n\n # Get config path\n local_dir = os.path.dirname(__file__)\n config_path_initial = os.path.join(local_dir, config_filename_initial)\n ... | [
"0.68488896",
"0.68204504",
"0.6643299",
"0.6561894",
"0.607547",
"0.6073705",
"0.602699",
"0.6008925",
"0.6005509",
"0.5995862",
"0.5968074",
"0.59674597",
"0.59479654",
"0.59245145",
"0.59239125",
"0.59189326",
"0.5917647",
"0.586907",
"0.58660805",
"0.58637446",
"0.584079"... | 0.5517543 | 55 |
Test if values that are set, then the configuration is saved and then loaded again, are the same. | def test_save_and_define_after_load(self, tmpdir, create_configuration):
global example_data
tmp_file = tmpdir.join("configuration.ini")
# create the configuration
configuration, load_args, save_args = create_configuration(tmp_file)
# set the values
for group, key, va... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_config_save_restore1(self):\n\n config_filename_initial = 'test_configuration2'\n config_filename_save = 'save_configuration2'\n\n # Get config path\n local_dir = os.path.dirname(__file__)\n config_path_initial = os.path.join(local_dir, config_filename_initial)\n ... | [
"0.6851151",
"0.68228287",
"0.6642664",
"0.65643656",
"0.6075316",
"0.6074868",
"0.602789",
"0.600922",
"0.60063636",
"0.5997755",
"0.59690094",
"0.5968977",
"0.59498835",
"0.59260166",
"0.5925142",
"0.59219694",
"0.5869016",
"0.58666855",
"0.5864089",
"0.5841494",
"0.5834879... | 0.5920246 | 16 |
Given the RNN outputs (presoftmax) at each time step and a target labeling, compute the negative of the CTC loss for one example, where the loss itself can be defined as the negative of the probability p(target | logits) as defined in equations 3 & 8 | def compute_ctc_loss(self, logits, target):
num_time_steps = logits.shape[0]
num_labels = logits.shape[1] - 1
num_labels_with_blank = num_labels + 1
# sanity check to ensure targets are all right
assert (target < num_labels).all()
######################
### YOUR CODE HERE ###
##############... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def CELOSS(output,label,delay = 0):\n if delay > 0:\n label.data[delay:,:] = label.data[0:-delay,:]\n label.data[0:delay, :] = -1\n _,predict = torch.max(output,1)\n correct = (predict.data == label.view(-1).data).sum()\n\n #correct = np.sum(predict_data == yt.reshape(-1))\n \n mask... | [
"0.7144969",
"0.6606015",
"0.6490216",
"0.64216244",
"0.6363278",
"0.63588995",
"0.63528866",
"0.63436717",
"0.63401145",
"0.633253",
"0.63303226",
"0.631504",
"0.6300099",
"0.6297033",
"0.6292471",
"0.6279375",
"0.62720025",
"0.6260915",
"0.62449986",
"0.6224692",
"0.6217328... | 0.7510228 | 0 |
Given the normalized RNN outputs (postsoftmax) at each time step and a target labeling, compute the forward variables alpha_t(s) as defined in equation 5 in the paper | def compute_forward_variables(self, normalized_logits, target):
target_length = target.shape[0]
num_time_steps = normalized_logits.shape[0]
######################
### YOUR CODE HERE ###
######################
blank_label = normalized_logits.shape[1] - 1
l = add_blanks(target, blank_label)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calculate_alpha(self, feats):\n \n init_alphas = torch.Tensor(1, self.tagset_size).fill_(-10000.)\n init_alphas[0][self.tag_to_ix[START_TAG]] = 0.\n\n forward_var = autograd.Variable(init_alphas)\n\n for feat in feats:\n alphas_t = [] # The forward variables at t... | [
"0.6556268",
"0.6452523",
"0.6378413",
"0.62199193",
"0.6107131",
"0.6078645",
"0.60783464",
"0.6060503",
"0.6053484",
"0.6044611",
"0.6033897",
"0.60004437",
"0.5989006",
"0.59869456",
"0.5968317",
"0.5951192",
"0.5950084",
"0.5944599",
"0.5943287",
"0.5917645",
"0.5909624",... | 0.73559594 | 0 |
Given the normalized RNN outputs (postsoftmax) at each time step and a target labeling, compute the backward variables beta_t(s) as defined in equation 9 in the paper | def compute_backward_variables(self, normalized_logits, target):
target_length = target.shape[0]
num_time_steps = normalized_logits.shape[0]
######################
### YOUR CODE HERE ###
######################
blank_label = normalized_logits.shape[1] - 1
l = add_blanks(target, blank_label)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backwardVariableGeneration(self):\n self.beta = zeros((self.noOfEmmittingStates+2, self.T + 1))\n\n # initialisation\n for j in range(self.noOfEmmittingStates+1):\n self.beta[j,-1] = self.transitionMatrix[j,-1]\n self.beta[-1,-1] = 1.0\n\n # main recursion\n for t in range(self.T, 1, -1)... | [
"0.69956106",
"0.64794415",
"0.64426166",
"0.6405609",
"0.6382755",
"0.62425697",
"0.6233701",
"0.62206537",
"0.6206972",
"0.6171835",
"0.6160794",
"0.6156567",
"0.6151788",
"0.614928",
"0.6116877",
"0.61009604",
"0.61001897",
"0.60951155",
"0.609498",
"0.6073558",
"0.6066956... | 0.7704807 | 0 |
Given the RNN outputs (presoftmax) at each time step and a target labeling, compute the gradients of the CTC loss w.r.t. the unnormalized logits | def compute_gradients(self, logits, target):
target_length = target.shape[0]
num_time_steps = logits.shape[0]
######################
### YOUR CODE HERE ###
######################
# expand labels by inserting a blank between each pair
normalized_logits = softmax(logits)
blank_label = normali... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_ctc_loss(self, logits, target):\n\n num_time_steps = logits.shape[0]\n num_labels = logits.shape[1] - 1\n num_labels_with_blank = num_labels + 1\n\n # sanity check to ensure targets are all right\n assert (target < num_labels).all()\n\n\t\t######################\n\t\t### YOUR CODE HERE #... | [
"0.70471126",
"0.6771997",
"0.6501649",
"0.6481051",
"0.6475507",
"0.64638615",
"0.645722",
"0.644719",
"0.6429101",
"0.6332298",
"0.6330999",
"0.6292698",
"0.622307",
"0.6192175",
"0.6190752",
"0.61711174",
"0.6128896",
"0.61129713",
"0.6112532",
"0.6099241",
"0.60904557",
... | 0.7260533 | 0 |
would this part be timecomsuming? | def __call__(self, rgbd_img_batch, color_id):
color = vis.id2color[color_id]
lower, upper = np.array(hsv_range[color])
#print('debug: rgbd_img_batch shape: ', rgbd_img_batch.shape)
color_imgs, depth_imgs = rgbd_img_batch[:, :3, :, :], rgbd_img_batch[:, 3, :, :]
color_imgs = colo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _optimise(self):\n pass",
"def process():",
"def apply(self) -> None:",
"def apply(self) -> None:",
"def process(self):",
"def process(self):",
"def process(self):",
"def apply(self):",
"def task4_1(self):\n\n pass",
"def task4(self):\n\n pass",
"def reduce_run():",
"... | [
"0.6332494",
"0.57432336",
"0.56503594",
"0.56503594",
"0.55950046",
"0.55950046",
"0.55950046",
"0.5529664",
"0.5525137",
"0.5439686",
"0.54379976",
"0.53378075",
"0.5307097",
"0.5272914",
"0.5244519",
"0.52339005",
"0.52292556",
"0.52130395",
"0.5194305",
"0.51748556",
"0.5... | 0.0 | -1 |
Deletes text object file, database records and any keywords in the graph. | def TextDelete(texttitle):
path = app.config['UPLOAD_FOLDER'] + \
'/objects/' + texttitle + '.txt'
with Database() as database:
database.deleteText(texttitle, session['id'])
# Loads in the file to be deleted and the keyword graph
with open(path, "rb") as objectfile:
current_fil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete():",
"def clear_db():\n humans = Human4j.nodes.all()\n for h in humans:\n h.delete()\n binomes = Binome4j.nodes.all()\n for b in binomes:\n b.delete()\n projects = Project4j.nodes.all()\n for p in projects:\n p.delete()\n sherpas = Sherpa4j.nodes.all()\n fo... | [
"0.66543853",
"0.6603808",
"0.6559491",
"0.6447322",
"0.64100724",
"0.6389136",
"0.6299942",
"0.62388057",
"0.6218455",
"0.6199544",
"0.6175071",
"0.61286473",
"0.6114",
"0.6112866",
"0.6111774",
"0.6104314",
"0.60767096",
"0.6068975",
"0.60340655",
"0.6027067",
"0.60106134",... | 0.78041196 | 0 |
Formats the texts recived from a database search to the format used to display them in the users profile page. | def formatTexts(owned, shared):
owned_texts = []
shared_texts = []
# Catches error if there is no score from the databse search
try:
for text in range(len(owned)):
owned_texts.append(
{'title': owned[text][0], 'body': owned[text][1], 'score': owned[text][2]})
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_search_content(self):\n words = [\",\".join(self.__get_property_from_all_views(\"resource_id\")),\n \",\".join(self.__get_property_from_all_views(\"text\"))]\n return \"\\n\".join(words)",
"def get_person_text(self, uid):\n words = \"\"\n\n query = \"\"\"\nSE... | [
"0.62584585",
"0.57925856",
"0.56610876",
"0.5613524",
"0.55420005",
"0.55332226",
"0.5522507",
"0.55062926",
"0.54419696",
"0.54157835",
"0.54024386",
"0.5361505",
"0.53395677",
"0.52929306",
"0.5253612",
"0.52431804",
"0.52359235",
"0.5234747",
"0.523413",
"0.5231484",
"0.5... | 0.55189323 | 7 |
Gets the extension of the submitted file | def check_extension(f):
parts = f.split('.')
last = parts[len(parts) - 1]
return last in allowed_extensions | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extension(self):\n return os.path.splitext(self.fname)[1]",
"def extension(self):\n name, ext = os.path.splitext(self.original_filename)\n return ext",
"def extension(self):\n #type: ()->Text\n return os.path.splitext(os.path.basename(self.fileName))[1]",
"def get_file_... | [
"0.85816354",
"0.8499633",
"0.84875196",
"0.8477434",
"0.8317361",
"0.82983124",
"0.7956723",
"0.79486096",
"0.79430157",
"0.79303133",
"0.786467",
"0.78199774",
"0.7804541",
"0.77982265",
"0.77892864",
"0.7778937",
"0.7774032",
"0.77076656",
"0.769469",
"0.7674665",
"0.76132... | 0.0 | -1 |
Wrapper for function that require the user to be logged in to access the function | def login_required(f):
@wraps(f)
def wrap(*args, **kwargs):
if 'logged_in' in session:
return f(*args, **kwargs)
else:
flash("You need to login first")
return redirect(url_for('login_page'))
return wrap | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dnzo_login_required(fn):\n def logged_in_wrapper(self, *args):\n from google.appengine.api.users import get_current_user\n dnzo_user = get_dnzo_user()\n \n if not dnzo_user and get_current_user():\n from tasks_data.users import create_user\n dnzo_user = create_user(get_current_user())\n ... | [
"0.79133797",
"0.7734768",
"0.77311295",
"0.7664327",
"0.76305085",
"0.75790405",
"0.7569456",
"0.7517191",
"0.75057024",
"0.74649686",
"0.7450219",
"0.7421285",
"0.7417829",
"0.74123853",
"0.7400424",
"0.73878455",
"0.73771745",
"0.7367976",
"0.7355343",
"0.7328803",
"0.7320... | 0.68923974 | 91 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.