%d: elapsed_time:%d acc_validation: %f, loss_validation: %f, memory_percent: %4s' % (\\n validation_step,validation_step * self.batch_no_validation\\n , elapsed, acc_vali, loss_vali, str(process.memory_percent()),\\n ))\\n\\n settings.queue_isready_vl = False\\n acc_validation = acc_validation / (validation_step)\\n loss_validation = loss_validation / (validation_step)\\n dsc_validation = dsc_validation / (validation_step)\\n if np.isnan(dsc_validation) or np.isnan(loss_validation) or np.isnan(acc_validation):\\n print('nan problem')\\n _fill_thread_vl.kill_thread()\\n print('******Validation, step: %d , accuracy: %.4f, loss: %f*******' % (\\n itr1, acc_validation, loss_validation))\\n\\n [sum_validation] = sess.run([summ],\\n feed_dict={image: validation_CT_image_patchs,\\n label: validation_GTV_label,\\n penalize: validation_Penalize_patch,\\n dropout: 1,\\n is_training: False,\\n ave_vali_acc: acc_validation,\\n ave_loss_vali: loss_validation,\\n ave_dsc_vali:dsc_validation,\\n dense_net_dim: self.patch_window,\\n is_training_bn: False,\\n alpha: 1,\\n beta: 1,\\n surf_map: validation_Surface_patch,\\n\\n })\\n validation_writer.add_summary(sum_validation, point)\\n print('end of validation---------%d' % (point))\\n\\n #loop for training batches\\n while(step*self.batch_no<self.no_sample_per_each_itr):\\n [train_CT_image_patchs, train_GTV_label, train_Penalize_patch,loss_coef_weights,train_Surface_patch] = _image_class.return_patches( self.batch_no)\\n\\n if (len(train_CT_image_patchs)<self.batch_no)|(len(train_GTV_label)<self.batch_no)\\\\\\n |(len(train_Penalize_patch)<self.batch_no)|(len(train_Surface_patch)<self.batch_no):\\n time.sleep(0.5)\\n _read_thread.resume()\\n continue\\n\\n tic=time.time()\\n [acc_train1, loss_train1, optimizing,out,dsc_train11] = sess.run([accuracy, cost, optimizer,y,f1_measure],\\n feed_dict={image: train_CT_image_patchs,\\n label: train_GTV_label,\\n penalize: train_Penalize_patch,\\n # loss_coef: loss_coef_weights,\\n dropout: self.dropout_keep,\\n is_training: True,\\n ave_vali_acc: -1,\\n ave_loss_vali: -1,\\n ave_dsc_vali: -1,\\n dense_net_dim: self.patch_window,\\n is_training_bn: True,\\n alpha: self.alpha_coeff,\\n beta: self.beta_coeff,\\n surf_map: train_Surface_patch,\\n\\n })\\n elapsed=time.time()-tic\\n dsc_train1=dsc_train11[1]\\n\\n self.x_hist=self.x_hist+1\\n # np.hstack((self.x_hist, [np.ceil(\\n\\n [sum_train] = sess.run([summ],\\n feed_dict={image: train_CT_image_patchs,\\n label: train_GTV_label,\\n penalize: train_Penalize_patch,\\n dropout: self.dropout_keep, is_training: True,\\n ave_vali_acc: acc_train1,\\n ave_loss_vali: loss_train1,\\n ave_dsc_vali: dsc_train1,\\n dense_net_dim: self.patch_window,\\n is_training_bn: True,\\n alpha: self.alpha_coeff,\\n beta: self.beta_coeff,\\n surf_map: train_Surface_patch,\\n\\n })\\n train_writer.add_summary(sum_train,point)\\n step = step + 1\\n\\n process = psutil.Process(os.getpid())\\n\\n print(\\n 'point: %d, elapsed_time:%d step*self.batch_no:%f , LR: %.15f, acc_train1:%f, loss_train1:%f,memory_percent: %4s' % (\\n int((point)),elapsed,\\n step * self.batch_no, self.learning_rate, acc_train1, loss_train1,\\n str(process.memory_percent())))\\n\\n\\n point=int((point))\\n if point%100==0:\\n '''saveing model inter epoch'''\\n chckpnt_path = os.path.join(self.chckpnt_dir,\\n ('densenet_unet_inter_epoch%d_point%d.ckpt' % (epoch, point)))\\n saver.save(sess, chckpnt_path, global_step=point)\\n itr1 = itr1 + 1\\n point=point+1\\n endTime = time.time()\\n\\n #==============\\n '''saveing model after each epoch'''\\n chckpnt_path = os.path.join(self.chckpnt_dir, 'densenet_unet.ckpt')\\n saver.save(sess, chckpnt_path, global_step=epoch)\\n print(\\\"End of epoch----> %d, elapsed time: %d\\\" % (epoch, endTime - startTime))\",\n \"def add_conv_layer(self, input_layer, hyperparams, func='relu', bn=True):\\n W = self._weight_variable(shape=hyperparams[0])\\n b = self._bias_variable(shape=hyperparams[1])\\n if bn:\\n return self._batch_normalize(\\n self._nonlinearity(func)(self._conv2d(input_layer, W) + b))\\n elif not bn:\\n return self._nonlinearity(func)(self._conv2d(input_layer, W) + b)\",\n \"def Classify(x, reuse=False, keepProb=1.0,isNankai=False):\\n with tf.variable_scope('Classify') as scope: \\n if reuse:\\n scope.reuse_variables()\\n \\n # 1st layer\\n w1 = weight_variable('w1',[dInput,nHidden])\\n bias1 = bias_variable('bias1',[nHidden])\\n h1 = fc_relu(x,w1,bias1,keepProb)\\n \\n # 2nd layer\\n w2 = weight_variable('w2',[nHidden,nHidden2])\\n bias2 = bias_variable('bias2',[nHidden2])\\n h2 = fc_relu(h1,w2,bias2,keepProb) \\n \\n # 3nd layer\\n w3 = weight_variable('w3',[nHidden2,nHidden3])\\n bias3 = bias_variable('bias3',[nHidden3])\\n h3 = fc_relu(h2,w3,bias3,keepProb) \\n\\n \\n # Toy\\n if dataMode == 0:\\n # 3rd layar\\n w3 = weight_variable('w3',[nHidden2,nClass])\\n bias3 = bias_variable('bias3',[nClass])\\n y = fc(h2,w3,bias3,keepProb)\\n # Nankai\\n else:\\n # 4th layer\\n w4_1 = weight_variable('w4_1',[nHidden3,nClass])\\n bias4_1 = bias_variable('bias4_1',[nClass])\\n \\n w4_2 = weight_variable('w4_2',[nHidden3,nClass])\\n bias4_2 = bias_variable('bias4_2',[nClass])\\n \\n w4_3 = weight_variable('w4_3',[nHidden3,nClass])\\n bias4_3 = bias_variable('bias4_3',[nClass])\\n \\n y1 = fc(h3,w4_1,bias4_1,keepProb)\\n y2 = fc(h3,w4_2,bias4_2,keepProb)\\n y3 = fc(h3,w4_3,bias4_3,keepProb)\\n # [number of data, number of class, cell(=3)]\\n y = tf.concat((tf.expand_dims(y1,2),tf.expand_dims(y2,2),tf.expand_dims(y3,2)),2)\\n \\n # shape=[None,number of class]\\n return y\",\n \"def entangling_layer(nqubits):\\n # In other words it should apply something like :\\n # CNOT CNOT CNOT CNOT... CNOT\\n # CNOT CNOT CNOT... CNOT\\n for i in range(0, nqubits - 1, 2): # Loop over even indices: i=0,2,...N-2\\n qml.CNOT(wires=[i, i + 1])\\n for i in range(1, nqubits - 1, 2): # Loop over odd indices: i=1,3,...N-3\\n qml.CNOT(wires=[i, i + 1])\",\n \"def modelbuilder():\\n model = Sequential()\\n # Add a convolution layer with with a sigmoid activation function\\n model.add(layers.Conv2D(1, (2, 2), strides=(1, 1), activation='sigmoid', padding='same', input_shape=(256, 256, 3)))\\n model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\\n model.summary()\\n return model\",\n \"def build_layers(self):\\n raise NotImplementedError\",\n \"def build(self, hp):\\n\\n model = Sequential()\\n model.add(Conv2D(filters=hp.Choice('num_filters_0', values=[8, 16, 32, 64]),\\n kernel_size=hp.Choice('kernel_size_0', values=[3, 4, 5]),\\n activation=hp.Choice('activation_0', values=['relu', 'tanh']),\\n input_shape=self.input_shape))\\n\\n for i in range(hp.Int('num_layers', 1, 3)):\\n model.add(Conv2D(filters=hp.Choice('num_filters_%d' % (i + 1), values=[8, 16, 32, 64]),\\n kernel_size=hp.Choice('kernel_size_%d' % (i + 1), values=[3, 4, 5]),\\n activation=hp.Choice('activation_%d' % (i + 1), values=['relu', 'tanh'])))\\n model.add(Flatten())\\n model.add(Dense(N_zern))\\n model.summary()\\n\\n model.compile(optimizer=keras.optimizers.Adam(hp.Choice('learning_rate', values=[1e-3, 5e-4, 1e-4])),\\n loss='mean_squared_error')\\n return model\",\n \"def test_ctor(self):\\r\\n # the network model itself\\r\\n model = densenet.DenseNet(\\r\\n depth=40,\\r\\n Block=densenet.BasicBlock,\\r\\n growth_rate=12,\\r\\n compression_rate=1.0,\\r\\n mask=True,\\r\\n num_classes=100,\\r\\n )\\r\\n num_params = model_utils.get_model_num_params(model)\\r\\n\\r\\n self.assertAlmostEqual(num_params, 1.06, places=1) # around 1.7\\r\\n self.assertEqual(model_utils.get_num_conv2d_layers(model), 40)\",\n \"def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,\\n hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,\\n dtype=np.float32):\\n self.params = {}\\n self.reg = reg\\n self.dtype = dtype\\n \\n ############################################################################\\n # TODO: Initialize weights and biases for the three-layer convolutional #\\n # network. Weights should be initialized from a Gaussian with standard #\\n # deviation equal to weight_scale; biases should be initialized to zero. #\\n # All weights and biases should be stored in the dictionary self.params. #\\n ############################################################################\\n \\n # Store weights and biases for the convolutional layer using the keys 'W1' and 'b1'; \\n C, H, W = input_dim\\n filter_sizes = (filter_size, filter_size)\\n self.params['W1'] = np.random.normal(0, weight_scale, [num_filters, C, filter_sizes[0], filter_sizes[1]])\\n self.params['b1'] = np.zeros((num_filters, ))\\n\\n # use keys 'W2' and 'b2' for the weights and biases of the hidden affine layer;\\n # In this case, ConvLayer doesn't reduce the spatial size of the input, (N, C, H, W) -> Conv -> (N, F, H, W)\\n # To satisfy this constraint, (W + 2 * pad - filter_size) / stride + 1 = W need to hold, which led to pad = (F - S) / 2 where S == 1\\n # (N, C, H, W) -> Conv -> (N, F, H, W) -> Pooling -> (N, F, H/2, W/2)\\n # In a FC_NN, FCL weights (input_dim, hidden_dim) where every img is flatten into a 1D array of length D = F * H/2 * W/2.\\n self.params['W2'] = np.random.normal(0, weight_scale, [num_filters * (H / 2) * (W / 2), hidden_dim])\\n self.params['b2'] = np.zeros((hidden_dim, ))\\n\\n # And the keys 'W3' and 'b3' for the weights and biases of the output affine layer. \\n self.params['W3'] = np.random.normal(0, weight_scale, [hidden_dim, num_classes])\\n self.params['b3'] = np.zeros((num_classes, ))\\n\\n \\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n for k, v in self.params.iteritems():\\n self.params[k] = v.astype(dtype)\",\n \"def basic_block(self, input_feats, name1, name2, is_train, use_batch_norm, c, s=2):\\n branch1_feats = convolution_no_bias(input_feats, 1, 1, 4*c, s, s, name1+'_branch1')\\n branch1_feats = batch_norm(branch1_feats, name2+'_branch1', is_train, use_batch_norm)\\n\\n branch2a_feats = convolution_no_bias(input_feats, 1, 1, c, s, s, name1+'_branch2a')\\n branch2a_feats = batch_norm(branch2a_feats, name2+'_branch2a', is_train, use_batch_norm)\\n branch2a_feats = nonlinear(branch2a_feats, 'relu')\\n\\n branch2b_feats = convolution_no_bias(branch2a_feats, 3, 3, c, 1, 1, name1+'_branch2b')\\n branch2b_feats = batch_norm(branch2b_feats, name2+'_branch2b', is_train, use_batch_norm)\\n branch2b_feats = nonlinear(branch2b_feats, 'relu')\\n\\n branch2c_feats = convolution_no_bias(branch2b_feats, 1, 1, 4*c, 1, 1, name1+'_branch2c')\\n branch2c_feats = batch_norm(branch2c_feats, name2+'_branch2c', is_train, use_batch_norm)\\n\\n output_feats = branch1_feats + branch2c_feats\\n output_feats = nonlinear(output_feats, 'relu')\\n return output_feats\",\n \"def __init__(self, mod_param, epochNb=3):\\n tf.reset_default_graph()\\n weight_path = '../caffe_layers_value.pickle'\\n model_path = mod_param.paths[\\\"save_model\\\"]\\n model_path += '-'+str(epochNb)\\n self.mod_param = mod_param\\n self.labels = mod_param.labels\\n self.n_labels = mod_param.n_labels\\n \\n # Initialize some tensorflow variables\\n self.images_tf = tf.placeholder( tf.float32, [None, None, None, 3], name=\\\"images\\\")\\n self.labels_tf = tf.placeholder( tf.int64, [None], name='labels')\\n \\n detector = Detector(mod_param)\\n c1,c2,c3,c4,conv5, self.conv6, self.gap, self.output = detector.inference( self.images_tf )\\n self.detector = detector\\n \\n self.sess = tf.InteractiveSession()\\n saver = tf.train.Saver()\\n saver.restore( self.sess, model_path )\\n\\n if re.match(\\\".*CAM.*_W_S\\\", self.mod_param.mod_type):\\n self.classmap = self.detector.get_classmap( self.labels_tf, self.conv6 )\",\n \"def construct_model():\\n import lbann\\n\\n # Layer graph\\n input = lbann.Input(target_mode='N/A', name='inp_data')\\n # data is 64*64*4 images + 15 scalar + 5 param\\n #inp_slice = lbann.Slice(input, axis=0, slice_points=\\\"0 16399 16404\\\",name='inp_slice')\\n inp_slice = lbann.Slice(input, axis=0, slice_points=str_list([0,args.ydim,args.ydim+5]),name='inp_slice')\\n gt_y = lbann.Identity(inp_slice,name='gt_y')\\n gt_x = lbann.Identity(inp_slice, name='gt_x') #param not used\\n\\n zero = lbann.Constant(value=0.0,num_neurons='1',name='zero')\\n one = lbann.Constant(value=1.0,num_neurons='1',name='one')\\n\\n z_dim = 20 #Latent space dim\\n\\n z = lbann.Gaussian(mean=0.0,stdev=1.0, neuron_dims=\\\"20\\\")\\n model = macc_models.MACCWAE(args.zdim,args.ydim,cf=args.mcf,use_CNN=args.useCNN)\\n d1_real, d1_fake, d_adv, pred_y = model(z,gt_y)\\n\\n d1_real_bce = lbann.SigmoidBinaryCrossEntropy([d1_real,one],name='d1_real_bce')\\n d1_fake_bce = lbann.SigmoidBinaryCrossEntropy([d1_fake,zero],name='d1_fake_bce')\\n d_adv_bce = lbann.SigmoidBinaryCrossEntropy([d_adv,one],name='d_adv_bce')\\n img_loss = lbann.MeanSquaredError([pred_y,gt_y])\\n rec_error = lbann.L2Norm2(lbann.WeightedSum([pred_y,gt_y], scaling_factors=\\\"1 -1\\\"))\\n\\n layers = list(lbann.traverse_layer_graph(input))\\n # Setup objective function\\n weights = set()\\n src_layers = []\\n dst_layers = []\\n for l in layers:\\n if(l.weights and \\\"disc0\\\" in l.name and \\\"instance1\\\" in l.name):\\n src_layers.append(l.name)\\n #freeze weights in disc2\\n if(l.weights and \\\"disc1\\\" in l.name):\\n dst_layers.append(l.name)\\n for idx in range(len(l.weights)):\\n l.weights[idx].optimizer = lbann.NoOptimizer()\\n weights.update(l.weights)\\n l2_reg = lbann.L2WeightRegularization(weights=weights, scale=1e-4)\\n d_adv_bce = lbann.LayerTerm(d_adv_bce,scale=0.01)\\n obj = lbann.ObjectiveFunction([d1_real_bce,d1_fake_bce,d_adv_bce,img_loss,rec_error,l2_reg])\\n # Initialize check metric callback\\n metrics = [lbann.Metric(img_loss, name='recon_error')]\\n #pred_y = macc_models.MACCWAE.pred_y_name\\n callbacks = [lbann.CallbackPrint(),\\n lbann.CallbackTimer(),\\n lbann.CallbackSaveModel(dir=args.dump_models),\\n lbann.CallbackReplaceWeights(source_layers=list2str(src_layers),\\n destination_layers=list2str(dst_layers),\\n batch_interval=2)]\\n\\n if(args.ltfb_batch_interval > 0) :\\n callbacks.append(lbann.CallbackLTFB(batch_interval=args.ltfb_batch_interval,metric='recon_error',\\n low_score_wins=True,\\n exchange_hyperparameters=True))\\n\\n # Construct model\\n return lbann.Model(args.num_epochs,\\n serialize_io=True,\\n weights=weights,\\n layers=layers,\\n metrics=metrics,\\n objective_function=obj,\\n callbacks=callbacks)\",\n \"def __init__(self, depth=7, feature_size=512, use_eql=True, gpu_parallelize=False):\\r\\n from torch.nn import ModuleList\\r\\n from CustomLayers import DisGeneralConvBlock, DisFinalBlock, _equalized_conv2d\\r\\n from torch.nn import Conv2d\\r\\n\\r\\n super().__init__()\\r\\n\\r\\n assert feature_size != 0 and ((feature_size & (feature_size - 1)) == 0), \\\\\\r\\n \\\"latent size not a power of 2\\\"\\r\\n if depth >= 4:\\r\\n assert feature_size >= np.power(2, depth - 4), \\\\\\r\\n \\\"feature size cannot be produced\\\"\\r\\n\\r\\n # create state of the object\\r\\n self.gpu_parallelize = gpu_parallelize\\r\\n self.use_eql = use_eql\\r\\n self.depth = depth\\r\\n self.feature_size = feature_size\\r\\n\\r\\n # create the fromRGB layers for various inputs:\\r\\n if self.use_eql:\\r\\n def from_rgb(out_channels):\\r\\n return _equalized_conv2d(1, out_channels, (1, 1), bias=True)\\r\\n else:\\r\\n def from_rgb(out_channels):\\r\\n return Conv2d(1, out_channels, (1, 1), bias=True)\\r\\n\\r\\n self.rgb_to_features = ModuleList()\\r\\n self.final_converter = from_rgb(self.feature_size // 2)\\r\\n\\r\\n # create a module list of the other required general convolution blocks\\r\\n self.layers = ModuleList()\\r\\n self.final_block = DisFinalBlock(self.feature_size, use_eql=self.use_eql)\\r\\n\\r\\n # create the remaining layers\\r\\n for i in range(self.depth - 1):\\r\\n if i > 2:\\r\\n layer = DisGeneralConvBlock(\\r\\n int(self.feature_size // np.power(2, i - 2)),\\r\\n int(self.feature_size // np.power(2, i - 2)),\\r\\n use_eql=self.use_eql\\r\\n )\\r\\n rgb = from_rgb(int(self.feature_size // np.power(2, i - 1)))\\r\\n else:\\r\\n layer = DisGeneralConvBlock(self.feature_size, self.feature_size // 2,\\r\\n use_eql=self.use_eql)\\r\\n rgb = from_rgb(self.feature_size // 2)\\r\\n\\r\\n self.layers.append(layer)\\r\\n self.rgb_to_features.append(rgb)\\r\\n\\r\\n # just replace the last converter\\r\\n self.rgb_to_features[self.depth - 2] = \\\\\\r\\n from_rgb(self.feature_size // np.power(2, i - 2))\\r\\n\\r\\n # parallelize the modules from the module-lists if asked to:\\r\\n if self.gpu_parallelize:\\r\\n for i in range(len(self.layers)):\\r\\n self.layers[i] = torch.nn.DataParallel(self.layers[i])\\r\\n self.rgb_to_features[i] = torch.nn.DataParallel(\\r\\n self.rgb_to_features[i])\\r\\n\\r\\n # Note that since the FinalBlock contains the StdDev layer,\\r\\n # it cannot be parallelized so easily. It will have to be parallelized\\r\\n # from the Lower level (from CustomLayers). This much parallelism\\r\\n # seems enough for me.\\r\",\n \"def baseUNet(input_shape,conv_depth,n_classes,init_w,dropout):\\n inputs = Input(input_shape)\\n\\n c1=Conv2D(conv_depth,\\n (3,3),\\n activation='relu',\\n padding='same',\\n kernel_initializer=init_w)(inputs)\\n\\n c1=Conv2D(conv_depth,\\n (3,3),\\n activation='relu',\\n padding=\\\"same\\\",\\n kernel_initializer=init_w)(c1)\\n\\n # pool down to next layer\\n pool1 = MaxPooling2D((2,2),strides = (2,2))(c1)\\n\\n conv_depth *= 2\\n\\n # convolute down again\\n conv2 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool1)\\n\\n conv2 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv2)\\n \\n # pool down again\\n pool2 = MaxPooling2D((2,2),strides = (2,2))(conv2)\\n\\n conv_depth *= 2 \\n\\n # Convolution\\n conv3 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool2)\\n\\n conv3 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv3)\\n \\n # pool down\\n pool3 = MaxPooling2D((2,2),strides = (2,2))(conv3)\\n\\n conv_depth *= 2 \\n # Convolution\\n conv4 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool3)\\n\\n conv4 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv4)\\n \\n # pool down \\n pool4 = MaxPooling2D((2,2),strides = (2,2))(conv4)\\n\\n conv_depth *=2 \\n\\n # Convolution\\n conv5 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool4)\\n\\n conv5 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv5)\\n\\n drop = Dropout(dropout)(conv5)\\n\\n conv_depth /= 2\\n conv_depth = int(conv_depth) \\n # do upsampling\\n up1 = UpSampling2D(size = (2,2))(drop)\\n conv6 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up1)\\n \\n # add in skip info\\n cat1 = concatenate([conv4,conv6],axis = 3)\\n conv6 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat1)\\n\\n conv6 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv6)\\n\\n conv_depth /= 2\\n conv_depth = int(conv_depth)\\n # do upsampling\\n up2 = UpSampling2D(size = (2,2))(conv6)\\n conv7 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up2)\\n \\n # add in skip info\\n cat2 = concatenate([conv3,conv7],axis = 3)\\n conv7 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat2)\\n\\n conv7 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv7)\\n \\n conv_depth /= 2\\n conv_depth = int(conv_depth)\\n # do upsampling\\n up3 = UpSampling2D(size = (2,2))(conv7)\\n conv8 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size=(3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up3)\\n \\n # add in skip info\\n cat3 = concatenate([conv2,conv8],axis = 3)\\n conv8 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat3)\\n\\n conv8 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv8)\\n \\n conv_depth /= 2\\n conv_depth = int(conv_depth)\\n # do upsampling\\n up4 = UpSampling2D(size = (2,2))(conv8)\\n conv9 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up4)\\n \\n # add in skip info\\n cat4 = concatenate([c1,conv9],axis = 3)\\n conv9 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat4)\\n\\n conv9 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv9)\\n\\n outputs = Conv2D(n_classes, 1, activation = 'softmax')(conv9)\\n\\n return outputs,inputs\",\n \"def model_CNN(x_train, y_train, x_test=None, y_test=None, kwargs={}):\\n \\\"\\\"\\\"\\n Notes on Input shape\\n 4D tensor with shape (batch_size, timesteps, features, `colors`).\\n 4D tensor with shape: (samples, rows, cols, channels)\\n `channels_last` (default)\\n Output 4D tensor with shape: (samples, new_rows, new_cols, filters)\\n \\\"\\\"\\\"\\n ######## CNN for stocks\\n # create and fit CNN\\n # input_shape = StockDate x Lookback x Features\\n from keras.layers import Conv2D, MaxPooling2D\\n from keras.optimizers import SGD\\n\\n\\n layers = kwargs.get('layers', 10 ) #TODO\\n nodes = kwargs.get('nodes', None) #TODO\\n\\n if nodes is None or nodes==0 or nodes==[0]:\\n nodes = [np.shape(x_train)[1]*3]\\n elif isinstance(nodes, (int, np.integer)): # turn int to list\\n nodes = [nodes]\\n\\n if layers > 1 and len(nodes) < layers:\\n nodes = list(np.pad(nodes,[0,layers-len(nodes)], mode='constant',constant_values=nodes[-1]))\\n\\n ndim = np.max([2,len(np.shape(x_train))]) # Min 2D\\n if ndim==2:\\n input_shape=(x_train.shape[1],)\\n elif ndim==3:\\n input_shape=(x_train.shape[1],x_train.shape[2])\\n elif ndim==4:\\n input_shape=(x_train.shape[1],x_train.shape[2],x_train.shape[3])\\n else:\\n input_shape=x_train.shape[1:]\\n if kwargs.get('learning_rate', False):\\n lr = kwargs.get('learning_rate')\\n else:\\n lr = False\\n\\n if False:\\n conv = (3, 3)\\n else:\\n conv = (2, 2)\\n n_conv = 5\\n\\n if np.ndim(y_train)==1:\\n n_out = 1 #e.g. forecast y as float, just 1 step ahead.\\n else:\\n n_out = np.shape(y_train)[1] #e.g. onehot encoded, or n-steps ahead.\\n\\n dropout = kwargs.get('dropout',0) # dropout rate between 0 and 1.\\n #stateful = kwargs.get('stateful',True)\\n actvn = 'relu' #kwargs.get('actvn','relu')\\n actvl = kwargs.get('actvl','sigmoid')\\n model=[]\\n model = Sequential() # https://keras.io/models/sequential/\\n model.reset_states()\\n # input: 100x100 images with 3 channels -> (100, 100, 3) tensors.\\n # this applies 32 convolution filters of size 3x3 each.\\n model.add(Conv2D(n_conv, conv, activation=actvn, input_shape=input_shape))\\n #model.add(Conv2D(n_conv, conv, activation=actvn))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(dropout ))\\n\\n model.add(Conv2D(n_conv*2, conv, activation=actvn))\\n #model.add(Conv2D(n_conv*2, conv, activation=actvn))\\n #model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(dropout ))\\n\\n model.add(Flatten())\\n model.add(Dense(np.min(input_shape), activation=actvn))\\n model.add(Dropout(dropout*2))\\n model.add(Dense(n_out, activation=actvl))\\n\\n if hasattr(kwargs,'optimizer'):\\n optimizer = kwargs['optimizer']\\n elif lr:\\n optimizer = SGD(lr=lr, decay=1e-6, momentum=0.01, nesterov=True)\\n else:\\n optimizer = 'Nadam' #keras.optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0, nesterov=False)\\n\\n if is_bool_dtype(y_train):\\n model.compile(loss='binary_crossentropy', optimizer=optimizer)\\n if is_categorical_dtype(y_train) or kwargs.get('onehot',False):\\n #TODO Multiple Category\\n model.compile(loss='categorical_crossentropy', optimizer=optimizer)\\n else:\\n #model.compile(loss='mean_squared_error', optimizer=optimizer)\\n model.compile(loss='mean_squared_error', optimizer=optimizer, metrics=[r2_keras])\\n\\n\\n if kwargs.get('verbose',False) > 1:\\n model.summary()\\n print(\\\"Inputs: {}\\\".format(model.input_shape))\\n print(\\\"Outputs: {}\\\".format(model.output_shape))\\n print(\\\"Actual input: {}\\\".format(x_train.shape))\\n print(\\\"Actual output: {}\\\".format(y_train.shape))\\n print('Model Loss: ' + model.loss)\\n\\n # For compatability with other models;\\n model.score = model.evaluate\\n\\n return model #self.model=model\",\n \"def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias):\\r\\n super(ResnetBlock, self).__init__()\\r\\n self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout, use_bias)\",\n \"def build(self, input_layer, trainable=True):\\n\\n with tf.variable_scope(self.name):\\n # Get the number of input channels\\n input_shape = input_layer.get_shape()\\n num_input_channels = input_shape[-1].value\\n\\n # Create the weights and convolutional layer\\n weight_shape = [self.kernel_shape[0], self.kernel_shape[1], num_input_channels, self.num_kernels]\\n\\n# if self.name:\\n# self.weights = weight_variable(weight_shape, 'W_'+self.name)\\n# else:\\n# self.weights = weight_variable(weight_shape)\\n\\n self.weights = weight_variable(weight_shape, 'weights', trainable)\\n self.bias = bias_variable([self.num_kernels], 'bias', trainable)\\n\\n self.layer = tf.nn.conv2d(input_layer, self.weights, strides=[1, self.stride, self.stride, 1], padding=self.padding) + self.bias\\n\\n if self.activation_function:\\n self.layer = self.activation_function(self.layer)\\n\\n return self.layer, self.weights, self.bias\",\n \"def __init__(self, \\n n_neurons = \\\"micro\\\", # else: \\\"brunel\\\" or arrays\\n C_ab = \\\"micro\\\", # else: \\\"brunel\\\" or arrays\\n area = net.area, # simulation size\\n neuron_model = net.neuron_model, # \\\"iaf_psc_delta\\\" or \\\"iaf_psc_exp\\\"\\n connection_rule = net.connection_rule, # \\\"fixed_total_number\\\" or \\\"fixed_indegree\\\"\\n j02 = net.j02, \\n weight_rel_sd = net.weight_rel_sd, \\n delay_rel_sd = net.delay_rel_sd, \\n g = net.g, \\n rate_ext = net.rate_ext):\\n ###################################################\\n ### \\tNetwork parameters\\t\\t### \\n ###################################################\\n\\n # area of network in mm^2; scales numbers of neurons\\n # use 1 for the full-size network (77,169 neurons)\\n self.area = area\\n \\n self.layers = net.layers #np.array([\\\"L23\\\", \\\"L4\\\", \\\"L5\\\", \\\"L6\\\"])\\n self.types = net.types #np.array([\\\"e\\\", \\\"i\\\"]) \\n self.populations = np.array([layer + typus for layer in self.layers for typus in self.types])\\n self.n_populations = len(self.populations)\\n self.n_layers = len(self.layers)\\n self.n_types = len(self.types)\\n \\n # Neuron numbers\\n if n_neurons == \\\"micro\\\":\\n self.n_neurons = np.int_(net.full_scale_n_neurons * self.area)\\n elif n_neurons == \\\"brunel\\\":\\n # Provide an array of equal number of neurons in each exc./inh. population\\n gamma = 0.25\\n inh_factor = 1. / (gamma + 1.)\\n exc_factor = 1. - inh_factor \\n n_total_micro = np.sum(net.full_scale_n_neurons * self.area)\\n N_exc = n_total_micro/self.n_populations * exc_factor\\n N_inh = n_total_micro/self.n_populations * inh_factor\\n self.n_neurons = np.tile([N_exc, N_inh], self.n_layers).astype(int)\\n else:\\n if type(n_neurons) == np.ndarray:\\n if n_neurons.shape == (self.n_populations, ):\\n self.n_neurons = np.int_(n_neurons)\\n else:\\n raise Exception(\\\"'n_neurons' has wrong shape. \\\"+\\n \\\"Expects (%i,)\\\"%self.n_populations)\\n else: \\n raise Exception(\\\"'n_neurons' expects either numpy.ndarray or string \\\"+\\n \\\"in {'micro', 'brunel'}\\\")\\n self.n_total = np.sum(self.n_neurons)\\n\\n \\n # Synapse numbers\\n # Connection probabilities: conn_probs[post, pre] = conn_probs[target, source]\\n conn_probs = net.conn_probs\\n # Scale synapse numbers of the C_ab\\n if net.scale_C_linearly:\\n n_outer_full = np.outer(net.full_scale_n_neurons, net.full_scale_n_neurons)\\n C_full_scale = np.log(1. - conn_probs) / np.log(1. - 1. / n_outer_full)\\n C_scaled = np.int_(C_full_scale * self.area)\\n else:\\n n_outer = np.outer(self.n_neurons, self.n_neurons)\\n C_scaled = np.int_(np.log(1. - conn_probs) / np.log(1. - 1. / n_outer))\\n\\n self.connection_rule = connection_rule\\n if self.connection_rule == \\\"fixed_total_number\\\":\\n C_ab_micro = C_scaled # total number, do not divide! \\n elif self.connection_rule == \\\"fixed_indegree\\\":\\n C_ab_micro = (C_scaled.T / (net.full_scale_n_neurons * self.area)).T\\n else:\\n raise Exception(\\\"Unexpected connection type. Use 'fixed_total_number' for microcircuit \\\" + \\n \\\"model or 'fixed_indegree' for Brunel's model!\\\")\\n\\n if C_ab == \\\"micro\\\":\\n self.C_ab = C_ab_micro # shall not be integer at this point!\\n elif C_ab == \\\"brunel\\\":\\n C_e = np.mean(C_ab_micro) # mean for microcircuit (= 501 in full scale)\\n C_i = gamma * C_e\\n self.C_ab = np.tile([C_e, C_i], (self.n_populations, self.n_layers)).astype(int) \\n else:\\n if type(C_ab) == np.ndarray:\\n if C_ab.shape == (self.n_populations, self.n_populations):\\n self.C_ab = np.int_(C_ab)\\n else:\\n raise Exception(\\\"'C_ab' has wrong shape. \\\"+\\n \\\"Expects (%i, %i)\\\"%(self.n_populations, self.n_populations))\\n else: \\n raise Exception(\\\"'C_ab' expects either numpy.ndarray or string \\\"+\\n \\\"in {'micro', 'brunel'}\\\")\\n\\n\\n ###################################################\\n ### Single-neuron parameters\\t\\t### \\n ###################################################\\n self.neuron_model = neuron_model\\n self.Vm0_mean = net.Vm0_mean # mean of initial membrane potential (mV)\\n self.Vm0_std = net.Vm0_std # std of initial membrane potential (mV)\\n self.model_params = net.model_params\\n if not self.neuron_model==\\\"iaf_psc_delta\\\":\\n self.model_params[\\\"tau_syn_ex\\\"] = net.tau_syn_ex # excitatory synaptic time constant (ms)\\n self.model_params[\\\"tau_syn_in\\\"] = net.tau_syn_in # inhibitory synaptic time constant (ms)\\n self.tau_syn_ex = net.tau_syn_ex # ms\\n self.tau_syn_in = net.tau_syn_in # ms\\n self.tau_syn = np.tile([self.tau_syn_ex, self.tau_syn_in], (self.n_populations, self.n_layers))\\n # Rescaling for model calculations: these values are not used in the simulation!\\n self.tau_m = self.model_params[\\\"tau_m\\\"] # ms\\n self.t_ref = self.model_params[\\\"t_ref\\\"] # ms\\n self.E_L = self.model_params[\\\"E_L\\\"] # mV\\n self.V_r = self.model_params[\\\"V_reset\\\"] - self.E_L # mV\\n self.theta = self.model_params[\\\"V_th\\\"] - self.E_L # mV\\n self.C_m = self.model_params[\\\"C_m\\\"] # pF\\n\\n\\n ######################################################\\n # Synaptic weights. Depend on neuron_model! ##\\n ######################################################\\n self.g = g\\n self.j02 = j02\\n\\n g_all = np.tile([1., -self.g], (self.n_populations, self.n_layers))\\n L23e_index = np.where(self.populations == \\\"L23e\\\")[0][0]\\n L4e_index = np.where(self.populations == \\\"L4e\\\")[0][0]\\n g_all[L23e_index, L4e_index] *= self.j02\\n \\n self.J = net.PSP_e # mv; mean PSP, used as reference PSP\\n self.J_ab = self.J * g_all\\n self.weight_rel_sd = weight_rel_sd # Standard deviation of weight relative to mean weight\\n # Transformation from peak PSP to PSC\\n delta_tau = self.tau_syn - self.tau_m\\n ratio_tau = self.tau_m / self.tau_syn\\n PSC_over_PSP = self.C_m * delta_tau / (self.tau_m * self.tau_syn * \\\\\\n (ratio_tau**(self.tau_m / delta_tau) - ratio_tau**(self.tau_syn / delta_tau))) \\n # Actual weights have to be adapted: from peak PSP to PSC (and back...)\\n if self.neuron_model==\\\"iaf_psc_exp\\\": # PSCs calculated from PSP amplitudes\\n self.weights = self.J_ab * PSC_over_PSP # neuron populations\\n elif self.neuron_model==\\\"iaf_psc_delta\\\":\\n self.weights = self.J_ab * PSC_over_PSP * (self.tau_syn_ex) / self.C_m\\n # This might be an overkill / doing things twice...\\n elif self.neuron_model==\\\"iaf_psc_alpha\\\": # PSCs calculated from PSP amplitudes\\n self.weights = self.J_ab * np.exp(1) / (self.tau_syn_ex) / self.C_m\\n else:\\n raise Exception(\\\"Neuron model should be iaf_psc_ - {delta, exp, alpha}!\\\")\\n\\n\\n ###################################################\\n ### Delays and dicts ### \\n ###################################################\\n # mean dendritic delays for excitatory and inhibitory transmission (ms)\\n self.delay_e = net.delay_e # ms, excitatory synapses\\n self.delay_i = net.delay_i # ms, inhibitory synapses\\n\\n self.delays = np.tile([self.delay_e, self.delay_i], (self.n_populations, self.n_layers)) # adapt...\\n self.delay_rel_sd = delay_rel_sd \\n \\n # Synapse dictionaries\\n # default connection dictionary\\n self.conn_dict = {\\\"rule\\\": connection_rule}\\n # weight distribution of connections between populations\\n self.weight_dict_exc = net.weight_dict_exc\\n self.weight_dict_inh = net.weight_dict_inh\\n # delay distribution of connections between populations\\n self.delay_dict = net.delay_dict\\n # default synapse dictionary\\n self.syn_dict = net.syn_dict\\n \\n \\n ###################################################\\n ### External stimuli ## \\n ###################################################\\n # rate of background Poisson input at each external input synapse (spikes/s) \\n self.rate_ext = rate_ext # Hz \\n self.J_ext = net.PSP_ext # external synaptic weight\\n self.delay_ext = self.delay_e # ms; mean delay of external input\\n self.dc_amplitude = net.dc_amplitude # constant bg amplitude\\n self.C_aext = net.C_aext # in-degrees for background input\\n # Adapt weights\\n if self.neuron_model==\\\"iaf_psc_exp\\\": # PSCs calculated from PSP amplitudes\\n self.weight_ext = self.J_ext * PSC_over_PSP[0, 0] \\n elif self.neuron_model==\\\"iaf_psc_delta\\\":\\n self.weight_ext = self.J_ext * PSC_over_PSP[0, 0] * self.tau_syn_ex / self.C_m\\n elif self.neuron_model==\\\"iaf_psc_alpha\\\": # PSCs calculated from PSP amplitudes\\n self.weight_ext = self.J_ext * np.exp(1) / self.tau_syn_ex / self.C_m\\n\\n # optional additional thalamic input (Poisson)\\n self.n_th = net.n_th # size of thalamic population\\n self.th_start = net.th_start # onset of thalamic input (ms)\\n self.th_duration = net.th_duration # duration of thalamic input (ms)\\n self.th_rate = net.th_rate # rate of thalamic neurons (spikes/s)\\n self.J_th = net.PSP_th # mean EPSP amplitude (mV) for thalamic input\\n # Adapt weights\\n if self.neuron_model==\\\"iaf_psc_exp\\\": # PSCs calculated from PSP amplitudes\\n self.weight_th = self.J_th * PSC_over_PSP[0, 0] \\n elif self.neuron_model==\\\"iaf_psc_delta\\\":\\n self.weight_th = self.J_th * PSC_over_PSP[0, 0] * self.tau_syn_ex / self.C_m\\n elif self.neuron_model==\\\"iaf_psc_alpha\\\": # PSCs calculated from PSP amplitudes\\n self.weight_th = self.J_th * np.exp(1) / self.tau_syn_ex / self.C_m\\n\\n \\n # connection probabilities for thalamic input\\n conn_probs_th = net.conn_probs_th\\n if net.scale_C_linearly:\\n if not self.n_th == 0:\\n C_th_full_scale = np.log(1. - conn_probs_th) / \\\\\\n np.log(1. - 1. / (self.n_th * net.full_scale_n_neurons))\\n self.C_th_scaled = np.int_(C_th_full_scale * self.area)\\n else:\\n if not self.n_th == 0:\\n self.C_th_scaled = np.int_(np.log(1. - conn_probs_th) / \\\\\\n np.log(1. - 1. / (self.n_th * self.n_neurons_micro)))\\n if self.n_th == 0:\\n self.C_th_scaled = None\\n \\n # mean delay of thalamic input (ms)\\n self.delay_th = net.delay_th\\n # standard deviation relative to mean delay of thalamic input\\n self.delay_th_rel_sd = net.delay_th_rel_sd\\n\\n\\n ######################################################\\n # Predefine matrices for mean field ##\\n ######################################################\\n if self.neuron_model==\\\"iaf_psc_delta\\\":\\n self.J_mu = self.weights\\n self.J_sd = self.weights\\n self.J_mu_ext = self.weight_ext \\n self.J_sd_ext = self.weight_ext\\n elif self.neuron_model==\\\"iaf_psc_exp\\\":\\n self.J_mu = self.weights * self.tau_syn / self.C_m\\n self.J_sd = self.weights * np.sqrt(self.tau_syn / 2.) / self.C_m\\n self.J_mu_ext = self.weight_ext * self.tau_syn_ex / self.C_m\\n self.J_sd_ext = self.weight_ext * np.sqrt(self.tau_syn_ex / 2.) / self.C_m\\n elif self.neuron_model==\\\"iaf_psc_alpha\\\":\\n self.J_mu = self.weights * self.tau_syn**2 / self.C_m\\n self.J_sd = self.weights * self.tau_syn**(3./2.) / (self.C_m * 2.)\\n self.J_mu_ext = self.weight_ext * self.tau_syn_ex**2 / self.C_m\\n self.J_sd_ext = self.weight_ext * self.tau_syn_ex**(3./2.) / (self.C_m * 2.)\\n self.mat_mu = self.tau_m * 1e-3 * self.J_mu * self.C_ab\\n self.mu_ext = self.tau_m * 1e-3 * self.J_mu_ext * self.C_aext * self.rate_ext\\n self.mat_var = self.tau_m * 1e-3 * (1 + self.weight_rel_sd ** 2) * self.J_sd**2 * self.C_ab\\n self.var_ext = self.tau_m * 1e-3 * (1 + self.weight_rel_sd ** 2) * self.J_sd_ext**2 * self.C_aext * self.rate_ext\",\n \"def __conv_block(self, x, stage, branch, nb_filter, dropout_rate=None, weight_decay=1e-4):\\n\\t\\teps = 1.1e-5\\n\\t\\tconv_name_base = \\\"conv\\\" + str(stage) + \\\"_\\\" + str(branch)\\n\\t\\trelu_name_base = \\\"relu\\\" + str(stage) + \\\"_\\\" + str(branch)\\n\\n\\t\\t# 1x1 Convolution (Bottleneck layer)\\n\\t\\tinter_channel = nb_filter * 4 \\n\\t\\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=conv_name_base+\\\"_x1_bn\\\")(x)\\n\\t\\tx = Scale(axis=self.concat_axis, name=conv_name_base+\\\"_x1_scale\\\")(x)\\n\\t\\tx = Activation(\\\"relu\\\", name=relu_name_base+\\\"_x1\\\")(x)\\n\\t\\tx = Conv2D(inter_channel, (1, 1), name=conv_name_base+\\\"_x1\\\", use_bias=False)(x)\\n\\n\\t\\tif dropout_rate:\\n\\t\\t\\tx = Dropout(dropout_rate)(x)\\n\\n\\t\\t# 3x3 Convolution\\n\\t\\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=conv_name_base+\\\"_x2_bn\\\")(x)\\n\\t\\tx = Scale(axis=self.concat_axis, name=conv_name_base+\\\"_x2_scale\\\")(x)\\n\\t\\tx = Activation(\\\"relu\\\", name=relu_name_base+\\\"_x2\\\")(x)\\n\\t\\tx = ZeroPadding2D((1, 1), name=conv_name_base+\\\"_x2_zeropadding\\\")(x)\\n\\t\\tx = Conv2D(nb_filter, (3, 3), name=conv_name_base+\\\"_x2\\\", use_bias=False)(x)\\n\\n\\t\\tif dropout_rate:\\n\\t\\t\\tx = Dropout(dropout_rate)(x)\\n\\n\\t\\treturn x\",\n \"def main():\\n args = get_arguments()\\n \\n # Create queue coordinator.\\n coord = tf.train.Coordinator()\\n \\n # Load reader.\\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader_MultiClass_Loss(\\n args.data_dir,\\n args.data_list,\\n None, # No defined input size.\\n RANDOM_SEED,\\n False, # No random scale.\\n False, # No random mirror.\\n coord)\\n image, l2_catg, binary_catg, hinge_catg = reader.image, reader.l2_catg, reader.binary_catg, reader.hinge_catg\\n image_batch = tf.expand_dims(image, dim=0)\\n binary_catg_batch = tf.expand_dims(binary_catg, dim=0)\\n\\n # Create network.\\n net = DeepLabResNetModel({'data': image_batch}, is_training=False)\\n\\n # Which variables to load.\\n restore_var = tf.global_variables()\\n \\n # Predictions.\\n raw_output = net.layers['fc1_voc12']\\n\\n # Do the global average pooling\\n raw_output_bcgd_rmvd = raw_output[:,:,:,1:]\\n g_avg_pool = tf.reduce_mean(tf.reduce_mean(raw_output_bcgd_rmvd, axis=1, keep_dims=True),\\\\\\n axis=2, keep_dims=True) # Avg across the width and height dimension -> [Bx21]\\n g_avg_pool_sqzd = tf.squeeze(g_avg_pool, axis=[1, 2])\\n pred = tf.nn.softmax(g_avg_pool_sqzd)\\n\\n # Get the class activation map\\n raw_output_up = tf.image.resize_bilinear(raw_output_bcgd_rmvd, tf.shape(image_batch)[1:3,])\\n raw_output_up = raw_output_up - tf.reduce_min(tf.reduce_min(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True) + EPSILON\\n raw_output_up = raw_output_up / tf.reduce_max(tf.reduce_max(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True)\\n cam_m_1 = tf.argmax(raw_output_up, dimension=3) + 1\\n raw_output_catgs_rmvd = raw_output_up * tf.expand_dims(tf.expand_dims(binary_catg_batch, 1), 2)\\n cam_m_2 = tf.argmax(raw_output_catgs_rmvd, dimension=3) + 1\\n cam = tf.cast(tf.equal(cam_m_1, cam_m_2), tf.int64) * cam_m_1\\n\\n cam_batch = tf.expand_dims(cam, dim=3)\\n\\n # Set up tf session and initialize variables. \\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n init = tf.global_variables_initializer()\\n \\n sess.run(init)\\n sess.run(tf.local_variables_initializer())\\n \\n # Load weights.\\n loader = tf.train.Saver(var_list=restore_var)\\n if args.restore_from is not None:\\n load(loader, sess, args.restore_from)\\n \\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\\n \\n # Iterate over training steps.\\n for step in range(args.num_steps):\\n preds, images, cams, bin_catg = sess.run([pred, image_batch, cam_batch, binary_catg])\\n \\\"\\\"\\\"\\n print(bin_catg)\\n print(np.unique(np.unique(cams)))\\n \\\"\\\"\\\"\\n img = inv_preprocess(images)\\n attMap = decode_labels(cams)\\n output_dir = './output_maps_binary_without_norm/'\\n img_name = output_dir + str(step) + '.jpg'\\n map_name = output_dir + str(step) + '.png'\\n misc.imsave(img_name, img[0,:,:,:])\\n misc.imsave(map_name, attMap[0,:,:,:])\\n coord.request_stop()\\n coord.join(threads)\",\n \"def __call__(self, inputs, state, scope=None, *args, **kwargs):\\r\\n # Bypass RNNCell's variable capturing semantics for LayerRNNCell.\\r\\n # Instead, it is up to subclasses to provide a proper build\\r\\n # method. See the class docstring for more details.\\r\\n return base_layer.Layer.__call__(self, inputs, state, scope=scope,\\r\\n *args, **kwargs)\",\n \"def __init__(self):\\r\\n super(HarrisNet, self).__init__()\\r\\n\\r\\n image_gradients_layer = ImageGradientsLayer()\\r\\n\\r\\n\\r\\n # (1) ImageGradientsLayer: Compute image gradients Ix Iy. Can be\\r\\n # approximated by convolving with sobel filter.\\r\\n # (2) EigenvalueApproxLayer: Compute S_xx, S_yy and S_xy, the output is\\r\\n # a tensor of size num_image x 3 x width x height\\r\\n # (3) CornerResponseLayer: Compute R matrix, the output is a tensor of\\r\\n # size num_image x 1 x width x height\\r\\n # (4) NMSLayer: Perform non-maximum suppression, the output is a tensor\\r\\n # of size num_image x 1 x width x height\\r\\n\\r\\n layer_1 = ChannelProductLayer()\\r\\n layer_2 = SecondMomentMatrixLayer()\\r\\n layer_3 = CornerResponseLayer()\\r\\n layer_4 = NMSLayer()\\r\\n\\r\\n self.net = nn.Sequential(\\r\\n image_gradients_layer,\\r\\n layer_1,\\r\\n layer_2,\\r\\n layer_3,\\r\\n layer_4\\r\\n )\",\n \"def test_CNN_hyperparameters_nrlayers(self):\\n hyperparams = modelgen.generate_CNN_hyperparameter_set(\\n min_fc_nodes=123, max_fc_nodes=123)\\n assert hyperparams.get('fc_hidden_nodes') == 123\",\n \"def inference(image, keep_prob):\\r\\n '''\\r\\n print(\\\"setting up vgg initialized conv layers ...\\\")\\r\\n model_data = utils.get_model_data(FLAGS.model_dir, MODEL_URL)\\r\\n\\r\\n mean = model_data['normalization'][0][0][0]\\r\\n mean_pixel = np.mean(mean, axis=(0, 1))\\r\\n\\r\\n weights = np.squeeze(model_data['layers'])\\r\\n print(\\\"weights.shape\\\",weights.shape)\\r\\n\\r\\n processed_image = utils.process_image(image, mean_pixel)'''\\r\\n\\r\\n with tf.variable_scope(\\\"inference\\\"):\\r\\n pooling_net,conv_final_layer = inference_op(image)\\r\\n #conv_final_layer = image_net[\\\"conv5_3\\\"]\\r\\n\\r\\n pool5 = utils.max_pool_2x2(conv_final_layer)\\r\\n\\r\\n W6 = utils.weight_variable([7, 7, 512, 4096], name=\\\"W6\\\")\\r\\n b6 = utils.bias_variable([4096], name=\\\"b6\\\")\\r\\n conv6 = utils.conv2d_basic(pool5, W6, b6)\\r\\n relu6 = tf.nn.relu(conv6, name=\\\"relu6\\\")\\r\\n if FLAGS.debug:\\r\\n utils.add_activation_summary(relu6)\\r\\n relu_dropout6 = tf.nn.dropout(relu6, keep_prob=keep_prob)\\r\\n\\r\\n W7 = utils.weight_variable([1, 1, 4096, 4096], name=\\\"W7\\\")\\r\\n b7 = utils.bias_variable([4096], name=\\\"b7\\\")\\r\\n conv7 = utils.conv2d_basic(relu_dropout6, W7, b7)\\r\\n relu7 = tf.nn.relu(conv7, name=\\\"relu7\\\")\\r\\n if FLAGS.debug:\\r\\n utils.add_activation_summary(relu7)\\r\\n relu_dropout7 = tf.nn.dropout(relu7, keep_prob=keep_prob)\\r\\n\\r\\n W8 = utils.weight_variable([1, 1, 4096, NUM_OF_CLASSESS], name=\\\"W8\\\")\\r\\n b8 = utils.bias_variable([NUM_OF_CLASSESS], name=\\\"b8\\\")\\r\\n conv8 = utils.conv2d_basic(relu_dropout7, W8, b8)\\r\\n # annotation_pred1 = tf.argmax(conv8, dimension=3, name=\\\"prediction1\\\")\\r\\n\\r\\n # now to upscale to actual image size\\r\\n deconv_shape1 = pooling_net[\\\"pool4\\\"].get_shape()\\r\\n W_t1 = utils.weight_variable([4, 4, deconv_shape1[3].value, NUM_OF_CLASSESS], name=\\\"W_t1\\\")\\r\\n b_t1 = utils.bias_variable([deconv_shape1[3].value], name=\\\"b_t1\\\")\\r\\n # 对第8层的结果进行反卷积(上采样),通道数也由NUM_OF_CLASSESS变为第4层的通道数\\r\\n conv_t1 = utils.conv2d_transpose_strided(conv8, W_t1, b_t1, output_shape=tf.shape(pooling_net[\\\"pool4\\\"]))\\r\\n fuse_1 = tf.add(conv_t1, pooling_net[\\\"pool4\\\"], name=\\\"fuse_1\\\")\\r\\n\\r\\n deconv_shape2 = pooling_net[\\\"pool3\\\"].get_shape()\\r\\n W_t2 = utils.weight_variable([4, 4, deconv_shape2[3].value, deconv_shape1[3].value], name=\\\"W_t2\\\")\\r\\n b_t2 = utils.bias_variable([deconv_shape2[3].value], name=\\\"b_t2\\\")\\r\\n conv_t2 = utils.conv2d_transpose_strided(fuse_1, W_t2, b_t2, output_shape=tf.shape(pooling_net[\\\"pool3\\\"]))\\r\\n fuse_2 = tf.add(conv_t2, pooling_net[\\\"pool3\\\"], name=\\\"fuse_2\\\")\\r\\n\\r\\n shape = tf.shape(image)\\r\\n deconv_shape3 = tf.stack([shape[0], shape[1], shape[2], NUM_OF_CLASSESS])\\r\\n W_t3 = utils.weight_variable([16, 16, NUM_OF_CLASSESS, deconv_shape2[3].value], name=\\\"W_t3\\\")\\r\\n b_t3 = utils.bias_variable([NUM_OF_CLASSESS], name=\\\"b_t3\\\")\\r\\n conv_t3 = utils.conv2d_transpose_strided(fuse_2, W_t3, b_t3, output_shape=deconv_shape3, stride=8)\\r\\n\\r\\n annotation_pred = tf.argmax(conv_t3, dimension=3, name=\\\"prediction\\\")\\r\\n print(\\\"annotation_pred.shape\\\",annotation_pred.shape)\\r\\n print(\\\"conv_t3\\\",conv_t3)\\r\\n print(\\\"tf.expand_dims(annotation_pred, dim=3)\\\",tf.expand_dims(annotation_pred, dim=3))\\r\\n return tf.expand_dims(annotation_pred, dim=3), conv_t3\",\n \"def __init__(self, network_path='.', logging=True,\\n input_image_size=None, n_input_channels=None,\\n n_output_classes=None,\\n conv1_size=5, conv1_n_chan=32, conv1_n_pool=2,\\n conv2_size=5, conv2_n_chan=64, conv2_n_pool=2,\\n fc1_n_chan=1024, fc1_dropout=0.5, alpha=4e-4 ):\\n self.logging = logging\\n\\n # If network path does not yet exists\\n self.network_path = network_path\\n if not os.path.isdir(self.network_path):\\n # Make network directory\\n os.mkdir(self.network_path)\\n now = datetime.datetime.now()\\n self.log(\\\"\\\\n\\\\n++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n self.log( \\\"Creation of new network: \\\")\\n self.log( \\\" {}\\\".format(self.network_path) )\\n self.log( \\\" @ {}\\\".format(now.strftime(\\\"%Y-%m-%d %H:%M\\\")) )\\n self.log( \\\"++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n self.log(\\\"\\\\nNetwork did not exist ... \\\")\\n self.log(\\\"Created new network with supplied (or default) architecture\\\")\\n\\n # Set up new network\\n self.y_res = input_image_size[0]\\n self.x_res = input_image_size[1]\\n self.n_input_channels = n_input_channels\\n self.n_output_classes = n_output_classes\\n self.conv1_size = conv1_size\\n self.conv1_n_chan = conv1_n_chan\\n self.conv1_n_pool = conv1_n_pool\\n self.conv2_size = conv2_size\\n self.conv2_n_chan = conv2_n_chan\\n self.conv2_n_pool = conv2_n_pool\\n self.fc1_y_size = int( np.ceil( np.ceil(\\n self.y_res/self.conv1_n_pool ) / self.conv2_n_pool ) )\\n self.fc1_x_size = int( np.ceil( np.ceil(\\n self.x_res/self.conv1_n_pool ) / self.conv2_n_pool ) )\\n self.fc1_n_chan = fc1_n_chan\\n self.fc1_dropout = fc1_dropout\\n self.alpha = alpha\\n self.n_samples_trained = 0\\n self.n_class_samples_trained = self.n_output_classes*[0]\\n self.n_samples_list = []\\n self.n_class_samples_list = [[] for _ in range(self.n_output_classes)]\\n self.accuracy_list = [[] for _ in range(self.n_output_classes)]\\n self.precision_list = [[] for _ in range(self.n_output_classes)]\\n self.recall_list = [[] for _ in range(self.n_output_classes)]\\n self.F1_list = [[] for _ in range(self.n_output_classes)]\\n\\n # Save network architecture\\n self.save_network_architecture( network_path=self.network_path )\\n\\n else:\\n now = datetime.datetime.now()\\n self.log(\\\"\\\\n\\\\n++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n self.log( \\\"Re-initialization of existing network: \\\")\\n self.log( \\\" {}\\\".format(self.network_path) )\\n self.log( \\\" @ {}\\\".format(now.strftime(\\\"%Y-%m-%d %H:%M\\\")) )\\n self.log( \\\"++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n self.log( \\\" \\\")\\n\\n # Load network architecture from directory\\n net_architecture = self.load_network_architecture(self.network_path)\\n\\n # Set up network variables from loaded architecture\\n self.y_res = net_architecture['y_res']\\n self.x_res = net_architecture['x_res']\\n self.n_input_channels = net_architecture['n_input_channels']\\n self.n_output_classes = net_architecture['n_output_classes']\\n self.conv1_size = net_architecture['conv1_size']\\n self.conv1_n_chan = net_architecture['conv1_n_chan']\\n self.conv1_n_pool = net_architecture['conv1_n_pool']\\n self.conv2_size = net_architecture['conv2_size']\\n self.conv2_n_chan = net_architecture['conv2_n_chan']\\n self.conv2_n_pool = net_architecture['conv2_n_pool']\\n self.fc1_y_size = int( np.ceil( np.ceil(\\n self.y_res/self.conv1_n_pool ) / self.conv2_n_pool ) )\\n self.fc1_x_size = int( np.ceil( np.ceil(\\n self.x_res/self.conv1_n_pool ) / self.conv2_n_pool ) )\\n self.fc1_n_chan = net_architecture['fc1_n_chan']\\n self.fc1_dropout = net_architecture['fc1_dropout']\\n self.alpha = net_architecture['alpha']\\n self.n_samples_trained = net_architecture['n_samples_trained']\\n self.n_class_samples_trained = net_architecture['n_class_samples_trained']\\n self.n_samples_list = net_architecture['n_samples_list']\\n self.n_class_samples_list = net_architecture['n_class_samples_list']\\n self.accuracy_list = net_architecture['accuracy_list']\\n self.precision_list = net_architecture['precision_list']\\n self.recall_list = net_architecture['recall_list']\\n self.F1_list = net_architecture['F1_list']\\n\\n # Update values of alpha and dropout if supplied\\n if self.alpha != alpha:\\n self.alpha = alpha\\n self.log(\\\"Updated learning rate 'alpha' to {}\\\".format(self.alpha))\\n if self.fc1_dropout != fc1_dropout:\\n self.fc1_dropout = fc1_dropout\\n self.log(\\\"Updated dropout fraction to {}\\\".format(self.fc1_dropout))\\n\\n # Clear previous graphs\\n tf.reset_default_graph()\\n\\n #########################################################\\n # Input and target variable placeholders\\n # x = [ m_samples x [channel_1_data, channel_2_data, etc.] ]\\n self.x = tf.placeholder( tf.float32, shape = [None,\\n self.n_input_channels * self.y_res * self.x_res] )\\n self.y_trgt = tf.placeholder( tf.float32, \\\\\\n shape = [None, self.n_output_classes] )\\n\\n # Convert input image to tensor with channel as last dimension\\n # x_image = [-1 x im-height x im-width x n-input-channels]\\n x_image_temp = tf.reshape(self.x, [-1,\\n self.n_input_channels,self.y_res,self.x_res])\\n x_image = tf.transpose(x_image_temp, [0,2,3,1])\\n\\n #########################################################\\n # Set up convolutional layer 1\\n # W = [im-height x im-width x n-input-channels x n-output-channels])\\n self.conv1_shape = [self.conv1_size, self.conv1_size,\\n self.n_input_channels, self.conv1_n_chan]\\n self.W_conv1 = tf.Variable( tf.truncated_normal(\\n shape=self.conv1_shape, stddev=0.1))\\n self.b_conv1 = tf.Variable( tf.constant(0.1,\\n shape=[self.conv1_n_chan] ))\\n\\n # Convolve x_image with the weight tensor\\n self.conv1_lin = tf.nn.conv2d( x_image, self.W_conv1,\\n strides=[1, 1, 1, 1], padding='SAME' )\\n\\n # Add bias and apply transfer function\\n self.conv1_relu = tf.nn.relu( self.conv1_lin + self.b_conv1 )\\n\\n # Max pooling\\n self.conv1_kernel = [1, self.conv1_n_pool, self.conv1_n_pool, 1]\\n self.conv1_pool = tf.nn.max_pool( self.conv1_relu,\\n ksize=self.conv1_kernel, strides=self.conv1_kernel, padding='SAME')\\n\\n #########################################################\\n # Convolutional layer 2\\n self.conv2_shape = [self.conv2_size, self.conv2_size,\\n self.conv1_n_chan, self.conv2_n_chan]\\n self.W_conv2 = tf.Variable( tf.truncated_normal(\\n shape=self.conv2_shape, stddev=0.1 ) )\\n self.b_conv2 = tf.Variable( tf.constant(0.1,\\n shape=[self.conv2_n_chan] ))\\n\\n # Convolve x_image with the weight tensor\\n self.conv2_lin = tf.nn.conv2d( self.conv1_pool, self.W_conv2,\\n strides=[1, 1, 1, 1], padding='SAME' )\\n\\n # Add bias and apply transfer function\\n self.conv2_relu = tf.nn.relu( self.conv2_lin + self.b_conv2 )\\n\\n # Max pooling\\n self.conv2_kernel = [1, self.conv2_n_pool, self.conv2_n_pool, 1]\\n self.conv2_pool = tf.nn.max_pool( self.conv2_relu,\\n ksize=self.conv2_kernel, strides=self.conv2_kernel, padding='SAME')\\n\\n\\n #########################################################\\n # Densely Connected Layer\\n # Weights and bias\\n self.fc1_shape = [self.fc1_y_size * self.fc1_x_size * self.conv2_n_chan,\\n self.fc1_n_chan]\\n self.W_fc1 = tf.Variable( tf.truncated_normal(\\n shape=self.fc1_shape, stddev=0.1 ) )\\n self.b_fc1 = tf.Variable( tf.constant(0.1, shape=[self.fc1_n_chan] ))\\n\\n # Flatten output from conv2\\n self.conv2_pool_flat = tf.reshape(\\n self.conv2_pool, [-1, self.fc1_shape[0]] )\\n\\n # Calculate network step\\n self.fc1_relu = tf.nn.relu( tf.matmul( self.conv2_pool_flat,\\n self.W_fc1) + self.b_fc1 )\\n\\n # Set up dropout option for fc1\\n self.fc1_keep_prob = tf.placeholder(tf.float32)\\n self.fc1_relu_drop = tf.nn.dropout(self.fc1_relu, self.fc1_keep_prob)\\n\\n #########################################################\\n # Readout layer\\n # Weights and bias\\n self.fc_out_shape = [self.fc1_n_chan, self.n_output_classes]\\n self.W_fc_out = tf.Variable( tf.truncated_normal(\\n shape=self.fc_out_shape, stddev=0.1 ) )\\n self.b_fc_out = tf.Variable( tf.constant(0.1,\\n shape=[self.fc_out_shape[1]] ))\\n\\n # Calculate network step\\n self.fc_out_lin = tf.matmul( self.fc1_relu_drop,\\n self.W_fc_out ) + self.b_fc_out\\n\\n #########################################################\\n # Define cost function and optimizer algorithm\\n self.cross_entropy = tf.reduce_mean(\\n tf.nn.softmax_cross_entropy_with_logits(\\n logits=self.fc_out_lin, labels=self.y_trgt ) )\\n self.train_step = tf.train.AdamOptimizer(self.alpha).minimize(\\n self.cross_entropy )\\n\\n #########################################################\\n # Define how to test trained model\\n self.network_prediction = tf.cast( tf.argmax(\\n self.fc_out_lin, 1 ), tf.float32 )\\n self.is_correct_prediction = tf.equal( tf.argmax( self.fc_out_lin, 1 ),\\n tf.argmax( self.y_trgt, 1 ) )\\n self.accuracy = tf.reduce_mean( tf.cast(\\n self.is_correct_prediction, tf.float32 ) )\\n\\n #########################################################\\n # Create save operation\\n self.saver = tf.train.Saver()\",\n \"def my_hom_cnn_model_fn(features, labels, mode):\\n # Input Layer\\n # Reshape X to 4-D tensor: [batch_size, width, height, channels]\\n\\n #HOM Images are 128x128, and have two channels\\n input_layer = tf.reshape(features[\\\"x\\\"], [-1, pSize, pSize, 2])\\n\\n # Convolutional Layer #1\\n # Computes 32 features using a 3x3 filter with ReLU activation.\\n # Padding is added to preserve width and height.\\n conv1 = tf.layers.conv2d(inputs=input_layer, filters=64,kernel_size=[3, 3], padding=\\\"same\\\",activation=tf.nn.relu) #None\\n conv2 = tf.layers.conv2d(inputs=conv1, filters=64, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n pool1 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)\\n\\n conv3 = tf.layers.conv2d(inputs=pool1, filters=64, kernel_size=[3, 3], padding=\\\"same\\\",activation=tf.nn.relu)\\n conv4 = tf.layers.conv2d(inputs=conv3,filters=64,kernel_size=[3, 3],padding=\\\"same\\\",activation=tf.nn.relu)\\n pool2 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=2)\\n\\n conv5 = tf.layers.conv2d(inputs=pool2, filters=128, kernel_size=[3, 3], padding=\\\"same\\\",activation=tf.nn.relu)\\n conv6 = tf.layers.conv2d(inputs=conv5,filters=128,kernel_size=[3, 3],padding=\\\"same\\\",activation=tf.nn.relu)\\n pool3 = tf.layers.max_pooling2d(inputs=conv6, pool_size=[2, 2], strides=2)\\n\\n conv7 = tf.layers.conv2d(inputs=pool3, filters=128, kernel_size=[3, 3], padding=\\\"same\\\",activation=tf.nn.relu)\\n conv8 = tf.layers.conv2d(inputs=conv7,filters=128,kernel_size=[3, 3],padding=\\\"same\\\",activation=tf.nn.relu)\\n\\n # Dense Layer\\n # Densely connected layer with 1024 neurons\\n conv2_flat = tf.reshape(conv8, [-1, 128 * 128 * 2])\\n # Add dropout operation; 0.5 probability that element will be kept\\n dropout = tf.layers.dropout(inputs=conv2_flat, rate=0.5, training=mode == tf.estimator.ModeKeys.TRAIN)\\n\\n fully_connect = tf.layers.dense(inputs=dropout, units=1024, activation=None) #activation=None\\n predictions = tf.layers.dense(inputs=fully_connect, units=8, activation=None)\\n\\n #predictions\\n if mode == tf.estimator.ModeKeys.PREDICT:\\n return tf.estimator.EstimatorSpec(mode=mode, predictions = predictions)\\n \\n loss = tf.losses.mean_squared_error(labels=labels, predictions = predictions)\\n \\n #loss = tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=predictions, name=\\\"softmax_tensor\\\")\\n\\n # Configure the Training Op (for TRAIN mode)\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)\\n train_op = optimizer.minimize(loss=loss, global_step=tf.train.get_global_step())\\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)\\n\\n # Add evaluation metrics (for EVAL mode)\\n #eval_metric_ops = {\\\"accuracy\\\": tf.metrics.accuracy(labels=labels, predictions=predictions[\\\"coord\\\"])}#predictions=predictions[\\\"classes\\\"])}\\n \\n if mode == tf.estimator.ModeKeys.EVAL:\\n eval_metric_ops = {\\n \\\"mean_square_error\\\": tf.metrics.mean_squared_error(labels=labels, predictions = predictions)}#predictions=predictions[\\\"classes\\\"])}\\n\\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops, predictions = predictions)\",\n \"def QCNN_layer_gen(self):\\n pixels = self.filter_size**2\\n # filter size: 2^n only for this version!\\n if np.log2(pixels) % 1 != 0:\\n raise NotImplementedError(\\\"filter size: 2^n only available\\\")\\n cirq_qubits = cirq.GridQubit.rect(self.filter_size, self.filter_size)\\n # mapping input data to circuit\\n input_circuit = cirq.Circuit()\\n input_params = [sympy.symbols('a%d' %i) for i in range(pixels)]\\n for i, qubit in enumerate(cirq_qubits):\\n input_circuit.append(cirq.rx(np.pi*input_params[i])(qubit))\\n # apply learnable gate set to QCNN circuit\\n QCNN_circuit = cirq.Circuit()\\n step_size = [2**i for i in range(np.log2(pixels).astype(np.int32))]\\n for step in step_size:\\n for target in range(0, pixels, 2*step):\\n QCNN_circuit.append(self._QConv(step, target, cirq_qubits))\\n # merge the circuits\\n full_circuit = cirq.Circuit()\\n full_circuit.append(input_circuit)\\n full_circuit.append(QCNN_circuit)\\n self.circuit = full_circuit # save circuit to the QCNN layer obj.\\n self.params = input_params + self.learning_params\\n self.op = cirq.Z(cirq_qubits[0])\",\n \"def __init__(self, layers, input_size):\\n super(ConvNetMaker, self).__init__()\\n self.conv_layers = []\\n self.fc_layers = []\\n # h, w, d = 32, 32, 3\\n h, w, d = input_size, input_size, 3\\n previous_layer_filter_count = 3\\n previous_layer_size = h * w * d\\n num_fc_layers_remained = len([1 for l in layers if l.startswith('FC')])\\n for layer in layers:\\n if layer.startswith('Conv'):\\n filter_count = int(layer[4:])\\n self.conv_layers += [\\n nn.Conv2d(previous_layer_filter_count,\\n filter_count,\\n kernel_size=3,\\n padding=1),\\n nn.BatchNorm2d(filter_count),\\n nn.ReLU(inplace=True)\\n ]\\n\\n previous_layer_filter_count = filter_count\\n d = filter_count\\n previous_layer_size = h * w * d\\n elif layer.startswith('MaxPool'):\\n self.conv_layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\\n h, w = int(h / 2.0), int(w / 2.0)\\n previous_layer_size = h * w * d\\n elif layer.startswith('FC'):\\n num_fc_layers_remained -= 1\\n current_layer_size = int(layer[2:])\\n if num_fc_layers_remained == 0:\\n self.fc_layers += [nn.Linear(previous_layer_size,\\n current_layer_size)]\\n else:\\n self.fc_layers += [nn.Linear(previous_layer_size,\\n current_layer_size),\\n nn.ReLU(inplace=True)]\\n previous_layer_size = current_layer_size\\n\\n conv_layers = self.conv_layers\\n fc_layers = self.fc_layers\\n self.conv_layers = nn.Sequential(*conv_layers)\\n self.fc_layers = nn.Sequential(*fc_layers)\",\n \"def build_net(self, inputs):\\n with tf.variable_scope(self._scope, self._scope, [inputs]) as sc:\\n end_points_collection = sc.name + '_end_points'\\n\\n with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.batch_norm],\\n outputs_collections=end_points_collection):\\n net = slim.conv2d(inputs, 32, 3, 1, scope='conv1')\\n net = slim.conv2d(net, 32, 3, 1, scope='conv2')\\n\\n net = slim.conv2d(net, 64, 3, 1, scope='conv3')\\n net = slim.conv2d(net, 64, 3, 1, scope='conv4')\\n\\n net = slim.max_pool2d(net, 2, 2, scope='pool1')\\n\\n net = slim.conv2d(net, 128, 3, 1, scope='conv5')\\n net = slim.conv2d(net, 128, 3, 1, scope='conv6')\\n\\n net = slim.max_pool2d(net, 2, 2, scope='pool2')\\n\\n net = slim.conv2d(net, 256, 3, scope='conv7')\\n net = slim.conv2d(net, 256, 3, scope='conv8')\\n\\n net = slim.max_pool2d(net, 2, [2, 1], scope='pool3')\\n\\n net = slim.conv2d(net, 512, 3, scope='conv9')\\n net = slim.conv2d(net, 512, 3, scope='conv10')\\n\\n net = slim.max_pool2d(net, 2, [1, 1], scope='pool4')\\n\\n net = slim.conv2d(net, 512, 2, padding='VALID', scope='conv11')\\n\\n net = slim.dropout(net, keep_prob=0.5)\\n\\n self.end_points = utils.convert_collection_to_dict(end_points_collection)\\n self.net = net\",\n \"def apply_network(inputs):\\n return apply_layer(tf.sigmoid(apply_layer(inputs, 64)), 1)\",\n \"def explain(self):\\n # build the 2 versions of the model\\n model = self.build_model()\\n last_conv_model = self.build_cut_model()\\n\\n for i, label_name in enumerate(self.label_names):\\n # This is the algorithm for the last convolution layer's tensor image\\n # Get the index of the image that was classified correctly with the most confidence for the class\\n predicted_col_proba = np.array(self.predicted_labels)[0][:, i]\\n predicted_col_argsort = predicted_col_proba.argsort()[::-1]\\n predicted_col = (predicted_col_proba > 0.2).astype(int)\\n true_col = self.true_labels[:, 0]\\n\\n representative_image_index = None\\n for most_probable_arg_index in predicted_col_argsort:\\n if predicted_col[most_probable_arg_index] == true_col[most_probable_arg_index]:\\n representative_image_index = most_probable_arg_index\\n break\\n\\n # Resize the image to fit the neural network and keep the original resized image\\n original_img = io.imread('{}/{}/{}'.format(path_to_img_directory, self.ex_format, np.array(self.image_names)[representative_image_index]))\\n original_img = cv2.normalize(original_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n original_img = cv2.resize(original_img, dsize=(self.ex_input_size, self.ex_input_size), interpolation=cv2.INTER_CUBIC)\\n img = np.expand_dims(original_img, axis=0)\\n original_img = original_img[:, :, :3]\\n\\n # Get the output of the neural network for this image as a tensor\\n model.predict(np.array(img))\\n class_output = model.output[:, i]\\n last_conv_layer = model.get_layer(self.ex_last_conv_layer_name1).output\\n # if self.model_name == 'vit':\\n # last_conv_layer = tf.nn.relu(tf.reshape(last_conv_layer[:, :256, :], (-1, 16, 16, 1024)))\\n\\n # Get the output for the cut model\\n cut_img = last_conv_model.predict(np.array(img))[0]\\n if self.model_name == 'vit':\\n cut_img = np.reshape(cut_img[:256, :], (16, 16, 1024))\\n cut_img = np.mean(cut_img, axis=-1)\\n cut_img = cv2.normalize(cut_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n if self.model_name == 'vit':\\n cut_img[0, 0] = np.mean(cut_img)\\n cut_img = cv2.normalize(cut_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n cut_img = cv2.resize(cut_img, (self.ex_input_size, self.ex_input_size))\\n\\n # This is the algorithm of the Grad-CAM model\\n # Refine the output of the last convolutional layer according to the class output\\n grads = K.gradients(class_output, last_conv_layer)[0]\\n if self.model_name == 'vit':\\n last_conv_layer = tf.reshape(last_conv_layer[:, :256, :], (-1, 16, 16, 1024))\\n last_conv_layer = last_conv_layer / tf.norm(last_conv_layer)\\n\\n grads = tf.reshape(grads[:, :256, :], (-1, 16, 16, 1024))\\n grads = grads / tf.norm(grads)\\n\\n pooled_grads = K.mean(grads, axis=(0, 1, 2))\\n iterate = K.function([model.input], [pooled_grads, last_conv_layer[0]])\\n pooled_grads_value, conv_layer_output_value = iterate([img])\\n for j in range(self.ex_last_conv_layer_filter_number):\\n conv_layer_output_value[:, :, j] *= pooled_grads_value[j]\\n\\n # Create a 16x16 heatmap and scale it to the same size as the original image\\n heatmap = np.mean(conv_layer_output_value, axis=-1)\\n heatmap = np.maximum(heatmap, 0)\\n heatmap /= np.max(heatmap)\\n heatmap = cv2.resize(heatmap, (self.ex_input_size, self.ex_input_size))\\n heatmap = np.uint8(255 * heatmap)\\n heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)\\n heatmap = cv2.normalize(heatmap, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n superimposed_img = cv2.addWeighted(original_img, 0.7, heatmap, 0.4, 0)\\n\\n # save the original image\\n plt.matshow(original_img)\\n plt.axis('off')\\n plt.title(label_name, fontdict={'fontsize': 18})\\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'original', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\\n\\n # save the cut image\\n plt.matshow(cut_img, cmap=plt.get_cmap('Spectral'))\\n plt.colorbar(shrink=0.75, ticks=np.linspace(0, 1, 11).tolist())\\n plt.axis('off')\\n plt.title(label_name, fontdict={'fontsize': 18})\\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'cut', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\\n\\n # save the superimposed gradcam image\\n plt.matshow(superimposed_img, cmap=plt.get_cmap('Spectral'))\\n plt.colorbar(shrink=0.75, ticks=np.linspace(0, 1, 11).tolist())\\n plt.axis('off')\\n plt.title(label_name, fontdict={'fontsize': 18})\\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'gradcam', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\",\n \"def __init__(self, args):\\n\\n self.args = args\\n\\n \\\"\\\"\\\"class args:\\n rows=16\\n cols=640\\n baseinfo=10\\n hps = 128\\n hpdist = 33\\n \\\"\\\"\\\"\\n\\n inputs = KK.layers.Input(shape=(args.rows,args.cols,args.baseinfo))\\n x = KK.layers.Conv2D(64, kernel_size= (1, 6), strides=(1,5), activation='relu')(inputs)\\n x = KK.layers.Conv2D(64, (16, 1), activation='relu')(x)\\n bottle = KK.layers.Flatten()(x) # This is now the bottleneck\\n\\n self.model = KK.models.Model(inputs=inputs, outputs=[bottle])\\n self.model.summary()\\n\\n ################################\\n # predict hp lengths\\n predsHPLEN = []\\n for ii in range( args.hps ):\\n tmp = KK.layers.Dense(args.hpdist, activation='softmax')(bottle)\\n # print(\\\"tmp\\\",tmp.shape) # tmp (N, 33)\\n predsHPLEN.append(tmp)\\n\\n # # stack into one array yielding (128,N,33)\\n predsHPLEN2 = KK.backend.stack(predsHPLEN)\\n print(\\\"predsHPLEN2.shape\\\", predsHPLEN2.shape)\\n\\n # # permute to yield (N,128,33) to compare against truth\\n predictionsHPLEN = KK.backend.permute_dimensions(predsHPLEN2,(1,0,2))\\n print(\\\"predictionsHPLEN.shape\\\",predictionsHPLEN.shape) # predictions.shape (?, 128, 33)\\n\\n ################################\\n # predict hp base IDentity\\n predsHPID = []\\n for ii in range( args.hps ):\\n tmp = KK.layers.Dense(4, activation='softmax')(bottle)\\n # print(\\\"tmp\\\",tmp.shape) # tmp (N, 4)\\n predsHPID.append(tmp)\\n\\n # # stack into one array yielding (128,N,4)\\n predsHPID2 = KK.backend.stack(predsHPID)\\n print(\\\"predsHPID2.shape\\\", predsHPID2.shape)\\n\\n # # permute to yield (N,128,4) to compare against truth\\n predictionsHPID = KK.backend.permute_dimensions(predsHPID2,(1,0,2))\\n print(\\\"predictionsHPID.shape\\\",predictionsHPID.shape) # predictions.shape (?, 128, 4)\\n\\n ################################\\n self.model = KK.models.Model(inputs=inputs, outputs=[predictionsHPID,predictionsHPLEN])\\n\\n #self.model.summary()\\n # # ValueError: You tried to call `count_params` on stack, but the layer isn't built. You can build it manually via: `stack.build(batch_input_shape)`.\\n\\n self.model.compile(optimizer=\\\"adam\\\", loss=\\\"categorical_crossentropy\\\", metrics=[\\\"categorical_accuracy\\\",\\\"kullback_leibler_divergence\\\"])\\n\\n # # instrument tensorboard\\n # tf.summary.histogram('output', self.output)\\n # tf.summary.histogram('softmax_w', softmax_w)\\n # tf.summary.histogram('logits', self.logits)\\n # tf.summary.histogram('probs', self.probs)\\n # tf.summary.scalar('train_loss', self.cost)\",\n \"def get_unet0(nClasses, input_height, input_width, nchannel=3):\\n\\n inputs = Input(shape=(input_height, input_width, nchannel))\\n # temp = BatchNormalization()(inputs)\\n\\n conv1 = Conv2D(32, (3, 3), padding='same', kernel_initializer='he_uniform')(inputs)\\n conv1 = BatchNormalization()(conv1)\\n conv1 = Activation(\\\"relu\\\")(conv1)\\n conv1 = Conv2D(32, (3, 3), padding='same', kernel_initializer='he_uniform')(conv1)\\n conv1 = BatchNormalization()(conv1)\\n conv1 = Activation(\\\"relu\\\")(conv1)\\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\\n\\n conv2 = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_uniform')(pool1)\\n conv2 = BatchNormalization()(conv2)\\n conv2 = Activation(\\\"relu\\\")(conv2)\\n conv2 = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_uniform')(conv2)\\n conv2 = BatchNormalization()(conv2)\\n conv2 = Activation(\\\"relu\\\")(conv2)\\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\\n\\n conv3 = Conv2D(128, (3, 3), padding='same', kernel_initializer='he_uniform')(pool2)\\n conv3 = BatchNormalization()(conv3)\\n conv3 = Activation(\\\"relu\\\")(conv3)\\n conv3 = Conv2D(128, (3, 3), padding='same', kernel_initializer='he_uniform')(conv3)\\n conv3 = BatchNormalization()(conv3)\\n conv3 = Activation(\\\"relu\\\")(conv3)\\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\\n\\n conv4 = Conv2D(256, (3, 3), padding='same', kernel_initializer='he_uniform')(pool3)\\n conv4 = BatchNormalization()(conv4)\\n conv4 = Activation(\\\"relu\\\")(conv4)\\n conv4 = Conv2D(256, (3, 3), padding='same', kernel_initializer='he_uniform')(conv4)\\n conv4 = BatchNormalization()(conv4)\\n conv4 = Activation(\\\"relu\\\")(conv4)\\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\\n\\n conv5 = Conv2D(512, (3, 3), padding='same', kernel_initializer='he_uniform')(pool4)\\n conv5 = BatchNormalization()(conv5)\\n conv5 = Activation(\\\"relu\\\")(conv5)\\n conv5 = Conv2D(512, (3, 3), padding='same', kernel_initializer='he_uniform')(conv5)\\n conv5 = BatchNormalization()(conv5)\\n conv5 = Activation(\\\"relu\\\")(conv5)\\n\\n up6 = concatenate([UpSampling2D(size=(2, 2))(conv5), conv4], axis=3)\\n conv6 = Conv2D(256, (3, 3), padding='same', kernel_initializer='he_uniform')(up6)\\n conv6 = BatchNormalization()(conv6)\\n conv6 = Activation(\\\"relu\\\")(conv6)\\n conv6 = Conv2D(256, (3, 3), padding='same', kernel_initializer='he_uniform')(conv6)\\n conv6 = BatchNormalization()(conv6)\\n conv6 = Activation(\\\"relu\\\")(conv6)\\n\\n up7 = concatenate([UpSampling2D(size=(2, 2))(conv6), conv3], axis=3)\\n conv7 = Conv2D(128, (3, 3), padding='same', kernel_initializer='he_uniform')(up7)\\n conv7 = BatchNormalization()(conv7)\\n conv7 = Activation(\\\"relu\\\")(conv7)\\n conv7 = Conv2D(128, (3, 3), padding='same', kernel_initializer='he_uniform')(conv7)\\n conv7 = BatchNormalization()(conv7)\\n conv7 = Activation(\\\"relu\\\")(conv7)\\n\\n up8 = concatenate([UpSampling2D(size=(2, 2))(conv7), conv2], axis=3)\\n conv8 = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_uniform')(up8)\\n conv8 = BatchNormalization()(conv8)\\n conv8 = Activation(\\\"relu\\\")(conv8)\\n conv8 = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_uniform')(conv8)\\n conv8 = BatchNormalization()(conv8)\\n conv8 = Activation(\\\"relu\\\")(conv8)\\n\\n up9 = concatenate([UpSampling2D(size=(2, 2))(conv8), conv1], axis=3)\\n conv9 = Conv2D(32, (3, 3), padding='same', kernel_initializer='he_uniform')(up9)\\n conv9 = BatchNormalization()(conv9)\\n conv9 = Activation(\\\"relu\\\")(conv9)\\n conv9 = Conv2D(32, (3, 3), padding='same', kernel_initializer='he_uniform')(conv9)\\n conv9 = BatchNormalization()(conv9)\\n conv9 = Activation(\\\"relu\\\")(conv9)\\n\\n conv10 = Conv2D(nClasses, (1, 1), activation='relu', padding='same')(conv9)\\n conv10 = Reshape((input_height * input_width, nClasses))(conv10)\\n # conv10 = Permute((2, 1))(conv10)\\n\\n conv11 = Activation('softmax')(conv10)\\n\\n\\n model = Model(inputs=inputs, outputs=conv11)\\n\\n return model\",\n \"def __init__(self, C, num_classes):\\n super(AuxiliaryHeadImageNet, self).__init__()\\n self.features = nn.Sequential(nn.ReLU(inplace=True), nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False), nn.Conv2d(C, 128, 1, bias=False), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 768, 2, bias=False), nn.ReLU(inplace=True))\\n self.classifier = nn.Linear(768, num_classes)\",\n \"def build_resnet101(self):\\n use_batch_norm = self.use_batch_norm\\n\\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\\n is_train = tf.placeholder(tf.bool)\\n\\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\\n conv1_feats = nonlinear(conv1_feats, 'relu')\\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\\n\\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\\n \\n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \\n temp = res3a_feats\\n for i in range(1, 4):\\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\\n res3b3_feats = temp\\n \\n res4a_feats = self.basic_block(res3b3_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\\n temp = res4a_feats\\n for i in range(1, 23):\\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\\n res4b22_feats = temp\\n\\n res5a_feats = self.basic_block(res4b22_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\\n\\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\\n self.conv_feats = res5c_feats_flat\\n self.conv_feat_shape = [49, 2048]\\n self.num_ctx = 49 \\n self.dim_ctx = 2048\\n\\n self.imgs = imgs\\n self.is_train = is_train\",\n \"def build_cnn(input_var=None):\\n\\n # input layer\\n network = lasagne.layers.InputLayer(\\n shape=(\\n None,\\n 1,\\n 128,\\n 129\\n ),\\n input_var=input_var\\n )\\n\\n # conv\\n network = lasagne.layers.Conv2DLayer(\\n lasagne.layers.batch_norm(network), # Batch norm on incoming\\n num_filters=32, # Number of convolution filters to use\\n filter_size=(5, 5),\\n stride=(1, 1), # Stride fo (1,1)\\n pad='same', # Keep output size same as input\\n nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n W=lasagne.init.GlorotUniform() # W initialization\\n )\\n\\n # conv\\n #network = lasagne.layers.Conv2DLayer(\\n #lasagne.layers.batch_norm(network), # Batch norm on incoming\\n #num_filters=32, # Number of convolution filters to use\\n #filter_size=(5, 5),\\n #stride=(1, 1), # Stride fo (1,1)\\n #pad='same', # Keep output size same as input\\n #nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n #W=lasagne.init.GlorotUniform() # W initialization\\n #)\\n\\n # pool (2x2 max pool)\\n network = lasagne.layers.MaxPool2DLayer(\\n network, pool_size=(2, 2)\\n )\\n\\n # conv\\n network = lasagne.layers.Conv2DLayer(\\n lasagne.layers.batch_norm(network), # Batch norm on incoming\\n num_filters=32, # Number of convolution filters to use\\n filter_size=(3, 3),\\n stride=(1, 1), # Stride fo (1,1)\\n pad='same', # Keep output size same as input\\n nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n W=lasagne.init.GlorotUniform() # W initialization\\n )\\n\\n # conv\\n #network = lasagne.layers.Conv2DLayer(\\n #lasagne.layers.batch_norm(network), # Batch norm on incoming\\n #num_filters=32, # Number of convolution filters to use\\n #filter_size=(3, 3),\\n #stride=(1, 1), # Stride fo (1,1)\\n #pad='same', # Keep output size same as input\\n #nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n #W=lasagne.init.GlorotUniform() # W initialization\\n #)\\n\\n # pool (2x2 max pool)\\n network = lasagne.layers.MaxPool2DLayer(\\n network, pool_size=(2, 2)\\n )\\n\\n # Fully-connected layer of 256 units with 50% dropout on its inputs\\n network = lasagne.layers.DenseLayer(\\n lasagne.layers.dropout(network, p=.5),\\n num_units=256,\\n nonlinearity=lasagne.nonlinearities.leaky_rectify, #rectify, # ReLU\\n W=lasagne.init.HeUniform() # W initialization\\n )\\n\\n # Finally add a 1-unit softmax output layer\\n network = lasagne.layers.DenseLayer(\\n network,\\n num_units=1,\\n nonlinearity=lasagne.nonlinearities.sigmoid\\n )\\n\\n return network\",\n \"def __call__(self, x_input):\\n reuse = True if self.built else None\\n net = load_kaffe_model(self.model_name, x_input, reuse=reuse)\\n self.built = True\\n self.net = net\\n #output = end_points['alexnet_v2/fc8']\\n # Strip off the extra reshape op at the output\\n output = self.net.get_output()\\n probs = output.op.inputs[0]\\n return probs\",\n \"def __init__(self, n_input, n_output, hidden_layer_size, reg):\\n self.reg = reg\\n self.fulllayer1 = FullyConnectedLayer(n_input, hidden_layer_size)\\n self.reglayer1 = ReLULayer()\\n self.fulllayer2 = FullyConnectedLayer(hidden_layer_size, n_output)\",\n \"def __init__(self, kernel_size, filters, stage, block):\\n super().__init__(name='identity' + str(stage) + block)\\n filters1, filters2, filters3 = filters\\n if K.image_data_format() == 'channels_last':\\n bn_axis = 3\\n else:\\n bn_axis = 1\\n\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n\\n self.conv1 = layers.Conv2D(\\n filters1, (1, 1),\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2a')\\n self.bn1 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')\\n self.act1 = layers.Activation('relu')\\n\\n self.conv2 = layers.Conv2D(\\n filters2,\\n kernel_size,\\n padding='same',\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2b')\\n self.bn2 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')\\n self.act2 = layers.Activation('relu')\\n\\n self.conv3 = layers.Conv2D(\\n filters3, (1, 1),\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2c')\\n self.bn3 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')\\n\\n self.add = layers.Add()\\n self.act = layers.Activation('relu')\",\n \"def Compute_EdgeBoxesAndCNN_features(demonet='res152',nms_thresh = 0.7,database='IconArt_v1',\\n augmentation=False,L2 =False,\\n saved='all',verbose=True,filesave='tfrecords',k_regions=300,\\n testMode=False,plotProposedBoxes=False):\\n\\n path_data = '/media/gonthier/HDD/output_exp/ClassifPaintings/'\\n path_imgs = path_data + 'EdgeBoxesIllust/'+database +'/'\\n \\n if plotProposedBoxes:\\n print(\\\"We will only plot the regions of the EdgeBoxes with k_regions = \\\",k_regions,path_imgs)\\n pathlib.Path(path_imgs).mkdir(parents=True, exist_ok=True) \\n \\n item_name,path_to_img,default_path_imdb,classes,ext,num_classes,str_val,df_label,\\\\\\n path_data,Not_on_NicolasPC = get_database(database)\\n \\n if augmentation:\\n raise NotImplementedError\\n N = 50\\n else: \\n N=1\\n if L2:\\n raise NotImplementedError\\n extL2 = '_L2'\\n else:\\n extL2 = ''\\n if saved=='all':\\n savedstr = '_all'\\n elif saved=='fc7':\\n savedstr = ''\\n elif saved=='pool5':\\n savedstr = '_pool5'\\n \\n tf.reset_default_graph() # Needed to use different nets one after the other\\n if verbose: print('=== EdgeBoxes net',demonet,'database',database,' ===')\\n \\n if demonet=='res152':\\n weights_path = '/media/gonthier/HDD/models/resnet152_weights_tf.h5'\\n model = resnet_152_keras.resnet152_model_2048output(weights_path)\\n num_features = 2048\\n else:\\n raise(NotImplementedError)\\n tfconfig = tf.ConfigProto(allow_soft_placement=True)\\n tfconfig.gpu_options.allow_growth=True\\n # init session\\n# sess = tf.Session(config=tfconfig)\\n \\n features_resnet_dict= {}\\n \\n sets = ['train','val','trainval','test']\\n \\n if filesave == 'pkl':\\n name_pkl_all_features = path_data+'EdgeBoxes_'+ demonet +'_'+database+'_N'+str(N)+extL2+'_TLforMIL_nms_'+str(nms_thresh)+savedstr+'.pkl'\\n pkl = open(name_pkl_all_features, 'wb')\\n elif filesave =='tfrecords':\\n if k_regions==300:\\n k_per_bag_str = ''\\n else:\\n k_per_bag_str = '_k'+str(k_regions)\\n dict_writers = {}\\n for set_str in sets:\\n name_pkl_all_features = path_data\\n if testMode: name_pkl_all_features+= 'TestMode_'\\n name_pkl_all_features += 'EdgeBoxes_'+ demonet +'_'+database+'_N'+str(N)+extL2+'_TLforMIL_nms_'+str(nms_thresh)+savedstr+k_per_bag_str+'_'+set_str+'.tfrecords'\\n dict_writers[set_str] = tf.python_io.TFRecordWriter(name_pkl_all_features)\\n \\n model_edgeboxes = 'model/model.yml'\\n print('Need of pip install opencv-contrib-python')\\n edge_detection = cv2.ximgproc.createStructuredEdgeDetection(model_edgeboxes)\\n \\n number_of_regions = []\\n Itera = 1000\\n if testMode:\\n Itera = 1\\n for i,name_img in enumerate(df_label[item_name]):\\n if testMode and i>1:\\n break\\n if filesave=='pkl':\\n if not(k_regions==300):\\n raise(NotImplementedError)\\n if i%Itera==0:\\n if verbose : print(i,name_img)\\n if not(i==0):\\n pickle.dump(features_resnet_dict,pkl) # Save the data\\n features_resnet_dict= {}\\n if database in ['IconArt_v1','VOC2007','clipart','comic','Paintings',\\\\\\n 'watercolor','WikiTenLabels','MiniTrain_WikiTenLabels',\\\\\\n 'WikiLabels1000training','CASPApaintings']:\\n complet_name = path_to_img + name_img + '.jpg'\\n elif database=='PeopleArt':\\n complet_name = path_to_img + name_img\\n name_sans_ext = os.path.splitext(name_img)[0]\\n elif(database=='Wikidata_Paintings') or (database=='Wikidata_Paintings_miniset_verif'):\\n name_sans_ext = os.path.splitext(name_img)[0]\\n complet_name = path_to_img +name_sans_ext + '.jpg'\\n\\n if plotProposedBoxes:\\n plot_im_withBoxes(complet_name,edge_detection,k_regions,path_imgs)\\n list_im, rois = get_crops(complet_name,edge_detection,k_regions,demonet,augmentation=False)\\n number_of_regions += [len(list_im)]\\n fc7 = model.predict(list_im)\\n # Need a BGR and between 0 and 255 minus the mean per color \\n \\n roi_scores = np.ones((len(list_im,)))\\n# cls_score, cls_prob, bbox_pred, rois,roi_scores, fc7,pool5 = TL_im_detect(sess, net, im) # Arguments: im (ndarray): a color image in BGR order\\n #features_resnet_dict[name_img] = fc7[np.concatenate(([0],np.random.randint(1,len(fc7),29))),:]\\n if saved=='fc7':\\n features_resnet_dict[name_img] = fc7\\n# elif saved=='pool5':\\n# features_resnet_dict[name_img] = pool5\\n elif saved=='all':\\n features_resnet_dict[name_img] = rois,roi_scores,fc7\\n \\n elif filesave=='tfrecords':\\n if i%Itera==0:\\n if verbose : print(i,name_img)\\n if database in ['IconArt_v1','VOC2007','clipart','comic','Paintings','watercolor'\\\\\\n ,'CASPApaintings','WikiTenLabels','MiniTrain_WikiTenLabels','WikiLabels1000training']:\\n complet_name = path_to_img + name_img + '.jpg'\\n name_sans_ext = name_img\\n elif database=='PeopleArt':\\n complet_name = path_to_img + name_img\\n name_sans_ext = os.path.splitext(name_img)[0]\\n elif(database=='Wikidata_Paintings') or (database=='Wikidata_Paintings_miniset_verif'):\\n name_sans_ext = os.path.splitext(name_img)[0]\\n complet_name = path_to_img +name_sans_ext + '.jpg'\\n\\n im = cv2.imread(complet_name)\\n \\n height = im.shape[0]\\n width = im.shape[1]\\n\\n if plotProposedBoxes:\\n plot_im_withBoxes(complet_name,edge_detection,k_regions,path_imgs)\\n list_im, rois = get_crops(complet_name,edge_detection,k_regions,demonet,augmentation=False)\\n # Boxes are x, y, w, h\\n number_of_regions += [len(list_im)]\\n fc7 = model.predict(list_im)\\n roi_scores = np.ones((len(list_im,)))\\n# cls_score, cls_prob, bbox_pred, rois,roi_scores, fc7,pool5 = TL_im_detect(sess, net, im) # Arguments: im (ndarray): a color image in BGR order\\n \\n if testMode:\\n print('Image :',height,width)\\n print('Normally ROI (x1,x2,y1,y2) :')\\n print(rois)\\n \\n if(len(fc7) >= k_regions):\\n rois = rois[0:k_regions,:]\\n roi_scores =roi_scores[0:k_regions,]\\n fc7 = fc7[0:k_regions,:]\\n else:\\n number_repeat = k_regions // len(fc7) +1\\n f_repeat = np.repeat(fc7,number_repeat,axis=0)\\n roi_scores_repeat = np.repeat(roi_scores,number_repeat,axis=0)\\n rois_repeat = np.repeat(rois,number_repeat,axis=0)\\n rois = rois_repeat[0:k_regions,:]\\n roi_scores =roi_scores_repeat[0:k_regions,]\\n fc7 = f_repeat[0:k_regions,:]\\n num_regions = fc7.shape[0]\\n num_features = fc7.shape[1]\\n dim1_rois = rois.shape[1]\\n classes_vectors = np.zeros((num_classes,1),dtype=np.float32)\\n \\n if database=='Paintings':\\n for j in range(num_classes):\\n if(classes[j] in df_label['classe'][i]):\\n classes_vectors[j] = 1\\n if database in ['VOC2007','clipart','watercolor','comic','PeopleArt','CASPApaintings']:\\n for j in range(num_classes):\\n value = int((int(df_label[classes[j]][i])+1.)/2.)\\n # En fait ce qui se passe la c'est que tu rescale a la sauvage \\n # entre 0 et 1 un truc qui peut etre entre 0 et 1 mais aussi entre -1 et 1\\n # C'est chelou\\n classes_vectors[j] = value\\n if database in ['WikiTenLabels','MiniTrain_WikiTenLabels','WikiLabels1000training','IconArt_v1']:\\n for j in range(num_classes):\\n value = int(df_label[classes[j]][i])\\n classes_vectors[j] = value\\n \\n #features_resnet_dict[name_img] = fc7[np.concatenate(([0],np.random.randint(1,len(fc7),29))),:]\\n if saved=='fc7':\\n print('It is possible that you need to replace _bytes_feature by _floats_feature in this function')\\n print('!!!!!!!!!!!!!!!!!!!!!')\\n raise(NotImplementedError)\\n # TODO : modifier cela !\\n features=tf.train.Features(feature={\\n 'height': _int64_feature(height),\\n 'width': _int64_feature(width),\\n 'num_regions': _int64_feature(num_regions),\\n 'num_features': _int64_feature(num_features),\\n 'fc7': _bytes_feature(tf.compat.as_bytes(fc7.tostring())),\\n 'label' : _bytes_feature(tf.compat.as_bytes(classes_vectors.tostring())),\\n 'name_img' : _bytes_feature(str.encode(name_sans_ext))})\\n elif saved=='pool5':\\n raise(NotImplementedError)\\n elif saved=='all':\\n feature={\\n 'height': _int64_feature(height),\\n 'width': _int64_feature(width),\\n 'num_regions': _int64_feature(num_regions),\\n 'num_features': _int64_feature(num_features),\\n 'dim1_rois': _int64_feature(dim1_rois),\\n 'rois': _floats_feature(rois),\\n 'roi_scores': _floats_feature(roi_scores),\\n 'fc7': _floats_feature(fc7),\\n 'label' : _floats_feature(classes_vectors),\\n 'name_img' : _bytes_feature(str.encode(name_sans_ext))}\\n features=tf.train.Features(feature=feature)\\n example = tf.train.Example(features=features) \\n# print(len(feature['rois']))\\n if database=='VOC2007' or database=='PeopleArt':\\n if (df_label.loc[df_label[item_name]==name_img]['set']=='train').any():\\n dict_writers['train'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='val').any():\\n dict_writers['val'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='test').any():\\n dict_writers['test'].write(example.SerializeToString())\\n if (database=='Wikidata_Paintings_miniset') or database=='Paintings':\\n if (df_label.loc[df_label[item_name]==name_img]['set']=='train').any():\\n dict_writers['train'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='validation').any():\\n dict_writers['val'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='test').any():\\n dict_writers['test'].write(example.SerializeToString())\\n if database in ['IconArt_v1','watercolor','clipart','comic','WikiTenLabels',\\\\\\n 'MiniTrain_WikiTenLabels','WikiLabels1000training','CASPApaintings']:\\n if (df_label.loc[df_label[item_name]==name_img]['set']=='train').any():\\n dict_writers['train'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='test').any():\\n dict_writers['test'].write(example.SerializeToString())\\n \\n if filesave=='pkl':\\n pickle.dump(features_resnet_dict,pkl)\\n pkl.close()\\n elif filesave=='tfrecords':\\n for set_str in sets:\\n dict_writers[set_str].close()\\n \\n print('Mean number of regions per image :',np.mean(number_of_regions),'with k max = ',k_regions)\\n \\n tf.reset_default_graph()\\n \\n if testMode:\\n sets = ['train','test','trainval','val']\\n dim_rois = 4\\n for set_str in sets:\\n name_pkl_all_features = path_data\\n if testMode: name_pkl_all_features+= 'TestMode_'\\n name_pkl_all_features += 'EdgeBoxes_'+ demonet +'_'+database+'_N'+str(N)+extL2+'_TLforMIL_nms_'+str(nms_thresh)+savedstr+k_per_bag_str+'_'+set_str+'.tfrecords'\\n print(name_pkl_all_features)\\n if set_str=='train':\\n train_dataset = tf.data.TFRecordDataset(name_pkl_all_features)\\n sess = tf.Session()\\n train_dataset = train_dataset.map(lambda r: parser_w_rois_all_class(r, \\\\\\n num_classes=num_classes,with_rois_scores=True,num_features=num_features,\\n num_rois=k_regions,dim_rois=dim_rois))\\n mini_batch_size = 1\\n dataset_batch = train_dataset.batch(mini_batch_size)\\n dataset_batch.cache()\\n iterator = dataset_batch.make_one_shot_iterator()\\n next_element = iterator.get_next()\\n print(next_element)\\n nx = sess.run(next_element)\\n print(nx)\\n name_img = nx[-1][0].decode('utf8')\\n if database in ['IconArt_v1','VOC2007','clipart','comic','Paintings',\\\\\\n 'watercolor','WikiTenLabels','MiniTrain_WikiTenLabels',\\\\\\n 'WikiLabels1000training','CASPApaintings']:\\n complet_name = path_to_img + name_img + '.jpg'\\n name_sans_ext = name_img\\n elif database=='PeopleArt':\\n complet_name = path_to_img + name_img\\n name_sans_ext = os.path.splitext(name_img)[0]\\n elif(database=='Wikidata_Paintings') or (database=='Wikidata_Paintings_miniset_verif'):\\n name_sans_ext = os.path.splitext(name_img)[0]\\n complet_name = path_to_img +name_sans_ext + '.jpg'\\n \\n im = cv2.imread(complet_name)\\n \\n blobs, im_scales = get_blobs(im)\\n dd = nx[1]/ im_scales[0] \\n score = nx[2]\\n roi = np.hstack((dd[0],score[0].reshape((-1,1))))\\n \\n \\n class_name = ['']\\n vis_detections_list(im, class_name, [roi])\\n \\n os.remove(name_pkl_all_features)\",\n \"def __init__(self, input_dim=(3, 32, 32), hidden_dims_CNN = ((32, 5, 1, 1), (2, 2, 2)),\\n hidden_dims_FC = ((1024), (0.5)), num_classes=10, weight_scale=1e-3, \\n reg=0.0, dtype=np.float32):\\n self.params = {}\\n self.fix_params = {}\\n self.reg = reg\\n self.dtype = dtype\\n \\n C_input, H_input, W_input = input_dim\\n pre_C = C_input \\n pre_H = H_input\\n pre_W = W_input\\n \\n num_CNN = len(hidden_dims_CNN)\\n num_FC = len(hidden_dims_FC)\\n\\n for i in range(0, num_CNN):\\n W_name = \\\"W\\\" + str(i)\\n b_name = \\\"b\\\" + str(i)\\n conv_param_name = \\\"conv_param\\\" + str(i)\\n gamma_name = \\\"gamma\\\" + str(i)\\n beta_name = \\\"beta\\\" + str(i)\\n bn_param_name = \\\"bn_param\\\" + str(i)\\n pool_param_name = \\\"pool_param\\\" + str(i)\\n\\n if num_CNN == 1:\\n num_filters, filter_size, stride, pad = hidden_dims_CNN[0] # (F, filter_size, stride, pad)\\n pool_stride, pool_height, pool_width = hidden_dims_CNN[1] # (pooling_stride, pooling_size)\\n else:\\n num_filters, filter_size, stride, pad = hidden_dims_CNN[i][0] # (F, filter_size, stride, pad)\\n pool_stride, pool_height, pool_width = hidden_dims_CNN[i][1] # (pooling_stride, pooling_size)\\n \\n if weight_scale == -1:\\n self.params[W_name] = np.random.randn(num_filters, pre_C, filter_size, filter_size) / np.sqrt(filter_size * filter_size * pre_C)\\n else: \\n self.params[W_name] = np.random.randn(num_filters, pre_C, filter_size, filter_size) * weight_scale\\n self.params[b_name] = np.zeros(num_filters)\\n self.fix_params[conv_param_name] = {'stride': stride, 'pad': pad}\\n \\n self.params[gamma_name] = np.random.randn(num_filters)\\n self.params[beta_name] = np.random.randn(num_filters)\\n self.fix_params[bn_param_name] = {'mode': 'train'}\\n\\n self.fix_params[pool_param_name] = {'pool_height': pool_height, 'pool_width': pool_width, 'stride': pool_stride}\\n \\n pre_H, pre_W = cnn_out_shape(pre_H, pre_W, filter_size, filter_size, stride, pad)\\n pre_C = num_filters \\n pre_H, pre_W = pool_out_shape(pre_H, pre_W, pool_height, pool_width, pool_stride)\\n\\n pre_fc_dim = pre_H * pre_W * pre_C\\n\\n for i in range(0, num_FC):\\n W_name = \\\"W\\\" + str(i + num_CNN)\\n b_name = \\\"b\\\" + str(i + num_CNN)\\n gamma_name = \\\"gamma\\\" + str(i + num_CNN)\\n beta_name = \\\"beta\\\" + str(i + num_CNN)\\n bn_param_name = \\\"bn_param\\\" + str(i + num_CNN)\\n drop_name = \\\"drop_ratio\\\" + str(i + num_CNN)\\n \\n if num_FC == 1 :\\n fc_num = hidden_dims_FC[0]\\n drop_ratio = hidden_dims_FC[1]\\n else:\\n fc_num = hidden_dims_FC[i][0]\\n drop_ratio = hidden_dims_FC[i][1]\\n\\n if weight_scale == -1:\\n self.params[W_name] = np.random.randn(pre_fc_dim, fc_num) / np.sqrt(pre_fc_dim)\\n else:\\n self.params[W_name] = np.random.randn(pre_fc_dim, fc_num) * weight_scale\\n self.params[b_name] = np.zeros(fc_num)\\n\\n self.params[gamma_name] = np.random.randn(fc_num)\\n self.params[beta_name] = np.random.randn(fc_num)\\n self.fix_params[bn_param_name] = {'mode': 'train'}\\n\\n self.fix_params[drop_name] = {'mode': 'train', 'p': drop_ratio}\\n\\n pre_fc_dim = fc_num\\n\\n total_layer = num_CNN + num_FC\\n W_name = \\\"W\\\" + str(total_layer)\\n b_name = \\\"b\\\" + str(total_layer)\\n if weight_scale == -1:\\n self.params[W_name] = np.random.randn(pre_fc_dim, num_classes) / np.sqrt(pre_fc_dim)\\n else:\\n self.params[W_name] = np.random.randn(pre_fc_dim, num_classes) * weight_scale\\n self.params[b_name] = np.zeros(num_classes)\\n\\n\\n self.num_CNN = num_CNN\\n self.num_FC = num_FC\\n self.total_layer = num_CNN + num_FC\\n\\n for k, v in self.params.iteritems():\\n self.params[k] = v.astype(dtype)\",\n \"def net(self):\\n model = self.get('forward','model')\\n weights = self.get('forward','weights')\\n return caffe.Net(model, weights, caffe.TEST)\",\n \"def __init__(self, h_units, weight_decay, dropout_rate):\\n \\n # inherit class constructor attributes from tf.keras.layers.Layer\\n super(fc_block, self).__init__()\\n \\n # add dense layer attribute with L2 Regulariser\\n self.dense = tf.keras.layers.Dense(h_units, use_bias = False, kernel_regularizer = \\n tf.keras.regularizers.l2(l = weight_decay))\\n \\n # add batch norm layer attribute\\n self.batch_norm = tf.keras.layers.BatchNormalization()\",\n \"def arch(self, nn) -> 'final node of the tensor flow graph (y_conv)':\\n\\n print(self)\\n\\n # first conv. layer \\n # 5x5 filter, 1 input channel, 32 output channels\\n W_conv1 = nn.weight_variable([5, 5, 1, 32])\\n b_conv1 = nn.bias_variable([32])\\n stride1 = 1\\n h_conv1 = tf.nn.relu(nn.conv2d(nn.x_image, W_conv1, stride1) + b_conv1)\\n \\n # first pooling layer (2x2) \\n h_pool1 = nn.max_pool_2x2(h_conv1)\\n\\n # second conv. layer \\n # 5x5 filter, 32 input channel, 64 output channels\\n W_conv2 = nn.weight_variable([5, 5, 32, 64])\\n b_conv2 = nn.bias_variable([64])\\n stride2 = 1\\n h_conv2 = tf.nn.relu(nn.conv2d(h_pool1, W_conv2, stride2) + b_conv2)\\n\\n # second pooling layer (2x2) \\n h_pool2 = nn.max_pool_2x2(h_conv2)\\n\\n # reshape (flatten) output\\n h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])\\n\\n # first fully connected layer\\n W_fc1 = nn.weight_variable([7 * 7 * 64, 1024])\\n b_fc1 = nn.bias_variable([1024])\\n h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)\\n\\n # dropout\\n h_fc1_drop = tf.nn.dropout(h_fc1, nn.keep_prob)\\n\\n # second (final) fully connected layer (softmax)\\n W_fc2 = nn.weight_variable([1024, 10])\\n b_fc2 = nn.bias_variable([10])\\n y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)\\n\\n return y_conv\",\n \"def __init__(self, settings):\\n super(CaffeNet, self).__init__(settings)\\n\\n self._range_scale = 1.0 # not needed; image already in [0,255]\\n\\n \\n #ULF[todo]: explain, make this a setting\\n self._net_channel_swap = (2,1,0)\\n #self._net_channel_swap = None\\n if self._net_channel_swap:\\n self._net_channel_swap_inv = tuple([self._net_channel_swap.index(ii) for ii in range(len(self._net_channel_swap))])\\n else:\\n self._net_channel_swap_inv = None\\n\\n\\n # (1) import caffe library\\n #\\n sys.path.insert(0, os.path.join(settings.caffevis_caffe_root, 'python'))\\n import caffe\\n print 'debug[caffe]: CaffeNet.__init__: using Caffe in', caffe.__file__\\n\\n # Check if the imported caffe provides all required functions\\n self._check_caffe_version(caffe)\\n \\n # Set the mode to CPU or GPU.\\n # Note: in the latest Caffe versions, there is one Caffe object\\n # *per thread*, so the mode must be set per thread!\\n # Here we set the mode for the main thread; it is also separately\\n # set in CaffeProcThread.\\n if settings.caffevis_mode_gpu:\\n caffe.set_mode_gpu()\\n print 'debug[caffe]: CaffeNet.__init__: CaffeVisApp mode (in main thread): GPU'\\n else:\\n caffe.set_mode_cpu()\\n print 'debug[caffe]: CaffeNet.__init__: CaffeVisApp mode (in main thread): CPU'\\n print 'debug[caffe]: CaffeNet.__init__: Loading the classifier (', settings.caffevis_deploy_prototxt, settings.caffevis_network_weights, ') ...'\\n\\n\\n # (2) load the caffe model\\n # \\n # ULF[hack]: make Caffe silent - there should be a better\\n # (i.e. official) way to do so. We only want to suppress\\n # the info (like network topology) while still seeing warnings\\n # and errors!\\n suppress_output = (hasattr(self.settings, 'caffe_init_silent')\\n and self.settings.caffe_init_silent)\\n\\n if suppress_output:\\n # open 2 file descriptors\\n null_fds = [os.open(os.devnull, os.O_RDWR) for x in xrange(2)]\\n # save the current file descriptors to a tuple\\n original_fds = os.dup(1), os.dup(2)\\n # put /dev/null fds on stdout (1) and stderr (2)\\n os.dup2(null_fds[0], 1)\\n os.dup2(null_fds[1], 2)\\n\\n self.net = caffe.Classifier(\\n settings.caffevis_deploy_prototxt,\\n settings.caffevis_network_weights,\\n mean = None, # Set to None for now, assign later # self._data_mean,\\n channel_swap = self._net_channel_swap,\\n raw_scale = self._range_scale,\\n )\\n \\n if suppress_output:\\n # restore file original descriptors for stdout (1) and stderr (2)\\n os.dup2(original_fds[0], 1)\\n os.dup2(original_fds[1], 2)\\n # close the temporary file descriptors\\n os.close(null_fds[0])\\n os.close(null_fds[1])\\n print 'debug[caffe]: CaffeNet.__init__: ... loading completed.'\\n\\n self._init_data_mean()\\n self._check_force_backward_true()\",\n \"def __init__(self, num_input_channels, k_way, final_layer_size):\\n super(MamlCNN, self).__init__()\\n self.conv1 = conv_block(num_input_channels, 64)\\n self.conv2 = conv_block(64, 64)\\n self.conv3 = conv_block(64, 64)\\n self.conv4 = conv_block(64, 64)\\n self.conv5 = conv_block(64, 64)\\n self.conv6 = conv_block(64, 64)\\n\\n self.logits = nn.Linear(final_layer_size, k_way)\",\n \"def _get_resnet_fc_layer(self):\\n\\t\\tlayer_iterator = ww.WeightWatcher().make_layer_iterator(self.model)\\n\\t\\tfc_layer= None\\n\\t\\tfor ww_layer in layer_iterator:\\n\\t\\t\\tprint(ww_layer.name)\\n\\t\\t\\tif ww_layer.name=='fc':\\n\\t\\t\\t\\tfc_layer = ww_layer\\n\\t\\t\\n\\t\\treturn fc_layer\",\n \"def __init__(self):\\n torch.nn.Module.__init__(self)\\n ######################### Convolution and pooling layers of VGG-16.\\n self.features = torchvision.models.vgg16(pretrained=True).features # fine tune?\\n self.features = torch.nn.Sequential(*list(self.features.children())\\n [:-22]) # Remove pool2 and rest, lack of computational resource\\n # No grad for convVGG\\n # for param in self.features.parameters():\\n # param.requires_grad = False\\n\\n #################### Channel Grouping Net\\n # self.fc1_ = torch.nn.Linear(128, 128*16)#lack of resource\\n # self.fc2_ = torch.nn.Linear(128, 128*16)\\n # self.fc3_ = torch.nn.Linear(128, 128*16)\\n #\\n # torch.nn.init.kaiming_normal_(self.fc1_.weight.data, nonlinearity='relu')\\n # if self.fc1_.bias is not None:\\n # torch.nn.init.constant_(self.fc1_.bias.data, val=0) # fc层的bias进行constant初始化\\n # torch.nn.init.kaiming_normal_(self.fc2_.weight.data, nonlinearity='relu')\\n # if self.fc2_.bias is not None:\\n # torch.nn.init.constant_(self.fc2_.bias.data, val=0) # fc层的bias进行constant初始化\\n # torch.nn.init.kaiming_normal_(self.fc3_.weight.data, nonlinearity='relu')\\n # if self.fc3_.bias is not None:\\n # torch.nn.init.constant_(self.fc3_.bias.data, val=0) # fc层的bias进行constant初始化\\n\\n self.fc1 = torch.nn.Linear(128*28*28, 128)\\n self.fc2 = torch.nn.Linear(128*28*28, 128)\\n self.fc3 = torch.nn.Linear(128*28*28, 128)\\n\\n\\n torch.nn.init.kaiming_normal_(self.fc1.weight.data, nonlinearity='relu')\\n if self.fc1.bias is not None:\\n torch.nn.init.constant_(self.fc1.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.fc2.weight.data, nonlinearity='relu')\\n if self.fc2.bias is not None:\\n torch.nn.init.constant_(self.fc2.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.fc3.weight.data, nonlinearity='relu')\\n if self.fc3.bias is not None:\\n torch.nn.init.constant_(self.fc3.bias.data, val=0) # fc层的bias进行constant初始化\\n\\n self.layerNorm=nn.LayerNorm([224,224])\\n\\n # global grad for hook\\n self.image_reconstruction = None\\n self.register_hooks()\\n self.GradWeight=1e-1\\n\\n # ################### STN input N*3*448*448\\n # self.localization = [\\n # nn.Sequential(\\n # nn.MaxPool2d(4,stride=4),#112\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(3, 32, kernel_size=5,stride=1,padding=2), # 112\\n # nn.MaxPool2d(2, stride=2), # 56\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(32, 48, kernel_size=3,stride=1,padding=1),\\n # nn.MaxPool2d(2, stride=2), # 56/2=28\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 28/2=14\\n # nn.ReLU(True) #output 64*14*14\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.MaxPool2d(4, stride=4), # 112\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\\n # nn.MaxPool2d(2, stride=2), # 56\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 56/2=28\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 28/2=14\\n # nn.ReLU(True) # output 64*14*14\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.MaxPool2d(4, stride=4), # 112\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\\n # nn.MaxPool2d(2, stride=2), # 56\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 56/2=28\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 28/2=14\\n # nn.ReLU(True) # output 64*14*14\\n # ).cuda()\\n # ]\\n # # Regressor for the 3 * 2 affine matrix\\n # self.fc_loc = [\\n # nn.Sequential(\\n # nn.Linear(64 * 14 * 14, 32),\\n # nn.ReLU(True),\\n # nn.Linear(32, 3 * 2)\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.Linear(64 * 14 * 14, 32),\\n # nn.ReLU(True),\\n # nn.Linear(32, 3 * 2)\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.Linear(64 * 14 * 14, 32),\\n # nn.ReLU(True),\\n # nn.Linear(32, 3 * 2)\\n # ).cuda()\\n # ]\\n # # Initialize the weights/bias with identity transformation\\n # for fc_locx in self.fc_loc:\\n # fc_locx[2].weight.data.zero_()\\n # fc_locx[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))\\n\\n ########################Bilinear CNN output 256 channels\\n self.bcnnConv_1=torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\\n [:-1]) # Remove pool3 and rest.\\n self.bcnnConv_2 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\\n [:-1]) # Remove pool3 and rest.\\n self.bcnnConv_3 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\\n [:-1]) # Remove pool3 and rest.\\n #BCNN Linear classifier.\\n self.bfc1 = torch.nn.Linear(512*512, 200)\\n self.bfc2 = torch.nn.Linear(512*512, 200)\\n self.bfc3 = torch.nn.Linear(512*512, 200)\\n torch.nn.init.kaiming_normal_(self.bfc1.weight.data) # 何凯明初始化\\n if self.bfc1.bias is not None:\\n torch.nn.init.constant_(self.bfc1.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.bfc2.weight.data) # 何凯明初始化\\n if self.bfc2.bias is not None:\\n torch.nn.init.constant_(self.bfc2.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.bfc3.weight.data) # 何凯明初始化\\n if self.bfc3.bias is not None:\\n torch.nn.init.constant_(self.bfc3.bias.data, val=0) # fc层的bias进行constant初始化\\n\\n # self.CBP1 = CompactBilinearPooling(512, 512, 50000)\\n # self.CBP2 = CompactBilinearPooling(512, 512, 50000)\\n # self.CBP3 = CompactBilinearPooling(512, 512, 50000)\",\n \"def __init__(self, input_dim=(3,32,32), num_filters=[32], hidden_layers=[100], \\r\\n num_classes=10 ,filter_size=7, weight_scale=1e-3, reg=0, dropout=0, \\r\\n use_batch_norm=False, dtype=np.float32):\\r\\n self.params={}\\r\\n self.use_dropout = dropout > 0\\r\\n self.use_batch_norm = use_batch_norm\\r\\n self.conv_params = {'stride': 1, 'pad': (filter_size - 1) // 2}\\r\\n self.pool_params = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\r\\n self.num_conv_layers = len(num_filters)\\r\\n self.num_hidden_layers = len(hidden_layers)\\r\\n self.bn_params = []\\r\\n self.dropout_params = []\\r\\n self.reg = reg\\r\\n\\r\\n # Initialize batch normalization parameters if necessary.\\r\\n num_layers = self.num_conv_layers + self.num_hidden_layers\\r\\n if self.use_batch_norm:\\r\\n for i in range(num_layers):\\r\\n self.bn_params.append({'mode':'train'})\\r\\n # Initialize dropout parameters if necessary\\r\\n if self.use_dropout:\\r\\n self.dropout_params = {'mode':'trian', 'p':dropout}\\r\\n\\r\\n C, H, W = input_dim\\r\\n channels, HH, WW = C, H, W\\r\\n # Initialize the parameters for the Convolutional network.\\r\\n for i in range(1, self.num_conv_layers+1):\\r\\n self.params['W{}'.format(i)] = np.random.randn(num_filters[i-1], \\r\\n channels, filter_size, \\r\\n filter_size) * weight_scale\\r\\n self.params['b{}'.format(i)] = np.zeros(num_filters[i-1])\\r\\n # Keeping track of the Height and Width of the image as we convolve\\r\\n # it through multiple layers. After pooling make sure the dimensions\\r\\n # make sense\\r\\n if (HH <= self.pool_params['pool_height']):\\r\\n raise Exception('The pool height and input height are equal'.\\\\\\r\\n format(self.pool_params['pool_height'], HH))\\r\\n else:\\r\\n HH = (HH - self.pool_params['pool_height']) / self.pool_params['stride'] + 1\\r\\n if (WW <= self.pool_params['pool_width']):\\r\\n raise Exception('The pool width and input width are equal'.\\\\\\r\\n format(self.params['pool_width'], WW))\\r\\n else:\\r\\n WW = (WW - self.pool_params['pool_width']) / self.pool_params['stride'] + 1\\r\\n\\r\\n\\r\\n # Updating the number of channels for the new input.\\r\\n channels = num_filters[i-1]\\r\\n # Initialize the parameters for the batch normalization if necessary.\\r\\n if self.use_batch_norm:\\r\\n self.params['gamma{}'.format(i)] = np.ones(channels)\\r\\n self.params['beta{}'.format(i)] = np.zeros(channels)\\r\\n\\r\\n # Initialize the parameters for the fully connected network.\\r\\n fc_input_dim = np.prod((HH, WW, channels))\\r\\n for i in range(1, self.num_hidden_layers+1):\\r\\n self.params['W{}'.format(i+self.num_conv_layers)] = np.random.randn(fc_input_dim, \\r\\n hidden_layers[i-1]) * weight_scale\\r\\n self.params['b{}'.format(i+self.num_conv_layers)] = np.zeros(hidden_layers[i-1])\\r\\n # Initialize the parameters for batch normalization if necessary.\\r\\n if self.use_batch_norm:\\r\\n self.params['gamma{}'.format(i+self.num_conv_layers)] = np.ones(hidden_layers[i-1])\\r\\n self.params['beta{}'.format(i+self.num_conv_layers)] = np.zeros(hidden_layers[i-1])\\r\\n fc_input_dim = hidden_layers[i-1]\\r\\n\\r\\n # Initialize the parameters for the last layer of the fully connected network.\\r\\n self.params['W{}'.format(i+self.num_conv_layers+1)] = np.random.randn(hidden_layers[i-1],\\r\\n num_classes) * weight_scale\\r\\n self.params['b{}'.format(i+self.num_conv_layers+1)] = np.zeros(num_classes)\\r\\n\\r\\n # Convert the dtype for the parameters of the model.\\r\\n for k, v in self.params.items():\\r\\n self.params[k] = v.astype(dtype)\",\n \"def __init__(self, num_features, lr, train_index2value, test_index2value, target_grp, optimizer, dataset_type, strength):\\n super().__init__()\\n\\n #self.save_hyperparameters()\\n\\n self.lr = lr\\n self.train_index2value = train_index2value\\n self.test_index2value = test_index2value\\n self.target_grp = target_grp\\n self.optimizer = optimizer\\n self.dataset_type = dataset_type\\n\\n if self.dataset_type == 'tabular':\\n self.net = nn.Linear(num_features, 1)\\n elif self.dataset_type == 'image':\\n # construct network\\n if strength == 'weak':\\n self.cnn = nn.Sequential(nn.Conv2d(in_channels=1, out_channels=2, kernel_size=(3, 3)),\\n nn.MaxPool2d(kernel_size=(2, 2)),\\n nn.Flatten())\\n self.fc = nn.Linear(338 + 1, 1)\\n elif strength == 'normal':\\n self.cnn = nn.Sequential(nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(3, 3)),\\n nn.MaxPool2d(kernel_size=(2, 2)),\\n nn.Flatten())\\n self.fc = nn.Linear(5408 + 1, 1)\\n elif strength == 'strong':\\n self.cnn = nn.Sequential(nn.Conv2d(in_channels=1, out_channels=64, kernel_size=(3, 3)),\\n nn.MaxPool2d(kernel_size=(2, 2)),\\n nn.Flatten())\\n self.fc = nn.Linear(10816 + 1, 1)\\n else:\\n raise Exception(\\\"Strength of the Adversary CNN not recognized!\\\")\\n else:\\n raise Exception(f\\\"Model was unable to recognize dataset type {self.dataset_type}!\\\")\\n \\n # init loss\\n self.loss_fct = nn.BCEWithLogitsLoss()\",\n \"def __init__(self):\\n super(DLStudio.ExperimentsWithCIFAR.Net2, self).__init__()\\n self.relu = nn.ReLU()\\n strides = []\\n patch_size = 2\\n ## conv1:\\n out_ch, ker_size, conv_stride, pool_stride = 128,5,1,2\\n self.conv1 = nn.Conv2d(3, out_ch, (ker_size,ker_size), padding=(ker_size-1)//2) \\n self.pool1 = nn.MaxPool2d(patch_size, pool_stride) \\n strides += (conv_stride, pool_stride)\\n ## conv2:\\n in_ch = out_ch\\n out_ch, ker_size, conv_stride, pool_stride = 128,3,1,2\\n self.conv2 = nn.Conv2d(in_ch, out_ch, ker_size, padding=(ker_size-1)//2)\\n self.pool2 = nn.MaxPool2d(patch_size, pool_stride) \\n strides += (conv_stride, pool_stride)\\n ## conv3: \\n ## meant for repeated invocation, must have same in_ch, out_ch and strides of 1\\n in_ch = out_ch\\n out_ch, ker_size, conv_stride, pool_stride = in_ch,2,1,1\\n self.conv3 = nn.Conv2d(in_ch, out_ch, ker_size, padding=1)\\n self.pool3 = nn.MaxPool2d(patch_size, pool_stride) \\n# strides += (conv_stride, pool_stride)\\n ## figure out the number of nodes needed for entry into fc:\\n in_size_for_fc = out_ch * (32 // np.prod(strides)) ** 2 ## (A)\\n self.in_size_for_fc = in_size_for_fc\\n self.fc1 = nn.Linear(in_size_for_fc, 150)\\n self.fc2 = nn.Linear(150, 100)\\n self.fc3 = nn.Linear(100, 10)\",\n \"def arch(self, nn) -> 'final node of the tensor flow graph (y_conv)':\\n\\n print(self)\\n\\n # first conv. layer \\n # 5x5 filter, 1 input channel, 32 output channels\\n W_conv1 = nn.weight_variable([5, 5, 1, 32])\\n b_conv1 = nn.bias_variable([32])\\n stride1 = 1\\n h_conv1 = tf.nn.relu(nn.conv2d(nn.x_image, W_conv1, stride1, 'VALID') + b_conv1) \\n # outputs a 24x24x32 image\\n \\n # first pooling layer (2x2) \\n h_pool1 = nn.max_pool_2x2(h_conv1) \\n # outputs a 12x12x32 image\\n\\n # second conv. layer \\n # 3x3 filter, 32 input channel, 32 output channels\\n W_conv2 = nn.weight_variable([3, 3, 32, 32])\\n b_conv2 = nn.bias_variable([32])\\n stride2 = 1\\n h_conv2 = tf.nn.relu(nn.conv2d(h_pool1, W_conv2, stride2, 'VALID') + b_conv2)\\n # outputs a 10x10x32 image\\n\\n # third conv. layer\\n # 3x3 filter, 32 input channel, 32 output channels\\n W_conv3 = nn.weight_variable([3, 3, 32, 32])\\n b_conv3 = nn.bias_variable([32])\\n stride3 = 1\\n h_conv3 = tf.nn.relu(nn.conv2d(h_conv2, W_conv3, stride3, 'VALID') + b_conv3)\\n # outputs a 8x8x32 image\\n\\n # reshape (flatten) output\\n h_conv3_flat = tf.reshape(h_conv3, [-1, 8*8*32])\\n\\n # first fully connected layer\\n W_fc1 = nn.weight_variable([8 * 8 * 32, 1024])\\n b_fc1 = nn.bias_variable([1024])\\n h_fc1 = tf.nn.relu(tf.matmul(h_conv3_flat, W_fc1) + b_fc1)\\n\\n # dropout\\n h_fc1_drop = tf.nn.dropout(h_fc1, nn.keep_prob)\\n\\n # second (final) fully connected layer (softmax)\\n W_fc2 = nn.weight_variable([1024, 10])\\n b_fc2 = nn.bias_variable([10])\\n y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)\\n\\n return y_conv\",\n \"def cnn_model_fn(features):\\n print(\\\"features shape\\\", features.shape)\\n\\n input_layer = tf.reshape(features, [-1, 28, 28, 1])\\n\\n conv1 = tf.layers.conv2d(inputs=input_layer, filters=64, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n print(conv1)\\n pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2, padding=\\\"same\\\")\\n print(pool1)\\n conv2 = tf.layers.conv2d(inputs=pool1, filters=128, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n print(conv2)\\n pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2, padding=\\\"same\\\")\\n print(pool2)\\n conv3 = tf.layers.conv2d(inputs=pool2, filters=256, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n print(conv3)\\n conv4 = tf.layers.conv2d(inputs=conv3, filters=256, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n print(conv4)\\n pool3 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=2, padding=\\\"same\\\")\\n print(pool3)\\n pool3_flat = tf.reshape(pool3, [-1, 4 * 4 * 256])\\n print(pool3_flat)\\n fc1 = tf.layers.dense(inputs=pool3_flat, units=1024, activation=tf.nn.relu)\\n print(fc1)\\n fc2 = tf.layers.dense(inputs=fc1, units=1024, activation=tf.nn.relu)\\n print(fc2)\\n fc2_bn = tf.nn.batch_normalization(x=fc2, mean=0, variance=1, scale=1, offset=0, variance_epsilon=1e-6)\\n print(fc2_bn)\\n fc3 = tf.layers.dense(inputs=fc2_bn, units=10)\\n print(fc3)\\n return fc3\",\n \"def build_network(self):\\n\\n input_placeholder = Input(shape = self.input_shape)\\n\\n # Stage 1\\n x = self.main_path_block(\\n input_placeholder,\\n 64, (7, 7), 'same',\\n 'conv1', 'bn_conv1',\\n activation = 'relu',\\n strides = (2, 2)\\n )\\n x = MaxPooling2D((3, 3), strides = (2, 2), padding = 'same')(x)\\n\\n # Stage 2\\n x = self.identity_block(x, 64, 'relu', 2, 'a', False)\\n x = self.identity_block(x, 64, 'relu', 2, 'b')\\n\\n # Stage 3\\n x = self.convolutional_block(x, [128, 128, 128], 'relu', 3, 'a')\\n x = self.identity_block(x, 128, 'relu', 3, 'b')\\n\\n # Stage 4\\n x = self.convolutional_block(x, [256, 256, 256], 'relu', 4, 'a')\\n x = self.identity_block(x, 256, 'relu', 4, 'b')\\n\\n # Stage 5\\n x = self.convolutional_block(x, [512, 512, 512], 'relu', 5, 'a')\\n x = self.identity_block(x, 512, 'relu', 4, 'b')\\n\\n # Fully Connected Layers\\n x = BatchNormalization(axis = 3)(x)\\n x = Activation('relu')(x)\\n x = AveragePooling2D((2, 1), padding = 'valid', strides = (2, 2))(x)\\n x = Flatten()(x)\\n x = Dense(512)\\n x = Dense(\\n self.classes, activation = 'softmax',\\n name = 'fc_' + str(self.classes),\\n kernel_initializer = glorot_uniform(seed = 0)\\n )(x)\\n\\n self.model = Model(input_placeholder, x, name = 'Resnet18')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63327324","0.62027663","0.61002606","0.6070533","0.59601736","0.59473467","0.5912948","0.5911498","0.58962667","0.58913976","0.58264315","0.58224165","0.5808085","0.58010757","0.5788575","0.5781931","0.5776973","0.57699645","0.57483983","0.57286537","0.57209235","0.5720423","0.5713747","0.5705745","0.5699857","0.5698856","0.56975317","0.5687108","0.5684361","0.5680609","0.5669319","0.5654715","0.56479096","0.562241","0.5620957","0.5611294","0.5607407","0.5603152","0.55951905","0.5589841","0.5588083","0.55877286","0.5586913","0.55843574","0.55815274","0.55803883","0.5574771","0.5572783","0.5568836","0.5567572","0.5562557","0.55552006","0.55534595","0.55486876","0.55485326","0.5545483","0.5541824","0.5534615","0.5533759","0.5533114","0.5530339","0.5529269","0.55229706","0.5508254","0.5494694","0.5488905","0.5488381","0.5484103","0.5482768","0.5473985","0.5470668","0.54673684","0.5467164","0.5465541","0.54633164","0.5462976","0.5462092","0.54619277","0.54606485","0.5459439","0.545723","0.5454476","0.5453386","0.5453326","0.5452251","0.5448844","0.5446767","0.54407555","0.54405594","0.5438879","0.54383546","0.5434781","0.54341054","0.54307866","0.5421651","0.5420113","0.5419239","0.54173404","0.5416654","0.541537","0.5412738"],"string":"[\n \"0.63327324\",\n \"0.62027663\",\n \"0.61002606\",\n \"0.6070533\",\n \"0.59601736\",\n \"0.59473467\",\n \"0.5912948\",\n \"0.5911498\",\n \"0.58962667\",\n \"0.58913976\",\n \"0.58264315\",\n \"0.58224165\",\n \"0.5808085\",\n \"0.58010757\",\n \"0.5788575\",\n \"0.5781931\",\n \"0.5776973\",\n \"0.57699645\",\n \"0.57483983\",\n \"0.57286537\",\n \"0.57209235\",\n \"0.5720423\",\n \"0.5713747\",\n \"0.5705745\",\n \"0.5699857\",\n \"0.5698856\",\n \"0.56975317\",\n \"0.5687108\",\n \"0.5684361\",\n \"0.5680609\",\n \"0.5669319\",\n \"0.5654715\",\n \"0.56479096\",\n \"0.562241\",\n \"0.5620957\",\n \"0.5611294\",\n \"0.5607407\",\n \"0.5603152\",\n \"0.55951905\",\n \"0.5589841\",\n \"0.5588083\",\n \"0.55877286\",\n \"0.5586913\",\n \"0.55843574\",\n \"0.55815274\",\n \"0.55803883\",\n \"0.5574771\",\n \"0.5572783\",\n \"0.5568836\",\n \"0.5567572\",\n \"0.5562557\",\n \"0.55552006\",\n \"0.55534595\",\n \"0.55486876\",\n \"0.55485326\",\n \"0.5545483\",\n \"0.5541824\",\n \"0.5534615\",\n \"0.5533759\",\n \"0.5533114\",\n \"0.5530339\",\n \"0.5529269\",\n \"0.55229706\",\n \"0.5508254\",\n \"0.5494694\",\n \"0.5488905\",\n \"0.5488381\",\n \"0.5484103\",\n \"0.5482768\",\n \"0.5473985\",\n \"0.5470668\",\n \"0.54673684\",\n \"0.5467164\",\n \"0.5465541\",\n \"0.54633164\",\n \"0.5462976\",\n \"0.5462092\",\n \"0.54619277\",\n \"0.54606485\",\n \"0.5459439\",\n \"0.545723\",\n \"0.5454476\",\n \"0.5453386\",\n \"0.5453326\",\n \"0.5452251\",\n \"0.5448844\",\n \"0.5446767\",\n \"0.54407555\",\n \"0.54405594\",\n \"0.5438879\",\n \"0.54383546\",\n \"0.5434781\",\n \"0.54341054\",\n \"0.54307866\",\n \"0.5421651\",\n \"0.5420113\",\n \"0.5419239\",\n \"0.54173404\",\n \"0.5416654\",\n \"0.541537\",\n \"0.5412738\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":8988,"cells":{"query":{"kind":"string","value":"This is some other solution from codewars to test against."},"document":{"kind":"string","value":"def my_fizz_buzz_cuckoo_clock(time):\n hours, minutes = map(int, time.split(\":\"))\n sounds = {0: \" \".join([\"Cuckoo\"] * (hours % 12 or 12)), 15: \"Fizz Buzz\", 30: \"Cuckoo\", 45: \"Fizz Buzz\"}\n if minutes in sounds:\n return sounds[minutes]\n return \"Fizz\" if minutes % 3 == 0 else \"Buzz\" if minutes % 5 == 0 else \"tick\""},"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 exercise_b2_53():\r\n pass","def exercise_b2_106():\r\n pass","def exercise_b2_113():\r\n pass","def exercise_b2_107():\r\n pass","def test_4_4_1_1(self):\n pass","def exercise_b2_69():\r\n pass","def exercise_b2_52():\r\n pass","def exercise_b2_56():\r\n pass","def exercise_b2_27():\r\n pass","def exercise_b2_39():\r\n pass","def exercise_b2_26():\r\n pass","def exercise_b2_98():\r\n pass","def exercise_b2_82():\r\n pass","def exercise_b2_70():\r\n pass","def exercise_b2_43():\r\n pass","def substantiate():","def exercise_b2_93():\r\n pass","def nulltest():","def test_create_unexpected_problem(self):\n pass","def solution(s):","def think(s):","def test_T4():","def test_T4():","def test_uparforvarg(self):","def test_probabilistic_parsers():","def testBeliefs1sk(self):","def test_fix_code_typical_code():\r\n\r\n pass","def check():","def test_03_visit_special(self):","def test_T01():","def exercise_b2_95():\r\n pass","def degibber(self):","def exo2():","def test_T0():","def problem_298():\n pass","def exercise_b2_86():\r\n pass","def regular(self):","def testBeliefs2sk(self):","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def __call__(self) -> None:","def fn():","def base():","def _regr_basic():","def test_T3():","def test_T3():","def unitary_test():","def test_4():","def test_replace_identity(self):\n pass","def test_trailing_data(self):","def test_string():","def check(self) -> None:","def exercise_2b():\n\n return","def __call__():","def __call__():","def __call__():","def __call__():","def __call__():","def test_get_list8(self):\n pass","def sth():","def g():","def test_optimize_parse():\n assert True","def test_get_parts(self):\n pass","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def test_identical(self):\n write this test!","def support(self):","def util():\n pass","def util():\n pass","def testGeneratorType(self):","def test_vargs(self):","def func():","def test_T2():","def test_T2():","def test_open_fill(self):","def smarter():\r\n pass","def simple():","def simple():"],"string":"[\n \"def exercise_b2_53():\\r\\n pass\",\n \"def exercise_b2_106():\\r\\n pass\",\n \"def exercise_b2_113():\\r\\n pass\",\n \"def exercise_b2_107():\\r\\n pass\",\n \"def test_4_4_1_1(self):\\n pass\",\n \"def exercise_b2_69():\\r\\n pass\",\n \"def exercise_b2_52():\\r\\n pass\",\n \"def exercise_b2_56():\\r\\n pass\",\n \"def exercise_b2_27():\\r\\n pass\",\n \"def exercise_b2_39():\\r\\n pass\",\n \"def exercise_b2_26():\\r\\n pass\",\n \"def exercise_b2_98():\\r\\n pass\",\n \"def exercise_b2_82():\\r\\n pass\",\n \"def exercise_b2_70():\\r\\n pass\",\n \"def exercise_b2_43():\\r\\n pass\",\n \"def substantiate():\",\n \"def exercise_b2_93():\\r\\n pass\",\n \"def nulltest():\",\n \"def test_create_unexpected_problem(self):\\n pass\",\n \"def solution(s):\",\n \"def think(s):\",\n \"def test_T4():\",\n \"def test_T4():\",\n \"def test_uparforvarg(self):\",\n \"def test_probabilistic_parsers():\",\n \"def testBeliefs1sk(self):\",\n \"def test_fix_code_typical_code():\\r\\n\\r\\n pass\",\n \"def check():\",\n \"def test_03_visit_special(self):\",\n \"def test_T01():\",\n \"def exercise_b2_95():\\r\\n pass\",\n \"def degibber(self):\",\n \"def exo2():\",\n \"def test_T0():\",\n \"def problem_298():\\n pass\",\n \"def exercise_b2_86():\\r\\n pass\",\n \"def regular(self):\",\n \"def testBeliefs2sk(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def __call__(self) -> None:\",\n \"def fn():\",\n \"def base():\",\n \"def _regr_basic():\",\n \"def test_T3():\",\n \"def test_T3():\",\n \"def unitary_test():\",\n \"def test_4():\",\n \"def test_replace_identity(self):\\n pass\",\n \"def test_trailing_data(self):\",\n \"def test_string():\",\n \"def check(self) -> None:\",\n \"def exercise_2b():\\n\\n return\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def test_get_list8(self):\\n pass\",\n \"def sth():\",\n \"def g():\",\n \"def test_optimize_parse():\\n assert True\",\n \"def test_get_parts(self):\\n pass\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def test_identical(self):\\n write this test!\",\n \"def support(self):\",\n \"def util():\\n pass\",\n \"def util():\\n pass\",\n \"def testGeneratorType(self):\",\n \"def test_vargs(self):\",\n \"def func():\",\n \"def test_T2():\",\n \"def test_T2():\",\n \"def test_open_fill(self):\",\n \"def smarter():\\r\\n pass\",\n \"def simple():\",\n \"def simple():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63127756","0.6088745","0.607841","0.60318285","0.5995737","0.5885328","0.586407","0.577447","0.57653236","0.57585347","0.57469904","0.57358444","0.56477886","0.564617","0.5639498","0.55612564","0.55611384","0.5469325","0.5427286","0.5421196","0.5418454","0.54146034","0.54146034","0.53854716","0.53742695","0.53642774","0.5359028","0.5356991","0.5353228","0.5324926","0.531178","0.52954376","0.5285454","0.5254097","0.52339953","0.51679623","0.5158468","0.5125574","0.5102975","0.5102975","0.5102975","0.5102975","0.5102975","0.5085822","0.50804144","0.5030538","0.5017904","0.5013748","0.5013748","0.50076914","0.4999001","0.49868155","0.49683502","0.49587232","0.4952172","0.49518982","0.49493307","0.49493307","0.49493307","0.49493307","0.49493307","0.49342734","0.49335015","0.49235168","0.49233004","0.4918259","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4901271","0.4898787","0.48978794","0.48873872","0.48873872","0.48860157","0.4877838","0.4876113","0.48728192","0.48728192","0.48700532","0.48656595","0.4864257","0.4864257"],"string":"[\n \"0.63127756\",\n \"0.6088745\",\n \"0.607841\",\n \"0.60318285\",\n \"0.5995737\",\n \"0.5885328\",\n \"0.586407\",\n \"0.577447\",\n \"0.57653236\",\n \"0.57585347\",\n \"0.57469904\",\n \"0.57358444\",\n \"0.56477886\",\n \"0.564617\",\n \"0.5639498\",\n \"0.55612564\",\n \"0.55611384\",\n \"0.5469325\",\n \"0.5427286\",\n \"0.5421196\",\n \"0.5418454\",\n \"0.54146034\",\n \"0.54146034\",\n \"0.53854716\",\n \"0.53742695\",\n \"0.53642774\",\n \"0.5359028\",\n \"0.5356991\",\n \"0.5353228\",\n \"0.5324926\",\n \"0.531178\",\n \"0.52954376\",\n \"0.5285454\",\n \"0.5254097\",\n \"0.52339953\",\n \"0.51679623\",\n \"0.5158468\",\n \"0.5125574\",\n \"0.5102975\",\n \"0.5102975\",\n \"0.5102975\",\n \"0.5102975\",\n \"0.5102975\",\n \"0.5085822\",\n \"0.50804144\",\n \"0.5030538\",\n \"0.5017904\",\n \"0.5013748\",\n \"0.5013748\",\n \"0.50076914\",\n \"0.4999001\",\n \"0.49868155\",\n \"0.49683502\",\n \"0.49587232\",\n \"0.4952172\",\n \"0.49518982\",\n \"0.49493307\",\n \"0.49493307\",\n \"0.49493307\",\n \"0.49493307\",\n \"0.49493307\",\n \"0.49342734\",\n \"0.49335015\",\n \"0.49235168\",\n \"0.49233004\",\n \"0.4918259\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4901271\",\n \"0.4898787\",\n \"0.48978794\",\n \"0.48873872\",\n \"0.48873872\",\n \"0.48860157\",\n \"0.4877838\",\n \"0.4876113\",\n \"0.48728192\",\n \"0.48728192\",\n \"0.48700532\",\n \"0.48656595\",\n \"0.4864257\",\n \"0.4864257\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":8989,"cells":{"query":{"kind":"string","value":"The index view, for the home page. Shows Campaigns this UserProfile is in."},"document":{"kind":"string","value":"def index(request):\n context = dict()\n if request.user.is_authenticated():\n context['campaigns'] = [\n CampaignSerializer(c).serialize() for c in\n request.user.userprofile.campaigns.order_by('pk')]\n return render(request, 'voter_validation/index.html', context)"},"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 index(request): \n \n all_projects = models.Project.objects.all()\n projects = get_objects_for_user(request.user, 'view_project', all_projects)\n \n fbads_settings = FacebookAdsSettings.objects.first()\n return render_to_response('index.html',{\n 'projects': projects, \n 'fbads_settings': fbads_settings},\n context_instance=RequestContext(request))","def index(request):\n\n LOGGER.debug('socialprofile_demo.views.index')\n\n response_data = {}\n\n return render_to_response('index.html', response_data, context_instance=RequestContext(request))","def index(request):\n return render(request, 'commissioned_sites/index.html',\n {'sites': CommissionedSite.objects.all().order_by('-date')},\n context_instance=RequestContext(request))","def index(page):\r\n per_page = 24\r\n count = cached_users.get_total_users()\r\n accounts = cached_users.get_users_page(page, per_page)\r\n if not accounts and page != 1:\r\n abort(404)\r\n pagination = Pagination(page, per_page, count)\r\n if current_user.is_authenticated():\r\n user_id = current_user.id\r\n else:\r\n user_id = 'anonymous'\r\n top_users = cached_users.get_leaderboard(current_app.config['LEADERBOARD'],\r\n user_id)\r\n return render_template('account/index.html', accounts=accounts,\r\n total=count,\r\n top_users=top_users,\r\n title=\"Community\", pagination=pagination)","def index(request):\n users = User.objects.filter(is_staff=False, is_active=True).order_by('username')\n return render(request, 'users/view_all_users.html',\n { 'users': users })","def index():\r\n if current_user.is_authenticated():\r\n user_id = current_user.id\r\n else:\r\n user_id = 'anonymous'\r\n top_users = cached_users.get_leaderboard(current_app.config['LEADERBOARD'],\r\n user_id=user_id)\r\n\r\n return render_template('/stats/index.html', title=\"Community Leaderboard\",\r\n top_users=top_users)","def index(request):\n home_user = request.user.profile\n \"\"\"num_activities = Activity.objects.count()\"\"\"\n Cactivity = CompletedActivity.objects.filter(user=home_user)\n UActivity = Cactivity.values('activity_id', 'activity__name', 'activity__value', 'activity__group').annotate \\\n (count=Count('activity__name'), earned=Sum('activity__value'))\n TimesCompelted = Cactivity.annotate(count=Count('activity__name'))\n # Generate counts of some of the main objects\n\n context = {\n 'huser': home_user,\n 'Lname' : home_user.user.last_name,\n 'Fname': home_user.user.first_name,\n 'num_activities': 1,\n 'activity_list' : UActivity,\n \"times_completed\" : TimesCompelted\n }\n\n # Render the HTML template index.html with the data in the context variable\n return render(request, 'index.html', context=context)","def index(request):\n\t# Generate counts of some of the main objects\n\tnum_customers = Customers.objects.all().count()\n\tnum_instructors = Instructors.objects.all().count()\n\tnum_membership_plans = MembershipPlans.objects.count() # The 'all()' is implied by default.\n\n\tselectInstructors = SelectInstructors();\n\tjoinQuery = JoinQuery();\n\taggregationQuery = AggregationQuery();\n\tdivisionQuery = DivisionQuery();\n\tnestedAggregationQuery = NestedAggregationQuery();\n\tdeleteOperationCascade = DeleteOperationCascade();\n\tdeleteOperation = DeleteOperation();\n\tupdateNumberOfPeople = UpdateNumberOfPeople();\n\t# Render the HTML template index.html with the data in the context variable\n\treturn render(\n\t\trequest,\n\t\t'index.html',\n\t\tcontext={'num_membership_plans':num_membership_plans,'num_instructors':num_instructors,'num_customers':num_customers,'select_instructors':selectInstructors,'join_query':joinQuery,'aggregation_query':aggregationQuery,'division_query':divisionQuery,'nested_aggregation_query':nestedAggregationQuery,'delete_operation_cascade':deleteOperationCascade, 'delete_operation': deleteOperation, 'update_number_of_people': updateNumberOfPeople},\n\t)","def index():\n user, user_id = get_user()\n # Get this user's course with their roles\n my_courses = []\n if user:\n my_courses = user.get_courses()\n # Get all public courses\n public_courses = Course.get_public()\n\n return render_template('courses/index.html',\n user=user,\n my_courses=my_courses,\n public_courses=public_courses)","def index(request):\n params = get_user_profile_params(request)\n\n competition = Competition.get_active()\n params['top_competition_id'] = competition.id\n params['minify_js'] = settings.MINIFY_JS\n\n params['first_page_text'] = ''\n config = Config.objects.all()\n if config.count() > 0:\n params['first_page_text'] = config[0].first_page_text\n\n #order email test\n #order = Order.objects.get(pk=25)\n #send_order_email(order.email, order, order.items.all)\n\n return render(request, 'base.html', params)","def index(request, extra_context={}, user=AnonymousUser()):\r\n\r\n # The course selection work is done in courseware.courses.\r\n domain = settings.FEATURES.get('FORCE_UNIVERSITY_DOMAIN') # normally False\r\n # do explicit check, because domain=None is valid\r\n if domain is False:\r\n domain = request.META.get('HTTP_HOST')\r\n\r\n courses = get_courses(user, domain=domain)\r\n courses = sort_by_announcement(courses)\r\n\r\n context = {'courses': courses}\r\n\r\n context.update(extra_context)\r\n return render_to_response('index.html', context)","def index(request):\n if request.user.is_authenticated:\n return redirect('/dashboard')\n else:\n context = {'client_id': settings.OPENHUMANS_CLIENT_ID,\n 'oh_proj_page': settings.OH_ACTIVITY_PAGE}\n\n return render(request, 'main/index.html', context=context)","def index():\n user_list = Users.query.all()\n return render_template('users/index.html'\n ,user_list=user_list\n ,t=t\n ,m=m)","def index(request):\n # Generate counts of some of the main objects\n num_orgs=Organization.objects.count()\n num_contacts=Contact.objects.count()\n # Get the number of Volunteers\n num_volunteers=ContactTypeTag.objects.filter(tag_type__exact='vo').count()\n num_projects=Project.objects.count() # The 'all()' is implied by default.\n \n # Render the HTML template index.html with the data in the context variable\n return render(\n request,\n 'index.html',\n context={\n 'num_orgs':num_orgs,\n 'num_contacts':num_contacts,\n 'num_volunteers':num_volunteers,\n 'num_projects':num_projects,\n },\n )","def list_campaigns(self, **kwargs) -> ApiResponse:\n return self._request(kwargs.pop('path'), params=kwargs)","def index(request):\n if request.user is None:\n return view_all(request, index_call=True)\n else:\n return mine(request)","def index(request):\n\n dests = Destination.objects.all()\n\n return render(request,'index.html',{'dests': dests})","def my_index(request):\n try:\n denied = models.ParticipantStatus.objects.get(codename=models.ParticipantStatus.DENIED)\n except:\n denied = -1\n\n competitions_im_creator_of = Competition.objects.filter(creator=request.user).order_by('-pk').select_related(\n 'creator').annotate(num_participants=Count('participants'))\n competitions_im_admin_of = Competition.objects.exclude(pk__in=[c.pk for c in competitions_im_creator_of]).filter(\n admins__in=[request.user]).order_by('-pk').select_related('creator').annotate(num_participants=Count('participants'))\n my_competitions = list(competitions_im_creator_of) + list(competitions_im_admin_of)\n\n # Invalid select related previously\n published_competitions = models.Competition.objects.filter(published=True).select_related('creator').annotate(num_participants=Count('participants'))\n published_competitions = reversed(sorted(published_competitions, key=lambda c: c.get_start_date))\n context_dict = {\n 'my_competitions': my_competitions,\n # Invalid select related previously\n 'competitions_im_in': list(request.user.participation.all().exclude(status=denied)),\n 'published_competitions': published_competitions,\n }\n return render(request, \"web/my/index.html\", context_dict)","def contest_won_viewall(request):\n is_loggedin, username = get_session_variables(request)\n contest_list = Contest_won.objects.all()\n\n if contest_list:\t\n contest_participant_list = []\n for contest_won_obj in contest_list:\t\n c_id = contest_won_obj.contest_id\n c_p_objs = Contest_won_participant.objects. \\\n filter(contest_id = c_id)\n contest_participant_list.extend(c_p_objs)\n\n return render_to_response('achievement/contest_viewall.html', \\\n {'is_loggedin':is_loggedin, \\\n 'username':username, \\\n 'contest_list':contest_list, \\\n 'contest_participant_list':contest_participant_list}, \\\n RequestContext(request))\n else:\n return render_to_response('achievement/noview.html', \\\n {'is_loggedin':is_loggedin, \\\n 'username':username, \\\n 'type': 'Contest\\'s won'}, \\\n RequestContext(request))","def all_accounts(request):\n accounts = Account.objects.all()\n return render(request, 'app/home.html', {'accounts': accounts})","def get(self):\n query = Campaign.query\n return paginate(Campaign.__tablename__, query, self.schema), HTTPStatus.OK","def index(request):\n\n context = {'employees': User.objects.select_related('profile').filter(is_staff=True).order_by('first_name')}\n return render(request, 'Employees/index.html', context)","def all_users(request):\n # order users by last name\n users = UserProfile.objects.all().order_by('last_name')\n return render(request, \"allusers.html\", {'users': users})","def show_campaigns(request, utm_campaign, **kwargs):\n \n err_msg = ''\n try:\n err_msg = str(kwargs['kwargs']['err_msg'])\n except:\n pass\n \n test_type_override = ''\n try:\n test_type_override = MySQLdb._mysql.escape_string(request.POST['test_type_override'])\n \n if test_type_override == 'Banner':\n test_type_var = FDH._TESTTYPE_BANNER_\n elif test_type_override == 'Landing Page':\n test_type_var = FDH._TESTTYPE_LP_\n elif test_type_override == 'Banner and LP':\n test_type_var = FDH._TESTTYPE_BANNER_LP_\n \n except:\n test_type_var = ''\n pass\n \n try:\n \"\"\" Find the earliest and latest page views for a given campaign \"\"\"\n lptl = DL.LandingPageTableLoader()\n ccrml = DL.CiviCRMLoader()\n \n start_time = ccrml.get_earliest_donation(utm_campaign)\n end_time = ccrml.get_latest_donation(utm_campaign)\n \n one_step = lptl.is_one_step(start_time, end_time, utm_campaign) \n \n if not(one_step): \n start_time = lptl.get_earliest_campaign_view(utm_campaign)\n end_time = lptl.get_latest_campaign_view(utm_campaign) \n\n interval = 1\n \n \"\"\" Create reporting object to retrieve campaign data and write plots to image repo on disk \"\"\"\n ir = DR.IntervalReporting(was_run=False, use_labels=False, font_size=20, plot_type='line', query_type='campaign', file_path=projSet.__web_home__ + 'campaigns/static/images/')\n \n \"\"\" Produce analysis on the campaign view data \"\"\" \n ir.run(start_time, end_time, interval, 'views', utm_campaign, {}, one_step=one_step)\n \n \"\"\" \n ESTIMATE THE START AND END TIME OF THE CAMPAIGN\n ===============================================\n \n Search for the first instance when more than 10 views are observed over a sampling period\n \"\"\"\n \n col_names = ir._data_loader_.get_column_names()\n \n views_index = col_names.index('views')\n ts_index = col_names.index('ts')\n \n row_list = list(ir._data_loader_._results_) # copy the query results\n for row in row_list:\n if row[views_index] > 100:\n start_time_est = row[ts_index]\n break\n row_list.reverse()\n for row in row_list:\n if row[views_index] > 100:\n end_time_est = row[ts_index]\n break\n \n \n \"\"\"\n BUILD THE VISUALIZATION FOR THE TEST VIEWS OF THIS CAMAPAIGN\n ============================================================ \n \"\"\"\n \n \"\"\" Read the test name \"\"\"\n ttl = DL.TestTableLoader()\n row = ttl.get_test_row(utm_campaign)\n test_name = ttl.get_test_field(row ,'test_name')\n \n \"\"\" Regenerate the data using the estimated start and end times \"\"\"\n ir = DR.IntervalReporting(was_run=False, use_labels=False, font_size=20, plot_type='line', query_type='campaign', file_path=projSet.__web_home__ + 'campaigns/static/images/')\n ir.run(start_time_est, end_time_est, interval, 'views', utm_campaign, {}, one_step=one_step)\n \n \"\"\" Determine the type of test (if not overridden) and retrieve the artifacts \"\"\"\n test_type, artifact_name_list = FDH.get_test_type(utm_campaign, start_time, end_time, DL.CampaignReportingLoader(query_type=''), test_type_var)\n \n return render_to_response('campaigns/show_campaigns.html', {'utm_campaign' : utm_campaign, 'test_name' : test_name, 'start_time' : start_time_est, 'end_time' : end_time_est, 'one_step' : one_step, \\\n 'artifacts' : artifact_name_list, 'test_type' : test_type, 'err_msg' : err_msg}, context_instance=RequestContext(request)) \n\n except Exception as inst:\n \n logging.error('Failed to correctly produce campaign diagnostics.')\n logging.error(type(inst))\n logging.error(inst.args)\n logging.error(inst)\n \n \"\"\" Return to the index page with an error \"\"\"\n err_msg = 'There is insufficient data to analyze this campaign: %s. Check to see if the <a href=\"/LML/\">impressions have been loaded</a>. <br><br>ERROR:<br><br>%s' % (utm_campaign, inst.__str__())\n \n return index(request, kwargs={'err_msg' : err_msg})","def view(args):\n if args.available:\n printAvailableCampaigns()\n if args.search_help:\n print(getSearchQueryHelp())","def get_list_of_campaigns(self, limit=0, offset=0):\n logger.info(\"Function call: get_list_of_campaigns\")\n return self.__handle_result(self.__send_request('campaigns', 'GET', {'limit': limit or 0, 'offset': offset or 0}))","def index(request):\n\n chats = Chat.objects.all().order_by('-created_at')\n\n if request.user.is_authenticated():\n chats = chats.filter(friend_groups__in=request.user.get_profile().\\\n friend_groups.all().values_list('id'))\n else:\n chats = chats.filter(friend_groups__isnull=True)\n\n return render_to_response('index.html', {\n 'chats': chats[:10],\n }, context_instance=RequestContext(request))","def dashboard(request):\r\n profile = get_object_or_404(Profile, user=request.user)\r\n wallet = Wallet.objects.get(user=request.user)\r\n history = History.objects.get(pk=1)\r\n referrals = Referral.objects.filter(referee=request.user).count()\r\n invoices = Invoice.objects.filter(issuer=request.user).count()\r\n return render(request, 'coin/dashboard.html', {'profile': profile, \r\n 'wallet': wallet, 'history': history, 'referrals': referrals, \r\n 'invoices': invoices})","def my_dashboard(request):\n #Get the associated contact for our user\n user_con = request.user.contact\n qs_proj_assoc, qs_task_assoc = get_tiered_upcoming(user_con)\n\n #Get the projects associated with the user\n user_proj_table = table_proj.ProjectAssocAjaxTable(qs_proj_assoc)\n #Get the tasks associated with the user\n user_task_table = table_task.TaskAssocAjaxTable(qs_task_assoc)\n\n # Render the HTML template index.html with the data in the context variable\n return render(\n request,\n 'my_dashboard.html',\n context={\n 'user_con':user_con,\n 'user_proj_table':user_proj_table,\n 'user_task_table':user_task_table,\n 'project_source' : 'data-dashboard-project-upcoming',\n 'task_source' : 'data-dashboard-task-upcoming',\n 'input_id' : user_con.pk,\n 'print_url':reverse_lazy('my-dashboard-print'),\n },\n )","def test_admin_sms_campaign_view_list(self):\n response = self.client.get('/admin/sms_module/smscampaign/')\n self.failUnlessEqual(response.status_code, 200)","def index(request):\n posts = Post.objects.filter(status=1).order_by('-created_on')[:2]\n\n # Pre populate fields with profile information\n if request.user.is_authenticated:\n profile = UserProfile.objects.get(user=request.user)\n form = ContactForm(initial={\n 'contact_name': profile.default_full_name,\n 'contact_email': profile.default_email,\n })\n else:\n form = ContactForm()\n\n context = {\n 'posts': posts,\n 'form': form,\n }\n\n return render(request, 'home/index.html', context)","def index(request):\n template_var = base_template_vals(request)\n up = UserProfile.objects.filter(django_user=request.user)\n template_var[\"likes\"] = Like.objects.filter(user=up[0])\n \n try:\n event_list = Event.objects.all().order_by('id')\n except Event.DoesNotExist:\n raise Http404\n output = ', '.join([e.title for e in event_list]) \n template_var[\"events\"] = output\t\n return render_to_response(\"event/index.html\", template_var,\n context_instance=RequestContext(request))","def list_view(request):\n campgrounds = Campground.objects.all()\n return render(request, 'campgrounds.html')","def index(request):\n template = 'index.html'\n hospitals = Hospital.objects.all()\n return render_to_response(template, {'hospitals': hospitals}, context_instance=RequestContext(request))","def index(request):\n if _use_new_ui(request):\n return _serve_new_ui(request)\n\n if request.user is None:\n return view_all(request, index_call=True)\n else:\n return mine(request)","def index():\n try:\n # Retrieve a list of active clients from the BancBox API for \n # the right side bar.\n active_clients = api.get_active_clients()\n except Exception, e:\n active_clients = []\n logger.error('Error retrieving active clients: %s', e)\n return render_template('index.html', active_clients=active_clients)","def index():\n if (session_get_int(\"user_id\") is not None):\n return render_template(\"dashboard.html\")\n else:\n return render_template(\"index.html\")","def index(request):\n # TODO: Use django.views.generic.ListView\n courses = Course.objects.order_by('-name')\n context = {\n 'courses': courses,\n }\n return render(request, 'hall_pass/index.html', context)","def index(request):\n user_data_list = UserData.objects.all().order_by('environment')\n context = {'user_data_list': user_data_list}\n\n return render(request, 'index.html', context)","def index(self):\n\n return render_template(\n 'home_page/index.html',\n **locals()\n )","def all_users():\n\n users = crud.get_users()\n\n return render_template('all_users.html', users=users)","def index(self):\n log.debug('index()')\n return redirect_to('/admin/dashboard')","def achieve_viewall(request):\n is_loggedin, username = get_session_variables(request)\n contrib_list = []\n article_list = []\n gsoc_list = []\n speaker_list = []\n intern_list = []\n contest_participant_list = []\n icpc_participants_regional_list = []\n icpc_participants_final_list = []\n\n contrib_list_all = Contribution.objects.all()\n contrib_list = Contribution.objects.all()[:5]\n article_list = Article.objects.all()[:5]\n gsoc_list = Gsoc.objects.all()[:5]\n speaker_list = Speaker.objects.all()[:5]\n intern_list = Intern.objects.all()[:5]\n contest_list = Contest_won.objects.all()[:5]\n\n \n contrib_org = {}\n if contrib_list_all:\n for contrib in contrib_list_all:\n if contrib.org_name not in contrib_org.keys():\n contrib_org[contrib.org_name] = 0\n\n for contrib in contrib_list:\n contrib_org[contrib.org_name] += 1\n\n if contest_list:\t\n contest_participant_list = []\n\tfor contest_won_obj in contest_list:\t\n\t c_id = contest_won_obj.contest_id\n\t c_p_objs = Contest_won_participant.objects.filter(contest_id = c_id)\n\t contest_participant_list.extend(c_p_objs)\n \n icpc_list_regionals = ACM_ICPC_detail.objects.filter(level='regional').order_by('ranking')[:2]\n if icpc_list_regionals:\n for icpc_obj in icpc_list_regionals:\n team = icpc_obj.team_name\n member1 = [icpc_obj.participant1_name, \\\n get_username_from_email(icpc_obj.participant1_email)]\n\n member2 = [icpc_obj.participant2_name, \\\n get_username_from_email(icpc_obj.participant2_email)]\n\n member3 = [icpc_obj.participant3_name, \\\n get_username_from_email(icpc_obj.participant3_email)]\n\n icpc_participant_list = [icpc_obj, member1,member2,member3]\n icpc_participants_regional_list.append(icpc_participant_list)\n\n icpc_list_finals = ACM_ICPC_detail.objects.filter(level='finals').order_by('ranking')[:2]\n if icpc_list_finals:\n for icpc_obj in icpc_list_finals:\n team = icpc_obj.team_name\n member1 = [icpc_obj.participant1_name, \\\n get_username_from_email(icpc_obj.participant1_email)]\n\n member2 = [icpc_obj.participant2_name, \\\n get_username_from_email(icpc_obj.participant2_email)]\n\n member3 = [icpc_obj.participant3_name, \\\n get_username_from_email(icpc_obj.participant3_email)]\n\n icpc_participant_list = [icpc_obj, member1,member2,member3]\n icpc_participants_final_list.append(icpc_participant_list)\n\n return render_to_response('achievement/achievement_viewall.html',\\\n\t\t{'username':username, \\\n 'is_loggedin':is_loggedin, \\\n 'contrib_list':contrib_list, \\\n 'contrib_org':contrib_org,\\\n 'article_list':article_list, \\\n 'gsoc_list':gsoc_list, \\\n 'speaker_list':speaker_list, \\\n 'intern_list':intern_list, \\\n 'contest_list':contest_list, \\\n 'contest_participant_list':contest_participant_list, \\\n 'icpc_participants_final_list':icpc_participants_final_list, \\\n 'icpc_participants_regional_list':icpc_participants_regional_list}, \\\n RequestContext(request))","def homepage(request):\n limit = 7\n featured_marketer_list = (\n PimpUser.objects\n .filter(featured=True)\n .filter(usertype=PimpUser.MARKETER)\n .order_by('-date_joined')[:limit]\n )\n featured_cause_list = (\n PimpUser.objects\n .filter(featured=True)\n .filter(usertype=PimpUser.CAUSE)\n .order_by('-date_joined')[:limit]\n )\n news_post_list = (\n NewsPost.objects\n .order_by('-created_at')[:3]\n )\n\n context = {\n 'featured_marketer_list': featured_marketer_list,\n 'featured_cause_list': featured_cause_list,\n 'news_post_list': news_post_list,\n }\n\n return render(\n request,\n 'index.html',\n context\n )","def get_homepage():\n\n list_of_students = hackbright.list_all_students()\n list_of_projects = hackbright.list_all_projects()\n\n return render_template(\"index.html\",\n list_of_students=list_of_students,\n list_of_projects=list_of_projects)","def index():\n\n if current_user.is_anonymous:\n flash(\"Login to add, edit and delete items\", category='warning')\n return render_template('index.html', title=\"index\")\n else:\n categories = Category.query.filter(\n current_user.id == Category.user_id).all()\n items = Item.query.filter(current_user.id == Item.user_id).all()\n return render_template(\n 'index.html',\n title=\"index\",\n categories=categories,\n items=items,\n category_id=None)","def home_app():\n users = User.query.order_by(User.last_name, User.first_name).all()\n\n return render_template('index.html', users=users)","def index(request):\n table = dynamodb.Table(table_name)\n sis_account_id = request.LTI[\"custom_canvas_account_sis_id\"]\n school_id = sis_account_id.split(\":\")[1]\n school_key = f'SCHOOL#{school_id.upper()}'\n query_params = {\n 'KeyConditionExpression': Key('pk').eq(school_key),\n 'ScanIndexForward': False,\n }\n logger.debug(f'Retrieving jobs for school {school_key}.')\n jobs_for_school = table.query(**query_params)['Items']\n\n # Update created_at (ISO8601) string timestamp to datetime.\n [item.update(created_at=parse_datetime(item['created_at']))\n for item in jobs_for_school]\n\n context = {\n 'jobs_for_school': jobs_for_school\n }\n logger.debug(f'Retrieved jobs for school {school_key}.', extra=context)\n return render(request, \"bulk_site_creator/index.html\", context=context)","def index(request):\n # # Generate counts of some of the main objects\n # class_iter = Course.objects.all()\n # num_instances = BookInstance.objects.all().count()\n # # Available books (status = 'a')\n # num_instances_available = BookInstance.objects.filter(status__exact='a').count()\n # num_authors = Author.objects.count() # The 'all()' is implied by default.\n\n # Render the HTML template index.html with the data in the context variable\n cr=Course.objects.filter(ta={Ta.full_name})\n context = dict()\n # for item in class_iter:\n # context[str(item)] = item.cname\n\n return render(\n request,\n 'index.html',\n # context={'num_books': num_books, 'num_instances': num_instances,\n # 'num_instances_available': num_instances_available, 'num_authors': num_authors},\n context,\n )","def icpc_viewall(request):\n is_loggedin, username = get_session_variables(request)\n icpc_participants_list = []\n p_list= []\n icpc_list = ACM_ICPC_detail.objects.all().order_by('ranking')\n if icpc_list:\n\n for icpc_obj in icpc_list:\n \n team = icpc_obj.team_name\n member1 = [icpc_obj.participant1_name, \\\n get_username_from_email(icpc_obj.participant1_email)]\n\n member2 = [icpc_obj.participant2_name, \\\n get_username_from_email(icpc_obj.participant2_email)]\n\n member3 = [icpc_obj.participant3_name, \\\n get_username_from_email(icpc_obj.participant3_email)]\n\n icpc_participant_list = [icpc_obj, member1,member2,member3]\n icpc_participants_list.append(icpc_participant_list)\n \n return render_to_response('achievement/icpc_viewall.html', \\\n {'is_loggedin':logged_in(request), \\\n 'username':username, \\\n 'icpc_list':icpc_list,\\\n 'icpc_participants_list':icpc_participants_list}, RequestContext(request))\n\n else:\n return render_to_response('achievement/noview.html', \\\n {'is_loggedin':logged_in(request), \\\n 'username':username, \\\n 'type': 'ACM ICPC Contest'}, \\\n RequestContext(request))","def base_dashboard(request):\n appointments = None\n\n if request.user.userprofile.is_patient():\n appointments = Appointment.objects.filter(patient=request.user.id).order_by('date')\n elif request.user.userprofile.is_doctor():\n appointments = Appointment.objects.filter(doctor=request.user.id).order_by('date')\n else:\n appointments = Appointment.objects.all().order_by('date')\n\n return render(request, 'base_dashboard.html', {'appointments': appointments, 'the_user': request.user})","def display_users(cls):\n return cls.user_list","def dashboard():\n # TODO: Optionally, old proposals should be shown in a read-only mode.\n talks = Talk.query.current.filter(Talk.user == current_user)\n return render_template(\n 'profile/dashboard.html', talks=talks)","def index(request):\n\n # Generate counts of some of the main objects\n num_blogs = Blog.objects.all().count()\n num_authors = BlogAuthor.objects.count()\n num_comments = BlogComment.objects.count()\n\n context = {\n 'num_blogs': num_blogs,\n 'num_authors': num_authors,\n 'num_comments': num_comments,\n }\n\n # Render the HTML template index.html with the data in the context variable\n return render(request, 'index.html', context=context)","def index(request):\n # Generate counts of some of the main objects\n num_inventions = Invention.objects.all().count()\n inventions = Invention.objects.order_by('-date_of_invention')\n\n inventions_to_random = list(Invention.objects.all())\n random_invention = random.choice(inventions_to_random)\n\n context = {\n 'num_inventions': num_inventions,\n 'inventions': inventions,\n 'random_invention': random_invention\n }\n\n # Render the HTML template index.html with the data in the context variable\n return render(request, 'index.html', context=context)","def index(request):\n return render(request, \"county/index.html\")","def show_users():\n\n user = User(connection=connection, cursor=cursor)\n\n all_users = user.get_all_users()\n\n context = {\n 'all_users': all_users\n }\n\n return render_template('pages/tables/users.html', **context)","def index(request):\n\tusuario = request.user\n\ttemplate = 'customerbuy/index.html'\n\treturn render_to_response(template,{'usuario': usuario},context_instance=RequestContext(request))","def index(request):\n if request.user.is_authenticated:\n return HttpResponseRedirect(reverse('surveys-dashboard'))\n\n context = {}\n\n # Render the HTML template index.html with the data in the context variable\n return render(request, 'index.html', context=context)","def list_users():\n\n db_users = User.query.all()\n\n return render_template(\"list_users.html\", headline=\"Blogly Users\", users=db_users)","def index(request):\n warnings.warn(\n \"icekit_events.views.index is deprecated and will disappear in a \"\n \"future version. If you need this code, copy it into your project.\"\n , DeprecationWarning\n )\n\n occurrences = models.Occurrence.objects.visible()\n context = {\n 'occurrences': occurrences,\n }\n return TemplateResponse(request, 'icekit_events/index.html', context)","def index(request):\n num_blogs = Blog.objects.all().count()\n num_authors = BlogAuthor.objects.all().count()\n num_unique_authors = Blog.objects.distinct().count()\n num_comments = Comment.objects.all().count()\n return render(request, 'index.html', context={'num_blogs' : num_blogs, 'num_authors' : num_authors,\n 'num_unique_authors' : num_unique_authors, 'num_comments' : num_comments})","def index(self):\n\n\t\tself.db = DB()\n\t\tactivityTuple = self.db.select_all_from(\"activity\")[1]\n\t\ttmpl = lookup.get_template(\"index.html\")\n\t\treturn (tmpl.render(activity=activityTuple))","def get(self, request):\n context = {}\n if request.user.is_authenticated:\n instagram_accounts = InstagramAccount.objects.filter(user_id=request.user.pk)\n context['instagram_accounts'] = instagram_accounts\n return render(request, 'home.html', context)","def intern_viewall(request):\n is_loggedin, username = get_session_variables(request)\n intern_list = Intern.objects.all()\n\n if intern_list:\n return render_to_response('achievement/intern_viewall.html', \\\n {'is_loggedin':is_loggedin, \\\n 'username':username, \\\n 'intern_list':intern_list}, \\\n RequestContext(request))\n else:\n return render_to_response('achievement/noview.html', \\\n {'is_loggedin':is_loggedin, \\\n 'username':username, \\\n 'type': 'Internship'}, \\\n RequestContext(request))","def index(self, page=1):\n users_obj = User.query.paginate(page)\n return render_template('item/list.html', items=users_obj)","def users_page(request):","def user(self):\n try:\n data_definitions = self.get_data_definitions(current_user.scheme_id)\n user_data = self.get_all_user_data(current_user.scheme_id, current_user.k_number)\n\n return render_template(\"user/dashboard_page.html\", title=\"Your Profile\", user_data=user_data)\n\n except Exception as e:\n self._log.exception(\"Could not execute get user logic\")\n return abort(500)","def index(request):\n cat_filter = request.GET.get('category_filter')\n context = {\"cat_filter\": cat_filter,\n \"gifs_with_cats\": GifToUser.get_user_gifs_for_category(\n request.user, cat_filter=cat_filter),\n \"all_cats\": GifToUserCategory.get_user_categories(request.user)}\n template = loader.get_template('gifs/index.html')\n return HttpResponse(template.render(context, request))","def list_users():\n users = User.query.order_by(User.last_name, User.first_name).all()\n return render_template('index.html', users=users)","def index(request):\n # Generate counts of some of the main objects\n projects = Project.objects.all()\n projects = projects[0:4]\n press = Press.objects.all().count()\n # Available books (status = 'a')\n # num_instances_available=BookInstance.objects.filter(status__exact='a').count()\n # num_authors=Author.objects.count() # The 'all()' is implied by default.\n\n # Render the HTML template index.html with the data in the context variable\n\n all_services = Service.objects.all()\n services = all_services[0:4]\n\n return render(\n request,\n 'index.html',\n context={'projects': projects, 'press': press, 'services': services})","def display_homepage(user_id):\n\n user_inv = (UserInv.query.filter_by(user_id=user_id)).all()\n\n return render_template('user-homepage.html',\n user_inv=user_inv)","def index(request):\n\treturn render(request, 'Toeic/index.html')","def index(request):\r\n assert isinstance(request, HttpRequest)\r\n return render(\r\n request,\r\n 'app/site/indexSite.html',\r\n context_instance=RequestContext(request,\r\n {\r\n 'title': 'Colmeia | Início',\r\n 'year': datetime.now().year,\r\n })\r\n )","def gsoc_viewall(request):\n is_loggedin, username = get_session_variables(request)\n gsoc_list = Gsoc.objects.all()\n\n if gsoc_list:\n return render_to_response('achievement/gsoc_viewall.html', \\\n {'is_loggedin':is_loggedin, \\\n 'username':username, \\\n 'gsoc_list':gsoc_list}, \\\n RequestContext(request))\n else:\n return render_to_response('achievement/noview.html', \\\n {'is_loggedin':is_loggedin, \\\n 'username':username, \\\n 'type': 'Gsoc'}, \\\n RequestContext(request))","def index_view(self) -> str:\n return render_template(\n \"index.html\",\n challenge_groups=self._challenge_groups,\n ctff=current_app,\n )","def users_in_cohort(request, course_key, cohort_id):\r\n # this is a string when we get it here\r\n course_key = SlashSeparatedCourseKey.from_deprecated_string(course_key)\r\n\r\n get_course_with_access(request.user, 'staff', course_key)\r\n\r\n # this will error if called with a non-int cohort_id. That's ok--it\r\n # shoudn't happen for valid clients.\r\n cohort = cohorts.get_cohort_by_id(course_key, int(cohort_id))\r\n\r\n paginator = Paginator(cohort.users.all(), 100)\r\n page = request.GET.get('page')\r\n try:\r\n users = paginator.page(page)\r\n except PageNotAnInteger:\r\n # return the first page\r\n page = 1\r\n users = paginator.page(page)\r\n except EmptyPage:\r\n # Page is out of range. Return last page\r\n page = paginator.num_pages\r\n contacts = paginator.page(page)\r\n\r\n user_info = [{'username': u.username,\r\n 'email': u.email,\r\n 'name': '{0} {1}'.format(u.first_name, u.last_name)}\r\n for u in users]\r\n\r\n return json_http_response({'success': True,\r\n 'page': page,\r\n 'num_pages': paginator.num_pages,\r\n 'users': user_info})","def user_home(request):\n # crop = Crop.objects.get(user=request.user)\n return render(request, 'user_home.html', locals())","def index():\n # return render_template('index.html', events=get_calendar_events_today(CALENDAR_URL))\n return render_template('index.html', events=get_calendar_events_limit(CALENDAR_URL), events_sorted=True)","def home(request):\n context = {\n 'tweets': Tweet.objects.all()\n }\n return render(request, 'index.html', context)","def index(request):\r\n return render(request, 'team_tasks_managers/index.html')","def index(request):\n\n # Generate counts of blog posts and blog authors\n\n num_blogs = Blog.objects.all().count()\n num_authors = BlogAuthor.objects.count()\n\n context = {\n 'num_blogs' : num_blogs,\n 'num_authors' : num_authors,\n }\n\n # Render the HTML template index.html with the data in the context variable\n return render(request, 'index.html', context = context)","def all_memberships(request):\n memberships = Membership.objects.all()\n context = {\n 'memberships': memberships,\n }\n return render(request, \"memberships.html\", context)","def user_home(request, user_name):\n query = User.objects.filter(username=user_name)\n if query.count() == 0:\n raise Http404(\"Can't find a user named: %s\" % user_name)\n else:\n user = query[0]\n if UserProfile.objects.filter(user=user):\n user_profile = UserProfile.objects.filter(user=user)[0]\n groups = get_user_groups(user)\n return render_to_response('user_home.html', locals())","def get(self):\n\n usrs = get_mapviewers(24)\n for usr in usrs:\n logging.info(\"Mapviewer: \" + usr.loginuser);\n\n template_values = {\n 'mapviewers': usrs,\n }\n\n logging.info(\"Showusers visited.\")\n template = JINJA_ENVIRONMENT.get_template('showusers.html')\n self.response.write(template.render(template_values))","def index(request):\n context = {'is_logged_in': request.user.is_authenticated}\n return render(request, 'sacms/index.html', context)","def home(request):\n\n swms = Swms.objects.all()\n\n context = {\n 'swms': swms,\n }\n\n return render(request, 'dashboard.html', context)","def get(self, request):\n cards = self.get_queryset().all()\n user = None\n auth = request.user.is_authenticated\n if auth:\n user = request.user\n return render(request, 'index/index.html', {\n 'cards': cards,\n 'user': user\n })","def home():\r\n\r\n page = 1\r\n per_page = current_app.config.get('APPS_PER_PAGE')\r\n if per_page is None: # pragma: no cover\r\n per_page = 5\r\n d = {'featured': cached_apps.get_featured_front_page(),\r\n 'top_apps': cached_apps.get_top(),\r\n 'top_users': None}\r\n\r\n # Get all the categories with apps\r\n categories = cached_cat.get_used()\r\n d['categories'] = categories\r\n d['categories_apps'] = {}\r\n for c in categories:\r\n tmp_apps, count = cached_apps.get(c['short_name'], page, per_page)\r\n d['categories_apps'][str(c['short_name'])] = tmp_apps\r\n\r\n # Add featured\r\n tmp_apps, count = cached_apps.get_featured('featured', page, per_page)\r\n if count > 0:\r\n featured = model.category.Category(name='Featured', short_name='featured')\r\n d['categories'].insert(0,featured)\r\n d['categories_apps']['featured'] = tmp_apps\r\n\r\n if current_app.config['ENFORCE_PRIVACY'] and current_user.is_authenticated():\r\n if current_user.admin:\r\n d['top_users'] = cached_users.get_top()\r\n if not current_app.config['ENFORCE_PRIVACY']:\r\n d['top_users'] = cached_users.get_top()\r\n return render_template('/home/index.html', **d)","def home(request):\n if not request.user.is_authenticated():\n soccer = Game.objects.filter(sport=Sport.objects.get(sport=\"soccer\"), active=\"true\")\n volleyball = Game.objects.filter(sport=Sport.objects.get(sport=\"volleyball\"), active=\"true\")\n baseball = Game.objects.filter(sport=Sport.objects.get(sport=\"baseball\"), active=\"true\")\n hockey = Game.objects.filter(sport=Sport.objects.get(sport=\"hockey\"), active=\"true\")\n basketball = Game.objects.filter(sport=Sport.objects.get(sport=\"basketball\"), active=\"true\")\n return render(request, 'index.html', {'soccer': soccer, 'hockey': hockey, 'basketball': basketball, 'baseball': baseball, 'volleyball': volleyball})\n\n if request.user.is_staff:\n return HttpResponseRedirect('/admin/')\n\n player = Player.objects.get(user=request.user)\n sports = player.sports.all()\n joined_games = player.game_set.all()\n my_games = Game.objects.filter(owner=request.user)\n profile_pic_url = player.image_url\n return render(request, 'profile.html', {'player': player, 'profile_pic_url': profile_pic_url, 'sports': sports, 'games': my_games | joined_games})","def show():\n return render_template(\n 'listUsers.html',\n title='List Users',\n message='These are the users in our system'\n )","def get_drip_campaigns(self):\n return list(DripCampaign.objects(user_id=self.user_id))","def index():\n\n class_entry_relations = title_context\n\n\n default_classes = sorted(class_entry_relations.keys())\n default_values = class_entry_relations[default_classes[0]]\n return render_template('index.html',\n all_classes=default_classes,\n all_entries=default_values,\n len = len(default_values)\n\n )","def index(request):\n\n\treturn render(request, 'index.html', {})\n\n\t# uncomment this line vvv and comment the above ^^^ line once we cut off scheduling\n\t#return render(request, 'cannot_schedule_anymore.html', {})","def _get_campaigns(self, params):\n return self._api.account.get_campaigns(params={**params, **self._state_filter()}, fields=[self.state_pk])","def index(request):\n\n # Generate counts of the main objects\n\n num_sales=Prodsale.objects.all().count()\n\n # Render the HTML template index.html with the data in the context variable\n\n return render(\n request, 'index.html',\n context={'num_sales':num_sales},\n )","def index():\n entertainment_news = get_sources('entertainment')\n fashion_news = get_sources('fashion')\n title = 'Vnews'\n return render_template('index.html', title=title, fashion=fashion_news, entertainment=entertainment_news)","def list_all(request):\n companies = Company.objects.order_by('-created')\n context = dict(companies=companies)\n return render(request, 'companies/all.html', context)","def overview(request):\n LOGGER.info('Rendering WMT16 HIT overview for user \"{0}\".'.format(\n request.user.username or \"Anonymous\"))\n \n # Re-initialise random number generator.\n seed(None)\n \n # Collect available language pairs for the current user.\n language_codes = set([x[0] for x in LANGUAGE_PAIR_CHOICES])\n language_pairs = request.user.groups.filter(name__in=language_codes)\n \n # Collect available annotation projects for the current user.\n annotation_projects = request.user.project_set.all()\n \n hit_data = []\n total = [0, 0, 0]\n\n for language_pair in language_pairs:\n for annotation_project in annotation_projects:\n hit = _compute_next_task_for_user(request.user, annotation_project, language_pair)\n user_status = HIT.compute_status_for_user(request.user, annotation_project, language_pair)\n for i in range(3):\n total[i] = total[i] + user_status[i]\n \n if hit:\n # Convert status seconds back into datetime.time instances.\n for i in range(2):\n user_status[i+1] = seconds_to_timedelta(int(user_status[i+1]))\n \n hit_data.append(\n (hit.get_language_pair_display(), hit.get_absolute_url(),\n hit.hit_id, user_status, annotation_project)\n )\n \n # Convert total seconds back into datetime.timedelta instances.\n total[1] = seconds_to_timedelta(int(total[2]) / float(int(total[0]) or 1))\n \n # Remove microseconds to get a nicer timedelta rendering in templates.\n total[1] = total[1] - timedelta(microseconds=total[1].microseconds)\n \n total[2] = seconds_to_timedelta(int(total[2]))\n \n groups = _identify_groups_for_user(request.user)\n group = None\n if len(groups) > 1:\n LOGGER.debug(u'User \"{0}\" assigned to multiple annotation groups: {1}'.format(\n request.user.username or u'Anonymous',\n u', '.join([x.name for x in groups]))\n )\n group = groups[0]\n \n if group is not None:\n group_name = group.name\n group_status = HIT.compute_status_for_group(group)\n for i in range(2):\n group_status[i+1] = seconds_to_timedelta(int(group_status[i+1]))\n \n else:\n group_status = None\n group_name = None\n \n LOGGER.debug(u'\\n\\nHIT data for user \"{0}\":\\n\\n{1}\\n'.format(\n request.user.username or \"Anonymous\",\n u'\\n'.join([u'{0}\\t{1}\\t{2}\\t{3}'.format(*x) for x in hit_data])))\n\n # Compute admin URL for super users.\n admin_url = None\n if request.user.is_superuser:\n admin_url = reverse('admin:index')\n \n dictionary = {\n 'active_page': \"OVERVIEW\",\n 'hit_data': hit_data,\n 'total': total,\n 'group_name': group_name,\n 'group_status': group_status,\n 'admin_url': admin_url,\n 'title': 'WMT16 Dashboard',\n 'annotation_groups': [x.name for x in groups],\n }\n dictionary.update(BASE_CONTEXT)\n \n LOGGER.info(dictionary.values())\n \n return render(request, 'wmt16/overview.html', dictionary)","def display_accounts(cls):\n return cls.account_list"],"string":"[\n \"def index(request): \\n \\n all_projects = models.Project.objects.all()\\n projects = get_objects_for_user(request.user, 'view_project', all_projects)\\n \\n fbads_settings = FacebookAdsSettings.objects.first()\\n return render_to_response('index.html',{\\n 'projects': projects, \\n 'fbads_settings': fbads_settings},\\n context_instance=RequestContext(request))\",\n \"def index(request):\\n\\n LOGGER.debug('socialprofile_demo.views.index')\\n\\n response_data = {}\\n\\n return render_to_response('index.html', response_data, context_instance=RequestContext(request))\",\n \"def index(request):\\n return render(request, 'commissioned_sites/index.html',\\n {'sites': CommissionedSite.objects.all().order_by('-date')},\\n context_instance=RequestContext(request))\",\n \"def index(page):\\r\\n per_page = 24\\r\\n count = cached_users.get_total_users()\\r\\n accounts = cached_users.get_users_page(page, per_page)\\r\\n if not accounts and page != 1:\\r\\n abort(404)\\r\\n pagination = Pagination(page, per_page, count)\\r\\n if current_user.is_authenticated():\\r\\n user_id = current_user.id\\r\\n else:\\r\\n user_id = 'anonymous'\\r\\n top_users = cached_users.get_leaderboard(current_app.config['LEADERBOARD'],\\r\\n user_id)\\r\\n return render_template('account/index.html', accounts=accounts,\\r\\n total=count,\\r\\n top_users=top_users,\\r\\n title=\\\"Community\\\", pagination=pagination)\",\n \"def index(request):\\n users = User.objects.filter(is_staff=False, is_active=True).order_by('username')\\n return render(request, 'users/view_all_users.html',\\n { 'users': users })\",\n \"def index():\\r\\n if current_user.is_authenticated():\\r\\n user_id = current_user.id\\r\\n else:\\r\\n user_id = 'anonymous'\\r\\n top_users = cached_users.get_leaderboard(current_app.config['LEADERBOARD'],\\r\\n user_id=user_id)\\r\\n\\r\\n return render_template('/stats/index.html', title=\\\"Community Leaderboard\\\",\\r\\n top_users=top_users)\",\n \"def index(request):\\n home_user = request.user.profile\\n \\\"\\\"\\\"num_activities = Activity.objects.count()\\\"\\\"\\\"\\n Cactivity = CompletedActivity.objects.filter(user=home_user)\\n UActivity = Cactivity.values('activity_id', 'activity__name', 'activity__value', 'activity__group').annotate \\\\\\n (count=Count('activity__name'), earned=Sum('activity__value'))\\n TimesCompelted = Cactivity.annotate(count=Count('activity__name'))\\n # Generate counts of some of the main objects\\n\\n context = {\\n 'huser': home_user,\\n 'Lname' : home_user.user.last_name,\\n 'Fname': home_user.user.first_name,\\n 'num_activities': 1,\\n 'activity_list' : UActivity,\\n \\\"times_completed\\\" : TimesCompelted\\n }\\n\\n # Render the HTML template index.html with the data in the context variable\\n return render(request, 'index.html', context=context)\",\n \"def index(request):\\n\\t# Generate counts of some of the main objects\\n\\tnum_customers = Customers.objects.all().count()\\n\\tnum_instructors = Instructors.objects.all().count()\\n\\tnum_membership_plans = MembershipPlans.objects.count() # The 'all()' is implied by default.\\n\\n\\tselectInstructors = SelectInstructors();\\n\\tjoinQuery = JoinQuery();\\n\\taggregationQuery = AggregationQuery();\\n\\tdivisionQuery = DivisionQuery();\\n\\tnestedAggregationQuery = NestedAggregationQuery();\\n\\tdeleteOperationCascade = DeleteOperationCascade();\\n\\tdeleteOperation = DeleteOperation();\\n\\tupdateNumberOfPeople = UpdateNumberOfPeople();\\n\\t# Render the HTML template index.html with the data in the context variable\\n\\treturn render(\\n\\t\\trequest,\\n\\t\\t'index.html',\\n\\t\\tcontext={'num_membership_plans':num_membership_plans,'num_instructors':num_instructors,'num_customers':num_customers,'select_instructors':selectInstructors,'join_query':joinQuery,'aggregation_query':aggregationQuery,'division_query':divisionQuery,'nested_aggregation_query':nestedAggregationQuery,'delete_operation_cascade':deleteOperationCascade, 'delete_operation': deleteOperation, 'update_number_of_people': updateNumberOfPeople},\\n\\t)\",\n \"def index():\\n user, user_id = get_user()\\n # Get this user's course with their roles\\n my_courses = []\\n if user:\\n my_courses = user.get_courses()\\n # Get all public courses\\n public_courses = Course.get_public()\\n\\n return render_template('courses/index.html',\\n user=user,\\n my_courses=my_courses,\\n public_courses=public_courses)\",\n \"def index(request):\\n params = get_user_profile_params(request)\\n\\n competition = Competition.get_active()\\n params['top_competition_id'] = competition.id\\n params['minify_js'] = settings.MINIFY_JS\\n\\n params['first_page_text'] = ''\\n config = Config.objects.all()\\n if config.count() > 0:\\n params['first_page_text'] = config[0].first_page_text\\n\\n #order email test\\n #order = Order.objects.get(pk=25)\\n #send_order_email(order.email, order, order.items.all)\\n\\n return render(request, 'base.html', params)\",\n \"def index(request, extra_context={}, user=AnonymousUser()):\\r\\n\\r\\n # The course selection work is done in courseware.courses.\\r\\n domain = settings.FEATURES.get('FORCE_UNIVERSITY_DOMAIN') # normally False\\r\\n # do explicit check, because domain=None is valid\\r\\n if domain is False:\\r\\n domain = request.META.get('HTTP_HOST')\\r\\n\\r\\n courses = get_courses(user, domain=domain)\\r\\n courses = sort_by_announcement(courses)\\r\\n\\r\\n context = {'courses': courses}\\r\\n\\r\\n context.update(extra_context)\\r\\n return render_to_response('index.html', context)\",\n \"def index(request):\\n if request.user.is_authenticated:\\n return redirect('/dashboard')\\n else:\\n context = {'client_id': settings.OPENHUMANS_CLIENT_ID,\\n 'oh_proj_page': settings.OH_ACTIVITY_PAGE}\\n\\n return render(request, 'main/index.html', context=context)\",\n \"def index():\\n user_list = Users.query.all()\\n return render_template('users/index.html'\\n ,user_list=user_list\\n ,t=t\\n ,m=m)\",\n \"def index(request):\\n # Generate counts of some of the main objects\\n num_orgs=Organization.objects.count()\\n num_contacts=Contact.objects.count()\\n # Get the number of Volunteers\\n num_volunteers=ContactTypeTag.objects.filter(tag_type__exact='vo').count()\\n num_projects=Project.objects.count() # The 'all()' is implied by default.\\n \\n # Render the HTML template index.html with the data in the context variable\\n return render(\\n request,\\n 'index.html',\\n context={\\n 'num_orgs':num_orgs,\\n 'num_contacts':num_contacts,\\n 'num_volunteers':num_volunteers,\\n 'num_projects':num_projects,\\n },\\n )\",\n \"def list_campaigns(self, **kwargs) -> ApiResponse:\\n return self._request(kwargs.pop('path'), params=kwargs)\",\n \"def index(request):\\n if request.user is None:\\n return view_all(request, index_call=True)\\n else:\\n return mine(request)\",\n \"def index(request):\\n\\n dests = Destination.objects.all()\\n\\n return render(request,'index.html',{'dests': dests})\",\n \"def my_index(request):\\n try:\\n denied = models.ParticipantStatus.objects.get(codename=models.ParticipantStatus.DENIED)\\n except:\\n denied = -1\\n\\n competitions_im_creator_of = Competition.objects.filter(creator=request.user).order_by('-pk').select_related(\\n 'creator').annotate(num_participants=Count('participants'))\\n competitions_im_admin_of = Competition.objects.exclude(pk__in=[c.pk for c in competitions_im_creator_of]).filter(\\n admins__in=[request.user]).order_by('-pk').select_related('creator').annotate(num_participants=Count('participants'))\\n my_competitions = list(competitions_im_creator_of) + list(competitions_im_admin_of)\\n\\n # Invalid select related previously\\n published_competitions = models.Competition.objects.filter(published=True).select_related('creator').annotate(num_participants=Count('participants'))\\n published_competitions = reversed(sorted(published_competitions, key=lambda c: c.get_start_date))\\n context_dict = {\\n 'my_competitions': my_competitions,\\n # Invalid select related previously\\n 'competitions_im_in': list(request.user.participation.all().exclude(status=denied)),\\n 'published_competitions': published_competitions,\\n }\\n return render(request, \\\"web/my/index.html\\\", context_dict)\",\n \"def contest_won_viewall(request):\\n is_loggedin, username = get_session_variables(request)\\n contest_list = Contest_won.objects.all()\\n\\n if contest_list:\\t\\n contest_participant_list = []\\n for contest_won_obj in contest_list:\\t\\n c_id = contest_won_obj.contest_id\\n c_p_objs = Contest_won_participant.objects. \\\\\\n filter(contest_id = c_id)\\n contest_participant_list.extend(c_p_objs)\\n\\n return render_to_response('achievement/contest_viewall.html', \\\\\\n {'is_loggedin':is_loggedin, \\\\\\n 'username':username, \\\\\\n 'contest_list':contest_list, \\\\\\n 'contest_participant_list':contest_participant_list}, \\\\\\n RequestContext(request))\\n else:\\n return render_to_response('achievement/noview.html', \\\\\\n {'is_loggedin':is_loggedin, \\\\\\n 'username':username, \\\\\\n 'type': 'Contest\\\\'s won'}, \\\\\\n RequestContext(request))\",\n \"def all_accounts(request):\\n accounts = Account.objects.all()\\n return render(request, 'app/home.html', {'accounts': accounts})\",\n \"def get(self):\\n query = Campaign.query\\n return paginate(Campaign.__tablename__, query, self.schema), HTTPStatus.OK\",\n \"def index(request):\\n\\n context = {'employees': User.objects.select_related('profile').filter(is_staff=True).order_by('first_name')}\\n return render(request, 'Employees/index.html', context)\",\n \"def all_users(request):\\n # order users by last name\\n users = UserProfile.objects.all().order_by('last_name')\\n return render(request, \\\"allusers.html\\\", {'users': users})\",\n \"def show_campaigns(request, utm_campaign, **kwargs):\\n \\n err_msg = ''\\n try:\\n err_msg = str(kwargs['kwargs']['err_msg'])\\n except:\\n pass\\n \\n test_type_override = ''\\n try:\\n test_type_override = MySQLdb._mysql.escape_string(request.POST['test_type_override'])\\n \\n if test_type_override == 'Banner':\\n test_type_var = FDH._TESTTYPE_BANNER_\\n elif test_type_override == 'Landing Page':\\n test_type_var = FDH._TESTTYPE_LP_\\n elif test_type_override == 'Banner and LP':\\n test_type_var = FDH._TESTTYPE_BANNER_LP_\\n \\n except:\\n test_type_var = ''\\n pass\\n \\n try:\\n \\\"\\\"\\\" Find the earliest and latest page views for a given campaign \\\"\\\"\\\"\\n lptl = DL.LandingPageTableLoader()\\n ccrml = DL.CiviCRMLoader()\\n \\n start_time = ccrml.get_earliest_donation(utm_campaign)\\n end_time = ccrml.get_latest_donation(utm_campaign)\\n \\n one_step = lptl.is_one_step(start_time, end_time, utm_campaign) \\n \\n if not(one_step): \\n start_time = lptl.get_earliest_campaign_view(utm_campaign)\\n end_time = lptl.get_latest_campaign_view(utm_campaign) \\n\\n interval = 1\\n \\n \\\"\\\"\\\" Create reporting object to retrieve campaign data and write plots to image repo on disk \\\"\\\"\\\"\\n ir = DR.IntervalReporting(was_run=False, use_labels=False, font_size=20, plot_type='line', query_type='campaign', file_path=projSet.__web_home__ + 'campaigns/static/images/')\\n \\n \\\"\\\"\\\" Produce analysis on the campaign view data \\\"\\\"\\\" \\n ir.run(start_time, end_time, interval, 'views', utm_campaign, {}, one_step=one_step)\\n \\n \\\"\\\"\\\" \\n ESTIMATE THE START AND END TIME OF THE CAMPAIGN\\n ===============================================\\n \\n Search for the first instance when more than 10 views are observed over a sampling period\\n \\\"\\\"\\\"\\n \\n col_names = ir._data_loader_.get_column_names()\\n \\n views_index = col_names.index('views')\\n ts_index = col_names.index('ts')\\n \\n row_list = list(ir._data_loader_._results_) # copy the query results\\n for row in row_list:\\n if row[views_index] > 100:\\n start_time_est = row[ts_index]\\n break\\n row_list.reverse()\\n for row in row_list:\\n if row[views_index] > 100:\\n end_time_est = row[ts_index]\\n break\\n \\n \\n \\\"\\\"\\\"\\n BUILD THE VISUALIZATION FOR THE TEST VIEWS OF THIS CAMAPAIGN\\n ============================================================ \\n \\\"\\\"\\\"\\n \\n \\\"\\\"\\\" Read the test name \\\"\\\"\\\"\\n ttl = DL.TestTableLoader()\\n row = ttl.get_test_row(utm_campaign)\\n test_name = ttl.get_test_field(row ,'test_name')\\n \\n \\\"\\\"\\\" Regenerate the data using the estimated start and end times \\\"\\\"\\\"\\n ir = DR.IntervalReporting(was_run=False, use_labels=False, font_size=20, plot_type='line', query_type='campaign', file_path=projSet.__web_home__ + 'campaigns/static/images/')\\n ir.run(start_time_est, end_time_est, interval, 'views', utm_campaign, {}, one_step=one_step)\\n \\n \\\"\\\"\\\" Determine the type of test (if not overridden) and retrieve the artifacts \\\"\\\"\\\"\\n test_type, artifact_name_list = FDH.get_test_type(utm_campaign, start_time, end_time, DL.CampaignReportingLoader(query_type=''), test_type_var)\\n \\n return render_to_response('campaigns/show_campaigns.html', {'utm_campaign' : utm_campaign, 'test_name' : test_name, 'start_time' : start_time_est, 'end_time' : end_time_est, 'one_step' : one_step, \\\\\\n 'artifacts' : artifact_name_list, 'test_type' : test_type, 'err_msg' : err_msg}, context_instance=RequestContext(request)) \\n\\n except Exception as inst:\\n \\n logging.error('Failed to correctly produce campaign diagnostics.')\\n logging.error(type(inst))\\n logging.error(inst.args)\\n logging.error(inst)\\n \\n \\\"\\\"\\\" Return to the index page with an error \\\"\\\"\\\"\\n err_msg = 'There is insufficient data to analyze this campaign: %s. Check to see if the <a href=\\\"/LML/\\\">impressions have been loaded</a>. <br><br>ERROR:<br><br>%s' % (utm_campaign, inst.__str__())\\n \\n return index(request, kwargs={'err_msg' : err_msg})\",\n \"def view(args):\\n if args.available:\\n printAvailableCampaigns()\\n if args.search_help:\\n print(getSearchQueryHelp())\",\n \"def get_list_of_campaigns(self, limit=0, offset=0):\\n logger.info(\\\"Function call: get_list_of_campaigns\\\")\\n return self.__handle_result(self.__send_request('campaigns', 'GET', {'limit': limit or 0, 'offset': offset or 0}))\",\n \"def index(request):\\n\\n chats = Chat.objects.all().order_by('-created_at')\\n\\n if request.user.is_authenticated():\\n chats = chats.filter(friend_groups__in=request.user.get_profile().\\\\\\n friend_groups.all().values_list('id'))\\n else:\\n chats = chats.filter(friend_groups__isnull=True)\\n\\n return render_to_response('index.html', {\\n 'chats': chats[:10],\\n }, context_instance=RequestContext(request))\",\n \"def dashboard(request):\\r\\n profile = get_object_or_404(Profile, user=request.user)\\r\\n wallet = Wallet.objects.get(user=request.user)\\r\\n history = History.objects.get(pk=1)\\r\\n referrals = Referral.objects.filter(referee=request.user).count()\\r\\n invoices = Invoice.objects.filter(issuer=request.user).count()\\r\\n return render(request, 'coin/dashboard.html', {'profile': profile, \\r\\n 'wallet': wallet, 'history': history, 'referrals': referrals, \\r\\n 'invoices': invoices})\",\n \"def my_dashboard(request):\\n #Get the associated contact for our user\\n user_con = request.user.contact\\n qs_proj_assoc, qs_task_assoc = get_tiered_upcoming(user_con)\\n\\n #Get the projects associated with the user\\n user_proj_table = table_proj.ProjectAssocAjaxTable(qs_proj_assoc)\\n #Get the tasks associated with the user\\n user_task_table = table_task.TaskAssocAjaxTable(qs_task_assoc)\\n\\n # Render the HTML template index.html with the data in the context variable\\n return render(\\n request,\\n 'my_dashboard.html',\\n context={\\n 'user_con':user_con,\\n 'user_proj_table':user_proj_table,\\n 'user_task_table':user_task_table,\\n 'project_source' : 'data-dashboard-project-upcoming',\\n 'task_source' : 'data-dashboard-task-upcoming',\\n 'input_id' : user_con.pk,\\n 'print_url':reverse_lazy('my-dashboard-print'),\\n },\\n )\",\n \"def test_admin_sms_campaign_view_list(self):\\n response = self.client.get('/admin/sms_module/smscampaign/')\\n self.failUnlessEqual(response.status_code, 200)\",\n \"def index(request):\\n posts = Post.objects.filter(status=1).order_by('-created_on')[:2]\\n\\n # Pre populate fields with profile information\\n if request.user.is_authenticated:\\n profile = UserProfile.objects.get(user=request.user)\\n form = ContactForm(initial={\\n 'contact_name': profile.default_full_name,\\n 'contact_email': profile.default_email,\\n })\\n else:\\n form = ContactForm()\\n\\n context = {\\n 'posts': posts,\\n 'form': form,\\n }\\n\\n return render(request, 'home/index.html', context)\",\n \"def index(request):\\n template_var = base_template_vals(request)\\n up = UserProfile.objects.filter(django_user=request.user)\\n template_var[\\\"likes\\\"] = Like.objects.filter(user=up[0])\\n \\n try:\\n event_list = Event.objects.all().order_by('id')\\n except Event.DoesNotExist:\\n raise Http404\\n output = ', '.join([e.title for e in event_list]) \\n template_var[\\\"events\\\"] = output\\t\\n return render_to_response(\\\"event/index.html\\\", template_var,\\n context_instance=RequestContext(request))\",\n \"def list_view(request):\\n campgrounds = Campground.objects.all()\\n return render(request, 'campgrounds.html')\",\n \"def index(request):\\n template = 'index.html'\\n hospitals = Hospital.objects.all()\\n return render_to_response(template, {'hospitals': hospitals}, context_instance=RequestContext(request))\",\n \"def index(request):\\n if _use_new_ui(request):\\n return _serve_new_ui(request)\\n\\n if request.user is None:\\n return view_all(request, index_call=True)\\n else:\\n return mine(request)\",\n \"def index():\\n try:\\n # Retrieve a list of active clients from the BancBox API for \\n # the right side bar.\\n active_clients = api.get_active_clients()\\n except Exception, e:\\n active_clients = []\\n logger.error('Error retrieving active clients: %s', e)\\n return render_template('index.html', active_clients=active_clients)\",\n \"def index():\\n if (session_get_int(\\\"user_id\\\") is not None):\\n return render_template(\\\"dashboard.html\\\")\\n else:\\n return render_template(\\\"index.html\\\")\",\n \"def index(request):\\n # TODO: Use django.views.generic.ListView\\n courses = Course.objects.order_by('-name')\\n context = {\\n 'courses': courses,\\n }\\n return render(request, 'hall_pass/index.html', context)\",\n \"def index(request):\\n user_data_list = UserData.objects.all().order_by('environment')\\n context = {'user_data_list': user_data_list}\\n\\n return render(request, 'index.html', context)\",\n \"def index(self):\\n\\n return render_template(\\n 'home_page/index.html',\\n **locals()\\n )\",\n \"def all_users():\\n\\n users = crud.get_users()\\n\\n return render_template('all_users.html', users=users)\",\n \"def index(self):\\n log.debug('index()')\\n return redirect_to('/admin/dashboard')\",\n \"def achieve_viewall(request):\\n is_loggedin, username = get_session_variables(request)\\n contrib_list = []\\n article_list = []\\n gsoc_list = []\\n speaker_list = []\\n intern_list = []\\n contest_participant_list = []\\n icpc_participants_regional_list = []\\n icpc_participants_final_list = []\\n\\n contrib_list_all = Contribution.objects.all()\\n contrib_list = Contribution.objects.all()[:5]\\n article_list = Article.objects.all()[:5]\\n gsoc_list = Gsoc.objects.all()[:5]\\n speaker_list = Speaker.objects.all()[:5]\\n intern_list = Intern.objects.all()[:5]\\n contest_list = Contest_won.objects.all()[:5]\\n\\n \\n contrib_org = {}\\n if contrib_list_all:\\n for contrib in contrib_list_all:\\n if contrib.org_name not in contrib_org.keys():\\n contrib_org[contrib.org_name] = 0\\n\\n for contrib in contrib_list:\\n contrib_org[contrib.org_name] += 1\\n\\n if contest_list:\\t\\n contest_participant_list = []\\n\\tfor contest_won_obj in contest_list:\\t\\n\\t c_id = contest_won_obj.contest_id\\n\\t c_p_objs = Contest_won_participant.objects.filter(contest_id = c_id)\\n\\t contest_participant_list.extend(c_p_objs)\\n \\n icpc_list_regionals = ACM_ICPC_detail.objects.filter(level='regional').order_by('ranking')[:2]\\n if icpc_list_regionals:\\n for icpc_obj in icpc_list_regionals:\\n team = icpc_obj.team_name\\n member1 = [icpc_obj.participant1_name, \\\\\\n get_username_from_email(icpc_obj.participant1_email)]\\n\\n member2 = [icpc_obj.participant2_name, \\\\\\n get_username_from_email(icpc_obj.participant2_email)]\\n\\n member3 = [icpc_obj.participant3_name, \\\\\\n get_username_from_email(icpc_obj.participant3_email)]\\n\\n icpc_participant_list = [icpc_obj, member1,member2,member3]\\n icpc_participants_regional_list.append(icpc_participant_list)\\n\\n icpc_list_finals = ACM_ICPC_detail.objects.filter(level='finals').order_by('ranking')[:2]\\n if icpc_list_finals:\\n for icpc_obj in icpc_list_finals:\\n team = icpc_obj.team_name\\n member1 = [icpc_obj.participant1_name, \\\\\\n get_username_from_email(icpc_obj.participant1_email)]\\n\\n member2 = [icpc_obj.participant2_name, \\\\\\n get_username_from_email(icpc_obj.participant2_email)]\\n\\n member3 = [icpc_obj.participant3_name, \\\\\\n get_username_from_email(icpc_obj.participant3_email)]\\n\\n icpc_participant_list = [icpc_obj, member1,member2,member3]\\n icpc_participants_final_list.append(icpc_participant_list)\\n\\n return render_to_response('achievement/achievement_viewall.html',\\\\\\n\\t\\t{'username':username, \\\\\\n 'is_loggedin':is_loggedin, \\\\\\n 'contrib_list':contrib_list, \\\\\\n 'contrib_org':contrib_org,\\\\\\n 'article_list':article_list, \\\\\\n 'gsoc_list':gsoc_list, \\\\\\n 'speaker_list':speaker_list, \\\\\\n 'intern_list':intern_list, \\\\\\n 'contest_list':contest_list, \\\\\\n 'contest_participant_list':contest_participant_list, \\\\\\n 'icpc_participants_final_list':icpc_participants_final_list, \\\\\\n 'icpc_participants_regional_list':icpc_participants_regional_list}, \\\\\\n RequestContext(request))\",\n \"def homepage(request):\\n limit = 7\\n featured_marketer_list = (\\n PimpUser.objects\\n .filter(featured=True)\\n .filter(usertype=PimpUser.MARKETER)\\n .order_by('-date_joined')[:limit]\\n )\\n featured_cause_list = (\\n PimpUser.objects\\n .filter(featured=True)\\n .filter(usertype=PimpUser.CAUSE)\\n .order_by('-date_joined')[:limit]\\n )\\n news_post_list = (\\n NewsPost.objects\\n .order_by('-created_at')[:3]\\n )\\n\\n context = {\\n 'featured_marketer_list': featured_marketer_list,\\n 'featured_cause_list': featured_cause_list,\\n 'news_post_list': news_post_list,\\n }\\n\\n return render(\\n request,\\n 'index.html',\\n context\\n )\",\n \"def get_homepage():\\n\\n list_of_students = hackbright.list_all_students()\\n list_of_projects = hackbright.list_all_projects()\\n\\n return render_template(\\\"index.html\\\",\\n list_of_students=list_of_students,\\n list_of_projects=list_of_projects)\",\n \"def index():\\n\\n if current_user.is_anonymous:\\n flash(\\\"Login to add, edit and delete items\\\", category='warning')\\n return render_template('index.html', title=\\\"index\\\")\\n else:\\n categories = Category.query.filter(\\n current_user.id == Category.user_id).all()\\n items = Item.query.filter(current_user.id == Item.user_id).all()\\n return render_template(\\n 'index.html',\\n title=\\\"index\\\",\\n categories=categories,\\n items=items,\\n category_id=None)\",\n \"def home_app():\\n users = User.query.order_by(User.last_name, User.first_name).all()\\n\\n return render_template('index.html', users=users)\",\n \"def index(request):\\n table = dynamodb.Table(table_name)\\n sis_account_id = request.LTI[\\\"custom_canvas_account_sis_id\\\"]\\n school_id = sis_account_id.split(\\\":\\\")[1]\\n school_key = f'SCHOOL#{school_id.upper()}'\\n query_params = {\\n 'KeyConditionExpression': Key('pk').eq(school_key),\\n 'ScanIndexForward': False,\\n }\\n logger.debug(f'Retrieving jobs for school {school_key}.')\\n jobs_for_school = table.query(**query_params)['Items']\\n\\n # Update created_at (ISO8601) string timestamp to datetime.\\n [item.update(created_at=parse_datetime(item['created_at']))\\n for item in jobs_for_school]\\n\\n context = {\\n 'jobs_for_school': jobs_for_school\\n }\\n logger.debug(f'Retrieved jobs for school {school_key}.', extra=context)\\n return render(request, \\\"bulk_site_creator/index.html\\\", context=context)\",\n \"def index(request):\\n # # Generate counts of some of the main objects\\n # class_iter = Course.objects.all()\\n # num_instances = BookInstance.objects.all().count()\\n # # Available books (status = 'a')\\n # num_instances_available = BookInstance.objects.filter(status__exact='a').count()\\n # num_authors = Author.objects.count() # The 'all()' is implied by default.\\n\\n # Render the HTML template index.html with the data in the context variable\\n cr=Course.objects.filter(ta={Ta.full_name})\\n context = dict()\\n # for item in class_iter:\\n # context[str(item)] = item.cname\\n\\n return render(\\n request,\\n 'index.html',\\n # context={'num_books': num_books, 'num_instances': num_instances,\\n # 'num_instances_available': num_instances_available, 'num_authors': num_authors},\\n context,\\n )\",\n \"def icpc_viewall(request):\\n is_loggedin, username = get_session_variables(request)\\n icpc_participants_list = []\\n p_list= []\\n icpc_list = ACM_ICPC_detail.objects.all().order_by('ranking')\\n if icpc_list:\\n\\n for icpc_obj in icpc_list:\\n \\n team = icpc_obj.team_name\\n member1 = [icpc_obj.participant1_name, \\\\\\n get_username_from_email(icpc_obj.participant1_email)]\\n\\n member2 = [icpc_obj.participant2_name, \\\\\\n get_username_from_email(icpc_obj.participant2_email)]\\n\\n member3 = [icpc_obj.participant3_name, \\\\\\n get_username_from_email(icpc_obj.participant3_email)]\\n\\n icpc_participant_list = [icpc_obj, member1,member2,member3]\\n icpc_participants_list.append(icpc_participant_list)\\n \\n return render_to_response('achievement/icpc_viewall.html', \\\\\\n {'is_loggedin':logged_in(request), \\\\\\n 'username':username, \\\\\\n 'icpc_list':icpc_list,\\\\\\n 'icpc_participants_list':icpc_participants_list}, RequestContext(request))\\n\\n else:\\n return render_to_response('achievement/noview.html', \\\\\\n {'is_loggedin':logged_in(request), \\\\\\n 'username':username, \\\\\\n 'type': 'ACM ICPC Contest'}, \\\\\\n RequestContext(request))\",\n \"def base_dashboard(request):\\n appointments = None\\n\\n if request.user.userprofile.is_patient():\\n appointments = Appointment.objects.filter(patient=request.user.id).order_by('date')\\n elif request.user.userprofile.is_doctor():\\n appointments = Appointment.objects.filter(doctor=request.user.id).order_by('date')\\n else:\\n appointments = Appointment.objects.all().order_by('date')\\n\\n return render(request, 'base_dashboard.html', {'appointments': appointments, 'the_user': request.user})\",\n \"def display_users(cls):\\n return cls.user_list\",\n \"def dashboard():\\n # TODO: Optionally, old proposals should be shown in a read-only mode.\\n talks = Talk.query.current.filter(Talk.user == current_user)\\n return render_template(\\n 'profile/dashboard.html', talks=talks)\",\n \"def index(request):\\n\\n # Generate counts of some of the main objects\\n num_blogs = Blog.objects.all().count()\\n num_authors = BlogAuthor.objects.count()\\n num_comments = BlogComment.objects.count()\\n\\n context = {\\n 'num_blogs': num_blogs,\\n 'num_authors': num_authors,\\n 'num_comments': num_comments,\\n }\\n\\n # Render the HTML template index.html with the data in the context variable\\n return render(request, 'index.html', context=context)\",\n \"def index(request):\\n # Generate counts of some of the main objects\\n num_inventions = Invention.objects.all().count()\\n inventions = Invention.objects.order_by('-date_of_invention')\\n\\n inventions_to_random = list(Invention.objects.all())\\n random_invention = random.choice(inventions_to_random)\\n\\n context = {\\n 'num_inventions': num_inventions,\\n 'inventions': inventions,\\n 'random_invention': random_invention\\n }\\n\\n # Render the HTML template index.html with the data in the context variable\\n return render(request, 'index.html', context=context)\",\n \"def index(request):\\n return render(request, \\\"county/index.html\\\")\",\n \"def show_users():\\n\\n user = User(connection=connection, cursor=cursor)\\n\\n all_users = user.get_all_users()\\n\\n context = {\\n 'all_users': all_users\\n }\\n\\n return render_template('pages/tables/users.html', **context)\",\n \"def index(request):\\n\\tusuario = request.user\\n\\ttemplate = 'customerbuy/index.html'\\n\\treturn render_to_response(template,{'usuario': usuario},context_instance=RequestContext(request))\",\n \"def index(request):\\n if request.user.is_authenticated:\\n return HttpResponseRedirect(reverse('surveys-dashboard'))\\n\\n context = {}\\n\\n # Render the HTML template index.html with the data in the context variable\\n return render(request, 'index.html', context=context)\",\n \"def list_users():\\n\\n db_users = User.query.all()\\n\\n return render_template(\\\"list_users.html\\\", headline=\\\"Blogly Users\\\", users=db_users)\",\n \"def index(request):\\n warnings.warn(\\n \\\"icekit_events.views.index is deprecated and will disappear in a \\\"\\n \\\"future version. If you need this code, copy it into your project.\\\"\\n , DeprecationWarning\\n )\\n\\n occurrences = models.Occurrence.objects.visible()\\n context = {\\n 'occurrences': occurrences,\\n }\\n return TemplateResponse(request, 'icekit_events/index.html', context)\",\n \"def index(request):\\n num_blogs = Blog.objects.all().count()\\n num_authors = BlogAuthor.objects.all().count()\\n num_unique_authors = Blog.objects.distinct().count()\\n num_comments = Comment.objects.all().count()\\n return render(request, 'index.html', context={'num_blogs' : num_blogs, 'num_authors' : num_authors,\\n 'num_unique_authors' : num_unique_authors, 'num_comments' : num_comments})\",\n \"def index(self):\\n\\n\\t\\tself.db = DB()\\n\\t\\tactivityTuple = self.db.select_all_from(\\\"activity\\\")[1]\\n\\t\\ttmpl = lookup.get_template(\\\"index.html\\\")\\n\\t\\treturn (tmpl.render(activity=activityTuple))\",\n \"def get(self, request):\\n context = {}\\n if request.user.is_authenticated:\\n instagram_accounts = InstagramAccount.objects.filter(user_id=request.user.pk)\\n context['instagram_accounts'] = instagram_accounts\\n return render(request, 'home.html', context)\",\n \"def intern_viewall(request):\\n is_loggedin, username = get_session_variables(request)\\n intern_list = Intern.objects.all()\\n\\n if intern_list:\\n return render_to_response('achievement/intern_viewall.html', \\\\\\n {'is_loggedin':is_loggedin, \\\\\\n 'username':username, \\\\\\n 'intern_list':intern_list}, \\\\\\n RequestContext(request))\\n else:\\n return render_to_response('achievement/noview.html', \\\\\\n {'is_loggedin':is_loggedin, \\\\\\n 'username':username, \\\\\\n 'type': 'Internship'}, \\\\\\n RequestContext(request))\",\n \"def index(self, page=1):\\n users_obj = User.query.paginate(page)\\n return render_template('item/list.html', items=users_obj)\",\n \"def users_page(request):\",\n \"def user(self):\\n try:\\n data_definitions = self.get_data_definitions(current_user.scheme_id)\\n user_data = self.get_all_user_data(current_user.scheme_id, current_user.k_number)\\n\\n return render_template(\\\"user/dashboard_page.html\\\", title=\\\"Your Profile\\\", user_data=user_data)\\n\\n except Exception as e:\\n self._log.exception(\\\"Could not execute get user logic\\\")\\n return abort(500)\",\n \"def index(request):\\n cat_filter = request.GET.get('category_filter')\\n context = {\\\"cat_filter\\\": cat_filter,\\n \\\"gifs_with_cats\\\": GifToUser.get_user_gifs_for_category(\\n request.user, cat_filter=cat_filter),\\n \\\"all_cats\\\": GifToUserCategory.get_user_categories(request.user)}\\n template = loader.get_template('gifs/index.html')\\n return HttpResponse(template.render(context, request))\",\n \"def list_users():\\n users = User.query.order_by(User.last_name, User.first_name).all()\\n return render_template('index.html', users=users)\",\n \"def index(request):\\n # Generate counts of some of the main objects\\n projects = Project.objects.all()\\n projects = projects[0:4]\\n press = Press.objects.all().count()\\n # Available books (status = 'a')\\n # num_instances_available=BookInstance.objects.filter(status__exact='a').count()\\n # num_authors=Author.objects.count() # The 'all()' is implied by default.\\n\\n # Render the HTML template index.html with the data in the context variable\\n\\n all_services = Service.objects.all()\\n services = all_services[0:4]\\n\\n return render(\\n request,\\n 'index.html',\\n context={'projects': projects, 'press': press, 'services': services})\",\n \"def display_homepage(user_id):\\n\\n user_inv = (UserInv.query.filter_by(user_id=user_id)).all()\\n\\n return render_template('user-homepage.html',\\n user_inv=user_inv)\",\n \"def index(request):\\n\\treturn render(request, 'Toeic/index.html')\",\n \"def index(request):\\r\\n assert isinstance(request, HttpRequest)\\r\\n return render(\\r\\n request,\\r\\n 'app/site/indexSite.html',\\r\\n context_instance=RequestContext(request,\\r\\n {\\r\\n 'title': 'Colmeia | Início',\\r\\n 'year': datetime.now().year,\\r\\n })\\r\\n )\",\n \"def gsoc_viewall(request):\\n is_loggedin, username = get_session_variables(request)\\n gsoc_list = Gsoc.objects.all()\\n\\n if gsoc_list:\\n return render_to_response('achievement/gsoc_viewall.html', \\\\\\n {'is_loggedin':is_loggedin, \\\\\\n 'username':username, \\\\\\n 'gsoc_list':gsoc_list}, \\\\\\n RequestContext(request))\\n else:\\n return render_to_response('achievement/noview.html', \\\\\\n {'is_loggedin':is_loggedin, \\\\\\n 'username':username, \\\\\\n 'type': 'Gsoc'}, \\\\\\n RequestContext(request))\",\n \"def index_view(self) -> str:\\n return render_template(\\n \\\"index.html\\\",\\n challenge_groups=self._challenge_groups,\\n ctff=current_app,\\n )\",\n \"def users_in_cohort(request, course_key, cohort_id):\\r\\n # this is a string when we get it here\\r\\n course_key = SlashSeparatedCourseKey.from_deprecated_string(course_key)\\r\\n\\r\\n get_course_with_access(request.user, 'staff', course_key)\\r\\n\\r\\n # this will error if called with a non-int cohort_id. That's ok--it\\r\\n # shoudn't happen for valid clients.\\r\\n cohort = cohorts.get_cohort_by_id(course_key, int(cohort_id))\\r\\n\\r\\n paginator = Paginator(cohort.users.all(), 100)\\r\\n page = request.GET.get('page')\\r\\n try:\\r\\n users = paginator.page(page)\\r\\n except PageNotAnInteger:\\r\\n # return the first page\\r\\n page = 1\\r\\n users = paginator.page(page)\\r\\n except EmptyPage:\\r\\n # Page is out of range. Return last page\\r\\n page = paginator.num_pages\\r\\n contacts = paginator.page(page)\\r\\n\\r\\n user_info = [{'username': u.username,\\r\\n 'email': u.email,\\r\\n 'name': '{0} {1}'.format(u.first_name, u.last_name)}\\r\\n for u in users]\\r\\n\\r\\n return json_http_response({'success': True,\\r\\n 'page': page,\\r\\n 'num_pages': paginator.num_pages,\\r\\n 'users': user_info})\",\n \"def user_home(request):\\n # crop = Crop.objects.get(user=request.user)\\n return render(request, 'user_home.html', locals())\",\n \"def index():\\n # return render_template('index.html', events=get_calendar_events_today(CALENDAR_URL))\\n return render_template('index.html', events=get_calendar_events_limit(CALENDAR_URL), events_sorted=True)\",\n \"def home(request):\\n context = {\\n 'tweets': Tweet.objects.all()\\n }\\n return render(request, 'index.html', context)\",\n \"def index(request):\\r\\n return render(request, 'team_tasks_managers/index.html')\",\n \"def index(request):\\n\\n # Generate counts of blog posts and blog authors\\n\\n num_blogs = Blog.objects.all().count()\\n num_authors = BlogAuthor.objects.count()\\n\\n context = {\\n 'num_blogs' : num_blogs,\\n 'num_authors' : num_authors,\\n }\\n\\n # Render the HTML template index.html with the data in the context variable\\n return render(request, 'index.html', context = context)\",\n \"def all_memberships(request):\\n memberships = Membership.objects.all()\\n context = {\\n 'memberships': memberships,\\n }\\n return render(request, \\\"memberships.html\\\", context)\",\n \"def user_home(request, user_name):\\n query = User.objects.filter(username=user_name)\\n if query.count() == 0:\\n raise Http404(\\\"Can't find a user named: %s\\\" % user_name)\\n else:\\n user = query[0]\\n if UserProfile.objects.filter(user=user):\\n user_profile = UserProfile.objects.filter(user=user)[0]\\n groups = get_user_groups(user)\\n return render_to_response('user_home.html', locals())\",\n \"def get(self):\\n\\n usrs = get_mapviewers(24)\\n for usr in usrs:\\n logging.info(\\\"Mapviewer: \\\" + usr.loginuser);\\n\\n template_values = {\\n 'mapviewers': usrs,\\n }\\n\\n logging.info(\\\"Showusers visited.\\\")\\n template = JINJA_ENVIRONMENT.get_template('showusers.html')\\n self.response.write(template.render(template_values))\",\n \"def index(request):\\n context = {'is_logged_in': request.user.is_authenticated}\\n return render(request, 'sacms/index.html', context)\",\n \"def home(request):\\n\\n swms = Swms.objects.all()\\n\\n context = {\\n 'swms': swms,\\n }\\n\\n return render(request, 'dashboard.html', context)\",\n \"def get(self, request):\\n cards = self.get_queryset().all()\\n user = None\\n auth = request.user.is_authenticated\\n if auth:\\n user = request.user\\n return render(request, 'index/index.html', {\\n 'cards': cards,\\n 'user': user\\n })\",\n \"def home():\\r\\n\\r\\n page = 1\\r\\n per_page = current_app.config.get('APPS_PER_PAGE')\\r\\n if per_page is None: # pragma: no cover\\r\\n per_page = 5\\r\\n d = {'featured': cached_apps.get_featured_front_page(),\\r\\n 'top_apps': cached_apps.get_top(),\\r\\n 'top_users': None}\\r\\n\\r\\n # Get all the categories with apps\\r\\n categories = cached_cat.get_used()\\r\\n d['categories'] = categories\\r\\n d['categories_apps'] = {}\\r\\n for c in categories:\\r\\n tmp_apps, count = cached_apps.get(c['short_name'], page, per_page)\\r\\n d['categories_apps'][str(c['short_name'])] = tmp_apps\\r\\n\\r\\n # Add featured\\r\\n tmp_apps, count = cached_apps.get_featured('featured', page, per_page)\\r\\n if count > 0:\\r\\n featured = model.category.Category(name='Featured', short_name='featured')\\r\\n d['categories'].insert(0,featured)\\r\\n d['categories_apps']['featured'] = tmp_apps\\r\\n\\r\\n if current_app.config['ENFORCE_PRIVACY'] and current_user.is_authenticated():\\r\\n if current_user.admin:\\r\\n d['top_users'] = cached_users.get_top()\\r\\n if not current_app.config['ENFORCE_PRIVACY']:\\r\\n d['top_users'] = cached_users.get_top()\\r\\n return render_template('/home/index.html', **d)\",\n \"def home(request):\\n if not request.user.is_authenticated():\\n soccer = Game.objects.filter(sport=Sport.objects.get(sport=\\\"soccer\\\"), active=\\\"true\\\")\\n volleyball = Game.objects.filter(sport=Sport.objects.get(sport=\\\"volleyball\\\"), active=\\\"true\\\")\\n baseball = Game.objects.filter(sport=Sport.objects.get(sport=\\\"baseball\\\"), active=\\\"true\\\")\\n hockey = Game.objects.filter(sport=Sport.objects.get(sport=\\\"hockey\\\"), active=\\\"true\\\")\\n basketball = Game.objects.filter(sport=Sport.objects.get(sport=\\\"basketball\\\"), active=\\\"true\\\")\\n return render(request, 'index.html', {'soccer': soccer, 'hockey': hockey, 'basketball': basketball, 'baseball': baseball, 'volleyball': volleyball})\\n\\n if request.user.is_staff:\\n return HttpResponseRedirect('/admin/')\\n\\n player = Player.objects.get(user=request.user)\\n sports = player.sports.all()\\n joined_games = player.game_set.all()\\n my_games = Game.objects.filter(owner=request.user)\\n profile_pic_url = player.image_url\\n return render(request, 'profile.html', {'player': player, 'profile_pic_url': profile_pic_url, 'sports': sports, 'games': my_games | joined_games})\",\n \"def show():\\n return render_template(\\n 'listUsers.html',\\n title='List Users',\\n message='These are the users in our system'\\n )\",\n \"def get_drip_campaigns(self):\\n return list(DripCampaign.objects(user_id=self.user_id))\",\n \"def index():\\n\\n class_entry_relations = title_context\\n\\n\\n default_classes = sorted(class_entry_relations.keys())\\n default_values = class_entry_relations[default_classes[0]]\\n return render_template('index.html',\\n all_classes=default_classes,\\n all_entries=default_values,\\n len = len(default_values)\\n\\n )\",\n \"def index(request):\\n\\n\\treturn render(request, 'index.html', {})\\n\\n\\t# uncomment this line vvv and comment the above ^^^ line once we cut off scheduling\\n\\t#return render(request, 'cannot_schedule_anymore.html', {})\",\n \"def _get_campaigns(self, params):\\n return self._api.account.get_campaigns(params={**params, **self._state_filter()}, fields=[self.state_pk])\",\n \"def index(request):\\n\\n # Generate counts of the main objects\\n\\n num_sales=Prodsale.objects.all().count()\\n\\n # Render the HTML template index.html with the data in the context variable\\n\\n return render(\\n request, 'index.html',\\n context={'num_sales':num_sales},\\n )\",\n \"def index():\\n entertainment_news = get_sources('entertainment')\\n fashion_news = get_sources('fashion')\\n title = 'Vnews'\\n return render_template('index.html', title=title, fashion=fashion_news, entertainment=entertainment_news)\",\n \"def list_all(request):\\n companies = Company.objects.order_by('-created')\\n context = dict(companies=companies)\\n return render(request, 'companies/all.html', context)\",\n \"def overview(request):\\n LOGGER.info('Rendering WMT16 HIT overview for user \\\"{0}\\\".'.format(\\n request.user.username or \\\"Anonymous\\\"))\\n \\n # Re-initialise random number generator.\\n seed(None)\\n \\n # Collect available language pairs for the current user.\\n language_codes = set([x[0] for x in LANGUAGE_PAIR_CHOICES])\\n language_pairs = request.user.groups.filter(name__in=language_codes)\\n \\n # Collect available annotation projects for the current user.\\n annotation_projects = request.user.project_set.all()\\n \\n hit_data = []\\n total = [0, 0, 0]\\n\\n for language_pair in language_pairs:\\n for annotation_project in annotation_projects:\\n hit = _compute_next_task_for_user(request.user, annotation_project, language_pair)\\n user_status = HIT.compute_status_for_user(request.user, annotation_project, language_pair)\\n for i in range(3):\\n total[i] = total[i] + user_status[i]\\n \\n if hit:\\n # Convert status seconds back into datetime.time instances.\\n for i in range(2):\\n user_status[i+1] = seconds_to_timedelta(int(user_status[i+1]))\\n \\n hit_data.append(\\n (hit.get_language_pair_display(), hit.get_absolute_url(),\\n hit.hit_id, user_status, annotation_project)\\n )\\n \\n # Convert total seconds back into datetime.timedelta instances.\\n total[1] = seconds_to_timedelta(int(total[2]) / float(int(total[0]) or 1))\\n \\n # Remove microseconds to get a nicer timedelta rendering in templates.\\n total[1] = total[1] - timedelta(microseconds=total[1].microseconds)\\n \\n total[2] = seconds_to_timedelta(int(total[2]))\\n \\n groups = _identify_groups_for_user(request.user)\\n group = None\\n if len(groups) > 1:\\n LOGGER.debug(u'User \\\"{0}\\\" assigned to multiple annotation groups: {1}'.format(\\n request.user.username or u'Anonymous',\\n u', '.join([x.name for x in groups]))\\n )\\n group = groups[0]\\n \\n if group is not None:\\n group_name = group.name\\n group_status = HIT.compute_status_for_group(group)\\n for i in range(2):\\n group_status[i+1] = seconds_to_timedelta(int(group_status[i+1]))\\n \\n else:\\n group_status = None\\n group_name = None\\n \\n LOGGER.debug(u'\\\\n\\\\nHIT data for user \\\"{0}\\\":\\\\n\\\\n{1}\\\\n'.format(\\n request.user.username or \\\"Anonymous\\\",\\n u'\\\\n'.join([u'{0}\\\\t{1}\\\\t{2}\\\\t{3}'.format(*x) for x in hit_data])))\\n\\n # Compute admin URL for super users.\\n admin_url = None\\n if request.user.is_superuser:\\n admin_url = reverse('admin:index')\\n \\n dictionary = {\\n 'active_page': \\\"OVERVIEW\\\",\\n 'hit_data': hit_data,\\n 'total': total,\\n 'group_name': group_name,\\n 'group_status': group_status,\\n 'admin_url': admin_url,\\n 'title': 'WMT16 Dashboard',\\n 'annotation_groups': [x.name for x in groups],\\n }\\n dictionary.update(BASE_CONTEXT)\\n \\n LOGGER.info(dictionary.values())\\n \\n return render(request, 'wmt16/overview.html', dictionary)\",\n \"def display_accounts(cls):\\n return cls.account_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6278449","0.5947191","0.57573825","0.57182586","0.5707867","0.5703257","0.56390655","0.5605963","0.55317235","0.5515906","0.5514333","0.5508371","0.54833335","0.5471401","0.5455781","0.54364294","0.5406502","0.5397928","0.53924406","0.53866136","0.5347947","0.5315827","0.5313521","0.52813923","0.5277998","0.5271437","0.5270981","0.52542007","0.5239706","0.52305603","0.5220847","0.5212447","0.5202224","0.5152002","0.5130391","0.5114246","0.5110644","0.51042706","0.5078861","0.50786954","0.50684065","0.50637984","0.5060998","0.5036714","0.50347584","0.5017168","0.5016778","0.5013453","0.5012359","0.50019675","0.50016207","0.4991074","0.49908188","0.4982552","0.49672452","0.49614766","0.4960523","0.49542","0.4951789","0.49457088","0.49293897","0.49247098","0.4924053","0.49173525","0.491699","0.49165308","0.49144363","0.49106506","0.4905267","0.49042198","0.4901741","0.48987973","0.48952028","0.4895117","0.48945037","0.48913905","0.48898765","0.48866144","0.4884839","0.4883926","0.4881192","0.48805594","0.487919","0.48687667","0.4864542","0.48612395","0.48556048","0.48529562","0.48457542","0.48424256","0.4840113","0.48388907","0.4833237","0.48323575","0.48300847","0.4827285","0.4827236","0.4824291","0.48181108","0.4805671"],"string":"[\n \"0.6278449\",\n \"0.5947191\",\n \"0.57573825\",\n \"0.57182586\",\n \"0.5707867\",\n \"0.5703257\",\n \"0.56390655\",\n \"0.5605963\",\n \"0.55317235\",\n \"0.5515906\",\n \"0.5514333\",\n \"0.5508371\",\n \"0.54833335\",\n \"0.5471401\",\n \"0.5455781\",\n \"0.54364294\",\n \"0.5406502\",\n \"0.5397928\",\n \"0.53924406\",\n \"0.53866136\",\n \"0.5347947\",\n \"0.5315827\",\n \"0.5313521\",\n \"0.52813923\",\n \"0.5277998\",\n \"0.5271437\",\n \"0.5270981\",\n \"0.52542007\",\n \"0.5239706\",\n \"0.52305603\",\n \"0.5220847\",\n \"0.5212447\",\n \"0.5202224\",\n \"0.5152002\",\n \"0.5130391\",\n \"0.5114246\",\n \"0.5110644\",\n \"0.51042706\",\n \"0.5078861\",\n \"0.50786954\",\n \"0.50684065\",\n \"0.50637984\",\n \"0.5060998\",\n \"0.5036714\",\n \"0.50347584\",\n \"0.5017168\",\n \"0.5016778\",\n \"0.5013453\",\n \"0.5012359\",\n \"0.50019675\",\n \"0.50016207\",\n \"0.4991074\",\n \"0.49908188\",\n \"0.4982552\",\n \"0.49672452\",\n \"0.49614766\",\n \"0.4960523\",\n \"0.49542\",\n \"0.4951789\",\n \"0.49457088\",\n \"0.49293897\",\n \"0.49247098\",\n \"0.4924053\",\n \"0.49173525\",\n \"0.491699\",\n \"0.49165308\",\n \"0.49144363\",\n \"0.49106506\",\n \"0.4905267\",\n \"0.49042198\",\n \"0.4901741\",\n \"0.48987973\",\n \"0.48952028\",\n \"0.4895117\",\n \"0.48945037\",\n \"0.48913905\",\n \"0.48898765\",\n \"0.48866144\",\n \"0.4884839\",\n \"0.4883926\",\n \"0.4881192\",\n \"0.48805594\",\n \"0.487919\",\n \"0.48687667\",\n \"0.4864542\",\n \"0.48612395\",\n \"0.48556048\",\n \"0.48529562\",\n \"0.48457542\",\n \"0.48424256\",\n \"0.4840113\",\n \"0.48388907\",\n \"0.4833237\",\n \"0.48323575\",\n \"0.48300847\",\n \"0.4827285\",\n \"0.4827236\",\n \"0.4824291\",\n \"0.48181108\",\n \"0.4805671\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6828237"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8990,"cells":{"query":{"kind":"string","value":"The logout view. Redirects to home page after."},"document":{"kind":"string","value":"def logout(request):\n if request.user.is_authenticated():\n auth_logout(request)\n return HttpResponseRedirect(reverse(\"voter_validation:index\"))"},"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 logout_view(request):\n logout(request)\n return redirect('home')","def logout_view(request):\n auth_logout(request)\n return redirect('home')","def logout_view(request):\n \n logout(request)\n return HttpResponseRedirect(reverse(\"index\"))","def logout_view(request):\n logout(request)\n return HttpResponseRedirect(reverse(\"index\"))","def logout():\n logout_user()\n return redirect(url_for('default.home'))","def logout_view(request):\n logout(request)\n return redirect('/')","def logout_view(request):\n logout(request)\n return redirect('/')","def logout_view(request):\n\n if request.user.is_authenticated:\n logout(request)\n\n return redirect(reverse('index_view'))","def GET_logout(self):\r\n self.logout()\r\n return self.redirect('/')","def logout_page(request):\n logout(request)\n return redirect('/')","def logoutPage(request):\n\n logout(request)\n return redirect('index')","def logout():\n logout_user()\n return redirect(url_for('home'))","def logout_view(request):\n logout(request)\n return redirect('login')","def logout_view(request):\n logout(request)\n return redirect('login')","def logout(request):\n auth.logout(request)\n return redirect('index')","def logout_view(request):\n\n\tlogout(request)\n\treturn HttpResponseRedirect('login')","def logoutView(request):\n logout(request)\n return redirect('/login')","def logout():\n do_logout()\n return redirect('/login')","def logout():\n session_logout()\n return redirect(url_for(\"home\"))","def logout_view(request):\n\n logout(request)\n return redirect('/login')","def logout_view(request):\n\n logout(request)\n return redirect('/user/login/')","def logout_redirect():\n login_session.clear()\n flash('You have logged out')\n return redirect(url_for('show_homepage'))","def logout_view(request):\n logout(request)\n return HttpResponseRedirect('/')","def logout_view(request):\n logout(request)\n return HttpResponseRedirect('/')","def logout_view(request):\n logout(request)\n return HttpResponseRedirect(reverse('dashboard:login'))","def logout_view(request):\n logout(request) # Logout request user\n messages.info(request, \"You have logged out successfully.\", fail_silently=False)\n return redirect(\"showLoginPage\")","def logout():\n session.pop('logged_in', None)\n return redirect(url_for('home'))","def logout():\n logout_user()\n return redirect(\"/\")","def logout_page(request):\n logout(request)\n return HttpResponseRedirect('/')","def logout(request):\n alogout(request)\n \n return HttpResponseRedirect(\"/\")","def auth_logout(request):\n logout(request)\n return HttpResponseRedirect( reverse('startpage') )","def logout(request):\n\tlogoutt(request)\n\treturn redirect(\"firstpage\")","def logout():\r\n logout_user()\r\n flash('You were logged out.')\r\n return redirect(url_for('index'))","def logout():\n session.clear()\n return redirect(url_for('index'))","def logout():\n logout_user()\n return redirect(url_for('index'))","def logout():\n logout_user()\n return redirect(url_for('index'))","def logout():\n logout_user()\n return redirect(url_for('main.index'))","def account_logout(request):\n logout(request)\n return redirect('/')","def logout(request):\n auth.logout(request)\n return redirect(settings.SITE_URL)","def logout():\n session.clear()\n return redirect(url_for(\"home\"))","def logout():\n logout_user()\n return redirect(url_for('auth.index'))","def logout():\n session.clear()\n return redirect(url_for('home'))","def logout(request):\n auth.logout(request)\n messages.success(request, 'You are logged out!')\n return redirect(reverse('index'))","def logout(request):\n auth.logout(request)\n messages.success(request, 'You have successfully been logged out.')\n return redirect(reverse('index'))","def logout(request):\n auth.logout(request)\n messages.success(request, \"You have successfully been logged out.\")\n return redirect(reverse('index'))","def logout(self):\n\n # remove session\n session.delete()\n\n return render('login.html')","def logout(request):\n auth.logout(request)\n messages.success(request, \"You have successfully been logged out!\",\n extra_tags=\"alert-success\")\n return redirect(reverse('index'))","def logout(self):\r\n session.clear()\r\n return redirect(\"/user/login\")","def user_logout(request):\r\n logout(request)\r\n return redirect('accounts:login')","def logout(request):\n auth.logout(request)\n messages.success(request, \"You have successfully been logged out\")\n return redirect('index')","def logout(request):\n auth.logout(request)\n messages.success(request, 'You have successfully logged out')\n return redirect(reverse('index'))","def logout_user(request):\n\tlogout(request)\n\treturn HttpResponseRedirect('/')","def logout_view():\n return url(r'^logout/$', logout, {'template_name': 'miniuser/logout.html'}, name='logout')","def logout(request):\n headers = forget(request)\n return HTTPFound(location=request.route_url('home_view'), headers=headers)","def logout(request):\n auth.logout(request)\n messages.success(request, \"You have successfully been logged out\", extra_tags=\"alert-success\")\n return redirect(reverse('index'))","def logout(self):\r\n # should redirect\r\n check_for_get_code(self, 302, reverse('logout'))","def logout():\n\n do_logout()\n flash('successfully logged out')\n return redirect(\"/\")","def logout(request):\n auth.logout(request)\n messages.success(request, \"You have logged out succesfully\")\n return redirect(reverse('index'))","def logout():\n flash(_('You were logged out'))\n session.pop('user_id', None)\n return redirect(url_for('index'))\n #return redirect(url_for('public_timeline'))","def logout():\n session.clear()\n return redirect(\"/\")","def logout():\n\n logout_user()\n return redirect('/')","def logout(request, error=None):\n auth_logout(request)\n return redirect('app:index')","def logout():\n \n # using the method from the flask module\n logout_user()\n return redirect(url_for('home'))","def logout(request):\n django_logout(request)#TODO log out from BASF too (!?)\n return HttpResponseRedirect(reverse_lazy(\"landing_page\"))","def logout():\n\tsession.pop(\"username\", None)\n\treturn redirect(url_for(\"default\"))","def s_logout(request):\n logout(request) # use django.contrib.auth.logout , clear all session , redirect to logout\n return redirect('/')","def log_out(request):\n logout(request)\n return redirect('user_login')","def logout(request):\n django_logout(request)\n return HttpResponseRedirect('/')","def logout_student(request):\n logout(request)\n return HttpResponseRedirect(reverse('home'))","def logout_view(request):\n logout(request)\n return render(request, 'woofer/index.html')","def user_logout(request):\n\n # Since we know the user is logged in, we can now just log them out.\n\tlogout(request)\n\n # Take the user back to the homepage. \n\treturn HttpResponseRedirect(reverse('website:index'))","def logout():\n # Log user out if they are authenticated\n if current_user.is_authenticated:\n logout_user()\n # Redirect to index page\n flash(\"Successfully logged out.\", category=\"success\")\n # Redirect back to index\n return redirect(url_for('main.index'))","def logout():\n session.clear()\n return redirect(url_for(\"index\"))","def logout():\n session.clear()\n return redirect(url_for(\"index\"))","def logout():\n session.clear()\n return redirect(url_for(\"index\"))","def logout():\n logout_user()\n return redirect(url_for(\".login\"))","def logout():\n flash(u'Zostałeś wylogowany')\n session.pop('user_id', None)\n return redirect(url_for('index'))","def logoutCurrentUser(request):\n logout(request)\n return redirect('indexPage')","def logout_view():\n return url(r'^logout/$', LogoutView.as_view(template_name='miniuser/logout.html'), name='logout')","def logout():\n session.pop(\"user\")\n return redirect(url_for(\"home\"))","def logout():\n logout_user()\n flash(\"Successfully signed out\", category='info')\n return redirect(url_for('url.index'))","def logout(request):\n auth_logout(request)\n messages.success(request, 'You are now logged out')\n return redirect('/')","def logout():\n session.clear()\n return redirect(url_for('index'))","def logout():\n session.pop('user', None)\n return redirect(url_for('index'))","def logout():\n session.pop('user', None)\n return redirect(url_for('index'))","def logout():\n logout_user()\n flash('Successfully logged out.')\n return redirect(request.referrer)","def logout_view(request):\n auth.logout(request)\n messages.info(request, _('You have logged out successfully.'), extra_tags='alert alert-info')\n return render(request, 'logout_complete.html')","def logout():\n\n session.clear()\n return redirect(url_for('index'))","def logout():\n\n session.clear()\n return redirect(url_for('index'))","def logoutuser(request):\n logout(request)\n return redirect('login')","def logout():\n\n # remove the username from the session if it is there\n out_user = current_user.get_id()\n logout_user()\n logger.info(out_user + ' has been logged out.')\n return redirect(url_for('home'))","def logout():\n\n if do_logout():\n flash('Logout Successful.', 'success')\n\n return redirect('/login')","def logout():\n\n do_logout()\n flash(\"Successfully logged out\", \"success\")\n return redirect('/')","def get(self, request):\n logout(request)\n return redirect(\"/\")","def logout():\n session.clear()\n return redirect(\"/showlog\")","def logout():\n\n do_logout()\n flash(f\"You are now logged out!\", \"success\")\n return redirect('/')","def logout():\n logout_user()\n flash('You have successfully been logged out.')\n # redirect to the login page\n return redirect(url_for('view.login'))","def logout(self) -> Union[redirect, HTMLBody]:\n\t\tif self.is_authorized:\n\t\t\tsession.clear()\n\t\t\tflash(\"Successfully logged out.\")\n\t\t\treturn render_template(\"index.jinja2\")\n\t\tflash(\"You must login before logging out.\")\n\t\treturn redirect(url_for(\"login\"))","def logoutUser(request):\n\n logout(request)\n return redirect('loginpage')","def logout():\n\n logout_user()\n return redirect(url_for('login'))"],"string":"[\n \"def logout_view(request):\\n logout(request)\\n return redirect('home')\",\n \"def logout_view(request):\\n auth_logout(request)\\n return redirect('home')\",\n \"def logout_view(request):\\n \\n logout(request)\\n return HttpResponseRedirect(reverse(\\\"index\\\"))\",\n \"def logout_view(request):\\n logout(request)\\n return HttpResponseRedirect(reverse(\\\"index\\\"))\",\n \"def logout():\\n logout_user()\\n return redirect(url_for('default.home'))\",\n \"def logout_view(request):\\n logout(request)\\n return redirect('/')\",\n \"def logout_view(request):\\n logout(request)\\n return redirect('/')\",\n \"def logout_view(request):\\n\\n if request.user.is_authenticated:\\n logout(request)\\n\\n return redirect(reverse('index_view'))\",\n \"def GET_logout(self):\\r\\n self.logout()\\r\\n return self.redirect('/')\",\n \"def logout_page(request):\\n logout(request)\\n return redirect('/')\",\n \"def logoutPage(request):\\n\\n logout(request)\\n return redirect('index')\",\n \"def logout():\\n logout_user()\\n return redirect(url_for('home'))\",\n \"def logout_view(request):\\n logout(request)\\n return redirect('login')\",\n \"def logout_view(request):\\n logout(request)\\n return redirect('login')\",\n \"def logout(request):\\n auth.logout(request)\\n return redirect('index')\",\n \"def logout_view(request):\\n\\n\\tlogout(request)\\n\\treturn HttpResponseRedirect('login')\",\n \"def logoutView(request):\\n logout(request)\\n return redirect('/login')\",\n \"def logout():\\n do_logout()\\n return redirect('/login')\",\n \"def logout():\\n session_logout()\\n return redirect(url_for(\\\"home\\\"))\",\n \"def logout_view(request):\\n\\n logout(request)\\n return redirect('/login')\",\n \"def logout_view(request):\\n\\n logout(request)\\n return redirect('/user/login/')\",\n \"def logout_redirect():\\n login_session.clear()\\n flash('You have logged out')\\n return redirect(url_for('show_homepage'))\",\n \"def logout_view(request):\\n logout(request)\\n return HttpResponseRedirect('/')\",\n \"def logout_view(request):\\n logout(request)\\n return HttpResponseRedirect('/')\",\n \"def logout_view(request):\\n logout(request)\\n return HttpResponseRedirect(reverse('dashboard:login'))\",\n \"def logout_view(request):\\n logout(request) # Logout request user\\n messages.info(request, \\\"You have logged out successfully.\\\", fail_silently=False)\\n return redirect(\\\"showLoginPage\\\")\",\n \"def logout():\\n session.pop('logged_in', None)\\n return redirect(url_for('home'))\",\n \"def logout():\\n logout_user()\\n return redirect(\\\"/\\\")\",\n \"def logout_page(request):\\n logout(request)\\n return HttpResponseRedirect('/')\",\n \"def logout(request):\\n alogout(request)\\n \\n return HttpResponseRedirect(\\\"/\\\")\",\n \"def auth_logout(request):\\n logout(request)\\n return HttpResponseRedirect( reverse('startpage') )\",\n \"def logout(request):\\n\\tlogoutt(request)\\n\\treturn redirect(\\\"firstpage\\\")\",\n \"def logout():\\r\\n logout_user()\\r\\n flash('You were logged out.')\\r\\n return redirect(url_for('index'))\",\n \"def logout():\\n session.clear()\\n return redirect(url_for('index'))\",\n \"def logout():\\n logout_user()\\n return redirect(url_for('index'))\",\n \"def logout():\\n logout_user()\\n return redirect(url_for('index'))\",\n \"def logout():\\n logout_user()\\n return redirect(url_for('main.index'))\",\n \"def account_logout(request):\\n logout(request)\\n return redirect('/')\",\n \"def logout(request):\\n auth.logout(request)\\n return redirect(settings.SITE_URL)\",\n \"def logout():\\n session.clear()\\n return redirect(url_for(\\\"home\\\"))\",\n \"def logout():\\n logout_user()\\n return redirect(url_for('auth.index'))\",\n \"def logout():\\n session.clear()\\n return redirect(url_for('home'))\",\n \"def logout(request):\\n auth.logout(request)\\n messages.success(request, 'You are logged out!')\\n return redirect(reverse('index'))\",\n \"def logout(request):\\n auth.logout(request)\\n messages.success(request, 'You have successfully been logged out.')\\n return redirect(reverse('index'))\",\n \"def logout(request):\\n auth.logout(request)\\n messages.success(request, \\\"You have successfully been logged out.\\\")\\n return redirect(reverse('index'))\",\n \"def logout(self):\\n\\n # remove session\\n session.delete()\\n\\n return render('login.html')\",\n \"def logout(request):\\n auth.logout(request)\\n messages.success(request, \\\"You have successfully been logged out!\\\",\\n extra_tags=\\\"alert-success\\\")\\n return redirect(reverse('index'))\",\n \"def logout(self):\\r\\n session.clear()\\r\\n return redirect(\\\"/user/login\\\")\",\n \"def user_logout(request):\\r\\n logout(request)\\r\\n return redirect('accounts:login')\",\n \"def logout(request):\\n auth.logout(request)\\n messages.success(request, \\\"You have successfully been logged out\\\")\\n return redirect('index')\",\n \"def logout(request):\\n auth.logout(request)\\n messages.success(request, 'You have successfully logged out')\\n return redirect(reverse('index'))\",\n \"def logout_user(request):\\n\\tlogout(request)\\n\\treturn HttpResponseRedirect('/')\",\n \"def logout_view():\\n return url(r'^logout/$', logout, {'template_name': 'miniuser/logout.html'}, name='logout')\",\n \"def logout(request):\\n headers = forget(request)\\n return HTTPFound(location=request.route_url('home_view'), headers=headers)\",\n \"def logout(request):\\n auth.logout(request)\\n messages.success(request, \\\"You have successfully been logged out\\\", extra_tags=\\\"alert-success\\\")\\n return redirect(reverse('index'))\",\n \"def logout(self):\\r\\n # should redirect\\r\\n check_for_get_code(self, 302, reverse('logout'))\",\n \"def logout():\\n\\n do_logout()\\n flash('successfully logged out')\\n return redirect(\\\"/\\\")\",\n \"def logout(request):\\n auth.logout(request)\\n messages.success(request, \\\"You have logged out succesfully\\\")\\n return redirect(reverse('index'))\",\n \"def logout():\\n flash(_('You were logged out'))\\n session.pop('user_id', None)\\n return redirect(url_for('index'))\\n #return redirect(url_for('public_timeline'))\",\n \"def logout():\\n session.clear()\\n return redirect(\\\"/\\\")\",\n \"def logout():\\n\\n logout_user()\\n return redirect('/')\",\n \"def logout(request, error=None):\\n auth_logout(request)\\n return redirect('app:index')\",\n \"def logout():\\n \\n # using the method from the flask module\\n logout_user()\\n return redirect(url_for('home'))\",\n \"def logout(request):\\n django_logout(request)#TODO log out from BASF too (!?)\\n return HttpResponseRedirect(reverse_lazy(\\\"landing_page\\\"))\",\n \"def logout():\\n\\tsession.pop(\\\"username\\\", None)\\n\\treturn redirect(url_for(\\\"default\\\"))\",\n \"def s_logout(request):\\n logout(request) # use django.contrib.auth.logout , clear all session , redirect to logout\\n return redirect('/')\",\n \"def log_out(request):\\n logout(request)\\n return redirect('user_login')\",\n \"def logout(request):\\n django_logout(request)\\n return HttpResponseRedirect('/')\",\n \"def logout_student(request):\\n logout(request)\\n return HttpResponseRedirect(reverse('home'))\",\n \"def logout_view(request):\\n logout(request)\\n return render(request, 'woofer/index.html')\",\n \"def user_logout(request):\\n\\n # Since we know the user is logged in, we can now just log them out.\\n\\tlogout(request)\\n\\n # Take the user back to the homepage. \\n\\treturn HttpResponseRedirect(reverse('website:index'))\",\n \"def logout():\\n # Log user out if they are authenticated\\n if current_user.is_authenticated:\\n logout_user()\\n # Redirect to index page\\n flash(\\\"Successfully logged out.\\\", category=\\\"success\\\")\\n # Redirect back to index\\n return redirect(url_for('main.index'))\",\n \"def logout():\\n session.clear()\\n return redirect(url_for(\\\"index\\\"))\",\n \"def logout():\\n session.clear()\\n return redirect(url_for(\\\"index\\\"))\",\n \"def logout():\\n session.clear()\\n return redirect(url_for(\\\"index\\\"))\",\n \"def logout():\\n logout_user()\\n return redirect(url_for(\\\".login\\\"))\",\n \"def logout():\\n flash(u'Zostałeś wylogowany')\\n session.pop('user_id', None)\\n return redirect(url_for('index'))\",\n \"def logoutCurrentUser(request):\\n logout(request)\\n return redirect('indexPage')\",\n \"def logout_view():\\n return url(r'^logout/$', LogoutView.as_view(template_name='miniuser/logout.html'), name='logout')\",\n \"def logout():\\n session.pop(\\\"user\\\")\\n return redirect(url_for(\\\"home\\\"))\",\n \"def logout():\\n logout_user()\\n flash(\\\"Successfully signed out\\\", category='info')\\n return redirect(url_for('url.index'))\",\n \"def logout(request):\\n auth_logout(request)\\n messages.success(request, 'You are now logged out')\\n return redirect('/')\",\n \"def logout():\\n session.clear()\\n return redirect(url_for('index'))\",\n \"def logout():\\n session.pop('user', None)\\n return redirect(url_for('index'))\",\n \"def logout():\\n session.pop('user', None)\\n return redirect(url_for('index'))\",\n \"def logout():\\n logout_user()\\n flash('Successfully logged out.')\\n return redirect(request.referrer)\",\n \"def logout_view(request):\\n auth.logout(request)\\n messages.info(request, _('You have logged out successfully.'), extra_tags='alert alert-info')\\n return render(request, 'logout_complete.html')\",\n \"def logout():\\n\\n session.clear()\\n return redirect(url_for('index'))\",\n \"def logout():\\n\\n session.clear()\\n return redirect(url_for('index'))\",\n \"def logoutuser(request):\\n logout(request)\\n return redirect('login')\",\n \"def logout():\\n\\n # remove the username from the session if it is there\\n out_user = current_user.get_id()\\n logout_user()\\n logger.info(out_user + ' has been logged out.')\\n return redirect(url_for('home'))\",\n \"def logout():\\n\\n if do_logout():\\n flash('Logout Successful.', 'success')\\n\\n return redirect('/login')\",\n \"def logout():\\n\\n do_logout()\\n flash(\\\"Successfully logged out\\\", \\\"success\\\")\\n return redirect('/')\",\n \"def get(self, request):\\n logout(request)\\n return redirect(\\\"/\\\")\",\n \"def logout():\\n session.clear()\\n return redirect(\\\"/showlog\\\")\",\n \"def logout():\\n\\n do_logout()\\n flash(f\\\"You are now logged out!\\\", \\\"success\\\")\\n return redirect('/')\",\n \"def logout():\\n logout_user()\\n flash('You have successfully been logged out.')\\n # redirect to the login page\\n return redirect(url_for('view.login'))\",\n \"def logout(self) -> Union[redirect, HTMLBody]:\\n\\t\\tif self.is_authorized:\\n\\t\\t\\tsession.clear()\\n\\t\\t\\tflash(\\\"Successfully logged out.\\\")\\n\\t\\t\\treturn render_template(\\\"index.jinja2\\\")\\n\\t\\tflash(\\\"You must login before logging out.\\\")\\n\\t\\treturn redirect(url_for(\\\"login\\\"))\",\n \"def logoutUser(request):\\n\\n logout(request)\\n return redirect('loginpage')\",\n \"def logout():\\n\\n logout_user()\\n return redirect(url_for('login'))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8744168","0.8659496","0.8525579","0.8507581","0.8489514","0.8458301","0.8458301","0.84309167","0.84134465","0.83970946","0.8394286","0.8385555","0.83608264","0.83608264","0.83596367","0.8345407","0.8336058","0.83315647","0.83303416","0.8329741","0.83283705","0.8294551","0.82840526","0.82840526","0.8275323","0.8268875","0.82398176","0.82339036","0.82318133","0.8231378","0.82286763","0.8214554","0.8197308","0.8195826","0.81866413","0.81866413","0.8184838","0.8161194","0.81581724","0.8148838","0.8138842","0.81277066","0.8126657","0.81252337","0.8124634","0.81200767","0.81151867","0.8113337","0.8111746","0.8110318","0.8108925","0.8096077","0.80949175","0.8089595","0.80841935","0.80739665","0.807221","0.8058011","0.8055578","0.80489373","0.8046632","0.80448043","0.8043686","0.80324","0.8019934","0.8006556","0.80038637","0.80024755","0.80017316","0.79940003","0.7988628","0.79810876","0.7976428","0.7976428","0.7976428","0.7967457","0.7967403","0.7964069","0.7951747","0.7950239","0.7940465","0.7934086","0.7930952","0.79303294","0.79303294","0.7916134","0.79136586","0.79118305","0.79118305","0.7907741","0.79055953","0.79016","0.7901307","0.78922695","0.78794503","0.78630143","0.78586775","0.7846096","0.78460824","0.784526"],"string":"[\n \"0.8744168\",\n \"0.8659496\",\n \"0.8525579\",\n \"0.8507581\",\n \"0.8489514\",\n \"0.8458301\",\n \"0.8458301\",\n \"0.84309167\",\n \"0.84134465\",\n \"0.83970946\",\n \"0.8394286\",\n \"0.8385555\",\n \"0.83608264\",\n \"0.83608264\",\n \"0.83596367\",\n \"0.8345407\",\n \"0.8336058\",\n \"0.83315647\",\n \"0.83303416\",\n \"0.8329741\",\n \"0.83283705\",\n \"0.8294551\",\n \"0.82840526\",\n \"0.82840526\",\n \"0.8275323\",\n \"0.8268875\",\n \"0.82398176\",\n \"0.82339036\",\n \"0.82318133\",\n \"0.8231378\",\n \"0.82286763\",\n \"0.8214554\",\n \"0.8197308\",\n \"0.8195826\",\n \"0.81866413\",\n \"0.81866413\",\n \"0.8184838\",\n \"0.8161194\",\n \"0.81581724\",\n \"0.8148838\",\n \"0.8138842\",\n \"0.81277066\",\n \"0.8126657\",\n \"0.81252337\",\n \"0.8124634\",\n \"0.81200767\",\n \"0.81151867\",\n \"0.8113337\",\n \"0.8111746\",\n \"0.8110318\",\n \"0.8108925\",\n \"0.8096077\",\n \"0.80949175\",\n \"0.8089595\",\n \"0.80841935\",\n \"0.80739665\",\n \"0.807221\",\n \"0.8058011\",\n \"0.8055578\",\n \"0.80489373\",\n \"0.8046632\",\n \"0.80448043\",\n \"0.8043686\",\n \"0.80324\",\n \"0.8019934\",\n \"0.8006556\",\n \"0.80038637\",\n \"0.80024755\",\n \"0.80017316\",\n \"0.79940003\",\n \"0.7988628\",\n \"0.79810876\",\n \"0.7976428\",\n \"0.7976428\",\n \"0.7976428\",\n \"0.7967457\",\n \"0.7967403\",\n \"0.7964069\",\n \"0.7951747\",\n \"0.7950239\",\n \"0.7940465\",\n \"0.7934086\",\n \"0.7930952\",\n \"0.79303294\",\n \"0.79303294\",\n \"0.7916134\",\n \"0.79136586\",\n \"0.79118305\",\n \"0.79118305\",\n \"0.7907741\",\n \"0.79055953\",\n \"0.79016\",\n \"0.7901307\",\n \"0.78922695\",\n \"0.78794503\",\n \"0.78630143\",\n \"0.78586775\",\n \"0.7846096\",\n \"0.78460824\",\n \"0.784526\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7844669"},"document_rank":{"kind":"string","value":"100"}}},{"rowIdx":8991,"cells":{"query":{"kind":"string","value":"Shows validation UI for a given campaign, if this UserProfile is authorized to do data entry for the specified Campaign. This is also the endpoint for searching for Voters as part of validation. If doing a search, assume that a sufficient number of the specified fields is present (taken care of in frontend form validation)."},"document":{"kind":"string","value":"def validate(request, campaign_id):\n if not request.user.userprofile.in_campaign(campaign_id):\n return HttpResponseRedirect(reverse(\"voter_validation:index\"))\n\n campaign_id = int(campaign_id)\n campaign = get_object_or_404(Campaign, id=campaign_id)\n\n # Get the number of signatures validated by the current user for this\n # campaign, and also for the past 24 hours.\n val_sigs_set = ValidationRecord.objects.filter(\n validator=request.user.userprofile, campaign=campaign)\n val_sigs_24h = val_sigs_set.filter(\n last_updated__gte=datetime.now(SERVER_TIME_ZONE) - timedelta(hours=24))\n\n context = {\n \"campaign_name\": campaign.name,\n \"campaign_id\": campaign_id,\n \"val_sigs\": val_sigs_set.count(),\n \"val_sigs_24h\": val_sigs_24h.count(),\n }\n\n # Search if specified in POST\n search = request.POST.get(\"search\", \"false\")\n if search.lower() == \"true\":\n name = request.POST.get(\"name\", None)\n address = request.POST.get(\"address\", None)\n res_zip = request.POST.get(\"zip\", None)\n # Pass in campaign_id so we can check the Voter was previously validated\n voters = voter_search(name, address, res_zip, campaign_id=campaign_id)\n context.update({\n \"name\": name,\n \"address\": address,\n \"zip\": res_zip,\n \"results\": voters,\n })\n\n return render(request, \"voter_validation/validation.html\", context)"},"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 index(request):\n context = dict()\n if request.user.is_authenticated():\n context['campaigns'] = [\n CampaignSerializer(c).serialize() for c in\n request.user.userprofile.campaigns.order_by('pk')]\n return render(request, 'voter_validation/index.html', context)","def view(args):\n if args.available:\n printAvailableCampaigns()\n if args.search_help:\n print(getSearchQueryHelp())","def validate(self, data):\n company = data['company']\n if self.context['request'].user.has_perm(\"view_company\", company):\n return data\n else:\n raise PermissionDenied()","def show_campaigns(request, utm_campaign, **kwargs):\n \n err_msg = ''\n try:\n err_msg = str(kwargs['kwargs']['err_msg'])\n except:\n pass\n \n test_type_override = ''\n try:\n test_type_override = MySQLdb._mysql.escape_string(request.POST['test_type_override'])\n \n if test_type_override == 'Banner':\n test_type_var = FDH._TESTTYPE_BANNER_\n elif test_type_override == 'Landing Page':\n test_type_var = FDH._TESTTYPE_LP_\n elif test_type_override == 'Banner and LP':\n test_type_var = FDH._TESTTYPE_BANNER_LP_\n \n except:\n test_type_var = ''\n pass\n \n try:\n \"\"\" Find the earliest and latest page views for a given campaign \"\"\"\n lptl = DL.LandingPageTableLoader()\n ccrml = DL.CiviCRMLoader()\n \n start_time = ccrml.get_earliest_donation(utm_campaign)\n end_time = ccrml.get_latest_donation(utm_campaign)\n \n one_step = lptl.is_one_step(start_time, end_time, utm_campaign) \n \n if not(one_step): \n start_time = lptl.get_earliest_campaign_view(utm_campaign)\n end_time = lptl.get_latest_campaign_view(utm_campaign) \n\n interval = 1\n \n \"\"\" Create reporting object to retrieve campaign data and write plots to image repo on disk \"\"\"\n ir = DR.IntervalReporting(was_run=False, use_labels=False, font_size=20, plot_type='line', query_type='campaign', file_path=projSet.__web_home__ + 'campaigns/static/images/')\n \n \"\"\" Produce analysis on the campaign view data \"\"\" \n ir.run(start_time, end_time, interval, 'views', utm_campaign, {}, one_step=one_step)\n \n \"\"\" \n ESTIMATE THE START AND END TIME OF THE CAMPAIGN\n ===============================================\n \n Search for the first instance when more than 10 views are observed over a sampling period\n \"\"\"\n \n col_names = ir._data_loader_.get_column_names()\n \n views_index = col_names.index('views')\n ts_index = col_names.index('ts')\n \n row_list = list(ir._data_loader_._results_) # copy the query results\n for row in row_list:\n if row[views_index] > 100:\n start_time_est = row[ts_index]\n break\n row_list.reverse()\n for row in row_list:\n if row[views_index] > 100:\n end_time_est = row[ts_index]\n break\n \n \n \"\"\"\n BUILD THE VISUALIZATION FOR THE TEST VIEWS OF THIS CAMAPAIGN\n ============================================================ \n \"\"\"\n \n \"\"\" Read the test name \"\"\"\n ttl = DL.TestTableLoader()\n row = ttl.get_test_row(utm_campaign)\n test_name = ttl.get_test_field(row ,'test_name')\n \n \"\"\" Regenerate the data using the estimated start and end times \"\"\"\n ir = DR.IntervalReporting(was_run=False, use_labels=False, font_size=20, plot_type='line', query_type='campaign', file_path=projSet.__web_home__ + 'campaigns/static/images/')\n ir.run(start_time_est, end_time_est, interval, 'views', utm_campaign, {}, one_step=one_step)\n \n \"\"\" Determine the type of test (if not overridden) and retrieve the artifacts \"\"\"\n test_type, artifact_name_list = FDH.get_test_type(utm_campaign, start_time, end_time, DL.CampaignReportingLoader(query_type=''), test_type_var)\n \n return render_to_response('campaigns/show_campaigns.html', {'utm_campaign' : utm_campaign, 'test_name' : test_name, 'start_time' : start_time_est, 'end_time' : end_time_est, 'one_step' : one_step, \\\n 'artifacts' : artifact_name_list, 'test_type' : test_type, 'err_msg' : err_msg}, context_instance=RequestContext(request)) \n\n except Exception as inst:\n \n logging.error('Failed to correctly produce campaign diagnostics.')\n logging.error(type(inst))\n logging.error(inst.args)\n logging.error(inst)\n \n \"\"\" Return to the index page with an error \"\"\"\n err_msg = 'There is insufficient data to analyze this campaign: %s. Check to see if the <a href=\"/LML/\">impressions have been loaded</a>. <br><br>ERROR:<br><br>%s' % (utm_campaign, inst.__str__())\n \n return index(request, kwargs={'err_msg' : err_msg})","def validate(self, data):\n company = data['company']\n invoice = data.get(\"invoice\")\n if not self.context['request'].user.has_perm(\"view_company\", company) or not all(\n self.context['request'].user.has_perm(\"view_media\", media) for media in invoice):\n raise PermissionDenied()\n return data","def validate(self, data):\n company = data['company']\n invoice = data.get(\"invoice\")\n if not self.context['request'].user.has_perm(\"view_company\", company) or not all(\n self.context['request'].user.has_perm(\"view_media\", media) for media in invoice):\n raise PermissionDenied()\n return data","def campground_checker_view(request):\n # If POST request, retrieve data from API\n if request.method == 'POST':\n form = forms.CampgroundForm(request.POST)\n if form.is_valid():\n start_date = form.cleaned_data['start_date']\n end_date = form.cleaned_data['end_date']\n camp_ids = form.cleaned_data['camp_ids']\n camp_id_list = camp_ids.split()\n try:\n results, start_string, end_string = check.master_scraping_routine(camp_id_list, start_date, end_date)\n return render(request, 'availability_results.html', {'start_date': start_string,\n 'end_date': end_string,\n 'results': results})\n except:\n return render(request, 'no_results_found.html')\n else:\n return 'No success'\n # If GET or other type of request, load empty form\n else:\n form = forms.CampgroundForm()\n return render(request, 'availability.html', {'form': form})","def validate_schema(self, data, **kwargs):\n if \"role\" not in data and \"visible\" not in data:\n raise ValidationError(_(\"Missing fields 'role' and/or 'visible'.\"))","def __call__(self, data):\n data_combiner = DataCombiner(self.instance, data)\n company = data_combiner.get_value(self.company_field)\n contact = data_combiner.get_value(self.contact_field)\n\n if contact.company != company:\n raise ValidationError({\n self.contact_field: self.message,\n })","def update_c_mandatory_fields(request, campaign_id):\n # print(request.POST)\n campaign = Campaign.objects.get(id=campaign_id)\n form = CampaignForm(request.POST, instance = campaign)\n # print(form)\n if form.is_valid():\n form.save()\n return redirect('add_campaign_spec', id=campaign_id)\n else:\n # return redirect('clonecampaign', id=campaign_id)\n print(form.errors)\n return redirect(reverse('edit_campaign', kwargs={'campaign_id':campaign_id}))","def validate(self) -> bool:\n required = self.crud.validate(required=True)\n if required:\n raise ValueError(\n f\"Validation error. Required destination fields are not present in the crosswalk: {required}\"\n )","def get_campaign_command(client: Client, campaign_id: str) -> CommandResults | str:\n try:\n raw_response = client.get_campaign(campaign_id)\n except ValueError:\n return 'Campaign Id not found'\n\n campaign_general_fields = ['id', 'name', 'description', 'startDate', 'notable']\n campaign_fields = ['families', 'techniques', 'actors', 'brands', 'malware']\n\n outputs = {}\n outputs['campaignMembers'] = dict_safe_get(raw_response, ['campaignMembers'])\n outputs['info'] = {key: value for key, value in raw_response.items() if key in campaign_general_fields}\n outputs.update({key: value for key, value in raw_response.items() if key in campaign_fields})\n fields_readable_output = \"\"\n for field in campaign_fields:\n fields_readable_output += \"\\n\" + tableToMarkdown(field.capitalize(),\n dict_safe_get(outputs, [field]), headers=['id', 'name'],\n headerTransform=pascalToSpace\n )\n\n campaign_info_output = tableToMarkdown('Campaign Information',\n outputs['info'],\n headers=['id', 'name', 'description', 'startDate', 'notable'],\n headerTransform=pascalToSpace\n )\n campaign_members_output = tableToMarkdown('Campaign Members',\n outputs['campaignMembers'],\n headers=['id', 'threat', 'type'],\n headerTransform=pascalToSpace\n )\n\n readable_output = campaign_info_output + \"\\n\" + campaign_members_output + fields_readable_output\n\n return CommandResults(\n readable_output=readable_output,\n outputs_prefix='Proofpoint.Campaign',\n outputs=outputs,\n outputs_key_field='id',\n raw_response=raw_response\n )","def test_get_campaign_by_id_passes(self):\n response = self.client.get(f\"{self.endpoint_url}{self.test_campaign.id}/\")\n response_body = response.get_json()\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response_body, {\"id\": CAMPAIGN_ID, \"name\": CAMPAIGN_NAME})","def validate(self, data):\n # if data['is_private'] and data['contestants']:\n # raise serializers.ValidationError(\"Can not be private and compete for an award.\")\n return data","def validate(self):\n\n form = CallEventForm(self.data)\n if not form.is_valid():\n self.errors = form.errors\n map_dict_fields(self.errors, const.DB_FIELDS, const.API_FIELDS)","def testGetCampaign(self):\n if self.__class__.campaign1 is None:\n self.testSaveCampaign()\n self.assert_(isinstance(self.__class__.service.GetCampaign(\n self.__class__.campaign1['id']), tuple))","def run_validation(self, data=empty):\n\n if data is not empty:\n unknown = set(data) - set(self.fields)\n if unknown:\n errors = ['Unknown field: {}'.format(f) for f in unknown]\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\n return super().run_validation(data)","def validate(self):\n return self.validator.validate(self.fields)","def run_validation(self, data=empty):\n\n # no idea why there is no such built in feature in DRF\n if data is not empty:\n unknown = set(data) - set(self.fields)\n if unknown:\n errors = ['Unknown field: {}'.format(f) for f in unknown]\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\n return super().run_validation(data)","def test_view_form_valid_sales_method(self, google):\n google.return_value = GeocoderMock()\n\n form_data = super(BaseSearchPageViewTestCase, self).get_data_sales()\n\n view = super(BaseSearchPageViewTestCase, self).initialize(BaseSearchPageView(), None)\n\n view.form_class = SearchForm\n\n form = SearchForm(form_data)\n\n form.is_valid()\n\n response = view.form_valid(form)\n\n (url, query) = super(BaseSearchPageViewTestCase, self).parse_url(response)\n\n form_data = super(BaseSearchPageViewTestCase, self).get_data_extra(form_data)\n\n for key, value in form_data.iteritems():\n self.assertTrue(key in query and query[key] == str(value))\n\n # Check we are dealing with a redirect and path as expected as sales/search\n self.assertIsInstance(response, HttpResponseRedirect)\n self.assertEqual(url.path, '/sales/search/')","def send_validation_request(self):\r\n self.send_request(send_function=self._assemble_and_send_validation_request)","def test_create_new_campaign_by_admin_passes(self):\n response = self.client.post(\n self.endpoint_url,\n json={\n \"logo\": None,\n \"name\": NEW_CAMPAIGN_NAME,\n \"organisations\": [self.test_org.id],\n \"url\": None,\n },\n headers={\"Authorization\": self.session_token},\n )\n response_body = response.get_json()\n self.assertEqual(response.status_code, 201)\n self.assertEqual(response_body, {\"campaignId\": 2})","def test_update_existent_campaign_by_admin_passes(self):\n response = self.client.patch(\n f\"{self.endpoint_url}{self.test_campaign.id}/\",\n json={\n \"logo\": None,\n \"name\": NEW_CAMPAIGN_NAME,\n \"organisations\": [],\n \"url\": None,\n },\n headers={\"Authorization\": self.admin_token},\n )\n response_body = response.get_json()\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response_body[\"Success\"], \"Campaign 1 updated\")","def test_update_existent_campaign_by_unauthenticated_user_fails(self):\n response = self.client.patch(\n f\"{self.endpoint_url}{self.test_campaign.id}/\",\n json={\n \"logo\": None,\n \"name\": NEW_CAMPAIGN_NAME,\n \"organisations\": [self.test_org.id],\n \"url\": None,\n },\n )\n self.assertEqual(response.status_code, 401)","def show_validator(self, show_validator):\n\n self._show_validator = show_validator","def show_validator(self, show_validator):\n\n self._show_validator = show_validator","def cingValidation(self): \n \n self.cingRun()\n \n self.analyseCingResults()","def check(self, args):\n self.parent.footer.set_text(\"Checking data...\")\n self.parent.refreshScreen()\n # Get field information\n responses = dict()\n\n for index, fieldname in enumerate(self.fields):\n if fieldname != \"blank\":\n responses[fieldname] = self.edits[index].get_edit_text()\n\n password = responses[\"FUEL_ACCESS/password\"]\n confirm_password = responses.pop(\"CONFIRM_PASSWORD\")\n\n if self.parent.save_only:\n return responses\n\n # Validate each field\n errors = []\n warnings = []\n\n # Passwords must match\n if password != confirm_password and \\\n password != self.defaults['FUEL_ACCESS/password']['value']:\n errors.append(\"Passwords do not match.\")\n\n # Password must not be empty\n if len(password) == 0:\n errors.append(\"Password must not be empty.\")\n\n # Password needs to be in ASCII character set\n try:\n if password.decode('ascii'):\n pass\n except UnicodeDecodeError:\n errors.append(\"Password contains non-ASCII characters.\")\n\n # Passwords should be at least 8 symbols\n if len(password) < 8:\n warnings.append(\"8 symbols\")\n\n # Passwords should contain at least one digit\n if re.search(r\"\\d\", password) is None:\n warnings.append(\"one digit\")\n\n if re.search(r\"[A-Z]\", password) is None:\n warnings.append(\"one uppercase letter\")\n\n if re.search(r\"[a-z]\", password) is None:\n warnings.append(\"one lowercase letter\")\n\n if re.search(r\"[!#$%&'()*+,-@./[\\\\\\]^_`{|}~\" + r'\"]', password) \\\n is None:\n warnings.append(\"one special character\")\n\n if len(errors) > 0:\n log.error(\"Errors: %s %s\" % (len(errors), errors))\n modulehelper.ModuleHelper.display_failed_check_dialog(self, errors)\n return False\n\n if len(warnings) > 0:\n self.parent.footer.set_text(\"Warning: Password should have \"\n \"at least %s.\" % (warnings[0]))\n else:\n self.parent.footer.set_text(\"No errors found.\")\n\n return responses","def validator(self, *args, **kwargs):\n if 'framework_slug' not in kwargs:\n current_app.logger.error(\"Required parameter `framework_slug` is undefined for the calling view.\")\n abort(500, \"There was a problem accessing this page of your application. Please try again later.\")\n\n if current_user.is_authenticated and current_user.supplier_id:\n supplier_framework = self.data_api_client.get_supplier_framework_info(\n current_user.supplier_id, kwargs['framework_slug']\n )['frameworkInterest']\n\n if supplier_framework['applicationCompanyDetailsConfirmed'] is not True:\n return abort(400, \"You cannot access this part of your application until you have confirmed your \"\n \"company details.\")\n\n return True","def validate_get_openings_result(self, result):\n\n\n requiredFields = {'company', 'title', 'url', 'locations'}\n #optionalFields = {'department', 'description'}\n\n for r in result:\n if not requiredFields.issubset(set(result.keys())):\n return False\n\n return True","def validate(self, data: Dict[str, Any]):\n data[\"profile\"] = self.context.get(\"profile\")\n\n if data.get(\"separate_commission_for_seller_and_buyer\") or data.get(\"only_seller_commission\"):\n if not data.get(\"seller_commission_value\") or not data.get(\"seller_commission_applied_to\") or not data.get(\"seller_commission_type\"):\n raise serializers.ValidationError(texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED.format(entity=\"Seller's\"))\n\n if data[\"seller_commission_type\"] == CommissionAndDiscountType.PERCENT and (not data.get(\"seller_price_for_commission\") or not data.get(\"seller_price_for_commission_applied_to\")):\n raise serializers.ValidationError(\n texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED_WHEN_PERCENT.format(entity=\"Seller's\"))\n\n if data.get(\"separate_commission_for_seller_and_buyer\") or data.get(\"only_buyer_commission\"):\n if not data.get(\"buyer_commission_value\") or not data.get(\"buyer_commission_applied_to\") or not data.get(\"buyer_commission_type\"):\n raise serializers.ValidationError(texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED.format(entity=\"Buyer's\"))\n\n if data[\"buyer_commission_type\"] == CommissionAndDiscountType.PERCENT and (not data.get(\"buyer_price_for_commission\") or not data.get(\"buyer_price_for_commission_applied_to\")):\n raise serializers.ValidationError(\n texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED_WHEN_PERCENT.format(entity=\"Buyer's\"))\n\n if not data.get(\"separate_commission_for_seller_and_buyer\") and not data.get(\"only_seller_commission\") and not data.get(\"only_buyer_commission\"):\n if not data.get(\"seller_commission_value\") or not data.get(\"seller_commission_applied_to\") or not data.get(\"seller_commission_type\"):\n raise serializers.ValidationError(\n texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED.format(entity=\"\"))\n\n if data[\"seller_commission_type\"] == CommissionAndDiscountType.PERCENT and (not data.get(\"seller_price_for_commission\") or not data.get(\"seller_price_for_commission_applied_to\")):\n raise serializers.ValidationError(\n texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED_WHEN_PERCENT.format(entity=\"\"))\n\n return data","def test_validate_when_user_found(self, view, mget_user):\n assert view.validate() is None","def validate(self):\n if self.id == None:\n return False\n return self.validator.validate(self.fields)","def contribute(request, campaign_id, template='campaign/campaign_contribution_form.html'):\r\n campaign = get_object_or_404(Campaign.objects.active(), pk=campaign_id)\r\n if not campaign.is_free:\r\n # Disable direct credit card based contribution\r\n request.user.message_set.create(message=_('That payment option is not available for this campaign.'))\r\n return HttpResponseRedirect(reverse('view_campaign', kwargs={'campaign_id':campaign_id}))\r\n err_msg = None\r\n try:\r\n qualifies, reasons = campaign.is_user_qualified(request.user)\r\n user_profile=request.user.get_profile()\r\n data = None\r\n if qualifies and request.user.first_name and request.user.last_name:\r\n # Skip the form and directly register this event attendee.\r\n data = {'first_name':request.user.first_name, \r\n 'last_name':request.user.last_name,\r\n 'birth_date':user_profile.birth_date}\r\n if data or request.method == 'POST':\r\n if request.method == 'POST':\r\n data = request.POST\r\n form = forms.DirectContributionForm(data=data, campaign=campaign, user_profile=user_profile)\r\n if form.is_valid():\r\n contribution = form.save(commit=True)\r\n _log.info('Contribution processed %s', contribution)\r\n if contribution.qty > 1:\r\n request.user.message_set.create(message=_('Your %s contributions totalling $.2f have been processed. Thank you.' % (contribution.qty, contribution.amount)))\r\n elif not campaign.is_free:\r\n request.user.message_set.create(message=_('Your contribution of $.2f has been processed. Thank you.' % contribution.amount))\r\n else:\r\n request.user.message_set.create(message=_('You have successfully joined this free campaign. Thank you.'))\r\n return HttpResponseRedirect(reverse('view_campaign', kwargs={'campaign_id':campaign_id}))\r\n else:\r\n form = forms.DirectContributionForm(campaign=campaign, user_profile=user_profile)\r\n ctx = {'campaign':campaign, 'c':campaign, 'form':form}\r\n except CampaignError, e:\r\n request.user.message_set.create(message=e.message)\r\n return HttpResponseRedirect(reverse('view_campaign', kwargs={'campaign_id':campaign.pk}))\r\n return render_view(request, template, ctx)","def get_adcampaign(self, campaign_id, fields, batch=False):\n path = '%s' % campaign_id\n args = {'fields': fields}\n return self.make_request(path, 'GET', args, batch=batch)","def test_context_data_with_valid_search_and_no_results(self):\n response = self.client.get(self.get_url(), {'description': 'test'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)","def check_for_required_fields(cls, fields=[], dataDict={}):\n\n validateRequired = Validate.required(fields=fields, dataDict=dataDict)\n if validateRequired['status'] == False:\n res = jsonify(\n {'status': 400, 'error': validateRequired['message'], 'data': []})\n return abort(make_response(res, 400))\n return True","def test_get_existent_campaigns_returns_campaigns_list(self):\n test_campaign = return_canned_campaign()\n test_campaign.create()\n response = self.client.get(self.endpoint_url)\n response_body = response.get_json()\n self.assertEqual(response.status_code, 200)\n self.assertEqual(\n response_body, {\"campaigns\": [{\"id\": 1, \"name\": \"Test Campaign\"}]}\n )","def validate_arguments(self, contest):\n #\n # validation if the contest argument\n self.validate_variable(Contest, contest)","def test_admin_sms_campaign_view_list(self):\n response = self.client.get('/admin/sms_module/smscampaign/')\n self.failUnlessEqual(response.status_code, 200)","def edit_campaigns(self, **kwargs) -> ApiResponse:\n return self._request(kwargs.pop('path'), data=kwargs.pop('body'), params=kwargs)","def test_request_form_successful(self):\n response = self.client.get(reverse(\n 'form', kwargs={'slug': self.agency.slug}))\n self.assertContains(response, self.agency.name)","def get_campaign(self, campaignId, **kwargs) -> ApiResponse:\n return self._request(fill_query_params(kwargs.pop('path'), campaignId), params=kwargs)","def view_edit_validate(request):\n template_file = \"validate_edit_or_validate.html\"\n # get all not validated curations\n curations = models.Curation.objects.\\\n filter(validated_by=None).\\\n order_by('created').all()\n template = {'curations': curations}\n return render_to_response(template_file, template,\n context_instance=RequestContext(request))","def validate_data(self, data):\n try:\n event_id = data[\"event\"]\n guests = data[\"guests\"]\n section = data.get(\"section\", None)\n except KeyError:\n return False, \"\", \"\", \"\"\n try:\n event = Event.objects.get(pk=event_id)\n except Event.DoesNotExist:\n return False, \"\", \"\", \"\"\n if not isinstance(guests, list):\n return False, \"\", \"\", \"\"\n if section is not None:\n try:\n event.venue.sections.get(pk=section)\n except Section.DoesNotExist:\n return False, \"\", \"\", \"\"\n return True, event, guests, section","def __call__(self, data=None):\n if not self.instance.assignees.count():\n raise ValidationError({\n 'assignees': [self.no_assignees_message],\n })\n\n if not self.instance.assignees.filter(is_lead=True).count():\n raise ValidationError({\n 'assignee_lead': [self.no_lead_assignee_message],\n })\n\n if not self.instance.assignees.aggregate(sum=models.Sum('estimated_time'))['sum']:\n raise ValidationError({\n 'assignee_time': [self.no_estimated_time_message],\n })","def validate(self, visibility_field):\r\n if self.original_query.filter is wtypes.Unset:\r\n self.filter_expr = None\r\n else:\r\n self.filter_expr = json.loads(self.original_query.filter)\r\n self._validate_filter(self.filter_expr)\r\n self._replace_isotime_with_datetime(self.filter_expr)\r\n self._convert_operator_to_lower_case(self.filter_expr)\r\n self._normalize_field_names_for_db_model(self.filter_expr)\r\n\r\n self._force_visibility(visibility_field)\r\n\r\n if self.original_query.orderby is wtypes.Unset:\r\n self.orderby = None\r\n else:\r\n self.orderby = json.loads(self.original_query.orderby)\r\n self._validate_orderby(self.orderby)\r\n self._convert_orderby_to_lower_case(self.orderby)\r\n self._normalize_field_names_in_orderby(self.orderby)\r\n\r\n if self.original_query.limit is wtypes.Unset:\r\n self.limit = None\r\n else:\r\n self.limit = self.original_query.limit\r\n\r\n if self.limit is not None and self.limit <= 0:\r\n msg = _('Limit should be positive')\r\n raise ClientSideError(msg)","def validate(self, data):\n request = self.context.get('request')\n data['poster'] = request.user\n\n return validate_complete_address(data)","def validate(self):\r\n def validation_assert(predicate):\r\n \"\"\" Throw a ValidationError if false. \"\"\"\r\n if not predicate:\r\n raise ProfileDistribution.ValidationError()\r\n\r\n validation_assert(isinstance(self.feature, str))\r\n validation_assert(self.feature in DISPLAY_NAMES)\r\n validation_assert(isinstance(self.feature_display_name, str))\r\n validation_assert(self.type in ['EASY_CHOICE', 'OPEN_CHOICE'])\r\n validation_assert(isinstance(self.data, dict))\r\n if self.type == 'EASY_CHOICE':\r\n validation_assert(isinstance(self.choices_display_names, dict))","def do_validate(self, request, _object):\n\n pass","def validate_contact(data, err_obj):\n\n error_count = 0\n\n if not data.get('contact_type').strip():\n error_count += 1\n err_obj['contact_type'] = 'Contact Type Required'\n return\n\n phone_or_email_only = False\n if data.get('contact_type') == 'Phone/Email Only':\n phone_or_email_only = True\n\n if not data.get('contact_priority').strip():\n error_count += 1\n err_obj['contact_priority'] = 'Priority Required'\n\n if phone_or_email_only:\n if not data.get('contact_description'):\n err_obj['contact_description'] = 'Contact Description Required.'\n error_count += 1\n\n # if not data.get('contact_mobile').strip() and not data.get('contact_phone').strip() and not data.get('contact_email').strip() and not data.get('contact_description'):\n # error_count += 3\n # err_obj['contact_phone'] = 'Mobile or Phone or Email Required'\n # err_obj['contact_mobile'] = 'Mobile or Phone or Email Required'\n # err_obj['contact_email'] = 'Mobile or Phone or Email Required'\n\n else:\n if not data.get('contact_first_name').strip():\n error_count += 1\n err_obj['contact_first_name'] = 'Please enter a first name'\n\n if not data.get('contact_last_name').strip():\n error_count += 1\n err_obj['contact_last_name'] = 'Please enter a last name'\n\n if not data.get('contact_postcode').strip():\n error_count += 1\n err_obj['contact_postcode'] = 'Please enter a postcode'\n\n if not data.get('contact_address_1').strip():\n error_count += 1\n err_obj['contact_address_1'] = 'Please enter an address line 1'\n\n if not data.get('contact_mobile').strip() and not data.get('contact_phone').strip():\n error_count += 1\n err_obj['contact_phone'] = 'Mobile or Phone Required'\n err_obj['contact_mobile'] = 'Mobile or Phone Required'\n\n if data.get('contact_mobile').strip():\n if not validate_mobile_number(data['contact_mobile'], err_obj, 'contact_mobile'):\n error_count += 1\n\n if data.get('contact_phone').strip():\n if not validate_phone_number(data['contact_phone'], err_obj, 'contact_phone'):\n error_count += 1\n\n if data.get('contact_email').strip():\n if not validate_email_addr(data['contact_email'], err_obj, 'contact_email'):\n error_count += 1\n\n if error_count:\n return\n\n return True","def test_create_new_campaign_by_unauthenticated_user_fails(self):\n response = self.client.post(\n self.endpoint_url,\n json={\n \"logo\": None,\n \"name\": CAMPAIGN_NAME,\n \"organisations\": [self.test_org.id],\n \"url\": None,\n },\n )\n self.assertEqual(response.status_code, 401)","def get_campaign(self, campaign_id: str) -> dict:\n return self.http_request(\"GET\", f'/campaign/{campaign_id}')","def campaign_id(request):\n\n user = None\n response = ApiJsonResponse()\n try:\n user = MyUser.objects.get(pk=request.user.pk)\n except ObjectDoesNotExist:\n return Response({\n \"msg\": _('MSG_USER_NOT_EXIST'),\n \"status\": 404\n }, status=404)\n try:\n company = Company.objects.get(owner=user)\n except:\n return Response({\n \"msg\": _('MSG_COMPANY_NOT_EXIST'),\n \"status\": 404\n }, status=404)\n try:\n promotions = Promotion.objects.filter(company=company)\n except ObjectDoesNotExist:\n response.set_data(\"[]\")\n response.set_result_code(200)\n response.set_result_msg(\"MSG_PROMOTIONS_NOT_FOUNDED\")\n return JsonResponse(response.get_dict())\n list_of_promotions = []\n for promotion in promotions:\n list_of_promotions.append({'name': promotion.campaign_name, 'id': promotion.pk})\n return Response({\n \"msg\": _('MSG_PROMOTION_FOUNDED'),\n \"list_of_promotions\": list_of_promotions,\n \"status\": 200\n }, status=200)","def test_update_existent_campaign_by_non_admin_fails(self):\n response = self.client.patch(\n f\"{self.endpoint_url}{self.test_campaign.id}/\",\n json={\n \"logo\": None,\n \"name\": NEW_CAMPAIGN_NAME,\n \"organisations\": [self.test_org.id],\n \"url\": None,\n },\n headers={\"Authorization\": self.non_admin_token},\n )\n response_body = response.get_json()\n self.assertEqual(response.status_code, 403)\n self.assertEqual(\n response_body[\"Error\"], \"CampaignsRestAPI PATCH: User not a Org Manager\"\n )\n self.assertEqual(response_body[\"SubCode\"], \"UserNotPermitted\")","def check_vulnerability_in_result(context):\n json_data = context.response.json()\n\n if \"component_analyses\" in json_data:\n vulnerabilities = json_data['component_analyses']['vulnerability']\n for vulnerability in vulnerabilities:\n assert \"cvss\" in vulnerability\n assert \"is_private\" in vulnerability\n assert \"vendor_cve_ids\" in vulnerability","def get(self, campaign_id):\n campaign = Campaign.query.filter_by(mailchimp_id=campaign_id).first()\n if campaign is None:\n return {\"message\": \"Campaign could not be found.\"}, HTTPStatus.NOT_FOUND\n return self.schema.dump(campaign), HTTPStatus.OK","def test_params_passed(self, mock_field_validator, mock_error_builder):\n\n ChargeTypeValidator.validate(CHARGE_TYPE)\n\n calls = [\n call(CHARGE_TYPE, 'charge-type', 'Charge type', mock_error_builder(),\n summary_message='Choose one option', inline_message='Choose one option'),\n call().is_required()\n ]\n mock_field_validator.assert_has_calls(calls)","def getresult(request):\r\n\r\n form = forms.SearchForm(request.POST)\r\n form.find_minmax_criteria(request.POST)\r\n\r\n if form.is_valid():\r\n\r\n headers, results = search.query(form.to_criteria(), form.cleaned_data['sector'], form.cleaned_data['exchange'], form.cleaned_data['show_result'])\r\n\r\n # show result in response\r\n return render_to_response('search/result.html', {\r\n 'headers': headers,\r\n 'results': results\r\n })\r\n\r\n else:\r\n # show error message in response\r\n return render_to_response('search/result-error.html', {\r\n 'message': 'Please enter details correctly.',\r\n 'form': form\r\n })","def validate(self):\n if self.tba_key is None:\n self.log.error(\n \"You are missing the TBA-Key field. Please check https://github.com/team4099/scouting-data-ingest#tba for more information.\"\n )\n return False\n\n self.check_internet_connection()\n\n if self.year is None:\n self.log.error(\n \"You are missing the Year field. Please add one in the style shown below.\"\n )\n year_example = \"\"\"\n {\n \"Year\": \"2020\"\n }\n \"\"\"\n console.print(Syntax(year_example, \"json\"))\n console.print(\n \"Reference https://github.com/team4099/scouting-data-ingest#configuration for more information.\"\n )\n return False\n\n if self.google_credentials is None:\n self.log.error(\n \"You are missing the Google-Credentials field. Please check https://github.com/team4099/scouting-data-ingest#google-service-account-credentials-file for more information.\"\n )\n return False\n elif not os.path.isfile(f\"config/{self.google_credentials}\"):\n self.log.error(\n \"The file listed in the Google-Credentials field does not exist in the config folder. Please place it inside the config folder.\"\n )\n return False\n else:\n try:\n gc = gspread.service_account(f\"./config/{self.google_credentials}\")\n except ValueError as e:\n self.log.error(\n \"The file listed in the Google-Credentials Field is improper. See below for details.\"\n )\n self.log.error(e)\n return False\n\n if self.spreadsheet is None:\n self.log.error(\n \"You are missing the Spreadsheet field. Please check https://github.com/team4099/scouting-data-ingest#spreadsheet for more information.\"\n )\n return False\n else:\n try:\n gc.open(f\"{self.spreadsheet}\").get_worksheet(0)\n except gspread.exceptions.SpreadsheetNotFound:\n self.log.error(\n \"The file listed in the Spreadsheets field has not been shared with the service account. Please make sure it is.\"\n )\n return False\n\n if self.db_user is None:\n self.log.error(\n \"You are missing the Database User field. Please check https://github.com/team4099/scouting-data-ingest#mysql for more information.\"\n )\n return False\n\n if self.db_pwd is None:\n self.log.error(\n \"You are missing the Database Password field. Please check https://github.com/team4099/scouting-data-ingest#mysql for more information.\"\n )\n return False\n\n try:\n create_engine(\n f\"mysql+pymysql://{self.db_user}:{self.db_pwd}@{self.db_host}/scouting\"\n )\n except pymysql.err.OperationalError:\n self.log.error(\n \"Your Database user name and/or password is not correct. Please verify them.\"\n )\n\n if self.event is None:\n self.log.error(\n \"You are missing the Event field. Please check https://github.com/team4099/scouting-data-ingest#event for more information.\"\n )\n return False\n\n if (\n requests.get(\n f\"https://www.thebluealliance.com/api/v3/event/{self.year}{self.event}\",\n headers={\"X-TBA-Auth-Key\": self.tba_key},\n ).status_code\n == 404\n ):\n self.log.error(\n \"The event listed in the TBA-Key field is not valid. Please ensure the event key and year are correct.\"\n )\n return False\n\n if self.simulation:\n if self.simulator_url is None:\n self.log.error(\n \"You are missing the Simulator URL field. Please check https://github.com/team4099/scouting-data-ingest#tba for more information.\"\n )\n return False\n\n try:\n simulator_status = requests.get(\n f\"{self.simulator_url}/matches\"\n ).status_code\n except (\n ConnectionRefusedError,\n urllib3.exceptions.NewConnectionError,\n requests.exceptions.ConnectionError,\n ):\n self.log.error(\n \"The simulator may not be running or it's at a different url than the one provided.\"\n )\n return False\n\n if simulator_status == 401:\n self.log.error(\n \"The simulator may not be running. Please make sure it is and that it is up-to-date.\"\n )\n return False\n\n if self.simulator_spreadsheet is None:\n self.log.error(\n \"You are missing the Simulator Spreadsheet field. Please check https://github.com/team4099/scouting-data-ingest#spreadsheet for more information.\"\n )\n return False\n else:\n try:\n gc.open(f\"{self.simulator_spreadsheet}\").get_worksheet(0)\n except gspread.exceptions.SpreadsheetNotFound:\n self.log.error(\n \"The file listed in the Simulator Spreadsheet field has not been shared with the service account. Please make sure it is. Please also make sure the name entered is correct.\"\n )\n return False\n\n return True","def is_field_available(request):\n if request.method == \"GET\":\n get = request.GET.copy()\n if get.has_key('username'):\n name = get['username']\n if User.objects.filter(username__iexact=name):\n return HttpResponse(False)\n else:\n return HttpResponse(True)\n if get.has_key('email'):\n email = get['email']\n if User.objects.filter(email__iexact=email):\n return HttpResponse(False)\n else:\n return HttpResponse(True)\n\n return HttpResponseServerError(_(\"Requires username or email to test\"))","async def _show_form(self, errors=None):\n data_schema = vol.Schema(\n {\n vol.Optional(\n CONF_LATITUDE, default=self.hass.config.latitude\n ): cv.latitude,\n vol.Optional(\n CONF_LONGITUDE, default=self.hass.config.longitude\n ): cv.longitude,\n vol.Optional(CONF_RADIUS, default=DEFAULT_RADIUS): cv.positive_int,\n }\n )\n\n return self.async_show_form(\n step_id=\"user\", data_schema=data_schema, errors=errors or {}\n )","def check_for_exposed(context):\n json_data = context.response.json()\n if \"exploitable_vulnerabilities_count\" in json_data:\n raise Exception(\"Field exploitable_vulnerabilities_count Exposed in\"\n \" Free user result\")\n if \"vendor_package_link\" in json_data:\n raise Exception(\"Field vendor_package_link has been exposed for free user\")","def test_view_form_valid_lettings_method(self, google):\n google.return_value = GeocoderMock()\n\n form_data = super(BaseSearchPageViewTestCase, self).get_data_lettings()\n\n view = super(BaseSearchPageViewTestCase, self).initialize(BaseSearchPageView(), None)\n\n view.form_class = SearchForm\n\n form = SearchForm(form_data)\n\n form.is_valid()\n\n response = view.form_valid(form)\n\n (url, query) = super(BaseSearchPageViewTestCase, self).parse_url(response)\n\n form_data = super(BaseSearchPageViewTestCase, self).get_data_extra(form_data)\n\n for key, value in form_data.iteritems():\n self.assertTrue(key in query and query[key] == str(value))\n\n # Check we are dealing with a redirect and path as expected is lettings/search\n self.assertIsInstance(response, HttpResponseRedirect)\n self.assertEqual(url.path, '/lettings/search/')","def validate_view(self):\n if self.view and self.get_custom_view() is None:\n raise ValidationError(\"Custom view couldn't be loaded: {}\".\n format(self.view))","def list_campaigns(self, **kwargs) -> ApiResponse:\n return self._request(kwargs.pop('path'), params=kwargs)","def __call__(self, data=None):\n data_combiner = DataCombiner(self.instance, data)\n\n meta = self.instance._meta\n errors = defaultdict(list)\n\n # direct required fields\n for field_name in self.REQUIRED_FIELDS:\n field = meta.get_field(field_name)\n\n if isinstance(field, models.ManyToManyField):\n value = data_combiner.get_value_to_many(field_name)\n else:\n value = data_combiner.get_value(field_name)\n\n if not value:\n errors[field_name] = [self.message]\n\n # extra validators\n extra_errors = self._run_extra_validators(data)\n for field, field_errors in extra_errors.items():\n errors[field] += field_errors\n\n if errors:\n raise ValidationError(errors)","def validate(self, consentDict):\n if(consentDict == None):\n return self.composeResult(API.STATUS_CODE.FAILED, errorMessage=\"Invalid consent dictionary object (null) passed!\")\n\n missingAttrList = []\n tableAttr = CustomerConsentDataTable.TABLE.ATTRIBUTE\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CUSTOMER_MK)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.SOURCE_MARKET)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.COUNTRY)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONTACT_TYPE)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONSENT_STATUS)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONSENT_DATETIME)\n\n contactType = consentDict.get(tableAttr.CONTACT_TYPE)\n contactTypeKey = self.contactTypeKeys.get(contactType)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, contactTypeKey)\n\n if(len(missingAttrList) > 0):\n errorMessage = f\"Consent is missing mandatory attribute(s): {missingAttrList}!\"\n return self.composeResult(API.STATUS_CODE.FAILED, errorMessage=errorMessage)\n\n return self.composeResult(API.STATUS_CODE.SUCCESS, data=consentDict)","def test_context_data_with_valid_search_and_no_results(self):\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)","def validate(self, data):\n if data.has_key('site'):\n if FieldSightXF.objects.filter(\n xf__id=data['xf'], is_staged=False, is_scheduled=True, site=data['site']).exists():\n raise serializers.ValidationError(\"Form Already Exists, Duplicate Forms Not Allowded\")\n elif data.has_key('project'):\n if FieldSightXF.objects.filter(\n xf__id=data['xf'], is_staged=False, is_scheduled=True, project=data['project']).exists():\n raise serializers.ValidationError(\"Form Already Exists, Duplicate Forms Not Allowded\")\n return data","def API_company(request):\n query = request.GET\n if any(key for key in query if key not in API_COMPANY_VALIDKEYS):\n #print([(key,key not in API_COMPANY_VALIDKEYS) for key in query])\n return django.http.HttpResponseBadRequest(\"Invalid query\")\n if \"search\" in query:\n return API_companysearch(request)\n elif \"po\" in query:\n return API_companypo(request)\n return django.http.Http404()","def clean_form(self):\n\n for condition in self.conditional_rules:\n\n all_conditions_passed = True\n\n # Only check if the field is required\n field_required = condition['required']\n if field_required:\n action = condition['action']\n\n for cond in condition['conditions']:\n condition_rule = cond['rule']\n condition_value = cond['value']\n condition_field_value = self.cleaned_data.get(cond['field_name'], None)\n\n all_conditions_passed = conditions_passed(condition_rule, condition_value, condition_field_value)\n if not all_conditions_passed:\n break\n\n if not all_conditions_passed and action == consts.FIELD_ACTION_SHOW:\n if condition['field_name'] in self._errors:\n del self._errors[condition['field_name']]\n elif all_conditions_passed and action == consts.FIELD_ACTION_HIDE:\n if condition['field_name'] in self._errors:\n del self._errors[condition['field_name']]\n\n return self.cleaned_data","def validate(self, view, data):\n\n with self._lock:\n return view and (data.get('id') in self.request_ids[view.id()])","def test_context_data_with_valid_search_and_no_results(self):\n response = self.client.get(self.get_url(), {'description': 'test'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)","def post(self):\n json_data = request.get_json()\n json_data[\"sender_id\"] = current_user.id\n try:\n new_campaign = self.schema.load(json_data)\n except ValidationError as err:\n return {\"message\": err.messages}, HTTPStatus.BAD_REQUEST\n if Campaign.query.filter_by(mailchimp_id=new_campaign.mailchimp_id).first() is not None:\n return {\"message\": \"Campaign already exists.\"}, HTTPStatus.CONFLICT\n db.session.add(new_campaign)\n db.session.commit()\n return self.schema.dump(new_campaign), HTTPStatus.CREATED","def _check_required_fields(self):\n assert self.title\n assert self.format","def validate_all_fields(self):\n\n if self.validate_byr() and \\\n self.validate_iyr() and \\\n self.validate_eyr() and \\\n self.validate_hgt() and \\\n self.validate_hcl() and \\\n self.validate_ecl() and \\\n self.validate_pid() and \\\n self.validate_cid():\n return True\n return False","def send_validation_requested(cls, validation_request, activity):\n\n template_id = settings.SENDINBLUE[\n \"REFERRAL_ANSWER_VALIDATION_REQUESTED_TEMPLATE_ID\"\n ]\n\n contact = validation_request.validator\n\n # Get the first unit from referral linked units the user is a part of.\n # Having a user in two different units both assigned on the same referral is a very\n # specific edge case and picking between those is not an important distinction.\n referral = validation_request.answer.referral\n unit = referral.units.filter(members__id=activity.actor.id).first()\n\n # Get the path to the referral detail view from the unit inbox\n link_path = FrontendLink.unit_referral_detail(\n unit=unit.id, referral=referral.id\n )\n\n data = {\n \"params\": {\n \"case_number\": referral.id,\n \"created_by\": activity.actor.get_full_name(),\n \"link_to_referral\": f\"{cls.location}{link_path}\",\n \"referral_users\": referral.get_users_text_list(),\n \"title\": referral.title or referral.object,\n \"topic\": referral.topic.name,\n \"unit_name\": unit.name,\n },\n \"replyTo\": cls.reply_to,\n \"templateId\": template_id,\n \"to\": [{\"email\": contact.email}],\n }\n\n cls.send(data)","def __ui_choose_search_criteria_for_activities(self):\n print(\"By which criteria do you want to search activities?\\n\"\n \" 1. By date\\n\"\n \" 2. By description\\n\")\n user_choice = input(\"Type your option: \").strip()\n if user_choice == \"1\":\n self.__ui_search_activities_by_date()\n elif user_choice == \"2\":\n self.__ui_search_activities_by_description()\n else:\n print(\"Invalid option!\\n\")\n return","def test_fields_presence(self):\n form = DCEventRequestForm()\n fields_left = set(form.fields.keys())\n fields_right = set([\n 'name', 'email', 'affiliation', 'location', 'country',\n 'conference', 'preferred_date', 'language', 'workshop_type',\n 'approx_attendees', 'attendee_domains', 'attendee_domains_other',\n 'data_types', 'data_types_other', 'attendee_academic_levels',\n 'attendee_data_analysis_level', 'cover_travel_accomodation',\n 'understand_admin_fee', 'fee_waiver_request',\n 'travel_reimbursement', 'travel_reimbursement_other',\n 'comment', 'privacy_consent', 'captcha',\n ])\n self.assertEqual(fields_left, fields_right)","def clean(self):\n data = super().clean()\n if (str(self.instance.resource_type.id) in data['license'].resource_types\n and data['access_policy'] == data['license'].access_policy):\n return data\n\n raise forms.ValidationError('Invalid policy license combination.')","def test_create_new_campaign_by_non_admin_fails(self):\n non_admin = create_canned_user()\n non_admin_token = generate_encoded_token(non_admin.id)\n response = self.client.post(\n self.endpoint_url,\n json={\n \"logo\": None,\n \"name\": CAMPAIGN_NAME,\n \"organisations\": [self.test_org.id],\n \"url\": None,\n },\n headers={\"Authorization\": non_admin_token},\n )\n response_body = response.get_json()\n self.assertEqual(response.status_code, 403)\n self.assertEqual(\n response_body[\"Error\"], \"CampaignsAllAPI POST: User not a Org Manager\"\n )\n self.assertEqual(response_body[\"SubCode\"], \"UserNotPermitted\")","def test_context_data_with_valid_search_and_no_results(self):\n response = self.client.get(self.get_url(), {'description': 'test'})\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.HarmonizedTraitTable)","def is_country_selection_criteria_field_present_in_vendor_profile_destinations_page(self):\n return self.is_specific_selection_criteria_filter_present(self.vendor_profile_destinations_page_div_id, self.country_label_name)","def test_fields_presence(self):\n form = SWCEventRequestForm()\n fields_left = set(form.fields.keys())\n fields_right = set([\n 'name', 'email', 'affiliation', 'location', 'country',\n 'conference', 'preferred_date', 'language', 'workshop_type',\n 'approx_attendees', 'attendee_domains', 'attendee_domains_other',\n 'attendee_academic_levels', 'attendee_computing_levels',\n 'cover_travel_accomodation', 'understand_admin_fee',\n 'travel_reimbursement', 'travel_reimbursement_other',\n 'admin_fee_payment', 'comment', 'captcha', 'privacy_consent',\n ])\n self.assertEqual(fields_left, fields_right)","def validate(self, data):\n\t\tvalidated_data = super(BoxSerializer, self).validate(data)\n\t\tuser = self.context['request'].user\n\t\tcheck_constraint_util = CheckConstraintsUtil(user, validated_data, self.instance) \n\t\treturn check_constraint_util.check_constraints()","def serve(self, request, *args, **kwargs):\n\n template = self.get_template(request)\n\n if request.method == 'POST':\n\n form = self.get_form(request.POST, page=self, user=request.user)\n\n if form.is_valid():\n self.process_form_submission(form)\n return HttpResponseRedirect(self.url + '?thank=you')\n\n else:\n\n thanks = request.GET.get('thank', False)\n if thanks:\n form = None\n template = self.get_landing_page_template(request)\n if self.thanks_page_title:\n self.title = self.thanks_page_title\n else:\n form = self.get_form(page=self, user=request.user)\n\n context = self.get_context(request)\n context['form'] = form\n if form:\n context['conditional_rules'] = json.dumps(form.conditional_rules)\n\n return render(\n request,\n template,\n context\n )","def _get_req_data(kwargs):\n if request.data:\n req = json.loads(request.data, encoding='utf-8')\n else:\n req = request.args or request.form\n\n if 'coid' not in kwargs:\n required_args = [\n 'name',\n 'consrc'\n ]\n\n for arg in required_args:\n if arg not in req or req[arg] == '':\n return True, make_json_response(\n status=410,\n success=0,\n errormsg=gettext(\n \"Could not find the required parameter ({}).\"\n ).format(arg)\n ), req\n return False, '', req","def test_positive_validation_decision(self, form_field_name, user_data):\n self.assertValidationDecision(\n {form_field_name: user_data},\n {form_field_name: ''}\n )","def is_country_selection_criteria_field_present_in_vendor_profile_page(self):\n return self.is_specific_selection_criteria_filter_present(self.vendor_profile_page_div_id, self.country_label_name)","def validate(self) -> None:\n\n if self.field not in self.model.table_fields:\n raise ValueError(f\"Value field {self.field} not present in {self.model.table}\")\n\n if self.pivot:\n if self.pivot not in self.model.table_fields:\n raise ValueError(\n f\"Pivot field {self.pivot} not present in {self.model.table}\"\n )\n\n if self.connector:\n if self.connector not in self.model.table_fields:\n raise ValueError(\n f\"Connector field {self.connector} not present in {self.model.table}\"\n )\n\n for field in self.selectors:\n if field not in self.model.table_fields:\n raise ValueError(f\"Selector field {field} not present in {self.model.table}\")","def has_permission(self, request, view):\n return has_permission(request.user, Permissions.CAN_ADVANCE_SEARCH)","def validate_club(self, club):\n request = self.context['request']\n # pylint: disable=no-member\n profile = UserProfile.objects.get(user=request.user)\n if club not in profile.get_club_privileges():\n raise serializers.ValidationError(\n \"You are not authorized to create workshops for this club\")\n return club","def validate(self, instance=None, REQUEST=None,\n errors=None, data=None, metadata=None, predicates=()):\n if REQUEST:\n fieldset = REQUEST.form.get('fieldset', None)\n else:\n fieldset = None\n fields = []\n\n if fieldset is not None:\n schemata = instance.Schemata()\n fields = [(field.getName(), field)\n for field in schemata[fieldset].fields()\n if not [pred for pred in predicates if not pred(field)]\n ]\n\n else:\n if data:\n fields.extend([(field.getName(), field)\n for field in self.filterFields(isMetadata=0, *predicates)])\n if metadata:\n fields.extend([(field.getName(), field)\n for field in self.filterFields(isMetadata=1, *predicates)])\n\n if REQUEST:\n form = REQUEST.form\n else:\n form = None\n for name, field in fields:\n error = 0\n value = None\n widget = field.widget\n if form:\n result = widget.process_form(instance, field, form,\n empty_marker=_marker)\n else:\n result = None\n if result is None or result is _marker:\n accessor = field.getEditAccessor(instance) or field.getAccessor(instance)\n if accessor is not None:\n value = accessor()\n else:\n # can't get value to validate -- bail\n continue\n else:\n value = result[0]\n\n res = field.validate(instance=instance,\n value=value,\n errors=errors,\n REQUEST=REQUEST)\n if res:\n errors[field.getName()] = res\n return errors","def test_get_non_existent_campaigns_returns_empty_list(self):\n response = self.client.get(self.endpoint_url)\n response_body = response.get_json()\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response_body, {\"campaigns\": []})","def validate(self, request):\n values = {\n 'robot_match_comments':request.POST['robot_match_comments'],\n 'did_foul':'did_foul' in request.POST,\n 'did_technical_foul':'did_technical_foul' in request.POST,\n 'foul_description':request.POST['foul_description'],\n 'did_shoot':'did_shoot' in request.POST,\n 'auto_1':request.POST['auto_1'],\n 'auto_2':request.POST['auto_2'],\n 'auto_3':request.POST['auto_3'],\n 'auto_miss':request.POST['auto_miss'],\n 'teleop_1':request.POST['teleop_1'],\n 'teleop_2':request.POST['teleop_2'],\n 'teleop_3':request.POST['teleop_3'],\n 'teleop_5':request.POST['teleop_5'],\n 'teleop_miss':request.POST['teleop_miss'],\n 'shooting_description':request.POST['shooting_description'],\n 'did_climb':'did_climb' in request.POST,\n 'climb_start':request.POST['climb_start'],\n 'climb_finish':request.POST['climb_finish'],\n 'level_reached':request.POST.get('level_reached'),\n 'frisbees_dumped':request.POST['frisbees_dumped'],\n 'climbing_description':request.POST['climbing_description'],\n 'did_human_load':'did_human_load' in request.POST,\n 'did_ground_load':'did_ground_load' in request.POST,\n 'auto_frisbees_ground_loaded':\\\n request.POST['auto_frisbees_ground_loaded'],\n 'loading_description':request.POST['loading_description'],\n }\n if ((values['did_foul'] or values['did_technical_foul']) and\n not values['foul_description']):\n new_values = self.__dict__.copy()\n new_values.update(values)\n raise ValidationError(\n 'Please enter a description of the foul(s) the robot committed',\n new_values\n )\n if values['did_shoot']:\n try:\n values['auto_1'] = int(values['auto_1'])\n values['auto_2'] = int(values['auto_2'])\n values['auto_3'] = int(values['auto_3'])\n values['auto_miss'] = int(values['auto_miss'])\n values['teleop_1'] = int(values['teleop_1'])\n values['teleop_2'] = int(values['teleop_2'])\n values['teleop_3'] = int(values['teleop_3'])\n values['teleop_5'] = int(values['teleop_5'])\n values['teleop_miss'] = int(values['teleop_miss'])\n except ValueError:\n raise ValidationError(\n 'You must enter a number for all of the shooting numbers',\n self.__dict__.copy().update(values)\n )\n if values['did_climb']:\n try:\n values['climb_start'] = int(values['climb_start'])\n values['climb_finish'] = int(values['climb_finish'])\n try:\n values['level_reached'] = int(values['level_reached'])\n except TypeError:\n new_values = self.__dict__.copy()\n new_values.update(values)\n raise ValidationError(\n 'You must select a level the robot climbed too',\n new_values\n )\n values['frisbees_dumped'] = int(values['frisbees_dumped'])\n except ValueError:\n new_values = self.__dict__.copy()\n new_values.update(values)\n raise ValidationError(\n 'All climbing related numbers must be numbers',\n new_values\n )\n if values['did_ground_load']:\n try:\n values['auto_frisbees_ground_loaded'] = int(\n values['auto_frisbees_ground_loaded'])\n except ValueError:\n new_values = self.__dict__.copy()\n new_values.update(values)\n raise ValidationError(\n 'All numbers of frisbees ground loaded must be numbers',\n new_values\n )\n return values","def validate(self, data):\r\n budgets = Budget.objects.filter(\r\n campaign__pk=self.context['view'].kwargs['campaign_pk']\r\n )\r\n covered = budgets.values_list('start_date', 'end_date')\r\n for each in covered:\r\n sd_fail = (\r\n data['start_date'] >= each[0] and\r\n data['start_date'] <= each[1]\r\n )\r\n ed_fail = (\r\n data['end_date'] >= each[0] and\r\n data['end_date'] <= each[1]\r\n )\r\n over_fail = (\r\n each[0] >= data['start_date'] and\r\n each[1] <= data['end_date']\r\n )\r\n if sd_fail:\r\n raise serializers.ValidationError({\r\n 'start_date': \"Start date conflicts with existing budget\"\r\n })\r\n if ed_fail:\r\n raise serializers.ValidationError({\r\n 'end_date': \"End date conflicts with existing budget\"\r\n })\r\n if over_fail:\r\n raise serializers.ValidationError(\r\n \"Date conflicts with existing budget\"\r\n )\r\n return data","def clean(self):\n cleaned_data = super(AuthorizenetSurveyPurchaseForm, self).clean()\n if cleaned_data.get(\"purchase_code\"):\n return cleaned_data\n\n for f in [\"card_number\", \"card_expiry\", \"card_ccv\"]:\n if not cleaned_data.get(f):\n self.add_error(f, \"Required for card payments\")\n return cleaned_data","def test_census_area_create_agency_restriction(client, user_staff, superuser):\n client.force_login(user_staff)\n url = reverse('census-areas-create')\n staff_response = client.get(url)\n assert staff_response.status_code == 200\n\n field = staff_response.context['form'].fields['restrict_by_agency']\n assert field.initial is True\n assert isinstance(field.widget, HiddenInput)\n\n client.force_login(superuser)\n sup_response = client.get(url)\n assert sup_response.status_code == 200\n\n field = sup_response.context['form'].fields['restrict_by_agency']\n assert field.initial is True\n assert isinstance(field.widget, CheckboxInput)","def test_context_data_with_valid_search_and_some_results(self):\n factories.SourceTraitFactory.create(i_description='lorem ipsum')\n response = self.client.get(self.get_url(), {'description': 'lorem'})\n qs = searches.search_source_traits(description='lorem')\n context = response.context\n self.assertIn('form', context)\n self.assertTrue(context['has_results'])\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\n self.assertQuerysetEqual(qs, [repr(x) for x in context['results_table'].data])"],"string":"[\n \"def index(request):\\n context = dict()\\n if request.user.is_authenticated():\\n context['campaigns'] = [\\n CampaignSerializer(c).serialize() for c in\\n request.user.userprofile.campaigns.order_by('pk')]\\n return render(request, 'voter_validation/index.html', context)\",\n \"def view(args):\\n if args.available:\\n printAvailableCampaigns()\\n if args.search_help:\\n print(getSearchQueryHelp())\",\n \"def validate(self, data):\\n company = data['company']\\n if self.context['request'].user.has_perm(\\\"view_company\\\", company):\\n return data\\n else:\\n raise PermissionDenied()\",\n \"def show_campaigns(request, utm_campaign, **kwargs):\\n \\n err_msg = ''\\n try:\\n err_msg = str(kwargs['kwargs']['err_msg'])\\n except:\\n pass\\n \\n test_type_override = ''\\n try:\\n test_type_override = MySQLdb._mysql.escape_string(request.POST['test_type_override'])\\n \\n if test_type_override == 'Banner':\\n test_type_var = FDH._TESTTYPE_BANNER_\\n elif test_type_override == 'Landing Page':\\n test_type_var = FDH._TESTTYPE_LP_\\n elif test_type_override == 'Banner and LP':\\n test_type_var = FDH._TESTTYPE_BANNER_LP_\\n \\n except:\\n test_type_var = ''\\n pass\\n \\n try:\\n \\\"\\\"\\\" Find the earliest and latest page views for a given campaign \\\"\\\"\\\"\\n lptl = DL.LandingPageTableLoader()\\n ccrml = DL.CiviCRMLoader()\\n \\n start_time = ccrml.get_earliest_donation(utm_campaign)\\n end_time = ccrml.get_latest_donation(utm_campaign)\\n \\n one_step = lptl.is_one_step(start_time, end_time, utm_campaign) \\n \\n if not(one_step): \\n start_time = lptl.get_earliest_campaign_view(utm_campaign)\\n end_time = lptl.get_latest_campaign_view(utm_campaign) \\n\\n interval = 1\\n \\n \\\"\\\"\\\" Create reporting object to retrieve campaign data and write plots to image repo on disk \\\"\\\"\\\"\\n ir = DR.IntervalReporting(was_run=False, use_labels=False, font_size=20, plot_type='line', query_type='campaign', file_path=projSet.__web_home__ + 'campaigns/static/images/')\\n \\n \\\"\\\"\\\" Produce analysis on the campaign view data \\\"\\\"\\\" \\n ir.run(start_time, end_time, interval, 'views', utm_campaign, {}, one_step=one_step)\\n \\n \\\"\\\"\\\" \\n ESTIMATE THE START AND END TIME OF THE CAMPAIGN\\n ===============================================\\n \\n Search for the first instance when more than 10 views are observed over a sampling period\\n \\\"\\\"\\\"\\n \\n col_names = ir._data_loader_.get_column_names()\\n \\n views_index = col_names.index('views')\\n ts_index = col_names.index('ts')\\n \\n row_list = list(ir._data_loader_._results_) # copy the query results\\n for row in row_list:\\n if row[views_index] > 100:\\n start_time_est = row[ts_index]\\n break\\n row_list.reverse()\\n for row in row_list:\\n if row[views_index] > 100:\\n end_time_est = row[ts_index]\\n break\\n \\n \\n \\\"\\\"\\\"\\n BUILD THE VISUALIZATION FOR THE TEST VIEWS OF THIS CAMAPAIGN\\n ============================================================ \\n \\\"\\\"\\\"\\n \\n \\\"\\\"\\\" Read the test name \\\"\\\"\\\"\\n ttl = DL.TestTableLoader()\\n row = ttl.get_test_row(utm_campaign)\\n test_name = ttl.get_test_field(row ,'test_name')\\n \\n \\\"\\\"\\\" Regenerate the data using the estimated start and end times \\\"\\\"\\\"\\n ir = DR.IntervalReporting(was_run=False, use_labels=False, font_size=20, plot_type='line', query_type='campaign', file_path=projSet.__web_home__ + 'campaigns/static/images/')\\n ir.run(start_time_est, end_time_est, interval, 'views', utm_campaign, {}, one_step=one_step)\\n \\n \\\"\\\"\\\" Determine the type of test (if not overridden) and retrieve the artifacts \\\"\\\"\\\"\\n test_type, artifact_name_list = FDH.get_test_type(utm_campaign, start_time, end_time, DL.CampaignReportingLoader(query_type=''), test_type_var)\\n \\n return render_to_response('campaigns/show_campaigns.html', {'utm_campaign' : utm_campaign, 'test_name' : test_name, 'start_time' : start_time_est, 'end_time' : end_time_est, 'one_step' : one_step, \\\\\\n 'artifacts' : artifact_name_list, 'test_type' : test_type, 'err_msg' : err_msg}, context_instance=RequestContext(request)) \\n\\n except Exception as inst:\\n \\n logging.error('Failed to correctly produce campaign diagnostics.')\\n logging.error(type(inst))\\n logging.error(inst.args)\\n logging.error(inst)\\n \\n \\\"\\\"\\\" Return to the index page with an error \\\"\\\"\\\"\\n err_msg = 'There is insufficient data to analyze this campaign: %s. Check to see if the <a href=\\\"/LML/\\\">impressions have been loaded</a>. <br><br>ERROR:<br><br>%s' % (utm_campaign, inst.__str__())\\n \\n return index(request, kwargs={'err_msg' : err_msg})\",\n \"def validate(self, data):\\n company = data['company']\\n invoice = data.get(\\\"invoice\\\")\\n if not self.context['request'].user.has_perm(\\\"view_company\\\", company) or not all(\\n self.context['request'].user.has_perm(\\\"view_media\\\", media) for media in invoice):\\n raise PermissionDenied()\\n return data\",\n \"def validate(self, data):\\n company = data['company']\\n invoice = data.get(\\\"invoice\\\")\\n if not self.context['request'].user.has_perm(\\\"view_company\\\", company) or not all(\\n self.context['request'].user.has_perm(\\\"view_media\\\", media) for media in invoice):\\n raise PermissionDenied()\\n return data\",\n \"def campground_checker_view(request):\\n # If POST request, retrieve data from API\\n if request.method == 'POST':\\n form = forms.CampgroundForm(request.POST)\\n if form.is_valid():\\n start_date = form.cleaned_data['start_date']\\n end_date = form.cleaned_data['end_date']\\n camp_ids = form.cleaned_data['camp_ids']\\n camp_id_list = camp_ids.split()\\n try:\\n results, start_string, end_string = check.master_scraping_routine(camp_id_list, start_date, end_date)\\n return render(request, 'availability_results.html', {'start_date': start_string,\\n 'end_date': end_string,\\n 'results': results})\\n except:\\n return render(request, 'no_results_found.html')\\n else:\\n return 'No success'\\n # If GET or other type of request, load empty form\\n else:\\n form = forms.CampgroundForm()\\n return render(request, 'availability.html', {'form': form})\",\n \"def validate_schema(self, data, **kwargs):\\n if \\\"role\\\" not in data and \\\"visible\\\" not in data:\\n raise ValidationError(_(\\\"Missing fields 'role' and/or 'visible'.\\\"))\",\n \"def __call__(self, data):\\n data_combiner = DataCombiner(self.instance, data)\\n company = data_combiner.get_value(self.company_field)\\n contact = data_combiner.get_value(self.contact_field)\\n\\n if contact.company != company:\\n raise ValidationError({\\n self.contact_field: self.message,\\n })\",\n \"def update_c_mandatory_fields(request, campaign_id):\\n # print(request.POST)\\n campaign = Campaign.objects.get(id=campaign_id)\\n form = CampaignForm(request.POST, instance = campaign)\\n # print(form)\\n if form.is_valid():\\n form.save()\\n return redirect('add_campaign_spec', id=campaign_id)\\n else:\\n # return redirect('clonecampaign', id=campaign_id)\\n print(form.errors)\\n return redirect(reverse('edit_campaign', kwargs={'campaign_id':campaign_id}))\",\n \"def validate(self) -> bool:\\n required = self.crud.validate(required=True)\\n if required:\\n raise ValueError(\\n f\\\"Validation error. Required destination fields are not present in the crosswalk: {required}\\\"\\n )\",\n \"def get_campaign_command(client: Client, campaign_id: str) -> CommandResults | str:\\n try:\\n raw_response = client.get_campaign(campaign_id)\\n except ValueError:\\n return 'Campaign Id not found'\\n\\n campaign_general_fields = ['id', 'name', 'description', 'startDate', 'notable']\\n campaign_fields = ['families', 'techniques', 'actors', 'brands', 'malware']\\n\\n outputs = {}\\n outputs['campaignMembers'] = dict_safe_get(raw_response, ['campaignMembers'])\\n outputs['info'] = {key: value for key, value in raw_response.items() if key in campaign_general_fields}\\n outputs.update({key: value for key, value in raw_response.items() if key in campaign_fields})\\n fields_readable_output = \\\"\\\"\\n for field in campaign_fields:\\n fields_readable_output += \\\"\\\\n\\\" + tableToMarkdown(field.capitalize(),\\n dict_safe_get(outputs, [field]), headers=['id', 'name'],\\n headerTransform=pascalToSpace\\n )\\n\\n campaign_info_output = tableToMarkdown('Campaign Information',\\n outputs['info'],\\n headers=['id', 'name', 'description', 'startDate', 'notable'],\\n headerTransform=pascalToSpace\\n )\\n campaign_members_output = tableToMarkdown('Campaign Members',\\n outputs['campaignMembers'],\\n headers=['id', 'threat', 'type'],\\n headerTransform=pascalToSpace\\n )\\n\\n readable_output = campaign_info_output + \\\"\\\\n\\\" + campaign_members_output + fields_readable_output\\n\\n return CommandResults(\\n readable_output=readable_output,\\n outputs_prefix='Proofpoint.Campaign',\\n outputs=outputs,\\n outputs_key_field='id',\\n raw_response=raw_response\\n )\",\n \"def test_get_campaign_by_id_passes(self):\\n response = self.client.get(f\\\"{self.endpoint_url}{self.test_campaign.id}/\\\")\\n response_body = response.get_json()\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response_body, {\\\"id\\\": CAMPAIGN_ID, \\\"name\\\": CAMPAIGN_NAME})\",\n \"def validate(self, data):\\n # if data['is_private'] and data['contestants']:\\n # raise serializers.ValidationError(\\\"Can not be private and compete for an award.\\\")\\n return data\",\n \"def validate(self):\\n\\n form = CallEventForm(self.data)\\n if not form.is_valid():\\n self.errors = form.errors\\n map_dict_fields(self.errors, const.DB_FIELDS, const.API_FIELDS)\",\n \"def testGetCampaign(self):\\n if self.__class__.campaign1 is None:\\n self.testSaveCampaign()\\n self.assert_(isinstance(self.__class__.service.GetCampaign(\\n self.__class__.campaign1['id']), tuple))\",\n \"def run_validation(self, data=empty):\\n\\n if data is not empty:\\n unknown = set(data) - set(self.fields)\\n if unknown:\\n errors = ['Unknown field: {}'.format(f) for f in unknown]\\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\\n return super().run_validation(data)\",\n \"def validate(self):\\n return self.validator.validate(self.fields)\",\n \"def run_validation(self, data=empty):\\n\\n # no idea why there is no such built in feature in DRF\\n if data is not empty:\\n unknown = set(data) - set(self.fields)\\n if unknown:\\n errors = ['Unknown field: {}'.format(f) for f in unknown]\\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\\n return super().run_validation(data)\",\n \"def test_view_form_valid_sales_method(self, google):\\n google.return_value = GeocoderMock()\\n\\n form_data = super(BaseSearchPageViewTestCase, self).get_data_sales()\\n\\n view = super(BaseSearchPageViewTestCase, self).initialize(BaseSearchPageView(), None)\\n\\n view.form_class = SearchForm\\n\\n form = SearchForm(form_data)\\n\\n form.is_valid()\\n\\n response = view.form_valid(form)\\n\\n (url, query) = super(BaseSearchPageViewTestCase, self).parse_url(response)\\n\\n form_data = super(BaseSearchPageViewTestCase, self).get_data_extra(form_data)\\n\\n for key, value in form_data.iteritems():\\n self.assertTrue(key in query and query[key] == str(value))\\n\\n # Check we are dealing with a redirect and path as expected as sales/search\\n self.assertIsInstance(response, HttpResponseRedirect)\\n self.assertEqual(url.path, '/sales/search/')\",\n \"def send_validation_request(self):\\r\\n self.send_request(send_function=self._assemble_and_send_validation_request)\",\n \"def test_create_new_campaign_by_admin_passes(self):\\n response = self.client.post(\\n self.endpoint_url,\\n json={\\n \\\"logo\\\": None,\\n \\\"name\\\": NEW_CAMPAIGN_NAME,\\n \\\"organisations\\\": [self.test_org.id],\\n \\\"url\\\": None,\\n },\\n headers={\\\"Authorization\\\": self.session_token},\\n )\\n response_body = response.get_json()\\n self.assertEqual(response.status_code, 201)\\n self.assertEqual(response_body, {\\\"campaignId\\\": 2})\",\n \"def test_update_existent_campaign_by_admin_passes(self):\\n response = self.client.patch(\\n f\\\"{self.endpoint_url}{self.test_campaign.id}/\\\",\\n json={\\n \\\"logo\\\": None,\\n \\\"name\\\": NEW_CAMPAIGN_NAME,\\n \\\"organisations\\\": [],\\n \\\"url\\\": None,\\n },\\n headers={\\\"Authorization\\\": self.admin_token},\\n )\\n response_body = response.get_json()\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response_body[\\\"Success\\\"], \\\"Campaign 1 updated\\\")\",\n \"def test_update_existent_campaign_by_unauthenticated_user_fails(self):\\n response = self.client.patch(\\n f\\\"{self.endpoint_url}{self.test_campaign.id}/\\\",\\n json={\\n \\\"logo\\\": None,\\n \\\"name\\\": NEW_CAMPAIGN_NAME,\\n \\\"organisations\\\": [self.test_org.id],\\n \\\"url\\\": None,\\n },\\n )\\n self.assertEqual(response.status_code, 401)\",\n \"def show_validator(self, show_validator):\\n\\n self._show_validator = show_validator\",\n \"def show_validator(self, show_validator):\\n\\n self._show_validator = show_validator\",\n \"def cingValidation(self): \\n \\n self.cingRun()\\n \\n self.analyseCingResults()\",\n \"def check(self, args):\\n self.parent.footer.set_text(\\\"Checking data...\\\")\\n self.parent.refreshScreen()\\n # Get field information\\n responses = dict()\\n\\n for index, fieldname in enumerate(self.fields):\\n if fieldname != \\\"blank\\\":\\n responses[fieldname] = self.edits[index].get_edit_text()\\n\\n password = responses[\\\"FUEL_ACCESS/password\\\"]\\n confirm_password = responses.pop(\\\"CONFIRM_PASSWORD\\\")\\n\\n if self.parent.save_only:\\n return responses\\n\\n # Validate each field\\n errors = []\\n warnings = []\\n\\n # Passwords must match\\n if password != confirm_password and \\\\\\n password != self.defaults['FUEL_ACCESS/password']['value']:\\n errors.append(\\\"Passwords do not match.\\\")\\n\\n # Password must not be empty\\n if len(password) == 0:\\n errors.append(\\\"Password must not be empty.\\\")\\n\\n # Password needs to be in ASCII character set\\n try:\\n if password.decode('ascii'):\\n pass\\n except UnicodeDecodeError:\\n errors.append(\\\"Password contains non-ASCII characters.\\\")\\n\\n # Passwords should be at least 8 symbols\\n if len(password) < 8:\\n warnings.append(\\\"8 symbols\\\")\\n\\n # Passwords should contain at least one digit\\n if re.search(r\\\"\\\\d\\\", password) is None:\\n warnings.append(\\\"one digit\\\")\\n\\n if re.search(r\\\"[A-Z]\\\", password) is None:\\n warnings.append(\\\"one uppercase letter\\\")\\n\\n if re.search(r\\\"[a-z]\\\", password) is None:\\n warnings.append(\\\"one lowercase letter\\\")\\n\\n if re.search(r\\\"[!#$%&'()*+,-@./[\\\\\\\\\\\\]^_`{|}~\\\" + r'\\\"]', password) \\\\\\n is None:\\n warnings.append(\\\"one special character\\\")\\n\\n if len(errors) > 0:\\n log.error(\\\"Errors: %s %s\\\" % (len(errors), errors))\\n modulehelper.ModuleHelper.display_failed_check_dialog(self, errors)\\n return False\\n\\n if len(warnings) > 0:\\n self.parent.footer.set_text(\\\"Warning: Password should have \\\"\\n \\\"at least %s.\\\" % (warnings[0]))\\n else:\\n self.parent.footer.set_text(\\\"No errors found.\\\")\\n\\n return responses\",\n \"def validator(self, *args, **kwargs):\\n if 'framework_slug' not in kwargs:\\n current_app.logger.error(\\\"Required parameter `framework_slug` is undefined for the calling view.\\\")\\n abort(500, \\\"There was a problem accessing this page of your application. Please try again later.\\\")\\n\\n if current_user.is_authenticated and current_user.supplier_id:\\n supplier_framework = self.data_api_client.get_supplier_framework_info(\\n current_user.supplier_id, kwargs['framework_slug']\\n )['frameworkInterest']\\n\\n if supplier_framework['applicationCompanyDetailsConfirmed'] is not True:\\n return abort(400, \\\"You cannot access this part of your application until you have confirmed your \\\"\\n \\\"company details.\\\")\\n\\n return True\",\n \"def validate_get_openings_result(self, result):\\n\\n\\n requiredFields = {'company', 'title', 'url', 'locations'}\\n #optionalFields = {'department', 'description'}\\n\\n for r in result:\\n if not requiredFields.issubset(set(result.keys())):\\n return False\\n\\n return True\",\n \"def validate(self, data: Dict[str, Any]):\\n data[\\\"profile\\\"] = self.context.get(\\\"profile\\\")\\n\\n if data.get(\\\"separate_commission_for_seller_and_buyer\\\") or data.get(\\\"only_seller_commission\\\"):\\n if not data.get(\\\"seller_commission_value\\\") or not data.get(\\\"seller_commission_applied_to\\\") or not data.get(\\\"seller_commission_type\\\"):\\n raise serializers.ValidationError(texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED.format(entity=\\\"Seller's\\\"))\\n\\n if data[\\\"seller_commission_type\\\"] == CommissionAndDiscountType.PERCENT and (not data.get(\\\"seller_price_for_commission\\\") or not data.get(\\\"seller_price_for_commission_applied_to\\\")):\\n raise serializers.ValidationError(\\n texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED_WHEN_PERCENT.format(entity=\\\"Seller's\\\"))\\n\\n if data.get(\\\"separate_commission_for_seller_and_buyer\\\") or data.get(\\\"only_buyer_commission\\\"):\\n if not data.get(\\\"buyer_commission_value\\\") or not data.get(\\\"buyer_commission_applied_to\\\") or not data.get(\\\"buyer_commission_type\\\"):\\n raise serializers.ValidationError(texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED.format(entity=\\\"Buyer's\\\"))\\n\\n if data[\\\"buyer_commission_type\\\"] == CommissionAndDiscountType.PERCENT and (not data.get(\\\"buyer_price_for_commission\\\") or not data.get(\\\"buyer_price_for_commission_applied_to\\\")):\\n raise serializers.ValidationError(\\n texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED_WHEN_PERCENT.format(entity=\\\"Buyer's\\\"))\\n\\n if not data.get(\\\"separate_commission_for_seller_and_buyer\\\") and not data.get(\\\"only_seller_commission\\\") and not data.get(\\\"only_buyer_commission\\\"):\\n if not data.get(\\\"seller_commission_value\\\") or not data.get(\\\"seller_commission_applied_to\\\") or not data.get(\\\"seller_commission_type\\\"):\\n raise serializers.ValidationError(\\n texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED.format(entity=\\\"\\\"))\\n\\n if data[\\\"seller_commission_type\\\"] == CommissionAndDiscountType.PERCENT and (not data.get(\\\"seller_price_for_commission\\\") or not data.get(\\\"seller_price_for_commission_applied_to\\\")):\\n raise serializers.ValidationError(\\n texts.VALIDATION_DATA_FOR_COMMISSION_CALCULATION_REQUIRED_WHEN_PERCENT.format(entity=\\\"\\\"))\\n\\n return data\",\n \"def test_validate_when_user_found(self, view, mget_user):\\n assert view.validate() is None\",\n \"def validate(self):\\n if self.id == None:\\n return False\\n return self.validator.validate(self.fields)\",\n \"def contribute(request, campaign_id, template='campaign/campaign_contribution_form.html'):\\r\\n campaign = get_object_or_404(Campaign.objects.active(), pk=campaign_id)\\r\\n if not campaign.is_free:\\r\\n # Disable direct credit card based contribution\\r\\n request.user.message_set.create(message=_('That payment option is not available for this campaign.'))\\r\\n return HttpResponseRedirect(reverse('view_campaign', kwargs={'campaign_id':campaign_id}))\\r\\n err_msg = None\\r\\n try:\\r\\n qualifies, reasons = campaign.is_user_qualified(request.user)\\r\\n user_profile=request.user.get_profile()\\r\\n data = None\\r\\n if qualifies and request.user.first_name and request.user.last_name:\\r\\n # Skip the form and directly register this event attendee.\\r\\n data = {'first_name':request.user.first_name, \\r\\n 'last_name':request.user.last_name,\\r\\n 'birth_date':user_profile.birth_date}\\r\\n if data or request.method == 'POST':\\r\\n if request.method == 'POST':\\r\\n data = request.POST\\r\\n form = forms.DirectContributionForm(data=data, campaign=campaign, user_profile=user_profile)\\r\\n if form.is_valid():\\r\\n contribution = form.save(commit=True)\\r\\n _log.info('Contribution processed %s', contribution)\\r\\n if contribution.qty > 1:\\r\\n request.user.message_set.create(message=_('Your %s contributions totalling $.2f have been processed. Thank you.' % (contribution.qty, contribution.amount)))\\r\\n elif not campaign.is_free:\\r\\n request.user.message_set.create(message=_('Your contribution of $.2f has been processed. Thank you.' % contribution.amount))\\r\\n else:\\r\\n request.user.message_set.create(message=_('You have successfully joined this free campaign. Thank you.'))\\r\\n return HttpResponseRedirect(reverse('view_campaign', kwargs={'campaign_id':campaign_id}))\\r\\n else:\\r\\n form = forms.DirectContributionForm(campaign=campaign, user_profile=user_profile)\\r\\n ctx = {'campaign':campaign, 'c':campaign, 'form':form}\\r\\n except CampaignError, e:\\r\\n request.user.message_set.create(message=e.message)\\r\\n return HttpResponseRedirect(reverse('view_campaign', kwargs={'campaign_id':campaign.pk}))\\r\\n return render_view(request, template, ctx)\",\n \"def get_adcampaign(self, campaign_id, fields, batch=False):\\n path = '%s' % campaign_id\\n args = {'fields': fields}\\n return self.make_request(path, 'GET', args, batch=batch)\",\n \"def test_context_data_with_valid_search_and_no_results(self):\\n response = self.client.get(self.get_url(), {'description': 'test'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\",\n \"def check_for_required_fields(cls, fields=[], dataDict={}):\\n\\n validateRequired = Validate.required(fields=fields, dataDict=dataDict)\\n if validateRequired['status'] == False:\\n res = jsonify(\\n {'status': 400, 'error': validateRequired['message'], 'data': []})\\n return abort(make_response(res, 400))\\n return True\",\n \"def test_get_existent_campaigns_returns_campaigns_list(self):\\n test_campaign = return_canned_campaign()\\n test_campaign.create()\\n response = self.client.get(self.endpoint_url)\\n response_body = response.get_json()\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(\\n response_body, {\\\"campaigns\\\": [{\\\"id\\\": 1, \\\"name\\\": \\\"Test Campaign\\\"}]}\\n )\",\n \"def validate_arguments(self, contest):\\n #\\n # validation if the contest argument\\n self.validate_variable(Contest, contest)\",\n \"def test_admin_sms_campaign_view_list(self):\\n response = self.client.get('/admin/sms_module/smscampaign/')\\n self.failUnlessEqual(response.status_code, 200)\",\n \"def edit_campaigns(self, **kwargs) -> ApiResponse:\\n return self._request(kwargs.pop('path'), data=kwargs.pop('body'), params=kwargs)\",\n \"def test_request_form_successful(self):\\n response = self.client.get(reverse(\\n 'form', kwargs={'slug': self.agency.slug}))\\n self.assertContains(response, self.agency.name)\",\n \"def get_campaign(self, campaignId, **kwargs) -> ApiResponse:\\n return self._request(fill_query_params(kwargs.pop('path'), campaignId), params=kwargs)\",\n \"def view_edit_validate(request):\\n template_file = \\\"validate_edit_or_validate.html\\\"\\n # get all not validated curations\\n curations = models.Curation.objects.\\\\\\n filter(validated_by=None).\\\\\\n order_by('created').all()\\n template = {'curations': curations}\\n return render_to_response(template_file, template,\\n context_instance=RequestContext(request))\",\n \"def validate_data(self, data):\\n try:\\n event_id = data[\\\"event\\\"]\\n guests = data[\\\"guests\\\"]\\n section = data.get(\\\"section\\\", None)\\n except KeyError:\\n return False, \\\"\\\", \\\"\\\", \\\"\\\"\\n try:\\n event = Event.objects.get(pk=event_id)\\n except Event.DoesNotExist:\\n return False, \\\"\\\", \\\"\\\", \\\"\\\"\\n if not isinstance(guests, list):\\n return False, \\\"\\\", \\\"\\\", \\\"\\\"\\n if section is not None:\\n try:\\n event.venue.sections.get(pk=section)\\n except Section.DoesNotExist:\\n return False, \\\"\\\", \\\"\\\", \\\"\\\"\\n return True, event, guests, section\",\n \"def __call__(self, data=None):\\n if not self.instance.assignees.count():\\n raise ValidationError({\\n 'assignees': [self.no_assignees_message],\\n })\\n\\n if not self.instance.assignees.filter(is_lead=True).count():\\n raise ValidationError({\\n 'assignee_lead': [self.no_lead_assignee_message],\\n })\\n\\n if not self.instance.assignees.aggregate(sum=models.Sum('estimated_time'))['sum']:\\n raise ValidationError({\\n 'assignee_time': [self.no_estimated_time_message],\\n })\",\n \"def validate(self, visibility_field):\\r\\n if self.original_query.filter is wtypes.Unset:\\r\\n self.filter_expr = None\\r\\n else:\\r\\n self.filter_expr = json.loads(self.original_query.filter)\\r\\n self._validate_filter(self.filter_expr)\\r\\n self._replace_isotime_with_datetime(self.filter_expr)\\r\\n self._convert_operator_to_lower_case(self.filter_expr)\\r\\n self._normalize_field_names_for_db_model(self.filter_expr)\\r\\n\\r\\n self._force_visibility(visibility_field)\\r\\n\\r\\n if self.original_query.orderby is wtypes.Unset:\\r\\n self.orderby = None\\r\\n else:\\r\\n self.orderby = json.loads(self.original_query.orderby)\\r\\n self._validate_orderby(self.orderby)\\r\\n self._convert_orderby_to_lower_case(self.orderby)\\r\\n self._normalize_field_names_in_orderby(self.orderby)\\r\\n\\r\\n if self.original_query.limit is wtypes.Unset:\\r\\n self.limit = None\\r\\n else:\\r\\n self.limit = self.original_query.limit\\r\\n\\r\\n if self.limit is not None and self.limit <= 0:\\r\\n msg = _('Limit should be positive')\\r\\n raise ClientSideError(msg)\",\n \"def validate(self, data):\\n request = self.context.get('request')\\n data['poster'] = request.user\\n\\n return validate_complete_address(data)\",\n \"def validate(self):\\r\\n def validation_assert(predicate):\\r\\n \\\"\\\"\\\" Throw a ValidationError if false. \\\"\\\"\\\"\\r\\n if not predicate:\\r\\n raise ProfileDistribution.ValidationError()\\r\\n\\r\\n validation_assert(isinstance(self.feature, str))\\r\\n validation_assert(self.feature in DISPLAY_NAMES)\\r\\n validation_assert(isinstance(self.feature_display_name, str))\\r\\n validation_assert(self.type in ['EASY_CHOICE', 'OPEN_CHOICE'])\\r\\n validation_assert(isinstance(self.data, dict))\\r\\n if self.type == 'EASY_CHOICE':\\r\\n validation_assert(isinstance(self.choices_display_names, dict))\",\n \"def do_validate(self, request, _object):\\n\\n pass\",\n \"def validate_contact(data, err_obj):\\n\\n error_count = 0\\n\\n if not data.get('contact_type').strip():\\n error_count += 1\\n err_obj['contact_type'] = 'Contact Type Required'\\n return\\n\\n phone_or_email_only = False\\n if data.get('contact_type') == 'Phone/Email Only':\\n phone_or_email_only = True\\n\\n if not data.get('contact_priority').strip():\\n error_count += 1\\n err_obj['contact_priority'] = 'Priority Required'\\n\\n if phone_or_email_only:\\n if not data.get('contact_description'):\\n err_obj['contact_description'] = 'Contact Description Required.'\\n error_count += 1\\n\\n # if not data.get('contact_mobile').strip() and not data.get('contact_phone').strip() and not data.get('contact_email').strip() and not data.get('contact_description'):\\n # error_count += 3\\n # err_obj['contact_phone'] = 'Mobile or Phone or Email Required'\\n # err_obj['contact_mobile'] = 'Mobile or Phone or Email Required'\\n # err_obj['contact_email'] = 'Mobile or Phone or Email Required'\\n\\n else:\\n if not data.get('contact_first_name').strip():\\n error_count += 1\\n err_obj['contact_first_name'] = 'Please enter a first name'\\n\\n if not data.get('contact_last_name').strip():\\n error_count += 1\\n err_obj['contact_last_name'] = 'Please enter a last name'\\n\\n if not data.get('contact_postcode').strip():\\n error_count += 1\\n err_obj['contact_postcode'] = 'Please enter a postcode'\\n\\n if not data.get('contact_address_1').strip():\\n error_count += 1\\n err_obj['contact_address_1'] = 'Please enter an address line 1'\\n\\n if not data.get('contact_mobile').strip() and not data.get('contact_phone').strip():\\n error_count += 1\\n err_obj['contact_phone'] = 'Mobile or Phone Required'\\n err_obj['contact_mobile'] = 'Mobile or Phone Required'\\n\\n if data.get('contact_mobile').strip():\\n if not validate_mobile_number(data['contact_mobile'], err_obj, 'contact_mobile'):\\n error_count += 1\\n\\n if data.get('contact_phone').strip():\\n if not validate_phone_number(data['contact_phone'], err_obj, 'contact_phone'):\\n error_count += 1\\n\\n if data.get('contact_email').strip():\\n if not validate_email_addr(data['contact_email'], err_obj, 'contact_email'):\\n error_count += 1\\n\\n if error_count:\\n return\\n\\n return True\",\n \"def test_create_new_campaign_by_unauthenticated_user_fails(self):\\n response = self.client.post(\\n self.endpoint_url,\\n json={\\n \\\"logo\\\": None,\\n \\\"name\\\": CAMPAIGN_NAME,\\n \\\"organisations\\\": [self.test_org.id],\\n \\\"url\\\": None,\\n },\\n )\\n self.assertEqual(response.status_code, 401)\",\n \"def get_campaign(self, campaign_id: str) -> dict:\\n return self.http_request(\\\"GET\\\", f'/campaign/{campaign_id}')\",\n \"def campaign_id(request):\\n\\n user = None\\n response = ApiJsonResponse()\\n try:\\n user = MyUser.objects.get(pk=request.user.pk)\\n except ObjectDoesNotExist:\\n return Response({\\n \\\"msg\\\": _('MSG_USER_NOT_EXIST'),\\n \\\"status\\\": 404\\n }, status=404)\\n try:\\n company = Company.objects.get(owner=user)\\n except:\\n return Response({\\n \\\"msg\\\": _('MSG_COMPANY_NOT_EXIST'),\\n \\\"status\\\": 404\\n }, status=404)\\n try:\\n promotions = Promotion.objects.filter(company=company)\\n except ObjectDoesNotExist:\\n response.set_data(\\\"[]\\\")\\n response.set_result_code(200)\\n response.set_result_msg(\\\"MSG_PROMOTIONS_NOT_FOUNDED\\\")\\n return JsonResponse(response.get_dict())\\n list_of_promotions = []\\n for promotion in promotions:\\n list_of_promotions.append({'name': promotion.campaign_name, 'id': promotion.pk})\\n return Response({\\n \\\"msg\\\": _('MSG_PROMOTION_FOUNDED'),\\n \\\"list_of_promotions\\\": list_of_promotions,\\n \\\"status\\\": 200\\n }, status=200)\",\n \"def test_update_existent_campaign_by_non_admin_fails(self):\\n response = self.client.patch(\\n f\\\"{self.endpoint_url}{self.test_campaign.id}/\\\",\\n json={\\n \\\"logo\\\": None,\\n \\\"name\\\": NEW_CAMPAIGN_NAME,\\n \\\"organisations\\\": [self.test_org.id],\\n \\\"url\\\": None,\\n },\\n headers={\\\"Authorization\\\": self.non_admin_token},\\n )\\n response_body = response.get_json()\\n self.assertEqual(response.status_code, 403)\\n self.assertEqual(\\n response_body[\\\"Error\\\"], \\\"CampaignsRestAPI PATCH: User not a Org Manager\\\"\\n )\\n self.assertEqual(response_body[\\\"SubCode\\\"], \\\"UserNotPermitted\\\")\",\n \"def check_vulnerability_in_result(context):\\n json_data = context.response.json()\\n\\n if \\\"component_analyses\\\" in json_data:\\n vulnerabilities = json_data['component_analyses']['vulnerability']\\n for vulnerability in vulnerabilities:\\n assert \\\"cvss\\\" in vulnerability\\n assert \\\"is_private\\\" in vulnerability\\n assert \\\"vendor_cve_ids\\\" in vulnerability\",\n \"def get(self, campaign_id):\\n campaign = Campaign.query.filter_by(mailchimp_id=campaign_id).first()\\n if campaign is None:\\n return {\\\"message\\\": \\\"Campaign could not be found.\\\"}, HTTPStatus.NOT_FOUND\\n return self.schema.dump(campaign), HTTPStatus.OK\",\n \"def test_params_passed(self, mock_field_validator, mock_error_builder):\\n\\n ChargeTypeValidator.validate(CHARGE_TYPE)\\n\\n calls = [\\n call(CHARGE_TYPE, 'charge-type', 'Charge type', mock_error_builder(),\\n summary_message='Choose one option', inline_message='Choose one option'),\\n call().is_required()\\n ]\\n mock_field_validator.assert_has_calls(calls)\",\n \"def getresult(request):\\r\\n\\r\\n form = forms.SearchForm(request.POST)\\r\\n form.find_minmax_criteria(request.POST)\\r\\n\\r\\n if form.is_valid():\\r\\n\\r\\n headers, results = search.query(form.to_criteria(), form.cleaned_data['sector'], form.cleaned_data['exchange'], form.cleaned_data['show_result'])\\r\\n\\r\\n # show result in response\\r\\n return render_to_response('search/result.html', {\\r\\n 'headers': headers,\\r\\n 'results': results\\r\\n })\\r\\n\\r\\n else:\\r\\n # show error message in response\\r\\n return render_to_response('search/result-error.html', {\\r\\n 'message': 'Please enter details correctly.',\\r\\n 'form': form\\r\\n })\",\n \"def validate(self):\\n if self.tba_key is None:\\n self.log.error(\\n \\\"You are missing the TBA-Key field. Please check https://github.com/team4099/scouting-data-ingest#tba for more information.\\\"\\n )\\n return False\\n\\n self.check_internet_connection()\\n\\n if self.year is None:\\n self.log.error(\\n \\\"You are missing the Year field. Please add one in the style shown below.\\\"\\n )\\n year_example = \\\"\\\"\\\"\\n {\\n \\\"Year\\\": \\\"2020\\\"\\n }\\n \\\"\\\"\\\"\\n console.print(Syntax(year_example, \\\"json\\\"))\\n console.print(\\n \\\"Reference https://github.com/team4099/scouting-data-ingest#configuration for more information.\\\"\\n )\\n return False\\n\\n if self.google_credentials is None:\\n self.log.error(\\n \\\"You are missing the Google-Credentials field. Please check https://github.com/team4099/scouting-data-ingest#google-service-account-credentials-file for more information.\\\"\\n )\\n return False\\n elif not os.path.isfile(f\\\"config/{self.google_credentials}\\\"):\\n self.log.error(\\n \\\"The file listed in the Google-Credentials field does not exist in the config folder. Please place it inside the config folder.\\\"\\n )\\n return False\\n else:\\n try:\\n gc = gspread.service_account(f\\\"./config/{self.google_credentials}\\\")\\n except ValueError as e:\\n self.log.error(\\n \\\"The file listed in the Google-Credentials Field is improper. See below for details.\\\"\\n )\\n self.log.error(e)\\n return False\\n\\n if self.spreadsheet is None:\\n self.log.error(\\n \\\"You are missing the Spreadsheet field. Please check https://github.com/team4099/scouting-data-ingest#spreadsheet for more information.\\\"\\n )\\n return False\\n else:\\n try:\\n gc.open(f\\\"{self.spreadsheet}\\\").get_worksheet(0)\\n except gspread.exceptions.SpreadsheetNotFound:\\n self.log.error(\\n \\\"The file listed in the Spreadsheets field has not been shared with the service account. Please make sure it is.\\\"\\n )\\n return False\\n\\n if self.db_user is None:\\n self.log.error(\\n \\\"You are missing the Database User field. Please check https://github.com/team4099/scouting-data-ingest#mysql for more information.\\\"\\n )\\n return False\\n\\n if self.db_pwd is None:\\n self.log.error(\\n \\\"You are missing the Database Password field. Please check https://github.com/team4099/scouting-data-ingest#mysql for more information.\\\"\\n )\\n return False\\n\\n try:\\n create_engine(\\n f\\\"mysql+pymysql://{self.db_user}:{self.db_pwd}@{self.db_host}/scouting\\\"\\n )\\n except pymysql.err.OperationalError:\\n self.log.error(\\n \\\"Your Database user name and/or password is not correct. Please verify them.\\\"\\n )\\n\\n if self.event is None:\\n self.log.error(\\n \\\"You are missing the Event field. Please check https://github.com/team4099/scouting-data-ingest#event for more information.\\\"\\n )\\n return False\\n\\n if (\\n requests.get(\\n f\\\"https://www.thebluealliance.com/api/v3/event/{self.year}{self.event}\\\",\\n headers={\\\"X-TBA-Auth-Key\\\": self.tba_key},\\n ).status_code\\n == 404\\n ):\\n self.log.error(\\n \\\"The event listed in the TBA-Key field is not valid. Please ensure the event key and year are correct.\\\"\\n )\\n return False\\n\\n if self.simulation:\\n if self.simulator_url is None:\\n self.log.error(\\n \\\"You are missing the Simulator URL field. Please check https://github.com/team4099/scouting-data-ingest#tba for more information.\\\"\\n )\\n return False\\n\\n try:\\n simulator_status = requests.get(\\n f\\\"{self.simulator_url}/matches\\\"\\n ).status_code\\n except (\\n ConnectionRefusedError,\\n urllib3.exceptions.NewConnectionError,\\n requests.exceptions.ConnectionError,\\n ):\\n self.log.error(\\n \\\"The simulator may not be running or it's at a different url than the one provided.\\\"\\n )\\n return False\\n\\n if simulator_status == 401:\\n self.log.error(\\n \\\"The simulator may not be running. Please make sure it is and that it is up-to-date.\\\"\\n )\\n return False\\n\\n if self.simulator_spreadsheet is None:\\n self.log.error(\\n \\\"You are missing the Simulator Spreadsheet field. Please check https://github.com/team4099/scouting-data-ingest#spreadsheet for more information.\\\"\\n )\\n return False\\n else:\\n try:\\n gc.open(f\\\"{self.simulator_spreadsheet}\\\").get_worksheet(0)\\n except gspread.exceptions.SpreadsheetNotFound:\\n self.log.error(\\n \\\"The file listed in the Simulator Spreadsheet field has not been shared with the service account. Please make sure it is. Please also make sure the name entered is correct.\\\"\\n )\\n return False\\n\\n return True\",\n \"def is_field_available(request):\\n if request.method == \\\"GET\\\":\\n get = request.GET.copy()\\n if get.has_key('username'):\\n name = get['username']\\n if User.objects.filter(username__iexact=name):\\n return HttpResponse(False)\\n else:\\n return HttpResponse(True)\\n if get.has_key('email'):\\n email = get['email']\\n if User.objects.filter(email__iexact=email):\\n return HttpResponse(False)\\n else:\\n return HttpResponse(True)\\n\\n return HttpResponseServerError(_(\\\"Requires username or email to test\\\"))\",\n \"async def _show_form(self, errors=None):\\n data_schema = vol.Schema(\\n {\\n vol.Optional(\\n CONF_LATITUDE, default=self.hass.config.latitude\\n ): cv.latitude,\\n vol.Optional(\\n CONF_LONGITUDE, default=self.hass.config.longitude\\n ): cv.longitude,\\n vol.Optional(CONF_RADIUS, default=DEFAULT_RADIUS): cv.positive_int,\\n }\\n )\\n\\n return self.async_show_form(\\n step_id=\\\"user\\\", data_schema=data_schema, errors=errors or {}\\n )\",\n \"def check_for_exposed(context):\\n json_data = context.response.json()\\n if \\\"exploitable_vulnerabilities_count\\\" in json_data:\\n raise Exception(\\\"Field exploitable_vulnerabilities_count Exposed in\\\"\\n \\\" Free user result\\\")\\n if \\\"vendor_package_link\\\" in json_data:\\n raise Exception(\\\"Field vendor_package_link has been exposed for free user\\\")\",\n \"def test_view_form_valid_lettings_method(self, google):\\n google.return_value = GeocoderMock()\\n\\n form_data = super(BaseSearchPageViewTestCase, self).get_data_lettings()\\n\\n view = super(BaseSearchPageViewTestCase, self).initialize(BaseSearchPageView(), None)\\n\\n view.form_class = SearchForm\\n\\n form = SearchForm(form_data)\\n\\n form.is_valid()\\n\\n response = view.form_valid(form)\\n\\n (url, query) = super(BaseSearchPageViewTestCase, self).parse_url(response)\\n\\n form_data = super(BaseSearchPageViewTestCase, self).get_data_extra(form_data)\\n\\n for key, value in form_data.iteritems():\\n self.assertTrue(key in query and query[key] == str(value))\\n\\n # Check we are dealing with a redirect and path as expected is lettings/search\\n self.assertIsInstance(response, HttpResponseRedirect)\\n self.assertEqual(url.path, '/lettings/search/')\",\n \"def validate_view(self):\\n if self.view and self.get_custom_view() is None:\\n raise ValidationError(\\\"Custom view couldn't be loaded: {}\\\".\\n format(self.view))\",\n \"def list_campaigns(self, **kwargs) -> ApiResponse:\\n return self._request(kwargs.pop('path'), params=kwargs)\",\n \"def __call__(self, data=None):\\n data_combiner = DataCombiner(self.instance, data)\\n\\n meta = self.instance._meta\\n errors = defaultdict(list)\\n\\n # direct required fields\\n for field_name in self.REQUIRED_FIELDS:\\n field = meta.get_field(field_name)\\n\\n if isinstance(field, models.ManyToManyField):\\n value = data_combiner.get_value_to_many(field_name)\\n else:\\n value = data_combiner.get_value(field_name)\\n\\n if not value:\\n errors[field_name] = [self.message]\\n\\n # extra validators\\n extra_errors = self._run_extra_validators(data)\\n for field, field_errors in extra_errors.items():\\n errors[field] += field_errors\\n\\n if errors:\\n raise ValidationError(errors)\",\n \"def validate(self, consentDict):\\n if(consentDict == None):\\n return self.composeResult(API.STATUS_CODE.FAILED, errorMessage=\\\"Invalid consent dictionary object (null) passed!\\\")\\n\\n missingAttrList = []\\n tableAttr = CustomerConsentDataTable.TABLE.ATTRIBUTE\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CUSTOMER_MK)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.SOURCE_MARKET)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.COUNTRY)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONTACT_TYPE)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONSENT_STATUS)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONSENT_DATETIME)\\n\\n contactType = consentDict.get(tableAttr.CONTACT_TYPE)\\n contactTypeKey = self.contactTypeKeys.get(contactType)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, contactTypeKey)\\n\\n if(len(missingAttrList) > 0):\\n errorMessage = f\\\"Consent is missing mandatory attribute(s): {missingAttrList}!\\\"\\n return self.composeResult(API.STATUS_CODE.FAILED, errorMessage=errorMessage)\\n\\n return self.composeResult(API.STATUS_CODE.SUCCESS, data=consentDict)\",\n \"def test_context_data_with_valid_search_and_no_results(self):\\n response = self.client.get(self.get_url(self.study.pk), {'description': 'test'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\",\n \"def validate(self, data):\\n if data.has_key('site'):\\n if FieldSightXF.objects.filter(\\n xf__id=data['xf'], is_staged=False, is_scheduled=True, site=data['site']).exists():\\n raise serializers.ValidationError(\\\"Form Already Exists, Duplicate Forms Not Allowded\\\")\\n elif data.has_key('project'):\\n if FieldSightXF.objects.filter(\\n xf__id=data['xf'], is_staged=False, is_scheduled=True, project=data['project']).exists():\\n raise serializers.ValidationError(\\\"Form Already Exists, Duplicate Forms Not Allowded\\\")\\n return data\",\n \"def API_company(request):\\n query = request.GET\\n if any(key for key in query if key not in API_COMPANY_VALIDKEYS):\\n #print([(key,key not in API_COMPANY_VALIDKEYS) for key in query])\\n return django.http.HttpResponseBadRequest(\\\"Invalid query\\\")\\n if \\\"search\\\" in query:\\n return API_companysearch(request)\\n elif \\\"po\\\" in query:\\n return API_companypo(request)\\n return django.http.Http404()\",\n \"def clean_form(self):\\n\\n for condition in self.conditional_rules:\\n\\n all_conditions_passed = True\\n\\n # Only check if the field is required\\n field_required = condition['required']\\n if field_required:\\n action = condition['action']\\n\\n for cond in condition['conditions']:\\n condition_rule = cond['rule']\\n condition_value = cond['value']\\n condition_field_value = self.cleaned_data.get(cond['field_name'], None)\\n\\n all_conditions_passed = conditions_passed(condition_rule, condition_value, condition_field_value)\\n if not all_conditions_passed:\\n break\\n\\n if not all_conditions_passed and action == consts.FIELD_ACTION_SHOW:\\n if condition['field_name'] in self._errors:\\n del self._errors[condition['field_name']]\\n elif all_conditions_passed and action == consts.FIELD_ACTION_HIDE:\\n if condition['field_name'] in self._errors:\\n del self._errors[condition['field_name']]\\n\\n return self.cleaned_data\",\n \"def validate(self, view, data):\\n\\n with self._lock:\\n return view and (data.get('id') in self.request_ids[view.id()])\",\n \"def test_context_data_with_valid_search_and_no_results(self):\\n response = self.client.get(self.get_url(), {'description': 'test'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceDatasetTableFull)\",\n \"def post(self):\\n json_data = request.get_json()\\n json_data[\\\"sender_id\\\"] = current_user.id\\n try:\\n new_campaign = self.schema.load(json_data)\\n except ValidationError as err:\\n return {\\\"message\\\": err.messages}, HTTPStatus.BAD_REQUEST\\n if Campaign.query.filter_by(mailchimp_id=new_campaign.mailchimp_id).first() is not None:\\n return {\\\"message\\\": \\\"Campaign already exists.\\\"}, HTTPStatus.CONFLICT\\n db.session.add(new_campaign)\\n db.session.commit()\\n return self.schema.dump(new_campaign), HTTPStatus.CREATED\",\n \"def _check_required_fields(self):\\n assert self.title\\n assert self.format\",\n \"def validate_all_fields(self):\\n\\n if self.validate_byr() and \\\\\\n self.validate_iyr() and \\\\\\n self.validate_eyr() and \\\\\\n self.validate_hgt() and \\\\\\n self.validate_hcl() and \\\\\\n self.validate_ecl() and \\\\\\n self.validate_pid() and \\\\\\n self.validate_cid():\\n return True\\n return False\",\n \"def send_validation_requested(cls, validation_request, activity):\\n\\n template_id = settings.SENDINBLUE[\\n \\\"REFERRAL_ANSWER_VALIDATION_REQUESTED_TEMPLATE_ID\\\"\\n ]\\n\\n contact = validation_request.validator\\n\\n # Get the first unit from referral linked units the user is a part of.\\n # Having a user in two different units both assigned on the same referral is a very\\n # specific edge case and picking between those is not an important distinction.\\n referral = validation_request.answer.referral\\n unit = referral.units.filter(members__id=activity.actor.id).first()\\n\\n # Get the path to the referral detail view from the unit inbox\\n link_path = FrontendLink.unit_referral_detail(\\n unit=unit.id, referral=referral.id\\n )\\n\\n data = {\\n \\\"params\\\": {\\n \\\"case_number\\\": referral.id,\\n \\\"created_by\\\": activity.actor.get_full_name(),\\n \\\"link_to_referral\\\": f\\\"{cls.location}{link_path}\\\",\\n \\\"referral_users\\\": referral.get_users_text_list(),\\n \\\"title\\\": referral.title or referral.object,\\n \\\"topic\\\": referral.topic.name,\\n \\\"unit_name\\\": unit.name,\\n },\\n \\\"replyTo\\\": cls.reply_to,\\n \\\"templateId\\\": template_id,\\n \\\"to\\\": [{\\\"email\\\": contact.email}],\\n }\\n\\n cls.send(data)\",\n \"def __ui_choose_search_criteria_for_activities(self):\\n print(\\\"By which criteria do you want to search activities?\\\\n\\\"\\n \\\" 1. By date\\\\n\\\"\\n \\\" 2. By description\\\\n\\\")\\n user_choice = input(\\\"Type your option: \\\").strip()\\n if user_choice == \\\"1\\\":\\n self.__ui_search_activities_by_date()\\n elif user_choice == \\\"2\\\":\\n self.__ui_search_activities_by_description()\\n else:\\n print(\\\"Invalid option!\\\\n\\\")\\n return\",\n \"def test_fields_presence(self):\\n form = DCEventRequestForm()\\n fields_left = set(form.fields.keys())\\n fields_right = set([\\n 'name', 'email', 'affiliation', 'location', 'country',\\n 'conference', 'preferred_date', 'language', 'workshop_type',\\n 'approx_attendees', 'attendee_domains', 'attendee_domains_other',\\n 'data_types', 'data_types_other', 'attendee_academic_levels',\\n 'attendee_data_analysis_level', 'cover_travel_accomodation',\\n 'understand_admin_fee', 'fee_waiver_request',\\n 'travel_reimbursement', 'travel_reimbursement_other',\\n 'comment', 'privacy_consent', 'captcha',\\n ])\\n self.assertEqual(fields_left, fields_right)\",\n \"def clean(self):\\n data = super().clean()\\n if (str(self.instance.resource_type.id) in data['license'].resource_types\\n and data['access_policy'] == data['license'].access_policy):\\n return data\\n\\n raise forms.ValidationError('Invalid policy license combination.')\",\n \"def test_create_new_campaign_by_non_admin_fails(self):\\n non_admin = create_canned_user()\\n non_admin_token = generate_encoded_token(non_admin.id)\\n response = self.client.post(\\n self.endpoint_url,\\n json={\\n \\\"logo\\\": None,\\n \\\"name\\\": CAMPAIGN_NAME,\\n \\\"organisations\\\": [self.test_org.id],\\n \\\"url\\\": None,\\n },\\n headers={\\\"Authorization\\\": non_admin_token},\\n )\\n response_body = response.get_json()\\n self.assertEqual(response.status_code, 403)\\n self.assertEqual(\\n response_body[\\\"Error\\\"], \\\"CampaignsAllAPI POST: User not a Org Manager\\\"\\n )\\n self.assertEqual(response_body[\\\"SubCode\\\"], \\\"UserNotPermitted\\\")\",\n \"def test_context_data_with_valid_search_and_no_results(self):\\n response = self.client.get(self.get_url(), {'description': 'test'})\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.HarmonizedTraitTable)\",\n \"def is_country_selection_criteria_field_present_in_vendor_profile_destinations_page(self):\\n return self.is_specific_selection_criteria_filter_present(self.vendor_profile_destinations_page_div_id, self.country_label_name)\",\n \"def test_fields_presence(self):\\n form = SWCEventRequestForm()\\n fields_left = set(form.fields.keys())\\n fields_right = set([\\n 'name', 'email', 'affiliation', 'location', 'country',\\n 'conference', 'preferred_date', 'language', 'workshop_type',\\n 'approx_attendees', 'attendee_domains', 'attendee_domains_other',\\n 'attendee_academic_levels', 'attendee_computing_levels',\\n 'cover_travel_accomodation', 'understand_admin_fee',\\n 'travel_reimbursement', 'travel_reimbursement_other',\\n 'admin_fee_payment', 'comment', 'captcha', 'privacy_consent',\\n ])\\n self.assertEqual(fields_left, fields_right)\",\n \"def validate(self, data):\\n\\t\\tvalidated_data = super(BoxSerializer, self).validate(data)\\n\\t\\tuser = self.context['request'].user\\n\\t\\tcheck_constraint_util = CheckConstraintsUtil(user, validated_data, self.instance) \\n\\t\\treturn check_constraint_util.check_constraints()\",\n \"def serve(self, request, *args, **kwargs):\\n\\n template = self.get_template(request)\\n\\n if request.method == 'POST':\\n\\n form = self.get_form(request.POST, page=self, user=request.user)\\n\\n if form.is_valid():\\n self.process_form_submission(form)\\n return HttpResponseRedirect(self.url + '?thank=you')\\n\\n else:\\n\\n thanks = request.GET.get('thank', False)\\n if thanks:\\n form = None\\n template = self.get_landing_page_template(request)\\n if self.thanks_page_title:\\n self.title = self.thanks_page_title\\n else:\\n form = self.get_form(page=self, user=request.user)\\n\\n context = self.get_context(request)\\n context['form'] = form\\n if form:\\n context['conditional_rules'] = json.dumps(form.conditional_rules)\\n\\n return render(\\n request,\\n template,\\n context\\n )\",\n \"def _get_req_data(kwargs):\\n if request.data:\\n req = json.loads(request.data, encoding='utf-8')\\n else:\\n req = request.args or request.form\\n\\n if 'coid' not in kwargs:\\n required_args = [\\n 'name',\\n 'consrc'\\n ]\\n\\n for arg in required_args:\\n if arg not in req or req[arg] == '':\\n return True, make_json_response(\\n status=410,\\n success=0,\\n errormsg=gettext(\\n \\\"Could not find the required parameter ({}).\\\"\\n ).format(arg)\\n ), req\\n return False, '', req\",\n \"def test_positive_validation_decision(self, form_field_name, user_data):\\n self.assertValidationDecision(\\n {form_field_name: user_data},\\n {form_field_name: ''}\\n )\",\n \"def is_country_selection_criteria_field_present_in_vendor_profile_page(self):\\n return self.is_specific_selection_criteria_filter_present(self.vendor_profile_page_div_id, self.country_label_name)\",\n \"def validate(self) -> None:\\n\\n if self.field not in self.model.table_fields:\\n raise ValueError(f\\\"Value field {self.field} not present in {self.model.table}\\\")\\n\\n if self.pivot:\\n if self.pivot not in self.model.table_fields:\\n raise ValueError(\\n f\\\"Pivot field {self.pivot} not present in {self.model.table}\\\"\\n )\\n\\n if self.connector:\\n if self.connector not in self.model.table_fields:\\n raise ValueError(\\n f\\\"Connector field {self.connector} not present in {self.model.table}\\\"\\n )\\n\\n for field in self.selectors:\\n if field not in self.model.table_fields:\\n raise ValueError(f\\\"Selector field {field} not present in {self.model.table}\\\")\",\n \"def has_permission(self, request, view):\\n return has_permission(request.user, Permissions.CAN_ADVANCE_SEARCH)\",\n \"def validate_club(self, club):\\n request = self.context['request']\\n # pylint: disable=no-member\\n profile = UserProfile.objects.get(user=request.user)\\n if club not in profile.get_club_privileges():\\n raise serializers.ValidationError(\\n \\\"You are not authorized to create workshops for this club\\\")\\n return club\",\n \"def validate(self, instance=None, REQUEST=None,\\n errors=None, data=None, metadata=None, predicates=()):\\n if REQUEST:\\n fieldset = REQUEST.form.get('fieldset', None)\\n else:\\n fieldset = None\\n fields = []\\n\\n if fieldset is not None:\\n schemata = instance.Schemata()\\n fields = [(field.getName(), field)\\n for field in schemata[fieldset].fields()\\n if not [pred for pred in predicates if not pred(field)]\\n ]\\n\\n else:\\n if data:\\n fields.extend([(field.getName(), field)\\n for field in self.filterFields(isMetadata=0, *predicates)])\\n if metadata:\\n fields.extend([(field.getName(), field)\\n for field in self.filterFields(isMetadata=1, *predicates)])\\n\\n if REQUEST:\\n form = REQUEST.form\\n else:\\n form = None\\n for name, field in fields:\\n error = 0\\n value = None\\n widget = field.widget\\n if form:\\n result = widget.process_form(instance, field, form,\\n empty_marker=_marker)\\n else:\\n result = None\\n if result is None or result is _marker:\\n accessor = field.getEditAccessor(instance) or field.getAccessor(instance)\\n if accessor is not None:\\n value = accessor()\\n else:\\n # can't get value to validate -- bail\\n continue\\n else:\\n value = result[0]\\n\\n res = field.validate(instance=instance,\\n value=value,\\n errors=errors,\\n REQUEST=REQUEST)\\n if res:\\n errors[field.getName()] = res\\n return errors\",\n \"def test_get_non_existent_campaigns_returns_empty_list(self):\\n response = self.client.get(self.endpoint_url)\\n response_body = response.get_json()\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response_body, {\\\"campaigns\\\": []})\",\n \"def validate(self, request):\\n values = {\\n 'robot_match_comments':request.POST['robot_match_comments'],\\n 'did_foul':'did_foul' in request.POST,\\n 'did_technical_foul':'did_technical_foul' in request.POST,\\n 'foul_description':request.POST['foul_description'],\\n 'did_shoot':'did_shoot' in request.POST,\\n 'auto_1':request.POST['auto_1'],\\n 'auto_2':request.POST['auto_2'],\\n 'auto_3':request.POST['auto_3'],\\n 'auto_miss':request.POST['auto_miss'],\\n 'teleop_1':request.POST['teleop_1'],\\n 'teleop_2':request.POST['teleop_2'],\\n 'teleop_3':request.POST['teleop_3'],\\n 'teleop_5':request.POST['teleop_5'],\\n 'teleop_miss':request.POST['teleop_miss'],\\n 'shooting_description':request.POST['shooting_description'],\\n 'did_climb':'did_climb' in request.POST,\\n 'climb_start':request.POST['climb_start'],\\n 'climb_finish':request.POST['climb_finish'],\\n 'level_reached':request.POST.get('level_reached'),\\n 'frisbees_dumped':request.POST['frisbees_dumped'],\\n 'climbing_description':request.POST['climbing_description'],\\n 'did_human_load':'did_human_load' in request.POST,\\n 'did_ground_load':'did_ground_load' in request.POST,\\n 'auto_frisbees_ground_loaded':\\\\\\n request.POST['auto_frisbees_ground_loaded'],\\n 'loading_description':request.POST['loading_description'],\\n }\\n if ((values['did_foul'] or values['did_technical_foul']) and\\n not values['foul_description']):\\n new_values = self.__dict__.copy()\\n new_values.update(values)\\n raise ValidationError(\\n 'Please enter a description of the foul(s) the robot committed',\\n new_values\\n )\\n if values['did_shoot']:\\n try:\\n values['auto_1'] = int(values['auto_1'])\\n values['auto_2'] = int(values['auto_2'])\\n values['auto_3'] = int(values['auto_3'])\\n values['auto_miss'] = int(values['auto_miss'])\\n values['teleop_1'] = int(values['teleop_1'])\\n values['teleop_2'] = int(values['teleop_2'])\\n values['teleop_3'] = int(values['teleop_3'])\\n values['teleop_5'] = int(values['teleop_5'])\\n values['teleop_miss'] = int(values['teleop_miss'])\\n except ValueError:\\n raise ValidationError(\\n 'You must enter a number for all of the shooting numbers',\\n self.__dict__.copy().update(values)\\n )\\n if values['did_climb']:\\n try:\\n values['climb_start'] = int(values['climb_start'])\\n values['climb_finish'] = int(values['climb_finish'])\\n try:\\n values['level_reached'] = int(values['level_reached'])\\n except TypeError:\\n new_values = self.__dict__.copy()\\n new_values.update(values)\\n raise ValidationError(\\n 'You must select a level the robot climbed too',\\n new_values\\n )\\n values['frisbees_dumped'] = int(values['frisbees_dumped'])\\n except ValueError:\\n new_values = self.__dict__.copy()\\n new_values.update(values)\\n raise ValidationError(\\n 'All climbing related numbers must be numbers',\\n new_values\\n )\\n if values['did_ground_load']:\\n try:\\n values['auto_frisbees_ground_loaded'] = int(\\n values['auto_frisbees_ground_loaded'])\\n except ValueError:\\n new_values = self.__dict__.copy()\\n new_values.update(values)\\n raise ValidationError(\\n 'All numbers of frisbees ground loaded must be numbers',\\n new_values\\n )\\n return values\",\n \"def validate(self, data):\\r\\n budgets = Budget.objects.filter(\\r\\n campaign__pk=self.context['view'].kwargs['campaign_pk']\\r\\n )\\r\\n covered = budgets.values_list('start_date', 'end_date')\\r\\n for each in covered:\\r\\n sd_fail = (\\r\\n data['start_date'] >= each[0] and\\r\\n data['start_date'] <= each[1]\\r\\n )\\r\\n ed_fail = (\\r\\n data['end_date'] >= each[0] and\\r\\n data['end_date'] <= each[1]\\r\\n )\\r\\n over_fail = (\\r\\n each[0] >= data['start_date'] and\\r\\n each[1] <= data['end_date']\\r\\n )\\r\\n if sd_fail:\\r\\n raise serializers.ValidationError({\\r\\n 'start_date': \\\"Start date conflicts with existing budget\\\"\\r\\n })\\r\\n if ed_fail:\\r\\n raise serializers.ValidationError({\\r\\n 'end_date': \\\"End date conflicts with existing budget\\\"\\r\\n })\\r\\n if over_fail:\\r\\n raise serializers.ValidationError(\\r\\n \\\"Date conflicts with existing budget\\\"\\r\\n )\\r\\n return data\",\n \"def clean(self):\\n cleaned_data = super(AuthorizenetSurveyPurchaseForm, self).clean()\\n if cleaned_data.get(\\\"purchase_code\\\"):\\n return cleaned_data\\n\\n for f in [\\\"card_number\\\", \\\"card_expiry\\\", \\\"card_ccv\\\"]:\\n if not cleaned_data.get(f):\\n self.add_error(f, \\\"Required for card payments\\\")\\n return cleaned_data\",\n \"def test_census_area_create_agency_restriction(client, user_staff, superuser):\\n client.force_login(user_staff)\\n url = reverse('census-areas-create')\\n staff_response = client.get(url)\\n assert staff_response.status_code == 200\\n\\n field = staff_response.context['form'].fields['restrict_by_agency']\\n assert field.initial is True\\n assert isinstance(field.widget, HiddenInput)\\n\\n client.force_login(superuser)\\n sup_response = client.get(url)\\n assert sup_response.status_code == 200\\n\\n field = sup_response.context['form'].fields['restrict_by_agency']\\n assert field.initial is True\\n assert isinstance(field.widget, CheckboxInput)\",\n \"def test_context_data_with_valid_search_and_some_results(self):\\n factories.SourceTraitFactory.create(i_description='lorem ipsum')\\n response = self.client.get(self.get_url(), {'description': 'lorem'})\\n qs = searches.search_source_traits(description='lorem')\\n context = response.context\\n self.assertIn('form', context)\\n self.assertTrue(context['has_results'])\\n self.assertIsInstance(context['results_table'], tables.SourceTraitTableFull)\\n self.assertQuerysetEqual(qs, [repr(x) for x in context['results_table'].data])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5706519","0.5386401","0.5315525","0.530953","0.51058286","0.51058286","0.48647565","0.4818601","0.47097164","0.46946898","0.46497676","0.4634922","0.46242386","0.45637044","0.449959","0.44929436","0.44728902","0.44613764","0.44438702","0.4442745","0.44330058","0.4426822","0.4408353","0.43987724","0.43857944","0.43857944","0.43846133","0.43533403","0.4345847","0.43383792","0.43270802","0.43234354","0.43206164","0.43179658","0.42991236","0.42925334","0.42923397","0.4290313","0.42749974","0.42627463","0.42603013","0.4256027","0.42371538","0.42315382","0.42258146","0.42215025","0.42154354","0.4211992","0.42083305","0.42079517","0.42048466","0.419826","0.41880703","0.41840306","0.41818509","0.4161982","0.41619077","0.41527897","0.41422802","0.4139899","0.4136058","0.41333628","0.4132349","0.41303486","0.4127781","0.4127455","0.4119001","0.41152492","0.4115241","0.41133142","0.4113177","0.41109475","0.4098598","0.40985823","0.4094262","0.4093622","0.40880835","0.4077336","0.40758267","0.40706965","0.4070667","0.406262","0.40612164","0.40598866","0.40581584","0.4052234","0.40511668","0.404885","0.4047613","0.40466687","0.40380368","0.4037637","0.40376276","0.40332305","0.40329728","0.40325627","0.402533","0.40234828","0.40219554","0.40188754"],"string":"[\n \"0.5706519\",\n \"0.5386401\",\n \"0.5315525\",\n \"0.530953\",\n \"0.51058286\",\n \"0.51058286\",\n \"0.48647565\",\n \"0.4818601\",\n \"0.47097164\",\n \"0.46946898\",\n \"0.46497676\",\n \"0.4634922\",\n \"0.46242386\",\n \"0.45637044\",\n \"0.449959\",\n \"0.44929436\",\n \"0.44728902\",\n \"0.44613764\",\n \"0.44438702\",\n \"0.4442745\",\n \"0.44330058\",\n \"0.4426822\",\n \"0.4408353\",\n \"0.43987724\",\n \"0.43857944\",\n \"0.43857944\",\n \"0.43846133\",\n \"0.43533403\",\n \"0.4345847\",\n \"0.43383792\",\n \"0.43270802\",\n \"0.43234354\",\n \"0.43206164\",\n \"0.43179658\",\n \"0.42991236\",\n \"0.42925334\",\n \"0.42923397\",\n \"0.4290313\",\n \"0.42749974\",\n \"0.42627463\",\n \"0.42603013\",\n \"0.4256027\",\n \"0.42371538\",\n \"0.42315382\",\n \"0.42258146\",\n \"0.42215025\",\n \"0.42154354\",\n \"0.4211992\",\n \"0.42083305\",\n \"0.42079517\",\n \"0.42048466\",\n \"0.419826\",\n \"0.41880703\",\n \"0.41840306\",\n \"0.41818509\",\n \"0.4161982\",\n \"0.41619077\",\n \"0.41527897\",\n \"0.41422802\",\n \"0.4139899\",\n \"0.4136058\",\n \"0.41333628\",\n \"0.4132349\",\n \"0.41303486\",\n \"0.4127781\",\n \"0.4127455\",\n \"0.4119001\",\n \"0.41152492\",\n \"0.4115241\",\n \"0.41133142\",\n \"0.4113177\",\n \"0.41109475\",\n \"0.4098598\",\n \"0.40985823\",\n \"0.4094262\",\n \"0.4093622\",\n \"0.40880835\",\n \"0.4077336\",\n \"0.40758267\",\n \"0.40706965\",\n \"0.4070667\",\n \"0.406262\",\n \"0.40612164\",\n \"0.40598866\",\n \"0.40581584\",\n \"0.4052234\",\n \"0.40511668\",\n \"0.404885\",\n \"0.4047613\",\n \"0.40466687\",\n \"0.40380368\",\n \"0.4037637\",\n \"0.40376276\",\n \"0.40332305\",\n \"0.40329728\",\n \"0.40325627\",\n \"0.402533\",\n \"0.40234828\",\n \"0.40219554\",\n \"0.40188754\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62158144"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8992,"cells":{"query":{"kind":"string","value":"this test only works if ANs fall within separate bins,"},"document":{"kind":"string","value":"def test_iter_bins_API_input_missing_bin(pqo_STRING, args_dict, foreground, background, enrichment_method):\n # foreground, background, enrichment_method = fixture_fg_bg_iter_bins\n fg = format_for_REST_API(foreground[foreground.notnull()])\n bg = format_for_REST_API(background.loc[background.background.notnull(), \"background\"])\n in_ = format_for_REST_API(background.loc[background.intensity.notnull(), \"intensity\"])\n\n # ui = userinput.REST_API_input(pqo=pqo_STRING, foreground_string=fg, background_string=bg, background_intensity=in_, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n args_dict_temp = args_dict.copy()\n args_dict_temp.update({\"foreground\":fg, \"background\":bg, \"intensity\":in_, \"num_bins\":NUM_BINS, \"enrichment_method\":enrichment_method})\n ui = userinput.REST_API_input(pqo_STRING, args_dict=args_dict_temp)\n\n counter = 0\n for ans, weight_fac in ui.iter_bins():\n # every weighting factor is a float\n assert isinstance(weight_fac, float) or isinstance(weight_fac, int)\n counter += 1\n # since integers instead of floats are being used for test data, the number of unique bins can be determined by sets\n num_min_iterations_expected = len({int(ele) for ele in ui.foreground[\"intensity\"].tolist()})\n assert counter >= num_min_iterations_expected"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_bins(self):\n\n \n for filename in ['data/population_padang_1.asc', \n 'data/test_grid.asc']: \n \n R = read_coverage(filename)\n \n min, max = R.get_extrema() #use_numeric=True)\n \n for N in [2,3,5,7,10,16]:\n linear_intervals = R.get_bins(N=N, quantiles=False) \n \n assert linear_intervals[0] == min\n assert linear_intervals[-1] == max \n \n d = (max-min)/N\n for i in range(N):\n assert numpy.allclose(linear_intervals[i], min + i*d) \n \n \n quantiles = R.get_bins(N=N, quantiles=True)\n\n A = R.get_data(nan=True).flat[:] \n \n mask = numpy.logical_not(numpy.isnan(A)) # Omit NaN's\n l1 = len(A)\n A = A.compress(mask) \n l2 = len(A)\n \n if filename == 'data/test_grid.asc':\n # Check that NaN's were removed\n \n assert l1 == 35\n assert l2 == 30\n \n \n # Assert that there are no NaN's \n assert not numpy.alltrue(numpy.isnan(A))\n \n number_of_elements = len(A)\n average_elements_per_bin = number_of_elements/N\n \n # Count elements in each bin and check\n\n i0 = quantiles[0]\n for i1 in quantiles[1:]:\n count = numpy.sum((i0 < A) & (A < i1))\n if i0 == quantiles[0]:\n refcount = count\n \n \n if i1 < quantiles[-1]:\n # Number of elements in each bin must vary by no more than 1\n assert abs(count - refcount) <= 1 \n assert abs(count - average_elements_per_bin) <= 3\n \n \n else:\n # The last bin is allowed vary by more\n pass\n \n i0 = i1","def test_bins(self):\n\n for filename in ['%s/population_padang_1.asc' % TESTDATA,\n '%s/test_grid.asc' % TESTDATA]:\n\n R = read_layer(filename)\n rmin, rmax = R.get_extrema()\n\n for N in [2, 3, 5, 7, 10, 16]:\n linear_intervals = R.get_bins(N=N, quantiles=False)\n\n assert linear_intervals[0] == rmin\n assert linear_intervals[-1] == rmax\n\n d = (rmax - rmin) / N\n for i in range(N):\n assert numpy.allclose(linear_intervals[i], rmin + i * d)\n\n quantiles = R.get_bins(N=N, quantiles=True)\n A = R.get_data(nan=True).flat[:]\n\n mask = numpy.logical_not(numpy.isnan(A)) # Omit NaN's\n l1 = len(A)\n A = A.compress(mask)\n l2 = len(A)\n\n if filename == '%s/test_grid.asc' % TESTDATA:\n # Check that NaN's were removed\n assert l1 == 35\n assert l2 == 30\n\n # Assert that there are no NaN's\n assert not numpy.alltrue(numpy.isnan(A))\n\n number_of_elements = len(A)\n average_elements_per_bin = number_of_elements / N\n\n # Count elements in each bin and check\n i0 = quantiles[0]\n for i1 in quantiles[1:]:\n count = numpy.sum((i0 < A) & (A < i1))\n if i0 == quantiles[0]:\n refcount = count\n\n if i1 < quantiles[-1]:\n # Number of elements in each bin must vary by no\n # more than 1\n assert abs(count - refcount) <= 1\n assert abs(count - average_elements_per_bin) <= 3\n else:\n # The last bin is allowed vary by more\n pass\n\n i0 = i1","def test_output_range(self):\n byt = bytscl(self.array1)\n outside = (byt < 0) | (byt > 255)\n total = numpy.sum(outside)\n self.assertEqual(total, 0)","def test_numpy_bins(self):\n # Load the data from the fixture\n data = load_occupancy(return_dataset=True)\n X, y = data.to_numpy()\n\n visualizer = BalancedBinningReference()\n visualizer.fit(y)\n visualizer.finalize()\n self.assert_images_similar(visualizer, tol=0.5)","def bin_stats(x,y,xbins,stat='average'):\n nbins=len(xbins)\n if stat=='average' or stat=='mean': func=mean\n elif stat=='median': func=median\n elif stat=='rms' or stat=='std' : func=std\n elif stat=='std_robust' or stat=='rms_robust': func=std_robust\n elif stat=='mean_robust': func=mean_robust\n elif stat=='median_robust': func=median_robust\n elif stat=='sum': func=sum\n results=[]\n for i in range(nbins):\n if i<nbins-1:\n good=(greater_equal(x,xbins[i])\n *less(x,xbins[i+1]))\n else: good=(greater_equal(x,xbins[-1]))\n if sum(good)>1.: results.append(func(compress(good,y)))\n else:\n results.append(0.)\n print('Bin starting at xbins[%i] has %i points' % (i,sum(good)))\n return array(results)","def azAverage(self,rads,vals,nbins=50):\n\t\ttry:\n\t\t\tavVals = []\n\t\t\tbins = np.linspace(0,self.annulus,nbins)\n\t\t\tfor i, bin in enumerate(bins[:-1]):\n\t\t\t\tav = np.max(vals[(rads>bins[i]) & (rads<=bins[i+1])])\n\t\t\t\tavVals.append(av)\n\t\texcept:\n\t\t\t#if bin size is too small, and some bins have no particles, make bins bigger\n\t\t\tnbins=25\t\t\t\n\t\t\tavVals = []\n\t\t\tbins = np.linspace(0,self.annulus,nbins)\n\t\t\tfor i, bin in enumerate(bins[:-1]):\n\t\t\t\ttry:\n\t\t\t\t\tav = np.max(vals[(rads>bins[i]) & (rads<=bins[i+1])])\n\t\t\t\texcept:\n\t\t\t\t\tav = 0\n\t\t\t\tavVals.append(av)\n\t\treturn bins[:-1], avVals","def __ptBin(self,pt):\n if len(self._ptbins)>0:\n return reduce(lambda x,y:x+y,map(lambda x:pt>x,self._ptbins))\n else:\n return 0","def test_nonmonotonic_bins(self):\n\n with pytest.raises(ValueError) as verr:\n avg.median2D(self.testInst, np.array([0., 300., 100.]), 'longitude',\n np.array([0., 24., 13.]), 'mlt',\n ['dummy1', 'dummy2', 'dummy3'], auto_bin=False)\n\n estr = 'bins must be monotonically increasing or decreasing'\n assert str(verr).find(estr) >= 0\n\n return","def bininator(magbins, dlt, mags, err):\n meds = np.zeros_like(magbins)\n for i in range(len(magbins)):\n ind = (mags > magbins[i] - dlt) & (mags <= magbins[i] + dlt)\n ind = ind & (err < 10.)\n meds[i] = np.median(err[ind])\n return meds","def test_nonmonotonic_bins(self):\n\n with pytest.raises(ValueError) as verr:\n avg.median1D(self.testInst, [0, 13, 5], self.test_label,\n self.test_data, auto_bin=False)\n\n estr = 'bins must be monotonically increasing or decreasing'\n assert str(verr).find(estr) >= 0\n\n return","def test_bin_edges(self):\n with Pandas() as pd:\n if pd is None:\n return\n with Numpy() as np:\n if numpy is None:\n return\n sys.stderr.write(\"\\n\")\n\n df1 = pd.DataFrame({'A': [0, 1, 2, 3, 4, 3, 2, 1, 1, 1]})\n df2 = pd.DataFrame({'A': [2, 3, 4, 5, 7, 4, 6, 5, 7, 8]})\n\n # building test histograms\n hist2 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\n hist3 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\n hist4 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\n hist5 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\n hist6 = hg.Bin(num=201, low=0.0, high=1.005)\n\n # fill them\n hist2.fill.numpy(df1)\n hist3.fill.numpy(df2)\n hist4.fill.numpy(df1)\n hist5.fill.numpy(df2)\n\n import numpy as np\n np.testing.assert_array_equal(hist2.bin_edges(), [0., 1., 2., 3., 4., 5.])\n np.testing.assert_array_equal(hist3.bin_edges(), [2., 3., 4., 5., 6., 7., 8., 9.])\n np.testing.assert_array_equal(hist4.bin_edges(), [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\n np.testing.assert_array_equal(hist5.bin_edges(), [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\n\n np.testing.assert_array_equal(hist2.bin_edges(low=2.1, high=11.9), [\n 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.])\n np.testing.assert_array_equal(hist3.bin_edges(low=1.1, high=6), [1., 2., 3., 4., 5., 6.])\n np.testing.assert_array_equal(hist4.bin_edges(low=2.1, high=11.9), [\n 2., 3., 4., 5., 6., 7., 8., 9., 10.])\n np.testing.assert_array_equal(hist5.bin_edges(low=1.1, high=5.4), [1., 2., 3., 4., 5., 6.])\n\n assert len(hist6.bin_edges()) == 202\n assert len(hist6.bin_edges(low=0.2089, high=0.9333)) == 147\n assert len(hist6.bin_edges(low=0.205, high=0.935)) == 147","def bincalc(nbin=0.1,bmin=5,bmax=2000):\n\n logbmin=np.log10(bmin)\n logbmax=np.log10(bmax)\n\n logbins=np.arange(logbmin,logbmax,nbin)\n\n bins=10**logbins\n\n #bins=np.linspace(bmin,bmax,60)\n return (bins)","def test_bins(self):\n min_val = 0\n max_val = 1\n buckets = 10\n values_per_bucket = 10\n\n import numpy\n\n data = list(numpy.linspace(min_val, max_val, buckets * values_per_bucket))\n bins = numpy.linspace(min_val, max_val + sys.float_info.epsilon, buckets + 1)\n digitized = numpy.digitize(data, bins)\n counts = numpy.bincount(digitized)\n self.assertEqual(buckets + 1, len(counts))\n self.assertEqual(0, counts[0])\n for bucket in counts[1:]:\n self.assertEqual(values_per_bucket, bucket)","def test_bin_entries(self):\n with Pandas() as pd:\n if pd is None:\n return\n with Numpy() as np:\n if numpy is None:\n return\n sys.stderr.write(\"\\n\")\n\n df1 = pd.DataFrame(\n {'A': [0, 1, 2, 3, 4, 3, 2, 1, 1, 1], 'C': ['f1', 'f3', 'f4', 'f3', 'f4', 'f2', 'f2', 'f1', 'f3', 'f4']})\n df2 = pd.DataFrame(\n {'A': [2, 3, 4, 5, 7, 4, 6, 5, 7, 8], 'C': ['f7', 'f3', 'f5', 'f8', 'f9', 'f2', 'f3', 'f6', 'f7', 'f7']})\n\n # building 1d-, 2d-, and 3d-histogram (iteratively)\n hist0 = hg.Categorize(unit('C'))\n hist1 = hg.Categorize(unit('C'))\n hist2 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\n hist3 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\n hist4 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\n hist5 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\n\n # fill them\n hist0.fill.numpy(df1)\n hist1.fill.numpy(df2)\n hist2.fill.numpy(df1)\n hist3.fill.numpy(df2)\n hist4.fill.numpy(df1)\n hist5.fill.numpy(df2)\n\n labels0 = hist0.bin_labels()\n labels1 = hist1.bin_labels()\n centers2 = hist2.bin_centers()\n centers3 = hist3.bin_centers()\n centers = hist4.bin_centers()\n\n import numpy as np\n np.testing.assert_array_equal(hist0.bin_entries(), [2., 2., 3., 3.])\n np.testing.assert_array_equal(hist1.bin_entries(), [1., 2., 1., 1., 3., 1., 1.])\n np.testing.assert_array_equal(hist0.bin_entries(labels=labels1), [2., 3., 0., 0., 0., 0., 0.])\n np.testing.assert_array_equal(hist1.bin_entries(labels=labels0), [0., 1., 2., 0.])\n\n np.testing.assert_array_equal(hist2.bin_entries(), [1., 4., 2., 2., 1.])\n np.testing.assert_array_equal(hist3.bin_entries(), [1., 1., 2., 2., 1., 2., 1.])\n np.testing.assert_array_equal(hist4.bin_entries(), [1., 4., 2., 2., 1., 0., 0., 0., 0., 0.])\n np.testing.assert_array_equal(hist5.bin_entries(), [0., 0., 1., 1., 2., 2., 1., 2., 1., 0.])\n\n np.testing.assert_array_equal(hist2.bin_entries(xvalues=centers3), [2., 2., 1., 0., 0., 0., 0.])\n np.testing.assert_array_equal(hist3.bin_entries(xvalues=centers2), [0., 0., 1., 1., 2.])\n np.testing.assert_array_equal(hist2.bin_entries(xvalues=centers), [\n 1., 4., 2., 2., 1., 0., 0., 0., 0., 0.])\n np.testing.assert_array_equal(hist3.bin_entries(xvalues=centers), [\n 0., 0., 1., 1., 2., 2., 1., 2., 1., 0.])\n\n np.testing.assert_array_equal(hist2.bin_entries(low=2.1, high=11.9), [\n 2., 2., 1., 0., 0., 0., 0., 0., 0., 0.])\n np.testing.assert_array_equal(hist3.bin_entries(low=1.1, high=5.4), [0., 1., 1., 2., 2.])\n np.testing.assert_array_equal(hist4.bin_entries(low=2.1, high=11.9), [2., 2., 1., 0., 0., 0., 0., 0.])\n np.testing.assert_array_equal(hist5.bin_entries(low=1.1, high=5.4), [0., 1., 1., 2., 2.])","def hist_bin_opt (x, minbin=20, maxbin=600, spacing=10, N_trials=1):\n bin_checks = np.arange(minbin, maxbin, spacing)\n # bin_checks = np.linspace(150, 300, 16)\n costs = np.zeros(len(bin_checks))\n i = 0\n # this might be vectorizable in np\n for n_bins in bin_checks:\n # use np.histogram to do the numerical minimization\n pdf, bin_edges = np.histogram(x, n_bins)\n # calculate bin width\n # some discrepancy here but should be fine\n w_bin = np.unique(np.diff(bin_edges))\n if len(w_bin) > 1: w_bin = w_bin[0]\n # calc mean and var\n kbar = np.mean(pdf)\n kvar = np.var(pdf)\n # calc cost\n costs[i] = (2.*kbar - kvar) / (N_trials * w_bin)**2.\n i += 1\n # find the bin size corresponding to a minimization of the costs\n bin_opt_list = bin_checks[costs.min() == costs]\n bin_opt = bin_opt_list[0]\n return bin_opt","def metric_iaf_binned(self, x, bins=10): \n data = np.asarray(x['data'])\n iaf = [10.0] * data.shape[0]\n for ch, ch_data in enumerate(data):\n pxx, freqs = mlab.psd(ch_data, Fs=128.0, NFFT=256)\n alpha_mask = np.abs(freqs - 10) <= 2.0\n alpha_pxx = 10*np.log10(pxx[alpha_mask])\n alpha_pxx = scipy.signal.detrend(alpha_pxx)\n # iaf[ch] = alpha_pxx.shape\n iaf[ch] = freqs[alpha_mask][np.argmax(alpha_pxx)]\n iaf = float(np.mean(iaf))\n bin = int(np.digitize((iaf,), np.linspace(8,12, bins+1)))\n return (bin, iaf)","def bins_match (a, b):\n return 0 == (\n np.sum ((a.xbins - b.xbins)**2)\n + np.sum ((a.ybins - b.ybins)**2) )","def conceptcover(bin_arr, limit=1, uncovered=0.1):\n arr = np.copy(bin_arr)\n arr_sum = np.sum(arr)\n result = []\n while True:\n k = kernel(arr)\n i = intent(bin_arr, k)\n e = extent(bin_arr, i)\n if len(e)*len(i) < limit or (e, i) in result: break\n result.append((e, i))\n arr = removed(arr, e, i)\n if np.sum(arr)/arr_sum < uncovered: break\n return result","def __check(self):\n if len(self._data)!=len(self._ptbins)+1: \n raise IndexError('Pt bins mismatch')\n for ptbin in self._data:\n if len(ptbin)!=len(self._etabins)+1:\n raise IndexError('Eta bins mismatch')","def bineval(ratings, gold, pred, increment=50, bins = [0, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600, 2700, 2800]):\n\n pw_accs = [(r, int(b==c)) for r,b,c in sorted(zip(ratings, gold, pred))]\n \n binned_accs = []\n current_acc = 0\n denom = 0\n bin_id = 0\n \n for r, acc in pw_accs:\n while r > bins[bin_id] + increment:\n bin_id += 1\n if denom == 0:\n binned_accs.append(float(\"NaN\"))\n else:\n binned_accs.append(current_acc/float(denom))\n current_acc = 0\n denom = 0\n current_acc += acc\n denom += 1\n\n if denom == 0:\n binned_accs.append(float(\"NaN\"))\n else:\n binned_accs.append(current_acc/float(denom))\n\n for b, acc in zip(bins, binned_accs):\n print b, acc","def test_pandas_bins(self):\n # Load the data from the fixture\n data = load_occupancy(return_dataset=True)\n X, y = data.to_pandas()\n\n visualizer = BalancedBinningReference()\n visualizer.fit(y)\n visualizer.finalize()\n self.assert_images_similar(visualizer, tol=0.5)","def bin_statistics(data,bin_against,bin_edges,data_signal=[]):\n\n assert isinstance(data, pd.DataFrame), 'data must be of type pd.DataFram' \n try: bin_against = np.asarray(bin_against) \n except: 'bin_against must be of type np.ndarray'\n try: bin_edges = np.asarray(bin_edges)\n except: 'bin_edges must be of type np.ndarray' \n\n # Determine variables to analyze\n if len(data_signal)==0: # if not specified, bin all variables\n data_signal=data.columns.values\n else:\n assert isinstance(data_signal, list), 'must be of type list'\n\n # Pre-allocate list variables\n bin_stat_list = []\n bin_std_list = []\n\n # loop through data_signal and get binned means\n for signal_name in data_signal:\n # Bin data\n bin_stat = binned_statistic(bin_against,data[signal_name],\n statistic='mean',bins=bin_edges)\n # Calculate std of bins\n std = []\n stdev = pd.DataFrame(data[signal_name])\n stdev.set_index(bin_stat.binnumber,inplace=True)\n for i in range(1,len(bin_stat.bin_edges)):\n try:\n temp = stdev.loc[i].std(ddof=0)\n std.append(temp[0])\n except:\n std.append(np.nan)\n bin_stat_list.append(bin_stat.statistic)\n bin_std_list.append(std)\n \n # Convert to DataFrames\n bin_mean = pd.DataFrame(np.transpose(bin_stat_list),columns=data_signal)\n bin_std = pd.DataFrame(np.transpose(bin_std_list),columns=data_signal)\n\n # Check for nans \n if bin_mean.isna().any().any():\n print('Warning: some bins may be empty!')\n\n return bin_mean, bin_std","def test_range_argument(self):\n # we test with range from 0 to 2, with 3 bins -> [0, 0.66, 1.33, 2] exp. bins\n bins_range = (0, 2)\n bins_exp = np.array([0, 2 / 3, 1 + 1 / 3, 2])\n hist_exp = np.array([1, 2, 0])\n\n bin_edges, hist, _, _ = hist_w_unc(\n self.input,\n bins=self.n_bins,\n bins_range=bins_range,\n normed=False,\n )\n\n # check if we end up with the same bin edges anyway\n np.testing.assert_array_almost_equal(bins_exp, bin_edges)\n np.testing.assert_array_almost_equal(hist_exp, hist)","def test_binops(self):","def __call__(self, n_bins, segment, elements):\n\n # n_bins\n assert type(n_bins) is int\n assert n_bins > 0\n\n # segment\n assert type(segment) is list or type(segment) is tuple\n assert len(segment) == 2\n assert np.isscalar(segment[0]) and np.isscalar(segment[1])\n assert segment[0] < segment[1]\n\n # elements\n assert type(elements) is np.ndarray, f\"elements should be an np.ndarray, instead of {type(elements)}\"\n assert elements.dtype == np.number\n\n raise NotImplemented","def test_range_argument_ignored(self):\n bins_range = (1, 2)\n\n bin_edges, hist, _, _ = hist_w_unc(\n self.input,\n bins=self.bin_edges,\n bins_range=bins_range,\n normed=False,\n )\n\n # check if we end up with the same bin edges anyway\n np.testing.assert_array_almost_equal(self.bin_edges, bin_edges)\n np.testing.assert_array_almost_equal(self.hist, hist)","def test_irregular(self):\n import numpy as np\n import histogrammar\n\n h = histogrammar.IrregularlyBin([0, 10, 20, 40, 100])\n h.fillnumpy([-5, 5, 5, 50, 10, 100, 1000, 50, 50])\n\n np.testing.assert_array_equal(h.bin_entries(), [1., 2., 1., 0., 3., 2.])\n np.testing.assert_array_equal(h.bin_edges(), [float('-inf'), 0., 10., 20., 40., 100., float('inf')])\n np.testing.assert_array_equal(h.bin_centers(), [float('-inf'), 5., 15., 30., 70., float('inf')])\n assert h.num_bins() == 6\n assert h.n_bins == 6\n np.testing.assert_almost_equal(h.mpv, 70.)\n\n np.testing.assert_array_equal(h.bin_entries(10, 40), [1., 0.])\n np.testing.assert_array_equal(h.bin_edges(10, 40), [10., 20., 40.])\n np.testing.assert_array_equal(h.bin_centers(10, 40), [15., 30.])\n assert h.num_bins(10, 40) == 2\n\n np.testing.assert_array_equal(h.bin_entries(5, 110), [2., 1., 0., 3., 2.])\n np.testing.assert_array_equal(h.bin_edges(5, 110), [0., 10., 20., 40., 100., float('inf')])\n np.testing.assert_array_equal(h.bin_centers(5, 110), [5., 15., 30., 70., float('inf')])\n assert h.num_bins(5, 110) == 5","def _get_optimal_threshold(arr, num_bins=1001, num_quantized_bins=255):\n if not isinstance(arr, np.ndarray):\n raise TypeError('get_optimal_threshold only supports input type of np.ndarray,'\n ' while received type=%s' % (str(type(arr))))\n min_val = np.min(arr)\n max_val = np.max(arr)\n th = max(abs(min_val), abs(max_val))\n\n hist, hist_edges = np.histogram(arr, bins=num_bins, range=(-th, th))\n zero_bin_idx = num_bins // 2\n num_half_quantized_bins = num_quantized_bins // 2\n assert np.allclose(hist_edges[zero_bin_idx] + hist_edges[zero_bin_idx + 1],\n 0, rtol=1e-5, atol=1e-7)\n\n thresholds = np.zeros(num_bins // 2 + 1 - num_quantized_bins // 2)\n divergence = np.zeros_like(thresholds)\n quantized_bins = np.zeros(num_quantized_bins, dtype=np.int32)\n # i means the number of bins on half axis excluding the zero bin.\n for i in range(num_quantized_bins // 2,\n num_bins // 2 + 1):\n p_bin_idx_start = zero_bin_idx - i\n p_bin_idx_stop = zero_bin_idx + i + 1\n thresholds[i - num_half_quantized_bins] = hist_edges[p_bin_idx_stop]\n sliced_nd_hist = hist[p_bin_idx_start:p_bin_idx_stop]\n\n # generate reference distribution p\n p = sliced_nd_hist.copy()\n assert p.size % 2 == 1\n assert p.size >= num_quantized_bins\n # put left outlier count in p[0]\n left_outlier_count = np.sum(hist[0:p_bin_idx_start])\n p[0] += left_outlier_count\n # put right outlier count in p[-1]\n right_outlier_count = np.sum(hist[p_bin_idx_stop:])\n p[-1] += right_outlier_count\n # is_nonzeros[k] indicates whether hist[k] is nonzero\n is_nonzeros = (sliced_nd_hist != 0).astype(np.int32)\n\n # calculate how many bins should be merged to generate quantized distribution q\n num_merged_bins = p.size // num_quantized_bins\n # merge hist into num_quantized_bins bins\n for j in range(num_quantized_bins):\n start = j * num_merged_bins\n stop = start + num_merged_bins\n quantized_bins[j] = sliced_nd_hist[start:stop].sum()\n quantized_bins[-1] += sliced_nd_hist[num_quantized_bins * num_merged_bins:].sum()\n # expand quantized_bins into p.size bins\n q = np.zeros(p.size, dtype=np.float32)\n for j in range(num_quantized_bins):\n start = j * num_merged_bins\n if j == num_quantized_bins - 1:\n stop = -1\n else:\n stop = start + num_merged_bins\n norm = is_nonzeros[start:stop].sum()\n if norm != 0:\n q[start:stop] = float(quantized_bins[j]) / float(norm)\n q[sliced_nd_hist == 0] = 0\n p = _smooth_distribution(p)\n # There is a chance that q is an invalid probability distribution.\n try:\n q = _smooth_distribution(q)\n except ValueError:\n divergence[i - num_half_quantized_bins] = float(\"inf\")\n else:\n divergence[i - num_half_quantized_bins] = stats.entropy(p, q)\n quantized_bins[:] = 0\n\n min_divergence_idx = np.argmin(divergence)\n min_divergence = divergence[min_divergence_idx]\n opt_th = thresholds[min_divergence_idx]\n return min_val, max_val, min_divergence, opt_th","def bins_match (a, b):\n return np.sum ((a.bins - b.bins)**2) == 0","def __call__(self, n_bins, segment, elements):\n\n # n_bins\n assert type(n_bins) is int\n assert n_bins > 0\n\n # segment\n assert type(segment) is list or type(segment) is tuple\n assert len(segment) == 2\n assert np.isscalar(segment[0]) and np.isscalar(segment[1])\n assert segment[0] < segment[1]\n\n # elements\n assert type(elements) is np.ndarray, f\"elements should be an np.ndarray, instead of {type(elements)}\"\n assert elements.dtype == np.number\n\n sorted_elements = np.sort(elements)\n\n bin_card = int(floor(elements.shape[0]/n_bins))\n\n bin_boundaries = [segment[0]]\n\n for i in range(1, n_bins):\n boundary_l = sorted_elements[i*bin_card - 1]\n boundary_r = sorted_elements[i * bin_card]\n boundary = (boundary_l+boundary_r)/2\n\n bin_boundaries.append(boundary)\n\n bin_boundaries.append(segment[1])\n\n return np.array(bin_boundaries)","def __init__(self, x, bin_edges, Nsamp):\n raw_vals, bin_edges = np.histogram(x, bins=bin_edges, normed=False)\n self.bin_edges = bin_edges\n self.bin_widths = np.diff(self.bin_edges)\n self.bin_centers = 0.5*(self.bin_edges[:-1] + self.bin_edges[1:])\n \n P, low, high = np.array([BinomialErrors(v, Nsamp) for v in raw_vals]).T\n self.raw_vals = P\n self.raw_low = low\n self.raw_high = high\n self.complete_vals = None\n self.malm_vals = None\n return","def binarize(adata, copy=False):\n threshold, upper, lower = 1.0, 1.0, 0.0\n admatrix = adata.X\n admatrix = np.where(admatrix>threshold, upper, lower)\n if copy:\n adata2 = adata.copy()\n adata2.X = admatrix\n return(adata2)\n else:\n adata.X = admatrix","def amp_bin(raw, depth, low, high):\n\n max_in_depth = 2 ** depth\n bin_range = np.linspace(low, high, max_in_depth)\n data = []\n for b in raw:\n i = 0\n while i <= (max_in_depth - 2):\n if (bin_range[i] <= b < bin_range[i+1]):\n data.append(i)\n i += 1\n break\n elif (b <= low):\n data.append(0)\n break\n elif (b >= high):\n data.append(max_in_depth - 1)\n break\n else:\n i += 1\n return np.array(data)","def test_num_bins(self):\n with Pandas() as pd:\n if pd is None:\n return\n with Numpy() as np: # noqa\n if numpy is None:\n return\n sys.stderr.write(\"\\n\")\n\n df1 = pd.DataFrame({'A': [0, 2, 4, 5, 7, 9, 11, 13, 13, 15]})\n df2 = pd.DataFrame({'A': [2, 4, 4, 6, 8, 7, 10, 14, 17, 19]})\n\n # building 1d-, 2d-, and 3d-histogram (iteratively)\n hist2 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\n hist3 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\n hist4 = hg.Bin(num=20, low=0.0, high=20., quantity=unit('A'))\n hist5 = hg.Bin(num=20, low=0.0, high=20., quantity=unit('A'))\n hist6 = hg.Bin(num=201, low=0.0, high=1.005)\n\n # fill them\n hist2.fill.numpy(df1)\n hist3.fill.numpy(df2)\n hist4.fill.numpy(df1)\n hist5.fill.numpy(df2)\n\n assert hist2.num_bins() == 16\n assert hist3.num_bins() == 18\n assert hist4.num_bins() == 20\n assert hist5.num_bins() == 20\n assert hist6.num_bins() == 201\n\n assert hist2.num_bins(low=10, high=25) == 15\n assert hist3.num_bins(low=10, high=25) == 15\n assert hist4.num_bins(low=10, high=25) == 10\n assert hist5.num_bins(low=10, high=25) == 10\n assert hist6.num_bins(low=0.2089, high=0.9333) == 146\n\n assert hist2.num_bins(low=-10, high=28) == 38\n assert hist3.num_bins(low=-10, high=28) == 38\n assert hist4.num_bins(low=-10, high=28) == 20\n assert hist5.num_bins(low=-10, high=28) == 20\n assert hist6.num_bins(low=0.205, high=0.935) == 146","def __etaBin(self,eta):\n if len(self._etabins)>0:\n return reduce(lambda x,y:x+y,map(lambda x:abs(eta)>x,self._etabins))\n else:\n return 0","def test08(self):\n a = np.arange(1, 11)\n b = bcolz.carray(a)\n ul = [v for v in a if v <= 5]\n u = b.where(a <= 5)\n wl = [v for v in a if v <= 6]\n w = b.where(a <= 6)\n self.assertEqual(ul, list(u))\n self.assertEqual(wl, list(w))","def autobin_stats(x,y,n_bins=8,stat='average',n_points=None):\n \n if not ascend(x):\n ix=argsort(x)\n x=take(x,ix)\n y=take(y,ix)\n n=len(x)\n if n_points==None: \n #This throws out some points\n n_points=n/n_bins\n else: \n n_bins=n/n_points\n #if there are more that 2 points in the last bin, add another bin\n if n%n_points>2: n_bins=n_bins+1\n \n if n_points<=1:\n print('Only 1 or less points per bin, output will be sorted input vector with rms==y')\n return x,y\n xb,yb=[],[]\n \n #print 'stat', stat\n if stat=='average' or stat=='mean': func=mean\n elif stat=='median': func=median\n elif stat=='rms' or stat=='std' : func=std\n elif stat=='std_robust' or stat=='rms_robust': func=std_robust\n elif stat=='mean_robust': func=mean_robust\n elif stat=='median_robust': func=median_robust\n elif stat=='p2p': func=p2p # --DC\n elif stat=='min': func=min # --DC\n elif stat=='max': func=max # --DC\n \n for i in range(n_bins):\n xb.append(mean(x[i*n_points:(i+1)*n_points]))\n if func==std and n_points==2:\n print('n_points==2; too few points to determine rms')\n print('Returning abs(y1-y2)/2. in each bin as rms')\n yb.append(abs(y[i*n_points]-y[i*n_points+1])/2.)\n else:\n yb.append(func(y[i*n_points:(i+1)*n_points]))\n if i>2 and xb[-1]==xb[-2]: \n yb[-2]=(yb[-2]+yb[-1])/2.\n xb=xb[:-1]\n yb=yb[:-1]\n return array(xb),array(yb)","def affect(self, bin_boundaries, element):\n\n # bin_boundaries\n assert type(bin_boundaries) is np.ndarray\n\n # element\n assert isinstance(element, (int, float, np.number)), \\\n \"element = {} should be of a numeric type, not {}.\".format(element, type(element))\n assert bin_boundaries[0] <= element <= bin_boundaries[-1]\n\n n_bins = len(bin_boundaries) - 1\n m = floor(element * n_bins) if floor(element * n_bins) < n_bins else n_bins - 1\n\n return m","def __init__(self, bins):\n self.bins = bins","def test_hgbat(self):\n fun = get_problem('hgbat', self.dimension, -100, 100)\n self.assertAlmostEqual(fun(self.array10), 61.91502622129181, delta=60)","def compute_acc_bin(conf_thresh_lower, conf_thresh_upper, conf, pred, true):\n filtered_tuples = [x for x in zip(pred, true, conf) if x[2] > conf_thresh_lower and x[2] <= conf_thresh_upper]\n if len(filtered_tuples) < 1:\n return 0,0,0\n else:\n correct = len([x for x in filtered_tuples if x[0] == x[1]]) # How many correct labels\n len_bin = len(filtered_tuples) # How many elements falls into given bin\n avg_conf = sum([x[2] for x in filtered_tuples]) / len_bin # Avg confidence of BIN\n accuracy = float(correct)/len_bin # accuracy of BIN\n return accuracy, avg_conf, len_bin","def compute_acc_bin(conf_thresh_lower, conf_thresh_upper, conf, pred, true):\n filtered_tuples = [x for x in zip(pred, true, conf) if x[2] > conf_thresh_lower and x[2] <= conf_thresh_upper]\n if len(filtered_tuples) < 1:\n return 0,0,0\n else:\n correct = len([x for x in filtered_tuples if x[0] == x[1]]) # How many correct labels\n len_bin = len(filtered_tuples) # How many elements falls into given bin\n avg_conf = sum([x[2] for x in filtered_tuples]) / len_bin # Avg confidence of BIN\n accuracy = float(correct)/len_bin # accuracy of BIN\n return accuracy, avg_conf, len_bin","def II_eq_counts(tobin_series, num_bins):\n num_pbin = int(len(tobin_series) / num_bins)\n obs_list = tobin_series.sort_values().tolist()\n upper_bounds = [obs_list[(i + 1) * num_pbin] for i in range(num_bins)]\n lower_bounds = [0]\n lower_bounds += upper_bounds[:-1]\n return pd.IntervalIndex.from_arrays(lower_bounds, upper_bounds), upper_bounds","def bin_data(bins, data2bin, bindata, mode='mean', nbinned=False):\n assert mode in ['mean', 'median', 'std', 'max', 'min'], \"mode not recognized: {}\".format(mode)\n digitized = np.digitize(bindata, bins)\n binned = np.zeros(len(bins)) * np.nan\n if nbinned: \n numbinned = np.zeros(len(bins))\n\n if mode == 'mean':\n for i, _ in enumerate(bins):\n binned[i] = np.nanmean(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n elif mode == 'median':\n for i, _ in enumerate(bins):\n binned[i] = np.nanmedian(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n elif mode == 'std':\n for i, _ in enumerate(bins):\n binned[i] = np.nanstd(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n elif mode == 'max':\n for i, _ in enumerate(bins):\n binned[i] = np.nanmax(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n elif mode == 'min':\n for i, _ in enumerate(bins):\n binned[i] = np.nanmin(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n else:\n raise ValueError('mode must be mean, median, std, max, or min')\n \n if nbinned:\n return np.array(binned), np.array(numbinned)\n else:\n return np.array(binned)","def binarize(X, *, threshold=..., copy=...):\n ...","def process_pain(x, lb, ub):\n x = x.abs()\n x.loc[(x > ub)] = 8\n x.loc[(x < lb) | (x > ub)] = np.nan\n return x","def calculate_bin_edges(n_bins, geo):\n #Gefittete offsets: x,y,factor: factor*(x+x_off)\n #[6.19, 0.064, 1.0128]\n \n #print \"Reading detector geometry in order to calculate the detector dimensions from file \" + fname_geo_limits\n #geo = np.loadtxt(fname_geo_limits)\n\n # derive maximum and minimum x,y,z coordinates of the geometry input [[first_OM_id, xmin, ymin, zmin], [last_OM_id, xmax, ymax, zmax]]\n geo_limits = np.nanmin(geo, axis = 0), np.nanmax(geo, axis = 0)\n #print ('Detector dimensions [[first_OM_id, xmin, ymin, zmin], [last_OM_id, xmax, ymax, zmax]]: ' + str(geo_limits))\n\n x_bin_edges = np.linspace(geo_limits[0][1] - 9.95, geo_limits[1][1] + 9.95, num=n_bins[0] + 1) #try to get the lines in the bin center 9.95*2 = average x-separation of two lines\n y_bin_edges = np.linspace(geo_limits[0][2] - 9.75, geo_limits[1][2] + 9.75, num=n_bins[1] + 1) # Delta y = 19.483\n z_bin_edges = np.linspace(geo_limits[0][3] - 4.665, geo_limits[1][3] + 4.665, num=n_bins[2] + 1) # Delta z = 9.329\n\n #offset_x, offset_y, scale = [6.19, 0.064, 1.0128]\n #x_bin_edges = (x_bin_edges + offset_x )*scale\n #y_bin_edges = (y_bin_edges + offset_y )*scale\n\n #calculate_bin_edges_test(geo, y_bin_edges, z_bin_edges) # test disabled by default. Activate it, if you change the offsets in x/y/z-bin-edges\n\n return x_bin_edges, y_bin_edges, z_bin_edges","def _loop_over_entries(x_bins, y_bins, used_eff, n_out_bins):\n sys.stdout.write('finding eff at rejection... ')\n sys.stdout.flush()\n\n valid_x = (x_bins >= 0) & (x_bins < n_out_bins) \n valid_y = (y_bins >= 0) & (y_bins < n_out_bins)\n\n valid_indices = np.flatnonzero(valid_x & valid_y)\n\n x_bins = x_bins[valid_indices]\n y_bins = y_bins[valid_indices]\n used_eff = used_eff[valid_indices]\n\n eff_array = np.ones((n_out_bins,n_out_bins)) * -1\n for x_bin, y_bin, z in zip(x_bins, y_bins, used_eff): \n # y_bin comes first because that's what imshow wants... \n eff_array[y_bin,x_bin] = max(z, eff_array[y_bin,x_bin])\n\n sys.stdout.write('done\\n')\n return eff_array","def __call__(self, n_bins, segment, elements):\n\n # n_bins\n assert type(n_bins) is int\n assert n_bins > 0\n\n # segment\n assert type(segment) is list or type(segment) is tuple\n assert len(segment) == 2\n assert np.isscalar(segment[0]) and np.isscalar(segment[1])\n assert segment[0] < segment[1]\n\n # elements\n assert type(elements) is np.ndarray, f\"elements should be an np.ndarray, instead of {type(elements)}\"\n assert elements.dtype == np.number\n\n return np.array([segment[0] + i / n_bins * (segment[1] - segment[0])\n for i in range(n_bins)]\n + [float(segment[1])])","def bin_data(y, num_bins, std_away):\n mean = np.mean(y)\n std = np.std(y)\n pitch_shifts = np.arange(-num_bins, num_bins + 1)\n thresholds = (std * std_away) * pitch_shifts + mean\n\n result = []\n for point in y:\n if point < thresholds[0]:\n result.append(pitch_shifts[0] - 1)\n elif point > thresholds[-1]:\n result.append(pitch_shifts[-1] + 1)\n else:\n for i in range(len(thresholds) - 1):\n if point >= thresholds[i] and point < thresholds[i + 1]:\n result.append(i - num_bins)\n return np.array(result)","def _determine_histogram_bins(self, ma_maps):\n if isinstance(ma_maps, list):\n ma_values = self.masker.transform(ma_maps)\n elif isinstance(ma_maps, np.ndarray):\n ma_values = ma_maps.copy()\n else:\n raise ValueError(f\"Unsupported data type '{type(ma_maps)}'\")\n\n # Determine bins for null distribution histogram\n # Remember that numpy histogram bins are bin edges, not centers\n # Assuming values of 0, .001, .002, etc., bins are -.0005-.0005, .0005-.0015, etc.\n INV_STEP_SIZE = 100000\n step_size = 1 / INV_STEP_SIZE\n max_ma_values = np.max(ma_values, axis=1)\n # round up based on resolution\n max_ma_values = np.ceil(max_ma_values * INV_STEP_SIZE) / INV_STEP_SIZE\n max_poss_ale = self.compute_summarystat(max_ma_values)\n # create bin centers\n hist_bins = np.round(np.arange(0, max_poss_ale + (1.5 * step_size), step_size), 5)\n self.null_distributions_[\"histogram_bins\"] = hist_bins","def _bin(self, X):\n H = np.linspace(0, 1, self.Nbin)\n return np.maximum(1 - (abs(X[..., None] - H)) / (H[1] - H[0]) , 0)","def mu_law_bins(num_bins):\n #all edges\n bins_edge = np.linspace(-1, 1, num_bins + 1)\n #center of all edges\n bins_center = np.linspace(-1 + 1.0 / num_bins, 1 - 1.0 / num_bins, num_bins)\n #get the right edges\n bins_trunc = bins_edge[1:]\n #if sample >= right edges, it might be assigned to the next bin, add 0.1 to avoid this\n bins_trunc[-1] += 0.1\n #convert edges and centers to mu-law scale\n bins_edge_mu = np.multiply(np.sign(bins_trunc), (num_bins ** np.absolute(bins_trunc) - 1) / (num_bins - 1))\n bins_center_mu = np.multiply(np.sign(bins_center), (num_bins ** np.absolute(bins_center) - 1) / (num_bins - 1))\n \n return (bins_edge_mu, bins_center_mu)","def test_bin_larvaemutattion():\n \n larvae = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\n [1, 1, 1, 1, 0, 0, 0, 0],\n [0, 0, 0, 0, 1, 1, 1, 1]])\n \n pos = np.array([[0, 3, 5]])\n mode = 'bin'\n \n larvaemutation_function = get_larvaemutation_function(mode)\n larvaemutated = larvaemutation_function(larvae, pos, seed=13)\n \n goodsol = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\n [1, 1, 1, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 1, 0, 1, 1]])\n\n np.testing.assert_almost_equal(larvaemutated, goodsol)","def modelOnBetaGrid(sample,bins,N,l,u):\r\n\r\n betaGrid=np.linspace(l,u,N)\r\n traces=[]\r\n WAIC=dict()\r\n index=0\r\n\r\n for beta in betaGrid:\r\n trace=intensityLogGauss(sample,bins,beta)\r\n traces.append(trace['intensity'])\r\n WAIC[index]=trace\r\n index+=1\r\n\r\n df=pm.compare(WAIC,ic='WAIC')\r\n\r\n return betaGrid,df,traces","def ANN_binned_tagged_jets_hist(datalist, model, discriminant_cuts, CSV_cuts, bins, nbins, mode=\"pT_jet\",Save=False,addFeature=False):\n title = \"binned_tagged_jets_vs_\"+mode\n\tdiscriminant = \"ANN\"\n AllJetsHistlist = []\n CSVHistlist = []\n DiscriminantHistlist = []\n if mode == \"pT_hadron\":\n feature = 2\n elif mode == \"pT_jet\":\n feature = 3\n elif mode == \"decay_vx\":\n feature = 4\n for n,data in enumerate(datalist):\n\t\tdatatitle = data[3]\n print \"working on\",datatitle\n ran = data[4]\n\t\tCSV = data[2]\n\t\tpT = data[1]\n\t\tx_data = data[0]\n AllJetsHistlist.append(rt.TH1D(datatitle+\"_AllJets\",datatitle+\"_\"+title,nbins,ran[0],ran[1]))\n AllJetsHistlist[n].SetLineColor(4)\n CSVHistlist.append(rt.TH1D(datatitle+\"_CSV\",datatitle+\"_\"+title,nbins,ran[0],ran[1]))\n CSVHistlist[n].SetLineColor(3)\n DiscriminantHistlist.append(rt.TH1D(datatitle+\"_Discriminant\",datatitle+\"_\"+title,nbins,ran[0],ran[1]))\n DiscriminantHistlist[n].SetLineColor(2)\n\t\n\t\tif addFeature == False:\n\t\t\tpred_y = model.predict(ANN_functional_shape(x_data))\n\t\telif addFeature == \"pT\":\n\t\t\tpred_y = model.predict(ANN_functional_shape(x_data)+[pT/200])\n\t\telif addFeature == \"PV\":\n\t\t\tassert x_data.shape[1] == 21, \"wrong x_data format: PV cannot be found\"\n\t\t\tpred_y = model.predict(ANN_functional_shape(x_data)+[x_data[:,-1]/10.])\n\t\telse:\n\t\t\tprint \"invalid feature input\"\n\t\t\treturn None\n\t\tbin_numbers = ANN_bin_selection(pT,bins)\n\n\t for i,pT_value in enumerate(pT):\n\t if bin_numbers[i] == -100: continue\n\t\t\tAllJetsHistlist[n].Fill(pT_value)\n\t if pred_y[i] >= discriminant_cuts[bin_numbers[i]]: DiscriminantHistlist[n].Fill(pT_value)\n\t if CSV[i] >= CSV_cuts[bin_numbers[i]]: CSVHistlist[n].Fill(pT_value)\n\n canvaslist = []\n legendlist = []\n Tfilelist = []\n for n,data in enumerate(datalist):\n\t\tdatatitle = data[3]\n canvaslist.append(rt.TCanvas(datatitle+\"_canvas\",\"canvas\",600,600))\n canvaslist[n].SetTitle(datatitle+\"_\"+title)\n rt.gStyle.SetOptStat(0)\n legendlist.append(rt.TLegend(0.9,0.9,0.65,0.75))\n legendlist[n].AddEntry(AllJetsHistlist[n], \"All jets\")\n legendlist[n].AddEntry(CSVHistlist[n], \"CSV\")\n legendlist[n].AddEntry(DiscriminantHistlist[n], discriminant)\n AllJetsHistlist[n].GetXaxis().SetTitle(mode)\n AllJetsHistlist[n].GetYaxis().SetTitle('# jets')\n AllJetsHistlist[n].GetYaxis().SetTitleOffset(1.5)\n #AllJetsHistlist[n].Draw()\n #CSVHistlist[n].Draw(\"SAME\")\n #DiscriminantHistlist[n].Draw(\"SAME\")\n #legendlist[n].Draw()\n if Save:\n #canvaslist[n].SaveAs(title+\"_\"+datatitle+discriminant+\".png\")\n Tfilelist.append(rt.TFile(\"Thesis_Plots/root_files/\"+title+\"_\"+datatitle+discriminant+\".root\",\"recreate\"))\n print \"saved histogram as Thesis_Plots/root_files/\"+title+\"_\"+datatitle+discriminant+\".root\"\n AllJetsHistlist[n].Write()\n CSVHistlist[n].Write()\n DiscriminantHistlist[n].Write()","def bin_definition(n_bins_gammaness, n_bins_theta2):\n max_gam = 0.9\n max_th2 = 0.05 * u.deg * u.deg\n min_th2 = 0.005 * u.deg * u.deg\n\n gammaness_bins = np.linspace(0, max_gam, n_bins_gammaness)\n theta2_bins = np.linspace(min_th2, max_th2, n_bins_theta2)\n\n return gammaness_bins, theta2_bins","def __init__(self, bin_edges, **kwargs):\n super().__init__(**kwargs)\n self.bin_edges = bin_edges\n self.num_bins = bin_edges.size + 1\n self.sigma = Parameter(1.0, transform=positive())","def test_bin_qual_scores(self):\r\n\r\n qual_data = {'seq1': [10, 20, 30, 40], 'seq2': [11, 21, 31],\r\n 'seq3': [12, 22]}\r\n\r\n expected_bins = [[10, 11, 12], [20, 21, 22], [30, 31], [40]]\r\n\r\n actual_bins = bin_qual_scores(qual_data)\r\n\r\n # Because of arbritrary dictionary order, need to sort results\r\n for bin in range(len(actual_bins)):\r\n actual_bins[bin].sort()\r\n\r\n self.assertEqual(actual_bins, expected_bins)","def sat_in_range(arr, args):\n # find number of saturated pixels, args[0] is the pixel saturation limit\n sat_pixels = (arr > args[0]).sum()\n # args[1] is a limit of saturated pixels\n res = sat_pixels < args[1]\n result = ct.Result(res, 'saturation_in_range')\n return result","def can_binarize(a, r, phrase_index):\n if r.arity() <= 2:\n return 1\n if r.arity() > 3:\n raise ValueError(\"4-ary rules and above not supported yet\")\n\n fvars = [x for x in r.fpos if type(x) is tuple]\n for (fi,fj) in phrase_index:\n if fi <= fvars[0][0] and fvars[1][1] <= fj <= fvars[2][0]:\n return 1\n if fvars[0][1] <= fi <= fvars[1][0] and fvars[2][1] <= fj:\n return 1\n\n return 0","def bin_discretize(self, variables=[], bins=3,\n min_const_samples_bin_size=1.0/3):\n self.edges=np.zeros((self.arity.size,bins+1))\n for i in variables:\n un_cnt=np.unique(self.data[:,i],return_counts=True)\n constvals=un_cnt[0][un_cnt[1]>self.data.shape[0]*min_const_samples_bin_size]\n mask=np.ones(self.data.shape[0],dtype=bool)\n if constvals.size>0:\n for j,cv in enumerate(constvals):\n mask*=(self.data[:,i]!=cv)\n self.data[self.data[:,i]==cv,i]=j\n\n size=np.sum(mask)/bins\n sorted_i=np.argsort(self.data[mask,i])\n edges=[self.data[mask,i][sorted_i[int(size*num)-1]] for num in range(1,bins)]\n self.edges[i]=[self.data[mask,i][sorted_i[0]]]+edges+[self.data[mask,i][sorted_i[-1]]]\n self.data[mask,i]=np.searchsorted(edges,self.data[mask,i])+constvals.size\n self.arity[i]=len(edges)+1+constvals.size","def test_bin_right(self):\n list_val=[0,1,2,3,4,5,6]\n low=0\n high= len(list_val)-1\n target=1\n self.assertEqual(bin_search(1,0,len(list_val)-1, list_val),1)","def __len__(self):\n return 9 # logsfr_ratios has 6 bins","def test_run_a_scan_on_sdp_subarray_in_low():","def computeAC(bins):\n halfn = len(bins)/2\n Npos = sum(bins[halfn:])\n Nneg = sum(bins[:halfn])\n return float(Npos-Nneg)/(Npos+Nneg)","def freedman_diaconis_bins(self, arr):\n # From https://stats.stackexchange.com/questions/798/\n if len(arr) < 2:\n return 1\n # Calculate the iqr ranges.\n self.iqr(arr)\n # Calculate the h\n h = 2 * (self.q3 - self.q1) / (len(arr) ** (1 / 3))\n # fall back to sqrt(a) bins if iqr is 0\n if h == 0:\n return int(np.sqrt(arr.size))\n else:\n return int(np.ceil((arr.max() - arr.min()) / h))","def test_bin_data_type(self):\n\n with pytest.raises(TypeError) as verr:\n avg.median2D(self.testInst, ['1', 'a', '23', '10'], 'longitude',\n ['0', 'd', '24', 'c'], 'mlt',\n ['dummy1', 'dummy2', 'dummy3'], auto_bin=False)\n\n estr = \"Cannot cast array data from\"\n assert str(verr).find(estr) >= 0\n\n return","def SetPRBinConstraint(self, model ) :\n tot = np.multiply(self.wish, self.dispo)\n for val in tot :\n if not val : continue\n if self.bound>0 : model += val <= self.valBound\n elif self.bound<0 : model += val >= self.valBound","def correct_ann_outliers(obj_tmp, ann_width, sig, med_neig, std_neig, cy, cx, \n min_thr, max_thr, rand_arr, stddev, half_res_y=False): \n \n if True:#no_numba: \n def _correct_ann_outliers(obj_tmp, ann_width, sig, med_neig, std_neig, \n cy, cx, min_thr, max_thr, rand_arr, stddev, \n half_res_y=False): \n n_y, n_x = obj_tmp.shape\n rand_arr = 2*(np.random.rand(n_y, n_x)-0.5)\n obj_tmp_corr = obj_tmp.copy()\n bpix_map = np.zeros([n_y,n_x])\n for yy in range(n_y):\n for xx in range(n_x):\n if half_res_y:\n rad = np.sqrt((2*(cy-yy))**2+(cx-xx)**2)\n else:\n rad = np.sqrt((cy-yy)**2+(cx-xx)**2)\n rr = int(rad/ann_width)\n dev = max(stddev,min(std_neig[rr],med_neig[rr]))\n \n # check min_thr\n if obj_tmp[yy,xx] < min_thr:\n bpix_map[yy,xx] = 1\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\n \n # check max_thr\n elif obj_tmp[yy,xx] > max_thr:\n bpix_map[yy,xx] = 1\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\n \n elif (obj_tmp[yy,xx] < med_neig[rr]-sig*dev or \n obj_tmp[yy,xx] > med_neig[rr]+sig*dev):\n bpix_map[yy,xx] = 1\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\n return obj_tmp_corr, bpix_map\n else:\n @njit \n def _correct_ann_outliers(obj_tmp, ann_width, sig, med_neig, std_neig, \n cy, cx, min_thr, max_thr, rand_arr, stddev, \n half_res_y=False): \n n_y, n_x = obj_tmp.shape\n rand_arr = 2*(np.random.rand(n_y, n_x)-0.5)\n obj_tmp_corr = obj_tmp.copy()\n bpix_map = np.zeros([n_y,n_x])\n for yy in range(n_y):\n for xx in range(n_x):\n if half_res_y:\n rad = np.sqrt((2*(cy-yy))**2+(cx-xx)**2)\n else:\n rad = np.sqrt((cy-yy)**2+(cx-xx)**2)\n rr = int(rad/ann_width)\n dev = max(stddev,min(std_neig[rr],med_neig[rr]))\n \n # check min_thr\n if obj_tmp[yy,xx] < min_thr:\n bpix_map[yy,xx] = 1\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\n \n # check max_thr\n elif obj_tmp[yy,xx] > max_thr:\n bpix_map[yy,xx] = 1\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\n \n elif (obj_tmp[yy,xx] < med_neig[rr]-sig*dev or \n obj_tmp[yy,xx] > med_neig[rr]+sig*dev):\n bpix_map[yy,xx] = 1\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\n return obj_tmp_corr, bpix_map\n \n return _correct_ann_outliers(obj_tmp, ann_width, sig, med_neig, std_neig, \n cy, cx, min_thr, max_thr, rand_arr, stddev, \n half_res_y=False)","def test_avalanche_warning_by_region_obs(self):\n pass","def eqf_binning(t, n_bins):\n t_bins= []\n t= sorted(t)\n n_items= int(len(t)/n_bins)\n\n for i in range(1, n_bins):\n t_bins.append(t[int(i*n_items)])\n t_bins.append(np.max(t) + 0.01)\n t_binning= np.digitize(t, t_bins)\n return t_binning","def othersn(ax):","def get_individual_manipulated_feature_centered(record,sensor,bins=100):\r\n \r\n #accesses the record's motion sensor\r\n ana=Analysis()\r\n ana.processRecord(record) \r\n motion=MotionProfileV2.extract(record)\r\n m = motion.vpsInDistance.toArray(sensor)\r\n \r\n #initializes variables\r\n my_range = np.linspace(-1,25,bins)\r\n d = np.zeros((len(my_range),1))\r\n prev=0\r\n index=0\r\n \r\n #iterates through the linspace vector\r\n for i in range(0,len(my_range)): \r\n cp=np.zeros((len(m),2))\r\n count=0\r\n \r\n #makes a copy of the values that fall within the given bin\r\n for j in range(0,len(m)):\r\n if m[j][0]+ ((25-record.motion.vehicleLength)/2-m[0][0]) >= my_range[i] and m[j][0]+ ((25-record.motion.vehicleLength)/2-m[0][0]) <= my_range[i+1]:\r\n cp[count][0]=m[j][0] + ((25-record.motion.vehicleLength)/2-m[0][0])\r\n cp[count][1]=m[j][1]\r\n count+=1\r\n\r\n #if there ARE changes within the bin (sensor switches from 0 or 1)\r\n if cp[0][0] != 0:\r\n \r\n #if there is ONLY ONE switch within the bin\r\n if cp[1][0] == 0:\r\n \r\n #if the sensor switches from 1 to 0\r\n if prev == 1:\r\n #finds the area\r\n d[index] = 1 - ((my_range[i+1] - cp[0][0])/(my_range[i+1]-my_range[i]))\r\n #increments the index and updates 'prev' accordingly\r\n index+=1\r\n prev=cp[0][1]\r\n \r\n #if the sensor switches from 0 to 1 \r\n else:\r\n #finds the are\r\n d[index] = ((my_range[i+1] - cp[0][0])/(my_range[i+1]-my_range[i]))\r\n #increments the index and updates 'prev' accordingly\r\n index+=1\r\n prev=cp[0][1]\r\n \r\n #if there are MORE than one switch within the bin \r\n else:\r\n value=0 \r\n #if the sensor switches from 1 to 0 then back any number of times\r\n if cp[0][1] == 1:\r\n #iterates through the copied matrix\r\n for j in range(0,len(cp),2):\r\n \r\n #finds the cumulative area\r\n if j+1<len(cp):\r\n if cp[j+1][0] == 0 and cp[j][0] != 0:\r\n value += my_range[i+1]-cp[j][0]\r\n prev=cp[j][1]\r\n else:\r\n value += cp[j+1][0] - cp[j][0]\r\n \r\n #adds the total area within the bin to the vector \r\n d[index] = value/(my_range[i+1]-my_range[i])\r\n index+=1\r\n \r\n #if the sensor switches from 0 to 1 then back any number of times \r\n else: \r\n #iterates through the copied matrix\r\n for j in range(0,len(cp),2):\r\n \r\n #finds the cumulative area\r\n if j+1<len(cp):\r\n if j == 0:\r\n value += cp[j][0] - my_range[i]\r\n prev=cp[j][1]\r\n elif cp[j][0] == 0 and cp[j-1][0] != 0:\r\n value += my_range[i+1]-cp[j-1][0]\r\n prev=cp[j-1][1]\r\n else:\r\n value += cp[j][0] - cp[j-1][0]\r\n \r\n #adds the total area within the bin to the vector \r\n d[index] = value/(my_range[i+1]-my_range[i])\r\n index+=1\r\n \r\n #if there ARE NOT changes within the bin (sensor stays either 0 or 1)\r\n elif cp[0][0] == 0:\r\n \r\n #changes the 'prev' variable accordingly and increments the index \r\n if prev == 0:\r\n d[index] = 0\r\n index+=1\r\n elif prev == 1:\r\n d[index] = 1\r\n index+=1\r\n \r\n #returns the individual sensor feature vector\r\n return(d)","def test_histogram_with_varying_number_of_bin(self):\n # this data use number of bins less than the max limit\n df1 = pd.Series([1, 2, 3, 4]).apply(str)\n profiler1 = FloatColumn(df1.name)\n profiler1.max_histogram_bin = 50\n profiler1.update(df1)\n num_bins = len(profiler1.profile['histogram']['bin_counts'])\n self.assertEqual(num_bins, 4)\n\n # this data uses large number of bins, which will be set to\n # the max limit\n df2 = pd.Series([3.195103249264023e+18, 9999995.0, 9999999.0,\n 0.0, -10 ** 10]).apply(str)\n profiler2 = FloatColumn(df2.name)\n profiler2.max_histogram_bin = 50\n profiler2.update(df2)\n num_bins = len(profiler2.profile['histogram']['bin_counts'])\n self.assertEqual(num_bins, 50)\n\n # max number of bin is increased to 10000\n profiler2 = FloatColumn(df2.name)\n profiler2.max_histogram_bin = 10000\n profiler2.update(df2)\n num_bins = len(profiler2.profile['histogram']['bin_counts'])\n self.assertEqual(num_bins, 10000)","def check_binning(comparefn):\n @wraps(comparefn)\n def wrapper(*args, **kwargs):\n # args[0] is self, since comparefn is member of a class\n if args[2].GetNbinsX() == args[1].GetNbinsX():\n return comparefn(*args, **kwargs)\n # FIXME: this check is incomplete, bin boundaries can also\n # be different: see TH1::CheckConsistency() (cannot use\n # this though, protected member)\n else:\n warning('Histograms with different number of bins.')\n # raise ValueError('Histograms with unequal number of bins')\n return ComparisonFunction.create_error_dict()\n return wrapper","def aggregate_behavior(Z):\n nsamp, nsen = Z.shape\n median_trace = np.median(Z, axis=1)\n dev = np.std(Z - np.repeat(np.matrix(median_trace).transpose(),\n nsen, axis=1), axis=1)\n cmpr_high_variability = [(Z[:, sen_i] > median_trace + 2 * dev\n ).sum()/nsamp > 0.5 for sen_i in range(nsen)]\n return nsamp, nsen, cmpr_high_variability, median_trace, dev","def _allowed_bands():\n pass","def get_mean_accuracy(all_means, nbins=10):\n ## Add a columns of bin assignments\n # bins = np.linspace(0, all_means['posterior'].max(), nbins)\n bins = np.linspace(0, 1, nbins)\n all_means['bin'] = np.digitize(all_means['posterior'], bins)\n\n ## Add upper bound to right-most bin\n all_means.replace(to_replace={'bin':{nbins: nbins-1}}, inplace=True)\n\n ## Bin ancestors by mean bootstrapped probability, adding columns for\n ## whether they were the true generating ancestor, and the number of\n ## ancestors in each bin\n bin_count = lambda x: len(x)\n binned = all_means[['generator', 'bin']].pivot_table(index='bin',\n aggfunc=[np.mean, bin_count], fill_value=0)\n binned.columns = [['observed_prob', 'bin_count']]\n binned['n_successes'] = binned['observed_prob'].values * \\\n binned['bin_count'].values\n\n ## Estimate means and confidence intervals as sampling from a binomial\n ## distribution, with a uniform prior on success rates - Done using\n ## a beta distribution\n binned['alpha'] = binned['n_successes'] + 1\n binned['beta'] = binned['bin_count'].values - binned['n_successes'].values + 1\n beta_mean = lambda row: beta.mean(float(row['alpha']), float(row['beta']))\n binned['posterior_mean'] = binned.apply(beta_mean, axis=1)\n\n ## Add confidence intercals\n beta_025CI = lambda row: beta.ppf(0.025, float(row['alpha']), float(row['beta']))\n beta_975CI = lambda row: beta.ppf(0.975, float(row['alpha']), float(row['beta']))\n binned['CI2.5'] = binned.apply(beta_025CI, axis=1)\n binned['CI97.5'] = binned.apply(beta_975CI, axis=1)\n\n ## Convert to values relative to mean, to fit plotting convention\n binned['CI2.5'] = binned['posterior_mean'].values - binned['CI2.5'].values\n binned['CI97.5'] = binned['CI97.5'].values - binned['posterior_mean'].values\n\n ## Add column with bin centre for plotting\n binned['bin_centre'] = all_means[['posterior', 'bin']].groupby('bin').mean()\n\n return binned","def plot_completeness(cat_name,output_name,name_plot,mag_lims,binning_mag,plot,second_cat='no'):\n\n cat=ascii.read('%s.txt' % cat_name)\n mag_bins=np.arange(mag_lims[0],mag_lims[1],binning_mag)\n\n mask=cat['detected']==1\n mag_binned_tot=np.digitize(cat['MAG'],mag_bins,right=True)\n mag_binned_det=np.digitize(cat[mask]['MAG'],mag_bins,right=True)\n\n nb_mag=np.array([ len(np.where(mag_binned_tot==i)[0]) for i in range(1,len(mag_bins)) ])\n nb_mag_det = np.array([ len(np.where(mag_binned_det==i)[0]) for i in range(1,len(mag_bins)) ])\n #mag_tot= np.array([stuff_cat['MAG'][mag_binned_tot == i].mean() for i in range(1, len(mag_bins))])\n #mag_det= np.array([stuff_cat[mask]['MAG'][mag_binned_det == i].mean() for i in range(1, len(mag_bins))])\n print (nb_mag)\n print (nb_mag_det)\n\n #Write completeness result in text file\n np.savetxt('%s.txt' % output_name, list(zip(mag_bins,nb_mag,nb_mag_det)),fmt='%.2f %d %d')\n\n\n mag_bin_plot=(mag_bins[:-1]+mag_bins[1:])/2\n\n import matplotlib.pyplot as plt\n\n # the histogram of the input sources\n n, bins, patches = plt.hist(cat['MAG'], mag_bins, normed=0, facecolor='green', alpha=0.75)\n plt.xlabel('Magnitude')\n plt.ylabel('Nb of sources')\n plt.xlim([mag_bins[0],mag_bins[-1]])\n plt.savefig('results/plots/hist_sources.png')\n #plt.show()\n\n plt.clf()\n plt.plot(mag_bin_plot,nb_mag_det/nb_mag)\n plt.xlabel('Magnitude AB')\n plt.ylabel('Efficiency')\n plt.grid(True)\n plt.savefig('%s.png' % output_name)\n if plot: plt.show()\n\n\n if second_cat != 'no':\n cat2=ascii.read('%s.txt' % second_cat)\n mag_bins2=np.arange(mag_lims[0],mag_lims[1],binning_mag)\n\n mask2=cat2['detected']==1\n mag_binned_tot2=np.digitize(cat2['MAG'],mag_bins2,right=True)\n mag_binned_det2=np.digitize(cat2[mask2]['MAG'],mag_bins2,right=True)\n\n nb_mag2=np.array([ len(np.where(mag_binned_tot2==i)[0]) for i in range(1,len(mag_bins2)) ])\n nb_mag_det2 = np.array([ len(np.where(mag_binned_det2==i)[0]) for i in range(1,len(mag_bins2)) ])\n\n mag_bin_plot2=(mag_bins2[:-1]+mag_bins2[1:])/2\n #print (mag_bin_plot)\n #plt.plot(mag_bin_plot,nb_mag_det/nb_mag,label='seeing=0.7\"',color='red')\n #plt.plot(mag_bin_plot2,nb_mag_det2/nb_mag2,label='seeing=0.1\"',color='green')\n plt.plot(mag_bin_plot,nb_mag_det/nb_mag,label='5.9',color='red')\n plt.plot(mag_bin_plot2,nb_mag_det2/nb_mag2,label='5',color='green')\n plt.xlabel('Magnitude AB')\n plt.ylabel('Efficiency')\n #plt.yscale('log')\n #plt.xscale('log')\n plt.grid(True)\n plt.legend()\n plt.savefig('results/plots/completeness_comp.png')\n if plot: plt.show()","def binning(S, bands):\n B = np.zeros((S.shape[0], len(bands)), dtype=S.dtype)\n for i, b in enumerate(bands):\n B[:, i] = np.mean(S[:, b[0] : b[1]], axis=1)\n\n return B","def __init__(self,ptbins,etabins,data=None):\n self._ptbins = ptbins\n self._etabins = etabins\n if data is not None:\n self._data = data\n else:\n self._data = [ [ (0,0) for i in range(len(self._etabins)+1) ] for i in range(len(self._ptbins)+1) ]\n self.__check()","def test_am_threshold(Simulator, plt, seed, rng):\n d = 64\n vocab = Vocabulary(d, pointer_gen=rng)\n vocab.populate('A; B; C; D')\n\n d2 = int(d / 2)\n vocab2 = Vocabulary(d2, pointer_gen=rng)\n vocab2.populate('A; B; C; D')\n\n def input_func(t):\n return '0.49 * A' if t < 0.1 else '0.8 * B'\n\n with spa.Network('model', seed=seed) as m:\n m.am = ThresholdingAssocMem(\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\n function=filtered_step_fn, mapping='by-key')\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\n m.stimulus >> m.am\n\n in_p = nengo.Probe(m.am.input)\n out_p = nengo.Probe(m.am.output, synapse=0.03)\n\n with Simulator(m) as sim:\n sim.run(0.3)\n t = sim.trange()\n below_th = t < 0.1\n above_th = t > 0.25\n\n plt.subplot(2, 1, 1)\n plt.plot(t, similarity(sim.data[in_p], vocab))\n plt.ylabel(\"Input\")\n plt.subplot(2, 1, 2)\n plt.plot(t, similarity(sim.data[out_p], vocab2))\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\n plt.ylabel(\"Output\")\n\n assert np.mean(sim.data[out_p][below_th]) < 0.01\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)","def rebin (self, bins, tol=1e-4):\n\n bins = np.copy (np.sort (bins))\n for (i, b) in enumerate (bins):\n misses = np.abs (b - self.bins)\n j = np.argmin (misses)\n closest = np.min (misses)\n if closest > tol:\n raise ValueError (\n '{0} is not among current bin edges'.format (b))\n bins[i] = self.bins[j]\n if bins[0] != self.bins[0]:\n raise ValueError (\n 'binning startpoint should match ({0} vs {1})'.format (\n bins[0], self.bins[0]))\n if bins[-1] != self.bins[-1]:\n raise ValueError (\n 'binning endpoint should match ({0} vs {1})'.format (\n bins[-1], self.bins[-1]))\n\n n_newbins = len (bins) - 1\n newbin_indices = np.digitize (self.bins, bins)[:-1] - 1\n values = np.array ([\n np.sum (self.values[newbin_indices == i])\n for i in range (n_newbins)\n ])\n if self.errors is not None:\n errors = np.array ([\n np.sqrt (np.sum (self.errors[newbin_indices == i]**2))\n for i in range (n_newbins)\n ])\n else:\n errors = None\n return Hist (bins, values, errors)","def anoise(this, *args, **kargs):\n\t\t\n\t\t# Arguments\n\t\tif not args: args = [50]\n\t\t\n\t\t# Kernel's retrieval\n\t\tanoisek = this._ANOISEK\n\t\tif anoisek is None: return None\n\t\t\n\t\t# More magic\n\t\tbin = this._BINARY\n\t\tfor thresh in args:\n\t\t\tbin[:,:] = (cv2.filter2D(bin, -1, anoisek) / 2.55 > thresh) * 255\n\t\treturn True","def test_WIMP_cut_region_on_true_data(bolo_name, mass, analysis):\n\t\n\n\t#Load 2D PDF\n\tfWIMP2D, f = PyRPl.open_ROOT_object(\"./ROOT_files/WIMP_PDF2D_\" + analysis + \".root\", \"WIMP_\" + mass + \"_GeV\")\n\n\t#Load cut value on PDF for 95% WIMP box\n\tcut_val_90, cut_val_99 = 0,0\n\twith open (\"./Text_files/WIMP_PDF_90_and_99_cut_value_\" + analysis + \".txt\", \"r\") as fcut:\n\t\tstuff = [elem.rstrip().split(\",\") for elem in fcut.readlines()]\n\t\tfor elem in stuff:\n\t\t\tmass_val = elem[0]\n\t\t\tif int(mass)==int(mass_val):\n\t\t\t\tcut_val_90 = float(elem[1])\n\t\t\t\tcut_val_99 = float(elem[2])\n\t\n\n\tdata_path = \"/home/irfulx204/mnt/tmain/Desktop/Run308_Analyse_ERA/Fond_ERA_merged/\"\n\tfilou = TFile(data_path + bolo_name + \"_\" + analysis + \"_fond.root\", \"read\")\n\ttree = filou.Get(\"data\")\n\tnum_pass_cut =0\n\n\thpass = TH2F(\"hpass\", \"hpass\", 100, 0, 15, 100, 0, 15)\n\n\t# #T Check that the events are found where expected\n\t# arr1 = np.random.uniform(0,15,size=(200000,2))\n\t# for i in range(arr1.shape[0]):\n\t# \tPDF_val = fWIMP2D.Eval(arr1[i][0], arr1[i][1])\n\t# \tif (cut_val_99<PDF_val<cut_val_90):\n\t# \t# if (cut_val_99<PDF_val<cut_val_90):\n\t# \t\tnum_pass_cut+=1\n\t# \t\thpass.Fill(arr1[i][0], arr1[i][1])\t\t\n\n\t# hpass.Draw()\n\t# raw_input()\n\n\tfor k in range(tree.GetEntries()):\n\t\ttree.GetEntry(k)\n\t\tER=(1+8./3)*0.5*(tree.EC1+tree.EC2)-0.33*(1.5*tree.EIA+4*tree.EIB+1.5*tree.EIC+4*tree.EID)\n\t\tPDF_val = fWIMP2D.Eval(ER, 0.5*(tree.EIB+tree.EID))\n\t\tif (cut_val_99<PDF_val<cut_val_90 and 0.5*(tree.EIB+tree.EID)>0.7):\n\t\t# if (cut_val_99<PDF_val<cut_val_90):\n\t\t\tnum_pass_cut+=1\n\t\t\thpass.Fill(0.5*(tree.EC1+tree.EC2), 0.5*(tree.EIB+tree.EID))\n\n\tprint num_pass_cut\n\thpass.Draw()\n\traw_input()","def check(self):\n self.lower_bound(5e-4)\n self.upper_bound(5e2)","def permutation_test(overlap_bins, nonoverlap_bins, thresh, ntrials):\n X = num_top_snps(I(overlap_bins.values()), thresh)\n if X == 0:\n return thresh, 0, 0, 0, 1, 0, 0\n overlap_counts = {k: len(overlap_bins[k]) for k in overlap_bins}\n Y = [num_top_snps(match(overlap_counts, nonoverlap_bins), thresh) for _ in range(ntrials)]\n mean, variance = moments(Y)\n anderson, critical_values, _ = scipy.stats.anderson(Y)\n exact_p = (1 + len([y for y in Y if y >= X])) / (1 + ntrials)\n return thresh, X, mean, variance, exact_p, anderson, critical_values[2]","def potential_energy_bins(xy, BL, bins, bo=1.0, kL=1.0):\n bL = bond_length_list(xy, BL)\n pe = 0.5 * kL * (bL - bo) ** 2\n # for each bin bins[kk], find incidices i of bL for which BL[i] is connected to at least one particle in bins[kk].\n pe_bins = np.zeros(len(bins), dtype=float)\n kk = 0\n for bin in bins:\n mask = np.logical_or(np.in1d(BL[:, 0], bin), np.in1d(BL[:, 1], bin))\n pe_bins[kk] = np.sum(pe[mask])\n kk += 1\n return pe_bins","def binned_AUC(func_predict, X, y, X_kin, VARS_kin, pt_edges, eta_edges, label):\n\n AUC = np.zeros((len(pt_edges)-1, len(eta_edges)-1))\n\n\n # ** Compute predictions **\n if type(X) is list: # Evaluate one by one\n y_pred = np.zeros(len(X))\n for k in range(len(y_pred)):\n y_pred[k] = func_predict(X[k])\n else:\n y_pred = func_predict(X)\n\n\n # Loop over bins\n for i in range(len(pt_edges) - 1):\n for j in range(len(eta_edges) - 1):\n\n pt_range = [ pt_edges[i], pt_edges[i+1]]\n eta_range = [eta_edges[j], eta_edges[j+1]]\n\n # Indices\n ind = np.logical_and(aux.pick_ind(X_kin[:, VARS_kin.index('trk_pt')], pt_range),\n aux.pick_ind(X_kin[:, VARS_kin.index('trk_eta')], eta_range))\n\n print(f'\\nEvaluate classifier <{label}> ...')\n print(f'*** pT = [{pt_range[0]:.3f},{pt_range[1]:.3f}], eta = [{eta_range[0]:.3f},{eta_range[1]:.3f}] ***')\n \n if np.sum(ind) > 0: # Do we have any events in this cell\n\n # Evaluate metric\n met = aux.Metric(y_true = y[ind], y_soft = y_pred[ind])\n print('AUC = {:.5f}'.format(met.auc))\n AUC[i,j] = met.auc\n\n else:\n print('No events found in this (eta,pt) cell!')\n \n # Evaluate total performance\n met = aux.Metric(y_true = y, y_soft = y_pred)\n fig,ax = plot_auc_matrix(AUC, pt_edges, eta_edges)\n ax.set_title('{}: Integrated AUC = {:.3f}'.format(label, met.auc))\n\n return fig,ax,met","def contact_probability(summary, results, contacts, bins, feature):\r\n\r\n # prepare sampling interval size\r\n bin_width = bins[2]\r\n n_bins = int(np.ceil(bins[1]/bin_width))\r\n # bin bounds\r\n end_bins = np.arange(bin_width,bin_width*(n_bins+1), bin_width)\r\n # prepare arrays\r\n # two counts will be made, for each assumption. r (contact radius), t (contact time)\r\n activated_counts_r = np.zeros(n_bins, dtype=int)\r\n activated_counts_t = np.zeros(n_bins, dtype=int)\r\n total_counts_r = np.zeros(n_bins, dtype=int)\r\n total_counts_t = np.zeros(n_bins, dtype=int)\r\n n_cells = len(summary.cell_ID)\r\n\r\n for i, cell in summary.iterrows():\r\n if cell.QC == 'good':\r\n trig_contacts = contacts.loc[(contacts.cell_ID == cell.cell_ID) & (contacts['time_to_Ca [s]'] == 0) & (contacts['contact'] == 'CCZ'), :]\r\n if len(trig_contacts) > 0:\r\n max_r_ = np.max(trig_contacts['radius [um]'].values)\r\n max_r = np.max(trig_contacts.loc[trig_contacts['radius [um]'] == max_r_, feature])\r\n max_t_ = np.max(trig_contacts['contact_time [s]'].values)\r\n max_t = np.max(trig_contacts.loc[trig_contacts['contact_time [s]'] == max_t_, feature])\r\n else:\r\n max_r = 0\r\n max_t = 0\r\n if feature == 'radius [um]':\r\n max_r = max_r*1000\r\n max_t = max_t*1000\r\n activated_counts_r += end_bins >= max_r\r\n activated_counts_t += end_bins >= max_t\r\n total_counts_r += 1\r\n total_counts_t += 1\r\n\r\n elif cell.QC == 'good_noCa':\r\n last_frame = np.amax(results.loc[results.cell_ID == cell.cell_ID, 'frame'])\r\n last_contacts = contacts.loc[(contacts.cell_ID == cell.cell_ID) & (contacts['frame'] == last_frame) & (contacts['contact'] == 'CCZ'), :]\r\n max_r_ = np.max(last_contacts['radius [um]'].values)\r\n max_r = np.max(last_contacts.loc[last_contacts['radius [um]'] == max_r_, feature])\r\n max_t_ = np.max(last_contacts['contact_time [s]'].values)\r\n max_t = np.max(last_contacts.loc[last_contacts['contact_time [s]'] == max_t_, feature])\r\n if feature == 'radius [um]':\r\n max_r = max_r*1000\r\n max_t = max_t*1000\r\n total_counts_r += end_bins-bin_width < max_r\r\n total_counts_t += end_bins-bin_width < max_t \r\n\r\n return end_bins, activated_counts_r, activated_counts_t, total_counts_r, total_counts_t","def bin_binarise(self):\n pass","def correlation_bins(shred):\n return 0","def SetPRBinCatConstraint( self, model ) :\n tot = np.dot( self.wish.T, self.dispo )\n for val in tot :\n if not val : continue\n if self.bound>0 : model += val <= self.valBound\n elif self.bound<0 : model += val >= self.valBound","def uniform_binning(ts, bins):\n symb = np.asarray(bins * (ts - ts.min()) / (ts.max() - ts.min() + 1e-12), dtype=int)\n return symb","def eqw_binning(t, n_bins):\n \n t_diff= (np.max(t) - np.min(t))/n_bins\n t_bins= np.hstack([np.array([np.min(t) + t_diff*i for i in range(1, n_bins)]), [np.max(t) + 0.01]])\n t_binning= np.digitize(t, t_bins)\n return t_binning","def get_selected_bin_low_median(self, hist, bin_edges, assigned_digits, original_values):\n PRINT_OUTPUT = False\n\n bin_max_index = np.where(hist == hist.max())\n refactored_index = bin_max_index[0].max()\n\n # special case: refactor maximum index, when there are multiple equal maximum values in histogram\n max_histo_value = hist[refactored_index]\n all_max_indices = []\n\n for hist_index, hist_value in enumerate(hist):\n if hist_value == max_histo_value:\n all_max_indices.append(hist_index)\n\n\n # adapt the index for special case, take the middle value in the distribution\n\n # my_custom_median_index = np.where(all_max_indices == np.median(all_max_indices))\n\n new_refactored_index = int(stats.median_low(all_max_indices))\n\n # additional condition for setting breakpoint\n if refactored_index != new_refactored_index:\n refactored_index = new_refactored_index\n\n values_in_this_bin = []\n for index_ad, ad in enumerate(assigned_digits):\n ad -= 1\n if ad == refactored_index:\n values_in_this_bin.append(original_values[index_ad])\n\n\n mean_val = np.mean(values_in_this_bin)\n final_mean = int(np.round(mean_val))\n return final_mean\n\n # detected_edges = bin_edges[bin_max_index]\n # detected_edge = detected_edges[0]\n\n # if PRINT_OUTPUT is True:\n # print('maxbin', detected_edge)\n\n # return detected_edge","def _analyze_series(self, series):\n # bin series by analysis time\n # only analyze the last bin\n ts = array([si['timestamp'] for si in series])\n ds = diff(ts)\n\n # tolerance_seconds = 60 * 60 * self._bin_hours\n # ds = diff(ts) > tolerance_seconds\n # bounds = where(ds)[0]\n # itemidx = bounds[-1] if bounds else 0\n # series = series[itemidx:]\n\n for ci in self._conditionals:\n ret = self._execute_conditional(ci, series, ds)\n if ret:\n return ret","def astats(npa, do_bits=True):\n mean = float(np.mean(npa))\n std = float(np.std(npa))\n amax = float(np.amax(npa))\n amin = float(np.amin(npa))\n quant1_3 = np.quantile(npa, [0.25, 0.75])\n iqr = quant1_3[1] - quant1_3[0]\n weak_min = (npa < quant1_3[0] - 1.5 * iqr)\n weak_max = (npa > quant1_3[1] + 1.5 * iqr)\n strong_min = (npa < quant1_3[0] - 3 * iqr)\n strong_max = (npa > quant1_3[1] + 3 * iqr)\n weak_count = int((weak_min | weak_max).sum())\n strong_count = int((strong_min|strong_max).sum())\n if weak_count:\n min_out = float(np.min(np.abs(npa[weak_min|weak_max])))\n if strong_count:\n max_out = float(np.max(np.abs(npa[strong_min|strong_max])))\n else:\n max_out = float(np.max(np.abs(npa[weak_min|weak_max])))\n else:\n min_out = max_out = 0\n\n ret = {\n 'mean': mean,\n 'std': std,\n 'min': amin,\n 'max': amax,\n 'size': npa.size,\n 'wols': weak_count,\n 'sols': strong_count,\n 'min_out' : min_out,\n 'max_out' : max_out,\n }\n if do_bits:\n ret['ibits'] = bits(amax, amin)\n return ret","def ahistogram (inarray,numbins=10,defaultlimits=None,printextras=1):\r\n inarray = N.ravel(inarray) # flatten any >1D arrays\r\n if (defaultlimits <> None):\r\n lowerreallimit = defaultlimits[0]\r\n upperreallimit = defaultlimits[1]\r\n binsize = (upperreallimit-lowerreallimit) / float(numbins)\r\n else:\r\n Min = N.minimum.reduce(inarray)\r\n Max = N.maximum.reduce(inarray)\r\n estbinwidth = float(Max - Min)/float(numbins) + 1e-6\r\n binsize = (Max-Min+estbinwidth)/float(numbins)\r\n lowerreallimit = Min - binsize/2.0 #lower real limit,1st bin\r\n bins = N.zeros(numbins)\r\n extrapoints = 0\r\n for num in inarray:\r\n try:\r\n if (num-lowerreallimit) < 0:\r\n extrapoints = extrapoints + 1\r\n else:\r\n bintoincrement = int((num-lowerreallimit) / float(binsize))\r\n bins[bintoincrement] = bins[bintoincrement] + 1\r\n except: # point outside lower/upper limits\r\n extrapoints = extrapoints + 1\r\n if (extrapoints > 0 and printextras == 1):\r\n print '\\nPoints outside given histogram range =',extrapoints\r\n return (bins, lowerreallimit, binsize, extrapoints)","def plot_bin_means(X,Y,bin_edges=None,mean='median',error='sem',color=None,\n style='errorbar',minimum_n=25,bin_style='equal'):\n \n assert(X.shape == Y.shape)\n \n X,Y = nonan_pairs(X,Y)\n \n # Flatten if not vectors\n if X.ndim > 1:\n X = X.flatten()\n Y = Y.flatten()\n \n if type(bin_edges) == int:\n if bin_style == 'equal':\n X_min = X.min()\n X_max = X.max() \n bin_edges = np.linspace(X_min,X_max,num=bin_edges)\n elif bin_style == 'percentile':\n bin_edges = np.percentile(nonans(X),np.linspace(0,100,num=bin_edges))\n print(bin_edges)\n else:\n raise ValueError\n \n which_bin = np.digitize(X,bin_edges)\n Nbins = len(bin_edges)-1\n means = np.zeros(Nbins)\n stds = np.zeros(Nbins)\n \n \n # bin_centers = np.zeros(Nbins)\n \n bin_centers = (bin_edges[:-1] + bin_edges[1:])/2\n \n for b in range(Nbins):\n y = Y[which_bin == b+1]\n # bin_centers[b] = (bin_edges[b] + bin_edges[b+1]) / 2\n # Suppress noisy bins\n if len(y) < minimum_n:\n means[b] = np.nan\n stds[b] = np.nan\n else:\n # Mean or median\n if mean == 'mean':\n means[b] = np.nanmean(y)\n elif mean == 'median':\n print(f'{y.shape}')\n means[b] = np.nanmedian(y)\n \n if error == 'sem':\n stds[b] = np.nanstd(y) / np.sqrt(len(y))\n elif error == 'std':\n stds[b] = y.std()\n\n # Plot\n if style == 'errorbar':\n plt.errorbar(bin_centers,means,stds,color=color)\n elif style == 'fill':\n plt.plot(bin_centers, means, color=color)\n plt.fill_between(bin_centers, means-stds, means+stds,\n color=color,alpha=0.5)\n \n return means"],"string":"[\n \"def test_bins(self):\\n\\n \\n for filename in ['data/population_padang_1.asc', \\n 'data/test_grid.asc']: \\n \\n R = read_coverage(filename)\\n \\n min, max = R.get_extrema() #use_numeric=True)\\n \\n for N in [2,3,5,7,10,16]:\\n linear_intervals = R.get_bins(N=N, quantiles=False) \\n \\n assert linear_intervals[0] == min\\n assert linear_intervals[-1] == max \\n \\n d = (max-min)/N\\n for i in range(N):\\n assert numpy.allclose(linear_intervals[i], min + i*d) \\n \\n \\n quantiles = R.get_bins(N=N, quantiles=True)\\n\\n A = R.get_data(nan=True).flat[:] \\n \\n mask = numpy.logical_not(numpy.isnan(A)) # Omit NaN's\\n l1 = len(A)\\n A = A.compress(mask) \\n l2 = len(A)\\n \\n if filename == 'data/test_grid.asc':\\n # Check that NaN's were removed\\n \\n assert l1 == 35\\n assert l2 == 30\\n \\n \\n # Assert that there are no NaN's \\n assert not numpy.alltrue(numpy.isnan(A))\\n \\n number_of_elements = len(A)\\n average_elements_per_bin = number_of_elements/N\\n \\n # Count elements in each bin and check\\n\\n i0 = quantiles[0]\\n for i1 in quantiles[1:]:\\n count = numpy.sum((i0 < A) & (A < i1))\\n if i0 == quantiles[0]:\\n refcount = count\\n \\n \\n if i1 < quantiles[-1]:\\n # Number of elements in each bin must vary by no more than 1\\n assert abs(count - refcount) <= 1 \\n assert abs(count - average_elements_per_bin) <= 3\\n \\n \\n else:\\n # The last bin is allowed vary by more\\n pass\\n \\n i0 = i1\",\n \"def test_bins(self):\\n\\n for filename in ['%s/population_padang_1.asc' % TESTDATA,\\n '%s/test_grid.asc' % TESTDATA]:\\n\\n R = read_layer(filename)\\n rmin, rmax = R.get_extrema()\\n\\n for N in [2, 3, 5, 7, 10, 16]:\\n linear_intervals = R.get_bins(N=N, quantiles=False)\\n\\n assert linear_intervals[0] == rmin\\n assert linear_intervals[-1] == rmax\\n\\n d = (rmax - rmin) / N\\n for i in range(N):\\n assert numpy.allclose(linear_intervals[i], rmin + i * d)\\n\\n quantiles = R.get_bins(N=N, quantiles=True)\\n A = R.get_data(nan=True).flat[:]\\n\\n mask = numpy.logical_not(numpy.isnan(A)) # Omit NaN's\\n l1 = len(A)\\n A = A.compress(mask)\\n l2 = len(A)\\n\\n if filename == '%s/test_grid.asc' % TESTDATA:\\n # Check that NaN's were removed\\n assert l1 == 35\\n assert l2 == 30\\n\\n # Assert that there are no NaN's\\n assert not numpy.alltrue(numpy.isnan(A))\\n\\n number_of_elements = len(A)\\n average_elements_per_bin = number_of_elements / N\\n\\n # Count elements in each bin and check\\n i0 = quantiles[0]\\n for i1 in quantiles[1:]:\\n count = numpy.sum((i0 < A) & (A < i1))\\n if i0 == quantiles[0]:\\n refcount = count\\n\\n if i1 < quantiles[-1]:\\n # Number of elements in each bin must vary by no\\n # more than 1\\n assert abs(count - refcount) <= 1\\n assert abs(count - average_elements_per_bin) <= 3\\n else:\\n # The last bin is allowed vary by more\\n pass\\n\\n i0 = i1\",\n \"def test_output_range(self):\\n byt = bytscl(self.array1)\\n outside = (byt < 0) | (byt > 255)\\n total = numpy.sum(outside)\\n self.assertEqual(total, 0)\",\n \"def test_numpy_bins(self):\\n # Load the data from the fixture\\n data = load_occupancy(return_dataset=True)\\n X, y = data.to_numpy()\\n\\n visualizer = BalancedBinningReference()\\n visualizer.fit(y)\\n visualizer.finalize()\\n self.assert_images_similar(visualizer, tol=0.5)\",\n \"def bin_stats(x,y,xbins,stat='average'):\\n nbins=len(xbins)\\n if stat=='average' or stat=='mean': func=mean\\n elif stat=='median': func=median\\n elif stat=='rms' or stat=='std' : func=std\\n elif stat=='std_robust' or stat=='rms_robust': func=std_robust\\n elif stat=='mean_robust': func=mean_robust\\n elif stat=='median_robust': func=median_robust\\n elif stat=='sum': func=sum\\n results=[]\\n for i in range(nbins):\\n if i<nbins-1:\\n good=(greater_equal(x,xbins[i])\\n *less(x,xbins[i+1]))\\n else: good=(greater_equal(x,xbins[-1]))\\n if sum(good)>1.: results.append(func(compress(good,y)))\\n else:\\n results.append(0.)\\n print('Bin starting at xbins[%i] has %i points' % (i,sum(good)))\\n return array(results)\",\n \"def azAverage(self,rads,vals,nbins=50):\\n\\t\\ttry:\\n\\t\\t\\tavVals = []\\n\\t\\t\\tbins = np.linspace(0,self.annulus,nbins)\\n\\t\\t\\tfor i, bin in enumerate(bins[:-1]):\\n\\t\\t\\t\\tav = np.max(vals[(rads>bins[i]) & (rads<=bins[i+1])])\\n\\t\\t\\t\\tavVals.append(av)\\n\\t\\texcept:\\n\\t\\t\\t#if bin size is too small, and some bins have no particles, make bins bigger\\n\\t\\t\\tnbins=25\\t\\t\\t\\n\\t\\t\\tavVals = []\\n\\t\\t\\tbins = np.linspace(0,self.annulus,nbins)\\n\\t\\t\\tfor i, bin in enumerate(bins[:-1]):\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tav = np.max(vals[(rads>bins[i]) & (rads<=bins[i+1])])\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\tav = 0\\n\\t\\t\\t\\tavVals.append(av)\\n\\t\\treturn bins[:-1], avVals\",\n \"def __ptBin(self,pt):\\n if len(self._ptbins)>0:\\n return reduce(lambda x,y:x+y,map(lambda x:pt>x,self._ptbins))\\n else:\\n return 0\",\n \"def test_nonmonotonic_bins(self):\\n\\n with pytest.raises(ValueError) as verr:\\n avg.median2D(self.testInst, np.array([0., 300., 100.]), 'longitude',\\n np.array([0., 24., 13.]), 'mlt',\\n ['dummy1', 'dummy2', 'dummy3'], auto_bin=False)\\n\\n estr = 'bins must be monotonically increasing or decreasing'\\n assert str(verr).find(estr) >= 0\\n\\n return\",\n \"def bininator(magbins, dlt, mags, err):\\n meds = np.zeros_like(magbins)\\n for i in range(len(magbins)):\\n ind = (mags > magbins[i] - dlt) & (mags <= magbins[i] + dlt)\\n ind = ind & (err < 10.)\\n meds[i] = np.median(err[ind])\\n return meds\",\n \"def test_nonmonotonic_bins(self):\\n\\n with pytest.raises(ValueError) as verr:\\n avg.median1D(self.testInst, [0, 13, 5], self.test_label,\\n self.test_data, auto_bin=False)\\n\\n estr = 'bins must be monotonically increasing or decreasing'\\n assert str(verr).find(estr) >= 0\\n\\n return\",\n \"def test_bin_edges(self):\\n with Pandas() as pd:\\n if pd is None:\\n return\\n with Numpy() as np:\\n if numpy is None:\\n return\\n sys.stderr.write(\\\"\\\\n\\\")\\n\\n df1 = pd.DataFrame({'A': [0, 1, 2, 3, 4, 3, 2, 1, 1, 1]})\\n df2 = pd.DataFrame({'A': [2, 3, 4, 5, 7, 4, 6, 5, 7, 8]})\\n\\n # building test histograms\\n hist2 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\\n hist3 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\\n hist4 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\\n hist5 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\\n hist6 = hg.Bin(num=201, low=0.0, high=1.005)\\n\\n # fill them\\n hist2.fill.numpy(df1)\\n hist3.fill.numpy(df2)\\n hist4.fill.numpy(df1)\\n hist5.fill.numpy(df2)\\n\\n import numpy as np\\n np.testing.assert_array_equal(hist2.bin_edges(), [0., 1., 2., 3., 4., 5.])\\n np.testing.assert_array_equal(hist3.bin_edges(), [2., 3., 4., 5., 6., 7., 8., 9.])\\n np.testing.assert_array_equal(hist4.bin_edges(), [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\\n np.testing.assert_array_equal(hist5.bin_edges(), [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\\n\\n np.testing.assert_array_equal(hist2.bin_edges(low=2.1, high=11.9), [\\n 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.])\\n np.testing.assert_array_equal(hist3.bin_edges(low=1.1, high=6), [1., 2., 3., 4., 5., 6.])\\n np.testing.assert_array_equal(hist4.bin_edges(low=2.1, high=11.9), [\\n 2., 3., 4., 5., 6., 7., 8., 9., 10.])\\n np.testing.assert_array_equal(hist5.bin_edges(low=1.1, high=5.4), [1., 2., 3., 4., 5., 6.])\\n\\n assert len(hist6.bin_edges()) == 202\\n assert len(hist6.bin_edges(low=0.2089, high=0.9333)) == 147\\n assert len(hist6.bin_edges(low=0.205, high=0.935)) == 147\",\n \"def bincalc(nbin=0.1,bmin=5,bmax=2000):\\n\\n logbmin=np.log10(bmin)\\n logbmax=np.log10(bmax)\\n\\n logbins=np.arange(logbmin,logbmax,nbin)\\n\\n bins=10**logbins\\n\\n #bins=np.linspace(bmin,bmax,60)\\n return (bins)\",\n \"def test_bins(self):\\n min_val = 0\\n max_val = 1\\n buckets = 10\\n values_per_bucket = 10\\n\\n import numpy\\n\\n data = list(numpy.linspace(min_val, max_val, buckets * values_per_bucket))\\n bins = numpy.linspace(min_val, max_val + sys.float_info.epsilon, buckets + 1)\\n digitized = numpy.digitize(data, bins)\\n counts = numpy.bincount(digitized)\\n self.assertEqual(buckets + 1, len(counts))\\n self.assertEqual(0, counts[0])\\n for bucket in counts[1:]:\\n self.assertEqual(values_per_bucket, bucket)\",\n \"def test_bin_entries(self):\\n with Pandas() as pd:\\n if pd is None:\\n return\\n with Numpy() as np:\\n if numpy is None:\\n return\\n sys.stderr.write(\\\"\\\\n\\\")\\n\\n df1 = pd.DataFrame(\\n {'A': [0, 1, 2, 3, 4, 3, 2, 1, 1, 1], 'C': ['f1', 'f3', 'f4', 'f3', 'f4', 'f2', 'f2', 'f1', 'f3', 'f4']})\\n df2 = pd.DataFrame(\\n {'A': [2, 3, 4, 5, 7, 4, 6, 5, 7, 8], 'C': ['f7', 'f3', 'f5', 'f8', 'f9', 'f2', 'f3', 'f6', 'f7', 'f7']})\\n\\n # building 1d-, 2d-, and 3d-histogram (iteratively)\\n hist0 = hg.Categorize(unit('C'))\\n hist1 = hg.Categorize(unit('C'))\\n hist2 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\\n hist3 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\\n hist4 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\\n hist5 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\\n\\n # fill them\\n hist0.fill.numpy(df1)\\n hist1.fill.numpy(df2)\\n hist2.fill.numpy(df1)\\n hist3.fill.numpy(df2)\\n hist4.fill.numpy(df1)\\n hist5.fill.numpy(df2)\\n\\n labels0 = hist0.bin_labels()\\n labels1 = hist1.bin_labels()\\n centers2 = hist2.bin_centers()\\n centers3 = hist3.bin_centers()\\n centers = hist4.bin_centers()\\n\\n import numpy as np\\n np.testing.assert_array_equal(hist0.bin_entries(), [2., 2., 3., 3.])\\n np.testing.assert_array_equal(hist1.bin_entries(), [1., 2., 1., 1., 3., 1., 1.])\\n np.testing.assert_array_equal(hist0.bin_entries(labels=labels1), [2., 3., 0., 0., 0., 0., 0.])\\n np.testing.assert_array_equal(hist1.bin_entries(labels=labels0), [0., 1., 2., 0.])\\n\\n np.testing.assert_array_equal(hist2.bin_entries(), [1., 4., 2., 2., 1.])\\n np.testing.assert_array_equal(hist3.bin_entries(), [1., 1., 2., 2., 1., 2., 1.])\\n np.testing.assert_array_equal(hist4.bin_entries(), [1., 4., 2., 2., 1., 0., 0., 0., 0., 0.])\\n np.testing.assert_array_equal(hist5.bin_entries(), [0., 0., 1., 1., 2., 2., 1., 2., 1., 0.])\\n\\n np.testing.assert_array_equal(hist2.bin_entries(xvalues=centers3), [2., 2., 1., 0., 0., 0., 0.])\\n np.testing.assert_array_equal(hist3.bin_entries(xvalues=centers2), [0., 0., 1., 1., 2.])\\n np.testing.assert_array_equal(hist2.bin_entries(xvalues=centers), [\\n 1., 4., 2., 2., 1., 0., 0., 0., 0., 0.])\\n np.testing.assert_array_equal(hist3.bin_entries(xvalues=centers), [\\n 0., 0., 1., 1., 2., 2., 1., 2., 1., 0.])\\n\\n np.testing.assert_array_equal(hist2.bin_entries(low=2.1, high=11.9), [\\n 2., 2., 1., 0., 0., 0., 0., 0., 0., 0.])\\n np.testing.assert_array_equal(hist3.bin_entries(low=1.1, high=5.4), [0., 1., 1., 2., 2.])\\n np.testing.assert_array_equal(hist4.bin_entries(low=2.1, high=11.9), [2., 2., 1., 0., 0., 0., 0., 0.])\\n np.testing.assert_array_equal(hist5.bin_entries(low=1.1, high=5.4), [0., 1., 1., 2., 2.])\",\n \"def hist_bin_opt (x, minbin=20, maxbin=600, spacing=10, N_trials=1):\\n bin_checks = np.arange(minbin, maxbin, spacing)\\n # bin_checks = np.linspace(150, 300, 16)\\n costs = np.zeros(len(bin_checks))\\n i = 0\\n # this might be vectorizable in np\\n for n_bins in bin_checks:\\n # use np.histogram to do the numerical minimization\\n pdf, bin_edges = np.histogram(x, n_bins)\\n # calculate bin width\\n # some discrepancy here but should be fine\\n w_bin = np.unique(np.diff(bin_edges))\\n if len(w_bin) > 1: w_bin = w_bin[0]\\n # calc mean and var\\n kbar = np.mean(pdf)\\n kvar = np.var(pdf)\\n # calc cost\\n costs[i] = (2.*kbar - kvar) / (N_trials * w_bin)**2.\\n i += 1\\n # find the bin size corresponding to a minimization of the costs\\n bin_opt_list = bin_checks[costs.min() == costs]\\n bin_opt = bin_opt_list[0]\\n return bin_opt\",\n \"def metric_iaf_binned(self, x, bins=10): \\n data = np.asarray(x['data'])\\n iaf = [10.0] * data.shape[0]\\n for ch, ch_data in enumerate(data):\\n pxx, freqs = mlab.psd(ch_data, Fs=128.0, NFFT=256)\\n alpha_mask = np.abs(freqs - 10) <= 2.0\\n alpha_pxx = 10*np.log10(pxx[alpha_mask])\\n alpha_pxx = scipy.signal.detrend(alpha_pxx)\\n # iaf[ch] = alpha_pxx.shape\\n iaf[ch] = freqs[alpha_mask][np.argmax(alpha_pxx)]\\n iaf = float(np.mean(iaf))\\n bin = int(np.digitize((iaf,), np.linspace(8,12, bins+1)))\\n return (bin, iaf)\",\n \"def bins_match (a, b):\\n return 0 == (\\n np.sum ((a.xbins - b.xbins)**2)\\n + np.sum ((a.ybins - b.ybins)**2) )\",\n \"def conceptcover(bin_arr, limit=1, uncovered=0.1):\\n arr = np.copy(bin_arr)\\n arr_sum = np.sum(arr)\\n result = []\\n while True:\\n k = kernel(arr)\\n i = intent(bin_arr, k)\\n e = extent(bin_arr, i)\\n if len(e)*len(i) < limit or (e, i) in result: break\\n result.append((e, i))\\n arr = removed(arr, e, i)\\n if np.sum(arr)/arr_sum < uncovered: break\\n return result\",\n \"def __check(self):\\n if len(self._data)!=len(self._ptbins)+1: \\n raise IndexError('Pt bins mismatch')\\n for ptbin in self._data:\\n if len(ptbin)!=len(self._etabins)+1:\\n raise IndexError('Eta bins mismatch')\",\n \"def bineval(ratings, gold, pred, increment=50, bins = [0, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600, 2700, 2800]):\\n\\n pw_accs = [(r, int(b==c)) for r,b,c in sorted(zip(ratings, gold, pred))]\\n \\n binned_accs = []\\n current_acc = 0\\n denom = 0\\n bin_id = 0\\n \\n for r, acc in pw_accs:\\n while r > bins[bin_id] + increment:\\n bin_id += 1\\n if denom == 0:\\n binned_accs.append(float(\\\"NaN\\\"))\\n else:\\n binned_accs.append(current_acc/float(denom))\\n current_acc = 0\\n denom = 0\\n current_acc += acc\\n denom += 1\\n\\n if denom == 0:\\n binned_accs.append(float(\\\"NaN\\\"))\\n else:\\n binned_accs.append(current_acc/float(denom))\\n\\n for b, acc in zip(bins, binned_accs):\\n print b, acc\",\n \"def test_pandas_bins(self):\\n # Load the data from the fixture\\n data = load_occupancy(return_dataset=True)\\n X, y = data.to_pandas()\\n\\n visualizer = BalancedBinningReference()\\n visualizer.fit(y)\\n visualizer.finalize()\\n self.assert_images_similar(visualizer, tol=0.5)\",\n \"def bin_statistics(data,bin_against,bin_edges,data_signal=[]):\\n\\n assert isinstance(data, pd.DataFrame), 'data must be of type pd.DataFram' \\n try: bin_against = np.asarray(bin_against) \\n except: 'bin_against must be of type np.ndarray'\\n try: bin_edges = np.asarray(bin_edges)\\n except: 'bin_edges must be of type np.ndarray' \\n\\n # Determine variables to analyze\\n if len(data_signal)==0: # if not specified, bin all variables\\n data_signal=data.columns.values\\n else:\\n assert isinstance(data_signal, list), 'must be of type list'\\n\\n # Pre-allocate list variables\\n bin_stat_list = []\\n bin_std_list = []\\n\\n # loop through data_signal and get binned means\\n for signal_name in data_signal:\\n # Bin data\\n bin_stat = binned_statistic(bin_against,data[signal_name],\\n statistic='mean',bins=bin_edges)\\n # Calculate std of bins\\n std = []\\n stdev = pd.DataFrame(data[signal_name])\\n stdev.set_index(bin_stat.binnumber,inplace=True)\\n for i in range(1,len(bin_stat.bin_edges)):\\n try:\\n temp = stdev.loc[i].std(ddof=0)\\n std.append(temp[0])\\n except:\\n std.append(np.nan)\\n bin_stat_list.append(bin_stat.statistic)\\n bin_std_list.append(std)\\n \\n # Convert to DataFrames\\n bin_mean = pd.DataFrame(np.transpose(bin_stat_list),columns=data_signal)\\n bin_std = pd.DataFrame(np.transpose(bin_std_list),columns=data_signal)\\n\\n # Check for nans \\n if bin_mean.isna().any().any():\\n print('Warning: some bins may be empty!')\\n\\n return bin_mean, bin_std\",\n \"def test_range_argument(self):\\n # we test with range from 0 to 2, with 3 bins -> [0, 0.66, 1.33, 2] exp. bins\\n bins_range = (0, 2)\\n bins_exp = np.array([0, 2 / 3, 1 + 1 / 3, 2])\\n hist_exp = np.array([1, 2, 0])\\n\\n bin_edges, hist, _, _ = hist_w_unc(\\n self.input,\\n bins=self.n_bins,\\n bins_range=bins_range,\\n normed=False,\\n )\\n\\n # check if we end up with the same bin edges anyway\\n np.testing.assert_array_almost_equal(bins_exp, bin_edges)\\n np.testing.assert_array_almost_equal(hist_exp, hist)\",\n \"def test_binops(self):\",\n \"def __call__(self, n_bins, segment, elements):\\n\\n # n_bins\\n assert type(n_bins) is int\\n assert n_bins > 0\\n\\n # segment\\n assert type(segment) is list or type(segment) is tuple\\n assert len(segment) == 2\\n assert np.isscalar(segment[0]) and np.isscalar(segment[1])\\n assert segment[0] < segment[1]\\n\\n # elements\\n assert type(elements) is np.ndarray, f\\\"elements should be an np.ndarray, instead of {type(elements)}\\\"\\n assert elements.dtype == np.number\\n\\n raise NotImplemented\",\n \"def test_range_argument_ignored(self):\\n bins_range = (1, 2)\\n\\n bin_edges, hist, _, _ = hist_w_unc(\\n self.input,\\n bins=self.bin_edges,\\n bins_range=bins_range,\\n normed=False,\\n )\\n\\n # check if we end up with the same bin edges anyway\\n np.testing.assert_array_almost_equal(self.bin_edges, bin_edges)\\n np.testing.assert_array_almost_equal(self.hist, hist)\",\n \"def test_irregular(self):\\n import numpy as np\\n import histogrammar\\n\\n h = histogrammar.IrregularlyBin([0, 10, 20, 40, 100])\\n h.fillnumpy([-5, 5, 5, 50, 10, 100, 1000, 50, 50])\\n\\n np.testing.assert_array_equal(h.bin_entries(), [1., 2., 1., 0., 3., 2.])\\n np.testing.assert_array_equal(h.bin_edges(), [float('-inf'), 0., 10., 20., 40., 100., float('inf')])\\n np.testing.assert_array_equal(h.bin_centers(), [float('-inf'), 5., 15., 30., 70., float('inf')])\\n assert h.num_bins() == 6\\n assert h.n_bins == 6\\n np.testing.assert_almost_equal(h.mpv, 70.)\\n\\n np.testing.assert_array_equal(h.bin_entries(10, 40), [1., 0.])\\n np.testing.assert_array_equal(h.bin_edges(10, 40), [10., 20., 40.])\\n np.testing.assert_array_equal(h.bin_centers(10, 40), [15., 30.])\\n assert h.num_bins(10, 40) == 2\\n\\n np.testing.assert_array_equal(h.bin_entries(5, 110), [2., 1., 0., 3., 2.])\\n np.testing.assert_array_equal(h.bin_edges(5, 110), [0., 10., 20., 40., 100., float('inf')])\\n np.testing.assert_array_equal(h.bin_centers(5, 110), [5., 15., 30., 70., float('inf')])\\n assert h.num_bins(5, 110) == 5\",\n \"def _get_optimal_threshold(arr, num_bins=1001, num_quantized_bins=255):\\n if not isinstance(arr, np.ndarray):\\n raise TypeError('get_optimal_threshold only supports input type of np.ndarray,'\\n ' while received type=%s' % (str(type(arr))))\\n min_val = np.min(arr)\\n max_val = np.max(arr)\\n th = max(abs(min_val), abs(max_val))\\n\\n hist, hist_edges = np.histogram(arr, bins=num_bins, range=(-th, th))\\n zero_bin_idx = num_bins // 2\\n num_half_quantized_bins = num_quantized_bins // 2\\n assert np.allclose(hist_edges[zero_bin_idx] + hist_edges[zero_bin_idx + 1],\\n 0, rtol=1e-5, atol=1e-7)\\n\\n thresholds = np.zeros(num_bins // 2 + 1 - num_quantized_bins // 2)\\n divergence = np.zeros_like(thresholds)\\n quantized_bins = np.zeros(num_quantized_bins, dtype=np.int32)\\n # i means the number of bins on half axis excluding the zero bin.\\n for i in range(num_quantized_bins // 2,\\n num_bins // 2 + 1):\\n p_bin_idx_start = zero_bin_idx - i\\n p_bin_idx_stop = zero_bin_idx + i + 1\\n thresholds[i - num_half_quantized_bins] = hist_edges[p_bin_idx_stop]\\n sliced_nd_hist = hist[p_bin_idx_start:p_bin_idx_stop]\\n\\n # generate reference distribution p\\n p = sliced_nd_hist.copy()\\n assert p.size % 2 == 1\\n assert p.size >= num_quantized_bins\\n # put left outlier count in p[0]\\n left_outlier_count = np.sum(hist[0:p_bin_idx_start])\\n p[0] += left_outlier_count\\n # put right outlier count in p[-1]\\n right_outlier_count = np.sum(hist[p_bin_idx_stop:])\\n p[-1] += right_outlier_count\\n # is_nonzeros[k] indicates whether hist[k] is nonzero\\n is_nonzeros = (sliced_nd_hist != 0).astype(np.int32)\\n\\n # calculate how many bins should be merged to generate quantized distribution q\\n num_merged_bins = p.size // num_quantized_bins\\n # merge hist into num_quantized_bins bins\\n for j in range(num_quantized_bins):\\n start = j * num_merged_bins\\n stop = start + num_merged_bins\\n quantized_bins[j] = sliced_nd_hist[start:stop].sum()\\n quantized_bins[-1] += sliced_nd_hist[num_quantized_bins * num_merged_bins:].sum()\\n # expand quantized_bins into p.size bins\\n q = np.zeros(p.size, dtype=np.float32)\\n for j in range(num_quantized_bins):\\n start = j * num_merged_bins\\n if j == num_quantized_bins - 1:\\n stop = -1\\n else:\\n stop = start + num_merged_bins\\n norm = is_nonzeros[start:stop].sum()\\n if norm != 0:\\n q[start:stop] = float(quantized_bins[j]) / float(norm)\\n q[sliced_nd_hist == 0] = 0\\n p = _smooth_distribution(p)\\n # There is a chance that q is an invalid probability distribution.\\n try:\\n q = _smooth_distribution(q)\\n except ValueError:\\n divergence[i - num_half_quantized_bins] = float(\\\"inf\\\")\\n else:\\n divergence[i - num_half_quantized_bins] = stats.entropy(p, q)\\n quantized_bins[:] = 0\\n\\n min_divergence_idx = np.argmin(divergence)\\n min_divergence = divergence[min_divergence_idx]\\n opt_th = thresholds[min_divergence_idx]\\n return min_val, max_val, min_divergence, opt_th\",\n \"def bins_match (a, b):\\n return np.sum ((a.bins - b.bins)**2) == 0\",\n \"def __call__(self, n_bins, segment, elements):\\n\\n # n_bins\\n assert type(n_bins) is int\\n assert n_bins > 0\\n\\n # segment\\n assert type(segment) is list or type(segment) is tuple\\n assert len(segment) == 2\\n assert np.isscalar(segment[0]) and np.isscalar(segment[1])\\n assert segment[0] < segment[1]\\n\\n # elements\\n assert type(elements) is np.ndarray, f\\\"elements should be an np.ndarray, instead of {type(elements)}\\\"\\n assert elements.dtype == np.number\\n\\n sorted_elements = np.sort(elements)\\n\\n bin_card = int(floor(elements.shape[0]/n_bins))\\n\\n bin_boundaries = [segment[0]]\\n\\n for i in range(1, n_bins):\\n boundary_l = sorted_elements[i*bin_card - 1]\\n boundary_r = sorted_elements[i * bin_card]\\n boundary = (boundary_l+boundary_r)/2\\n\\n bin_boundaries.append(boundary)\\n\\n bin_boundaries.append(segment[1])\\n\\n return np.array(bin_boundaries)\",\n \"def __init__(self, x, bin_edges, Nsamp):\\n raw_vals, bin_edges = np.histogram(x, bins=bin_edges, normed=False)\\n self.bin_edges = bin_edges\\n self.bin_widths = np.diff(self.bin_edges)\\n self.bin_centers = 0.5*(self.bin_edges[:-1] + self.bin_edges[1:])\\n \\n P, low, high = np.array([BinomialErrors(v, Nsamp) for v in raw_vals]).T\\n self.raw_vals = P\\n self.raw_low = low\\n self.raw_high = high\\n self.complete_vals = None\\n self.malm_vals = None\\n return\",\n \"def binarize(adata, copy=False):\\n threshold, upper, lower = 1.0, 1.0, 0.0\\n admatrix = adata.X\\n admatrix = np.where(admatrix>threshold, upper, lower)\\n if copy:\\n adata2 = adata.copy()\\n adata2.X = admatrix\\n return(adata2)\\n else:\\n adata.X = admatrix\",\n \"def amp_bin(raw, depth, low, high):\\n\\n max_in_depth = 2 ** depth\\n bin_range = np.linspace(low, high, max_in_depth)\\n data = []\\n for b in raw:\\n i = 0\\n while i <= (max_in_depth - 2):\\n if (bin_range[i] <= b < bin_range[i+1]):\\n data.append(i)\\n i += 1\\n break\\n elif (b <= low):\\n data.append(0)\\n break\\n elif (b >= high):\\n data.append(max_in_depth - 1)\\n break\\n else:\\n i += 1\\n return np.array(data)\",\n \"def test_num_bins(self):\\n with Pandas() as pd:\\n if pd is None:\\n return\\n with Numpy() as np: # noqa\\n if numpy is None:\\n return\\n sys.stderr.write(\\\"\\\\n\\\")\\n\\n df1 = pd.DataFrame({'A': [0, 2, 4, 5, 7, 9, 11, 13, 13, 15]})\\n df2 = pd.DataFrame({'A': [2, 4, 4, 6, 8, 7, 10, 14, 17, 19]})\\n\\n # building 1d-, 2d-, and 3d-histogram (iteratively)\\n hist2 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\\n hist3 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\\n hist4 = hg.Bin(num=20, low=0.0, high=20., quantity=unit('A'))\\n hist5 = hg.Bin(num=20, low=0.0, high=20., quantity=unit('A'))\\n hist6 = hg.Bin(num=201, low=0.0, high=1.005)\\n\\n # fill them\\n hist2.fill.numpy(df1)\\n hist3.fill.numpy(df2)\\n hist4.fill.numpy(df1)\\n hist5.fill.numpy(df2)\\n\\n assert hist2.num_bins() == 16\\n assert hist3.num_bins() == 18\\n assert hist4.num_bins() == 20\\n assert hist5.num_bins() == 20\\n assert hist6.num_bins() == 201\\n\\n assert hist2.num_bins(low=10, high=25) == 15\\n assert hist3.num_bins(low=10, high=25) == 15\\n assert hist4.num_bins(low=10, high=25) == 10\\n assert hist5.num_bins(low=10, high=25) == 10\\n assert hist6.num_bins(low=0.2089, high=0.9333) == 146\\n\\n assert hist2.num_bins(low=-10, high=28) == 38\\n assert hist3.num_bins(low=-10, high=28) == 38\\n assert hist4.num_bins(low=-10, high=28) == 20\\n assert hist5.num_bins(low=-10, high=28) == 20\\n assert hist6.num_bins(low=0.205, high=0.935) == 146\",\n \"def __etaBin(self,eta):\\n if len(self._etabins)>0:\\n return reduce(lambda x,y:x+y,map(lambda x:abs(eta)>x,self._etabins))\\n else:\\n return 0\",\n \"def test08(self):\\n a = np.arange(1, 11)\\n b = bcolz.carray(a)\\n ul = [v for v in a if v <= 5]\\n u = b.where(a <= 5)\\n wl = [v for v in a if v <= 6]\\n w = b.where(a <= 6)\\n self.assertEqual(ul, list(u))\\n self.assertEqual(wl, list(w))\",\n \"def autobin_stats(x,y,n_bins=8,stat='average',n_points=None):\\n \\n if not ascend(x):\\n ix=argsort(x)\\n x=take(x,ix)\\n y=take(y,ix)\\n n=len(x)\\n if n_points==None: \\n #This throws out some points\\n n_points=n/n_bins\\n else: \\n n_bins=n/n_points\\n #if there are more that 2 points in the last bin, add another bin\\n if n%n_points>2: n_bins=n_bins+1\\n \\n if n_points<=1:\\n print('Only 1 or less points per bin, output will be sorted input vector with rms==y')\\n return x,y\\n xb,yb=[],[]\\n \\n #print 'stat', stat\\n if stat=='average' or stat=='mean': func=mean\\n elif stat=='median': func=median\\n elif stat=='rms' or stat=='std' : func=std\\n elif stat=='std_robust' or stat=='rms_robust': func=std_robust\\n elif stat=='mean_robust': func=mean_robust\\n elif stat=='median_robust': func=median_robust\\n elif stat=='p2p': func=p2p # --DC\\n elif stat=='min': func=min # --DC\\n elif stat=='max': func=max # --DC\\n \\n for i in range(n_bins):\\n xb.append(mean(x[i*n_points:(i+1)*n_points]))\\n if func==std and n_points==2:\\n print('n_points==2; too few points to determine rms')\\n print('Returning abs(y1-y2)/2. in each bin as rms')\\n yb.append(abs(y[i*n_points]-y[i*n_points+1])/2.)\\n else:\\n yb.append(func(y[i*n_points:(i+1)*n_points]))\\n if i>2 and xb[-1]==xb[-2]: \\n yb[-2]=(yb[-2]+yb[-1])/2.\\n xb=xb[:-1]\\n yb=yb[:-1]\\n return array(xb),array(yb)\",\n \"def affect(self, bin_boundaries, element):\\n\\n # bin_boundaries\\n assert type(bin_boundaries) is np.ndarray\\n\\n # element\\n assert isinstance(element, (int, float, np.number)), \\\\\\n \\\"element = {} should be of a numeric type, not {}.\\\".format(element, type(element))\\n assert bin_boundaries[0] <= element <= bin_boundaries[-1]\\n\\n n_bins = len(bin_boundaries) - 1\\n m = floor(element * n_bins) if floor(element * n_bins) < n_bins else n_bins - 1\\n\\n return m\",\n \"def __init__(self, bins):\\n self.bins = bins\",\n \"def test_hgbat(self):\\n fun = get_problem('hgbat', self.dimension, -100, 100)\\n self.assertAlmostEqual(fun(self.array10), 61.91502622129181, delta=60)\",\n \"def compute_acc_bin(conf_thresh_lower, conf_thresh_upper, conf, pred, true):\\n filtered_tuples = [x for x in zip(pred, true, conf) if x[2] > conf_thresh_lower and x[2] <= conf_thresh_upper]\\n if len(filtered_tuples) < 1:\\n return 0,0,0\\n else:\\n correct = len([x for x in filtered_tuples if x[0] == x[1]]) # How many correct labels\\n len_bin = len(filtered_tuples) # How many elements falls into given bin\\n avg_conf = sum([x[2] for x in filtered_tuples]) / len_bin # Avg confidence of BIN\\n accuracy = float(correct)/len_bin # accuracy of BIN\\n return accuracy, avg_conf, len_bin\",\n \"def compute_acc_bin(conf_thresh_lower, conf_thresh_upper, conf, pred, true):\\n filtered_tuples = [x for x in zip(pred, true, conf) if x[2] > conf_thresh_lower and x[2] <= conf_thresh_upper]\\n if len(filtered_tuples) < 1:\\n return 0,0,0\\n else:\\n correct = len([x for x in filtered_tuples if x[0] == x[1]]) # How many correct labels\\n len_bin = len(filtered_tuples) # How many elements falls into given bin\\n avg_conf = sum([x[2] for x in filtered_tuples]) / len_bin # Avg confidence of BIN\\n accuracy = float(correct)/len_bin # accuracy of BIN\\n return accuracy, avg_conf, len_bin\",\n \"def II_eq_counts(tobin_series, num_bins):\\n num_pbin = int(len(tobin_series) / num_bins)\\n obs_list = tobin_series.sort_values().tolist()\\n upper_bounds = [obs_list[(i + 1) * num_pbin] for i in range(num_bins)]\\n lower_bounds = [0]\\n lower_bounds += upper_bounds[:-1]\\n return pd.IntervalIndex.from_arrays(lower_bounds, upper_bounds), upper_bounds\",\n \"def bin_data(bins, data2bin, bindata, mode='mean', nbinned=False):\\n assert mode in ['mean', 'median', 'std', 'max', 'min'], \\\"mode not recognized: {}\\\".format(mode)\\n digitized = np.digitize(bindata, bins)\\n binned = np.zeros(len(bins)) * np.nan\\n if nbinned: \\n numbinned = np.zeros(len(bins))\\n\\n if mode == 'mean':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanmean(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n elif mode == 'median':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanmedian(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n elif mode == 'std':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanstd(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n elif mode == 'max':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanmax(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n elif mode == 'min':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanmin(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n else:\\n raise ValueError('mode must be mean, median, std, max, or min')\\n \\n if nbinned:\\n return np.array(binned), np.array(numbinned)\\n else:\\n return np.array(binned)\",\n \"def binarize(X, *, threshold=..., copy=...):\\n ...\",\n \"def process_pain(x, lb, ub):\\n x = x.abs()\\n x.loc[(x > ub)] = 8\\n x.loc[(x < lb) | (x > ub)] = np.nan\\n return x\",\n \"def calculate_bin_edges(n_bins, geo):\\n #Gefittete offsets: x,y,factor: factor*(x+x_off)\\n #[6.19, 0.064, 1.0128]\\n \\n #print \\\"Reading detector geometry in order to calculate the detector dimensions from file \\\" + fname_geo_limits\\n #geo = np.loadtxt(fname_geo_limits)\\n\\n # derive maximum and minimum x,y,z coordinates of the geometry input [[first_OM_id, xmin, ymin, zmin], [last_OM_id, xmax, ymax, zmax]]\\n geo_limits = np.nanmin(geo, axis = 0), np.nanmax(geo, axis = 0)\\n #print ('Detector dimensions [[first_OM_id, xmin, ymin, zmin], [last_OM_id, xmax, ymax, zmax]]: ' + str(geo_limits))\\n\\n x_bin_edges = np.linspace(geo_limits[0][1] - 9.95, geo_limits[1][1] + 9.95, num=n_bins[0] + 1) #try to get the lines in the bin center 9.95*2 = average x-separation of two lines\\n y_bin_edges = np.linspace(geo_limits[0][2] - 9.75, geo_limits[1][2] + 9.75, num=n_bins[1] + 1) # Delta y = 19.483\\n z_bin_edges = np.linspace(geo_limits[0][3] - 4.665, geo_limits[1][3] + 4.665, num=n_bins[2] + 1) # Delta z = 9.329\\n\\n #offset_x, offset_y, scale = [6.19, 0.064, 1.0128]\\n #x_bin_edges = (x_bin_edges + offset_x )*scale\\n #y_bin_edges = (y_bin_edges + offset_y )*scale\\n\\n #calculate_bin_edges_test(geo, y_bin_edges, z_bin_edges) # test disabled by default. Activate it, if you change the offsets in x/y/z-bin-edges\\n\\n return x_bin_edges, y_bin_edges, z_bin_edges\",\n \"def _loop_over_entries(x_bins, y_bins, used_eff, n_out_bins):\\n sys.stdout.write('finding eff at rejection... ')\\n sys.stdout.flush()\\n\\n valid_x = (x_bins >= 0) & (x_bins < n_out_bins) \\n valid_y = (y_bins >= 0) & (y_bins < n_out_bins)\\n\\n valid_indices = np.flatnonzero(valid_x & valid_y)\\n\\n x_bins = x_bins[valid_indices]\\n y_bins = y_bins[valid_indices]\\n used_eff = used_eff[valid_indices]\\n\\n eff_array = np.ones((n_out_bins,n_out_bins)) * -1\\n for x_bin, y_bin, z in zip(x_bins, y_bins, used_eff): \\n # y_bin comes first because that's what imshow wants... \\n eff_array[y_bin,x_bin] = max(z, eff_array[y_bin,x_bin])\\n\\n sys.stdout.write('done\\\\n')\\n return eff_array\",\n \"def __call__(self, n_bins, segment, elements):\\n\\n # n_bins\\n assert type(n_bins) is int\\n assert n_bins > 0\\n\\n # segment\\n assert type(segment) is list or type(segment) is tuple\\n assert len(segment) == 2\\n assert np.isscalar(segment[0]) and np.isscalar(segment[1])\\n assert segment[0] < segment[1]\\n\\n # elements\\n assert type(elements) is np.ndarray, f\\\"elements should be an np.ndarray, instead of {type(elements)}\\\"\\n assert elements.dtype == np.number\\n\\n return np.array([segment[0] + i / n_bins * (segment[1] - segment[0])\\n for i in range(n_bins)]\\n + [float(segment[1])])\",\n \"def bin_data(y, num_bins, std_away):\\n mean = np.mean(y)\\n std = np.std(y)\\n pitch_shifts = np.arange(-num_bins, num_bins + 1)\\n thresholds = (std * std_away) * pitch_shifts + mean\\n\\n result = []\\n for point in y:\\n if point < thresholds[0]:\\n result.append(pitch_shifts[0] - 1)\\n elif point > thresholds[-1]:\\n result.append(pitch_shifts[-1] + 1)\\n else:\\n for i in range(len(thresholds) - 1):\\n if point >= thresholds[i] and point < thresholds[i + 1]:\\n result.append(i - num_bins)\\n return np.array(result)\",\n \"def _determine_histogram_bins(self, ma_maps):\\n if isinstance(ma_maps, list):\\n ma_values = self.masker.transform(ma_maps)\\n elif isinstance(ma_maps, np.ndarray):\\n ma_values = ma_maps.copy()\\n else:\\n raise ValueError(f\\\"Unsupported data type '{type(ma_maps)}'\\\")\\n\\n # Determine bins for null distribution histogram\\n # Remember that numpy histogram bins are bin edges, not centers\\n # Assuming values of 0, .001, .002, etc., bins are -.0005-.0005, .0005-.0015, etc.\\n INV_STEP_SIZE = 100000\\n step_size = 1 / INV_STEP_SIZE\\n max_ma_values = np.max(ma_values, axis=1)\\n # round up based on resolution\\n max_ma_values = np.ceil(max_ma_values * INV_STEP_SIZE) / INV_STEP_SIZE\\n max_poss_ale = self.compute_summarystat(max_ma_values)\\n # create bin centers\\n hist_bins = np.round(np.arange(0, max_poss_ale + (1.5 * step_size), step_size), 5)\\n self.null_distributions_[\\\"histogram_bins\\\"] = hist_bins\",\n \"def _bin(self, X):\\n H = np.linspace(0, 1, self.Nbin)\\n return np.maximum(1 - (abs(X[..., None] - H)) / (H[1] - H[0]) , 0)\",\n \"def mu_law_bins(num_bins):\\n #all edges\\n bins_edge = np.linspace(-1, 1, num_bins + 1)\\n #center of all edges\\n bins_center = np.linspace(-1 + 1.0 / num_bins, 1 - 1.0 / num_bins, num_bins)\\n #get the right edges\\n bins_trunc = bins_edge[1:]\\n #if sample >= right edges, it might be assigned to the next bin, add 0.1 to avoid this\\n bins_trunc[-1] += 0.1\\n #convert edges and centers to mu-law scale\\n bins_edge_mu = np.multiply(np.sign(bins_trunc), (num_bins ** np.absolute(bins_trunc) - 1) / (num_bins - 1))\\n bins_center_mu = np.multiply(np.sign(bins_center), (num_bins ** np.absolute(bins_center) - 1) / (num_bins - 1))\\n \\n return (bins_edge_mu, bins_center_mu)\",\n \"def test_bin_larvaemutattion():\\n \\n larvae = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\\n [1, 1, 1, 1, 0, 0, 0, 0],\\n [0, 0, 0, 0, 1, 1, 1, 1]])\\n \\n pos = np.array([[0, 3, 5]])\\n mode = 'bin'\\n \\n larvaemutation_function = get_larvaemutation_function(mode)\\n larvaemutated = larvaemutation_function(larvae, pos, seed=13)\\n \\n goodsol = np.array([[1, 0, 0, 0, 0, 0, 0, 0],\\n [1, 1, 1, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 1, 0, 1, 1]])\\n\\n np.testing.assert_almost_equal(larvaemutated, goodsol)\",\n \"def modelOnBetaGrid(sample,bins,N,l,u):\\r\\n\\r\\n betaGrid=np.linspace(l,u,N)\\r\\n traces=[]\\r\\n WAIC=dict()\\r\\n index=0\\r\\n\\r\\n for beta in betaGrid:\\r\\n trace=intensityLogGauss(sample,bins,beta)\\r\\n traces.append(trace['intensity'])\\r\\n WAIC[index]=trace\\r\\n index+=1\\r\\n\\r\\n df=pm.compare(WAIC,ic='WAIC')\\r\\n\\r\\n return betaGrid,df,traces\",\n \"def ANN_binned_tagged_jets_hist(datalist, model, discriminant_cuts, CSV_cuts, bins, nbins, mode=\\\"pT_jet\\\",Save=False,addFeature=False):\\n title = \\\"binned_tagged_jets_vs_\\\"+mode\\n\\tdiscriminant = \\\"ANN\\\"\\n AllJetsHistlist = []\\n CSVHistlist = []\\n DiscriminantHistlist = []\\n if mode == \\\"pT_hadron\\\":\\n feature = 2\\n elif mode == \\\"pT_jet\\\":\\n feature = 3\\n elif mode == \\\"decay_vx\\\":\\n feature = 4\\n for n,data in enumerate(datalist):\\n\\t\\tdatatitle = data[3]\\n print \\\"working on\\\",datatitle\\n ran = data[4]\\n\\t\\tCSV = data[2]\\n\\t\\tpT = data[1]\\n\\t\\tx_data = data[0]\\n AllJetsHistlist.append(rt.TH1D(datatitle+\\\"_AllJets\\\",datatitle+\\\"_\\\"+title,nbins,ran[0],ran[1]))\\n AllJetsHistlist[n].SetLineColor(4)\\n CSVHistlist.append(rt.TH1D(datatitle+\\\"_CSV\\\",datatitle+\\\"_\\\"+title,nbins,ran[0],ran[1]))\\n CSVHistlist[n].SetLineColor(3)\\n DiscriminantHistlist.append(rt.TH1D(datatitle+\\\"_Discriminant\\\",datatitle+\\\"_\\\"+title,nbins,ran[0],ran[1]))\\n DiscriminantHistlist[n].SetLineColor(2)\\n\\t\\n\\t\\tif addFeature == False:\\n\\t\\t\\tpred_y = model.predict(ANN_functional_shape(x_data))\\n\\t\\telif addFeature == \\\"pT\\\":\\n\\t\\t\\tpred_y = model.predict(ANN_functional_shape(x_data)+[pT/200])\\n\\t\\telif addFeature == \\\"PV\\\":\\n\\t\\t\\tassert x_data.shape[1] == 21, \\\"wrong x_data format: PV cannot be found\\\"\\n\\t\\t\\tpred_y = model.predict(ANN_functional_shape(x_data)+[x_data[:,-1]/10.])\\n\\t\\telse:\\n\\t\\t\\tprint \\\"invalid feature input\\\"\\n\\t\\t\\treturn None\\n\\t\\tbin_numbers = ANN_bin_selection(pT,bins)\\n\\n\\t for i,pT_value in enumerate(pT):\\n\\t if bin_numbers[i] == -100: continue\\n\\t\\t\\tAllJetsHistlist[n].Fill(pT_value)\\n\\t if pred_y[i] >= discriminant_cuts[bin_numbers[i]]: DiscriminantHistlist[n].Fill(pT_value)\\n\\t if CSV[i] >= CSV_cuts[bin_numbers[i]]: CSVHistlist[n].Fill(pT_value)\\n\\n canvaslist = []\\n legendlist = []\\n Tfilelist = []\\n for n,data in enumerate(datalist):\\n\\t\\tdatatitle = data[3]\\n canvaslist.append(rt.TCanvas(datatitle+\\\"_canvas\\\",\\\"canvas\\\",600,600))\\n canvaslist[n].SetTitle(datatitle+\\\"_\\\"+title)\\n rt.gStyle.SetOptStat(0)\\n legendlist.append(rt.TLegend(0.9,0.9,0.65,0.75))\\n legendlist[n].AddEntry(AllJetsHistlist[n], \\\"All jets\\\")\\n legendlist[n].AddEntry(CSVHistlist[n], \\\"CSV\\\")\\n legendlist[n].AddEntry(DiscriminantHistlist[n], discriminant)\\n AllJetsHistlist[n].GetXaxis().SetTitle(mode)\\n AllJetsHistlist[n].GetYaxis().SetTitle('# jets')\\n AllJetsHistlist[n].GetYaxis().SetTitleOffset(1.5)\\n #AllJetsHistlist[n].Draw()\\n #CSVHistlist[n].Draw(\\\"SAME\\\")\\n #DiscriminantHistlist[n].Draw(\\\"SAME\\\")\\n #legendlist[n].Draw()\\n if Save:\\n #canvaslist[n].SaveAs(title+\\\"_\\\"+datatitle+discriminant+\\\".png\\\")\\n Tfilelist.append(rt.TFile(\\\"Thesis_Plots/root_files/\\\"+title+\\\"_\\\"+datatitle+discriminant+\\\".root\\\",\\\"recreate\\\"))\\n print \\\"saved histogram as Thesis_Plots/root_files/\\\"+title+\\\"_\\\"+datatitle+discriminant+\\\".root\\\"\\n AllJetsHistlist[n].Write()\\n CSVHistlist[n].Write()\\n DiscriminantHistlist[n].Write()\",\n \"def bin_definition(n_bins_gammaness, n_bins_theta2):\\n max_gam = 0.9\\n max_th2 = 0.05 * u.deg * u.deg\\n min_th2 = 0.005 * u.deg * u.deg\\n\\n gammaness_bins = np.linspace(0, max_gam, n_bins_gammaness)\\n theta2_bins = np.linspace(min_th2, max_th2, n_bins_theta2)\\n\\n return gammaness_bins, theta2_bins\",\n \"def __init__(self, bin_edges, **kwargs):\\n super().__init__(**kwargs)\\n self.bin_edges = bin_edges\\n self.num_bins = bin_edges.size + 1\\n self.sigma = Parameter(1.0, transform=positive())\",\n \"def test_bin_qual_scores(self):\\r\\n\\r\\n qual_data = {'seq1': [10, 20, 30, 40], 'seq2': [11, 21, 31],\\r\\n 'seq3': [12, 22]}\\r\\n\\r\\n expected_bins = [[10, 11, 12], [20, 21, 22], [30, 31], [40]]\\r\\n\\r\\n actual_bins = bin_qual_scores(qual_data)\\r\\n\\r\\n # Because of arbritrary dictionary order, need to sort results\\r\\n for bin in range(len(actual_bins)):\\r\\n actual_bins[bin].sort()\\r\\n\\r\\n self.assertEqual(actual_bins, expected_bins)\",\n \"def sat_in_range(arr, args):\\n # find number of saturated pixels, args[0] is the pixel saturation limit\\n sat_pixels = (arr > args[0]).sum()\\n # args[1] is a limit of saturated pixels\\n res = sat_pixels < args[1]\\n result = ct.Result(res, 'saturation_in_range')\\n return result\",\n \"def can_binarize(a, r, phrase_index):\\n if r.arity() <= 2:\\n return 1\\n if r.arity() > 3:\\n raise ValueError(\\\"4-ary rules and above not supported yet\\\")\\n\\n fvars = [x for x in r.fpos if type(x) is tuple]\\n for (fi,fj) in phrase_index:\\n if fi <= fvars[0][0] and fvars[1][1] <= fj <= fvars[2][0]:\\n return 1\\n if fvars[0][1] <= fi <= fvars[1][0] and fvars[2][1] <= fj:\\n return 1\\n\\n return 0\",\n \"def bin_discretize(self, variables=[], bins=3,\\n min_const_samples_bin_size=1.0/3):\\n self.edges=np.zeros((self.arity.size,bins+1))\\n for i in variables:\\n un_cnt=np.unique(self.data[:,i],return_counts=True)\\n constvals=un_cnt[0][un_cnt[1]>self.data.shape[0]*min_const_samples_bin_size]\\n mask=np.ones(self.data.shape[0],dtype=bool)\\n if constvals.size>0:\\n for j,cv in enumerate(constvals):\\n mask*=(self.data[:,i]!=cv)\\n self.data[self.data[:,i]==cv,i]=j\\n\\n size=np.sum(mask)/bins\\n sorted_i=np.argsort(self.data[mask,i])\\n edges=[self.data[mask,i][sorted_i[int(size*num)-1]] for num in range(1,bins)]\\n self.edges[i]=[self.data[mask,i][sorted_i[0]]]+edges+[self.data[mask,i][sorted_i[-1]]]\\n self.data[mask,i]=np.searchsorted(edges,self.data[mask,i])+constvals.size\\n self.arity[i]=len(edges)+1+constvals.size\",\n \"def test_bin_right(self):\\n list_val=[0,1,2,3,4,5,6]\\n low=0\\n high= len(list_val)-1\\n target=1\\n self.assertEqual(bin_search(1,0,len(list_val)-1, list_val),1)\",\n \"def __len__(self):\\n return 9 # logsfr_ratios has 6 bins\",\n \"def test_run_a_scan_on_sdp_subarray_in_low():\",\n \"def computeAC(bins):\\n halfn = len(bins)/2\\n Npos = sum(bins[halfn:])\\n Nneg = sum(bins[:halfn])\\n return float(Npos-Nneg)/(Npos+Nneg)\",\n \"def freedman_diaconis_bins(self, arr):\\n # From https://stats.stackexchange.com/questions/798/\\n if len(arr) < 2:\\n return 1\\n # Calculate the iqr ranges.\\n self.iqr(arr)\\n # Calculate the h\\n h = 2 * (self.q3 - self.q1) / (len(arr) ** (1 / 3))\\n # fall back to sqrt(a) bins if iqr is 0\\n if h == 0:\\n return int(np.sqrt(arr.size))\\n else:\\n return int(np.ceil((arr.max() - arr.min()) / h))\",\n \"def test_bin_data_type(self):\\n\\n with pytest.raises(TypeError) as verr:\\n avg.median2D(self.testInst, ['1', 'a', '23', '10'], 'longitude',\\n ['0', 'd', '24', 'c'], 'mlt',\\n ['dummy1', 'dummy2', 'dummy3'], auto_bin=False)\\n\\n estr = \\\"Cannot cast array data from\\\"\\n assert str(verr).find(estr) >= 0\\n\\n return\",\n \"def SetPRBinConstraint(self, model ) :\\n tot = np.multiply(self.wish, self.dispo)\\n for val in tot :\\n if not val : continue\\n if self.bound>0 : model += val <= self.valBound\\n elif self.bound<0 : model += val >= self.valBound\",\n \"def correct_ann_outliers(obj_tmp, ann_width, sig, med_neig, std_neig, cy, cx, \\n min_thr, max_thr, rand_arr, stddev, half_res_y=False): \\n \\n if True:#no_numba: \\n def _correct_ann_outliers(obj_tmp, ann_width, sig, med_neig, std_neig, \\n cy, cx, min_thr, max_thr, rand_arr, stddev, \\n half_res_y=False): \\n n_y, n_x = obj_tmp.shape\\n rand_arr = 2*(np.random.rand(n_y, n_x)-0.5)\\n obj_tmp_corr = obj_tmp.copy()\\n bpix_map = np.zeros([n_y,n_x])\\n for yy in range(n_y):\\n for xx in range(n_x):\\n if half_res_y:\\n rad = np.sqrt((2*(cy-yy))**2+(cx-xx)**2)\\n else:\\n rad = np.sqrt((cy-yy)**2+(cx-xx)**2)\\n rr = int(rad/ann_width)\\n dev = max(stddev,min(std_neig[rr],med_neig[rr]))\\n \\n # check min_thr\\n if obj_tmp[yy,xx] < min_thr:\\n bpix_map[yy,xx] = 1\\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\\\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\\n \\n # check max_thr\\n elif obj_tmp[yy,xx] > max_thr:\\n bpix_map[yy,xx] = 1\\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\\\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\\n \\n elif (obj_tmp[yy,xx] < med_neig[rr]-sig*dev or \\n obj_tmp[yy,xx] > med_neig[rr]+sig*dev):\\n bpix_map[yy,xx] = 1\\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\\\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\\n return obj_tmp_corr, bpix_map\\n else:\\n @njit \\n def _correct_ann_outliers(obj_tmp, ann_width, sig, med_neig, std_neig, \\n cy, cx, min_thr, max_thr, rand_arr, stddev, \\n half_res_y=False): \\n n_y, n_x = obj_tmp.shape\\n rand_arr = 2*(np.random.rand(n_y, n_x)-0.5)\\n obj_tmp_corr = obj_tmp.copy()\\n bpix_map = np.zeros([n_y,n_x])\\n for yy in range(n_y):\\n for xx in range(n_x):\\n if half_res_y:\\n rad = np.sqrt((2*(cy-yy))**2+(cx-xx)**2)\\n else:\\n rad = np.sqrt((cy-yy)**2+(cx-xx)**2)\\n rr = int(rad/ann_width)\\n dev = max(stddev,min(std_neig[rr],med_neig[rr]))\\n \\n # check min_thr\\n if obj_tmp[yy,xx] < min_thr:\\n bpix_map[yy,xx] = 1\\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\\\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\\n \\n # check max_thr\\n elif obj_tmp[yy,xx] > max_thr:\\n bpix_map[yy,xx] = 1\\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\\\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\\n \\n elif (obj_tmp[yy,xx] < med_neig[rr]-sig*dev or \\n obj_tmp[yy,xx] > med_neig[rr]+sig*dev):\\n bpix_map[yy,xx] = 1\\n obj_tmp_corr[yy,xx] = med_neig[rr] + \\\\\\n np.sqrt(np.abs(med_neig[rr]))*rand_arr[yy,xx]\\n return obj_tmp_corr, bpix_map\\n \\n return _correct_ann_outliers(obj_tmp, ann_width, sig, med_neig, std_neig, \\n cy, cx, min_thr, max_thr, rand_arr, stddev, \\n half_res_y=False)\",\n \"def test_avalanche_warning_by_region_obs(self):\\n pass\",\n \"def eqf_binning(t, n_bins):\\n t_bins= []\\n t= sorted(t)\\n n_items= int(len(t)/n_bins)\\n\\n for i in range(1, n_bins):\\n t_bins.append(t[int(i*n_items)])\\n t_bins.append(np.max(t) + 0.01)\\n t_binning= np.digitize(t, t_bins)\\n return t_binning\",\n \"def othersn(ax):\",\n \"def get_individual_manipulated_feature_centered(record,sensor,bins=100):\\r\\n \\r\\n #accesses the record's motion sensor\\r\\n ana=Analysis()\\r\\n ana.processRecord(record) \\r\\n motion=MotionProfileV2.extract(record)\\r\\n m = motion.vpsInDistance.toArray(sensor)\\r\\n \\r\\n #initializes variables\\r\\n my_range = np.linspace(-1,25,bins)\\r\\n d = np.zeros((len(my_range),1))\\r\\n prev=0\\r\\n index=0\\r\\n \\r\\n #iterates through the linspace vector\\r\\n for i in range(0,len(my_range)): \\r\\n cp=np.zeros((len(m),2))\\r\\n count=0\\r\\n \\r\\n #makes a copy of the values that fall within the given bin\\r\\n for j in range(0,len(m)):\\r\\n if m[j][0]+ ((25-record.motion.vehicleLength)/2-m[0][0]) >= my_range[i] and m[j][0]+ ((25-record.motion.vehicleLength)/2-m[0][0]) <= my_range[i+1]:\\r\\n cp[count][0]=m[j][0] + ((25-record.motion.vehicleLength)/2-m[0][0])\\r\\n cp[count][1]=m[j][1]\\r\\n count+=1\\r\\n\\r\\n #if there ARE changes within the bin (sensor switches from 0 or 1)\\r\\n if cp[0][0] != 0:\\r\\n \\r\\n #if there is ONLY ONE switch within the bin\\r\\n if cp[1][0] == 0:\\r\\n \\r\\n #if the sensor switches from 1 to 0\\r\\n if prev == 1:\\r\\n #finds the area\\r\\n d[index] = 1 - ((my_range[i+1] - cp[0][0])/(my_range[i+1]-my_range[i]))\\r\\n #increments the index and updates 'prev' accordingly\\r\\n index+=1\\r\\n prev=cp[0][1]\\r\\n \\r\\n #if the sensor switches from 0 to 1 \\r\\n else:\\r\\n #finds the are\\r\\n d[index] = ((my_range[i+1] - cp[0][0])/(my_range[i+1]-my_range[i]))\\r\\n #increments the index and updates 'prev' accordingly\\r\\n index+=1\\r\\n prev=cp[0][1]\\r\\n \\r\\n #if there are MORE than one switch within the bin \\r\\n else:\\r\\n value=0 \\r\\n #if the sensor switches from 1 to 0 then back any number of times\\r\\n if cp[0][1] == 1:\\r\\n #iterates through the copied matrix\\r\\n for j in range(0,len(cp),2):\\r\\n \\r\\n #finds the cumulative area\\r\\n if j+1<len(cp):\\r\\n if cp[j+1][0] == 0 and cp[j][0] != 0:\\r\\n value += my_range[i+1]-cp[j][0]\\r\\n prev=cp[j][1]\\r\\n else:\\r\\n value += cp[j+1][0] - cp[j][0]\\r\\n \\r\\n #adds the total area within the bin to the vector \\r\\n d[index] = value/(my_range[i+1]-my_range[i])\\r\\n index+=1\\r\\n \\r\\n #if the sensor switches from 0 to 1 then back any number of times \\r\\n else: \\r\\n #iterates through the copied matrix\\r\\n for j in range(0,len(cp),2):\\r\\n \\r\\n #finds the cumulative area\\r\\n if j+1<len(cp):\\r\\n if j == 0:\\r\\n value += cp[j][0] - my_range[i]\\r\\n prev=cp[j][1]\\r\\n elif cp[j][0] == 0 and cp[j-1][0] != 0:\\r\\n value += my_range[i+1]-cp[j-1][0]\\r\\n prev=cp[j-1][1]\\r\\n else:\\r\\n value += cp[j][0] - cp[j-1][0]\\r\\n \\r\\n #adds the total area within the bin to the vector \\r\\n d[index] = value/(my_range[i+1]-my_range[i])\\r\\n index+=1\\r\\n \\r\\n #if there ARE NOT changes within the bin (sensor stays either 0 or 1)\\r\\n elif cp[0][0] == 0:\\r\\n \\r\\n #changes the 'prev' variable accordingly and increments the index \\r\\n if prev == 0:\\r\\n d[index] = 0\\r\\n index+=1\\r\\n elif prev == 1:\\r\\n d[index] = 1\\r\\n index+=1\\r\\n \\r\\n #returns the individual sensor feature vector\\r\\n return(d)\",\n \"def test_histogram_with_varying_number_of_bin(self):\\n # this data use number of bins less than the max limit\\n df1 = pd.Series([1, 2, 3, 4]).apply(str)\\n profiler1 = FloatColumn(df1.name)\\n profiler1.max_histogram_bin = 50\\n profiler1.update(df1)\\n num_bins = len(profiler1.profile['histogram']['bin_counts'])\\n self.assertEqual(num_bins, 4)\\n\\n # this data uses large number of bins, which will be set to\\n # the max limit\\n df2 = pd.Series([3.195103249264023e+18, 9999995.0, 9999999.0,\\n 0.0, -10 ** 10]).apply(str)\\n profiler2 = FloatColumn(df2.name)\\n profiler2.max_histogram_bin = 50\\n profiler2.update(df2)\\n num_bins = len(profiler2.profile['histogram']['bin_counts'])\\n self.assertEqual(num_bins, 50)\\n\\n # max number of bin is increased to 10000\\n profiler2 = FloatColumn(df2.name)\\n profiler2.max_histogram_bin = 10000\\n profiler2.update(df2)\\n num_bins = len(profiler2.profile['histogram']['bin_counts'])\\n self.assertEqual(num_bins, 10000)\",\n \"def check_binning(comparefn):\\n @wraps(comparefn)\\n def wrapper(*args, **kwargs):\\n # args[0] is self, since comparefn is member of a class\\n if args[2].GetNbinsX() == args[1].GetNbinsX():\\n return comparefn(*args, **kwargs)\\n # FIXME: this check is incomplete, bin boundaries can also\\n # be different: see TH1::CheckConsistency() (cannot use\\n # this though, protected member)\\n else:\\n warning('Histograms with different number of bins.')\\n # raise ValueError('Histograms with unequal number of bins')\\n return ComparisonFunction.create_error_dict()\\n return wrapper\",\n \"def aggregate_behavior(Z):\\n nsamp, nsen = Z.shape\\n median_trace = np.median(Z, axis=1)\\n dev = np.std(Z - np.repeat(np.matrix(median_trace).transpose(),\\n nsen, axis=1), axis=1)\\n cmpr_high_variability = [(Z[:, sen_i] > median_trace + 2 * dev\\n ).sum()/nsamp > 0.5 for sen_i in range(nsen)]\\n return nsamp, nsen, cmpr_high_variability, median_trace, dev\",\n \"def _allowed_bands():\\n pass\",\n \"def get_mean_accuracy(all_means, nbins=10):\\n ## Add a columns of bin assignments\\n # bins = np.linspace(0, all_means['posterior'].max(), nbins)\\n bins = np.linspace(0, 1, nbins)\\n all_means['bin'] = np.digitize(all_means['posterior'], bins)\\n\\n ## Add upper bound to right-most bin\\n all_means.replace(to_replace={'bin':{nbins: nbins-1}}, inplace=True)\\n\\n ## Bin ancestors by mean bootstrapped probability, adding columns for\\n ## whether they were the true generating ancestor, and the number of\\n ## ancestors in each bin\\n bin_count = lambda x: len(x)\\n binned = all_means[['generator', 'bin']].pivot_table(index='bin',\\n aggfunc=[np.mean, bin_count], fill_value=0)\\n binned.columns = [['observed_prob', 'bin_count']]\\n binned['n_successes'] = binned['observed_prob'].values * \\\\\\n binned['bin_count'].values\\n\\n ## Estimate means and confidence intervals as sampling from a binomial\\n ## distribution, with a uniform prior on success rates - Done using\\n ## a beta distribution\\n binned['alpha'] = binned['n_successes'] + 1\\n binned['beta'] = binned['bin_count'].values - binned['n_successes'].values + 1\\n beta_mean = lambda row: beta.mean(float(row['alpha']), float(row['beta']))\\n binned['posterior_mean'] = binned.apply(beta_mean, axis=1)\\n\\n ## Add confidence intercals\\n beta_025CI = lambda row: beta.ppf(0.025, float(row['alpha']), float(row['beta']))\\n beta_975CI = lambda row: beta.ppf(0.975, float(row['alpha']), float(row['beta']))\\n binned['CI2.5'] = binned.apply(beta_025CI, axis=1)\\n binned['CI97.5'] = binned.apply(beta_975CI, axis=1)\\n\\n ## Convert to values relative to mean, to fit plotting convention\\n binned['CI2.5'] = binned['posterior_mean'].values - binned['CI2.5'].values\\n binned['CI97.5'] = binned['CI97.5'].values - binned['posterior_mean'].values\\n\\n ## Add column with bin centre for plotting\\n binned['bin_centre'] = all_means[['posterior', 'bin']].groupby('bin').mean()\\n\\n return binned\",\n \"def plot_completeness(cat_name,output_name,name_plot,mag_lims,binning_mag,plot,second_cat='no'):\\n\\n cat=ascii.read('%s.txt' % cat_name)\\n mag_bins=np.arange(mag_lims[0],mag_lims[1],binning_mag)\\n\\n mask=cat['detected']==1\\n mag_binned_tot=np.digitize(cat['MAG'],mag_bins,right=True)\\n mag_binned_det=np.digitize(cat[mask]['MAG'],mag_bins,right=True)\\n\\n nb_mag=np.array([ len(np.where(mag_binned_tot==i)[0]) for i in range(1,len(mag_bins)) ])\\n nb_mag_det = np.array([ len(np.where(mag_binned_det==i)[0]) for i in range(1,len(mag_bins)) ])\\n #mag_tot= np.array([stuff_cat['MAG'][mag_binned_tot == i].mean() for i in range(1, len(mag_bins))])\\n #mag_det= np.array([stuff_cat[mask]['MAG'][mag_binned_det == i].mean() for i in range(1, len(mag_bins))])\\n print (nb_mag)\\n print (nb_mag_det)\\n\\n #Write completeness result in text file\\n np.savetxt('%s.txt' % output_name, list(zip(mag_bins,nb_mag,nb_mag_det)),fmt='%.2f %d %d')\\n\\n\\n mag_bin_plot=(mag_bins[:-1]+mag_bins[1:])/2\\n\\n import matplotlib.pyplot as plt\\n\\n # the histogram of the input sources\\n n, bins, patches = plt.hist(cat['MAG'], mag_bins, normed=0, facecolor='green', alpha=0.75)\\n plt.xlabel('Magnitude')\\n plt.ylabel('Nb of sources')\\n plt.xlim([mag_bins[0],mag_bins[-1]])\\n plt.savefig('results/plots/hist_sources.png')\\n #plt.show()\\n\\n plt.clf()\\n plt.plot(mag_bin_plot,nb_mag_det/nb_mag)\\n plt.xlabel('Magnitude AB')\\n plt.ylabel('Efficiency')\\n plt.grid(True)\\n plt.savefig('%s.png' % output_name)\\n if plot: plt.show()\\n\\n\\n if second_cat != 'no':\\n cat2=ascii.read('%s.txt' % second_cat)\\n mag_bins2=np.arange(mag_lims[0],mag_lims[1],binning_mag)\\n\\n mask2=cat2['detected']==1\\n mag_binned_tot2=np.digitize(cat2['MAG'],mag_bins2,right=True)\\n mag_binned_det2=np.digitize(cat2[mask2]['MAG'],mag_bins2,right=True)\\n\\n nb_mag2=np.array([ len(np.where(mag_binned_tot2==i)[0]) for i in range(1,len(mag_bins2)) ])\\n nb_mag_det2 = np.array([ len(np.where(mag_binned_det2==i)[0]) for i in range(1,len(mag_bins2)) ])\\n\\n mag_bin_plot2=(mag_bins2[:-1]+mag_bins2[1:])/2\\n #print (mag_bin_plot)\\n #plt.plot(mag_bin_plot,nb_mag_det/nb_mag,label='seeing=0.7\\\"',color='red')\\n #plt.plot(mag_bin_plot2,nb_mag_det2/nb_mag2,label='seeing=0.1\\\"',color='green')\\n plt.plot(mag_bin_plot,nb_mag_det/nb_mag,label='5.9',color='red')\\n plt.plot(mag_bin_plot2,nb_mag_det2/nb_mag2,label='5',color='green')\\n plt.xlabel('Magnitude AB')\\n plt.ylabel('Efficiency')\\n #plt.yscale('log')\\n #plt.xscale('log')\\n plt.grid(True)\\n plt.legend()\\n plt.savefig('results/plots/completeness_comp.png')\\n if plot: plt.show()\",\n \"def binning(S, bands):\\n B = np.zeros((S.shape[0], len(bands)), dtype=S.dtype)\\n for i, b in enumerate(bands):\\n B[:, i] = np.mean(S[:, b[0] : b[1]], axis=1)\\n\\n return B\",\n \"def __init__(self,ptbins,etabins,data=None):\\n self._ptbins = ptbins\\n self._etabins = etabins\\n if data is not None:\\n self._data = data\\n else:\\n self._data = [ [ (0,0) for i in range(len(self._etabins)+1) ] for i in range(len(self._ptbins)+1) ]\\n self.__check()\",\n \"def test_am_threshold(Simulator, plt, seed, rng):\\n d = 64\\n vocab = Vocabulary(d, pointer_gen=rng)\\n vocab.populate('A; B; C; D')\\n\\n d2 = int(d / 2)\\n vocab2 = Vocabulary(d2, pointer_gen=rng)\\n vocab2.populate('A; B; C; D')\\n\\n def input_func(t):\\n return '0.49 * A' if t < 0.1 else '0.8 * B'\\n\\n with spa.Network('model', seed=seed) as m:\\n m.am = ThresholdingAssocMem(\\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\\n function=filtered_step_fn, mapping='by-key')\\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\\n m.stimulus >> m.am\\n\\n in_p = nengo.Probe(m.am.input)\\n out_p = nengo.Probe(m.am.output, synapse=0.03)\\n\\n with Simulator(m) as sim:\\n sim.run(0.3)\\n t = sim.trange()\\n below_th = t < 0.1\\n above_th = t > 0.25\\n\\n plt.subplot(2, 1, 1)\\n plt.plot(t, similarity(sim.data[in_p], vocab))\\n plt.ylabel(\\\"Input\\\")\\n plt.subplot(2, 1, 2)\\n plt.plot(t, similarity(sim.data[out_p], vocab2))\\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\\n plt.ylabel(\\\"Output\\\")\\n\\n assert np.mean(sim.data[out_p][below_th]) < 0.01\\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)\",\n \"def rebin (self, bins, tol=1e-4):\\n\\n bins = np.copy (np.sort (bins))\\n for (i, b) in enumerate (bins):\\n misses = np.abs (b - self.bins)\\n j = np.argmin (misses)\\n closest = np.min (misses)\\n if closest > tol:\\n raise ValueError (\\n '{0} is not among current bin edges'.format (b))\\n bins[i] = self.bins[j]\\n if bins[0] != self.bins[0]:\\n raise ValueError (\\n 'binning startpoint should match ({0} vs {1})'.format (\\n bins[0], self.bins[0]))\\n if bins[-1] != self.bins[-1]:\\n raise ValueError (\\n 'binning endpoint should match ({0} vs {1})'.format (\\n bins[-1], self.bins[-1]))\\n\\n n_newbins = len (bins) - 1\\n newbin_indices = np.digitize (self.bins, bins)[:-1] - 1\\n values = np.array ([\\n np.sum (self.values[newbin_indices == i])\\n for i in range (n_newbins)\\n ])\\n if self.errors is not None:\\n errors = np.array ([\\n np.sqrt (np.sum (self.errors[newbin_indices == i]**2))\\n for i in range (n_newbins)\\n ])\\n else:\\n errors = None\\n return Hist (bins, values, errors)\",\n \"def anoise(this, *args, **kargs):\\n\\t\\t\\n\\t\\t# Arguments\\n\\t\\tif not args: args = [50]\\n\\t\\t\\n\\t\\t# Kernel's retrieval\\n\\t\\tanoisek = this._ANOISEK\\n\\t\\tif anoisek is None: return None\\n\\t\\t\\n\\t\\t# More magic\\n\\t\\tbin = this._BINARY\\n\\t\\tfor thresh in args:\\n\\t\\t\\tbin[:,:] = (cv2.filter2D(bin, -1, anoisek) / 2.55 > thresh) * 255\\n\\t\\treturn True\",\n \"def test_WIMP_cut_region_on_true_data(bolo_name, mass, analysis):\\n\\t\\n\\n\\t#Load 2D PDF\\n\\tfWIMP2D, f = PyRPl.open_ROOT_object(\\\"./ROOT_files/WIMP_PDF2D_\\\" + analysis + \\\".root\\\", \\\"WIMP_\\\" + mass + \\\"_GeV\\\")\\n\\n\\t#Load cut value on PDF for 95% WIMP box\\n\\tcut_val_90, cut_val_99 = 0,0\\n\\twith open (\\\"./Text_files/WIMP_PDF_90_and_99_cut_value_\\\" + analysis + \\\".txt\\\", \\\"r\\\") as fcut:\\n\\t\\tstuff = [elem.rstrip().split(\\\",\\\") for elem in fcut.readlines()]\\n\\t\\tfor elem in stuff:\\n\\t\\t\\tmass_val = elem[0]\\n\\t\\t\\tif int(mass)==int(mass_val):\\n\\t\\t\\t\\tcut_val_90 = float(elem[1])\\n\\t\\t\\t\\tcut_val_99 = float(elem[2])\\n\\t\\n\\n\\tdata_path = \\\"/home/irfulx204/mnt/tmain/Desktop/Run308_Analyse_ERA/Fond_ERA_merged/\\\"\\n\\tfilou = TFile(data_path + bolo_name + \\\"_\\\" + analysis + \\\"_fond.root\\\", \\\"read\\\")\\n\\ttree = filou.Get(\\\"data\\\")\\n\\tnum_pass_cut =0\\n\\n\\thpass = TH2F(\\\"hpass\\\", \\\"hpass\\\", 100, 0, 15, 100, 0, 15)\\n\\n\\t# #T Check that the events are found where expected\\n\\t# arr1 = np.random.uniform(0,15,size=(200000,2))\\n\\t# for i in range(arr1.shape[0]):\\n\\t# \\tPDF_val = fWIMP2D.Eval(arr1[i][0], arr1[i][1])\\n\\t# \\tif (cut_val_99<PDF_val<cut_val_90):\\n\\t# \\t# if (cut_val_99<PDF_val<cut_val_90):\\n\\t# \\t\\tnum_pass_cut+=1\\n\\t# \\t\\thpass.Fill(arr1[i][0], arr1[i][1])\\t\\t\\n\\n\\t# hpass.Draw()\\n\\t# raw_input()\\n\\n\\tfor k in range(tree.GetEntries()):\\n\\t\\ttree.GetEntry(k)\\n\\t\\tER=(1+8./3)*0.5*(tree.EC1+tree.EC2)-0.33*(1.5*tree.EIA+4*tree.EIB+1.5*tree.EIC+4*tree.EID)\\n\\t\\tPDF_val = fWIMP2D.Eval(ER, 0.5*(tree.EIB+tree.EID))\\n\\t\\tif (cut_val_99<PDF_val<cut_val_90 and 0.5*(tree.EIB+tree.EID)>0.7):\\n\\t\\t# if (cut_val_99<PDF_val<cut_val_90):\\n\\t\\t\\tnum_pass_cut+=1\\n\\t\\t\\thpass.Fill(0.5*(tree.EC1+tree.EC2), 0.5*(tree.EIB+tree.EID))\\n\\n\\tprint num_pass_cut\\n\\thpass.Draw()\\n\\traw_input()\",\n \"def check(self):\\n self.lower_bound(5e-4)\\n self.upper_bound(5e2)\",\n \"def permutation_test(overlap_bins, nonoverlap_bins, thresh, ntrials):\\n X = num_top_snps(I(overlap_bins.values()), thresh)\\n if X == 0:\\n return thresh, 0, 0, 0, 1, 0, 0\\n overlap_counts = {k: len(overlap_bins[k]) for k in overlap_bins}\\n Y = [num_top_snps(match(overlap_counts, nonoverlap_bins), thresh) for _ in range(ntrials)]\\n mean, variance = moments(Y)\\n anderson, critical_values, _ = scipy.stats.anderson(Y)\\n exact_p = (1 + len([y for y in Y if y >= X])) / (1 + ntrials)\\n return thresh, X, mean, variance, exact_p, anderson, critical_values[2]\",\n \"def potential_energy_bins(xy, BL, bins, bo=1.0, kL=1.0):\\n bL = bond_length_list(xy, BL)\\n pe = 0.5 * kL * (bL - bo) ** 2\\n # for each bin bins[kk], find incidices i of bL for which BL[i] is connected to at least one particle in bins[kk].\\n pe_bins = np.zeros(len(bins), dtype=float)\\n kk = 0\\n for bin in bins:\\n mask = np.logical_or(np.in1d(BL[:, 0], bin), np.in1d(BL[:, 1], bin))\\n pe_bins[kk] = np.sum(pe[mask])\\n kk += 1\\n return pe_bins\",\n \"def binned_AUC(func_predict, X, y, X_kin, VARS_kin, pt_edges, eta_edges, label):\\n\\n AUC = np.zeros((len(pt_edges)-1, len(eta_edges)-1))\\n\\n\\n # ** Compute predictions **\\n if type(X) is list: # Evaluate one by one\\n y_pred = np.zeros(len(X))\\n for k in range(len(y_pred)):\\n y_pred[k] = func_predict(X[k])\\n else:\\n y_pred = func_predict(X)\\n\\n\\n # Loop over bins\\n for i in range(len(pt_edges) - 1):\\n for j in range(len(eta_edges) - 1):\\n\\n pt_range = [ pt_edges[i], pt_edges[i+1]]\\n eta_range = [eta_edges[j], eta_edges[j+1]]\\n\\n # Indices\\n ind = np.logical_and(aux.pick_ind(X_kin[:, VARS_kin.index('trk_pt')], pt_range),\\n aux.pick_ind(X_kin[:, VARS_kin.index('trk_eta')], eta_range))\\n\\n print(f'\\\\nEvaluate classifier <{label}> ...')\\n print(f'*** pT = [{pt_range[0]:.3f},{pt_range[1]:.3f}], eta = [{eta_range[0]:.3f},{eta_range[1]:.3f}] ***')\\n \\n if np.sum(ind) > 0: # Do we have any events in this cell\\n\\n # Evaluate metric\\n met = aux.Metric(y_true = y[ind], y_soft = y_pred[ind])\\n print('AUC = {:.5f}'.format(met.auc))\\n AUC[i,j] = met.auc\\n\\n else:\\n print('No events found in this (eta,pt) cell!')\\n \\n # Evaluate total performance\\n met = aux.Metric(y_true = y, y_soft = y_pred)\\n fig,ax = plot_auc_matrix(AUC, pt_edges, eta_edges)\\n ax.set_title('{}: Integrated AUC = {:.3f}'.format(label, met.auc))\\n\\n return fig,ax,met\",\n \"def contact_probability(summary, results, contacts, bins, feature):\\r\\n\\r\\n # prepare sampling interval size\\r\\n bin_width = bins[2]\\r\\n n_bins = int(np.ceil(bins[1]/bin_width))\\r\\n # bin bounds\\r\\n end_bins = np.arange(bin_width,bin_width*(n_bins+1), bin_width)\\r\\n # prepare arrays\\r\\n # two counts will be made, for each assumption. r (contact radius), t (contact time)\\r\\n activated_counts_r = np.zeros(n_bins, dtype=int)\\r\\n activated_counts_t = np.zeros(n_bins, dtype=int)\\r\\n total_counts_r = np.zeros(n_bins, dtype=int)\\r\\n total_counts_t = np.zeros(n_bins, dtype=int)\\r\\n n_cells = len(summary.cell_ID)\\r\\n\\r\\n for i, cell in summary.iterrows():\\r\\n if cell.QC == 'good':\\r\\n trig_contacts = contacts.loc[(contacts.cell_ID == cell.cell_ID) & (contacts['time_to_Ca [s]'] == 0) & (contacts['contact'] == 'CCZ'), :]\\r\\n if len(trig_contacts) > 0:\\r\\n max_r_ = np.max(trig_contacts['radius [um]'].values)\\r\\n max_r = np.max(trig_contacts.loc[trig_contacts['radius [um]'] == max_r_, feature])\\r\\n max_t_ = np.max(trig_contacts['contact_time [s]'].values)\\r\\n max_t = np.max(trig_contacts.loc[trig_contacts['contact_time [s]'] == max_t_, feature])\\r\\n else:\\r\\n max_r = 0\\r\\n max_t = 0\\r\\n if feature == 'radius [um]':\\r\\n max_r = max_r*1000\\r\\n max_t = max_t*1000\\r\\n activated_counts_r += end_bins >= max_r\\r\\n activated_counts_t += end_bins >= max_t\\r\\n total_counts_r += 1\\r\\n total_counts_t += 1\\r\\n\\r\\n elif cell.QC == 'good_noCa':\\r\\n last_frame = np.amax(results.loc[results.cell_ID == cell.cell_ID, 'frame'])\\r\\n last_contacts = contacts.loc[(contacts.cell_ID == cell.cell_ID) & (contacts['frame'] == last_frame) & (contacts['contact'] == 'CCZ'), :]\\r\\n max_r_ = np.max(last_contacts['radius [um]'].values)\\r\\n max_r = np.max(last_contacts.loc[last_contacts['radius [um]'] == max_r_, feature])\\r\\n max_t_ = np.max(last_contacts['contact_time [s]'].values)\\r\\n max_t = np.max(last_contacts.loc[last_contacts['contact_time [s]'] == max_t_, feature])\\r\\n if feature == 'radius [um]':\\r\\n max_r = max_r*1000\\r\\n max_t = max_t*1000\\r\\n total_counts_r += end_bins-bin_width < max_r\\r\\n total_counts_t += end_bins-bin_width < max_t \\r\\n\\r\\n return end_bins, activated_counts_r, activated_counts_t, total_counts_r, total_counts_t\",\n \"def bin_binarise(self):\\n pass\",\n \"def correlation_bins(shred):\\n return 0\",\n \"def SetPRBinCatConstraint( self, model ) :\\n tot = np.dot( self.wish.T, self.dispo )\\n for val in tot :\\n if not val : continue\\n if self.bound>0 : model += val <= self.valBound\\n elif self.bound<0 : model += val >= self.valBound\",\n \"def uniform_binning(ts, bins):\\n symb = np.asarray(bins * (ts - ts.min()) / (ts.max() - ts.min() + 1e-12), dtype=int)\\n return symb\",\n \"def eqw_binning(t, n_bins):\\n \\n t_diff= (np.max(t) - np.min(t))/n_bins\\n t_bins= np.hstack([np.array([np.min(t) + t_diff*i for i in range(1, n_bins)]), [np.max(t) + 0.01]])\\n t_binning= np.digitize(t, t_bins)\\n return t_binning\",\n \"def get_selected_bin_low_median(self, hist, bin_edges, assigned_digits, original_values):\\n PRINT_OUTPUT = False\\n\\n bin_max_index = np.where(hist == hist.max())\\n refactored_index = bin_max_index[0].max()\\n\\n # special case: refactor maximum index, when there are multiple equal maximum values in histogram\\n max_histo_value = hist[refactored_index]\\n all_max_indices = []\\n\\n for hist_index, hist_value in enumerate(hist):\\n if hist_value == max_histo_value:\\n all_max_indices.append(hist_index)\\n\\n\\n # adapt the index for special case, take the middle value in the distribution\\n\\n # my_custom_median_index = np.where(all_max_indices == np.median(all_max_indices))\\n\\n new_refactored_index = int(stats.median_low(all_max_indices))\\n\\n # additional condition for setting breakpoint\\n if refactored_index != new_refactored_index:\\n refactored_index = new_refactored_index\\n\\n values_in_this_bin = []\\n for index_ad, ad in enumerate(assigned_digits):\\n ad -= 1\\n if ad == refactored_index:\\n values_in_this_bin.append(original_values[index_ad])\\n\\n\\n mean_val = np.mean(values_in_this_bin)\\n final_mean = int(np.round(mean_val))\\n return final_mean\\n\\n # detected_edges = bin_edges[bin_max_index]\\n # detected_edge = detected_edges[0]\\n\\n # if PRINT_OUTPUT is True:\\n # print('maxbin', detected_edge)\\n\\n # return detected_edge\",\n \"def _analyze_series(self, series):\\n # bin series by analysis time\\n # only analyze the last bin\\n ts = array([si['timestamp'] for si in series])\\n ds = diff(ts)\\n\\n # tolerance_seconds = 60 * 60 * self._bin_hours\\n # ds = diff(ts) > tolerance_seconds\\n # bounds = where(ds)[0]\\n # itemidx = bounds[-1] if bounds else 0\\n # series = series[itemidx:]\\n\\n for ci in self._conditionals:\\n ret = self._execute_conditional(ci, series, ds)\\n if ret:\\n return ret\",\n \"def astats(npa, do_bits=True):\\n mean = float(np.mean(npa))\\n std = float(np.std(npa))\\n amax = float(np.amax(npa))\\n amin = float(np.amin(npa))\\n quant1_3 = np.quantile(npa, [0.25, 0.75])\\n iqr = quant1_3[1] - quant1_3[0]\\n weak_min = (npa < quant1_3[0] - 1.5 * iqr)\\n weak_max = (npa > quant1_3[1] + 1.5 * iqr)\\n strong_min = (npa < quant1_3[0] - 3 * iqr)\\n strong_max = (npa > quant1_3[1] + 3 * iqr)\\n weak_count = int((weak_min | weak_max).sum())\\n strong_count = int((strong_min|strong_max).sum())\\n if weak_count:\\n min_out = float(np.min(np.abs(npa[weak_min|weak_max])))\\n if strong_count:\\n max_out = float(np.max(np.abs(npa[strong_min|strong_max])))\\n else:\\n max_out = float(np.max(np.abs(npa[weak_min|weak_max])))\\n else:\\n min_out = max_out = 0\\n\\n ret = {\\n 'mean': mean,\\n 'std': std,\\n 'min': amin,\\n 'max': amax,\\n 'size': npa.size,\\n 'wols': weak_count,\\n 'sols': strong_count,\\n 'min_out' : min_out,\\n 'max_out' : max_out,\\n }\\n if do_bits:\\n ret['ibits'] = bits(amax, amin)\\n return ret\",\n \"def ahistogram (inarray,numbins=10,defaultlimits=None,printextras=1):\\r\\n inarray = N.ravel(inarray) # flatten any >1D arrays\\r\\n if (defaultlimits <> None):\\r\\n lowerreallimit = defaultlimits[0]\\r\\n upperreallimit = defaultlimits[1]\\r\\n binsize = (upperreallimit-lowerreallimit) / float(numbins)\\r\\n else:\\r\\n Min = N.minimum.reduce(inarray)\\r\\n Max = N.maximum.reduce(inarray)\\r\\n estbinwidth = float(Max - Min)/float(numbins) + 1e-6\\r\\n binsize = (Max-Min+estbinwidth)/float(numbins)\\r\\n lowerreallimit = Min - binsize/2.0 #lower real limit,1st bin\\r\\n bins = N.zeros(numbins)\\r\\n extrapoints = 0\\r\\n for num in inarray:\\r\\n try:\\r\\n if (num-lowerreallimit) < 0:\\r\\n extrapoints = extrapoints + 1\\r\\n else:\\r\\n bintoincrement = int((num-lowerreallimit) / float(binsize))\\r\\n bins[bintoincrement] = bins[bintoincrement] + 1\\r\\n except: # point outside lower/upper limits\\r\\n extrapoints = extrapoints + 1\\r\\n if (extrapoints > 0 and printextras == 1):\\r\\n print '\\\\nPoints outside given histogram range =',extrapoints\\r\\n return (bins, lowerreallimit, binsize, extrapoints)\",\n \"def plot_bin_means(X,Y,bin_edges=None,mean='median',error='sem',color=None,\\n style='errorbar',minimum_n=25,bin_style='equal'):\\n \\n assert(X.shape == Y.shape)\\n \\n X,Y = nonan_pairs(X,Y)\\n \\n # Flatten if not vectors\\n if X.ndim > 1:\\n X = X.flatten()\\n Y = Y.flatten()\\n \\n if type(bin_edges) == int:\\n if bin_style == 'equal':\\n X_min = X.min()\\n X_max = X.max() \\n bin_edges = np.linspace(X_min,X_max,num=bin_edges)\\n elif bin_style == 'percentile':\\n bin_edges = np.percentile(nonans(X),np.linspace(0,100,num=bin_edges))\\n print(bin_edges)\\n else:\\n raise ValueError\\n \\n which_bin = np.digitize(X,bin_edges)\\n Nbins = len(bin_edges)-1\\n means = np.zeros(Nbins)\\n stds = np.zeros(Nbins)\\n \\n \\n # bin_centers = np.zeros(Nbins)\\n \\n bin_centers = (bin_edges[:-1] + bin_edges[1:])/2\\n \\n for b in range(Nbins):\\n y = Y[which_bin == b+1]\\n # bin_centers[b] = (bin_edges[b] + bin_edges[b+1]) / 2\\n # Suppress noisy bins\\n if len(y) < minimum_n:\\n means[b] = np.nan\\n stds[b] = np.nan\\n else:\\n # Mean or median\\n if mean == 'mean':\\n means[b] = np.nanmean(y)\\n elif mean == 'median':\\n print(f'{y.shape}')\\n means[b] = np.nanmedian(y)\\n \\n if error == 'sem':\\n stds[b] = np.nanstd(y) / np.sqrt(len(y))\\n elif error == 'std':\\n stds[b] = y.std()\\n\\n # Plot\\n if style == 'errorbar':\\n plt.errorbar(bin_centers,means,stds,color=color)\\n elif style == 'fill':\\n plt.plot(bin_centers, means, color=color)\\n plt.fill_between(bin_centers, means-stds, means+stds,\\n color=color,alpha=0.5)\\n \\n return means\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67321396","0.6631882","0.612074","0.60527307","0.5962843","0.5934379","0.5913258","0.5909307","0.57914376","0.5731966","0.5723782","0.5706618","0.56629616","0.5644072","0.5630398","0.562626","0.562407","0.561191","0.5604084","0.55954075","0.5590886","0.5554225","0.55534935","0.5552162","0.55136806","0.5511174","0.5506232","0.545142","0.5450618","0.54437184","0.5439406","0.5431434","0.54301965","0.54184574","0.5406317","0.54031926","0.5395762","0.5393106","0.538843","0.53681767","0.5346323","0.5346323","0.5346243","0.53274703","0.53243524","0.53147036","0.5313107","0.53098446","0.5309488","0.5308276","0.53024334","0.5300855","0.52987635","0.52970725","0.5296807","0.52911365","0.52909","0.5283605","0.5277589","0.52750313","0.52549684","0.52505416","0.5249979","0.52467877","0.52461255","0.52322","0.523018","0.5223921","0.5220508","0.52138805","0.5212118","0.5211606","0.5207827","0.52061635","0.52025187","0.5200061","0.51975733","0.519718","0.51887125","0.51882815","0.5187752","0.5185588","0.51841825","0.5180243","0.51763","0.51717883","0.51697206","0.5164345","0.5159885","0.5157851","0.51545936","0.51545775","0.51444185","0.51341486","0.5132037","0.5125338","0.5122793","0.511758","0.51148385","0.51115733","0.5106939"],"string":"[\n \"0.67321396\",\n \"0.6631882\",\n \"0.612074\",\n \"0.60527307\",\n \"0.5962843\",\n \"0.5934379\",\n \"0.5913258\",\n \"0.5909307\",\n \"0.57914376\",\n \"0.5731966\",\n \"0.5723782\",\n \"0.5706618\",\n \"0.56629616\",\n \"0.5644072\",\n \"0.5630398\",\n \"0.562626\",\n \"0.562407\",\n \"0.561191\",\n \"0.5604084\",\n \"0.55954075\",\n \"0.5590886\",\n \"0.5554225\",\n \"0.55534935\",\n \"0.5552162\",\n \"0.55136806\",\n \"0.5511174\",\n \"0.5506232\",\n \"0.545142\",\n \"0.5450618\",\n \"0.54437184\",\n \"0.5439406\",\n \"0.5431434\",\n \"0.54301965\",\n \"0.54184574\",\n \"0.5406317\",\n \"0.54031926\",\n \"0.5395762\",\n \"0.5393106\",\n \"0.538843\",\n \"0.53681767\",\n \"0.5346323\",\n \"0.5346323\",\n \"0.5346243\",\n \"0.53274703\",\n \"0.53243524\",\n \"0.53147036\",\n \"0.5313107\",\n \"0.53098446\",\n \"0.5309488\",\n \"0.5308276\",\n \"0.53024334\",\n \"0.5300855\",\n \"0.52987635\",\n \"0.52970725\",\n \"0.5296807\",\n \"0.52911365\",\n \"0.52909\",\n \"0.5283605\",\n \"0.5277589\",\n \"0.52750313\",\n \"0.52549684\",\n \"0.52505416\",\n \"0.5249979\",\n \"0.52467877\",\n \"0.52461255\",\n \"0.52322\",\n \"0.523018\",\n \"0.5223921\",\n \"0.5220508\",\n \"0.52138805\",\n \"0.5212118\",\n \"0.5211606\",\n \"0.5207827\",\n \"0.52061635\",\n \"0.52025187\",\n \"0.5200061\",\n \"0.51975733\",\n \"0.519718\",\n \"0.51887125\",\n \"0.51882815\",\n \"0.5187752\",\n \"0.5185588\",\n \"0.51841825\",\n \"0.5180243\",\n \"0.51763\",\n \"0.51717883\",\n \"0.51697206\",\n \"0.5164345\",\n \"0.5159885\",\n \"0.5157851\",\n \"0.51545936\",\n \"0.51545775\",\n \"0.51444185\",\n \"0.51341486\",\n \"0.5132037\",\n \"0.5125338\",\n \"0.5122793\",\n \"0.511758\",\n \"0.51148385\",\n \"0.51115733\",\n \"0.5106939\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":8993,"cells":{"query":{"kind":"string","value":"This is the base Exception class for all step failures. It can be manually raised from recipe code to cause the build to turn red."},"document":{"kind":"string","value":"def StepFailure(self):\n return recipe_api.StepFailure"},"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 raise_step_error(self, error: Exception, step: str):\n error_message = \"{}\\nFailed: Error={}\".format(step, str(error))\n logging.error(error_message)\n self.slacker.send_thread_reply(error_message)\n raise Exception(error_message)","def raise_on_error(self):\n if not self._status.success:\n cls = UrlApi.InfraHTTPError if self._infra_step else UrlApi.HTTPError\n raise cls('HTTP status (%d)' % (self.status_code,), self)","def test_fails(self):\n raise FoolishError(\"I am a broken test\")","def fail(self, msg=None):\r\n raise self.failureException(msg)","def step(self):\n raise TaskError(\"Task %s: subclass should override step() method!\" %\n self)","def raise_for_failure(self) -> None:\n if not self.is_success():\n raise exc.ExecutionError(self)","def exception(self, *args, **kwargs):\n return super(Blueprint, self).exception(*args, **kwargs)","def abort(self, message: str) -> None:\n message = f\"{Invocation.current.log} - {message}\"\n self.exception = StepException(message)\n global failure_aborts_build # pylint: disable=invalid-name\n global no_actions # pylint: disable=invalid-name\n if failure_aborts_build.value and not no_actions.value:\n no_additional_complaints()\n raise self.exception","def setup_class(cls):\n try:\n super(BuildFailureTests, cls).setup_class()\n except CommandFailure:\n pass\n else:\n raise AssertionError('A failed build returned an exit code of 0.')","def fail(self, msg=None):\n raise Exception, msg","def failed(self):\n\t\tpass","def raise_fail(*args, **kwargs):\n raise Exception(\"oops\")","def test_second_step_strict(self):\n with self.assertRaises(Exception):\n self.run_step('S02-errors.py', allow_failure=False)","def testRunException(self):\n class TestError(Exception):\n \"\"\"Unique test exception\"\"\"\n\n perform_mock = self.PatchObject(generic_stages.BuilderStage, 'PerformStage')\n perform_mock.side_effect = TestError('fail!')\n\n stage = self.ConstructStage()\n results_lib.Results.Clear()\n self.assertRaises(failures_lib.StepFailure, self._RunCapture, stage)\n\n results = results_lib.Results.Get()[0]\n self.assertTrue(isinstance(results.result, TestError))\n self.assertEqual(str(results.result), 'fail!')\n self.mock_cidb.StartBuildStage.assert_called_once_with(\n DEFAULT_BUILD_STAGE_ID)\n self.mock_cidb.FinishBuildStage.assert_called_once_with(\n DEFAULT_BUILD_STAGE_ID,\n constants.BUILDER_STATUS_FAILED)","def failure_callback(self):\n error_filename = self.run_dir / \"eplusout.err\"\n if error_filename.exists():\n with open(error_filename, \"r\") as stderr:\n stderr_r = stderr.read()\n self.exception = EnergyPlusProcessError(\n cmd=self.cmd, stderr=stderr_r, idf=self.idf\n )\n self.cleanup_callback()","def add_failure(self, task: Task, exception: Any) -> None: # noqa: DAR101\n super().add_failure(task, exception)\n self._add_summary(task, _TaskExitCode.FAIL)","def test_badstageerror_raise(self, mock_isdir):\n # Set the mocked functions returned values\n mock_isdir.side_effect = [True]\n\n # Test execution\n wrong_kwargs = copy.copy(self.kwargs)\n wrong_kwargs[\"reconstruction_stage\"] = \"WRONG\"\n self.assertRaises(ValueError, recon_all, **wrong_kwargs)","def fail(msg):\n\n # Not sure if simply raising the exception is clearer.\n raise CommandFailed(msg)","def error(self):\n raise NotImplementedError(\"subclasses need to override this method\")","def InfraFailure(self):\n return recipe_api.InfraFailure","def __init__(self, message=\"\"):\n super(AutomationError, self).__init__(message)","def test_class_errored(self, cls, exception):","def report_unexpected_exception(self, *args, **kwargs):\n pass","def test_runFailed(self):\n builder = BookBuilder()\n exc = self.assertRaises(\n CommandFailed, builder.run,\n [sys.executable, '-c', 'print \"hi\"; raise SystemExit(1)'])\n self.assertEquals(exc.exitStatus, 1)\n self.assertEquals(exc.exitSignal, None)\n self.assertEquals(exc.output, \"hi\\n\")","def failure_exception(cls, state, exception):\r\n return PlatformMessage(method=\"__reply__\", kwargs={\"__result__\": \"fail\", \"state\": state, \"errcode\": -2,\r\n \"e\": exception})","def test_fail(make_runner: Callable[..., TargetFunctionRunner]) -> None:\n runner = make_runner(target_failed, use_instances=True)\n run_info = TrialInfo(config=2, instance=\"test\", seed=0, budget=0.0)\n\n runner.submit_trial(run_info)\n run_info, run_value = next(runner.iter_results())\n\n # Make sure the traceback message is included\n assert \"traceback\" in run_value.additional_info\n assert \"RuntimeError\" in run_value.additional_info[\"traceback\"]","def test_config_step_raises(self):\n\n run_step = self.ConfigStep.create({\n 'name': 'run_step',\n 'job_type': 'run_odoo',\n })\n\n create_step = self.ConfigStep.create({\n 'name': 'test_step',\n 'job_type': 'create_build',\n })\n\n config = self.Config.create({'name': 'test_config'})\n\n # test that the run_odoo step has to be the last one\n with self.assertRaises(UserError):\n config.write({\n 'step_order_ids': [\n (0, 0, {'sequence': 10, 'step_id': run_step.id}),\n (0, 0, {'sequence': 15, 'step_id': create_step.id}),\n ]\n })\n\n # test that the run_odoo step should be preceded by an install step\n with self.assertRaises(UserError):\n config.write({\n 'step_order_ids': [\n (0, 0, {'sequence': 15, 'step_id': run_step.id}),\n (0, 0, {'sequence': 10, 'step_id': create_step.id}),\n ]\n })","def failure(self, input: str) -> enumFail:\n pass","def test_raise_exception(self):\n with self.assertRaises(Exception):\n SshpassBaseCommandBuilder(COMMAND).to_build()","def indicate_failure(self):\n pass","def failure(self, message=''):\n print(colored(message, 'red'))","def throw(self):\n pass","def buildException(status, why):\n print >>sys.stderr, 'build error encountered:', why\n print >>sys.stderr, 'aborting build'\n status.code = 1\n reactor.callFromThread(reactor.stop)","def unexpected_error(self, exception):","def job_step_error(self, job_request_payload, message):\n payload = JobStepErrorPayload(job_request_payload, message)\n self.send(job_request_payload.error_command, payload)","def error(self, msg, transfers):\n self.validation_exceptions.extend(self._create_exceptions(msg, transfers, ValidationType.ERROR))","def print_failed(self):\n # Construct the message dynamically based on the instance_type\n msg = colored(\"FAIL\", \"red\") + f\" | [ERROR] {self.message}\"\n if self.instance_type == \"FILE\":\n msg += f\" [{self.instance_type}] {self.instance_location}/{self.instance_name}\"\n\n elif self.instance_type == \"HOST\":\n msg += f\" [{self.instance_type}] {self.instance_hostname}\"\n\n msg += f\" [PROPERTY] {':'.join(str(item) for item in self.absolute_path)}\"\n\n # print the msg\n print(msg)","def raise_(err):\n raise err","def fail(self):\n self.cleanup()\n self.runner.report_job_fail(self.id)","def test_raise_exception2(self):\n with self.assertRaises(Exception):\n SshpassBaseCommandBuilder(COMMAND)\\\n .set_password(SERVER_PASSWORD)\\\n .set_file(PASSWORD_FILE)\\\n .to_build()","def failure(self, cb: CircuitBreaker, exc: BaseException) -> None:","def _message_failed_job(self):\n self.ensure_one()\n return _(\"Something bad happened during the execution of the job. \"\n \"More details in the 'Exception Information' section.\")","def error():\r\n raise RuntimeError('admin ticket generator at your service')","def error(self):\n pass","def test_no_such_step(self):\n with self.assertRaises(Exception):\n self.run_step('FAKE-STEP.no-exists')","def unexpectedException(self):","def checkStep(rc, steps, run_status, prog_args):\n\n if (rc == FAILURE) or (rc == EXCEPTION):\n buildException(run_status, 'previous command failed')\n else:\n defer.maybeDeferred(lambda x: startNextStep(x,\n run_status, prog_args), steps)","def task_failed(self, worker_name, error):\n self.status = 'failed'\n self.modification_time = current_millis()\n self.message = '{} (worker): {}'.format(worker_name, error)\n return self","def raise_error(cls, *args):\n raise cls(cls.message)","def failure(self, result):\r\n raise NotImplementedError","def _failed(self, msg):\n self.log(msg)\n self.result.passed = False\n self.result.add_error(msg)\n self.log(u\"Failed\")","def test_valid_python_raise_exception(self):\n \n data_file = testutils.DataFile(\"integration_module_valid_raise\")\n\n rtn = self.run_cmd(\"pm install --force --single module --install_name test_raise --name %s --auto\" % str(data_file))\n assert(rtn.return_code == 0)\n\n rtn = self.run_cmd(\"test_raise test\")\n\n assert(rtn.return_code == 246)","def failed(self, message=None):\n doc = {self.STATE: self.STATE_FAILED}\n\n if message:\n doc.update({self.ERROR_MESSAGE: message})\n\n self.update(doc)","def test_create_status_throws_exception():\n with pytest.raises(ValueError):\n BuildResults.BuildStatus.create(\"unknown_status\")","def failure(self, target):\n print \"FAILED:\"\n self.show_target(target)\n self.failed += 1","def fail(self, msg, *args):\n self.log.error(msg, *args)\n sys.exit(1)","def exception(self, *args, **kwargs):","def __init__(self, reason, stage=\"\"):\n super(ProjectConstructionException, self).__init__(\n datatype=\"Project\", stage=stage, context=reason)","def on_saga_failure(self, failed_step: BaseStep, initial_failure_payload: dict):\n logger.info(f'Saga {self.saga_id} failed on \"{failed_step.name}\" step. \\n'\n f'Failure details: {initial_failure_payload}')","def test_failure_result(self):\n dr = EventualResult(fail(RuntimeError()), None)\n self.assertRaises(RuntimeError, dr.wait, 0.1)","def __repr__(self: \"Failed\") -> str:\n return \"Failed()\"","def build_step(self):\n pass","def build_step(self):\n pass","def run(self, failure_info):\n signals = {}\n if not failure_info['failed'] or not failure_info['chromium_revision']:\n # Bail out if no failed step or no chromium revision.\n return signals\n\n # Bail out on infra failure\n if failure_info.get('failure_type') == failure_type.INFRA:\n return signals\n\n master_name = failure_info['master_name']\n builder_name = failure_info['builder_name']\n build_number = failure_info['build_number']\n\n for step_name in failure_info.get('failed_steps', []):\n if not waterfall_config.StepIsSupportedForMaster(step_name, master_name):\n # Bail out if the step is not supported.\n continue\n\n step = WfStep.Get(master_name, builder_name, build_number, step_name)\n if step and step.log_data:\n failure_log = step.log_data\n else:\n # TODO: do test-level analysis instead of step-level.\n # TODO: Use swarming test result instead of archived gtest results\n gtest_result = buildbot.GetGtestResultLog(\n master_name, builder_name, build_number, step_name)\n if gtest_result:\n failure_log = _GetReliableTestFailureLog(gtest_result)\n\n if gtest_result is None or failure_log == 'invalid':\n if not lock_util.WaitUntilDownloadAllowed(\n master_name): # pragma: no cover\n raise pipeline.Retry('Failed to pull log of step %s of master %s'\n % (step_name, master_name))\n try:\n failure_log = buildbot.GetStepLog(\n master_name, builder_name, build_number, step_name,\n self.HTTP_CLIENT)\n except ResponseTooLargeError: # pragma: no cover.\n logging.exception(\n 'Log of step \"%s\" is too large for urlfetch.', step_name)\n # If the stdio log of a step is too large, we don't want to pull it\n # again in next run, because that might lead to DDoS to the master.\n # TODO: Use archived stdio logs in Google Storage instead.\n failure_log = 'Stdio log is too large for urlfetch.'\n\n if not failure_log: # pragma: no cover\n raise pipeline.Retry('Failed to pull stdio of step %s of master %s'\n % (step_name, master_name))\n\n # Save step log in datastore and avoid downloading again during retry.\n if not step: # pragma: no cover\n step = WfStep.Create(\n master_name, builder_name, build_number, step_name)\n\n step.log_data = _ExtractStorablePortionOfLog(failure_log)\n\n try:\n step.put()\n except Exception as e: # pragma: no cover\n # Sometimes, the step log is too large to save in datastore.\n logging.exception(e)\n\n # TODO: save result in datastore?\n if step.isolated:\n try:\n json_failure_log = (\n json.loads(failure_log) if failure_log != 'flaky' else {})\n except ValueError: # pragma: no cover\n json_failure_log = {}\n logging.warning('failure_log %s is not valid JSON.' % failure_log)\n\n signals[step_name] = {\n 'tests': {}\n }\n step_signal = FailureSignal()\n\n for test_name, test_failure_log in json_failure_log.iteritems():\n signals[step_name]['tests'][test_name] = extractors.ExtractSignal(\n master_name, builder_name, step_name, test_name,\n base64.b64decode(test_failure_log)).ToDict()\n\n # Save signals in test failure log to step level.\n step_signal.MergeFrom(signals[step_name]['tests'][test_name])\n\n signals[step_name]['files'] = step_signal.files\n signals[step_name]['keywords'] = step_signal.keywords\n else:\n signals[step_name] = extractors.ExtractSignal(\n master_name, builder_name, step_name, None, failure_log).ToDict()\n\n return signals","def exception(self, e):\n pass","def error_handler(self, step_name: str = None, state_name=None):\n if state_name:\n warnings.warn(\n \"The state_name parameter is deprecated. Use step_name instead\",\n # TODO: In 0.7.0 do changes in examples & demos In 0.9.0 remove\n PendingDeprecationWarning,\n )\n step_name = step_name or state_name\n if not step_name:\n raise MLRunInvalidArgumentError(\"Must specify step_name\")\n self.on_error = step_name\n return self","def error(self):\n ...","def failure(self, error):\n print \"comm failed Reason:\", error\n return error","def on_failure(self, exc: BaseException) -> None:","def td_error(self, states, actions, rewards, next_states):\n raise NotImplemented","def context_errored(self, cls, example, exception):","def error(self, cause = None, annotations = {}):\n self.set_outcome(Result.ERROR, cause, annotations)","def handle_build_error(error):\n sys.stderr.write('Error running command `%s`. Returned %s.\\n' % (\n ' '.join(error.argv), str(error.error_code)))","def _create_failure_entry(self):\r\n # view task entry for task failure\r\n progress = {'message': TEST_FAILURE_MESSAGE,\r\n 'exception': TEST_FAILURE_EXCEPTION,\r\n }\r\n return self._create_entry(task_state=FAILURE, task_output=progress)","def exception(self):\n raise Exception(\"Exception test\")","def RaiseToolException(problems, error_message=None):\n RaiseException(problems, calliope_exceptions.ToolException, error_message)","def fail(self, key, **kwargs):\n return fail(self, key, **kwargs)","def raise_error(Err):\n raise Err()","def throw(self, type, value=None, traceback=None):\n pass","def op_exception(self) -> Optional[BaseException]:\n exc = self._step_execution_context.step_exception\n\n if isinstance(exc, RetryRequestedFromPolicy):\n return exc.__cause__\n\n return exc","def test_handles_job_exception(self):\n from furious.async import Async\n from furious.context._execution import _ExecutionContext\n from furious.processors import run_job\n from furious.processors import AsyncException\n\n work = Async(target=dir, args=[1, 2])\n\n with _ExecutionContext(work):\n self.assertRaises(TypeError, run_job)\n\n self.assertIsInstance(work.result.payload, AsyncException)","def test_failed():\n build()\n sh(\"%s %s --last-failed\" % (PYTHON, RUNNER_PY))","def test_raise_exception(self):\n with self.assertRaises(Exception):\n SshCommandBuilder(SERVER_USER, COMMAND).to_build()","def rollback(self, exc):\n USER.info('%s: Rolling Back Failed Build', self.recipe.name)\n cascade = False\n if isinstance(exc, AssertionError):\n logging.error('Error during verify() of %s', self.recipe.name)\n cascade = True\n if cascade or isinstance(exc, PakitLinkError):\n if not cascade:\n logging.error('Error during linking of %s', self.recipe.name)\n walk_and_unlink(self.recipe.install_dir, self.recipe.link_dir)\n cascade = True\n if cascade or (not isinstance(exc, PakitLinkError) and\n not isinstance(exc, AssertionError)):\n if not cascade:\n logging.error('Error during build() of %s', self.recipe.name)\n try:\n Command('rm -rf ' + self.recipe.install_dir).wait()\n except PakitCmdError: # pragma: no cover\n pass","def error(reason, order):\n return ResultProxy(TaskResult(TaskError(reason), order))","def indicate_error(self):\n pass","def error(self, *args, **kwargs):","def test_exception_class_hierarchy(self) -> None:\n\n try:\n raise CustomDerivedError(state=\"test\")\n except CustomDerivedError as cex:\n assert type(cex) is CustomDerivedError\n assert \"test\" == cex.state\n except CustomError as cex:\n assert False, \"CustomDerivedError should have caught the exception.\"\n except:\n assert False, f\"Unhandled exception: {sys.exc_info()[0]}\"","def test_error(self) -> None:\n context: Dict[str, ArtifactDescriptor] = dict()\n cmd = ModuleCommand(\n package_id='error', \n command_id='error',\n arguments=[],\n packages=None\n )\n controller = FakeWorkflowController()\n self.backend.execute_async(\n task=TaskHandle(\n task_id='000',\n project_id=self.PROJECT_ID,\n controller=controller\n ),\n command=cmd,\n artifacts=context\n )\n time.sleep(2)\n self.assertEqual(controller.task_id, '000')\n self.assertEqual(controller.state, 'ERROR')\n self.assertEqual(len(controller.outputs.stdout), 0)\n self.assertNotEqual(len(controller.outputs.stderr), 0)","def build_step(self):\n\n pass","def render_revalidation_failure(self,failed_step): \n return self.redirect(self.get_step_url(failed_step))","def test_task_failed(self):\n\n task1 = FailedTask(mock.Mock(), total_retries=0)\n task2 = mock.Mock(execute_after=0)\n\n g = TaskDependencyGraph(MockWorkflowContext())\n seq = g.sequence()\n seq.add(task1, task2)\n\n with limited_sleep_mock():\n self.assertRaisesRegex(WorkflowFailed, 'failtask', g.execute)\n self.assertTrue(task1.is_terminated)\n self.assertFalse(task2.apply_async.called)","def error_handler(self, failure):\n log.error(failure)","def fail(self, cause = None, annotations = {}):\n self.set_outcome(Result.FAIL, cause, annotations)","def set_test_failed(self):\n self.set_result(Status.FAILED)","def _handle_error(self, failure, item, spider):\n # do nothing, just log\n log.err(failure)","def test_failure(self):\n\n @sync_performer\n def fail(dispatcher, intent):\n raise intent\n\n dispatcher = lambda _: fail\n self.assertThat(\n sync_perform(\n dispatcher, Effect(ValueError(\"oh dear\")).on(error=lambda e: e)\n ),\n MatchesException(ValueError(\"oh dear\")),\n )","def creation_error(src_dict: Dict[str, List[str]], e: str):\n return \"LED Group error in %s: %s\\n)\" % (json.dumps(src_dict), e)","def error(self, messages=None):\n return StateError(\n created_at=self.created_at,\n started_at=self.started_at,\n messages=messages\n )","def test_broken_error_descriptor(self):\r\n with self.assertRaises(TestException):\r\n module = self.descriptor._xmodule"],"string":"[\n \"def raise_step_error(self, error: Exception, step: str):\\n error_message = \\\"{}\\\\nFailed: Error={}\\\".format(step, str(error))\\n logging.error(error_message)\\n self.slacker.send_thread_reply(error_message)\\n raise Exception(error_message)\",\n \"def raise_on_error(self):\\n if not self._status.success:\\n cls = UrlApi.InfraHTTPError if self._infra_step else UrlApi.HTTPError\\n raise cls('HTTP status (%d)' % (self.status_code,), self)\",\n \"def test_fails(self):\\n raise FoolishError(\\\"I am a broken test\\\")\",\n \"def fail(self, msg=None):\\r\\n raise self.failureException(msg)\",\n \"def step(self):\\n raise TaskError(\\\"Task %s: subclass should override step() method!\\\" %\\n self)\",\n \"def raise_for_failure(self) -> None:\\n if not self.is_success():\\n raise exc.ExecutionError(self)\",\n \"def exception(self, *args, **kwargs):\\n return super(Blueprint, self).exception(*args, **kwargs)\",\n \"def abort(self, message: str) -> None:\\n message = f\\\"{Invocation.current.log} - {message}\\\"\\n self.exception = StepException(message)\\n global failure_aborts_build # pylint: disable=invalid-name\\n global no_actions # pylint: disable=invalid-name\\n if failure_aborts_build.value and not no_actions.value:\\n no_additional_complaints()\\n raise self.exception\",\n \"def setup_class(cls):\\n try:\\n super(BuildFailureTests, cls).setup_class()\\n except CommandFailure:\\n pass\\n else:\\n raise AssertionError('A failed build returned an exit code of 0.')\",\n \"def fail(self, msg=None):\\n raise Exception, msg\",\n \"def failed(self):\\n\\t\\tpass\",\n \"def raise_fail(*args, **kwargs):\\n raise Exception(\\\"oops\\\")\",\n \"def test_second_step_strict(self):\\n with self.assertRaises(Exception):\\n self.run_step('S02-errors.py', allow_failure=False)\",\n \"def testRunException(self):\\n class TestError(Exception):\\n \\\"\\\"\\\"Unique test exception\\\"\\\"\\\"\\n\\n perform_mock = self.PatchObject(generic_stages.BuilderStage, 'PerformStage')\\n perform_mock.side_effect = TestError('fail!')\\n\\n stage = self.ConstructStage()\\n results_lib.Results.Clear()\\n self.assertRaises(failures_lib.StepFailure, self._RunCapture, stage)\\n\\n results = results_lib.Results.Get()[0]\\n self.assertTrue(isinstance(results.result, TestError))\\n self.assertEqual(str(results.result), 'fail!')\\n self.mock_cidb.StartBuildStage.assert_called_once_with(\\n DEFAULT_BUILD_STAGE_ID)\\n self.mock_cidb.FinishBuildStage.assert_called_once_with(\\n DEFAULT_BUILD_STAGE_ID,\\n constants.BUILDER_STATUS_FAILED)\",\n \"def failure_callback(self):\\n error_filename = self.run_dir / \\\"eplusout.err\\\"\\n if error_filename.exists():\\n with open(error_filename, \\\"r\\\") as stderr:\\n stderr_r = stderr.read()\\n self.exception = EnergyPlusProcessError(\\n cmd=self.cmd, stderr=stderr_r, idf=self.idf\\n )\\n self.cleanup_callback()\",\n \"def add_failure(self, task: Task, exception: Any) -> None: # noqa: DAR101\\n super().add_failure(task, exception)\\n self._add_summary(task, _TaskExitCode.FAIL)\",\n \"def test_badstageerror_raise(self, mock_isdir):\\n # Set the mocked functions returned values\\n mock_isdir.side_effect = [True]\\n\\n # Test execution\\n wrong_kwargs = copy.copy(self.kwargs)\\n wrong_kwargs[\\\"reconstruction_stage\\\"] = \\\"WRONG\\\"\\n self.assertRaises(ValueError, recon_all, **wrong_kwargs)\",\n \"def fail(msg):\\n\\n # Not sure if simply raising the exception is clearer.\\n raise CommandFailed(msg)\",\n \"def error(self):\\n raise NotImplementedError(\\\"subclasses need to override this method\\\")\",\n \"def InfraFailure(self):\\n return recipe_api.InfraFailure\",\n \"def __init__(self, message=\\\"\\\"):\\n super(AutomationError, self).__init__(message)\",\n \"def test_class_errored(self, cls, exception):\",\n \"def report_unexpected_exception(self, *args, **kwargs):\\n pass\",\n \"def test_runFailed(self):\\n builder = BookBuilder()\\n exc = self.assertRaises(\\n CommandFailed, builder.run,\\n [sys.executable, '-c', 'print \\\"hi\\\"; raise SystemExit(1)'])\\n self.assertEquals(exc.exitStatus, 1)\\n self.assertEquals(exc.exitSignal, None)\\n self.assertEquals(exc.output, \\\"hi\\\\n\\\")\",\n \"def failure_exception(cls, state, exception):\\r\\n return PlatformMessage(method=\\\"__reply__\\\", kwargs={\\\"__result__\\\": \\\"fail\\\", \\\"state\\\": state, \\\"errcode\\\": -2,\\r\\n \\\"e\\\": exception})\",\n \"def test_fail(make_runner: Callable[..., TargetFunctionRunner]) -> None:\\n runner = make_runner(target_failed, use_instances=True)\\n run_info = TrialInfo(config=2, instance=\\\"test\\\", seed=0, budget=0.0)\\n\\n runner.submit_trial(run_info)\\n run_info, run_value = next(runner.iter_results())\\n\\n # Make sure the traceback message is included\\n assert \\\"traceback\\\" in run_value.additional_info\\n assert \\\"RuntimeError\\\" in run_value.additional_info[\\\"traceback\\\"]\",\n \"def test_config_step_raises(self):\\n\\n run_step = self.ConfigStep.create({\\n 'name': 'run_step',\\n 'job_type': 'run_odoo',\\n })\\n\\n create_step = self.ConfigStep.create({\\n 'name': 'test_step',\\n 'job_type': 'create_build',\\n })\\n\\n config = self.Config.create({'name': 'test_config'})\\n\\n # test that the run_odoo step has to be the last one\\n with self.assertRaises(UserError):\\n config.write({\\n 'step_order_ids': [\\n (0, 0, {'sequence': 10, 'step_id': run_step.id}),\\n (0, 0, {'sequence': 15, 'step_id': create_step.id}),\\n ]\\n })\\n\\n # test that the run_odoo step should be preceded by an install step\\n with self.assertRaises(UserError):\\n config.write({\\n 'step_order_ids': [\\n (0, 0, {'sequence': 15, 'step_id': run_step.id}),\\n (0, 0, {'sequence': 10, 'step_id': create_step.id}),\\n ]\\n })\",\n \"def failure(self, input: str) -> enumFail:\\n pass\",\n \"def test_raise_exception(self):\\n with self.assertRaises(Exception):\\n SshpassBaseCommandBuilder(COMMAND).to_build()\",\n \"def indicate_failure(self):\\n pass\",\n \"def failure(self, message=''):\\n print(colored(message, 'red'))\",\n \"def throw(self):\\n pass\",\n \"def buildException(status, why):\\n print >>sys.stderr, 'build error encountered:', why\\n print >>sys.stderr, 'aborting build'\\n status.code = 1\\n reactor.callFromThread(reactor.stop)\",\n \"def unexpected_error(self, exception):\",\n \"def job_step_error(self, job_request_payload, message):\\n payload = JobStepErrorPayload(job_request_payload, message)\\n self.send(job_request_payload.error_command, payload)\",\n \"def error(self, msg, transfers):\\n self.validation_exceptions.extend(self._create_exceptions(msg, transfers, ValidationType.ERROR))\",\n \"def print_failed(self):\\n # Construct the message dynamically based on the instance_type\\n msg = colored(\\\"FAIL\\\", \\\"red\\\") + f\\\" | [ERROR] {self.message}\\\"\\n if self.instance_type == \\\"FILE\\\":\\n msg += f\\\" [{self.instance_type}] {self.instance_location}/{self.instance_name}\\\"\\n\\n elif self.instance_type == \\\"HOST\\\":\\n msg += f\\\" [{self.instance_type}] {self.instance_hostname}\\\"\\n\\n msg += f\\\" [PROPERTY] {':'.join(str(item) for item in self.absolute_path)}\\\"\\n\\n # print the msg\\n print(msg)\",\n \"def raise_(err):\\n raise err\",\n \"def fail(self):\\n self.cleanup()\\n self.runner.report_job_fail(self.id)\",\n \"def test_raise_exception2(self):\\n with self.assertRaises(Exception):\\n SshpassBaseCommandBuilder(COMMAND)\\\\\\n .set_password(SERVER_PASSWORD)\\\\\\n .set_file(PASSWORD_FILE)\\\\\\n .to_build()\",\n \"def failure(self, cb: CircuitBreaker, exc: BaseException) -> None:\",\n \"def _message_failed_job(self):\\n self.ensure_one()\\n return _(\\\"Something bad happened during the execution of the job. \\\"\\n \\\"More details in the 'Exception Information' section.\\\")\",\n \"def error():\\r\\n raise RuntimeError('admin ticket generator at your service')\",\n \"def error(self):\\n pass\",\n \"def test_no_such_step(self):\\n with self.assertRaises(Exception):\\n self.run_step('FAKE-STEP.no-exists')\",\n \"def unexpectedException(self):\",\n \"def checkStep(rc, steps, run_status, prog_args):\\n\\n if (rc == FAILURE) or (rc == EXCEPTION):\\n buildException(run_status, 'previous command failed')\\n else:\\n defer.maybeDeferred(lambda x: startNextStep(x,\\n run_status, prog_args), steps)\",\n \"def task_failed(self, worker_name, error):\\n self.status = 'failed'\\n self.modification_time = current_millis()\\n self.message = '{} (worker): {}'.format(worker_name, error)\\n return self\",\n \"def raise_error(cls, *args):\\n raise cls(cls.message)\",\n \"def failure(self, result):\\r\\n raise NotImplementedError\",\n \"def _failed(self, msg):\\n self.log(msg)\\n self.result.passed = False\\n self.result.add_error(msg)\\n self.log(u\\\"Failed\\\")\",\n \"def test_valid_python_raise_exception(self):\\n \\n data_file = testutils.DataFile(\\\"integration_module_valid_raise\\\")\\n\\n rtn = self.run_cmd(\\\"pm install --force --single module --install_name test_raise --name %s --auto\\\" % str(data_file))\\n assert(rtn.return_code == 0)\\n\\n rtn = self.run_cmd(\\\"test_raise test\\\")\\n\\n assert(rtn.return_code == 246)\",\n \"def failed(self, message=None):\\n doc = {self.STATE: self.STATE_FAILED}\\n\\n if message:\\n doc.update({self.ERROR_MESSAGE: message})\\n\\n self.update(doc)\",\n \"def test_create_status_throws_exception():\\n with pytest.raises(ValueError):\\n BuildResults.BuildStatus.create(\\\"unknown_status\\\")\",\n \"def failure(self, target):\\n print \\\"FAILED:\\\"\\n self.show_target(target)\\n self.failed += 1\",\n \"def fail(self, msg, *args):\\n self.log.error(msg, *args)\\n sys.exit(1)\",\n \"def exception(self, *args, **kwargs):\",\n \"def __init__(self, reason, stage=\\\"\\\"):\\n super(ProjectConstructionException, self).__init__(\\n datatype=\\\"Project\\\", stage=stage, context=reason)\",\n \"def on_saga_failure(self, failed_step: BaseStep, initial_failure_payload: dict):\\n logger.info(f'Saga {self.saga_id} failed on \\\"{failed_step.name}\\\" step. \\\\n'\\n f'Failure details: {initial_failure_payload}')\",\n \"def test_failure_result(self):\\n dr = EventualResult(fail(RuntimeError()), None)\\n self.assertRaises(RuntimeError, dr.wait, 0.1)\",\n \"def __repr__(self: \\\"Failed\\\") -> str:\\n return \\\"Failed()\\\"\",\n \"def build_step(self):\\n pass\",\n \"def build_step(self):\\n pass\",\n \"def run(self, failure_info):\\n signals = {}\\n if not failure_info['failed'] or not failure_info['chromium_revision']:\\n # Bail out if no failed step or no chromium revision.\\n return signals\\n\\n # Bail out on infra failure\\n if failure_info.get('failure_type') == failure_type.INFRA:\\n return signals\\n\\n master_name = failure_info['master_name']\\n builder_name = failure_info['builder_name']\\n build_number = failure_info['build_number']\\n\\n for step_name in failure_info.get('failed_steps', []):\\n if not waterfall_config.StepIsSupportedForMaster(step_name, master_name):\\n # Bail out if the step is not supported.\\n continue\\n\\n step = WfStep.Get(master_name, builder_name, build_number, step_name)\\n if step and step.log_data:\\n failure_log = step.log_data\\n else:\\n # TODO: do test-level analysis instead of step-level.\\n # TODO: Use swarming test result instead of archived gtest results\\n gtest_result = buildbot.GetGtestResultLog(\\n master_name, builder_name, build_number, step_name)\\n if gtest_result:\\n failure_log = _GetReliableTestFailureLog(gtest_result)\\n\\n if gtest_result is None or failure_log == 'invalid':\\n if not lock_util.WaitUntilDownloadAllowed(\\n master_name): # pragma: no cover\\n raise pipeline.Retry('Failed to pull log of step %s of master %s'\\n % (step_name, master_name))\\n try:\\n failure_log = buildbot.GetStepLog(\\n master_name, builder_name, build_number, step_name,\\n self.HTTP_CLIENT)\\n except ResponseTooLargeError: # pragma: no cover.\\n logging.exception(\\n 'Log of step \\\"%s\\\" is too large for urlfetch.', step_name)\\n # If the stdio log of a step is too large, we don't want to pull it\\n # again in next run, because that might lead to DDoS to the master.\\n # TODO: Use archived stdio logs in Google Storage instead.\\n failure_log = 'Stdio log is too large for urlfetch.'\\n\\n if not failure_log: # pragma: no cover\\n raise pipeline.Retry('Failed to pull stdio of step %s of master %s'\\n % (step_name, master_name))\\n\\n # Save step log in datastore and avoid downloading again during retry.\\n if not step: # pragma: no cover\\n step = WfStep.Create(\\n master_name, builder_name, build_number, step_name)\\n\\n step.log_data = _ExtractStorablePortionOfLog(failure_log)\\n\\n try:\\n step.put()\\n except Exception as e: # pragma: no cover\\n # Sometimes, the step log is too large to save in datastore.\\n logging.exception(e)\\n\\n # TODO: save result in datastore?\\n if step.isolated:\\n try:\\n json_failure_log = (\\n json.loads(failure_log) if failure_log != 'flaky' else {})\\n except ValueError: # pragma: no cover\\n json_failure_log = {}\\n logging.warning('failure_log %s is not valid JSON.' % failure_log)\\n\\n signals[step_name] = {\\n 'tests': {}\\n }\\n step_signal = FailureSignal()\\n\\n for test_name, test_failure_log in json_failure_log.iteritems():\\n signals[step_name]['tests'][test_name] = extractors.ExtractSignal(\\n master_name, builder_name, step_name, test_name,\\n base64.b64decode(test_failure_log)).ToDict()\\n\\n # Save signals in test failure log to step level.\\n step_signal.MergeFrom(signals[step_name]['tests'][test_name])\\n\\n signals[step_name]['files'] = step_signal.files\\n signals[step_name]['keywords'] = step_signal.keywords\\n else:\\n signals[step_name] = extractors.ExtractSignal(\\n master_name, builder_name, step_name, None, failure_log).ToDict()\\n\\n return signals\",\n \"def exception(self, e):\\n pass\",\n \"def error_handler(self, step_name: str = None, state_name=None):\\n if state_name:\\n warnings.warn(\\n \\\"The state_name parameter is deprecated. Use step_name instead\\\",\\n # TODO: In 0.7.0 do changes in examples & demos In 0.9.0 remove\\n PendingDeprecationWarning,\\n )\\n step_name = step_name or state_name\\n if not step_name:\\n raise MLRunInvalidArgumentError(\\\"Must specify step_name\\\")\\n self.on_error = step_name\\n return self\",\n \"def error(self):\\n ...\",\n \"def failure(self, error):\\n print \\\"comm failed Reason:\\\", error\\n return error\",\n \"def on_failure(self, exc: BaseException) -> None:\",\n \"def td_error(self, states, actions, rewards, next_states):\\n raise NotImplemented\",\n \"def context_errored(self, cls, example, exception):\",\n \"def error(self, cause = None, annotations = {}):\\n self.set_outcome(Result.ERROR, cause, annotations)\",\n \"def handle_build_error(error):\\n sys.stderr.write('Error running command `%s`. Returned %s.\\\\n' % (\\n ' '.join(error.argv), str(error.error_code)))\",\n \"def _create_failure_entry(self):\\r\\n # view task entry for task failure\\r\\n progress = {'message': TEST_FAILURE_MESSAGE,\\r\\n 'exception': TEST_FAILURE_EXCEPTION,\\r\\n }\\r\\n return self._create_entry(task_state=FAILURE, task_output=progress)\",\n \"def exception(self):\\n raise Exception(\\\"Exception test\\\")\",\n \"def RaiseToolException(problems, error_message=None):\\n RaiseException(problems, calliope_exceptions.ToolException, error_message)\",\n \"def fail(self, key, **kwargs):\\n return fail(self, key, **kwargs)\",\n \"def raise_error(Err):\\n raise Err()\",\n \"def throw(self, type, value=None, traceback=None):\\n pass\",\n \"def op_exception(self) -> Optional[BaseException]:\\n exc = self._step_execution_context.step_exception\\n\\n if isinstance(exc, RetryRequestedFromPolicy):\\n return exc.__cause__\\n\\n return exc\",\n \"def test_handles_job_exception(self):\\n from furious.async import Async\\n from furious.context._execution import _ExecutionContext\\n from furious.processors import run_job\\n from furious.processors import AsyncException\\n\\n work = Async(target=dir, args=[1, 2])\\n\\n with _ExecutionContext(work):\\n self.assertRaises(TypeError, run_job)\\n\\n self.assertIsInstance(work.result.payload, AsyncException)\",\n \"def test_failed():\\n build()\\n sh(\\\"%s %s --last-failed\\\" % (PYTHON, RUNNER_PY))\",\n \"def test_raise_exception(self):\\n with self.assertRaises(Exception):\\n SshCommandBuilder(SERVER_USER, COMMAND).to_build()\",\n \"def rollback(self, exc):\\n USER.info('%s: Rolling Back Failed Build', self.recipe.name)\\n cascade = False\\n if isinstance(exc, AssertionError):\\n logging.error('Error during verify() of %s', self.recipe.name)\\n cascade = True\\n if cascade or isinstance(exc, PakitLinkError):\\n if not cascade:\\n logging.error('Error during linking of %s', self.recipe.name)\\n walk_and_unlink(self.recipe.install_dir, self.recipe.link_dir)\\n cascade = True\\n if cascade or (not isinstance(exc, PakitLinkError) and\\n not isinstance(exc, AssertionError)):\\n if not cascade:\\n logging.error('Error during build() of %s', self.recipe.name)\\n try:\\n Command('rm -rf ' + self.recipe.install_dir).wait()\\n except PakitCmdError: # pragma: no cover\\n pass\",\n \"def error(reason, order):\\n return ResultProxy(TaskResult(TaskError(reason), order))\",\n \"def indicate_error(self):\\n pass\",\n \"def error(self, *args, **kwargs):\",\n \"def test_exception_class_hierarchy(self) -> None:\\n\\n try:\\n raise CustomDerivedError(state=\\\"test\\\")\\n except CustomDerivedError as cex:\\n assert type(cex) is CustomDerivedError\\n assert \\\"test\\\" == cex.state\\n except CustomError as cex:\\n assert False, \\\"CustomDerivedError should have caught the exception.\\\"\\n except:\\n assert False, f\\\"Unhandled exception: {sys.exc_info()[0]}\\\"\",\n \"def test_error(self) -> None:\\n context: Dict[str, ArtifactDescriptor] = dict()\\n cmd = ModuleCommand(\\n package_id='error', \\n command_id='error',\\n arguments=[],\\n packages=None\\n )\\n controller = FakeWorkflowController()\\n self.backend.execute_async(\\n task=TaskHandle(\\n task_id='000',\\n project_id=self.PROJECT_ID,\\n controller=controller\\n ),\\n command=cmd,\\n artifacts=context\\n )\\n time.sleep(2)\\n self.assertEqual(controller.task_id, '000')\\n self.assertEqual(controller.state, 'ERROR')\\n self.assertEqual(len(controller.outputs.stdout), 0)\\n self.assertNotEqual(len(controller.outputs.stderr), 0)\",\n \"def build_step(self):\\n\\n pass\",\n \"def render_revalidation_failure(self,failed_step): \\n return self.redirect(self.get_step_url(failed_step))\",\n \"def test_task_failed(self):\\n\\n task1 = FailedTask(mock.Mock(), total_retries=0)\\n task2 = mock.Mock(execute_after=0)\\n\\n g = TaskDependencyGraph(MockWorkflowContext())\\n seq = g.sequence()\\n seq.add(task1, task2)\\n\\n with limited_sleep_mock():\\n self.assertRaisesRegex(WorkflowFailed, 'failtask', g.execute)\\n self.assertTrue(task1.is_terminated)\\n self.assertFalse(task2.apply_async.called)\",\n \"def error_handler(self, failure):\\n log.error(failure)\",\n \"def fail(self, cause = None, annotations = {}):\\n self.set_outcome(Result.FAIL, cause, annotations)\",\n \"def set_test_failed(self):\\n self.set_result(Status.FAILED)\",\n \"def _handle_error(self, failure, item, spider):\\n # do nothing, just log\\n log.err(failure)\",\n \"def test_failure(self):\\n\\n @sync_performer\\n def fail(dispatcher, intent):\\n raise intent\\n\\n dispatcher = lambda _: fail\\n self.assertThat(\\n sync_perform(\\n dispatcher, Effect(ValueError(\\\"oh dear\\\")).on(error=lambda e: e)\\n ),\\n MatchesException(ValueError(\\\"oh dear\\\")),\\n )\",\n \"def creation_error(src_dict: Dict[str, List[str]], e: str):\\n return \\\"LED Group error in %s: %s\\\\n)\\\" % (json.dumps(src_dict), e)\",\n \"def error(self, messages=None):\\n return StateError(\\n created_at=self.created_at,\\n started_at=self.started_at,\\n messages=messages\\n )\",\n \"def test_broken_error_descriptor(self):\\r\\n with self.assertRaises(TestException):\\r\\n module = self.descriptor._xmodule\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65778327","0.6160697","0.6118424","0.6045226","0.6028757","0.59925586","0.59890693","0.5984237","0.5979543","0.5880542","0.58220655","0.58042306","0.58023226","0.57811123","0.57735544","0.56904095","0.56897426","0.5686951","0.56869185","0.5652853","0.5650791","0.5649762","0.56389666","0.5612642","0.5602301","0.55968726","0.5593547","0.5591498","0.55746824","0.5562834","0.55435306","0.5543076","0.55419517","0.5537418","0.5518677","0.5516668","0.55114883","0.5475968","0.5459171","0.54355115","0.54351425","0.54309916","0.5422185","0.5413536","0.54118836","0.54106736","0.5407893","0.5407813","0.54001236","0.5362275","0.535933","0.5357869","0.53560364","0.5346884","0.53428936","0.5342327","0.5340739","0.5338552","0.5334603","0.5333543","0.5329987","0.53285986","0.53285986","0.53211355","0.53193825","0.53033006","0.5302605","0.5301806","0.5301303","0.5289473","0.52825433","0.5278118","0.52748775","0.52738404","0.5272844","0.5271023","0.5263156","0.52626497","0.5256101","0.5249445","0.5242914","0.52420443","0.5241046","0.5232203","0.5224821","0.5222814","0.5221684","0.5216956","0.5192028","0.5178878","0.51782656","0.517177","0.51460487","0.5144369","0.5142773","0.5142699","0.5142338","0.5141423","0.51404685","0.5136248"],"string":"[\n \"0.65778327\",\n \"0.6160697\",\n \"0.6118424\",\n \"0.6045226\",\n \"0.6028757\",\n \"0.59925586\",\n \"0.59890693\",\n \"0.5984237\",\n \"0.5979543\",\n \"0.5880542\",\n \"0.58220655\",\n \"0.58042306\",\n \"0.58023226\",\n \"0.57811123\",\n \"0.57735544\",\n \"0.56904095\",\n \"0.56897426\",\n \"0.5686951\",\n \"0.56869185\",\n \"0.5652853\",\n \"0.5650791\",\n \"0.5649762\",\n \"0.56389666\",\n \"0.5612642\",\n \"0.5602301\",\n \"0.55968726\",\n \"0.5593547\",\n \"0.5591498\",\n \"0.55746824\",\n \"0.5562834\",\n \"0.55435306\",\n \"0.5543076\",\n \"0.55419517\",\n \"0.5537418\",\n \"0.5518677\",\n \"0.5516668\",\n \"0.55114883\",\n \"0.5475968\",\n \"0.5459171\",\n \"0.54355115\",\n \"0.54351425\",\n \"0.54309916\",\n \"0.5422185\",\n \"0.5413536\",\n \"0.54118836\",\n \"0.54106736\",\n \"0.5407893\",\n \"0.5407813\",\n \"0.54001236\",\n \"0.5362275\",\n \"0.535933\",\n \"0.5357869\",\n \"0.53560364\",\n \"0.5346884\",\n \"0.53428936\",\n \"0.5342327\",\n \"0.5340739\",\n \"0.5338552\",\n \"0.5334603\",\n \"0.5333543\",\n \"0.5329987\",\n \"0.53285986\",\n \"0.53285986\",\n \"0.53211355\",\n \"0.53193825\",\n \"0.53033006\",\n \"0.5302605\",\n \"0.5301806\",\n \"0.5301303\",\n \"0.5289473\",\n \"0.52825433\",\n \"0.5278118\",\n \"0.52748775\",\n \"0.52738404\",\n \"0.5272844\",\n \"0.5271023\",\n \"0.5263156\",\n \"0.52626497\",\n \"0.5256101\",\n \"0.5249445\",\n \"0.5242914\",\n \"0.52420443\",\n \"0.5241046\",\n \"0.5232203\",\n \"0.5224821\",\n \"0.5222814\",\n \"0.5221684\",\n \"0.5216956\",\n \"0.5192028\",\n \"0.5178878\",\n \"0.51782656\",\n \"0.517177\",\n \"0.51460487\",\n \"0.5144369\",\n \"0.5142773\",\n \"0.5142699\",\n \"0.5142338\",\n \"0.5141423\",\n \"0.51404685\",\n \"0.5136248\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6969654"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8994,"cells":{"query":{"kind":"string","value":"StepWarning is a subclass of StepFailure, and will translate to a yellow build."},"document":{"kind":"string","value":"def StepWarning(self):\n return recipe_api.StepWarning"},"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 _warn(self, warning=None):\r\n debug.err('Warning: %s' % warning)\r\n\r\n if core.FW_conf['settings'].TestRun.ExecutionMode == 'Leader' and warning != None:\r\n executeInFollower(\"self.warn('%s')\" % (warning,))\r\n\r\n if type(warning) != types.ListType:\r\n warning = [warning]\r\n\r\n self.result.addStepWarning(warning)","def warning(self, warning):\n pass","def StepFailure(self):\n return recipe_api.StepFailure","def warning(self, msg, *args, **kwargs):\n pass","def warning(self, *args, **kwargs):","def test_warning(self):\n self.p.compute_termination_criteria = True\n self.set_parameter_and_step(\"max_iter\", True, 5, \"ignore\")","def warning ( self , message , *args , **kwargs ) :\n return self.logger.warning ( message , *args , **kwargs )","def warning(msg):\n click.secho(msg, fg='yellow')","def warning(self, *args, **kwargs):\n self.msg(logging.WARNING, *args, **kwargs)","def success_failure_color(self, evaluation):\n return \"#60f979\" if evaluation.passes else \"#f96c60\"","def warning(self, msg, transfers):\n self.validation_exceptions.extend(self._create_exceptions(msg, transfers, ValidationType.WARNING))","def notice(self, warning):\n pass","def warning(self, message):\n return self.log(\"WARNING\", message)","def fail(self, message):\n logger.warning(message)\n g.failed = True","def warning(self, *lines):\n if self.__debug_level >= DEBUG_LEVELS['warning']:\n self.print_lines(self.colored(('magenta', 'bold'), lines))","def warning(self) -> str:\n return pulumi.get(self, \"warning\")","def failure(self, message=''):\n print(colored(message, 'red'))","def set_warning_message(msg):\n set_message(msg, TYPE_WARNING)","def warning(self) -> Optional[pulumi.Input['AnyArgs']]:\n return pulumi.get(self, \"warning\")","def warning(self, message, *, preprocessor=None):\n console.warning(message)","async def warning(self, check, *, note=None):\n return await self.mark(check, \"warning\", note=note)","def warning(self, msg):\r\n self.logger.warning(msg)","def warning(self, msg, *args):\n if self.lvl<=logging.WARNING: return self._log(msg, *args)","def WARNING(self, _strMessage=\"\"):\n self.edLogging.WARNING(_strMessage)","def warning(self, _strMessage=\"\"):\n self.edLogging.warning(_strMessage)","def warning(self, msg):\n\n self.logger.warning(msg)","def report_step_progress(self, step):\n dot_status = self.dot_status[step.status.name]\n if step.status == Status.failed:\n if (step.exception and\n not isinstance(step.exception, AssertionError)):\n # -- ISA-ERROR: Some Exception\n dot_status = self.dot_status[\"error\"]\n step.feature = self.current_feature\n step.scenario = self.current_scenario\n self.failures.append(step)\n self.stream.write(dot_status)\n self.stream.flush()","def log_check_warnings(self):\n pass","def log_check_warnings(self):\n pass","def log_check_warnings(self):\n pass","def log_check_warnings(self):\n pass","def log_check_warnings(self):\n pass","def log_check_warnings(self):\n pass","def log_check_warnings(self):\n pass","def log_check_warnings(self):\n pass","def warning(self, msg, *args, **kwargs):\n self._log(\"WARNING\", msg, args, kwargs)","def warning(warning_message: str):\n logger.warning(warning_message)","def warnings(self) -> List[Error]:","def warning(self, msg: str):\n self._logger.warning(msg)","def warn():\n pass","def warning(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"warning\")","def log(failure):\n return self._env.logger.warning('[ping] {}'.format(failure.getErrorMessage()))","def render_revalidation_failure(self,failed_step): \n return self.redirect(self.get_step_url(failed_step))","def get_warning(self) -> List[str]:\n return []","def get_warning(self) -> List[str]:\n return []","def set_warning(warning):\n impl.set_warning(**locals())","def warning(self, msg):\n self.__logger.warning(msg)","def print_failure_msg(msg):\n click.secho(msg, fg='red', file=sys.stderr)","def warning(self, msg, *args, **kwargs):\n self._logger.warning(msg, *args, **kwargs)","def warning(self) -> Optional[str]:\n return pulumi.get(self, \"warning\")","def warning(self, msg, *args, **kwargs):\n logger = self.__get_logger()\n logger.warning(msg, *args, **kwargs)","def warningglobal(self, *args, **kwargs):\n return self.logger.log(logging.WARNING+1, *args, **kwargs)","def warn(self, msg):\n warning_msg = self._warning_color\n warning_msg += \"[SHOULDER_WARNING] \" + msg\n warning_msg += self._reset_color\n self.logger.warning(warning_msg)","def warning(msg):\n log('WARNING', msg)","def get_warning_text(self):\n \n to_print = []\n if self['skipped_subchannel'] > 0:\n to_print.append(\"Some event with large weight have been discarded.\"+\\\n \" This happens %s times.\" % self['skipped_subchannel'])\n if self['n_madloop_calls'] > 0:\n fraction = self['exceptional_points']/float(self['n_madloop_calls'])\n if fraction > 1.0e-4:\n to_print.append(\"Some PS with numerical instability have been set \"+\\\n \"to a zero matrix-element (%.3g%%)\" % (100.0*fraction))\n \n return ('\\n'.join(to_print)).replace(\"'\",\" \")","def addFailure(self, test, err):\n\n super(ForceBalanceTestResult, self).addFailure(test,err)\n self.logger.warning(\"\\r\\x1b[31;1m\" + \"FAIL\" + \"\\x1b[0m \" + test.shortDescription() + \"\\n\")\n\n errorMessage = self.buildErrorMessage(test, err)\n\n for line in errorMessage.splitlines():\n self.logger.warning(\"\\t >\\t\" + line + \"\\n\")","def worker_warning_captured(self, warning_message, when, item):\n # This hook as been removed in pytest 7.1, and we can remove support once we only\n # support pytest >=7.1.\n kwargs = dict(warning_message=warning_message, when=when, item=item)\n self.config.hook.pytest_warning_captured.call_historic(kwargs=kwargs)","def warn(self, msg, line=None):\n sys.stderr.write('warning: ' + self.gen_error(msg, line) + '\\n')","def print_warning(string: str, begin: str = '') -> str:\n return begin + Fore.RED + \"[WARNING] \" + string + Fore.RESET","def show_warning(title, message, print_message=False):\n\n pass","def worker_warning_recorded(self, warning_message, when, nodeid, location):\n kwargs = dict(\n warning_message=warning_message, when=when, nodeid=nodeid, location=location\n )\n self.config.hook.pytest_warning_recorded.call_historic(kwargs=kwargs)","def test_normal_priority_warnings(self):\n self.__jenkins.contents = self.html\n self.assertEqual(4, self.__jenkins.nr_warnings(('job',), 'normal'))","def warning(self, message, *args, **kwargs):\n\n self.logger.warning(message, *args, **kwargs)","def warning(*args, noContext: bool=True, showLineNumber: bool=True, **kwargs)->None:\n pass","def __nextWarning(self):\n self.activeWindow().nextWarning()","def warning(self) -> 'outputs.AnyResponse':\n return pulumi.get(self, \"warning\")","def warning(message):\n env = Environment()\n env.loader = FileSystemLoader(osp.join(CONFDIR_PATH, 'templates'))\n warning = env.get_template(\"warning.html\")\n return warning.render(css_path=CSS_PATH, text=message)","def warn(msg):\n print(colored.yellow(\"[WARN]: {0}\".format(msg)))","def add_warning(self, msg):\n self._add_message(msg, self._warnings)","def warning(msg):\n log_msg(WARNING, msg)","def warn(text):\n print(colored(\"WARNING:\", \"yellow\", attrs=(\"bold\",)), colored(text))","def after_step(context, step):\n if context.config.userdata.getbool(\"debug\") and step.status == \"failed\":\n spost_mortem(step.exc_traceback)","def print_warning(*args):\n print_message_with_title('WARNING', *args, c1='y', c2='k', style='b')","def message_warning(msg, *a, **kwargs):\n return str(msg) + '\\n'","def _get_warning_message(self, target_class):\n\n message = \"%s failed to create a %s\" % (\n self.__class__.__name__,\n target_class.__name__\n )\n\n return message","def set_warning(warningTxt):\r\n if not core.does_item_exist(\"Warning##Warning\"):\r\n with simple.collapsing_header(\"Warning##Warning\", parent=\"##GroupStats\",\r\n default_open=True,\r\n closable=False,\r\n bullet=True):\r\n core.add_text(\"Warning\", default_value=warningTxt, color=(255, 255, 0, 255))","def print_warning(text: str):\n templateName = \"{:s}\"\n print(bcolors.WARNING + templateName.format(text) + bcolors.ENDC,\n flush=True)","def warning(message):\n global LAST_LOG\n LAST_LOG = message\n cprint('\\r[WRN] {0}'.format(message), 'yellow', file=sys.stderr)","def handle_warning(self, api, command):\n return self.handle_log(api, command, level=logging.WARNING)","def warning(self, *args, **kwargs): # real signature unknown\n pass","def _failed(self, msg):\n self.log(msg)\n self.result.passed = False\n self.result.add_error(msg)\n self.log(u\"Failed\")","def fail():\n sys.stdout.write('%s[ fail ]%s\\n' % (colors.RED, colors.RESET))","def on_warning(self, warning):\n log.warning(\"Received stall warning: %s\", warning)","def failure_cmd(self) -> str:\n return \"{} --enable=all -f -q {}\".format(\n self.conf.get_executable(), constants.ROOT_PATH + \"/data/cppcheck-152/trial-fail.cpp\"\n )","def report_step_progress(self, step):\n pass","def warning(self, tag, message, exc_info=False):\n \n self.log(logging.warning,tag, message, exc_info)","def print_warning(msg):\n print('WARNING - %s' % (msg))\n sys.exit(1)","def error(cls, message, *args, **kwargs):\n warnings.warn(\n cls.marker_theme.error() + cls.time() + cls.parse(message), *args, **kwargs\n )","def logwarning(self, msg):\n self.logger.warning(msg)","def warning(self, message, code=None):\n\n if code is None:\n code = ''\n self._add_message( message, self.WARNING, code=code )\n self.n_warnings += 1","def warning(self, value='', line_before=False):\n self.warnings += 1\n if line_before:\n print('\\n')\n print(Fore.YELLOW + '--- ' + value)","def warning(self, message: str) -> None:\n\n self.__add_log(self.WARNING, message)","def get_name(self) -> str:\n return \"write_jenkins_warnings\"","def warning(self) -> pulumi.Output[Optional['outputs.InfraAlertConditionWarning']]:\n return pulumi.get(self, \"warning\")","def ReportWarning(text):\n print('warning: %s' % text)","def print_failure(text):\n\n print(colorize(text, Colors.FAIL))","def print_warning_msgs():\n for err in TypeWarning.warnings:\n print err","def warn(self, message):\n return self.log(\"WARNING\", message)","def warn(self, msg):\n\n self(msg, WARN)","def warning(\n self,\n msg,\n color=None,\n light=None\n ) -> None:\n self.write(msg, level=logging.WARNING, color=color, light=light)"],"string":"[\n \"def _warn(self, warning=None):\\r\\n debug.err('Warning: %s' % warning)\\r\\n\\r\\n if core.FW_conf['settings'].TestRun.ExecutionMode == 'Leader' and warning != None:\\r\\n executeInFollower(\\\"self.warn('%s')\\\" % (warning,))\\r\\n\\r\\n if type(warning) != types.ListType:\\r\\n warning = [warning]\\r\\n\\r\\n self.result.addStepWarning(warning)\",\n \"def warning(self, warning):\\n pass\",\n \"def StepFailure(self):\\n return recipe_api.StepFailure\",\n \"def warning(self, msg, *args, **kwargs):\\n pass\",\n \"def warning(self, *args, **kwargs):\",\n \"def test_warning(self):\\n self.p.compute_termination_criteria = True\\n self.set_parameter_and_step(\\\"max_iter\\\", True, 5, \\\"ignore\\\")\",\n \"def warning ( self , message , *args , **kwargs ) :\\n return self.logger.warning ( message , *args , **kwargs )\",\n \"def warning(msg):\\n click.secho(msg, fg='yellow')\",\n \"def warning(self, *args, **kwargs):\\n self.msg(logging.WARNING, *args, **kwargs)\",\n \"def success_failure_color(self, evaluation):\\n return \\\"#60f979\\\" if evaluation.passes else \\\"#f96c60\\\"\",\n \"def warning(self, msg, transfers):\\n self.validation_exceptions.extend(self._create_exceptions(msg, transfers, ValidationType.WARNING))\",\n \"def notice(self, warning):\\n pass\",\n \"def warning(self, message):\\n return self.log(\\\"WARNING\\\", message)\",\n \"def fail(self, message):\\n logger.warning(message)\\n g.failed = True\",\n \"def warning(self, *lines):\\n if self.__debug_level >= DEBUG_LEVELS['warning']:\\n self.print_lines(self.colored(('magenta', 'bold'), lines))\",\n \"def warning(self) -> str:\\n return pulumi.get(self, \\\"warning\\\")\",\n \"def failure(self, message=''):\\n print(colored(message, 'red'))\",\n \"def set_warning_message(msg):\\n set_message(msg, TYPE_WARNING)\",\n \"def warning(self) -> Optional[pulumi.Input['AnyArgs']]:\\n return pulumi.get(self, \\\"warning\\\")\",\n \"def warning(self, message, *, preprocessor=None):\\n console.warning(message)\",\n \"async def warning(self, check, *, note=None):\\n return await self.mark(check, \\\"warning\\\", note=note)\",\n \"def warning(self, msg):\\r\\n self.logger.warning(msg)\",\n \"def warning(self, msg, *args):\\n if self.lvl<=logging.WARNING: return self._log(msg, *args)\",\n \"def WARNING(self, _strMessage=\\\"\\\"):\\n self.edLogging.WARNING(_strMessage)\",\n \"def warning(self, _strMessage=\\\"\\\"):\\n self.edLogging.warning(_strMessage)\",\n \"def warning(self, msg):\\n\\n self.logger.warning(msg)\",\n \"def report_step_progress(self, step):\\n dot_status = self.dot_status[step.status.name]\\n if step.status == Status.failed:\\n if (step.exception and\\n not isinstance(step.exception, AssertionError)):\\n # -- ISA-ERROR: Some Exception\\n dot_status = self.dot_status[\\\"error\\\"]\\n step.feature = self.current_feature\\n step.scenario = self.current_scenario\\n self.failures.append(step)\\n self.stream.write(dot_status)\\n self.stream.flush()\",\n \"def log_check_warnings(self):\\n pass\",\n \"def log_check_warnings(self):\\n pass\",\n \"def log_check_warnings(self):\\n pass\",\n \"def log_check_warnings(self):\\n pass\",\n \"def log_check_warnings(self):\\n pass\",\n \"def log_check_warnings(self):\\n pass\",\n \"def log_check_warnings(self):\\n pass\",\n \"def log_check_warnings(self):\\n pass\",\n \"def warning(self, msg, *args, **kwargs):\\n self._log(\\\"WARNING\\\", msg, args, kwargs)\",\n \"def warning(warning_message: str):\\n logger.warning(warning_message)\",\n \"def warnings(self) -> List[Error]:\",\n \"def warning(self, msg: str):\\n self._logger.warning(msg)\",\n \"def warn():\\n pass\",\n \"def warning(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"warning\\\")\",\n \"def log(failure):\\n return self._env.logger.warning('[ping] {}'.format(failure.getErrorMessage()))\",\n \"def render_revalidation_failure(self,failed_step): \\n return self.redirect(self.get_step_url(failed_step))\",\n \"def get_warning(self) -> List[str]:\\n return []\",\n \"def get_warning(self) -> List[str]:\\n return []\",\n \"def set_warning(warning):\\n impl.set_warning(**locals())\",\n \"def warning(self, msg):\\n self.__logger.warning(msg)\",\n \"def print_failure_msg(msg):\\n click.secho(msg, fg='red', file=sys.stderr)\",\n \"def warning(self, msg, *args, **kwargs):\\n self._logger.warning(msg, *args, **kwargs)\",\n \"def warning(self) -> Optional[str]:\\n return pulumi.get(self, \\\"warning\\\")\",\n \"def warning(self, msg, *args, **kwargs):\\n logger = self.__get_logger()\\n logger.warning(msg, *args, **kwargs)\",\n \"def warningglobal(self, *args, **kwargs):\\n return self.logger.log(logging.WARNING+1, *args, **kwargs)\",\n \"def warn(self, msg):\\n warning_msg = self._warning_color\\n warning_msg += \\\"[SHOULDER_WARNING] \\\" + msg\\n warning_msg += self._reset_color\\n self.logger.warning(warning_msg)\",\n \"def warning(msg):\\n log('WARNING', msg)\",\n \"def get_warning_text(self):\\n \\n to_print = []\\n if self['skipped_subchannel'] > 0:\\n to_print.append(\\\"Some event with large weight have been discarded.\\\"+\\\\\\n \\\" This happens %s times.\\\" % self['skipped_subchannel'])\\n if self['n_madloop_calls'] > 0:\\n fraction = self['exceptional_points']/float(self['n_madloop_calls'])\\n if fraction > 1.0e-4:\\n to_print.append(\\\"Some PS with numerical instability have been set \\\"+\\\\\\n \\\"to a zero matrix-element (%.3g%%)\\\" % (100.0*fraction))\\n \\n return ('\\\\n'.join(to_print)).replace(\\\"'\\\",\\\" \\\")\",\n \"def addFailure(self, test, err):\\n\\n super(ForceBalanceTestResult, self).addFailure(test,err)\\n self.logger.warning(\\\"\\\\r\\\\x1b[31;1m\\\" + \\\"FAIL\\\" + \\\"\\\\x1b[0m \\\" + test.shortDescription() + \\\"\\\\n\\\")\\n\\n errorMessage = self.buildErrorMessage(test, err)\\n\\n for line in errorMessage.splitlines():\\n self.logger.warning(\\\"\\\\t >\\\\t\\\" + line + \\\"\\\\n\\\")\",\n \"def worker_warning_captured(self, warning_message, when, item):\\n # This hook as been removed in pytest 7.1, and we can remove support once we only\\n # support pytest >=7.1.\\n kwargs = dict(warning_message=warning_message, when=when, item=item)\\n self.config.hook.pytest_warning_captured.call_historic(kwargs=kwargs)\",\n \"def warn(self, msg, line=None):\\n sys.stderr.write('warning: ' + self.gen_error(msg, line) + '\\\\n')\",\n \"def print_warning(string: str, begin: str = '') -> str:\\n return begin + Fore.RED + \\\"[WARNING] \\\" + string + Fore.RESET\",\n \"def show_warning(title, message, print_message=False):\\n\\n pass\",\n \"def worker_warning_recorded(self, warning_message, when, nodeid, location):\\n kwargs = dict(\\n warning_message=warning_message, when=when, nodeid=nodeid, location=location\\n )\\n self.config.hook.pytest_warning_recorded.call_historic(kwargs=kwargs)\",\n \"def test_normal_priority_warnings(self):\\n self.__jenkins.contents = self.html\\n self.assertEqual(4, self.__jenkins.nr_warnings(('job',), 'normal'))\",\n \"def warning(self, message, *args, **kwargs):\\n\\n self.logger.warning(message, *args, **kwargs)\",\n \"def warning(*args, noContext: bool=True, showLineNumber: bool=True, **kwargs)->None:\\n pass\",\n \"def __nextWarning(self):\\n self.activeWindow().nextWarning()\",\n \"def warning(self) -> 'outputs.AnyResponse':\\n return pulumi.get(self, \\\"warning\\\")\",\n \"def warning(message):\\n env = Environment()\\n env.loader = FileSystemLoader(osp.join(CONFDIR_PATH, 'templates'))\\n warning = env.get_template(\\\"warning.html\\\")\\n return warning.render(css_path=CSS_PATH, text=message)\",\n \"def warn(msg):\\n print(colored.yellow(\\\"[WARN]: {0}\\\".format(msg)))\",\n \"def add_warning(self, msg):\\n self._add_message(msg, self._warnings)\",\n \"def warning(msg):\\n log_msg(WARNING, msg)\",\n \"def warn(text):\\n print(colored(\\\"WARNING:\\\", \\\"yellow\\\", attrs=(\\\"bold\\\",)), colored(text))\",\n \"def after_step(context, step):\\n if context.config.userdata.getbool(\\\"debug\\\") and step.status == \\\"failed\\\":\\n spost_mortem(step.exc_traceback)\",\n \"def print_warning(*args):\\n print_message_with_title('WARNING', *args, c1='y', c2='k', style='b')\",\n \"def message_warning(msg, *a, **kwargs):\\n return str(msg) + '\\\\n'\",\n \"def _get_warning_message(self, target_class):\\n\\n message = \\\"%s failed to create a %s\\\" % (\\n self.__class__.__name__,\\n target_class.__name__\\n )\\n\\n return message\",\n \"def set_warning(warningTxt):\\r\\n if not core.does_item_exist(\\\"Warning##Warning\\\"):\\r\\n with simple.collapsing_header(\\\"Warning##Warning\\\", parent=\\\"##GroupStats\\\",\\r\\n default_open=True,\\r\\n closable=False,\\r\\n bullet=True):\\r\\n core.add_text(\\\"Warning\\\", default_value=warningTxt, color=(255, 255, 0, 255))\",\n \"def print_warning(text: str):\\n templateName = \\\"{:s}\\\"\\n print(bcolors.WARNING + templateName.format(text) + bcolors.ENDC,\\n flush=True)\",\n \"def warning(message):\\n global LAST_LOG\\n LAST_LOG = message\\n cprint('\\\\r[WRN] {0}'.format(message), 'yellow', file=sys.stderr)\",\n \"def handle_warning(self, api, command):\\n return self.handle_log(api, command, level=logging.WARNING)\",\n \"def warning(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def _failed(self, msg):\\n self.log(msg)\\n self.result.passed = False\\n self.result.add_error(msg)\\n self.log(u\\\"Failed\\\")\",\n \"def fail():\\n sys.stdout.write('%s[ fail ]%s\\\\n' % (colors.RED, colors.RESET))\",\n \"def on_warning(self, warning):\\n log.warning(\\\"Received stall warning: %s\\\", warning)\",\n \"def failure_cmd(self) -> str:\\n return \\\"{} --enable=all -f -q {}\\\".format(\\n self.conf.get_executable(), constants.ROOT_PATH + \\\"/data/cppcheck-152/trial-fail.cpp\\\"\\n )\",\n \"def report_step_progress(self, step):\\n pass\",\n \"def warning(self, tag, message, exc_info=False):\\n \\n self.log(logging.warning,tag, message, exc_info)\",\n \"def print_warning(msg):\\n print('WARNING - %s' % (msg))\\n sys.exit(1)\",\n \"def error(cls, message, *args, **kwargs):\\n warnings.warn(\\n cls.marker_theme.error() + cls.time() + cls.parse(message), *args, **kwargs\\n )\",\n \"def logwarning(self, msg):\\n self.logger.warning(msg)\",\n \"def warning(self, message, code=None):\\n\\n if code is None:\\n code = ''\\n self._add_message( message, self.WARNING, code=code )\\n self.n_warnings += 1\",\n \"def warning(self, value='', line_before=False):\\n self.warnings += 1\\n if line_before:\\n print('\\\\n')\\n print(Fore.YELLOW + '--- ' + value)\",\n \"def warning(self, message: str) -> None:\\n\\n self.__add_log(self.WARNING, message)\",\n \"def get_name(self) -> str:\\n return \\\"write_jenkins_warnings\\\"\",\n \"def warning(self) -> pulumi.Output[Optional['outputs.InfraAlertConditionWarning']]:\\n return pulumi.get(self, \\\"warning\\\")\",\n \"def ReportWarning(text):\\n print('warning: %s' % text)\",\n \"def print_failure(text):\\n\\n print(colorize(text, Colors.FAIL))\",\n \"def print_warning_msgs():\\n for err in TypeWarning.warnings:\\n print err\",\n \"def warn(self, message):\\n return self.log(\\\"WARNING\\\", message)\",\n \"def warn(self, msg):\\n\\n self(msg, WARN)\",\n \"def warning(\\n self,\\n msg,\\n color=None,\\n light=None\\n ) -> None:\\n self.write(msg, level=logging.WARNING, color=color, light=light)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.680333","0.6467354","0.6363371","0.6182617","0.6118767","0.60774654","0.6036392","0.6019372","0.6014528","0.6010554","0.5999503","0.5906176","0.5892281","0.5887475","0.5859568","0.5821751","0.5817227","0.5793164","0.5664179","0.5653461","0.5625123","0.56036913","0.55827785","0.55620575","0.55563116","0.5553998","0.5553989","0.55525285","0.55525285","0.55525285","0.55525285","0.55525285","0.55525285","0.55525285","0.55525285","0.55445296","0.5538642","0.5519302","0.5509324","0.5508511","0.54968333","0.54736036","0.54733646","0.5466505","0.5466505","0.54664433","0.5437949","0.5428915","0.5420023","0.5418672","0.5406106","0.5404654","0.5401399","0.5391984","0.5385157","0.5382221","0.5377263","0.5369732","0.53641987","0.53622323","0.5342601","0.5337679","0.5337286","0.53355074","0.5331821","0.5325915","0.5325645","0.5321884","0.53109646","0.53076696","0.53044534","0.5296953","0.52952737","0.52904564","0.5289009","0.52872247","0.5276126","0.5271471","0.52711165","0.52624005","0.52619725","0.52572846","0.52521104","0.52434146","0.52425337","0.5233112","0.52301854","0.52271414","0.5224837","0.5218483","0.521276","0.52087796","0.52010745","0.51992345","0.5195959","0.51934665","0.51890093","0.5181308","0.5180704","0.5171982"],"string":"[\n \"0.680333\",\n \"0.6467354\",\n \"0.6363371\",\n \"0.6182617\",\n \"0.6118767\",\n \"0.60774654\",\n \"0.6036392\",\n \"0.6019372\",\n \"0.6014528\",\n \"0.6010554\",\n \"0.5999503\",\n \"0.5906176\",\n \"0.5892281\",\n \"0.5887475\",\n \"0.5859568\",\n \"0.5821751\",\n \"0.5817227\",\n \"0.5793164\",\n \"0.5664179\",\n \"0.5653461\",\n \"0.5625123\",\n \"0.56036913\",\n \"0.55827785\",\n \"0.55620575\",\n \"0.55563116\",\n \"0.5553998\",\n \"0.5553989\",\n \"0.55525285\",\n \"0.55525285\",\n \"0.55525285\",\n \"0.55525285\",\n \"0.55525285\",\n \"0.55525285\",\n \"0.55525285\",\n \"0.55525285\",\n \"0.55445296\",\n \"0.5538642\",\n \"0.5519302\",\n \"0.5509324\",\n \"0.5508511\",\n \"0.54968333\",\n \"0.54736036\",\n \"0.54733646\",\n \"0.5466505\",\n \"0.5466505\",\n \"0.54664433\",\n \"0.5437949\",\n \"0.5428915\",\n \"0.5420023\",\n \"0.5418672\",\n \"0.5406106\",\n \"0.5404654\",\n \"0.5401399\",\n \"0.5391984\",\n \"0.5385157\",\n \"0.5382221\",\n \"0.5377263\",\n \"0.5369732\",\n \"0.53641987\",\n \"0.53622323\",\n \"0.5342601\",\n \"0.5337679\",\n \"0.5337286\",\n \"0.53355074\",\n \"0.5331821\",\n \"0.5325915\",\n \"0.5325645\",\n \"0.5321884\",\n \"0.53109646\",\n \"0.53076696\",\n \"0.53044534\",\n \"0.5296953\",\n \"0.52952737\",\n \"0.52904564\",\n \"0.5289009\",\n \"0.52872247\",\n \"0.5276126\",\n \"0.5271471\",\n \"0.52711165\",\n \"0.52624005\",\n \"0.52619725\",\n \"0.52572846\",\n \"0.52521104\",\n \"0.52434146\",\n \"0.52425337\",\n \"0.5233112\",\n \"0.52301854\",\n \"0.52271414\",\n \"0.5224837\",\n \"0.5218483\",\n \"0.521276\",\n \"0.52087796\",\n \"0.52010745\",\n \"0.51992345\",\n \"0.5195959\",\n \"0.51934665\",\n \"0.51890093\",\n \"0.5181308\",\n \"0.5180704\",\n \"0.5171982\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.792026"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8995,"cells":{"query":{"kind":"string","value":"InfraFailure is a subclass of StepFailure, and will translate to a purple build. This exception is raised from steps which are marked as `infra_step`s when they fail."},"document":{"kind":"string","value":"def InfraFailure(self):\n return recipe_api.InfraFailure"},"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 _identify_fail(failure):\n logger.warning(failure.getErrorMessage())\n logger.warning(\"Failed to setup & obtain identity\")\n return","def failure_exception(cls, state, exception):\r\n return PlatformMessage(method=\"__reply__\", kwargs={\"__result__\": \"fail\", \"state\": state, \"errcode\": -2,\r\n \"e\": exception})","def infrastructure_failure(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"infrastructure_failure\")","def infrastructure_failure(self) -> bool:\n return pulumi.get(self, \"infrastructure_failure\")","def raise_on_error(self):\n if not self._status.success:\n cls = UrlApi.InfraHTTPError if self._infra_step else UrlApi.HTTPError\n raise cls('HTTP status (%d)' % (self.status_code,), self)","def failure(self, cb: CircuitBreaker, exc: BaseException) -> None:","def StepFailure(self):\n return recipe_api.StepFailure","def handle_deploy_failure(self):\n step = \"Recovering From Deployment Error\"\n self.slacker.send_thread_reply(step)\n\n if self.has_down_time is True and self.migration_completed:\n return \"Skipped Automated Recovery: Requires Manual Intervention\"\n\n try:\n self.rollback_images()\n self.scale_up_deployments()\n error_handler_message = \"Successfully Rolled Back Deployment\"\n\n except Exception as e:\n error_handler_message = str(e)\n logging.error(error_handler_message)\n\n return error_handler_message","def report_recoverable(self, payload, exception, callback_url):\n capture_exception(exception)\n\n if not callback_url:\n return\n\n payload[\"failure\"] = {\"type\": \"RECOVERABLE_FAILURE\", \"message\": str(exception)}\n\n data = GraphExportCallbackError().load(payload)\n with retry() as session:\n session.post(callback_url, data=data)","def handle_unrecoverable_failure(self, node):\n if node.is_failed and node.exit_status < 400:\n self.report_error_handled(node, 'unrecoverable error, aborting...')\n return ProcessHandlerReport(True, self.exit_codes.ERROR_UNRECOVERABLE_FAILURE)","def on_saga_failure(self, failed_step: BaseStep, initial_failure_payload: dict):\n logger.info(f'Saga {self.saga_id} failed on \"{failed_step.name}\" step. \\n'\n f'Failure details: {initial_failure_payload}')","def failure_callback(self):\n error_filename = self.run_dir / \"eplusout.err\"\n if error_filename.exists():\n with open(error_filename, \"r\") as stderr:\n stderr_r = stderr.read()\n self.exception = EnergyPlusProcessError(\n cmd=self.cmd, stderr=stderr_r, idf=self.idf\n )\n self.cleanup_callback()","def failure(self) -> 'outputs.EndConditionResponse':\n return pulumi.get(self, \"failure\")","def _fail(self, exception):\n self.monitor_loop.stop()\n self._maintained.errback(exception)","def failure(self, input: str) -> enumFail:\n pass","def failure(cls, state, errcode=-1):\r\n return PlatformMessage(method=\"__reply__\", kwargs={\"__result__\": \"fail\", \"state\": state, \"errcode\": errcode})","def logFailure(failure, msg='Unhandled exception in deferred:'):\n logging.error('%s\\n%s', msg, failure.getTraceback())","def test_import_infra(self):\n project = Project.create()\n # Read an engine and check\n infra = import_infra(\"A320.xml\", \"engine\")\n self.assertEqual(len(infra.engines), 1)\n engine = infra.engines[0]\n self.assertEqual(engine.name, \"Machine 0\")\n self.assertEqual(engine.hauteur, 0.0)\n # Local frame:\n self.assertEqual(engine.position.x, 0.0)\n self.assertEqual(engine.position.y, 0.0)\n self.assertEqual(engine.position.z, 0.0)\n\n # Read a building and check\n infra = import_infra(\"Building.xml\", \"building\")\n self.assertEqual(len(infra.buildings), 1)\n building = infra.buildings[0]\n self.assertEqual(building.name, \"MyBuilding\")\n self.assertEqual(building.hauteur, 0.0)\n # Local frame:\n self.assertEqual(building.position.x, 0.0)\n self.assertEqual(building.position.y, 0.0)\n self.assertEqual(building.position.z, 0.0)\n\n # Check a no radiant building is refused:\n try:\n infra = import_infra(\"Building_no_radiant.xml\", \"building\")\n except:\n print(\"Ok, non radiant building is refused as expected.\")\n else:\n print(\"Non radiant building should be refused.\")\n sys.exit(-1)","def add_failure(self, task: Task, exception: Any) -> None: # noqa: DAR101\n super().add_failure(task, exception)\n self._add_summary(task, _TaskExitCode.FAIL)","def indicate_failure(self):\n pass","def inject_failure(self):\n # Inject a failure only if there's a process running\n self.BqLog(\"Starting failure injection\")\n while len(self.circQ) > 0 or (self.currentProc and self.currentProc.workLeft > 0):\n t = time_to_failure()\n self.BqLog(\"Inject the next failure after %d seconds\" % (t))\n if t == 0:\n continue\n yield self.env.timeout(t)\n if len(self.circQ) >= 0 and \\\n self.currentProc.workLeft > 0:\n # Only break the machine if it is currently computing,\n # and if current proc is not restarting\n self.BqLog(\"Injecting a failure in %s\" % (self.currentProc.name))\n self.numFailures += 1\n self.process.interrupt(cause=\"failure\")","def _logError(self, failure):\r\n try:\r\n failure.printTraceback()\r\n except:\r\n print('Could not print traceback of failure, print error '\r\n 'message instead:')\r\n print(failure.getErrorMessage())","def failure(self):\n self.logger.debug(\"Logging failure for %s\", self.key)\n self.failures = self.driver.failure(self.key)","def run(self, failure_info):\n signals = {}\n if not failure_info['failed'] or not failure_info['chromium_revision']:\n # Bail out if no failed step or no chromium revision.\n return signals\n\n # Bail out on infra failure\n if failure_info.get('failure_type') == failure_type.INFRA:\n return signals\n\n master_name = failure_info['master_name']\n builder_name = failure_info['builder_name']\n build_number = failure_info['build_number']\n\n for step_name in failure_info.get('failed_steps', []):\n if not waterfall_config.StepIsSupportedForMaster(step_name, master_name):\n # Bail out if the step is not supported.\n continue\n\n step = WfStep.Get(master_name, builder_name, build_number, step_name)\n if step and step.log_data:\n failure_log = step.log_data\n else:\n # TODO: do test-level analysis instead of step-level.\n # TODO: Use swarming test result instead of archived gtest results\n gtest_result = buildbot.GetGtestResultLog(\n master_name, builder_name, build_number, step_name)\n if gtest_result:\n failure_log = _GetReliableTestFailureLog(gtest_result)\n\n if gtest_result is None or failure_log == 'invalid':\n if not lock_util.WaitUntilDownloadAllowed(\n master_name): # pragma: no cover\n raise pipeline.Retry('Failed to pull log of step %s of master %s'\n % (step_name, master_name))\n try:\n failure_log = buildbot.GetStepLog(\n master_name, builder_name, build_number, step_name,\n self.HTTP_CLIENT)\n except ResponseTooLargeError: # pragma: no cover.\n logging.exception(\n 'Log of step \"%s\" is too large for urlfetch.', step_name)\n # If the stdio log of a step is too large, we don't want to pull it\n # again in next run, because that might lead to DDoS to the master.\n # TODO: Use archived stdio logs in Google Storage instead.\n failure_log = 'Stdio log is too large for urlfetch.'\n\n if not failure_log: # pragma: no cover\n raise pipeline.Retry('Failed to pull stdio of step %s of master %s'\n % (step_name, master_name))\n\n # Save step log in datastore and avoid downloading again during retry.\n if not step: # pragma: no cover\n step = WfStep.Create(\n master_name, builder_name, build_number, step_name)\n\n step.log_data = _ExtractStorablePortionOfLog(failure_log)\n\n try:\n step.put()\n except Exception as e: # pragma: no cover\n # Sometimes, the step log is too large to save in datastore.\n logging.exception(e)\n\n # TODO: save result in datastore?\n if step.isolated:\n try:\n json_failure_log = (\n json.loads(failure_log) if failure_log != 'flaky' else {})\n except ValueError: # pragma: no cover\n json_failure_log = {}\n logging.warning('failure_log %s is not valid JSON.' % failure_log)\n\n signals[step_name] = {\n 'tests': {}\n }\n step_signal = FailureSignal()\n\n for test_name, test_failure_log in json_failure_log.iteritems():\n signals[step_name]['tests'][test_name] = extractors.ExtractSignal(\n master_name, builder_name, step_name, test_name,\n base64.b64decode(test_failure_log)).ToDict()\n\n # Save signals in test failure log to step level.\n step_signal.MergeFrom(signals[step_name]['tests'][test_name])\n\n signals[step_name]['files'] = step_signal.files\n signals[step_name]['keywords'] = step_signal.keywords\n else:\n signals[step_name] = extractors.ExtractSignal(\n master_name, builder_name, step_name, None, failure_log).ToDict()\n\n return signals","def error_handler(self, failure):\n log.error(failure)","def on_failure(self, exc: BaseException) -> NoReturn:\n throw_new_error = self._breaker.open()\n\n if throw_new_error:\n error_msg = \"Trial call failed, circuit breaker opened\"\n raise CircuitBreakerError(error_msg).with_traceback(sys.exc_info()[2])\n else:\n raise exc","def fail(self, msg=None):\r\n raise self.failureException(msg)","def on_compensation_failure(self, initially_failed_step: BaseStep,\n initial_failure_payload: dict,\n compensation_failed_step: BaseStep,\n compensation_exception: BaseException):\n logger.info(f'Saga {self.saga_id} failed while compensating \"{compensation_failed_step.name}\" step.\\n'\n f'Error details: {format_exception_as_python_does(compensation_exception)} \\n \\n'\n f'Initial failure details: {initial_failure_payload}')","def failure_detail(self) -> 'outputs.FailureDetailResponse':\n return pulumi.get(self, \"failure_detail\")","def _authenticate_failed(self, e):\r\n if e.check(InvalidRequest):\r\n code = httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0]\r\n msg = e.getErrorMessage()\r\n elif e.check(UnauthorizedLogin):\r\n code = httpstatus.HTTP_STATUS_CODE_UNAUTHORIZED[0]\r\n msg = httpstatus.HTTP_STATUS_CODE_UNAUTHORIZED[1]\r\n else:\r\n e.printTraceback()\r\n code = httpstatus.HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR[0]\r\n msg = httpstatus.HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR[1]\r\n\r\n return Failure(HttpException(code, msg))","def detail_errorback(self, failure):\n\t\tglobal exitCode\n\t\tif hasattr(failure.value,'reasons') and any(reason.type is OpenSSL.SSL.Error for reason in failure.value.reasons):\n\t\t\tmessage = 'SSL error on ' + failure.request.url\n\t\t\tif sys.platform == 'win32' and not os.environ.get('SSL_CERT_FILE'):\n\t\t\t\tmessage += '''\\nOn Windows, you may have to set environment variable \"SSL_CERT_FILE\" to the location of root certificates bundle.\nYou may find the location by running\n> import certifi\n> certifi.where()'''\n\t\t\t# https://github.com/pyca/pyopenssl/issues/823#issuecomment-468675241 explains On Windows pyOpenSSL doesn't ship with any trust roots\n\t\t\t# https://twistedmatrix.com/documents/current/api/twisted.internet.ssl.html#platformTrust read SSL_CERT_FILE environment variable.\n\n\t\t\tself.logger.error(message)\n\t\t\texitCode = GooglePlayAdvancedSearch.Errors.sslErrorCode\n\t\t\traise CloseSpider('SSL error on ' + failure.request.url)","def report_unexpected_exception(self, *args, **kwargs):\n pass","def report_unrecoverable(self, payload, exception, callback_url):\n capture_exception(exception)\n\n if not callback_url:\n return\n\n payload[\"failure\"] = {\"type\": \"UNRECOVERABLE_FAILURE\", \"message\": str(exception)}\n\n data = GraphExportCallbackError().load(payload)\n with retry() as session:\n session.post(callback_url, data=data)","def test_add_failure(self):\n self.protocol.addFailure(\n self.test, pysubunit.RemoteError(compat._u(\"boo qux\")))\n self.assertEqual(\n self.io.getvalue(),\n compat._b(\n ('failure: %s [\\n' +\n _remote_exception_str + ': boo qux\\n]\\n')\n % self.test.id()))","def testFailureReturnsInternalErrorCode(self):\n body = dumps({'id': 100, 'jsonrpc': '2.0', 'method': 'fail',\n 'params': {}})\n headers = Headers({'Content-Length': [str(len(body))],\n 'Content-Type': ['application/json']})\n request = FakeRequest(headers=headers, body=body)\n resource = TestResource(None, None)\n result = yield resource.deferred_render_POST(request)\n response = loads(result)\n self.assertEqual({'code': JSONRPC_INTERNAL_ERROR,\n 'message': 'Internal error.'},\n response['error'])\n self.assertIn('exceptions.RuntimeError', self.log.getvalue())","def _failure_to_exception_tuple(failure):\n return (\n failure.value.__class__,\n failure.value,\n failure.getBriefTraceback(),\n )","def emergency_recover_states_from_failure():\n _emergency_state_check()\n _emergency_iobuf_extract()","def import_failure_reason(self) -> str:\n return pulumi.get(self, \"import_failure_reason\")","def failure_detail(self) -> Optional[pulumi.Input['FailureDetailArgs']]:\n return pulumi.get(self, \"failure_detail\")","def test_add_expected_failure(self):\n self.protocol.addExpectedFailure(\n self.test, pysubunit.RemoteError(compat._u(\"phwoar crikey\")))\n self.assertEqual(\n self.io.getvalue(),\n compat._b(('xfail: %s [\\n' +\n _remote_exception_str + \": phwoar crikey\\n\"\n \"]\\n\") % self.test.id()))","def failure(self, error):\n print \"comm failed Reason:\", error\n return error","def raise_for_failure(self) -> None:\n if not self.is_success():\n raise exc.ExecutionError(self)","def test_original_failure(self):\n try:\n 1 / 0\n except ZeroDivisionError:\n f = Failure()\n dr = EventualResult(fail(f), None)\n self.assertIdentical(dr.original_failure(), f)","def abort(self, message: str) -> None:\n message = f\"{Invocation.current.log} - {message}\"\n self.exception = StepException(message)\n global failure_aborts_build # pylint: disable=invalid-name\n global no_actions # pylint: disable=invalid-name\n if failure_aborts_build.value and not no_actions.value:\n no_additional_complaints()\n raise self.exception","def testFailure():\n run(\"chariot-me\") #Start management-engine without initial deplflag\n egress()","def inject_failure(self):\n while len(self.circQ):\n yield self.env.timeout(time_to_failure())\n if len(self.circQ) > 0 and \\\n not self.currentProc.broken and \\\n self.currentProc.workLeft > 0:\n # Only break the machine if it is currently computing,\n # and if current proc is not restarting\n # TODO: Allow errors to be thrown while restarting\n self.BqLog(\"Injecting a failure in %s\" % (self.currentProc.name))\n self.numFailures += 1\n self.process.interrupt(cause=\"failure\")","def on_failure(self, exc: BaseException) -> None:","def end_failure(self, error: Exception):\n if self.__tracer is not None:\n elapsed = (datetime.datetime.now().timestamp() * 1000) - self.__start\n self.__tracer.failure(self.__correlation_id, self.__component, self.__operation, error, round(elapsed))","def failure(self, error, rc, msg):\n self.module.fail_json(msg=msg, rc=rc, err=error)","def test_fails(self):\n raise FoolishError(\"I am a broken test\")","def test_failure(self):\n\n @sync_performer\n def fail(dispatcher, intent):\n raise intent\n\n dispatcher = lambda _: fail\n self.assertThat(\n sync_perform(\n dispatcher, Effect(ValueError(\"oh dear\")).on(error=lambda e: e)\n ),\n MatchesException(ValueError(\"oh dear\")),\n )","def _create_failure_entry(self):\r\n # view task entry for task failure\r\n progress = {'message': TEST_FAILURE_MESSAGE,\r\n 'exception': TEST_FAILURE_EXCEPTION,\r\n }\r\n return self._create_entry(task_state=FAILURE, task_output=progress)","def _get_failure_from_exception(\n e: BaseException) -> TransactionResult.Failure:\n\n try:\n if isinstance(e, IconServiceBaseException):\n if e.code == ExceptionCode.SCORE_ERROR or isinstance(e, ScoreErrorException):\n Logger.warning(e.message, ICON_SERVICE_LOG_TAG)\n else:\n Logger.exception(e.message, ICON_SERVICE_LOG_TAG)\n\n code = int(e.code)\n message = str(e.message)\n else:\n Logger.exception(e, ICON_SERVICE_LOG_TAG)\n Logger.error(e, ICON_SERVICE_LOG_TAG)\n\n code: int = ExceptionCode.SERVER_ERROR.value\n message = str(e)\n except:\n code: int = ExceptionCode.SERVER_ERROR.value\n message = 'Invalid exception: code or message is invalid'\n\n return TransactionResult.Failure(code, message)","def failure(self, message=''):\n print(colored(message, 'red'))","def tc_fail(self, msg):\n self.recover()\n tc_fail(msg)","def add_failure(self, test, exception_string):\n failure = E.failure(exception_string)\n self._add_test_report(test, result_description=failure,\n error=False, failure=True)","def resolve_failure(self):\n\t\tpass","def addFailure(self, test, err):\n\n super(ForceBalanceTestResult, self).addFailure(test,err)\n self.logger.warning(\"\\r\\x1b[31;1m\" + \"FAIL\" + \"\\x1b[0m \" + test.shortDescription() + \"\\n\")\n\n errorMessage = self.buildErrorMessage(test, err)\n\n for line in errorMessage.splitlines():\n self.logger.warning(\"\\t >\\t\" + line + \"\\n\")","def test_launch_failures_hw(self):\n self.test_launch_failures()","def extraction_failure(self, extraction_failure):\n self._extraction_failure = extraction_failure","def _adapt_to_exception_tuple(failure):\n if isinstance(failure, Failure):\n return _failure_to_exception_tuple(failure)\n return failure","def diagnostic_self_test_fail(reason='no errors found', additional_text='no errors found', severity_level='error'):\n\n SysTools.notify.error(RPD_EVENT_CONNECTIVITY_DIAGNOSTIC_SELF_TEST_FAIL[0],\n reason, additional_text, severity_level)","def testRunException(self):\n class TestError(Exception):\n \"\"\"Unique test exception\"\"\"\n\n perform_mock = self.PatchObject(generic_stages.BuilderStage, 'PerformStage')\n perform_mock.side_effect = TestError('fail!')\n\n stage = self.ConstructStage()\n results_lib.Results.Clear()\n self.assertRaises(failures_lib.StepFailure, self._RunCapture, stage)\n\n results = results_lib.Results.Get()[0]\n self.assertTrue(isinstance(results.result, TestError))\n self.assertEqual(str(results.result), 'fail!')\n self.mock_cidb.StartBuildStage.assert_called_once_with(\n DEFAULT_BUILD_STAGE_ID)\n self.mock_cidb.FinishBuildStage.assert_called_once_with(\n DEFAULT_BUILD_STAGE_ID,\n constants.BUILDER_STATUS_FAILED)","def make_expected_failure_message(todo, failure):\n exc_type, exc_value, exc_traceback = _adapt_to_exception_tuple(failure)\n return EXPECTED_FAILURE(\n todo=todo,\n exception=exc_type,\n reason=exc_value,\n traceback=exc_traceback,\n )","def fail(self):\n self.cleanup()\n self.runner.report_job_fail(self.id)","def test_failure_result(self):\n dr = EventualResult(fail(RuntimeError()), None)\n self.assertRaises(RuntimeError, dr.wait, 0.1)","def failure(self, result):\r\n raise NotImplementedError","def _reportError(self, failure):\r\n self._connection.reportError(failure.getErrorMessage())","def log(failure):\n return self._env.logger.warning('[ping] {}'.format(failure.getErrorMessage()))","def fail(msg):\n\n # Not sure if simply raising the exception is clearer.\n raise CommandFailed(msg)","def on_failure(self, exc: BaseException) -> None:\n if self._breaker._state_storage.counter >= self._breaker.fail_max:\n throw_new_error = self._breaker.open()\n\n if throw_new_error:\n error_msg = \"Failures threshold reached, circuit breaker opened\"\n raise CircuitBreakerError(error_msg).with_traceback(sys.exc_info()[2])\n else:\n raise exc","def on_trial_error(self, trial_runner, trial):\n\n raise NotImplementedError","def test_fail(make_runner: Callable[..., TargetFunctionRunner]) -> None:\n runner = make_runner(target_failed, use_instances=True)\n run_info = TrialInfo(config=2, instance=\"test\", seed=0, budget=0.0)\n\n runner.submit_trial(run_info)\n run_info, run_value = next(runner.iter_results())\n\n # Make sure the traceback message is included\n assert \"traceback\" in run_value.additional_info\n assert \"RuntimeError\" in run_value.additional_info[\"traceback\"]","def repr_failure(self, excinfo):\n if isinstance(excinfo.value, NbCellError):\n msg_items = [bcolors.FAIL + \"Notebook cell execution failed\" + bcolors.ENDC]\n formatstring = bcolors.OKBLUE + \"Cell %d: %s\\n\\n\" + \\\n \"Input:\\n\" + bcolors.ENDC + \"%s\\n\\n\" + \\\n bcolors.OKBLUE + \"Traceback:%s\" + bcolors.ENDC\n msg_items.append(formatstring % excinfo.value.args)\n return \"\\n\".join(msg_items)\n else:\n return \"pytest plugin exception: %s\" % str(excinfo.value)","def _handle_failure(self, proc, test_case):\n if proc.returncode != 0:\n print('ERROR: Test execution failed: {}'.format(test_case.get_name()))\n stdout, stderr = proc.communicate()\n raise TestCaseFailure('Test case {} failed. stdout: {}, stderr: {}, '\n 'return code: {}.'.format(test_case.get_name(),\n stdout, stderr,\n proc.returncode))","def unexpected_error(self, exception):","def fail(self, failure):\n if self._state == self.State.transfering_no_waiters:\n self._get_deferreds = None\n self._free_deferreds = None\n self._state = self.State.freed\n \n elif self._state == self.State.transfering_waiters:\n for d in self._get_deferreds:\n d.errback(failure)\n self._get_deferreds = None\n self._free_deferreds = None\n self._state = self.State.freed\n \n elif self._state == self.State.transfering_waiters_free:\n for d in self._get_deferreds:\n d.errback(failure)\n self._get_deferreds = None\n self._state = self.State.freed\n for d in self._free_deferreds:\n d.callback(None)\n self._free_deferreds = None\n \n elif self._state == self.State.stored:\n raise ValueError(\"Attempt to set already set value\")\n \n elif self._state == self.State.freed:\n raise ValueError(\"This value instance should not be used anymore\")\n \n else:\n raise ValueError(\"Invalid state\")","def addFailure(self, result):\n result.addFailure(self, (Exception, Exception(), None))\n # Since TAP will not provide assertion data, clean up the assertion\n # section so it is not so spaced out.\n test, err = result.failures[-1]\n result.failures[-1] = (test, \"\")","def _response_failure(self, failure, msgID):\r\n if not self._status:\r\n # Can not help it if the response takes some time and in the mean\r\n # time the interface is disabled; therefore, don't raise an error\r\n # instead just skip sending the response\r\n return\r\n\r\n # TODO: Return something useful to the cloud here!\r\n print('Service call failed.')","def _handle_error(self, failure, item, spider):\n # do nothing, just log\n log.err(failure)","def TestCaseDidFail(self, request, context):\n LOGGER.info('Received request for TestCaseDidFail %s', request)\n for plugin in self.plugins:\n plugin.test_case_did_fail(request)\n return test_plugin_service_pb2.TestCaseDidFailResponse()","def test_internal_server_error_beomces_remote_initiated_server_error(self):\n msg = \"The server has encountered an error\"\n error = ErrorParser().process_all(msg)\n assert isinstance(error, RemoteInitiatedServerError)\n eq_(BibliothecaAPI.SERVICE_NAME, error.service_name)\n eq_(502, error.status_code)\n eq_(msg, error.message)\n doc = error.as_problem_detail_document()\n eq_(502, doc.status_code)\n eq_(\"Integration error communicating with 3M\", doc.detail)","def fail(self, exception):\n with self._lock:\n self._termination_manager.abort(self._local_failure)\n self._transmission_manager.abort(self._local_failure)\n self._ingestion_manager.abort()\n self._expiration_manager.abort()","def renderHTTP_exception(request, failure):","def device_stats_collection_failure_reason(self, device_stats_collection_failure_reason):\n\n self._device_stats_collection_failure_reason = device_stats_collection_failure_reason","def test_ComputerPartition_error_HostingResource_DeliveredState(self):\n sequence_list = SequenceList()\n sequence_string = self.prepare_stopped_computer_partition_sequence_string + '\\\n SlapLoginCurrentComputer \\\n CheckSuccessComputerPartitionErrorCall \\\n Tic \\\n SlapLogout \\\n \\\n LoginDefaultUser \\\n CheckSalePackingListErrorText \\\n Logout \\\n LoginERP5TypeTestCase \\\n CheckSiteConsistency \\\n Logout \\\n '\n sequence_list.addSequenceString(sequence_string)\n sequence_list.play(self)","def answerFailure( self, reason ):\n\t\tlog.warn( \n\t\t\t\"\"\"Unable to answer channel %r: %s\"\"\", \n\t\t\tself.agi.variables['agi_channel'], reason.getTraceback(),\n\t\t)\n\t\tself.agi.finish()","def fail(self, cause = None, annotations = {}):\n self.set_outcome(Result.FAIL, cause, annotations)","def Raise( self, Message ):\r\n UsbBootLoaderDriverError( Message )","def _message_failed_job(self):\n self.ensure_one()\n return _(\"Something bad happened during the execution of the job. \"\n \"More details in the 'Exception Information' section.\")","def _handle_tracker_error(self, failure):\n\n # Log the error\n logging.error(\"An error occured while running the '\"+self._service_id+\"' service, the service has been stopped: '\"+\n failure.getErrorMessage()+\"'\")\n # TODO: Log the error to the driver's state dictionary.\n\n # Stop the event loop just incase it's still running\n if self._tracking_update_loop.running:\n self._tracking_update_loop.stop()\n\n return False","def test_remote_authentication_failed_becomes_remote_initiated_server_error(self):\n msg=self.sample_data(\"error_authentication_failed.xml\")\n error = ErrorParser().process_all(msg)\n assert isinstance(error, RemoteInitiatedServerError)\n eq_(BibliothecaAPI.SERVICE_NAME, error.service_name)\n eq_(\"Authentication failed\", error.message)","def _get_error_type(self):\n\n error_type = AladdinUserFaultType.Unknown\n if not self.error_msg:\n return error_type.value\n\n error_msg = self.error_msg.lower()\n if 'unrecognized' in error_msg:\n error_type = AladdinUserFaultType.UnrecognizedArguments\n elif 'expected one argument' in error_msg or 'expected at least one argument' in error_msg \\\n or 'value required' in error_msg:\n error_type = AladdinUserFaultType.ExpectedArgument\n elif 'misspelled' in error_msg:\n error_type = AladdinUserFaultType.UnknownSubcommand\n elif 'arguments are required' in error_msg or 'argument required' in error_msg:\n error_type = AladdinUserFaultType.MissingRequiredParameters\n if '_subcommand' in error_msg:\n error_type = AladdinUserFaultType.MissingRequiredSubcommand\n elif '_command_package' in error_msg:\n error_type = AladdinUserFaultType.UnableToParseCommandInput\n elif 'not found' in error_msg or 'could not be found' in error_msg \\\n or 'resource not found' in error_msg:\n error_type = AladdinUserFaultType.AzureResourceNotFound\n if 'storage_account' in error_msg or 'storage account' in error_msg:\n error_type = AladdinUserFaultType.StorageAccountNotFound\n elif 'resource_group' in error_msg or 'resource group' in error_msg:\n error_type = AladdinUserFaultType.ResourceGroupNotFound\n elif 'pattern' in error_msg or 'is not a valid value' in error_msg or 'invalid' in error_msg:\n error_type = AladdinUserFaultType.InvalidParameterValue\n if 'jmespath_type' in error_msg:\n error_type = AladdinUserFaultType.InvalidJMESPathQuery\n elif 'datetime_type' in error_msg:\n error_type = AladdinUserFaultType.InvalidDateTimeArgumentValue\n elif '--output' in error_msg:\n error_type = AladdinUserFaultType.InvalidOutputType\n elif 'resource_group' in error_msg:\n error_type = AladdinUserFaultType.InvalidResourceGroupName\n elif 'storage_account' in error_msg:\n error_type = AladdinUserFaultType.InvalidAccountName\n elif \"validation error\" in error_msg:\n error_type = AladdinUserFaultType.ValidationError\n\n return error_type.value","def raise_fail(*args, **kwargs):\n raise Exception(\"oops\")","def test_ComputerPartition_error_HostingResource_StoppedState(self):\n sequence_list = SequenceList()\n sequence_string = self.prepare_stop_requested_computer_partition_sequence_string + '\\\n SlapLoginCurrentComputer \\\n CheckSuccessComputerPartitionErrorCall \\\n Tic \\\n SlapLogout \\\n \\\n LoginDefaultUser \\\n CheckSalePackingListErrorText \\\n Logout \\\n LoginERP5TypeTestCase \\\n CheckSiteConsistency \\\n Logout \\\n '\n sequence_list.addSequenceString(sequence_string)\n sequence_list.play(self)","def failure(self, validation_failure):\n \n self.request.response.status_int = 400\n return validation_failure.error.asdict()","def test_failed_processing(self):\n # setup\n ledger_api_dialogue, fipa_dialogue = self._setup_fipa_ledger_api_dialogues(self)\n\n self.transaction_behaviour.timedout.add(ledger_api_dialogue.dialogue_label)\n\n # operation\n with patch.object(self.logger, \"log\") as mock_logger:\n self.transaction_behaviour.failed_processing(ledger_api_dialogue)\n\n # after\n self.assert_quantity_in_outbox(0)\n\n # finish_processing\n assert self.transaction_behaviour.timedout == set()\n\n mock_logger.assert_any_call(\n logging.DEBUG,\n f\"Timeout dialogue in transaction processing: {ledger_api_dialogue}\",\n )\n\n # failed_processing\n assert fipa_dialogue in self.transaction_behaviour.waiting","def failure(self, error):\n \n self.request.response.status_int = 400\n return None","def raise_step_error(self, error: Exception, step: str):\n error_message = \"{}\\nFailed: Error={}\".format(step, str(error))\n logging.error(error_message)\n self.slacker.send_thread_reply(error_message)\n raise Exception(error_message)","def _test_run_with_failure(self, task_class, expected_message):\r\n task_entry = self._create_input_entry()\r\n self.define_option_problem(PROBLEM_URL_NAME)\r\n with self.assertRaises(TestTaskFailure):\r\n self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id, expected_message)\r\n # compare with entry in table:\r\n entry = InstructorTask.objects.get(id=task_entry.id)\r\n self.assertEquals(entry.task_state, FAILURE)\r\n output = json.loads(entry.task_output)\r\n self.assertEquals(output['exception'], 'TestTaskFailure')\r\n self.assertEquals(output['message'], expected_message)"],"string":"[\n \"def _identify_fail(failure):\\n logger.warning(failure.getErrorMessage())\\n logger.warning(\\\"Failed to setup & obtain identity\\\")\\n return\",\n \"def failure_exception(cls, state, exception):\\r\\n return PlatformMessage(method=\\\"__reply__\\\", kwargs={\\\"__result__\\\": \\\"fail\\\", \\\"state\\\": state, \\\"errcode\\\": -2,\\r\\n \\\"e\\\": exception})\",\n \"def infrastructure_failure(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"infrastructure_failure\\\")\",\n \"def infrastructure_failure(self) -> bool:\\n return pulumi.get(self, \\\"infrastructure_failure\\\")\",\n \"def raise_on_error(self):\\n if not self._status.success:\\n cls = UrlApi.InfraHTTPError if self._infra_step else UrlApi.HTTPError\\n raise cls('HTTP status (%d)' % (self.status_code,), self)\",\n \"def failure(self, cb: CircuitBreaker, exc: BaseException) -> None:\",\n \"def StepFailure(self):\\n return recipe_api.StepFailure\",\n \"def handle_deploy_failure(self):\\n step = \\\"Recovering From Deployment Error\\\"\\n self.slacker.send_thread_reply(step)\\n\\n if self.has_down_time is True and self.migration_completed:\\n return \\\"Skipped Automated Recovery: Requires Manual Intervention\\\"\\n\\n try:\\n self.rollback_images()\\n self.scale_up_deployments()\\n error_handler_message = \\\"Successfully Rolled Back Deployment\\\"\\n\\n except Exception as e:\\n error_handler_message = str(e)\\n logging.error(error_handler_message)\\n\\n return error_handler_message\",\n \"def report_recoverable(self, payload, exception, callback_url):\\n capture_exception(exception)\\n\\n if not callback_url:\\n return\\n\\n payload[\\\"failure\\\"] = {\\\"type\\\": \\\"RECOVERABLE_FAILURE\\\", \\\"message\\\": str(exception)}\\n\\n data = GraphExportCallbackError().load(payload)\\n with retry() as session:\\n session.post(callback_url, data=data)\",\n \"def handle_unrecoverable_failure(self, node):\\n if node.is_failed and node.exit_status < 400:\\n self.report_error_handled(node, 'unrecoverable error, aborting...')\\n return ProcessHandlerReport(True, self.exit_codes.ERROR_UNRECOVERABLE_FAILURE)\",\n \"def on_saga_failure(self, failed_step: BaseStep, initial_failure_payload: dict):\\n logger.info(f'Saga {self.saga_id} failed on \\\"{failed_step.name}\\\" step. \\\\n'\\n f'Failure details: {initial_failure_payload}')\",\n \"def failure_callback(self):\\n error_filename = self.run_dir / \\\"eplusout.err\\\"\\n if error_filename.exists():\\n with open(error_filename, \\\"r\\\") as stderr:\\n stderr_r = stderr.read()\\n self.exception = EnergyPlusProcessError(\\n cmd=self.cmd, stderr=stderr_r, idf=self.idf\\n )\\n self.cleanup_callback()\",\n \"def failure(self) -> 'outputs.EndConditionResponse':\\n return pulumi.get(self, \\\"failure\\\")\",\n \"def _fail(self, exception):\\n self.monitor_loop.stop()\\n self._maintained.errback(exception)\",\n \"def failure(self, input: str) -> enumFail:\\n pass\",\n \"def failure(cls, state, errcode=-1):\\r\\n return PlatformMessage(method=\\\"__reply__\\\", kwargs={\\\"__result__\\\": \\\"fail\\\", \\\"state\\\": state, \\\"errcode\\\": errcode})\",\n \"def logFailure(failure, msg='Unhandled exception in deferred:'):\\n logging.error('%s\\\\n%s', msg, failure.getTraceback())\",\n \"def test_import_infra(self):\\n project = Project.create()\\n # Read an engine and check\\n infra = import_infra(\\\"A320.xml\\\", \\\"engine\\\")\\n self.assertEqual(len(infra.engines), 1)\\n engine = infra.engines[0]\\n self.assertEqual(engine.name, \\\"Machine 0\\\")\\n self.assertEqual(engine.hauteur, 0.0)\\n # Local frame:\\n self.assertEqual(engine.position.x, 0.0)\\n self.assertEqual(engine.position.y, 0.0)\\n self.assertEqual(engine.position.z, 0.0)\\n\\n # Read a building and check\\n infra = import_infra(\\\"Building.xml\\\", \\\"building\\\")\\n self.assertEqual(len(infra.buildings), 1)\\n building = infra.buildings[0]\\n self.assertEqual(building.name, \\\"MyBuilding\\\")\\n self.assertEqual(building.hauteur, 0.0)\\n # Local frame:\\n self.assertEqual(building.position.x, 0.0)\\n self.assertEqual(building.position.y, 0.0)\\n self.assertEqual(building.position.z, 0.0)\\n\\n # Check a no radiant building is refused:\\n try:\\n infra = import_infra(\\\"Building_no_radiant.xml\\\", \\\"building\\\")\\n except:\\n print(\\\"Ok, non radiant building is refused as expected.\\\")\\n else:\\n print(\\\"Non radiant building should be refused.\\\")\\n sys.exit(-1)\",\n \"def add_failure(self, task: Task, exception: Any) -> None: # noqa: DAR101\\n super().add_failure(task, exception)\\n self._add_summary(task, _TaskExitCode.FAIL)\",\n \"def indicate_failure(self):\\n pass\",\n \"def inject_failure(self):\\n # Inject a failure only if there's a process running\\n self.BqLog(\\\"Starting failure injection\\\")\\n while len(self.circQ) > 0 or (self.currentProc and self.currentProc.workLeft > 0):\\n t = time_to_failure()\\n self.BqLog(\\\"Inject the next failure after %d seconds\\\" % (t))\\n if t == 0:\\n continue\\n yield self.env.timeout(t)\\n if len(self.circQ) >= 0 and \\\\\\n self.currentProc.workLeft > 0:\\n # Only break the machine if it is currently computing,\\n # and if current proc is not restarting\\n self.BqLog(\\\"Injecting a failure in %s\\\" % (self.currentProc.name))\\n self.numFailures += 1\\n self.process.interrupt(cause=\\\"failure\\\")\",\n \"def _logError(self, failure):\\r\\n try:\\r\\n failure.printTraceback()\\r\\n except:\\r\\n print('Could not print traceback of failure, print error '\\r\\n 'message instead:')\\r\\n print(failure.getErrorMessage())\",\n \"def failure(self):\\n self.logger.debug(\\\"Logging failure for %s\\\", self.key)\\n self.failures = self.driver.failure(self.key)\",\n \"def run(self, failure_info):\\n signals = {}\\n if not failure_info['failed'] or not failure_info['chromium_revision']:\\n # Bail out if no failed step or no chromium revision.\\n return signals\\n\\n # Bail out on infra failure\\n if failure_info.get('failure_type') == failure_type.INFRA:\\n return signals\\n\\n master_name = failure_info['master_name']\\n builder_name = failure_info['builder_name']\\n build_number = failure_info['build_number']\\n\\n for step_name in failure_info.get('failed_steps', []):\\n if not waterfall_config.StepIsSupportedForMaster(step_name, master_name):\\n # Bail out if the step is not supported.\\n continue\\n\\n step = WfStep.Get(master_name, builder_name, build_number, step_name)\\n if step and step.log_data:\\n failure_log = step.log_data\\n else:\\n # TODO: do test-level analysis instead of step-level.\\n # TODO: Use swarming test result instead of archived gtest results\\n gtest_result = buildbot.GetGtestResultLog(\\n master_name, builder_name, build_number, step_name)\\n if gtest_result:\\n failure_log = _GetReliableTestFailureLog(gtest_result)\\n\\n if gtest_result is None or failure_log == 'invalid':\\n if not lock_util.WaitUntilDownloadAllowed(\\n master_name): # pragma: no cover\\n raise pipeline.Retry('Failed to pull log of step %s of master %s'\\n % (step_name, master_name))\\n try:\\n failure_log = buildbot.GetStepLog(\\n master_name, builder_name, build_number, step_name,\\n self.HTTP_CLIENT)\\n except ResponseTooLargeError: # pragma: no cover.\\n logging.exception(\\n 'Log of step \\\"%s\\\" is too large for urlfetch.', step_name)\\n # If the stdio log of a step is too large, we don't want to pull it\\n # again in next run, because that might lead to DDoS to the master.\\n # TODO: Use archived stdio logs in Google Storage instead.\\n failure_log = 'Stdio log is too large for urlfetch.'\\n\\n if not failure_log: # pragma: no cover\\n raise pipeline.Retry('Failed to pull stdio of step %s of master %s'\\n % (step_name, master_name))\\n\\n # Save step log in datastore and avoid downloading again during retry.\\n if not step: # pragma: no cover\\n step = WfStep.Create(\\n master_name, builder_name, build_number, step_name)\\n\\n step.log_data = _ExtractStorablePortionOfLog(failure_log)\\n\\n try:\\n step.put()\\n except Exception as e: # pragma: no cover\\n # Sometimes, the step log is too large to save in datastore.\\n logging.exception(e)\\n\\n # TODO: save result in datastore?\\n if step.isolated:\\n try:\\n json_failure_log = (\\n json.loads(failure_log) if failure_log != 'flaky' else {})\\n except ValueError: # pragma: no cover\\n json_failure_log = {}\\n logging.warning('failure_log %s is not valid JSON.' % failure_log)\\n\\n signals[step_name] = {\\n 'tests': {}\\n }\\n step_signal = FailureSignal()\\n\\n for test_name, test_failure_log in json_failure_log.iteritems():\\n signals[step_name]['tests'][test_name] = extractors.ExtractSignal(\\n master_name, builder_name, step_name, test_name,\\n base64.b64decode(test_failure_log)).ToDict()\\n\\n # Save signals in test failure log to step level.\\n step_signal.MergeFrom(signals[step_name]['tests'][test_name])\\n\\n signals[step_name]['files'] = step_signal.files\\n signals[step_name]['keywords'] = step_signal.keywords\\n else:\\n signals[step_name] = extractors.ExtractSignal(\\n master_name, builder_name, step_name, None, failure_log).ToDict()\\n\\n return signals\",\n \"def error_handler(self, failure):\\n log.error(failure)\",\n \"def on_failure(self, exc: BaseException) -> NoReturn:\\n throw_new_error = self._breaker.open()\\n\\n if throw_new_error:\\n error_msg = \\\"Trial call failed, circuit breaker opened\\\"\\n raise CircuitBreakerError(error_msg).with_traceback(sys.exc_info()[2])\\n else:\\n raise exc\",\n \"def fail(self, msg=None):\\r\\n raise self.failureException(msg)\",\n \"def on_compensation_failure(self, initially_failed_step: BaseStep,\\n initial_failure_payload: dict,\\n compensation_failed_step: BaseStep,\\n compensation_exception: BaseException):\\n logger.info(f'Saga {self.saga_id} failed while compensating \\\"{compensation_failed_step.name}\\\" step.\\\\n'\\n f'Error details: {format_exception_as_python_does(compensation_exception)} \\\\n \\\\n'\\n f'Initial failure details: {initial_failure_payload}')\",\n \"def failure_detail(self) -> 'outputs.FailureDetailResponse':\\n return pulumi.get(self, \\\"failure_detail\\\")\",\n \"def _authenticate_failed(self, e):\\r\\n if e.check(InvalidRequest):\\r\\n code = httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0]\\r\\n msg = e.getErrorMessage()\\r\\n elif e.check(UnauthorizedLogin):\\r\\n code = httpstatus.HTTP_STATUS_CODE_UNAUTHORIZED[0]\\r\\n msg = httpstatus.HTTP_STATUS_CODE_UNAUTHORIZED[1]\\r\\n else:\\r\\n e.printTraceback()\\r\\n code = httpstatus.HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR[0]\\r\\n msg = httpstatus.HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR[1]\\r\\n\\r\\n return Failure(HttpException(code, msg))\",\n \"def detail_errorback(self, failure):\\n\\t\\tglobal exitCode\\n\\t\\tif hasattr(failure.value,'reasons') and any(reason.type is OpenSSL.SSL.Error for reason in failure.value.reasons):\\n\\t\\t\\tmessage = 'SSL error on ' + failure.request.url\\n\\t\\t\\tif sys.platform == 'win32' and not os.environ.get('SSL_CERT_FILE'):\\n\\t\\t\\t\\tmessage += '''\\\\nOn Windows, you may have to set environment variable \\\"SSL_CERT_FILE\\\" to the location of root certificates bundle.\\nYou may find the location by running\\n> import certifi\\n> certifi.where()'''\\n\\t\\t\\t# https://github.com/pyca/pyopenssl/issues/823#issuecomment-468675241 explains On Windows pyOpenSSL doesn't ship with any trust roots\\n\\t\\t\\t# https://twistedmatrix.com/documents/current/api/twisted.internet.ssl.html#platformTrust read SSL_CERT_FILE environment variable.\\n\\n\\t\\t\\tself.logger.error(message)\\n\\t\\t\\texitCode = GooglePlayAdvancedSearch.Errors.sslErrorCode\\n\\t\\t\\traise CloseSpider('SSL error on ' + failure.request.url)\",\n \"def report_unexpected_exception(self, *args, **kwargs):\\n pass\",\n \"def report_unrecoverable(self, payload, exception, callback_url):\\n capture_exception(exception)\\n\\n if not callback_url:\\n return\\n\\n payload[\\\"failure\\\"] = {\\\"type\\\": \\\"UNRECOVERABLE_FAILURE\\\", \\\"message\\\": str(exception)}\\n\\n data = GraphExportCallbackError().load(payload)\\n with retry() as session:\\n session.post(callback_url, data=data)\",\n \"def test_add_failure(self):\\n self.protocol.addFailure(\\n self.test, pysubunit.RemoteError(compat._u(\\\"boo qux\\\")))\\n self.assertEqual(\\n self.io.getvalue(),\\n compat._b(\\n ('failure: %s [\\\\n' +\\n _remote_exception_str + ': boo qux\\\\n]\\\\n')\\n % self.test.id()))\",\n \"def testFailureReturnsInternalErrorCode(self):\\n body = dumps({'id': 100, 'jsonrpc': '2.0', 'method': 'fail',\\n 'params': {}})\\n headers = Headers({'Content-Length': [str(len(body))],\\n 'Content-Type': ['application/json']})\\n request = FakeRequest(headers=headers, body=body)\\n resource = TestResource(None, None)\\n result = yield resource.deferred_render_POST(request)\\n response = loads(result)\\n self.assertEqual({'code': JSONRPC_INTERNAL_ERROR,\\n 'message': 'Internal error.'},\\n response['error'])\\n self.assertIn('exceptions.RuntimeError', self.log.getvalue())\",\n \"def _failure_to_exception_tuple(failure):\\n return (\\n failure.value.__class__,\\n failure.value,\\n failure.getBriefTraceback(),\\n )\",\n \"def emergency_recover_states_from_failure():\\n _emergency_state_check()\\n _emergency_iobuf_extract()\",\n \"def import_failure_reason(self) -> str:\\n return pulumi.get(self, \\\"import_failure_reason\\\")\",\n \"def failure_detail(self) -> Optional[pulumi.Input['FailureDetailArgs']]:\\n return pulumi.get(self, \\\"failure_detail\\\")\",\n \"def test_add_expected_failure(self):\\n self.protocol.addExpectedFailure(\\n self.test, pysubunit.RemoteError(compat._u(\\\"phwoar crikey\\\")))\\n self.assertEqual(\\n self.io.getvalue(),\\n compat._b(('xfail: %s [\\\\n' +\\n _remote_exception_str + \\\": phwoar crikey\\\\n\\\"\\n \\\"]\\\\n\\\") % self.test.id()))\",\n \"def failure(self, error):\\n print \\\"comm failed Reason:\\\", error\\n return error\",\n \"def raise_for_failure(self) -> None:\\n if not self.is_success():\\n raise exc.ExecutionError(self)\",\n \"def test_original_failure(self):\\n try:\\n 1 / 0\\n except ZeroDivisionError:\\n f = Failure()\\n dr = EventualResult(fail(f), None)\\n self.assertIdentical(dr.original_failure(), f)\",\n \"def abort(self, message: str) -> None:\\n message = f\\\"{Invocation.current.log} - {message}\\\"\\n self.exception = StepException(message)\\n global failure_aborts_build # pylint: disable=invalid-name\\n global no_actions # pylint: disable=invalid-name\\n if failure_aborts_build.value and not no_actions.value:\\n no_additional_complaints()\\n raise self.exception\",\n \"def testFailure():\\n run(\\\"chariot-me\\\") #Start management-engine without initial deplflag\\n egress()\",\n \"def inject_failure(self):\\n while len(self.circQ):\\n yield self.env.timeout(time_to_failure())\\n if len(self.circQ) > 0 and \\\\\\n not self.currentProc.broken and \\\\\\n self.currentProc.workLeft > 0:\\n # Only break the machine if it is currently computing,\\n # and if current proc is not restarting\\n # TODO: Allow errors to be thrown while restarting\\n self.BqLog(\\\"Injecting a failure in %s\\\" % (self.currentProc.name))\\n self.numFailures += 1\\n self.process.interrupt(cause=\\\"failure\\\")\",\n \"def on_failure(self, exc: BaseException) -> None:\",\n \"def end_failure(self, error: Exception):\\n if self.__tracer is not None:\\n elapsed = (datetime.datetime.now().timestamp() * 1000) - self.__start\\n self.__tracer.failure(self.__correlation_id, self.__component, self.__operation, error, round(elapsed))\",\n \"def failure(self, error, rc, msg):\\n self.module.fail_json(msg=msg, rc=rc, err=error)\",\n \"def test_fails(self):\\n raise FoolishError(\\\"I am a broken test\\\")\",\n \"def test_failure(self):\\n\\n @sync_performer\\n def fail(dispatcher, intent):\\n raise intent\\n\\n dispatcher = lambda _: fail\\n self.assertThat(\\n sync_perform(\\n dispatcher, Effect(ValueError(\\\"oh dear\\\")).on(error=lambda e: e)\\n ),\\n MatchesException(ValueError(\\\"oh dear\\\")),\\n )\",\n \"def _create_failure_entry(self):\\r\\n # view task entry for task failure\\r\\n progress = {'message': TEST_FAILURE_MESSAGE,\\r\\n 'exception': TEST_FAILURE_EXCEPTION,\\r\\n }\\r\\n return self._create_entry(task_state=FAILURE, task_output=progress)\",\n \"def _get_failure_from_exception(\\n e: BaseException) -> TransactionResult.Failure:\\n\\n try:\\n if isinstance(e, IconServiceBaseException):\\n if e.code == ExceptionCode.SCORE_ERROR or isinstance(e, ScoreErrorException):\\n Logger.warning(e.message, ICON_SERVICE_LOG_TAG)\\n else:\\n Logger.exception(e.message, ICON_SERVICE_LOG_TAG)\\n\\n code = int(e.code)\\n message = str(e.message)\\n else:\\n Logger.exception(e, ICON_SERVICE_LOG_TAG)\\n Logger.error(e, ICON_SERVICE_LOG_TAG)\\n\\n code: int = ExceptionCode.SERVER_ERROR.value\\n message = str(e)\\n except:\\n code: int = ExceptionCode.SERVER_ERROR.value\\n message = 'Invalid exception: code or message is invalid'\\n\\n return TransactionResult.Failure(code, message)\",\n \"def failure(self, message=''):\\n print(colored(message, 'red'))\",\n \"def tc_fail(self, msg):\\n self.recover()\\n tc_fail(msg)\",\n \"def add_failure(self, test, exception_string):\\n failure = E.failure(exception_string)\\n self._add_test_report(test, result_description=failure,\\n error=False, failure=True)\",\n \"def resolve_failure(self):\\n\\t\\tpass\",\n \"def addFailure(self, test, err):\\n\\n super(ForceBalanceTestResult, self).addFailure(test,err)\\n self.logger.warning(\\\"\\\\r\\\\x1b[31;1m\\\" + \\\"FAIL\\\" + \\\"\\\\x1b[0m \\\" + test.shortDescription() + \\\"\\\\n\\\")\\n\\n errorMessage = self.buildErrorMessage(test, err)\\n\\n for line in errorMessage.splitlines():\\n self.logger.warning(\\\"\\\\t >\\\\t\\\" + line + \\\"\\\\n\\\")\",\n \"def test_launch_failures_hw(self):\\n self.test_launch_failures()\",\n \"def extraction_failure(self, extraction_failure):\\n self._extraction_failure = extraction_failure\",\n \"def _adapt_to_exception_tuple(failure):\\n if isinstance(failure, Failure):\\n return _failure_to_exception_tuple(failure)\\n return failure\",\n \"def diagnostic_self_test_fail(reason='no errors found', additional_text='no errors found', severity_level='error'):\\n\\n SysTools.notify.error(RPD_EVENT_CONNECTIVITY_DIAGNOSTIC_SELF_TEST_FAIL[0],\\n reason, additional_text, severity_level)\",\n \"def testRunException(self):\\n class TestError(Exception):\\n \\\"\\\"\\\"Unique test exception\\\"\\\"\\\"\\n\\n perform_mock = self.PatchObject(generic_stages.BuilderStage, 'PerformStage')\\n perform_mock.side_effect = TestError('fail!')\\n\\n stage = self.ConstructStage()\\n results_lib.Results.Clear()\\n self.assertRaises(failures_lib.StepFailure, self._RunCapture, stage)\\n\\n results = results_lib.Results.Get()[0]\\n self.assertTrue(isinstance(results.result, TestError))\\n self.assertEqual(str(results.result), 'fail!')\\n self.mock_cidb.StartBuildStage.assert_called_once_with(\\n DEFAULT_BUILD_STAGE_ID)\\n self.mock_cidb.FinishBuildStage.assert_called_once_with(\\n DEFAULT_BUILD_STAGE_ID,\\n constants.BUILDER_STATUS_FAILED)\",\n \"def make_expected_failure_message(todo, failure):\\n exc_type, exc_value, exc_traceback = _adapt_to_exception_tuple(failure)\\n return EXPECTED_FAILURE(\\n todo=todo,\\n exception=exc_type,\\n reason=exc_value,\\n traceback=exc_traceback,\\n )\",\n \"def fail(self):\\n self.cleanup()\\n self.runner.report_job_fail(self.id)\",\n \"def test_failure_result(self):\\n dr = EventualResult(fail(RuntimeError()), None)\\n self.assertRaises(RuntimeError, dr.wait, 0.1)\",\n \"def failure(self, result):\\r\\n raise NotImplementedError\",\n \"def _reportError(self, failure):\\r\\n self._connection.reportError(failure.getErrorMessage())\",\n \"def log(failure):\\n return self._env.logger.warning('[ping] {}'.format(failure.getErrorMessage()))\",\n \"def fail(msg):\\n\\n # Not sure if simply raising the exception is clearer.\\n raise CommandFailed(msg)\",\n \"def on_failure(self, exc: BaseException) -> None:\\n if self._breaker._state_storage.counter >= self._breaker.fail_max:\\n throw_new_error = self._breaker.open()\\n\\n if throw_new_error:\\n error_msg = \\\"Failures threshold reached, circuit breaker opened\\\"\\n raise CircuitBreakerError(error_msg).with_traceback(sys.exc_info()[2])\\n else:\\n raise exc\",\n \"def on_trial_error(self, trial_runner, trial):\\n\\n raise NotImplementedError\",\n \"def test_fail(make_runner: Callable[..., TargetFunctionRunner]) -> None:\\n runner = make_runner(target_failed, use_instances=True)\\n run_info = TrialInfo(config=2, instance=\\\"test\\\", seed=0, budget=0.0)\\n\\n runner.submit_trial(run_info)\\n run_info, run_value = next(runner.iter_results())\\n\\n # Make sure the traceback message is included\\n assert \\\"traceback\\\" in run_value.additional_info\\n assert \\\"RuntimeError\\\" in run_value.additional_info[\\\"traceback\\\"]\",\n \"def repr_failure(self, excinfo):\\n if isinstance(excinfo.value, NbCellError):\\n msg_items = [bcolors.FAIL + \\\"Notebook cell execution failed\\\" + bcolors.ENDC]\\n formatstring = bcolors.OKBLUE + \\\"Cell %d: %s\\\\n\\\\n\\\" + \\\\\\n \\\"Input:\\\\n\\\" + bcolors.ENDC + \\\"%s\\\\n\\\\n\\\" + \\\\\\n bcolors.OKBLUE + \\\"Traceback:%s\\\" + bcolors.ENDC\\n msg_items.append(formatstring % excinfo.value.args)\\n return \\\"\\\\n\\\".join(msg_items)\\n else:\\n return \\\"pytest plugin exception: %s\\\" % str(excinfo.value)\",\n \"def _handle_failure(self, proc, test_case):\\n if proc.returncode != 0:\\n print('ERROR: Test execution failed: {}'.format(test_case.get_name()))\\n stdout, stderr = proc.communicate()\\n raise TestCaseFailure('Test case {} failed. stdout: {}, stderr: {}, '\\n 'return code: {}.'.format(test_case.get_name(),\\n stdout, stderr,\\n proc.returncode))\",\n \"def unexpected_error(self, exception):\",\n \"def fail(self, failure):\\n if self._state == self.State.transfering_no_waiters:\\n self._get_deferreds = None\\n self._free_deferreds = None\\n self._state = self.State.freed\\n \\n elif self._state == self.State.transfering_waiters:\\n for d in self._get_deferreds:\\n d.errback(failure)\\n self._get_deferreds = None\\n self._free_deferreds = None\\n self._state = self.State.freed\\n \\n elif self._state == self.State.transfering_waiters_free:\\n for d in self._get_deferreds:\\n d.errback(failure)\\n self._get_deferreds = None\\n self._state = self.State.freed\\n for d in self._free_deferreds:\\n d.callback(None)\\n self._free_deferreds = None\\n \\n elif self._state == self.State.stored:\\n raise ValueError(\\\"Attempt to set already set value\\\")\\n \\n elif self._state == self.State.freed:\\n raise ValueError(\\\"This value instance should not be used anymore\\\")\\n \\n else:\\n raise ValueError(\\\"Invalid state\\\")\",\n \"def addFailure(self, result):\\n result.addFailure(self, (Exception, Exception(), None))\\n # Since TAP will not provide assertion data, clean up the assertion\\n # section so it is not so spaced out.\\n test, err = result.failures[-1]\\n result.failures[-1] = (test, \\\"\\\")\",\n \"def _response_failure(self, failure, msgID):\\r\\n if not self._status:\\r\\n # Can not help it if the response takes some time and in the mean\\r\\n # time the interface is disabled; therefore, don't raise an error\\r\\n # instead just skip sending the response\\r\\n return\\r\\n\\r\\n # TODO: Return something useful to the cloud here!\\r\\n print('Service call failed.')\",\n \"def _handle_error(self, failure, item, spider):\\n # do nothing, just log\\n log.err(failure)\",\n \"def TestCaseDidFail(self, request, context):\\n LOGGER.info('Received request for TestCaseDidFail %s', request)\\n for plugin in self.plugins:\\n plugin.test_case_did_fail(request)\\n return test_plugin_service_pb2.TestCaseDidFailResponse()\",\n \"def test_internal_server_error_beomces_remote_initiated_server_error(self):\\n msg = \\\"The server has encountered an error\\\"\\n error = ErrorParser().process_all(msg)\\n assert isinstance(error, RemoteInitiatedServerError)\\n eq_(BibliothecaAPI.SERVICE_NAME, error.service_name)\\n eq_(502, error.status_code)\\n eq_(msg, error.message)\\n doc = error.as_problem_detail_document()\\n eq_(502, doc.status_code)\\n eq_(\\\"Integration error communicating with 3M\\\", doc.detail)\",\n \"def fail(self, exception):\\n with self._lock:\\n self._termination_manager.abort(self._local_failure)\\n self._transmission_manager.abort(self._local_failure)\\n self._ingestion_manager.abort()\\n self._expiration_manager.abort()\",\n \"def renderHTTP_exception(request, failure):\",\n \"def device_stats_collection_failure_reason(self, device_stats_collection_failure_reason):\\n\\n self._device_stats_collection_failure_reason = device_stats_collection_failure_reason\",\n \"def test_ComputerPartition_error_HostingResource_DeliveredState(self):\\n sequence_list = SequenceList()\\n sequence_string = self.prepare_stopped_computer_partition_sequence_string + '\\\\\\n SlapLoginCurrentComputer \\\\\\n CheckSuccessComputerPartitionErrorCall \\\\\\n Tic \\\\\\n SlapLogout \\\\\\n \\\\\\n LoginDefaultUser \\\\\\n CheckSalePackingListErrorText \\\\\\n Logout \\\\\\n LoginERP5TypeTestCase \\\\\\n CheckSiteConsistency \\\\\\n Logout \\\\\\n '\\n sequence_list.addSequenceString(sequence_string)\\n sequence_list.play(self)\",\n \"def answerFailure( self, reason ):\\n\\t\\tlog.warn( \\n\\t\\t\\t\\\"\\\"\\\"Unable to answer channel %r: %s\\\"\\\"\\\", \\n\\t\\t\\tself.agi.variables['agi_channel'], reason.getTraceback(),\\n\\t\\t)\\n\\t\\tself.agi.finish()\",\n \"def fail(self, cause = None, annotations = {}):\\n self.set_outcome(Result.FAIL, cause, annotations)\",\n \"def Raise( self, Message ):\\r\\n UsbBootLoaderDriverError( Message )\",\n \"def _message_failed_job(self):\\n self.ensure_one()\\n return _(\\\"Something bad happened during the execution of the job. \\\"\\n \\\"More details in the 'Exception Information' section.\\\")\",\n \"def _handle_tracker_error(self, failure):\\n\\n # Log the error\\n logging.error(\\\"An error occured while running the '\\\"+self._service_id+\\\"' service, the service has been stopped: '\\\"+\\n failure.getErrorMessage()+\\\"'\\\")\\n # TODO: Log the error to the driver's state dictionary.\\n\\n # Stop the event loop just incase it's still running\\n if self._tracking_update_loop.running:\\n self._tracking_update_loop.stop()\\n\\n return False\",\n \"def test_remote_authentication_failed_becomes_remote_initiated_server_error(self):\\n msg=self.sample_data(\\\"error_authentication_failed.xml\\\")\\n error = ErrorParser().process_all(msg)\\n assert isinstance(error, RemoteInitiatedServerError)\\n eq_(BibliothecaAPI.SERVICE_NAME, error.service_name)\\n eq_(\\\"Authentication failed\\\", error.message)\",\n \"def _get_error_type(self):\\n\\n error_type = AladdinUserFaultType.Unknown\\n if not self.error_msg:\\n return error_type.value\\n\\n error_msg = self.error_msg.lower()\\n if 'unrecognized' in error_msg:\\n error_type = AladdinUserFaultType.UnrecognizedArguments\\n elif 'expected one argument' in error_msg or 'expected at least one argument' in error_msg \\\\\\n or 'value required' in error_msg:\\n error_type = AladdinUserFaultType.ExpectedArgument\\n elif 'misspelled' in error_msg:\\n error_type = AladdinUserFaultType.UnknownSubcommand\\n elif 'arguments are required' in error_msg or 'argument required' in error_msg:\\n error_type = AladdinUserFaultType.MissingRequiredParameters\\n if '_subcommand' in error_msg:\\n error_type = AladdinUserFaultType.MissingRequiredSubcommand\\n elif '_command_package' in error_msg:\\n error_type = AladdinUserFaultType.UnableToParseCommandInput\\n elif 'not found' in error_msg or 'could not be found' in error_msg \\\\\\n or 'resource not found' in error_msg:\\n error_type = AladdinUserFaultType.AzureResourceNotFound\\n if 'storage_account' in error_msg or 'storage account' in error_msg:\\n error_type = AladdinUserFaultType.StorageAccountNotFound\\n elif 'resource_group' in error_msg or 'resource group' in error_msg:\\n error_type = AladdinUserFaultType.ResourceGroupNotFound\\n elif 'pattern' in error_msg or 'is not a valid value' in error_msg or 'invalid' in error_msg:\\n error_type = AladdinUserFaultType.InvalidParameterValue\\n if 'jmespath_type' in error_msg:\\n error_type = AladdinUserFaultType.InvalidJMESPathQuery\\n elif 'datetime_type' in error_msg:\\n error_type = AladdinUserFaultType.InvalidDateTimeArgumentValue\\n elif '--output' in error_msg:\\n error_type = AladdinUserFaultType.InvalidOutputType\\n elif 'resource_group' in error_msg:\\n error_type = AladdinUserFaultType.InvalidResourceGroupName\\n elif 'storage_account' in error_msg:\\n error_type = AladdinUserFaultType.InvalidAccountName\\n elif \\\"validation error\\\" in error_msg:\\n error_type = AladdinUserFaultType.ValidationError\\n\\n return error_type.value\",\n \"def raise_fail(*args, **kwargs):\\n raise Exception(\\\"oops\\\")\",\n \"def test_ComputerPartition_error_HostingResource_StoppedState(self):\\n sequence_list = SequenceList()\\n sequence_string = self.prepare_stop_requested_computer_partition_sequence_string + '\\\\\\n SlapLoginCurrentComputer \\\\\\n CheckSuccessComputerPartitionErrorCall \\\\\\n Tic \\\\\\n SlapLogout \\\\\\n \\\\\\n LoginDefaultUser \\\\\\n CheckSalePackingListErrorText \\\\\\n Logout \\\\\\n LoginERP5TypeTestCase \\\\\\n CheckSiteConsistency \\\\\\n Logout \\\\\\n '\\n sequence_list.addSequenceString(sequence_string)\\n sequence_list.play(self)\",\n \"def failure(self, validation_failure):\\n \\n self.request.response.status_int = 400\\n return validation_failure.error.asdict()\",\n \"def test_failed_processing(self):\\n # setup\\n ledger_api_dialogue, fipa_dialogue = self._setup_fipa_ledger_api_dialogues(self)\\n\\n self.transaction_behaviour.timedout.add(ledger_api_dialogue.dialogue_label)\\n\\n # operation\\n with patch.object(self.logger, \\\"log\\\") as mock_logger:\\n self.transaction_behaviour.failed_processing(ledger_api_dialogue)\\n\\n # after\\n self.assert_quantity_in_outbox(0)\\n\\n # finish_processing\\n assert self.transaction_behaviour.timedout == set()\\n\\n mock_logger.assert_any_call(\\n logging.DEBUG,\\n f\\\"Timeout dialogue in transaction processing: {ledger_api_dialogue}\\\",\\n )\\n\\n # failed_processing\\n assert fipa_dialogue in self.transaction_behaviour.waiting\",\n \"def failure(self, error):\\n \\n self.request.response.status_int = 400\\n return None\",\n \"def raise_step_error(self, error: Exception, step: str):\\n error_message = \\\"{}\\\\nFailed: Error={}\\\".format(step, str(error))\\n logging.error(error_message)\\n self.slacker.send_thread_reply(error_message)\\n raise Exception(error_message)\",\n \"def _test_run_with_failure(self, task_class, expected_message):\\r\\n task_entry = self._create_input_entry()\\r\\n self.define_option_problem(PROBLEM_URL_NAME)\\r\\n with self.assertRaises(TestTaskFailure):\\r\\n self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id, expected_message)\\r\\n # compare with entry in table:\\r\\n entry = InstructorTask.objects.get(id=task_entry.id)\\r\\n self.assertEquals(entry.task_state, FAILURE)\\r\\n output = json.loads(entry.task_output)\\r\\n self.assertEquals(output['exception'], 'TestTaskFailure')\\r\\n self.assertEquals(output['message'], expected_message)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5803383","0.5730745","0.565321","0.5649556","0.56122845","0.5440349","0.5320383","0.52736396","0.5240046","0.5213798","0.5201333","0.5083693","0.50791305","0.50574607","0.5027117","0.50205135","0.5006612","0.5000682","0.49848235","0.49722403","0.49625576","0.49599424","0.4942724","0.49408588","0.49185506","0.488899","0.4879341","0.48707384","0.48572305","0.4842845","0.48270127","0.4819731","0.48160434","0.48101956","0.4799666","0.47852236","0.47834268","0.47699845","0.47579664","0.47562757","0.47484428","0.4743476","0.47429636","0.47365955","0.47143108","0.46903548","0.4688951","0.46770164","0.4674069","0.46680197","0.46428528","0.46341965","0.4621173","0.46185598","0.46027678","0.45785254","0.45689493","0.4566813","0.45639262","0.45586154","0.4551573","0.4541139","0.45411196","0.45381817","0.45267048","0.45247993","0.4517097","0.45154822","0.45076606","0.44826734","0.4478757","0.4476612","0.44711167","0.44664472","0.4465498","0.4462783","0.44556847","0.44530702","0.44476348","0.44436517","0.4437343","0.4436699","0.44356203","0.4422762","0.4419166","0.44183642","0.44152057","0.44143176","0.44119385","0.44071454","0.43809232","0.43798807","0.43776825","0.43711096","0.437048","0.43676996","0.43657333","0.43651947","0.4347545","0.43311942"],"string":"[\n \"0.5803383\",\n \"0.5730745\",\n \"0.565321\",\n \"0.5649556\",\n \"0.56122845\",\n \"0.5440349\",\n \"0.5320383\",\n \"0.52736396\",\n \"0.5240046\",\n \"0.5213798\",\n \"0.5201333\",\n \"0.5083693\",\n \"0.50791305\",\n \"0.50574607\",\n \"0.5027117\",\n \"0.50205135\",\n \"0.5006612\",\n \"0.5000682\",\n \"0.49848235\",\n \"0.49722403\",\n \"0.49625576\",\n \"0.49599424\",\n \"0.4942724\",\n \"0.49408588\",\n \"0.49185506\",\n \"0.488899\",\n \"0.4879341\",\n \"0.48707384\",\n \"0.48572305\",\n \"0.4842845\",\n \"0.48270127\",\n \"0.4819731\",\n \"0.48160434\",\n \"0.48101956\",\n \"0.4799666\",\n \"0.47852236\",\n \"0.47834268\",\n \"0.47699845\",\n \"0.47579664\",\n \"0.47562757\",\n \"0.47484428\",\n \"0.4743476\",\n \"0.47429636\",\n \"0.47365955\",\n \"0.47143108\",\n \"0.46903548\",\n \"0.4688951\",\n \"0.46770164\",\n \"0.4674069\",\n \"0.46680197\",\n \"0.46428528\",\n \"0.46341965\",\n \"0.4621173\",\n \"0.46185598\",\n \"0.46027678\",\n \"0.45785254\",\n \"0.45689493\",\n \"0.4566813\",\n \"0.45639262\",\n \"0.45586154\",\n \"0.4551573\",\n \"0.4541139\",\n \"0.45411196\",\n \"0.45381817\",\n \"0.45267048\",\n \"0.45247993\",\n \"0.4517097\",\n \"0.45154822\",\n \"0.45076606\",\n \"0.44826734\",\n \"0.4478757\",\n \"0.4476612\",\n \"0.44711167\",\n \"0.44664472\",\n \"0.4465498\",\n \"0.4462783\",\n \"0.44556847\",\n \"0.44530702\",\n \"0.44476348\",\n \"0.44436517\",\n \"0.4437343\",\n \"0.4436699\",\n \"0.44356203\",\n \"0.4422762\",\n \"0.4419166\",\n \"0.44183642\",\n \"0.44152057\",\n \"0.44143176\",\n \"0.44119385\",\n \"0.44071454\",\n \"0.43809232\",\n \"0.43798807\",\n \"0.43776825\",\n \"0.43711096\",\n \"0.437048\",\n \"0.43676996\",\n \"0.43657333\",\n \"0.43651947\",\n \"0.4347545\",\n \"0.43311942\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6850455"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8996,"cells":{"query":{"kind":"string","value":"StepTimeout is a subclass of StepFailure and is raised when a step times out."},"document":{"kind":"string","value":"def StepTimeout(self):\n return recipe_api.StepTimeout"},"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 raise_timeout(self, *args, **kwargs):\n\n self.log.error(\"Task timeout encountered.\")\n raise TimeoutError","def handler(*args, **kwargs):\n raise TimeoutException(\"Test aborted due to timeout. Test was \" +\n \"expected to finish in less than {} second(s).\".format(time_limit))","def StepFailure(self):\n return recipe_api.StepFailure","async def timeout(self, failed: bool = False) -> None:\n raise NotImplementedError()","def test_timeout_elapsed_exception(self):\n deadline = Deadline(-MS)\n with self.assertRaises(TimeoutError):\n deadline.timeout()","def assert_timeout(self) -> None:","def timeout(order):\n return ResultProxy(TaskResult(TaskTimedout('A task has timedout'), order))","def _timeout(signum, frame):\n # Raise TimeoutException with system default timeout message\n raise TimeoutException()","def test_timeoutRaises(self):\n\n @self.eventloop.wait_for(timeout=0.5)\n def times_out():\n return Deferred().addErrback(lambda f: f.trap(CancelledError))\n\n start = time.time()\n self.assertRaises(TimeoutError, times_out)\n self.assertTrue(abs(time.time() - start - 0.5) < 0.1)","def _check_timeouts(self, chunk_timeout, total_timeout):\n cur_time = time()\n\n if chunk_timeout is not None and cur_time > self._chunk_time + chunk_timeout:\n raise ChunkTimeout('Item timeout expired.')\n elif total_timeout is not None and cur_time > self._total_time + total_timeout:\n raise TotalTimeout('Total timeout expired.')","def test_timeout(self, mocker, mock_timedelta):\n\n tid = 289466\n site = \"mysite\"\n\n exception_response = self.generate_task_dictionary(\n tid, state=\"started\", completed=None\n )\n\n responses = [{\"json\": exception_response}]\n url = (\n \"https://cloudapi.acquia.com/v1/\"\n \"sites/prod:{site}/tasks/{tid}.json\".format(tid=tid, site=site)\n )\n\n mocker.register_uri(\"GET\", url, responses)\n\n with self.assertRaises(exceptions.AcquiaCloudTimeoutError):\n self.client.site(site).task(tid).wait(0)","def _handle_timeout(self, frame=None, **_):\n\n raise TimeOut.TimeOutError(self, frame)","def test_failed_processing(self):\n # setup\n ledger_api_dialogue, fipa_dialogue = self._setup_fipa_ledger_api_dialogues(self)\n\n self.transaction_behaviour.timedout.add(ledger_api_dialogue.dialogue_label)\n\n # operation\n with patch.object(self.logger, \"log\") as mock_logger:\n self.transaction_behaviour.failed_processing(ledger_api_dialogue)\n\n # after\n self.assert_quantity_in_outbox(0)\n\n # finish_processing\n assert self.transaction_behaviour.timedout == set()\n\n mock_logger.assert_any_call(\n logging.DEBUG,\n f\"Timeout dialogue in transaction processing: {ledger_api_dialogue}\",\n )\n\n # failed_processing\n assert fipa_dialogue in self.transaction_behaviour.waiting","def assert_timeout(self) -> None:\n if self._cancelled:\n raise asyncio.TimeoutError from None","def onTimeStepEnd(self, timeStep):\n pass","def test_step_stop_aborted(self, _step: PropertyMock):\n _step.return_value = None\n es = exposed.ExposedStep()\n es.stop()","def testTimeout(self):\n\n class TimeoutTestCase(cros_test_lib.TestCase):\n \"\"\"Test case that raises a TimeoutError because it takes too long.\"\"\"\n\n TEST_CASE_TIMEOUT = 1\n\n def testSleeping(self):\n \"\"\"Sleep for 2 minutes. This should raise a TimeoutError.\"\"\"\n time.sleep(2 * 60)\n raise AssertionError('Test case should have timed out.')\n\n # Run the test case, verifying it raises a TimeoutError.\n test = TimeoutTestCase(methodName='testSleeping')\n self.assertRaises(timeout_util.TimeoutError, test.testSleeping)","def test_set_timeout_value_error(self, timeout):\n self.assertRaises(ValueError, self.root.set_timeout, timeout)","def check_timeout(self, msg):\n if msg.clock.secs > self.timeout and not self.is_cancelled:\n rospy.loginfo(\"Test timed out, cancelling job\")\n self.utils.set_tag(name=self.test_name + \"_Status\", value=\"Failed\")\n self.utils.set_tag(name=self.test_name + \"_Timed_Out\", value=str(self.timeout))\n self.utils.cancel_job()","def test_timeout(self):\n start = time.time()\n dr = EventualResult(Deferred(), None)\n self.assertRaises(TimeoutError, dr.wait, timeout=0.03)\n # be a little lenient for slow computers:\n self.assertTrue(abs(time.time() - start) < 0.05)","def pytest_timeout_cancel_timer(item):","def test_wait_for_predicate_timeout(self):\n predicate_mock = mock.MagicMock(side_effect=[True, True, True])\n with self.assertRaises(TimeoutError):\n train_utils.wait_for_predicate(predicate_mock, num_retries=3)","def _test_run_with_long_error_msg(self, task_class):\r\n task_entry = self._create_input_entry()\r\n self.define_option_problem(PROBLEM_URL_NAME)\r\n expected_message = \"x\" * 1500\r\n with self.assertRaises(TestTaskFailure):\r\n self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id, expected_message)\r\n # compare with entry in table:\r\n entry = InstructorTask.objects.get(id=task_entry.id)\r\n self.assertEquals(entry.task_state, FAILURE)\r\n self.assertGreater(1023, len(entry.task_output))\r\n output = json.loads(entry.task_output)\r\n self.assertEquals(output['exception'], 'TestTaskFailure')\r\n self.assertEquals(output['message'], expected_message[:len(output['message']) - 3] + \"...\")\r\n self.assertTrue('traceback' not in output)","def __step_waiter(self, step_id):\n\n # don't forget to tip the waiter :)\n step_waiter = self.emr_client.get_waiter('step_complete')\n try:\n step_waiter.wait(ClusterId=self.clusID,\n StepId=step_id[0],\n WaiterConfig={\n 'Delay': 15,\n 'MaxAttempts': 480\n })\n\n except WaiterError as e:\n if 'Max attempts exceeded' in e.message:\n print('EMR Step did not complete in two hours')\n else:\n print(e.message)","def test_task_failed(self):\n\n task1 = FailedTask(mock.Mock(), total_retries=0)\n task2 = mock.Mock(execute_after=0)\n\n g = TaskDependencyGraph(MockWorkflowContext())\n seq = g.sequence()\n seq.add(task1, task2)\n\n with limited_sleep_mock():\n self.assertRaisesRegex(WorkflowFailed, 'failtask', g.execute)\n self.assertTrue(task1.is_terminated)\n self.assertFalse(task2.apply_async.called)","def step(self):\n raise TaskError(\"Task %s: subclass should override step() method!\" %\n self)","def pytest_exception_interact(node):\n hooks = node.config.pluginmanager.hook\n hooks.pytest_timeout_cancel_timer(item=node)","def test_timeout_retries(self):\n\n batch = Batch(Mock())\n self.check_instance(batch=batch)\n\n self.assertEqual(batch.timeout_retries, 0)\n self.check_instance(batch, timeout_retries=0)\n\n batch.timeout_retries = 10\n self.assertEqual(batch.timeout_retries, 10)\n self.check_instance(batch, timeout_retries=10)\n\n batch.timeout_retries = 0\n self.assertEqual(batch.timeout_retries, 0)\n self.check_instance(batch, timeout_retries=0)\n\n batch.timeout_retries = 1\n self.assertEqual(batch.timeout_retries, 1)\n self.check_instance(batch, timeout_retries=1)\n\n # exceptions\n ## error messages\n value_error = \"'timeout_retries' must be positive, i.e. greater or equal that zero (>=0).\"\n type_error = f\"'timeout_retries' must be of type {int}.\"\n\n #######################################################################\n # test wrong value\n with self.assertRaises(ValueError) as error:\n batch.timeout_retries = -1\n self.assertEqual(batch.timeout_retries, 1)\n self.check_instance(batch, timeout_retries=1)\n check_error_message(self, error, value_error)\n\n #######################################################################\n # test wrong type\n with self.assertRaises(TypeError) as error:\n batch.timeout_retries = True\n self.assertEqual(batch.timeout_retries, 1)\n self.check_instance(batch, timeout_retries=1)\n check_error_message(self, error, type_error)\n\n with self.assertRaises(TypeError) as error:\n batch.timeout_retries = '2'\n self.assertEqual(batch.timeout_retries, 1)\n self.check_instance(batch, timeout_retries=1)\n check_error_message(self, error, type_error)","def fail(self):\n self.cleanup()\n self.runner.report_job_fail(self.id)","def test_timeout_elapsed_no_exception(self):\n deadline = Deadline(-MS)\n timeout = deadline.timeout(raise_if_elapsed=False)\n self.assertGreater(timeout, -2 * MS)\n self.assertLess(timeout, -MS)","def test_pipeline_timeout(mockpipe_timeout, testdir):\n test = testdir.makepyfile(TEST_TIMEOUT)\n result = testdir.inline_run(\n \"-v\",\n f\"--base-pipeline-dir={test.dirname}\",\n test\n )\n passed, skipped, failed = result.listoutcomes()\n\n assert len(passed) == 0\n assert len(skipped) == 0\n assert len(failed) == 1","def timeout(self, timeout):\n assert timeout is None or timeout > 0\n self._timeout = timeout","def test_timeout_twice(self):\n dr = EventualResult(Deferred(), None)\n self.assertRaises(TimeoutError, dr.wait, timeout=0.01)\n self.assertRaises(TimeoutError, dr.wait, timeout=0.01)","def test_wait_timeout_raises():\n with pytest.raises(WaitTimeOut) as err_info:\n raise WaitTimeOut(\"this is error text right here\")\n\n assert str(err_info.value) == \"this is error text right here\"","def timeout(time_limit):\n\n def wrapUnitTest(testcase):\n\n @wraps(testcase)\n def testWrapper(self):\n\n queue = Queue()\n\n try:\n p = Thread(target=handler, args=(self, testcase, queue))\n p.daemon = True\n p.start()\n err, res = queue.get(timeout=time_limit)\n p.join()\n if err:\n raise err[0](err[1]).with_traceback(err[2])\n return res\n except QueueEmptyError:\n raise TimeoutError(\"Test aborted due to timeout. Test was \" +\n \"expected to finish in less than {} second(s).\".format(time_limit))\n\n return testWrapper\n\n return wrapUnitTest","def test_timeoutCancels(self):\n result = Deferred()\n error = []\n result.addErrback(error.append)\n\n @self.eventloop.wait_for(timeout=0.0)\n def times_out():\n return result\n\n self.assertRaises(TimeoutError, times_out)\n self.assertIsInstance(error[0].value, CancelledError)","def test_timeout_exceeded():\n connection = FakeBaseConnection(session_timeout=10)\n start = time.time() - 11\n try:\n connection._timeout_exceeded(start)\n except NetmikoTimeoutException as exc:\n assert isinstance(exc, NetmikoTimeoutException)\n return\n\n assert False","def failure(self, target):\n print \"FAILED:\"\n self.show_target(target)\n self.failed += 1","def test_timeout_processing(self):\n # setup\n self.transaction_behaviour.processing_time = None\n\n # operation\n self.transaction_behaviour._timeout_processing()\n\n # after\n self.assert_quantity_in_outbox(0)","def testTrialErrored(self):\n stats = self.default_statistics()\n trial_count = stats[str(0)][\"n\"] + 3\n sched, mock_runner = self.schedulerSetup(trial_count)\n t1, t2, t3 = sched._state[\"bracket\"].current_trials()\n for t in [t1, t2, t3]:\n mock_runner._launch_trial(t)\n\n sched.on_trial_error(mock_runner, t3)\n self.assertEqual(\n TrialScheduler.PAUSE,\n sched.on_trial_result(\n mock_runner, t1, result(stats[str(1)][\"r\"], 10)))\n self.assertEqual(\n TrialScheduler.CONTINUE,\n sched.on_trial_result(\n mock_runner, t2, result(stats[str(1)][\"r\"], 10)))","def fail_job( self, job_state ):\n self.stop_job( self.sa_session.query( self.app.model.Job ).get( job_state.job_wrapper.job_id ) )\n job_state.job_wrapper.fail( getattr( job_state, \"fail_message\", GENERIC_REMOTE_ERROR ) )","def on_trial_error(self, trial: Trial):\n pass","def raise_step_error(self, error: Exception, step: str):\n error_message = \"{}\\nFailed: Error={}\".format(step, str(error))\n logging.error(error_message)\n self.slacker.send_thread_reply(error_message)\n raise Exception(error_message)","def timeout(time_limit):\n\n class TimeoutException(Exception):\n \"\"\" Subclass Exception to catch timer expiration during search \"\"\"\n pass\n\n def handler(*args, **kwargs):\n \"\"\" Generic handler to raise an exception when a timer expires \"\"\"\n raise TimeoutException(\"Test aborted due to timeout. Test was \" +\n \"expected to finish in less than {} second(s).\".format(time_limit))\n\n def wrapUnitTest(testcase):\n\n @wraps(testcase)\n def testWrapper(self, *args, **kwargs):\n\n signal.signal(signal.SIGALRM, handler)\n signal.alarm(time_limit)\n\n try:\n return testcase(self, *args, **kwargs)\n finally:\n signal.alarm(0)\n\n return testWrapper\n\n return wrapUnitTest","def raise_timeout_error(api_url, headers, timeout, proxies):\n raise requests.exceptions.Timeout","def raise_timeout_error(api_url, headers, timeout, proxies):\n raise requests.exceptions.Timeout","def set_timeout(self, timeout: int) -> None:\n raise WatchdogError(\"Setting timeout is not supported on {0}\".format(self.describe()))","def timeout(seconds, error_message=\"Time out.\"):\n import signal\n def decorator(func):\n\n def __timiout_handler(signum, frame):\n raise TimeoutError(error_message)\n\n @functools.wraps(func)\n def wrapper(*arg, **kw):\n signal.signal(signal.SIGALRM, __timiout_handler)\n signal.alarm(seconds)\n ret = \"\"\n try:\n ret = func(*arg, **kw)\n except TimeoutError,e:\n print \"TimeoutError: \", e\n print \"{name} ran more than {seconds}s.\".format(name=func.__name__, seconds=seconds)\n except Exception,e:\n print \"Error: \",e\n finally:\n signal.alarm(0)\n return ret\n return wrapper\n return decorator","def raise_timeout_error_upload(api_url, headers, data, timeout, proxies):\n raise requests.exceptions.Timeout","def test_failure_result(self):\n dr = EventualResult(fail(RuntimeError()), None)\n self.assertRaises(RuntimeError, dr.wait, 0.1)","def error_detection_timeout(self, error_detection_timeout):\n\n self._error_detection_timeout = error_detection_timeout","def test_fail(make_runner: Callable[..., TargetFunctionRunner]) -> None:\n runner = make_runner(target_failed, use_instances=True)\n run_info = TrialInfo(config=2, instance=\"test\", seed=0, budget=0.0)\n\n runner.submit_trial(run_info)\n run_info, run_value = next(runner.iter_results())\n\n # Make sure the traceback message is included\n assert \"traceback\" in run_value.additional_info\n assert \"RuntimeError\" in run_value.additional_info[\"traceback\"]","def timeout(self, timeout):\n\n self._timeout = timeout","def test_wait_timeout_inheritance():\n # confirm subclassed from pypyr root error\n err = WaitTimeOut()\n assert isinstance(err, PypyrAwsError)\n assert isinstance(err, PlugInError)\n assert isinstance(err, PypyrError)","def cancelled_to_request_timed_out_error(value, timeout):\n if isinstance(value, failure.Failure):\n value.trap(CancelledError)\n raise RequestTimedOutError()\n return value","def stopped_check(self, timeout=None):","def inject_failure(self):\n while len(self.circQ):\n yield self.env.timeout(time_to_failure())\n if len(self.circQ) > 0 and \\\n not self.currentProc.broken and \\\n self.currentProc.workLeft > 0:\n # Only break the machine if it is currently computing,\n # and if current proc is not restarting\n # TODO: Allow errors to be thrown while restarting\n self.BqLog(\"Injecting a failure in %s\" % (self.currentProc.name))\n self.numFailures += 1\n self.process.interrupt(cause=\"failure\")","def grr_set_flow_timeout(line: Text) -> None:\n args = grr_set_flow_timeout.parser.parse_args(shlex.split(line))\n magics_impl.grr_set_flow_timeout_impl(args.timeout)","def test_timeout(self) -> Optional[pulumi.Input['DurationArgs']]:\n return pulumi.get(self, \"test_timeout\")","def test_timeout(self) -> Optional[pulumi.Input['DurationArgs']]:\n return pulumi.get(self, \"test_timeout\")","def test_timeout_pending(self):\n deadline = Deadline(MS)\n timeout = deadline.timeout()\n self.assertGreater(timeout, 0)\n self.assertLess(timeout, MS)","def on_trial_error(self, trial_runner, trial):\n\n raise NotImplementedError","def end_failure(self, error: Exception):\n if self.__tracer is not None:\n elapsed = (datetime.datetime.now().timestamp() * 1000) - self.__start\n self.__tracer.failure(self.__correlation_id, self.__component, self.__operation, error, round(elapsed))","def test_polling_custom_interval():\n with pytest.raises(polling2.MaxCallException):\n polling2.poll(\n target=lambda: requests.get(\"http://google.com\").status_code == 400,\n step_function=_custom_step, # adds 0.5 seconds to each iteration\n # step_function=polling.step_constant, # returns step\n # step_function=polling.step_linear_double, # returns step * 2\n step=0.5,\n max_tries=3,\n )","def on_saga_failure(self, failed_step: BaseStep, initial_failure_payload: dict):\n logger.info(f'Saga {self.saga_id} failed on \"{failed_step.name}\" step. \\n'\n f'Failure details: {initial_failure_payload}')","def onTimeStep(self, timeStep):\n pass","def transition_on_timeout(timeout, *, to):\n\n # Figure out how many cycles need to pass before we consider ourselves timed out.\n timeout_in_cycles = int(math.ceil(timeout * self._clock_frequency))\n\n # If we've reached that many cycles, transition to the target state.\n with m.If(cycles_in_state == timeout_in_cycles):\n transition_to_state(to)","def pytest_timeout_set_timer(item, settings):","async def test_timeout_error(hass: HomeAssistant, mock_daikin) -> None:\n config_entry = MockConfigEntry(\n domain=DOMAIN,\n unique_id=MAC,\n data={CONF_HOST: HOST, KEY_MAC: MAC},\n )\n config_entry.add_to_hass(hass)\n\n mock_daikin.factory.side_effect = asyncio.TimeoutError\n await hass.config_entries.async_setup(config_entry.entry_id)\n await hass.async_block_till_done()\n\n assert config_entry.state == ConfigEntryState.SETUP_RETRY","def raise_timeout_exception(self, _result=None, _timeout=None):\n raise RosTimeoutError(\"No service response received\")","def _test_run_with_failure(self, task_class, expected_message):\r\n task_entry = self._create_input_entry()\r\n self.define_option_problem(PROBLEM_URL_NAME)\r\n with self.assertRaises(TestTaskFailure):\r\n self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id, expected_message)\r\n # compare with entry in table:\r\n entry = InstructorTask.objects.get(id=task_entry.id)\r\n self.assertEquals(entry.task_state, FAILURE)\r\n output = json.loads(entry.task_output)\r\n self.assertEquals(output['exception'], 'TestTaskFailure')\r\n self.assertEquals(output['message'], expected_message)","def set_timeout(self, timeout):\n pass","def _do_fail_retry(self, event):\n if self._retries > 0:\n self._retries -= 1\n self._state_machine.retry()\n else:\n self._state_machine.abort(result=event.result)","def _do_fail_retry(self, event):\n if self._retries > 0:\n self._retries -= 1\n self._state_machine.retry()\n else:\n self._state_machine.abort(result=event.result)","def test_timeout(self) -> 'outputs.DurationResponse':\n return pulumi.get(self, \"test_timeout\")","def test_timeout(self) -> 'outputs.DurationResponse':\n return pulumi.get(self, \"test_timeout\")","def get_test_timeout(self):\n return None","def test_failed_job(self):\n\n failed_job = json.loads(TREEHERDER_JOB % (\"testfailed\", \"completed\"))\n self.assertEquals(self.query_api.get_job_status(failed_job), FAILURE)","def set_timeout(self, timeout):\n self.timeout = timeout","def testTrialErrored2(self):\n stats = self.default_statistics()\n trial_count = stats[str(0)][\"n\"] + stats[str(1)][\"n\"]\n sched, mock_runner = self.schedulerSetup(trial_count)\n trials = sched._state[\"bracket\"].current_trials()\n for t in trials[:-1]:\n mock_runner._launch_trial(t)\n sched.on_trial_result(\n mock_runner, t, result(stats[str(1)][\"r\"], 10))\n\n mock_runner._launch_trial(trials[-1])\n sched.on_trial_error(mock_runner, trials[-1])\n self.assertEqual(len(sched._state[\"bracket\"].current_trials()),\n self.downscale(stats[str(1)][\"n\"], sched))","def test_timeout(self, timeout, tmpdir, monkeypatch):\n\n file_name = \"test_workflow.yaml\"\n dev = qml.device(\"orquestra.forest\", wires=3, timeout=timeout)\n mock_res_dict = {\"First\": {\"expval\": {\"list\": [123456789]}}}\n\n test_uuid = \"1234\"\n assert dev._timeout == timeout\n assert not os.path.exists(tmpdir.join(f\"expval-{test_uuid}.yaml\"))\n with monkeypatch.context() as m:\n m.setattr(pennylane_orquestra.cli_actions, \"user_data_dir\", lambda *args: tmpdir)\n m.setattr(pennylane_orquestra.cli_actions, \"workflow_results\", lambda *args: \"Test res\")\n\n # Disable submitting to the Orquestra platform by mocking Popen\n m.setattr(subprocess, \"Popen\", lambda *args, **kwargs: MockPopen())\n\n # Disable random uuid generation\n m.setattr(uuid, \"uuid4\", lambda *args: test_uuid)\n\n @qml.qnode(dev)\n def circuit():\n qml.PauliX(0)\n return qml.expval(qml.PauliZ(0))\n\n start = time.time()\n with pytest.raises(TimeoutError, match=\"The workflow results for workflow\"):\n circuit()\n end = time.time()\n assert end - start >= timeout","def timeout_change(self, timedelta):\n pass # pylint: disable=unnecessary-pass\n # For backward compatibility only.","def inject_failure(self):\n # Inject a failure only if there's a process running\n self.BqLog(\"Starting failure injection\")\n while len(self.circQ) > 0 or (self.currentProc and self.currentProc.workLeft > 0):\n t = time_to_failure()\n self.BqLog(\"Inject the next failure after %d seconds\" % (t))\n if t == 0:\n continue\n yield self.env.timeout(t)\n if len(self.circQ) >= 0 and \\\n self.currentProc.workLeft > 0:\n # Only break the machine if it is currently computing,\n # and if current proc is not restarting\n self.BqLog(\"Injecting a failure in %s\" % (self.currentProc.name))\n self.numFailures += 1\n self.process.interrupt(cause=\"failure\")","def timeout(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"timeout\")","def timeout(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"timeout\")","def test_pass_times_error_server(self):\n with HTTMock(self.http_wrong):\n self.assertRaises(Exception, self.iss.pass_times, 15,20)","def trial_end(self, parameter_id, success, **kwargs):","def test_state_after_failure(self):\n pass","def _timeout(self, timeout, f, *args, **kwargs):\r\n\r\n t = spawn_thread(target=f, args=args, kwargs=kwargs)\r\n t.daemon = True\r\n t.start()\r\n t.join(timeout)\r\n\r\n if not t.is_alive():\r\n if t.exc_info:\r\n return t.exc_info\r\n return t.result\r\n else:\r\n try:\r\n msg = '[%s] Execution was forcefully terminated'\r\n raise RuntimeError(msg % t.name)\r\n except:\r\n return sys.exc_info()","def job_step_error(self, job_request_payload, message):\n payload = JobStepErrorPayload(job_request_payload, message)\n self.send(job_request_payload.error_command, payload)","def timed_out(self):\n return self.__timed_out","def test_progress__fail(self):\n # progress all quests\n self.character.quests.progress()\n # progress one quest\n self.character.quests.progress(_TestQuest.key)\n\n # still on step A\n self.assertEqual(self._get_quest().current_step, \"A\")","def _timestep_after_hook(self, *args, **kwargs):\n pass","def setTimeout(self, timeout):\n self.timeout = timeout","def failed_workflow_cleanup_duration(self,\n failed_workflow_cleanup_duration):\n\n self._failed_workflow_cleanup_duration = failed_workflow_cleanup_duration","def timeout(self, value):\n if isinstance(value, timedelta):\n value = value.days * 3600 * 24 + value.seconds\n self._timeout = value # noqa","def test_timeout_not_exceeded():\n connection = FakeBaseConnection(session_timeout=10)\n start = time.time()\n assert not connection._timeout_exceeded(start)","def _timeout_observer(self, connection_observer, timeout, passed_time, runner_logger, kind=\"background_run\"):\n if not connection_observer.life_status.was_on_timeout_called:\n connection_observer.life_status.was_on_timeout_called = True\n if not connection_observer.done():\n if connection_observer.is_command():\n exception = CommandTimeout(connection_observer=connection_observer,\n timeout=timeout, kind=kind, passed_time=passed_time)\n else:\n exception = ConnectionObserverTimeout(connection_observer=connection_observer,\n timeout=timeout, kind=kind, passed_time=passed_time)\n connection_observer.set_exception(exception)\n connection_observer.on_timeout()\n\n observer_info = \"{}.{}\".format(connection_observer.__class__.__module__, connection_observer)\n timeout_msg = \"has timed out after {:.2f} seconds.\".format(passed_time)\n msg = \"{} {}\".format(observer_info, timeout_msg)\n\n # levels_to_go_up: extract caller info to log where .time_out_observer has been called from\n connection_observer._log(logging.INFO, msg, levels_to_go_up=2)\n log_into_logger(runner_logger, level=logging.DEBUG,\n msg=\"{} {}\".format(connection_observer, timeout_msg),\n levels_to_go_up=1)","def timeout(self) -> str:\n return pulumi.get(self, \"timeout\")","def timeout(self, timeout):\n if (self.local_vars_configuration.client_side_validation and\n timeout is not None and not isinstance(timeout, int)):\n raise ValueError(\"Parameter `timeout` must be an integer\") # noqa: E501\n\n self._timeout = timeout"],"string":"[\n \"def raise_timeout(self, *args, **kwargs):\\n\\n self.log.error(\\\"Task timeout encountered.\\\")\\n raise TimeoutError\",\n \"def handler(*args, **kwargs):\\n raise TimeoutException(\\\"Test aborted due to timeout. Test was \\\" +\\n \\\"expected to finish in less than {} second(s).\\\".format(time_limit))\",\n \"def StepFailure(self):\\n return recipe_api.StepFailure\",\n \"async def timeout(self, failed: bool = False) -> None:\\n raise NotImplementedError()\",\n \"def test_timeout_elapsed_exception(self):\\n deadline = Deadline(-MS)\\n with self.assertRaises(TimeoutError):\\n deadline.timeout()\",\n \"def assert_timeout(self) -> None:\",\n \"def timeout(order):\\n return ResultProxy(TaskResult(TaskTimedout('A task has timedout'), order))\",\n \"def _timeout(signum, frame):\\n # Raise TimeoutException with system default timeout message\\n raise TimeoutException()\",\n \"def test_timeoutRaises(self):\\n\\n @self.eventloop.wait_for(timeout=0.5)\\n def times_out():\\n return Deferred().addErrback(lambda f: f.trap(CancelledError))\\n\\n start = time.time()\\n self.assertRaises(TimeoutError, times_out)\\n self.assertTrue(abs(time.time() - start - 0.5) < 0.1)\",\n \"def _check_timeouts(self, chunk_timeout, total_timeout):\\n cur_time = time()\\n\\n if chunk_timeout is not None and cur_time > self._chunk_time + chunk_timeout:\\n raise ChunkTimeout('Item timeout expired.')\\n elif total_timeout is not None and cur_time > self._total_time + total_timeout:\\n raise TotalTimeout('Total timeout expired.')\",\n \"def test_timeout(self, mocker, mock_timedelta):\\n\\n tid = 289466\\n site = \\\"mysite\\\"\\n\\n exception_response = self.generate_task_dictionary(\\n tid, state=\\\"started\\\", completed=None\\n )\\n\\n responses = [{\\\"json\\\": exception_response}]\\n url = (\\n \\\"https://cloudapi.acquia.com/v1/\\\"\\n \\\"sites/prod:{site}/tasks/{tid}.json\\\".format(tid=tid, site=site)\\n )\\n\\n mocker.register_uri(\\\"GET\\\", url, responses)\\n\\n with self.assertRaises(exceptions.AcquiaCloudTimeoutError):\\n self.client.site(site).task(tid).wait(0)\",\n \"def _handle_timeout(self, frame=None, **_):\\n\\n raise TimeOut.TimeOutError(self, frame)\",\n \"def test_failed_processing(self):\\n # setup\\n ledger_api_dialogue, fipa_dialogue = self._setup_fipa_ledger_api_dialogues(self)\\n\\n self.transaction_behaviour.timedout.add(ledger_api_dialogue.dialogue_label)\\n\\n # operation\\n with patch.object(self.logger, \\\"log\\\") as mock_logger:\\n self.transaction_behaviour.failed_processing(ledger_api_dialogue)\\n\\n # after\\n self.assert_quantity_in_outbox(0)\\n\\n # finish_processing\\n assert self.transaction_behaviour.timedout == set()\\n\\n mock_logger.assert_any_call(\\n logging.DEBUG,\\n f\\\"Timeout dialogue in transaction processing: {ledger_api_dialogue}\\\",\\n )\\n\\n # failed_processing\\n assert fipa_dialogue in self.transaction_behaviour.waiting\",\n \"def assert_timeout(self) -> None:\\n if self._cancelled:\\n raise asyncio.TimeoutError from None\",\n \"def onTimeStepEnd(self, timeStep):\\n pass\",\n \"def test_step_stop_aborted(self, _step: PropertyMock):\\n _step.return_value = None\\n es = exposed.ExposedStep()\\n es.stop()\",\n \"def testTimeout(self):\\n\\n class TimeoutTestCase(cros_test_lib.TestCase):\\n \\\"\\\"\\\"Test case that raises a TimeoutError because it takes too long.\\\"\\\"\\\"\\n\\n TEST_CASE_TIMEOUT = 1\\n\\n def testSleeping(self):\\n \\\"\\\"\\\"Sleep for 2 minutes. This should raise a TimeoutError.\\\"\\\"\\\"\\n time.sleep(2 * 60)\\n raise AssertionError('Test case should have timed out.')\\n\\n # Run the test case, verifying it raises a TimeoutError.\\n test = TimeoutTestCase(methodName='testSleeping')\\n self.assertRaises(timeout_util.TimeoutError, test.testSleeping)\",\n \"def test_set_timeout_value_error(self, timeout):\\n self.assertRaises(ValueError, self.root.set_timeout, timeout)\",\n \"def check_timeout(self, msg):\\n if msg.clock.secs > self.timeout and not self.is_cancelled:\\n rospy.loginfo(\\\"Test timed out, cancelling job\\\")\\n self.utils.set_tag(name=self.test_name + \\\"_Status\\\", value=\\\"Failed\\\")\\n self.utils.set_tag(name=self.test_name + \\\"_Timed_Out\\\", value=str(self.timeout))\\n self.utils.cancel_job()\",\n \"def test_timeout(self):\\n start = time.time()\\n dr = EventualResult(Deferred(), None)\\n self.assertRaises(TimeoutError, dr.wait, timeout=0.03)\\n # be a little lenient for slow computers:\\n self.assertTrue(abs(time.time() - start) < 0.05)\",\n \"def pytest_timeout_cancel_timer(item):\",\n \"def test_wait_for_predicate_timeout(self):\\n predicate_mock = mock.MagicMock(side_effect=[True, True, True])\\n with self.assertRaises(TimeoutError):\\n train_utils.wait_for_predicate(predicate_mock, num_retries=3)\",\n \"def _test_run_with_long_error_msg(self, task_class):\\r\\n task_entry = self._create_input_entry()\\r\\n self.define_option_problem(PROBLEM_URL_NAME)\\r\\n expected_message = \\\"x\\\" * 1500\\r\\n with self.assertRaises(TestTaskFailure):\\r\\n self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id, expected_message)\\r\\n # compare with entry in table:\\r\\n entry = InstructorTask.objects.get(id=task_entry.id)\\r\\n self.assertEquals(entry.task_state, FAILURE)\\r\\n self.assertGreater(1023, len(entry.task_output))\\r\\n output = json.loads(entry.task_output)\\r\\n self.assertEquals(output['exception'], 'TestTaskFailure')\\r\\n self.assertEquals(output['message'], expected_message[:len(output['message']) - 3] + \\\"...\\\")\\r\\n self.assertTrue('traceback' not in output)\",\n \"def __step_waiter(self, step_id):\\n\\n # don't forget to tip the waiter :)\\n step_waiter = self.emr_client.get_waiter('step_complete')\\n try:\\n step_waiter.wait(ClusterId=self.clusID,\\n StepId=step_id[0],\\n WaiterConfig={\\n 'Delay': 15,\\n 'MaxAttempts': 480\\n })\\n\\n except WaiterError as e:\\n if 'Max attempts exceeded' in e.message:\\n print('EMR Step did not complete in two hours')\\n else:\\n print(e.message)\",\n \"def test_task_failed(self):\\n\\n task1 = FailedTask(mock.Mock(), total_retries=0)\\n task2 = mock.Mock(execute_after=0)\\n\\n g = TaskDependencyGraph(MockWorkflowContext())\\n seq = g.sequence()\\n seq.add(task1, task2)\\n\\n with limited_sleep_mock():\\n self.assertRaisesRegex(WorkflowFailed, 'failtask', g.execute)\\n self.assertTrue(task1.is_terminated)\\n self.assertFalse(task2.apply_async.called)\",\n \"def step(self):\\n raise TaskError(\\\"Task %s: subclass should override step() method!\\\" %\\n self)\",\n \"def pytest_exception_interact(node):\\n hooks = node.config.pluginmanager.hook\\n hooks.pytest_timeout_cancel_timer(item=node)\",\n \"def test_timeout_retries(self):\\n\\n batch = Batch(Mock())\\n self.check_instance(batch=batch)\\n\\n self.assertEqual(batch.timeout_retries, 0)\\n self.check_instance(batch, timeout_retries=0)\\n\\n batch.timeout_retries = 10\\n self.assertEqual(batch.timeout_retries, 10)\\n self.check_instance(batch, timeout_retries=10)\\n\\n batch.timeout_retries = 0\\n self.assertEqual(batch.timeout_retries, 0)\\n self.check_instance(batch, timeout_retries=0)\\n\\n batch.timeout_retries = 1\\n self.assertEqual(batch.timeout_retries, 1)\\n self.check_instance(batch, timeout_retries=1)\\n\\n # exceptions\\n ## error messages\\n value_error = \\\"'timeout_retries' must be positive, i.e. greater or equal that zero (>=0).\\\"\\n type_error = f\\\"'timeout_retries' must be of type {int}.\\\"\\n\\n #######################################################################\\n # test wrong value\\n with self.assertRaises(ValueError) as error:\\n batch.timeout_retries = -1\\n self.assertEqual(batch.timeout_retries, 1)\\n self.check_instance(batch, timeout_retries=1)\\n check_error_message(self, error, value_error)\\n\\n #######################################################################\\n # test wrong type\\n with self.assertRaises(TypeError) as error:\\n batch.timeout_retries = True\\n self.assertEqual(batch.timeout_retries, 1)\\n self.check_instance(batch, timeout_retries=1)\\n check_error_message(self, error, type_error)\\n\\n with self.assertRaises(TypeError) as error:\\n batch.timeout_retries = '2'\\n self.assertEqual(batch.timeout_retries, 1)\\n self.check_instance(batch, timeout_retries=1)\\n check_error_message(self, error, type_error)\",\n \"def fail(self):\\n self.cleanup()\\n self.runner.report_job_fail(self.id)\",\n \"def test_timeout_elapsed_no_exception(self):\\n deadline = Deadline(-MS)\\n timeout = deadline.timeout(raise_if_elapsed=False)\\n self.assertGreater(timeout, -2 * MS)\\n self.assertLess(timeout, -MS)\",\n \"def test_pipeline_timeout(mockpipe_timeout, testdir):\\n test = testdir.makepyfile(TEST_TIMEOUT)\\n result = testdir.inline_run(\\n \\\"-v\\\",\\n f\\\"--base-pipeline-dir={test.dirname}\\\",\\n test\\n )\\n passed, skipped, failed = result.listoutcomes()\\n\\n assert len(passed) == 0\\n assert len(skipped) == 0\\n assert len(failed) == 1\",\n \"def timeout(self, timeout):\\n assert timeout is None or timeout > 0\\n self._timeout = timeout\",\n \"def test_timeout_twice(self):\\n dr = EventualResult(Deferred(), None)\\n self.assertRaises(TimeoutError, dr.wait, timeout=0.01)\\n self.assertRaises(TimeoutError, dr.wait, timeout=0.01)\",\n \"def test_wait_timeout_raises():\\n with pytest.raises(WaitTimeOut) as err_info:\\n raise WaitTimeOut(\\\"this is error text right here\\\")\\n\\n assert str(err_info.value) == \\\"this is error text right here\\\"\",\n \"def timeout(time_limit):\\n\\n def wrapUnitTest(testcase):\\n\\n @wraps(testcase)\\n def testWrapper(self):\\n\\n queue = Queue()\\n\\n try:\\n p = Thread(target=handler, args=(self, testcase, queue))\\n p.daemon = True\\n p.start()\\n err, res = queue.get(timeout=time_limit)\\n p.join()\\n if err:\\n raise err[0](err[1]).with_traceback(err[2])\\n return res\\n except QueueEmptyError:\\n raise TimeoutError(\\\"Test aborted due to timeout. Test was \\\" +\\n \\\"expected to finish in less than {} second(s).\\\".format(time_limit))\\n\\n return testWrapper\\n\\n return wrapUnitTest\",\n \"def test_timeoutCancels(self):\\n result = Deferred()\\n error = []\\n result.addErrback(error.append)\\n\\n @self.eventloop.wait_for(timeout=0.0)\\n def times_out():\\n return result\\n\\n self.assertRaises(TimeoutError, times_out)\\n self.assertIsInstance(error[0].value, CancelledError)\",\n \"def test_timeout_exceeded():\\n connection = FakeBaseConnection(session_timeout=10)\\n start = time.time() - 11\\n try:\\n connection._timeout_exceeded(start)\\n except NetmikoTimeoutException as exc:\\n assert isinstance(exc, NetmikoTimeoutException)\\n return\\n\\n assert False\",\n \"def failure(self, target):\\n print \\\"FAILED:\\\"\\n self.show_target(target)\\n self.failed += 1\",\n \"def test_timeout_processing(self):\\n # setup\\n self.transaction_behaviour.processing_time = None\\n\\n # operation\\n self.transaction_behaviour._timeout_processing()\\n\\n # after\\n self.assert_quantity_in_outbox(0)\",\n \"def testTrialErrored(self):\\n stats = self.default_statistics()\\n trial_count = stats[str(0)][\\\"n\\\"] + 3\\n sched, mock_runner = self.schedulerSetup(trial_count)\\n t1, t2, t3 = sched._state[\\\"bracket\\\"].current_trials()\\n for t in [t1, t2, t3]:\\n mock_runner._launch_trial(t)\\n\\n sched.on_trial_error(mock_runner, t3)\\n self.assertEqual(\\n TrialScheduler.PAUSE,\\n sched.on_trial_result(\\n mock_runner, t1, result(stats[str(1)][\\\"r\\\"], 10)))\\n self.assertEqual(\\n TrialScheduler.CONTINUE,\\n sched.on_trial_result(\\n mock_runner, t2, result(stats[str(1)][\\\"r\\\"], 10)))\",\n \"def fail_job( self, job_state ):\\n self.stop_job( self.sa_session.query( self.app.model.Job ).get( job_state.job_wrapper.job_id ) )\\n job_state.job_wrapper.fail( getattr( job_state, \\\"fail_message\\\", GENERIC_REMOTE_ERROR ) )\",\n \"def on_trial_error(self, trial: Trial):\\n pass\",\n \"def raise_step_error(self, error: Exception, step: str):\\n error_message = \\\"{}\\\\nFailed: Error={}\\\".format(step, str(error))\\n logging.error(error_message)\\n self.slacker.send_thread_reply(error_message)\\n raise Exception(error_message)\",\n \"def timeout(time_limit):\\n\\n class TimeoutException(Exception):\\n \\\"\\\"\\\" Subclass Exception to catch timer expiration during search \\\"\\\"\\\"\\n pass\\n\\n def handler(*args, **kwargs):\\n \\\"\\\"\\\" Generic handler to raise an exception when a timer expires \\\"\\\"\\\"\\n raise TimeoutException(\\\"Test aborted due to timeout. Test was \\\" +\\n \\\"expected to finish in less than {} second(s).\\\".format(time_limit))\\n\\n def wrapUnitTest(testcase):\\n\\n @wraps(testcase)\\n def testWrapper(self, *args, **kwargs):\\n\\n signal.signal(signal.SIGALRM, handler)\\n signal.alarm(time_limit)\\n\\n try:\\n return testcase(self, *args, **kwargs)\\n finally:\\n signal.alarm(0)\\n\\n return testWrapper\\n\\n return wrapUnitTest\",\n \"def raise_timeout_error(api_url, headers, timeout, proxies):\\n raise requests.exceptions.Timeout\",\n \"def raise_timeout_error(api_url, headers, timeout, proxies):\\n raise requests.exceptions.Timeout\",\n \"def set_timeout(self, timeout: int) -> None:\\n raise WatchdogError(\\\"Setting timeout is not supported on {0}\\\".format(self.describe()))\",\n \"def timeout(seconds, error_message=\\\"Time out.\\\"):\\n import signal\\n def decorator(func):\\n\\n def __timiout_handler(signum, frame):\\n raise TimeoutError(error_message)\\n\\n @functools.wraps(func)\\n def wrapper(*arg, **kw):\\n signal.signal(signal.SIGALRM, __timiout_handler)\\n signal.alarm(seconds)\\n ret = \\\"\\\"\\n try:\\n ret = func(*arg, **kw)\\n except TimeoutError,e:\\n print \\\"TimeoutError: \\\", e\\n print \\\"{name} ran more than {seconds}s.\\\".format(name=func.__name__, seconds=seconds)\\n except Exception,e:\\n print \\\"Error: \\\",e\\n finally:\\n signal.alarm(0)\\n return ret\\n return wrapper\\n return decorator\",\n \"def raise_timeout_error_upload(api_url, headers, data, timeout, proxies):\\n raise requests.exceptions.Timeout\",\n \"def test_failure_result(self):\\n dr = EventualResult(fail(RuntimeError()), None)\\n self.assertRaises(RuntimeError, dr.wait, 0.1)\",\n \"def error_detection_timeout(self, error_detection_timeout):\\n\\n self._error_detection_timeout = error_detection_timeout\",\n \"def test_fail(make_runner: Callable[..., TargetFunctionRunner]) -> None:\\n runner = make_runner(target_failed, use_instances=True)\\n run_info = TrialInfo(config=2, instance=\\\"test\\\", seed=0, budget=0.0)\\n\\n runner.submit_trial(run_info)\\n run_info, run_value = next(runner.iter_results())\\n\\n # Make sure the traceback message is included\\n assert \\\"traceback\\\" in run_value.additional_info\\n assert \\\"RuntimeError\\\" in run_value.additional_info[\\\"traceback\\\"]\",\n \"def timeout(self, timeout):\\n\\n self._timeout = timeout\",\n \"def test_wait_timeout_inheritance():\\n # confirm subclassed from pypyr root error\\n err = WaitTimeOut()\\n assert isinstance(err, PypyrAwsError)\\n assert isinstance(err, PlugInError)\\n assert isinstance(err, PypyrError)\",\n \"def cancelled_to_request_timed_out_error(value, timeout):\\n if isinstance(value, failure.Failure):\\n value.trap(CancelledError)\\n raise RequestTimedOutError()\\n return value\",\n \"def stopped_check(self, timeout=None):\",\n \"def inject_failure(self):\\n while len(self.circQ):\\n yield self.env.timeout(time_to_failure())\\n if len(self.circQ) > 0 and \\\\\\n not self.currentProc.broken and \\\\\\n self.currentProc.workLeft > 0:\\n # Only break the machine if it is currently computing,\\n # and if current proc is not restarting\\n # TODO: Allow errors to be thrown while restarting\\n self.BqLog(\\\"Injecting a failure in %s\\\" % (self.currentProc.name))\\n self.numFailures += 1\\n self.process.interrupt(cause=\\\"failure\\\")\",\n \"def grr_set_flow_timeout(line: Text) -> None:\\n args = grr_set_flow_timeout.parser.parse_args(shlex.split(line))\\n magics_impl.grr_set_flow_timeout_impl(args.timeout)\",\n \"def test_timeout(self) -> Optional[pulumi.Input['DurationArgs']]:\\n return pulumi.get(self, \\\"test_timeout\\\")\",\n \"def test_timeout(self) -> Optional[pulumi.Input['DurationArgs']]:\\n return pulumi.get(self, \\\"test_timeout\\\")\",\n \"def test_timeout_pending(self):\\n deadline = Deadline(MS)\\n timeout = deadline.timeout()\\n self.assertGreater(timeout, 0)\\n self.assertLess(timeout, MS)\",\n \"def on_trial_error(self, trial_runner, trial):\\n\\n raise NotImplementedError\",\n \"def end_failure(self, error: Exception):\\n if self.__tracer is not None:\\n elapsed = (datetime.datetime.now().timestamp() * 1000) - self.__start\\n self.__tracer.failure(self.__correlation_id, self.__component, self.__operation, error, round(elapsed))\",\n \"def test_polling_custom_interval():\\n with pytest.raises(polling2.MaxCallException):\\n polling2.poll(\\n target=lambda: requests.get(\\\"http://google.com\\\").status_code == 400,\\n step_function=_custom_step, # adds 0.5 seconds to each iteration\\n # step_function=polling.step_constant, # returns step\\n # step_function=polling.step_linear_double, # returns step * 2\\n step=0.5,\\n max_tries=3,\\n )\",\n \"def on_saga_failure(self, failed_step: BaseStep, initial_failure_payload: dict):\\n logger.info(f'Saga {self.saga_id} failed on \\\"{failed_step.name}\\\" step. \\\\n'\\n f'Failure details: {initial_failure_payload}')\",\n \"def onTimeStep(self, timeStep):\\n pass\",\n \"def transition_on_timeout(timeout, *, to):\\n\\n # Figure out how many cycles need to pass before we consider ourselves timed out.\\n timeout_in_cycles = int(math.ceil(timeout * self._clock_frequency))\\n\\n # If we've reached that many cycles, transition to the target state.\\n with m.If(cycles_in_state == timeout_in_cycles):\\n transition_to_state(to)\",\n \"def pytest_timeout_set_timer(item, settings):\",\n \"async def test_timeout_error(hass: HomeAssistant, mock_daikin) -> None:\\n config_entry = MockConfigEntry(\\n domain=DOMAIN,\\n unique_id=MAC,\\n data={CONF_HOST: HOST, KEY_MAC: MAC},\\n )\\n config_entry.add_to_hass(hass)\\n\\n mock_daikin.factory.side_effect = asyncio.TimeoutError\\n await hass.config_entries.async_setup(config_entry.entry_id)\\n await hass.async_block_till_done()\\n\\n assert config_entry.state == ConfigEntryState.SETUP_RETRY\",\n \"def raise_timeout_exception(self, _result=None, _timeout=None):\\n raise RosTimeoutError(\\\"No service response received\\\")\",\n \"def _test_run_with_failure(self, task_class, expected_message):\\r\\n task_entry = self._create_input_entry()\\r\\n self.define_option_problem(PROBLEM_URL_NAME)\\r\\n with self.assertRaises(TestTaskFailure):\\r\\n self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id, expected_message)\\r\\n # compare with entry in table:\\r\\n entry = InstructorTask.objects.get(id=task_entry.id)\\r\\n self.assertEquals(entry.task_state, FAILURE)\\r\\n output = json.loads(entry.task_output)\\r\\n self.assertEquals(output['exception'], 'TestTaskFailure')\\r\\n self.assertEquals(output['message'], expected_message)\",\n \"def set_timeout(self, timeout):\\n pass\",\n \"def _do_fail_retry(self, event):\\n if self._retries > 0:\\n self._retries -= 1\\n self._state_machine.retry()\\n else:\\n self._state_machine.abort(result=event.result)\",\n \"def _do_fail_retry(self, event):\\n if self._retries > 0:\\n self._retries -= 1\\n self._state_machine.retry()\\n else:\\n self._state_machine.abort(result=event.result)\",\n \"def test_timeout(self) -> 'outputs.DurationResponse':\\n return pulumi.get(self, \\\"test_timeout\\\")\",\n \"def test_timeout(self) -> 'outputs.DurationResponse':\\n return pulumi.get(self, \\\"test_timeout\\\")\",\n \"def get_test_timeout(self):\\n return None\",\n \"def test_failed_job(self):\\n\\n failed_job = json.loads(TREEHERDER_JOB % (\\\"testfailed\\\", \\\"completed\\\"))\\n self.assertEquals(self.query_api.get_job_status(failed_job), FAILURE)\",\n \"def set_timeout(self, timeout):\\n self.timeout = timeout\",\n \"def testTrialErrored2(self):\\n stats = self.default_statistics()\\n trial_count = stats[str(0)][\\\"n\\\"] + stats[str(1)][\\\"n\\\"]\\n sched, mock_runner = self.schedulerSetup(trial_count)\\n trials = sched._state[\\\"bracket\\\"].current_trials()\\n for t in trials[:-1]:\\n mock_runner._launch_trial(t)\\n sched.on_trial_result(\\n mock_runner, t, result(stats[str(1)][\\\"r\\\"], 10))\\n\\n mock_runner._launch_trial(trials[-1])\\n sched.on_trial_error(mock_runner, trials[-1])\\n self.assertEqual(len(sched._state[\\\"bracket\\\"].current_trials()),\\n self.downscale(stats[str(1)][\\\"n\\\"], sched))\",\n \"def test_timeout(self, timeout, tmpdir, monkeypatch):\\n\\n file_name = \\\"test_workflow.yaml\\\"\\n dev = qml.device(\\\"orquestra.forest\\\", wires=3, timeout=timeout)\\n mock_res_dict = {\\\"First\\\": {\\\"expval\\\": {\\\"list\\\": [123456789]}}}\\n\\n test_uuid = \\\"1234\\\"\\n assert dev._timeout == timeout\\n assert not os.path.exists(tmpdir.join(f\\\"expval-{test_uuid}.yaml\\\"))\\n with monkeypatch.context() as m:\\n m.setattr(pennylane_orquestra.cli_actions, \\\"user_data_dir\\\", lambda *args: tmpdir)\\n m.setattr(pennylane_orquestra.cli_actions, \\\"workflow_results\\\", lambda *args: \\\"Test res\\\")\\n\\n # Disable submitting to the Orquestra platform by mocking Popen\\n m.setattr(subprocess, \\\"Popen\\\", lambda *args, **kwargs: MockPopen())\\n\\n # Disable random uuid generation\\n m.setattr(uuid, \\\"uuid4\\\", lambda *args: test_uuid)\\n\\n @qml.qnode(dev)\\n def circuit():\\n qml.PauliX(0)\\n return qml.expval(qml.PauliZ(0))\\n\\n start = time.time()\\n with pytest.raises(TimeoutError, match=\\\"The workflow results for workflow\\\"):\\n circuit()\\n end = time.time()\\n assert end - start >= timeout\",\n \"def timeout_change(self, timedelta):\\n pass # pylint: disable=unnecessary-pass\\n # For backward compatibility only.\",\n \"def inject_failure(self):\\n # Inject a failure only if there's a process running\\n self.BqLog(\\\"Starting failure injection\\\")\\n while len(self.circQ) > 0 or (self.currentProc and self.currentProc.workLeft > 0):\\n t = time_to_failure()\\n self.BqLog(\\\"Inject the next failure after %d seconds\\\" % (t))\\n if t == 0:\\n continue\\n yield self.env.timeout(t)\\n if len(self.circQ) >= 0 and \\\\\\n self.currentProc.workLeft > 0:\\n # Only break the machine if it is currently computing,\\n # and if current proc is not restarting\\n self.BqLog(\\\"Injecting a failure in %s\\\" % (self.currentProc.name))\\n self.numFailures += 1\\n self.process.interrupt(cause=\\\"failure\\\")\",\n \"def timeout(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"timeout\\\")\",\n \"def timeout(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"timeout\\\")\",\n \"def test_pass_times_error_server(self):\\n with HTTMock(self.http_wrong):\\n self.assertRaises(Exception, self.iss.pass_times, 15,20)\",\n \"def trial_end(self, parameter_id, success, **kwargs):\",\n \"def test_state_after_failure(self):\\n pass\",\n \"def _timeout(self, timeout, f, *args, **kwargs):\\r\\n\\r\\n t = spawn_thread(target=f, args=args, kwargs=kwargs)\\r\\n t.daemon = True\\r\\n t.start()\\r\\n t.join(timeout)\\r\\n\\r\\n if not t.is_alive():\\r\\n if t.exc_info:\\r\\n return t.exc_info\\r\\n return t.result\\r\\n else:\\r\\n try:\\r\\n msg = '[%s] Execution was forcefully terminated'\\r\\n raise RuntimeError(msg % t.name)\\r\\n except:\\r\\n return sys.exc_info()\",\n \"def job_step_error(self, job_request_payload, message):\\n payload = JobStepErrorPayload(job_request_payload, message)\\n self.send(job_request_payload.error_command, payload)\",\n \"def timed_out(self):\\n return self.__timed_out\",\n \"def test_progress__fail(self):\\n # progress all quests\\n self.character.quests.progress()\\n # progress one quest\\n self.character.quests.progress(_TestQuest.key)\\n\\n # still on step A\\n self.assertEqual(self._get_quest().current_step, \\\"A\\\")\",\n \"def _timestep_after_hook(self, *args, **kwargs):\\n pass\",\n \"def setTimeout(self, timeout):\\n self.timeout = timeout\",\n \"def failed_workflow_cleanup_duration(self,\\n failed_workflow_cleanup_duration):\\n\\n self._failed_workflow_cleanup_duration = failed_workflow_cleanup_duration\",\n \"def timeout(self, value):\\n if isinstance(value, timedelta):\\n value = value.days * 3600 * 24 + value.seconds\\n self._timeout = value # noqa\",\n \"def test_timeout_not_exceeded():\\n connection = FakeBaseConnection(session_timeout=10)\\n start = time.time()\\n assert not connection._timeout_exceeded(start)\",\n \"def _timeout_observer(self, connection_observer, timeout, passed_time, runner_logger, kind=\\\"background_run\\\"):\\n if not connection_observer.life_status.was_on_timeout_called:\\n connection_observer.life_status.was_on_timeout_called = True\\n if not connection_observer.done():\\n if connection_observer.is_command():\\n exception = CommandTimeout(connection_observer=connection_observer,\\n timeout=timeout, kind=kind, passed_time=passed_time)\\n else:\\n exception = ConnectionObserverTimeout(connection_observer=connection_observer,\\n timeout=timeout, kind=kind, passed_time=passed_time)\\n connection_observer.set_exception(exception)\\n connection_observer.on_timeout()\\n\\n observer_info = \\\"{}.{}\\\".format(connection_observer.__class__.__module__, connection_observer)\\n timeout_msg = \\\"has timed out after {:.2f} seconds.\\\".format(passed_time)\\n msg = \\\"{} {}\\\".format(observer_info, timeout_msg)\\n\\n # levels_to_go_up: extract caller info to log where .time_out_observer has been called from\\n connection_observer._log(logging.INFO, msg, levels_to_go_up=2)\\n log_into_logger(runner_logger, level=logging.DEBUG,\\n msg=\\\"{} {}\\\".format(connection_observer, timeout_msg),\\n levels_to_go_up=1)\",\n \"def timeout(self) -> str:\\n return pulumi.get(self, \\\"timeout\\\")\",\n \"def timeout(self, timeout):\\n if (self.local_vars_configuration.client_side_validation and\\n timeout is not None and not isinstance(timeout, int)):\\n raise ValueError(\\\"Parameter `timeout` must be an integer\\\") # noqa: E501\\n\\n self._timeout = timeout\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6783338","0.6670357","0.6458349","0.6233549","0.620531","0.6151229","0.61305606","0.6103031","0.59383696","0.5915559","0.5886344","0.5850895","0.58435684","0.58397263","0.5815907","0.5812256","0.576869","0.5734896","0.5714007","0.56782407","0.56605077","0.5657417","0.5595983","0.5576143","0.55475986","0.5510916","0.5483291","0.5479062","0.5474232","0.5470697","0.5464927","0.5464671","0.54575634","0.54533696","0.5453333","0.54485744","0.54314154","0.5428915","0.54010683","0.539764","0.53960466","0.539481","0.5393146","0.5383996","0.53727674","0.53727674","0.53589004","0.5356304","0.5353029","0.53518677","0.5341568","0.5336356","0.5331105","0.5327217","0.5318342","0.53102636","0.5305946","0.5298865","0.52947414","0.52947414","0.52862656","0.5280357","0.5275419","0.52709675","0.5260154","0.5256531","0.5254572","0.5250279","0.52444607","0.5243784","0.5236402","0.5236256","0.5229225","0.5229225","0.5224458","0.5224458","0.52235574","0.5222473","0.5215483","0.52084464","0.5204799","0.5202364","0.5193975","0.5187106","0.5187106","0.51860386","0.516845","0.51291466","0.5123117","0.5117812","0.5117453","0.51157373","0.5111363","0.51050705","0.50997037","0.50975853","0.50962245","0.5090135","0.50892955","0.50870377"],"string":"[\n \"0.6783338\",\n \"0.6670357\",\n \"0.6458349\",\n \"0.6233549\",\n \"0.620531\",\n \"0.6151229\",\n \"0.61305606\",\n \"0.6103031\",\n \"0.59383696\",\n \"0.5915559\",\n \"0.5886344\",\n \"0.5850895\",\n \"0.58435684\",\n \"0.58397263\",\n \"0.5815907\",\n \"0.5812256\",\n \"0.576869\",\n \"0.5734896\",\n \"0.5714007\",\n \"0.56782407\",\n \"0.56605077\",\n \"0.5657417\",\n \"0.5595983\",\n \"0.5576143\",\n \"0.55475986\",\n \"0.5510916\",\n \"0.5483291\",\n \"0.5479062\",\n \"0.5474232\",\n \"0.5470697\",\n \"0.5464927\",\n \"0.5464671\",\n \"0.54575634\",\n \"0.54533696\",\n \"0.5453333\",\n \"0.54485744\",\n \"0.54314154\",\n \"0.5428915\",\n \"0.54010683\",\n \"0.539764\",\n \"0.53960466\",\n \"0.539481\",\n \"0.5393146\",\n \"0.5383996\",\n \"0.53727674\",\n \"0.53727674\",\n \"0.53589004\",\n \"0.5356304\",\n \"0.5353029\",\n \"0.53518677\",\n \"0.5341568\",\n \"0.5336356\",\n \"0.5331105\",\n \"0.5327217\",\n \"0.5318342\",\n \"0.53102636\",\n \"0.5305946\",\n \"0.5298865\",\n \"0.52947414\",\n \"0.52947414\",\n \"0.52862656\",\n \"0.5280357\",\n \"0.5275419\",\n \"0.52709675\",\n \"0.5260154\",\n \"0.5256531\",\n \"0.5254572\",\n \"0.5250279\",\n \"0.52444607\",\n \"0.5243784\",\n \"0.5236402\",\n \"0.5236256\",\n \"0.5229225\",\n \"0.5229225\",\n \"0.5224458\",\n \"0.5224458\",\n \"0.52235574\",\n \"0.5222473\",\n \"0.5215483\",\n \"0.52084464\",\n \"0.5204799\",\n \"0.5202364\",\n \"0.5193975\",\n \"0.5187106\",\n \"0.5187106\",\n \"0.51860386\",\n \"0.516845\",\n \"0.51291466\",\n \"0.5123117\",\n \"0.5117812\",\n \"0.5117453\",\n \"0.51157373\",\n \"0.5111363\",\n \"0.51050705\",\n \"0.50997037\",\n \"0.50975853\",\n \"0.50962245\",\n \"0.5090135\",\n \"0.50892955\",\n \"0.50870377\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7499932"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8997,"cells":{"query":{"kind":"string","value":"The currently active (open) result from the last step that was run. This is a `types.StepData` object."},"document":{"kind":"string","value":"def active_result(self):\n return self.step_client.previous_step_result()"},"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 result(self):\n # most pythonic way to get last in last is -1\n return self.history[-1]","def current_progress_data(self):\n return self._current_progress_data","def previous_step_result(self):\n return self._previous_step_result","def cur_step(self):\n return self._cur_step","def previous_step_result(self):\n if not self._engine._step_stack:\n raise ValueError(\n 'No steps have been run yet, and you are asking for a previous step '\n 'result.')\n return self._engine._step_stack[-1].step_result","def get_last_result(self):\n return self.last_result","def getCurrentStep():","def last_triggered_step(self):\n return self._last_triggered_step","def result(self):\n assert(self.__complete)\n return self.__result","def get_current_observation(self):\n return self.observation_history[-1]","def result( self):\n return self._result","def result(self):\n return self['result']","def get_last_solution(self):\n return self.last_result","def get_current_value(self):\n assert(self.is_started())\n return self.currValue","def currentValue(self):\n return self.__currentValue","def result(self):\n return self._result","def result(self):\n return self._result","def result(self):\n return self._result","def result(self):\n with self._condition:\n self.fetch()\n return self.__get_result()","def last_result(self):\n # TODO : when evaluating multiline expressions this returns the first result\n lr = self.jiloop.lastRequest()\n res = lr.lineRep().call(\"$result\", spark_jvm_helpers.to_scala_list([]))\n return res","def _get_result(self):\r\n \r\n return self._result","def current(self):\n return self._wizard.current_step or self.first","def get_data(self):\n return self._result","def state(self):\n result = self.getResult()\n return result.state","def last_value(self):\n return self._stop","def step(self):\n return self._step","def extract_goal_state(self):\n time = rospy.get_time()\n ref_time = time - self.last_time\n future_time = ref_time + self.update_rate\n\n # get state of future time in global trajectory\n return df.compute_output3D(self.global_solution, self.order, self.time[self.future_index], future_time)","def step(self):\n return self._step","def step(self):\n return self._step","def step(self):\n return self._step","def step(self):\n return self._step","def getCurrent(self):\n return self.__current","def result(self) -> T:\n if not self.done():\n raise InvalidStateError(\"result is not yet available\")\n elif self.cancelled():\n raise self._cancelled\n else:\n return self._outcome.get()","def GetCurrentItem(self):\r\n\r\n return self._current","def get_goal(self):\n return self.get_observation(self.env._get_goal())","def result(self) -> Item:\n return self._result","def get_current_task(self):\n return self.get_current_step().get_last_task()","def finish_checkpoint(self):\n return self.this_evaluation.checkpoint","def state(self):\n return self._current_value","def get_current_state(self, data):\r\n return self.get_context()","def current(self):\n return self._current","def current(self):\n return self._current","def current(self):\n return self._current","def get_step(self):\n return self.step","def get_step(self):\n return self.step","def result(self):\n with self.__lock:\n assert(self.__complete)\n return self.__result","def getObservation(self):\n return self._cur_state","def get_last_step(self):\n return self.get_step_by_index(-1)","def get_goal(self):\n self._pid_lock.acquire() # Acquire Lock\n rtn = self._goal\n self._pid_lock.release() # Release Lock\n\n return rtn","def getStep():\n # TODO: can there be non-Step logs?","def last_run(self):\n return self._last_run","def current_step(self) -> FlowNode:\n return self._current_step","def get_outcome(self):\n return self.__outcome","def current_time_step(self) -> ts.TimeStep:\n return self._current_time_step","def result(self):\n if self._child:\n return self._child.result()\n return self._result","def get_current(self) -> typing.Any:\n\n return self.current_obj","def get_state(self):\r\n return self.currentObservation","def get_value(self):\n return self.last_value","def result(self):\n if not self._last_command:\n return []\n return self._last_command.result()","def process_finish(self):\n return self.x","def process_finish(self):\n return self.x","def get_results(self):\n return self.result","def CurrentState(self):\n return self.currentState","def get(self):\n if not self.finished():\n self.wait()\n return self._result","def step ( self ) :\n return self.__step","def last_value(self):\n return self.samples[-1]","def active_step(self):\n if self._step_stack:\n return self._step_stack[-1]\n return None","def current_state(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"current_state\")","def get_result_of_first_calculation_added_to_history():\n return Calculator.history[0].getResult()","def last_state(self):\n return self._simstate","def get_result(self):\n try:\n return self.results.get_nowait()\n except Empty:\n return None","def getFinish(self):\n return self._finish","def current_value(self):\n return self.current_counter.value","def get_current_state(self):\n return self.nextYs[-1]","def get_current(self):\n return self.current","def last_value(self):\n return self._last_value","def current_temp(self):\n return self._current_temp","def result(self):\n if self._result is not None:\n return self._result\n if self._exc_info is not None:\n raise self._exc_info[0], self._exc_info[1], self._exc_info[2]\n self._check_done()\n return self._result","def current_operation(self):\n return self.state","def result(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"result\")","def get_current_turn(self):\n return self.turns.latest('number')","def last_value(self):\n return self._waveforms[-1].last_value","def best_step(self):\r\n return self._best_value_step","def last_processed(self):\n return self._last_processed","def state(self):\n return self.probe.get_data(self.variable)","def state(self):\n return self.probe.get_data(self.variable)","def get_output(self):\r\n return self._api.get_output()","def output(self) -> pulumi.Output[Optional['outputs.JobStepOutputResponse']]:\n return pulumi.get(self, \"output\")","def current_martingale(self):\n t, *_ = self._integrator.get_state(copy=False)\n return self._martingale.value(t)","def last_attempt_result(self) -> Optional[pulumi.Input['InstanceAttemptResultArgs']]:\n return pulumi.get(self, \"last_attempt_result\")","def get_current(self) -> int:\n return self._current","def get_current_step(self):\n try:\n return self.get_step_by_id(self.current_step.id)\n except (AttributeError, ValueError):\n message = \"The current step for this ticket is not set.\"\n logger.debug(message)\n raise KeyError(message)","def get_current(self):\n return self.x","def last_value(self):\n return self._value","def value(self):\n\n return self._progress.value()","def outcome(self):\r\n return self._outcome","def latest_state_data(self):\n if not self.state_list:\n return None\n if not self.state_list[-1]:\n return None\n return self.state_list[-1]","def get_output(self):\n return self._output","def get_current_token(self):\n with self._lock:\n if self._unfinished_ids:\n return self._unfinished_ids[0] - self._step\n\n return self._current","def getCurrentObservation(self):\n\n if (len(self.observationHistory) == 0):\n return None\n\n return self.observationHistory[-1]"],"string":"[\n \"def result(self):\\n # most pythonic way to get last in last is -1\\n return self.history[-1]\",\n \"def current_progress_data(self):\\n return self._current_progress_data\",\n \"def previous_step_result(self):\\n return self._previous_step_result\",\n \"def cur_step(self):\\n return self._cur_step\",\n \"def previous_step_result(self):\\n if not self._engine._step_stack:\\n raise ValueError(\\n 'No steps have been run yet, and you are asking for a previous step '\\n 'result.')\\n return self._engine._step_stack[-1].step_result\",\n \"def get_last_result(self):\\n return self.last_result\",\n \"def getCurrentStep():\",\n \"def last_triggered_step(self):\\n return self._last_triggered_step\",\n \"def result(self):\\n assert(self.__complete)\\n return self.__result\",\n \"def get_current_observation(self):\\n return self.observation_history[-1]\",\n \"def result( self):\\n return self._result\",\n \"def result(self):\\n return self['result']\",\n \"def get_last_solution(self):\\n return self.last_result\",\n \"def get_current_value(self):\\n assert(self.is_started())\\n return self.currValue\",\n \"def currentValue(self):\\n return self.__currentValue\",\n \"def result(self):\\n return self._result\",\n \"def result(self):\\n return self._result\",\n \"def result(self):\\n return self._result\",\n \"def result(self):\\n with self._condition:\\n self.fetch()\\n return self.__get_result()\",\n \"def last_result(self):\\n # TODO : when evaluating multiline expressions this returns the first result\\n lr = self.jiloop.lastRequest()\\n res = lr.lineRep().call(\\\"$result\\\", spark_jvm_helpers.to_scala_list([]))\\n return res\",\n \"def _get_result(self):\\r\\n \\r\\n return self._result\",\n \"def current(self):\\n return self._wizard.current_step or self.first\",\n \"def get_data(self):\\n return self._result\",\n \"def state(self):\\n result = self.getResult()\\n return result.state\",\n \"def last_value(self):\\n return self._stop\",\n \"def step(self):\\n return self._step\",\n \"def extract_goal_state(self):\\n time = rospy.get_time()\\n ref_time = time - self.last_time\\n future_time = ref_time + self.update_rate\\n\\n # get state of future time in global trajectory\\n return df.compute_output3D(self.global_solution, self.order, self.time[self.future_index], future_time)\",\n \"def step(self):\\n return self._step\",\n \"def step(self):\\n return self._step\",\n \"def step(self):\\n return self._step\",\n \"def step(self):\\n return self._step\",\n \"def getCurrent(self):\\n return self.__current\",\n \"def result(self) -> T:\\n if not self.done():\\n raise InvalidStateError(\\\"result is not yet available\\\")\\n elif self.cancelled():\\n raise self._cancelled\\n else:\\n return self._outcome.get()\",\n \"def GetCurrentItem(self):\\r\\n\\r\\n return self._current\",\n \"def get_goal(self):\\n return self.get_observation(self.env._get_goal())\",\n \"def result(self) -> Item:\\n return self._result\",\n \"def get_current_task(self):\\n return self.get_current_step().get_last_task()\",\n \"def finish_checkpoint(self):\\n return self.this_evaluation.checkpoint\",\n \"def state(self):\\n return self._current_value\",\n \"def get_current_state(self, data):\\r\\n return self.get_context()\",\n \"def current(self):\\n return self._current\",\n \"def current(self):\\n return self._current\",\n \"def current(self):\\n return self._current\",\n \"def get_step(self):\\n return self.step\",\n \"def get_step(self):\\n return self.step\",\n \"def result(self):\\n with self.__lock:\\n assert(self.__complete)\\n return self.__result\",\n \"def getObservation(self):\\n return self._cur_state\",\n \"def get_last_step(self):\\n return self.get_step_by_index(-1)\",\n \"def get_goal(self):\\n self._pid_lock.acquire() # Acquire Lock\\n rtn = self._goal\\n self._pid_lock.release() # Release Lock\\n\\n return rtn\",\n \"def getStep():\\n # TODO: can there be non-Step logs?\",\n \"def last_run(self):\\n return self._last_run\",\n \"def current_step(self) -> FlowNode:\\n return self._current_step\",\n \"def get_outcome(self):\\n return self.__outcome\",\n \"def current_time_step(self) -> ts.TimeStep:\\n return self._current_time_step\",\n \"def result(self):\\n if self._child:\\n return self._child.result()\\n return self._result\",\n \"def get_current(self) -> typing.Any:\\n\\n return self.current_obj\",\n \"def get_state(self):\\r\\n return self.currentObservation\",\n \"def get_value(self):\\n return self.last_value\",\n \"def result(self):\\n if not self._last_command:\\n return []\\n return self._last_command.result()\",\n \"def process_finish(self):\\n return self.x\",\n \"def process_finish(self):\\n return self.x\",\n \"def get_results(self):\\n return self.result\",\n \"def CurrentState(self):\\n return self.currentState\",\n \"def get(self):\\n if not self.finished():\\n self.wait()\\n return self._result\",\n \"def step ( self ) :\\n return self.__step\",\n \"def last_value(self):\\n return self.samples[-1]\",\n \"def active_step(self):\\n if self._step_stack:\\n return self._step_stack[-1]\\n return None\",\n \"def current_state(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"current_state\\\")\",\n \"def get_result_of_first_calculation_added_to_history():\\n return Calculator.history[0].getResult()\",\n \"def last_state(self):\\n return self._simstate\",\n \"def get_result(self):\\n try:\\n return self.results.get_nowait()\\n except Empty:\\n return None\",\n \"def getFinish(self):\\n return self._finish\",\n \"def current_value(self):\\n return self.current_counter.value\",\n \"def get_current_state(self):\\n return self.nextYs[-1]\",\n \"def get_current(self):\\n return self.current\",\n \"def last_value(self):\\n return self._last_value\",\n \"def current_temp(self):\\n return self._current_temp\",\n \"def result(self):\\n if self._result is not None:\\n return self._result\\n if self._exc_info is not None:\\n raise self._exc_info[0], self._exc_info[1], self._exc_info[2]\\n self._check_done()\\n return self._result\",\n \"def current_operation(self):\\n return self.state\",\n \"def result(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"result\\\")\",\n \"def get_current_turn(self):\\n return self.turns.latest('number')\",\n \"def last_value(self):\\n return self._waveforms[-1].last_value\",\n \"def best_step(self):\\r\\n return self._best_value_step\",\n \"def last_processed(self):\\n return self._last_processed\",\n \"def state(self):\\n return self.probe.get_data(self.variable)\",\n \"def state(self):\\n return self.probe.get_data(self.variable)\",\n \"def get_output(self):\\r\\n return self._api.get_output()\",\n \"def output(self) -> pulumi.Output[Optional['outputs.JobStepOutputResponse']]:\\n return pulumi.get(self, \\\"output\\\")\",\n \"def current_martingale(self):\\n t, *_ = self._integrator.get_state(copy=False)\\n return self._martingale.value(t)\",\n \"def last_attempt_result(self) -> Optional[pulumi.Input['InstanceAttemptResultArgs']]:\\n return pulumi.get(self, \\\"last_attempt_result\\\")\",\n \"def get_current(self) -> int:\\n return self._current\",\n \"def get_current_step(self):\\n try:\\n return self.get_step_by_id(self.current_step.id)\\n except (AttributeError, ValueError):\\n message = \\\"The current step for this ticket is not set.\\\"\\n logger.debug(message)\\n raise KeyError(message)\",\n \"def get_current(self):\\n return self.x\",\n \"def last_value(self):\\n return self._value\",\n \"def value(self):\\n\\n return self._progress.value()\",\n \"def outcome(self):\\r\\n return self._outcome\",\n \"def latest_state_data(self):\\n if not self.state_list:\\n return None\\n if not self.state_list[-1]:\\n return None\\n return self.state_list[-1]\",\n \"def get_output(self):\\n return self._output\",\n \"def get_current_token(self):\\n with self._lock:\\n if self._unfinished_ids:\\n return self._unfinished_ids[0] - self._step\\n\\n return self._current\",\n \"def getCurrentObservation(self):\\n\\n if (len(self.observationHistory) == 0):\\n return None\\n\\n return self.observationHistory[-1]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7012832","0.6931432","0.6929647","0.67603475","0.66973376","0.6685482","0.66834754","0.66508675","0.66325194","0.65645987","0.6562965","0.65574545","0.65385914","0.6496028","0.6484237","0.6467374","0.6467374","0.6467374","0.64124614","0.6401742","0.63910645","0.63884705","0.6376051","0.63594383","0.63495255","0.6305278","0.6294111","0.6282416","0.6282416","0.6282416","0.6282416","0.62147653","0.6212894","0.62097275","0.6203121","0.61913353","0.6190178","0.6187749","0.6154861","0.61456746","0.6142923","0.6142923","0.6142923","0.61391056","0.61391056","0.61371815","0.61318827","0.6122624","0.6102315","0.6101212","0.60999984","0.6097255","0.6093705","0.6087391","0.60836005","0.6081218","0.60774505","0.6071859","0.6037898","0.6036325","0.6036325","0.60246277","0.60171604","0.60038084","0.6000166","0.5991118","0.59891015","0.5985999","0.59822875","0.5967685","0.5959902","0.5959734","0.59573627","0.5954868","0.5934783","0.5913976","0.5910642","0.59095323","0.5903416","0.589284","0.5880374","0.5860184","0.58465505","0.5838734","0.58289903","0.58289903","0.5822166","0.58127725","0.58116287","0.580642","0.5806218","0.5795891","0.5791988","0.57916343","0.57900494","0.57893115","0.57844126","0.57789654","0.57780576","0.5777528"],"string":"[\n \"0.7012832\",\n \"0.6931432\",\n \"0.6929647\",\n \"0.67603475\",\n \"0.66973376\",\n \"0.6685482\",\n \"0.66834754\",\n \"0.66508675\",\n \"0.66325194\",\n \"0.65645987\",\n \"0.6562965\",\n \"0.65574545\",\n \"0.65385914\",\n \"0.6496028\",\n \"0.6484237\",\n \"0.6467374\",\n \"0.6467374\",\n \"0.6467374\",\n \"0.64124614\",\n \"0.6401742\",\n \"0.63910645\",\n \"0.63884705\",\n \"0.6376051\",\n \"0.63594383\",\n \"0.63495255\",\n \"0.6305278\",\n \"0.6294111\",\n \"0.6282416\",\n \"0.6282416\",\n \"0.6282416\",\n \"0.6282416\",\n \"0.62147653\",\n \"0.6212894\",\n \"0.62097275\",\n \"0.6203121\",\n \"0.61913353\",\n \"0.6190178\",\n \"0.6187749\",\n \"0.6154861\",\n \"0.61456746\",\n \"0.6142923\",\n \"0.6142923\",\n \"0.6142923\",\n \"0.61391056\",\n \"0.61391056\",\n \"0.61371815\",\n \"0.61318827\",\n \"0.6122624\",\n \"0.6102315\",\n \"0.6101212\",\n \"0.60999984\",\n \"0.6097255\",\n \"0.6093705\",\n \"0.6087391\",\n \"0.60836005\",\n \"0.6081218\",\n \"0.60774505\",\n \"0.6071859\",\n \"0.6037898\",\n \"0.6036325\",\n \"0.6036325\",\n \"0.60246277\",\n \"0.60171604\",\n \"0.60038084\",\n \"0.6000166\",\n \"0.5991118\",\n \"0.59891015\",\n \"0.5985999\",\n \"0.59822875\",\n \"0.5967685\",\n \"0.5959902\",\n \"0.5959734\",\n \"0.59573627\",\n \"0.5954868\",\n \"0.5934783\",\n \"0.5913976\",\n \"0.5910642\",\n \"0.59095323\",\n \"0.5903416\",\n \"0.589284\",\n \"0.5880374\",\n \"0.5860184\",\n \"0.58465505\",\n \"0.5838734\",\n \"0.58289903\",\n \"0.58289903\",\n \"0.5822166\",\n \"0.58127725\",\n \"0.58116287\",\n \"0.580642\",\n \"0.5806218\",\n \"0.5795891\",\n \"0.5791988\",\n \"0.57916343\",\n \"0.57900494\",\n \"0.57893115\",\n \"0.57844126\",\n \"0.57789654\",\n \"0.57780576\",\n \"0.5777528\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78945726"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8998,"cells":{"query":{"kind":"string","value":"Nest allows you to nest steps hierarchically on the build UI. Calling ```python"},"document":{"kind":"string","value":"def nest(self, name):\n step_result = self(name, [])\n with self.m.context(name_prefix=name, increment_nest_level=True):\n yield step_result"},"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 build_step(self):\n pass","def build_step(self):\n pass","def test_build_page_nested(build_resources, cli):\n books, _ = build_resources\n src = books.joinpath(\"nested\")\n page = src.joinpath(\"contents\", \"markdown.md\")\n html = src.joinpath(\"_build\", \"_page\", \"contents-markdown\", \"html\")\n index = html.joinpath(\"index.html\")\n result = cli.invoke(commands.build, [page.as_posix(), \"-n\", \"-W\", \"--keep-going\"])\n assert result.exit_code == 0, result.output\n assert html.joinpath(\"markdown.html\").exists()\n assert not html.joinpath(\"extra_page.html\").exists()\n assert 'url=markdown.html\" />' in index.read_text(encoding=\"utf8\")","def build_step(self):\n\n pass","def test_run_tempest(self, tempest_actions, show_step, _):\n show_step(1)\n tempest_actions.prepare_and_run_tempest()","def stepStarted(build, step):","def build_nested_blocks(self):\n pass","def less_nested_example_vanilla():\n return","def build(ctx: typer.Context):\n from .tasks import build, main\n\n sys.argv = sys.argv[:1] + (ctx.args or [\"list\"])\n main(vars(build))","def build(parameters):\n\n\n print(\"In Build module\")","def actionBuild():\n\n #Init builder logger\n Builder.init()\n\n for target in Settings.targets:\n targetsToBuild, combineLibs, copyToOutput = Builder.getTargetGnPath(target)\n for platform in Settings.targetPlatforms:\n for cpu in Settings.targetCPUs:\n if System.checkIfCPUIsSupportedForPlatform(cpu,platform):\n for configuration in Settings.targetConfigurations:\n if not Summary.checkIfActionFailed(ACTION_PREPARE, target, platform, cpu, configuration):\n Logger.printStartActionMessage('Build ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration,ColoredFormatter.YELLOW)\n result = Builder.run(target, targetsToBuild, platform, cpu, configuration, combineLibs, copyToOutput)\n Summary.addSummary(ACTION_BUILD, target, platform, cpu, configuration, result, Builder.executionTime)\n if result != NO_ERROR:\n Logger.printEndActionMessage('Failed building ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration,ColoredFormatter.RED)\n #Terminate script execution if stopExecutionOnError is set to True in userdef\n shouldEndOnError(result)\n else:\n Logger.printEndActionMessage('Build ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration)\n else:\n Logger.printColorMessage('Build cannot run because preparation has failed for ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration,ColoredFormatter.YELLOW)\n Logger.printEndActionMessage('Build not run for ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration,ColoredFormatter.YELLOW)","def build_root(event):\n mode = event.parameters['mode']\n if mode == 'from config':\n config = event.parameters['config']\n\n elif mode == 'from template':\n manager = event.workbench.get_plugin('exopy.tasks')\n view = TemplateSelector(event.parameters.get('widget'),\n manager=manager)\n result = view.exec_()\n if result:\n path = view.path\n config, _ = load_template(path)\n\n else:\n msg = 'Invalid mode (%s) for build_root. Valid ones are : %s'\n raise ValueError(msg % (mode, ('from config', 'from template')))\n\n if config:\n build_dep = event.parameters.get('build_dep', event.workbench)\n return build_task_from_config(config, build_dep, True)\n\n else:\n raise RuntimeError('No config for building')","def show_build_order(c, ignore=False, update=False):\n\n print(\" # Add this to invoke.yaml\")\n print(\" build_order:\")\n for p in _build_order(c, ignore=ignore, update=update):\n print(f\" - {p}\")\n\n print(\"\")","def main():\n logging.basicConfig(\n level=logging.DEBUG, format=\"%(levelname)s: %(message)s\")\n root.add_command(all_)\n root.add_command(build)\n root.add_command(cleanup)\n root.add_command(clitest)\n root.add_command(run)\n root.add_command(push)\n root.add_command(unittest)\n root.add_command(list_images)\n root.add_command(list_stages)\n root()","def less_nested_example_rst():\n\n return","def build_step(self, signals):\n raise BuildError(\"OpBuilders must implement a `build_step` function\")","def build(root):","def tree(ctx):\n hokusai.print_command_tree(ctx.find_root().command)","def test_get_scenarios_expanded(self):\n pass","def test_python(width=10):\n\n stage_1 = [diamond(sleep=60, inputs=[0])]\n\n stage_2 = []\n for i in range(0, width):\n stage_2.extend([diamond(sleep=20, inputs=stage_1)])\n\n stage_3 = [diamond(sleep=30, inputs=stage_2)]\n\n if not stage_3[0].done():\n time.sleep(30)\n for sitename in dfk.executors:\n print(dfk.executors[sitename].status())","def ui_root1():\n return send_build()","def run_steps(properties, stream_engine, step_runner, universe_view,\n engine_flags=None, emit_initial_properties=False):\n with stream_engine.make_step_stream('setup_build') as s:\n if emit_initial_properties:\n for key in sorted(properties.iterkeys()):\n s.set_build_property(key, json.dumps(properties[key], sort_keys=True))\n\n engine = RecipeEngine(\n step_runner, properties, os.environ, universe_view, engine_flags)\n\n # Create all API modules and top level RunSteps function. It doesn't launch\n # any recipe code yet; RunSteps needs to be called.\n api = None\n\n assert 'recipe' in properties\n recipe = properties['recipe']\n\n root_package = universe_view.universe.package_deps.root_package\n run_recipe_help_lines = [\n 'To repro this locally, run the following line from the root of a %r'\n ' checkout:' % (root_package.name),\n '',\n '%s run --properties-file - %s <<EOF' % (\n os.path.join( '.', root_package.relative_recipes_dir, 'recipes.py'),\n recipe),\n '%s' % json.dumps(properties),\n 'EOF',\n '',\n 'To run on Windows, you can put the JSON in a file and redirect the',\n 'contents of the file into run_recipe.py, with the < operator.',\n ]\n\n with s.new_log_stream('run_recipe') as l:\n for line in run_recipe_help_lines:\n l.write_line(line)\n\n # Find and load the recipe to run.\n try:\n recipe_script = universe_view.load_recipe(recipe, engine=engine)\n s.write_line('Running recipe with %s' % (properties,))\n\n api = loader.create_recipe_api(\n universe_view.universe.package_deps.root_package,\n recipe_script.LOADED_DEPS,\n recipe_script.path,\n engine,\n recipe_test_api.DisabledTestData())\n\n s.add_step_text('running recipe: \"%s\"' % recipe)\n except (loader.LoaderError, ImportError, AssertionError) as e:\n for line in str(e).splitlines():\n s.add_step_text(line)\n s.set_step_status('EXCEPTION')\n if engine_flags and engine_flags.use_result_proto:\n return result_pb2.Result(\n failure=result_pb2.Failure(\n human_reason=str(e),\n exception=result_pb2.Exception(\n traceback=traceback.format_exc().splitlines()\n )))\n return RecipeResult({\n 'status_code': 2,\n 'reason': str(e),\n })\n\n # The engine will use step_runner to run the steps, and the step_runner in\n # turn uses stream_engine internally to build steam steps IO.\n return engine.run(recipe_script, api)","def build(ctx):\n ctx.run(\"vsce package\", replace_env=False)","def test_sections_json_spider_three_levels_with_summary_and_call(self):\n title = (\"Taking Action for the Social and Emotional Health of \"\n\t \"Young Children: A Report to the Community from the Denver \"\n\t\t \"Early Childhood Council\")\n\tsummary = (\"Now, Denver has a plan of action to make it easier for \"\n\t \"families to access early childhood mental health \"\n\t\t \"information, intervention and services.\")\n\tcall_to_action = (\"Test call to action.\")\n\tbyline = \"Denver Early Childhood Council\"\n story = create_story(title=title, summary=summary, byline=byline,\n\t\t\t call_to_action=call_to_action)\n section1 = create_section(\"We're ready to take action. Are you?\",\n\t\t\t story=story, weight=7)\n\tsection2 = create_section(\"Ricardo's Story\",\n\t\t\t story=story, weight=2)\n\tsection3 = create_section(\"Meeting the need for better child mental health services\",\n\t\t\t story=story, root=True, weight=1)\n\tsection4 = create_section(\"Healthy Minds Support Strong Futures\",\n\t\t\t story=story, weight=5) \n\tsection5 = create_section(\"Community Voices\",\n\t\t\t story=story, weight=3)\n\tsection6 = create_section(\"Our Vision: That All Children in Denver are Valued, Healthy and Thriving\",\n\t\t\t story=story, weight=4)\n\tsection7 = create_section(\"Defining a \\\"Framework for Change\\\" with Actionable Goals and Strategies\",\n\t\t\t story=story, weight=5) \n section8 = create_section(\"How Can the Plan Make a Difference?\",\n\t\t\t story=story, weight=5)\n\tsection9 = create_section(\"Impact\", story=story, weight=6)\n SectionRelation.objects.create(parent=section6, child=section8,\n weight=0)\n SectionRelation.objects.create(parent=section7, child=section9,\n weight=0)\n SectionRelation.objects.create(parent=section6, child=section7,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section1,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section6,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section4,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section5,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section2,\n weight=0)\n\tjson_sections = simplejson.loads(story.structure.sections_json(\n\t\tinclude_summary=True, include_call_to_action=True))\n\tself.assertIn(\n\t section8.section_id,\n\t self._get_section(json_sections, section6.section_id)['children'])\n\tself.assertIn(\n\t section9.section_id,\n\t self._get_section(json_sections, section7.section_id)['children'])\n\tself.assertIn(\n\t section7.section_id,\n\t self._get_section(json_sections, section6.section_id)['children'])\n\tself.assertIn(\n\t section1.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])\n\tself.assertIn(\n\t section6.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])\n\tself.assertIn(\n\t section4.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])\n\tself.assertIn(\n\t section5.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])\n\tself.assertIn(\n\t section2.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])\n\tself.assertEqual(json_sections[0]['section_id'], 'summary')\n\tself.assertEqual(json_sections[0]['next_section_id'], \n\t\t\t json_sections[1]['section_id'])\n\tself.assertEqual(json_sections[1]['previous_section_id'], 'summary')\n\tself.assertEqual(json_sections[-1]['section_id'], 'call-to-action')\n\tself.assertEqual(json_sections[-1]['previous_section_id'], \n\t\t\t json_sections[-2]['section_id'])\n\tself.assertEqual(json_sections[-2]['next_section_id'], 'call-to-action')","def start(context, project_name):\n\n gcc_version = '10-2020-q4-major-'\n os_extension = ''\n\n if platform.system() == 'Linux':\n if platform.machine() == 'x86_64':\n os_extension = 'x86_64-linux'\n else:\n os_extension = 'aarch64-linux'\n elif platform.system() == 'Darwin':\n os_extension = 'mac'\n elif platform.system() == 'Windows':\n os_extension = 'win32'\n\n final_branch_name = f'{gcc_version}{os_extension}'\n\n if not os_extension:\n click.secho(f'This system {platform.system()}:{platform.machine()} ' +\n 'is not supported for SJSU-Dev2 ', fg='red', bold=True)\n return -1\n\n click.secho(f'Creating project: {project_name}', fg='white', bold=True)\n Path(project_name).mkdir()\n\n click.echo(f' Creating \"{project_name}/.sj2\" directory')\n Path(f'{project_name}/.sj2').mkdir(exist_ok=True)\n Path(f'{project_name}/.sj2/reserved').touch(exist_ok=True)\n\n click.echo(f' Creating \"{project_name}/library\" directory')\n Path(f'{project_name}/library').mkdir(exist_ok=True)\n\n click.echo(f' Creating \"{project_name}/packages\" directory')\n Path(f'{project_name}/packages').mkdir(exist_ok=True)\n\n click.echo(f' Creating \"{project_name}/main.cpp\" source file')\n Path(f'{project_name}/main.cpp').write_text(BASIC_MAIN_CPP)\n\n click.echo('')\n\n context.invoke(install, library='libcore', tag='main',\n project_directory=project_name)\n context.invoke(install, library='libarmcortex',\n tag='main', project_directory=project_name)\n context.invoke(install, library='liblpc40xx', tag='main',\n project_directory=project_name)\n context.invoke(install, library='libstm32f10x',\n tag='main', project_directory=project_name)\n context.invoke(install, library='gcc-arm-none-eabi-picolibc',\n tag=final_branch_name, project_directory=project_name)","def explore(self, board, args):\n self.tree.explore(board, *args)","def run_steps(stream, build_properties, factory_properties,\n test_data=recipe_test_api.DisabledTestData()):\n stream.honor_zero_return_code()\n\n # TODO(iannucci): Stop this when blamelist becomes sane data.\n if ('blamelist_real' in build_properties and\n 'blamelist' in build_properties):\n build_properties['blamelist'] = build_properties['blamelist_real']\n del build_properties['blamelist_real']\n\n properties = factory_properties.copy()\n properties.update(build_properties)\n\n # TODO(iannucci): A much better way to do this would be to dynamically\n # detect if the mirrors are actually available during the execution of the\n # recipe.\n if ('use_mirror' not in properties and (\n 'TESTING_MASTERNAME' in os.environ or\n 'TESTING_SLAVENAME' in os.environ)):\n properties['use_mirror'] = False\n\n # It's an integration point with a new recipe engine that can run steps\n # in parallel (that is not implemented yet). Use new engine only if explicitly\n # asked by setting 'engine' property to 'ParallelRecipeEngine'.\n engine = RecipeEngine.create(stream, properties, test_data)\n\n # Create all API modules and an instance of top level GenSteps generator.\n # It doesn't launch any recipe code yet (generator needs to be iterated upon\n # to start executing code).\n api = None\n with stream.step('setup_build') as s:\n assert 'recipe' in factory_properties\n recipe = factory_properties['recipe']\n\n properties_to_print = properties.copy()\n if 'use_mirror' in properties:\n del properties_to_print['use_mirror']\n\n run_recipe_help_lines = [\n 'To repro this locally, run the following line from a build checkout:',\n '',\n './scripts/tools/run_recipe.py %s --properties-file - <<EOF' % recipe,\n repr(properties_to_print),\n 'EOF',\n '',\n 'To run on Windows, you can put the JSON in a file and redirect the',\n 'contents of the file into run_recipe.py, with the < operator.',\n ]\n\n for line in run_recipe_help_lines:\n s.step_log_line('run_recipe', line)\n s.step_log_end('run_recipe')\n\n try:\n recipe_module = recipe_loader.load_recipe(recipe)\n stream.emit('Running recipe with %s' % (properties,))\n api = recipe_loader.create_recipe_api(recipe_module.DEPS,\n engine,\n test_data)\n steps = recipe_module.GenSteps\n s.step_text('<br/>running recipe: \"%s\"' % recipe)\n except recipe_loader.NoSuchRecipe as e:\n s.step_text('<br/>recipe not found: %s' % e)\n s.step_failure()\n return RecipeExecutionResult(2, None)\n\n # Run the steps emitted by a recipe via the engine, emitting annotations\n # into |stream| along the way.\n return engine.run(steps, api)","def stage(self, stage: osbuild.Stage):","def test_quick_build1(self):\n pass","def expand_tasks_with_samples( # pylint: disable=R0913,R0914\n self,\n dag,\n chain_,\n samples,\n labels,\n task_type,\n adapter_config,\n level_max_dirs,\n):\n LOG.debug(f\"expand_tasks_with_samples called with chain,{chain_}\\n\")\n # Figure out how many directories there are, make a glob string\n directory_sizes = uniform_directories(len(samples), bundle_size=1, level_max_dirs=level_max_dirs)\n\n glob_path = \"*/\" * len(directory_sizes)\n\n LOG.debug(\"creating sample_index\")\n # Write a hierarchy to get the all paths string\n sample_index = create_hierarchy(\n len(samples),\n bundle_size=1,\n directory_sizes=directory_sizes,\n root=\"\",\n n_digits=len(str(level_max_dirs)),\n )\n\n LOG.debug(\"creating sample_paths\")\n sample_paths = sample_index.make_directory_string()\n\n LOG.debug(\"assembling steps\")\n # the steps in the chain\n steps = [dag.step(name) for name in chain_]\n\n # sub in globs prior to expansion\n # sub the glob command\n steps = [\n step.clone_changing_workspace_and_cmd(cmd_replacement_pairs=parameter_substitutions_for_cmd(glob_path, sample_paths))\n for step in steps\n ]\n\n # workspaces = [step.get_workspace() for step in steps]\n # LOG.debug(f\"workspaces : {workspaces}\")\n\n needs_expansion = is_chain_expandable(steps, labels)\n\n LOG.debug(f\"needs_expansion {needs_expansion}\")\n\n if needs_expansion:\n # prepare_chain_workspace(sample_index, steps)\n sample_index.name = \"\"\n LOG.debug(\"queuing merlin expansion tasks\")\n found_tasks = False\n conditions = [\n lambda c: c.is_great_grandparent_of_leaf,\n lambda c: c.is_grandparent_of_leaf,\n lambda c: c.is_parent_of_leaf,\n lambda c: c.is_leaf,\n ]\n for condition in conditions:\n if not found_tasks:\n for next_index_path, next_index in sample_index.traverse(conditional=condition):\n LOG.info(\n f\"generating next step for range {next_index.min}:{next_index.max} {next_index.max-next_index.min}\"\n )\n next_index.name = next_index_path\n\n sig = add_merlin_expanded_chain_to_chord.s(\n task_type,\n steps,\n samples[next_index.min : next_index.max],\n labels,\n next_index,\n adapter_config,\n next_index.min,\n )\n sig.set(queue=steps[0].get_task_queue())\n\n if self.request.is_eager:\n sig.delay()\n else:\n LOG.info(f\"queuing expansion task {next_index.min}:{next_index.max}\")\n self.add_to_chord(sig, lazy=False)\n LOG.info(f\"merlin expansion task {next_index.min}:{next_index.max} queued\")\n found_tasks = True\n else:\n LOG.debug(\"queuing simple chain task\")\n add_simple_chain_to_chord(self, task_type, steps, adapter_config)\n LOG.debug(\"simple chain task queued\")","def run():\n from cgl.plugins.blender.tasks.rig import parent_mdl_to_rig\n parent_mdl_to_rig()","def test_quick_build(self):\n pass","def main():\n parser = argparse.ArgumentParser(\n epilog=main.__doc__, formatter_class=argparse.RawDescriptionHelpFormatter\n )\n parser.add_argument(\n \"-d\", \"--dry-run\", action=\"store_true\", default=0, help=\"Dry run mode.\"\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n action=\"count\",\n default=0,\n help=\"Verbosity. Default is WARNING level.\",\n )\n\n subparsers = parser.add_subparsers(help=\"Sub commands\", dest=\"subparser\")\n subparsers.required = True\n\n build_parser = subparsers.add_parser(\n \"build\",\n description=\"Build an image from Dockerfile, caching image hierarchy\",\n help=\"Build an image from a Dockerfile\",\n )\n build_parser.add_argument(\n \"path\", metavar=\"PATH\", help=\"The build context directory\"\n )\n build_parser.add_argument(\n \"-f\",\n \"--file\",\n help=\"Name of the Dockerfile. If not provided, \"\n \"will use config.DOCKERFILE_PATH_PATTERN to compute. \",\n )\n build_parser.add_argument(\n \"-v\",\n \"--git-sha\",\n required=True,\n help=\"The version of code to build against, \" \"will pass as GIT_SHA variable\",\n )\n build_parser.add_argument(\n \"-n\", \"--name\", required=True, help=\"The name of the image to build\"\n )\n build_parser.add_argument(\n \"--build-arg\",\n metavar=\"ARG=VALUE\",\n nargs=\"*\",\n default=[],\n help=\"Set extra build-time variables. GIT_SHA, TIMESTAMP will be passed by default.\",\n )\n build_parser.add_argument(\n \"-r\",\n \"--raw\",\n action=\"store_true\",\n help=\"Whether to use raw docker build command to build, skipping caching logic\",\n )\n build_parser.add_argument(\n \"--registry\",\n default=config.DOCKER_REGISTRY,\n help=\"Docker registry use to determine the image identity, \"\n \"can be set via IMAGE_BUILDER_DOCKER_REGISTRY environment variable, \"\n 'or set DOCKER_REGISTRY in config.py. Default is \"%(default)s\"',\n )\n build_parser.add_argument(\n \"-t\",\n \"--tag-pattern\",\n default=config.GIT_SHA_TAG_PATTERN,\n help=\"Tag pattern, can only include one `{git_sha}` placeholder, \"\n 'such as \"{git_sha}-new\". If the tag exists, we won\\'t rebuild it. '\n 'Default is \"%(default)s\"',\n )\n build_parser.add_argument(\n \"-e\",\n \"--extra-tag\",\n nargs=\"*\",\n default=[],\n help=\"Extra tags to tag to the final images\",\n )\n build_parser.add_argument(\n \"--extra-name\",\n nargs=\"*\",\n default=[],\n help=\"Extra name and optionally with a tag in the 'name:tag' format\",\n )\n build_parser.add_argument(\n \"-o\", \"--output-hash\", help=\"The output filename of the files hash log.\"\n )\n build_parser.set_defaults(func=build)\n\n args = parser.parse_args()\n if args.dry_run:\n # DRY_RUN env will be read in image_builder.libs.process\n os.environ[\"DRY_RUN\"] = \"1\"\n\n if args.func == build:\n args.path = expand_path(args.path)\n if args.output_hash:\n args.output_hash = expand_path(args.output_hash)\n\n args.file = args.file or locate_dockerfile(args.name)\n args.file = expand_path(args.file)\n # set environ for main dockerfile for possibly retrieving later\n os.environ[\n config.DOCKERFILE_ENV_PATTERN.format(image_name=args.name)\n ] = args.file\n\n # change CWD to PATH\n os.chdir(args.path)\n\n if not args.registry:\n parser.error(\n \"--registry should be provied \"\n \"or specified by IMAGE_BUILDER_DOCKER_REGISTRY environment variable or set DOCKER_REGISTRY in config.py\"\n )\n if not all(\"=\" in kv for kv in args.build_arg):\n parser.error(\"--build_arg must be in ARG=VALUE format\")\n\n # set git_sha_tag\n try:\n args.git_sha_tag = args.tag_pattern.format(git_sha=args.git_sha)\n except KeyError:\n parser.error(\n 'Wrong --tag-pattern provided. Can only include one `{git_sha}` placeholder, such as \"{git_sha}-new\"'\n )\n\n # setup logging\n level = logging.WARNING - args.verbose * 10\n logging.basicConfig(\n level=level, format=\"%(asctime)s %(name)s %(levelname)s %(message)s\"\n )\n\n if args.output_hash:\n h = logging.FileHandler(args.output_hash)\n h.setLevel(logging.DEBUG)\n h.setFormatter(logging.Formatter(\"%(message)s\"))\n hash_logger.addHandler(h)\n\n # Suppress warning when we don't verify ssl\n import urllib3\n\n urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)\n\n return args.func(args)","def build(c, force=None):\n for sp_ns in ns_foreach_task_subdir(c):\n print(\"-- running build in \", os.getcwd())\n\n # sp_ns.tasks.build(c, force)\n c.run('invoke build')","def test_documentation_popxl_nested_session_contexts(self):\n filename = \"nested_session_contexts.py\"\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)","def tfrun(args, build_modules, build_workspace, build_env):\n\n # loop through each selected module(s) and apply the action as specified by user\n for m in build_modules:\n print(\"\\n\\n****************************************************************************\")\n print(\"Permforming action \\\"{0}\\\" for module {1}\".format(args.action, m))\n print(\"****************************************************************************\\n\\n\")\n run_module(args, m, build_workspace, build_env)","def test_documentation_popxl_nested_code_loading(self):\n filename = \"code_loading_nested.py\"\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)","def ninja_simulate_block():\n return '''\n```sh\n# In build directory\nninja && ./simulate\n```'''","def run():\n build_no_documentation()\n build_sphinx_build()\n #build_sphinx_pdf()\n build_graphviz_files()","def buildStarted(self, name, build):\n if self.isInterestingBuilder(name):\n return self","def test_build(self):\n self.app.build()","def step_impl(context):\n pass","def step_impl(context):\n pass","def process_steps(steplist, build, buildslave, build_status, basedir):\n for step in steplist:\n step.setBuild(build)\n step.setBuildSlave(buildslave)\n step.setStepStatus(build_status.addStepWithName(step.name))\n step.setDefaultWorkdir(os.path.join(basedir, 'build'))\n step.workdir = os.path.join(basedir, 'build')","def build(_):","def nested(*contexts):\n with ExitStack() as stack:\n for ctx in contexts:\n stack.enter_context(ctx())\n yield contexts","def do_build(self):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\tcfg = self.cfg\n\t\tself.log('PHASE: build, repository work', level=logging.DEBUG)\n\t\tmodule_id_list = self.module_ids()\n\t\tif self.build['deps_only']:\n\t\t\tmodule_id_list_build_only = filter(lambda x: cfg[x]['shutit.core.module.build'], module_id_list)\n\t\tfor module_id in module_id_list:\n\t\t\tmodule = self.shutit_map[module_id]\n\t\t\tself.log('Considering whether to build: ' + module.module_id, level=logging.INFO)\n\t\t\tif cfg[module.module_id]['shutit.core.module.build']:\n\t\t\t\tif self.build['delivery'] not in module.ok_delivery_methods:\n\t\t\t\t\tself.fail('Module: ' + module.module_id + ' can only be built with one of these --delivery methods: ' + str(module.ok_delivery_methods) + '\\nSee shutit build -h for more info, or try adding: --delivery <method> to your shutit invocation') # pragma: no cover\n\t\t\t\tif self.is_installed(module):\n\t\t\t\t\tself.build['report'] = (self.build['report'] + '\\nBuilt already: ' + module.module_id + ' with run order: ' + str(module.run_order))\n\t\t\t\telse:\n\t\t\t\t\t# We move to the module directory to perform the build, returning immediately afterwards.\n\t\t\t\t\tif self.build['deps_only'] and module_id == module_id_list_build_only[-1]:\n\t\t\t\t\t\t# If this is the last module, and we are only building deps, stop here.\n\t\t\t\t\t\tself.build['report'] = (self.build['report'] + '\\nSkipping: ' + module.module_id + ' with run order: ' + str(module.run_order) + '\\n\\tas this is the final module and we are building dependencies only')\n\t\t\t\t\telse:\n\t\t\t\t\t\trevert_dir = os.getcwd()\n\t\t\t\t\t\tself.get_current_shutit_pexpect_session_environment().module_root_dir = os.path.dirname(self.shutit_file_map[module_id])\n\t\t\t\t\t\tself.chdir(self.get_current_shutit_pexpect_session_environment().module_root_dir)\n\t\t\t\t\t\tself.login(prompt_prefix=module_id,command=shutit_global.shutit_global_object.bash_startup_command,echo=False)\n\t\t\t\t\t\tself.build_module(module)\n\t\t\t\t\t\tself.logout(echo=False)\n\t\t\t\t\t\tself.chdir(revert_dir)\n\t\t\tif self.is_installed(module):\n\t\t\t\tself.log('Starting module',level=logging.DEBUG)\n\t\t\t\tif not module.start(self):\n\t\t\t\t\tself.fail(module.module_id + ' failed on start', shutit_pexpect_child=self.get_shutit_pexpect_session_from_id('target_child').pexpect_child) # pragma: no cover","def test_sections_json_spider_three_levels_with_summary_and_call(self):\n title = (\"Taking Action for the Social and Emotional Health of \"\n \"Young Children: A Report to the Community from the \" \n\t\t \"Denver Early Childhood Council\")\n summary = (\"Now, Denver has a plan of action to make it easier \"\n \"for families to access early childhood mental health \"\n \"information, intervention and services.\")\n call_to_action = (\"Test call to action.\")\n byline = \"Denver Early Childhood Council\"\n story = create_story(title=title, summary=summary, byline=byline,\n\t\t\t call_to_action=call_to_action)\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\"Side by Side\")\n section1 = create_section(\"We're ready to take action. Are you?\",\n\t\t\t story=story, layout=layout, weight=7)\n section2 = create_section(\"Ricardo's Story\",\n\t\t\t story=story, layout=layout, weight=2)\n section3 = create_section(\"Meeting the need for better child mental health services\",\n\t\t\t story=story, layout=layout, root=True, weight=1)\n section4 = create_section(\"Healthy Minds Support Strong Futures\",\n\t\t\t story=story, layout=layout, weight=5) \n section5 = create_section(\"Community Voices\",\n\t\t\t story=story, layout=layout, weight=3)\n section6 = create_section(\"Our Vision: That All Children in Denver are Valued, Healthy and Thriving\",\n\t\t\t story=story, layout=layout, weight=4)\n section7 = create_section(\"Defining a \\\"Framework for Change\\\" with Actionable Goals and Strategies\",\n\t\t\t story=story, layout=layout, weight=5) \n section8 = create_section(\"How Can the Plan Make a Difference?\",\n\t\t\t story=story, layout=layout, weight=5)\n section9 = create_section(\"Impact\", \n story=story, layout=layout, weight=6)\n SectionRelation.objects.create(parent=section6, child=section8,\n weight=0)\n SectionRelation.objects.create(parent=section7, child=section9,\n weight=0)\n SectionRelation.objects.create(parent=section6, child=section7,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section1,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section6,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section4,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section5,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section2,\n weight=0)\n json_sections = simplejson.loads(story.structure.sections_json(\n include_summary=True, include_call_to_action=True))\n self.assertIn(\n section8.section_id,\n self._get_section(json_sections, section6.section_id)['children'])\n self.assertIn(\n section9.section_id,\n self._get_section(json_sections, section7.section_id)['children'])\n self.assertIn(\n section7.section_id,\n self._get_section(json_sections, section6.section_id)['children'])\n self.assertIn(\n section1.section_id,\n self._get_section(json_sections, section3.section_id)['children'])\n self.assertIn(\n section6.section_id,\n self._get_section(json_sections, section3.section_id)['children'])\n self.assertIn(\n section4.section_id,\n self._get_section(json_sections, section3.section_id)['children'])\n self.assertIn(\n section5.section_id,\n self._get_section(json_sections, section3.section_id)['children'])\n self.assertIn(\n section2.section_id,\n self._get_section(json_sections, section3.section_id)['children'])\n self.assertEqual(json_sections[0]['section_id'], 'summary')\n self.assertEqual(json_sections[0]['next_section_id'], \n json_sections[1]['section_id'])\n self.assertEqual(json_sections[1]['previous_section_id'], 'summary')\n self.assertEqual(json_sections[-1]['section_id'], 'call-to-action')\n self.assertEqual(json_sections[-1]['previous_section_id'], \n json_sections[-2]['section_id'])\n self.assertEqual(json_sections[-2]['next_section_id'], 'call-to-action')","def deploy_steps(self):\n return [ShellCommand(command=[\"node\", \"medic/build_\" + self.platform + \".js\"], workdir='build', timeout=CONFIG.build_timeout, description='Run tests', name='Run tests')]","def build():","def do_step(self) -> None:","def build():\n local('wintersmith build')","def import_ebuilds ( self, catview, **kwargs ):\n stats = self.STATS\n for eview in catview:\n self._get_package_dir ( eview.name ).import_ebuilds (\n eview, stats=stats, **kwargs\n )","def stage_run(args):\n\n print \"stage_run args:\", args\n if args.phase == \"split\":\n adapters.split(args.stage, args)\n if args.phase == \"main\":\n adapters.main(args.stage, args)\n if args.phase == \"join\":\n\n #for key in args.__dict__:\n # if isinstance(getattr(args, key), list) and len(getattr(args, key)) == 1:\n # setattr(args, key, getattr(args, key)[0])\n\n adapters.join(args.stage, args)","def test_explant(install_test_files, data_dir):\n with make_workdir() as workdir:\n cl = [\"bcbio_nextgen.py\",\n get_post_process_yaml(data_dir, workdir),\n os.path.join(data_dir, os.pardir, \"1_explant\"),\n os.path.join(data_dir, \"run_info-explant.yaml\")]\n subprocess.check_call(cl)","def ninja_block():\n return '''\n```sh\n# In build directory\nninja\n```'''","def run(self):\n self.render_templates()\n self.create_docker_context()\n self.build()\n self.push()","def explore(self, *args):","def step_by_step_instructions(element, sectionlevel=\"##\", to_markdown=safe_html_to_markdown):\n output = \"\"\n for step in element:\n assert step.tag.lower() == \"step\", \"instructions sections can only contain steps\"\n output += sectionlevel + \" Step\\n\"\n output += to_markdown(step.find(\"description\"))\n output += \"\\n\"\n output += media_section(step)\n output += \"\\n\\n\"\n return output","def test_BuildModel3(self):\n print(\"\\nTest 7: Building a more complicated Model\")\n builder = StaticBuilder(\"BreakIt\")\n in1 = builder.addInput(10)\n in2 = builder.addInput(20)\n enc1 = builder.addInner(3)\n enc2 = builder.addInner(5, num_islots=2)\n out1 = builder.addOutput()\n out2 = builder.addOutput()\n \n builder.addDirectedLink(in1, enc1)\n builder.addDirectedLink(in2, enc2, islot=0)\n builder.addDirectedLink(enc1, enc2, islot=1)\n builder.addDirectedLink(enc1, out1)\n builder.addDirectedLink(enc2, out2)\n \n builder.build()","def rf_stepMode(self, selTree, treeDict):\n for step in treeDict['steps']:\n newStep = TreeNode(nodeType='step', nodeLabel=step, nodeName=step)\n self.addTopLevelItem(newStep)\n for node in treeDict['tree']['_order']:\n newItem = TreeNode(**treeDict['tree'][node])\n if len(node.split('/')) == 1:\n newStep.addChild(newItem)\n else:\n rootPath = \"%s/%s\" % (step, '/'.join(node.split('/')[:-1]))\n parent = self._getItemFromTreePath(rootPath)\n parent.addChild(newItem)\n if getattr(newItem, 'nodeType') == 'shotNode':\n newItem._tree = selTree\n newItem._step = step\n newItem._itemPath = node\n newItem._dataPath = os.path.join(self.pm._treePath, selTree)\n for fld in node.split('/'):\n newItem._dataPath = os.path.join(newItem._dataPath, fld)\n newItem._dataPath = pFile.conformPath(newItem._dataPath)\n newItem._ltPath = pFile.conformPath(os.path.join(newItem._dataPath, 'lt', step))\n newItem._dataFile = \"%s.py\" % newItem._dataPath","def run_module_structure_plan(args):\n step = args.step\n if step == \"generate_images\":\n StructureGenerator = dataset_builder.ImageStructureGenerator(\n input_directory=args.input_directory, output_directory=args.output_directory\n )\n StructureGenerator.run(n_jobs=args.n_jobs, starting_block=args.starting_block)\n elif step == \"generate_dataset\":\n DatasetGenerator = dataset_builder.DatasetGenerator(\n input_directory=args.input_directory, output_directory=args.output_directory\n )\n DatasetGenerator.generate_dataset()","def make(repo, component, clean, install, install_prefix, storage_type, with_java):\n if clean:\n click.secho(\"Cleaning previous build.\", fg=\"green\")\n cmd = [\"make\", \"clean\"]\n run_shell_cmd(cmd, repo.home)\n return\n click.secho(\n \"Before making artifacts, please manually source ENVs from ~/.graphscope_env.\",\n fg=\"yellow\",\n )\n click.secho(\n f\"Begin the make command, to build components [{component}] of GraphScope, with repo = {repo.home}\",\n fg=\"green\",\n )\n cmd = []\n workingdir = repo.home\n if component == \"interactive\":\n click.secho(\"Building interactive engine.\", fg=\"green\")\n if storage_type == \"experimental\":\n cmd = [\"make\", \"build\", 'QUIET_OPT=\"\"']\n workingdir = os.path.join(repo.home, \"interactive_engine\", \"compiler\")\n if storage_type == \"vineyard\":\n cmd = [\n \"mvn\",\n \"install\",\n \"-DskipTests\",\n \"-Drust.compile.mode=release\",\n \"-P\",\n \"graphscope,graphscope-assembly\",\n ]\n workingdir = os.path.join(repo.home, \"interactive_engine\")\n run_shell_cmd(cmd, workingdir)\n cmd = [\"tar\", \"xvzf\", \"graphscope.tar.gz\"]\n workingdir = os.path.join(\n repo.home, \"interactive_engine\", \"assembly\", \"target\"\n )\n click.secho(f\"Begin to extract, from {workingdir}.\", fg=\"green\")\n run_shell_cmd(cmd, workingdir)\n click.secho(\"GraphScope interactive engine has been built.\", fg=\"green\")\n if install is True:\n cmd = [\n \"make\",\n \"interactive-install\",\n \"INSTALL_PREFIX={}\".format(install_prefix),\n ]\n run_shell_cmd(cmd, repo.home)\n click.secho(\n f\"GraphScope interactive engine has been installed to {install_prefix}.\",\n fg=\"green\",\n )\n\n if component == \"analytical\":\n cmd = [\"make\", \"analytical\"]\n if with_java:\n cmd = [\"make\", \"analytical-java\"]\n run_shell_cmd(cmd, repo.home)\n click.secho(\"GraphScope analytical engine has been built.\", fg=\"green\")\n if install is True:\n cmd = [\n \"make\",\n \"analytical-install\",\n \"INSTALL_PREFIX={}\".format(install_prefix),\n ]\n run_shell_cmd(cmd, repo.home)\n click.secho(\n f\"GraphScope analytical engine has been installed to {install_prefix}.\",\n fg=\"green\",\n )\n\n if component == \"client\":\n cmd = [\"make\", \"client\"]\n run_shell_cmd(cmd, repo.home)\n\n if component == \"coordinator\":\n cmd = [\"make\", \"coordinator\"]\n run_shell_cmd(cmd, repo.home)\n\n if component is None:\n click.secho(\"Building all components.\", fg=\"green\")\n cmd = [\"make\", \"all\"]\n if install is True:\n cmd = [\"make\", \"install\", \"INSTALL_PREFIX={}\".format(install_prefix)]\n run_shell_cmd(cmd, repo.home)","def go_deeper(cls, *args, **kwargs):\n\t\treturn True","def gen_stage_loop(cls, _opts, tests, put_next_stage, _put_result_stage):\n for test in tests:\n put_next_stage(test)","def execute(self):\n if len(self._tree) > 0:\n return self._tour(self._tree.root(),0,[]) # start the recursion","def step(self, **kwargs):\n pass","def build(c, path=\"../..\", name=\"testapp\"):\n if not os.name in [\"nt\", \"posix\"]:\n print(\"Sorry. this only supports Posix (e.g. Linux, OSX) and Windows OS. \")\n sys.exit()\n\n path=os.path.normpath(path)\n print(\"Building : -n {} -p {} \".format(name, path))\n if os.path.exists(os.path.join(path, name)):\n print(\"sorry, path {} exists\".format(os.path.abspath(os.path.join(path, name))))\n r=input(\" .. type y or yes, to go ahead deleting the existing: {} ? : \".format(os.path.join(path,name)))\n if r in [\"y\", \"yes\"]:\n import shutil\n r=shutil.rmtree(os.path.join(path,name))\n print(40*\"-\")\n print(\" ..... deleted dir tree: {}\".format(os.path.join(path, name)))\n print(40*\"-\")\n build_all(c,name, path)\n else:\n print(40*\"-\")\n print(\" ok, exiting...\")\n print(40*\"-\")\n sys.exit()\n else:\n # start the build and check\n build_all(c,name, path)","def render(self):\n self.env.render()\n #input(\"Press enter to take a step \")","def build():\n conf_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'conf'))\n instance_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'instance'))\n outdir = os.path.join(conf_dir, '..', '_build')\n\n options_file = os.path.join(instance_dir, 'site.yaml')\n if not os.path.exists(options_file):\n click.echo('ERROR: Could not find %s' % options_file)\n click.echo('...a sample is located in `conf`')\n click.echo('...copy `conf/site.yaml` to your instance folder, and modify it as needed')\n raise click.Abort()\n\n options = ruamel.yaml.safe_load(open(options_file).read())\n\n if not os.path.isdir(outdir):\n os.makedirs(outdir)\n\n env = Environment(\n loader=FileSystemLoader(conf_dir),\n undefined=StrictUndefined)\n\n ###########################################################################\n click.echo('Creating `_build/invoicer-uwsgi.ini')\n template = env.get_template('invoicer-uwsgi.ini.j2')\n content = template.render(**options)\n with open(os.path.join(outdir, 'invoicer-uwsgi.ini'), 'w') as fh:\n fh.write(content)\n click.echo('...done')\n ###########################################################################\n\n ###########################################################################\n click.echo('Creating `_build/invoicer-systemd.service')\n template = env.get_template('invoicer-systemd.service.j2')\n content = template.render(**options)\n with open(os.path.join(outdir, 'invoicer-systemd.service'), 'w') as fh:\n fh.write(content)\n click.echo('...done')\n ###########################################################################\n\n ###########################################################################\n click.echo('Creating `_build/invoicer-upstream.nginx')\n template = env.get_template('invoicer-upstream.nginx.j2')\n content = template.render(**options)\n with open(os.path.join(outdir, 'invoicer-upstream.nginx'), 'w') as fh:\n fh.write(content)\n click.echo('...done')\n\n click.echo('Creating `_build/invoicer-location.nginx')\n template = env.get_template('invoicer-location.nginx.j2')\n content = template.render(**options)\n with open(os.path.join(outdir, 'invoicer-location.nginx'), 'w') as fh:\n fh.write(content)\n click.echo('...done')\n ###########################################################################\n\n ###########################################################################\n click.echo('Creating `_build/fail2ban/filter.d/invoicer.local')\n f2b_filter_outdir = os.path.join(outdir, 'fail2ban', 'filter.d')\n if not os.path.isdir(f2b_filter_outdir):\n os.makedirs(f2b_filter_outdir)\n\n template = env.get_template('fail2ban/filter.d/invoicer.local.j2')\n content = template.render(**options)\n with open(os.path.join(f2b_filter_outdir, 'invoicer.local'), 'w') as fh:\n fh.write(content)\n click.echo('...done')\n ###########################################################################\n\n ###########################################################################\n click.echo('Creating `_build/fail2ban/jail.d/invoicer.local')\n f2b_filter_outdir = os.path.join(outdir, 'fail2ban', 'jail.d')\n if not os.path.isdir(f2b_filter_outdir):\n os.makedirs(f2b_filter_outdir)\n\n template = env.get_template('fail2ban/jail.d/invoicer.local.j2')\n content = template.render(**options)\n with open(os.path.join(f2b_filter_outdir, 'invoicer.local'), 'w') as fh:\n fh.write(content)\n click.echo('...done')\n ###########################################################################\n\n ###########################################################################\n click.echo('Creating `_build/deploy.bash')\n template = env.get_template('deploy.bash.j2')\n content = template.render(**options)\n with open(os.path.join(outdir, 'deploy.bash'), 'w') as fh:\n fh.write(content)\n click.echo('...done')\n ###########################################################################","def _close_through_level(self, level):\n while self._step_stack and self._step_stack[-1].config.nest_level >= level:\n cur = self._step_stack.pop()\n if cur.step_result:\n cur.step_result.presentation.finalize(cur.open_step.stream)\n cur.open_step.finalize()","def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,\n\tfetchonly=0, cleanup=0, dbkey=None, use_cache=1, fetchall=0, tree=None,\n\tmydbapi=None, vartree=None, prev_mtimes=None,\n\tfd_pipes=None, returnpid=False):\n\n\tif settings is None:\n\t\traise TypeError(\"settings parameter is required\")\n\tmysettings = settings\n\tmyroot = settings['EROOT']\n\n\tif _unused is not None and _unused != mysettings['EROOT']:\n\t\twarnings.warn(\"The third parameter of the \"\n\t\t\t\"portage.doebuild() is now unused. Use \"\n\t\t\t\"settings['ROOT'] instead.\",\n\t\t\tDeprecationWarning, stacklevel=2)\n\n\tif not tree:\n\t\twritemsg(\"Warning: tree not specified to doebuild\\n\")\n\t\ttree = \"porttree\"\n\t\n\t# chunked out deps for each phase, so that ebuild binary can use it \n\t# to collapse targets down.\n\tactionmap_deps={\n\t\"pretend\" : [],\n\t\"setup\": [\"pretend\"],\n\t\"unpack\": [\"setup\"],\n\t\"prepare\": [\"unpack\"],\n\t\"configure\": [\"prepare\"],\n\t\"compile\":[\"configure\"],\n\t\"test\": [\"compile\"],\n\t\"install\":[\"test\"],\n\t\"rpm\": [\"install\"],\n\t\"package\":[\"install\"],\n\t\"merge\" :[\"install\"],\n\t}\n\t\n\tif mydbapi is None:\n\t\tmydbapi = portage.db[myroot][tree].dbapi\n\n\tif vartree is None and mydo in (\"merge\", \"qmerge\", \"unmerge\"):\n\t\tvartree = portage.db[myroot][\"vartree\"]\n\n\tfeatures = mysettings.features\n\n\tclean_phases = (\"clean\", \"cleanrm\")\n\tvalidcommands = [\"help\",\"clean\",\"prerm\",\"postrm\",\"cleanrm\",\"preinst\",\"postinst\",\n\t \"config\", \"info\", \"setup\", \"depend\", \"pretend\",\n\t \"fetch\", \"fetchall\", \"digest\",\n\t \"unpack\", \"prepare\", \"configure\", \"compile\", \"test\",\n\t \"install\", \"rpm\", \"qmerge\", \"merge\",\n\t \"package\",\"unmerge\", \"manifest\"]\n\n\tif mydo not in validcommands:\n\t\tvalidcommands.sort()\n\t\twritemsg(\"!!! doebuild: '%s' is not one of the following valid commands:\" % mydo,\n\t\t\tnoiselevel=-1)\n\t\tfor vcount in range(len(validcommands)):\n\t\t\tif vcount%6 == 0:\n\t\t\t\twritemsg(\"\\n!!! \", noiselevel=-1)\n\t\t\twritemsg(validcommands[vcount].ljust(11), noiselevel=-1)\n\t\twritemsg(\"\\n\", noiselevel=-1)\n\t\treturn 1\n\n\tif returnpid and mydo != 'depend':\n\t\twarnings.warn(\"portage.doebuild() called \" + \\\n\t\t\t\"with returnpid parameter enabled. This usage will \" + \\\n\t\t\t\"not be supported in the future.\",\n\t\t\tDeprecationWarning, stacklevel=2)\n\n\tif mydo == \"fetchall\":\n\t\tfetchall = 1\n\t\tmydo = \"fetch\"\n\n\tparallel_fetchonly = mydo in (\"fetch\", \"fetchall\") and \\\n\t\t\"PORTAGE_PARALLEL_FETCHONLY\" in mysettings\n\n\tif mydo not in clean_phases and not os.path.exists(myebuild):\n\t\twritemsg(\"!!! doebuild: %s not found for %s\\n\" % (myebuild, mydo),\n\t\t\tnoiselevel=-1)\n\t\treturn 1\n\n\tglobal _doebuild_manifest_cache\n\tpkgdir = os.path.dirname(myebuild)\n\tmanifest_path = os.path.join(pkgdir, \"Manifest\")\n\tif tree == \"porttree\":\n\t\trepo_config = mysettings.repositories.get_repo_for_location(\n\t\t\tos.path.dirname(os.path.dirname(pkgdir)))\n\telse:\n\t\trepo_config = None\n\n\tmf = None\n\tif \"strict\" in features and \\\n\t\t\"digest\" not in features and \\\n\t\ttree == \"porttree\" and \\\n\t\tnot repo_config.thin_manifest and \\\n\t\tmydo not in (\"digest\", \"manifest\", \"help\") and \\\n\t\tnot portage._doebuild_manifest_exempt_depend and \\\n\t\tnot (repo_config.allow_missing_manifest and not os.path.exists(manifest_path)):\n\t\t# Always verify the ebuild checksums before executing it.\n\t\tglobal _doebuild_broken_ebuilds\n\n\t\tif myebuild in _doebuild_broken_ebuilds:\n\t\t\treturn 1\n\n\t\t# Avoid checking the same Manifest several times in a row during a\n\t\t# regen with an empty cache.\n\t\tif _doebuild_manifest_cache is None or \\\n\t\t\t_doebuild_manifest_cache.getFullname() != manifest_path:\n\t\t\t_doebuild_manifest_cache = None\n\t\t\tif not os.path.exists(manifest_path):\n\t\t\t\tout = portage.output.EOutput()\n\t\t\t\tout.eerror(_(\"Manifest not found for '%s'\") % (myebuild,))\n\t\t\t\t_doebuild_broken_ebuilds.add(myebuild)\n\t\t\t\treturn 1\n\t\t\tmf = repo_config.load_manifest(pkgdir, mysettings[\"DISTDIR\"])\n\n\t\telse:\n\t\t\tmf = _doebuild_manifest_cache\n\n\t\ttry:\n\t\t\tmf.checkFileHashes(\"EBUILD\", os.path.basename(myebuild))\n\t\texcept KeyError:\n\t\t\tif not (mf.allow_missing and\n\t\t\t\tos.path.basename(myebuild) not in mf.fhashdict[\"EBUILD\"]):\n\t\t\t\tout = portage.output.EOutput()\n\t\t\t\tout.eerror(_(\"Missing digest for '%s'\") % (myebuild,))\n\t\t\t\t_doebuild_broken_ebuilds.add(myebuild)\n\t\t\t\treturn 1\n\t\texcept FileNotFound:\n\t\t\tout = portage.output.EOutput()\n\t\t\tout.eerror(_(\"A file listed in the Manifest \"\n\t\t\t\t\"could not be found: '%s'\") % (myebuild,))\n\t\t\t_doebuild_broken_ebuilds.add(myebuild)\n\t\t\treturn 1\n\t\texcept DigestException as e:\n\t\t\tout = portage.output.EOutput()\n\t\t\tout.eerror(_(\"Digest verification failed:\"))\n\t\t\tout.eerror(\"%s\" % e.value[0])\n\t\t\tout.eerror(_(\"Reason: %s\") % e.value[1])\n\t\t\tout.eerror(_(\"Got: %s\") % e.value[2])\n\t\t\tout.eerror(_(\"Expected: %s\") % e.value[3])\n\t\t\t_doebuild_broken_ebuilds.add(myebuild)\n\t\t\treturn 1\n\n\t\tif mf.getFullname() in _doebuild_broken_manifests:\n\t\t\treturn 1\n\n\t\tif mf is not _doebuild_manifest_cache and not mf.allow_missing:\n\n\t\t\t# Make sure that all of the ebuilds are\n\t\t\t# actually listed in the Manifest.\n\t\t\tfor f in os.listdir(pkgdir):\n\t\t\t\tpf = None\n\t\t\t\tif f[-7:] == '.ebuild':\n\t\t\t\t\tpf = f[:-7]\n\t\t\t\tif pf is not None and not mf.hasFile(\"EBUILD\", f):\n\t\t\t\t\tf = os.path.join(pkgdir, f)\n\t\t\t\t\tif f not in _doebuild_broken_ebuilds:\n\t\t\t\t\t\tout = portage.output.EOutput()\n\t\t\t\t\t\tout.eerror(_(\"A file is not listed in the \"\n\t\t\t\t\t\t\t\"Manifest: '%s'\") % (f,))\n\t\t\t\t\t_doebuild_broken_manifests.add(manifest_path)\n\t\t\t\t\treturn 1\n\n\t\t# We cache it only after all above checks succeed.\n\t\t_doebuild_manifest_cache = mf\n\n\tlogfile=None\n\tbuilddir_lock = None\n\ttmpdir = None\n\ttmpdir_orig = None\n\n\ttry:\n\t\tif mydo in (\"digest\", \"manifest\", \"help\"):\n\t\t\t# Temporarily exempt the depend phase from manifest checks, in case\n\t\t\t# aux_get calls trigger cache generation.\n\t\t\tportage._doebuild_manifest_exempt_depend += 1\n\n\t\t# If we don't need much space and we don't need a constant location,\n\t\t# we can temporarily override PORTAGE_TMPDIR with a random temp dir\n\t\t# so that there's no need for locking and it can be used even if the\n\t\t# user isn't in the portage group.\n\t\tif mydo in (\"info\",):\n\t\t\ttmpdir = tempfile.mkdtemp()\n\t\t\ttmpdir_orig = mysettings[\"PORTAGE_TMPDIR\"]\n\t\t\tmysettings[\"PORTAGE_TMPDIR\"] = tmpdir\n\n\t\tdoebuild_environment(myebuild, mydo, myroot, mysettings, debug,\n\t\t\tuse_cache, mydbapi)\n\n\t\tif mydo in clean_phases:\n\t\t\tbuilddir_lock = None\n\t\t\tif not returnpid and \\\n\t\t\t\t'PORTAGE_BUILDIR_LOCKED' not in mysettings:\n\t\t\t\tbuilddir_lock = EbuildBuildDir(\n\t\t\t\t\tscheduler=EventLoop(main=False),\n\t\t\t\t\tsettings=mysettings)\n\t\t\t\tbuilddir_lock.lock()\n\t\t\ttry:\n\t\t\t\treturn _spawn_phase(mydo, mysettings,\n\t\t\t\t\tfd_pipes=fd_pipes, returnpid=returnpid)\n\t\t\tfinally:\n\t\t\t\tif builddir_lock is not None:\n\t\t\t\t\tbuilddir_lock.unlock()\n\n\t\t# get possible slot information from the deps file\n\t\tif mydo == \"depend\":\n\t\t\twritemsg(\"!!! DEBUG: dbkey: %s\\n\" % str(dbkey), 2)\n\t\t\tif returnpid:\n\t\t\t\treturn _spawn_phase(mydo, mysettings,\n\t\t\t\t\tfd_pipes=fd_pipes, returnpid=returnpid)\n\t\t\telif isinstance(dbkey, dict):\n\t\t\t\twarnings.warn(\"portage.doebuild() called \" + \\\n\t\t\t\t\t\"with dict dbkey argument. This usage will \" + \\\n\t\t\t\t\t\"not be supported in the future.\",\n\t\t\t\t\tDeprecationWarning, stacklevel=2)\n\t\t\t\tmysettings[\"dbkey\"] = \"\"\n\t\t\t\tpr, pw = os.pipe()\n\t\t\t\tfd_pipes = {\n\t\t\t\t\t0:sys.__stdin__.fileno(),\n\t\t\t\t\t1:sys.__stdout__.fileno(),\n\t\t\t\t\t2:sys.__stderr__.fileno(),\n\t\t\t\t\t9:pw}\n\t\t\t\tmypids = _spawn_phase(mydo, mysettings, returnpid=True,\n\t\t\t\t\tfd_pipes=fd_pipes)\n\t\t\t\tos.close(pw) # belongs exclusively to the child process now\n\t\t\t\tf = os.fdopen(pr, 'rb', 0)\n\t\t\t\tfor k, v in zip(auxdbkeys,\n\t\t\t\t\t(_unicode_decode(line).rstrip('\\n') for line in f)):\n\t\t\t\t\tdbkey[k] = v\n\t\t\t\tf.close()\n\t\t\t\tretval = os.waitpid(mypids[0], 0)[1]\n\t\t\t\tportage.process.spawned_pids.remove(mypids[0])\n\t\t\t\t# If it got a signal, return the signal that was sent, but\n\t\t\t\t# shift in order to distinguish it from a return value. (just\n\t\t\t\t# like portage.process.spawn() would do).\n\t\t\t\tif retval & 0xff:\n\t\t\t\t\tretval = (retval & 0xff) << 8\n\t\t\t\telse:\n\t\t\t\t\t# Otherwise, return its exit code.\n\t\t\t\t\tretval = retval >> 8\n\t\t\t\tif retval == os.EX_OK and len(dbkey) != len(auxdbkeys):\n\t\t\t\t\t# Don't trust bash's returncode if the\n\t\t\t\t\t# number of lines is incorrect.\n\t\t\t\t\tretval = 1\n\t\t\t\treturn retval\n\t\t\telif dbkey:\n\t\t\t\tmysettings[\"dbkey\"] = dbkey\n\t\t\telse:\n\t\t\t\tmysettings[\"dbkey\"] = \\\n\t\t\t\t\tos.path.join(mysettings.depcachedir, \"aux_db_key_temp\")\n\n\t\t\treturn _spawn_phase(mydo, mysettings,\n\t\t\t\tfd_pipes=fd_pipes, returnpid=returnpid)\n\n\t\t# Validate dependency metadata here to ensure that ebuilds with invalid\n\t\t# data are never installed via the ebuild command. Don't bother when\n\t\t# returnpid == True since there's no need to do this every time emerge\n\t\t# executes a phase.\n\t\tif tree == \"porttree\":\n\t\t\trval = _validate_deps(mysettings, myroot, mydo, mydbapi)\n\t\t\tif rval != os.EX_OK:\n\t\t\t\treturn rval\n\n\t\telse:\n\t\t\t# FEATURES=noauto only makes sense for porttree, and we don't want\n\t\t\t# it to trigger redundant sourcing of the ebuild for API consumers\n\t\t\t# that are using binary packages\n\t\t\tif \"noauto\" in mysettings.features:\n\t\t\t\tmysettings.features.discard(\"noauto\")\n\n\t\t# The info phase is special because it uses mkdtemp so and\n\t\t# user (not necessarily in the portage group) can run it.\n\t\tif mydo not in ('info',) and \\\n\t\t\tmydo not in _doebuild_commands_without_builddir:\n\t\t\trval = _check_temp_dir(mysettings)\n\t\t\tif rval != os.EX_OK:\n\t\t\t\treturn rval\n\n\t\tif mydo == \"unmerge\":\n\t\t\treturn unmerge(mysettings[\"CATEGORY\"],\n\t\t\t\tmysettings[\"PF\"], myroot, mysettings, vartree=vartree)\n\n\t\tphases_to_run = set()\n\t\tif \"noauto\" in mysettings.features or \\\n\t\t\tmydo not in actionmap_deps:\n\t\t\tphases_to_run.add(mydo)\n\t\telse:\n\t\t\tphase_stack = [mydo]\n\t\t\twhile phase_stack:\n\t\t\t\tx = phase_stack.pop()\n\t\t\t\tif x in phases_to_run:\n\t\t\t\t\tcontinue\n\t\t\t\tphases_to_run.add(x)\n\t\t\t\tphase_stack.extend(actionmap_deps.get(x, []))\n\t\t\tdel phase_stack\n\n\t\talist = set(mysettings.configdict[\"pkg\"].get(\"A\", \"\").split())\n\n\t\tunpacked = False\n\t\tif tree != \"porttree\":\n\t\t\tpass\n\t\telif \"unpack\" not in phases_to_run:\n\t\t\tunpacked = os.path.exists(os.path.join(\n\t\t\t\tmysettings[\"PORTAGE_BUILDDIR\"], \".unpacked\"))\n\t\telse:\n\t\t\ttry:\n\t\t\t\tworkdir_st = os.stat(mysettings[\"WORKDIR\"])\n\t\t\texcept OSError:\n\t\t\t\tpass\n\t\t\telse:\n\t\t\t\tnewstuff = False\n\t\t\t\tif not os.path.exists(os.path.join(\n\t\t\t\t\tmysettings[\"PORTAGE_BUILDDIR\"], \".unpacked\")):\n\t\t\t\t\twritemsg_stdout(_(\n\t\t\t\t\t\t\">>> Not marked as unpacked; recreating WORKDIR...\\n\"))\n\t\t\t\t\tnewstuff = True\n\t\t\t\telse:\n\t\t\t\t\tfor x in alist:\n\t\t\t\t\t\twritemsg_stdout(\">>> Checking %s's mtime...\\n\" % x)\n\t\t\t\t\t\ttry:\n\t\t\t\t\t\t\tx_st = os.stat(os.path.join(\n\t\t\t\t\t\t\t\tmysettings[\"DISTDIR\"], x))\n\t\t\t\t\t\texcept OSError:\n\t\t\t\t\t\t\t# file not fetched yet\n\t\t\t\t\t\t\tx_st = None\n\n\t\t\t\t\t\tif x_st is None or x_st.st_mtime > workdir_st.st_mtime:\n\t\t\t\t\t\t\twritemsg_stdout(_(\">>> Timestamp of \"\n\t\t\t\t\t\t\t\t\"%s has changed; recreating WORKDIR...\\n\") % x)\n\t\t\t\t\t\t\tnewstuff = True\n\t\t\t\t\t\t\tbreak\n\n\t\t\t\tif newstuff:\n\t\t\t\t\tif builddir_lock is None and \\\n\t\t\t\t\t\t'PORTAGE_BUILDIR_LOCKED' not in mysettings:\n\t\t\t\t\t\tbuilddir_lock = EbuildBuildDir(\n\t\t\t\t\t\t\tscheduler=EventLoop(main=False),\n\t\t\t\t\t\t\tsettings=mysettings)\n\t\t\t\t\t\tbuilddir_lock.lock()\n\t\t\t\t\ttry:\n\t\t\t\t\t\t_spawn_phase(\"clean\", mysettings)\n\t\t\t\t\tfinally:\n\t\t\t\t\t\tif builddir_lock is not None:\n\t\t\t\t\t\t\tbuilddir_lock.unlock()\n\t\t\t\t\t\t\tbuilddir_lock = None\n\t\t\t\telse:\n\t\t\t\t\twritemsg_stdout(_(\">>> WORKDIR is up-to-date, keeping...\\n\"))\n\t\t\t\t\tunpacked = True\n\n\t\t# Build directory creation isn't required for any of these.\n\t\t# In the fetch phase, the directory is needed only for RESTRICT=fetch\n\t\t# in order to satisfy the sane $PWD requirement (from bug #239560)\n\t\t# when pkg_nofetch is spawned.\n\t\thave_build_dirs = False\n\t\tif not parallel_fetchonly and \\\n\t\t\tmydo not in ('digest', 'fetch', 'help', 'manifest'):\n\t\t\tif not returnpid and \\\n\t\t\t\t'PORTAGE_BUILDIR_LOCKED' not in mysettings:\n\t\t\t\tbuilddir_lock = EbuildBuildDir(\n\t\t\t\t\tscheduler=EventLoop(main=False),\n\t\t\t\t\tsettings=mysettings)\n\t\t\t\tbuilddir_lock.lock()\n\t\t\tmystatus = prepare_build_dirs(myroot, mysettings, cleanup)\n\t\t\tif mystatus:\n\t\t\t\treturn mystatus\n\t\t\thave_build_dirs = True\n\n\t\t\t# emerge handles logging externally\n\t\t\tif not returnpid:\n\t\t\t\t# PORTAGE_LOG_FILE is set by the\n\t\t\t\t# above prepare_build_dirs() call.\n\t\t\t\tlogfile = mysettings.get(\"PORTAGE_LOG_FILE\")\n\n\t\tif have_build_dirs:\n\t\t\trval = _prepare_env_file(mysettings)\n\t\t\tif rval != os.EX_OK:\n\t\t\t\treturn rval\n\n\t\tif eapi_exports_merge_type(mysettings[\"EAPI\"]) and \\\n\t\t\t\"MERGE_TYPE\" not in mysettings.configdict[\"pkg\"]:\n\t\t\tif tree == \"porttree\":\n\t\t\t\tmysettings.configdict[\"pkg\"][\"EMERGE_FROM\"] = \"ebuild\"\n\t\t\t\tmysettings.configdict[\"pkg\"][\"MERGE_TYPE\"] = \"source\"\n\t\t\telif tree == \"bintree\":\n\t\t\t\tmysettings.configdict[\"pkg\"][\"EMERGE_FROM\"] = \"binary\"\n\t\t\t\tmysettings.configdict[\"pkg\"][\"MERGE_TYPE\"] = \"binary\"\n\n\t\t# NOTE: It's not possible to set REPLACED_BY_VERSION for prerm\n\t\t# and postrm here, since we don't necessarily know what\n\t\t# versions are being installed. This could be a problem\n\t\t# for API consumers if they don't use dblink.treewalk()\n\t\t# to execute prerm and postrm.\n\t\tif eapi_exports_replace_vars(mysettings[\"EAPI\"]) and \\\n\t\t\t(mydo in (\"postinst\", \"preinst\", \"pretend\", \"setup\") or \\\n\t\t\t(\"noauto\" not in features and not returnpid and \\\n\t\t\t(mydo in actionmap_deps or mydo in (\"merge\", \"package\", \"qmerge\")))):\n\t\t\tif not vartree:\n\t\t\t\twritemsg(\"Warning: vartree not given to doebuild. \" + \\\n\t\t\t\t\t\"Cannot set REPLACING_VERSIONS in pkg_{pretend,setup}\\n\")\n\t\t\telse:\n\t\t\t\tvardb = vartree.dbapi\n\t\t\t\tcpv = mysettings.mycpv\n\t\t\t\tcpv_slot = \"%s%s%s\" % \\\n\t\t\t\t\t(cpv.cp, portage.dep._slot_separator, cpv.slot)\n\t\t\t\tmysettings[\"REPLACING_VERSIONS\"] = \" \".join(\n\t\t\t\t\tset(portage.versions.cpv_getversion(match) \\\n\t\t\t\t\t\tfor match in vardb.match(cpv_slot) + \\\n\t\t\t\t\t\tvardb.match('='+cpv)))\n\n\t\t# if any of these are being called, handle them -- running them out of\n\t\t# the sandbox -- and stop now.\n\t\tif mydo in (\"config\", \"help\", \"info\", \"postinst\",\n\t\t\t\"preinst\", \"pretend\", \"postrm\", \"prerm\"):\n\t\t\tif mydo in (\"preinst\", \"postinst\"):\n\t\t\t\tenv_file = os.path.join(os.path.dirname(mysettings[\"EBUILD\"]),\n\t\t\t\t\t\"environment.bz2\")\n\t\t\t\tif os.path.isfile(env_file):\n\t\t\t\t\tmysettings[\"PORTAGE_UPDATE_ENV\"] = env_file\n\t\t\ttry:\n\t\t\t\treturn _spawn_phase(mydo, mysettings,\n\t\t\t\t\tfd_pipes=fd_pipes, logfile=logfile, returnpid=returnpid)\n\t\t\tfinally:\n\t\t\t\tmysettings.pop(\"PORTAGE_UPDATE_ENV\", None)\n\n\t\tmycpv = \"/\".join((mysettings[\"CATEGORY\"], mysettings[\"PF\"]))\n\n\t\t# Only try and fetch the files if we are going to need them ...\n\t\t# otherwise, if user has FEATURES=noauto and they run `ebuild clean\n\t\t# unpack compile install`, we will try and fetch 4 times :/\n\t\tneed_distfiles = tree == \"porttree\" and not unpacked and \\\n\t\t\t(mydo in (\"fetch\", \"unpack\") or \\\n\t\t\tmydo not in (\"digest\", \"manifest\") and \"noauto\" not in features)\n\t\tif need_distfiles:\n\n\t\t\tsrc_uri, = mydbapi.aux_get(mysettings.mycpv,\n\t\t\t\t[\"SRC_URI\"], mytree=os.path.dirname(os.path.dirname(\n\t\t\t\tos.path.dirname(myebuild))))\n\t\t\tmetadata = {\n\t\t\t\t\"EAPI\" : mysettings[\"EAPI\"],\n\t\t\t\t\"SRC_URI\" : src_uri,\n\t\t\t}\n\t\t\tuse = frozenset(mysettings[\"PORTAGE_USE\"].split())\n\t\t\ttry:\n\t\t\t\talist = _parse_uri_map(mysettings.mycpv, metadata, use=use)\n\t\t\t\taalist = _parse_uri_map(mysettings.mycpv, metadata)\n\t\t\texcept InvalidDependString as e:\n\t\t\t\twritemsg(\"!!! %s\\n\" % str(e), noiselevel=-1)\n\t\t\t\twritemsg(_(\"!!! Invalid SRC_URI for '%s'.\\n\") % mycpv,\n\t\t\t\t\tnoiselevel=-1)\n\t\t\t\tdel e\n\t\t\t\treturn 1\n\n\t\t\tif \"mirror\" in features or fetchall:\n\t\t\t\tfetchme = aalist\n\t\t\telse:\n\t\t\t\tfetchme = alist\n\n\t\t\tdist_digests = None\n\t\t\tif mf is not None:\n\t\t\t\tdist_digests = mf.getTypeDigests(\"DIST\")\n\t\t\tif not fetch(fetchme, mysettings, listonly=listonly,\n\t\t\t\tfetchonly=fetchonly, allow_missing_digests=True,\n\t\t\t\tdigests=dist_digests):\n\t\t\t\tspawn_nofetch(mydbapi, myebuild, settings=mysettings)\n\t\t\t\tif listonly:\n\t\t\t\t\t# The convention for listonly mode is to report\n\t\t\t\t\t# success in any case, even though fetch() may\n\t\t\t\t\t# return unsuccessfully in order to trigger the\n\t\t\t\t\t# nofetch phase.\n\t\t\t\t\treturn 0\n\t\t\t\treturn 1\n\n\t\tif need_distfiles:\n\t\t\t# Files are already checked inside fetch(),\n\t\t\t# so do not check them again.\n\t\t\tcheckme = []\n\t\telif unpacked:\n\t\t\t# The unpack phase is marked as complete, so it\n\t\t\t# would be wasteful to check distfiles again.\n\t\t\tcheckme = []\n\t\telse:\n\t\t\tcheckme = alist\n\n\t\tif mydo == \"fetch\" and listonly:\n\t\t\treturn 0\n\n\t\ttry:\n\t\t\tif mydo == \"manifest\":\n\t\t\t\tmf = None\n\t\t\t\t_doebuild_manifest_cache = None\n\t\t\t\treturn not digestgen(mysettings=mysettings, myportdb=mydbapi)\n\t\t\telif mydo == \"digest\":\n\t\t\t\tmf = None\n\t\t\t\t_doebuild_manifest_cache = None\n\t\t\t\treturn not digestgen(mysettings=mysettings, myportdb=mydbapi)\n\t\t\telif mydo != 'fetch' and \\\n\t\t\t\t\"digest\" in mysettings.features:\n\t\t\t\t# Don't do this when called by emerge or when called just\n\t\t\t\t# for fetch (especially parallel-fetch) since it's not needed\n\t\t\t\t# and it can interfere with parallel tasks.\n\t\t\t\tmf = None\n\t\t\t\t_doebuild_manifest_cache = None\n\t\t\t\tdigestgen(mysettings=mysettings, myportdb=mydbapi)\n\t\texcept PermissionDenied as e:\n\t\t\twritemsg(_(\"!!! Permission Denied: %s\\n\") % (e,), noiselevel=-1)\n\t\t\tif mydo in (\"digest\", \"manifest\"):\n\t\t\t\treturn 1\n\n\t\t# See above comment about fetching only when needed\n\t\tif tree == 'porttree' and \\\n\t\t\tnot digestcheck(checkme, mysettings, \"strict\" in features, mf=mf):\n\t\t\treturn 1\n\n\t\tif mydo == \"fetch\":\n\t\t\treturn 0\n\n\t\t# remove PORTAGE_ACTUAL_DISTDIR once cvs/svn is supported via SRC_URI\n\t\tif tree == 'porttree' and \\\n\t\t\t((mydo != \"setup\" and \"noauto\" not in features) \\\n\t\t\tor mydo in (\"install\", \"unpack\")):\n\t\t\t_prepare_fake_distdir(mysettings, alist)\n\n\t\t#initial dep checks complete; time to process main commands\n\t\tactionmap = _spawn_actionmap(mysettings)\n\n\t\t# merge the deps in so we have again a 'full' actionmap\n\t\t# be glad when this can die.\n\t\tfor x in actionmap:\n\t\t\tif len(actionmap_deps.get(x, [])):\n\t\t\t\tactionmap[x][\"dep\"] = ' '.join(actionmap_deps[x])\n\n\t\tif mydo in actionmap:\n\t\t\tbintree = None\n\t\t\tif mydo == \"package\":\n\t\t\t\t# Make sure the package directory exists before executing\n\t\t\t\t# this phase. This can raise PermissionDenied if\n\t\t\t\t# the current user doesn't have write access to $PKGDIR.\n\t\t\t\tif hasattr(portage, 'db'):\n\t\t\t\t\tbintree = portage.db[mysettings['EROOT']]['bintree']\n\t\t\t\t\tmysettings[\"PORTAGE_BINPKG_TMPFILE\"] = \\\n\t\t\t\t\t\tbintree.getname(mysettings.mycpv) + \\\n\t\t\t\t\t\t\".%s\" % (os.getpid(),)\n\t\t\t\t\tbintree._ensure_dir(os.path.dirname(\n\t\t\t\t\t\tmysettings[\"PORTAGE_BINPKG_TMPFILE\"]))\n\t\t\t\telse:\n\t\t\t\t\tparent_dir = os.path.join(mysettings[\"PKGDIR\"],\n\t\t\t\t\t\tmysettings[\"CATEGORY\"])\n\t\t\t\t\tportage.util.ensure_dirs(parent_dir)\n\t\t\t\t\tif not os.access(parent_dir, os.W_OK):\n\t\t\t\t\t\traise PermissionDenied(\n\t\t\t\t\t\t\t\"access('%s', os.W_OK)\" % parent_dir)\n\t\t\tretval = spawnebuild(mydo,\n\t\t\t\tactionmap, mysettings, debug, logfile=logfile,\n\t\t\t\tfd_pipes=fd_pipes, returnpid=returnpid)\n\n\t\t\tif retval == os.EX_OK:\n\t\t\t\tif mydo == \"package\" and bintree is not None:\n\t\t\t\t\tbintree.inject(mysettings.mycpv,\n\t\t\t\t\t\tfilename=mysettings[\"PORTAGE_BINPKG_TMPFILE\"])\n\t\t\telse:\n\t\t\t\tif \"PORTAGE_BINPKG_TMPFILE\" in mysettings:\n\t\t\t\t\ttry:\n\t\t\t\t\t\tos.unlink(mysettings[\"PORTAGE_BINPKG_TMPFILE\"])\n\t\t\t\t\texcept OSError:\n\t\t\t\t\t\tpass\n\n\t\telif mydo==\"qmerge\":\n\t\t\t# check to ensure install was run. this *only* pops up when users\n\t\t\t# forget it and are using ebuild\n\t\t\tif not os.path.exists(\n\t\t\t\tos.path.join(mysettings[\"PORTAGE_BUILDDIR\"], \".installed\")):\n\t\t\t\twritemsg(_(\"!!! mydo=qmerge, but the install phase has not been run\\n\"),\n\t\t\t\t\tnoiselevel=-1)\n\t\t\t\treturn 1\n\t\t\t# qmerge is a special phase that implies noclean.\n\t\t\tif \"noclean\" not in mysettings.features:\n\t\t\t\tmysettings.features.add(\"noclean\")\n\t\t\t_handle_self_update(mysettings, vartree.dbapi)\n\t\t\t#qmerge is specifically not supposed to do a runtime dep check\n\t\t\tretval = merge(\n\t\t\t\tmysettings[\"CATEGORY\"], mysettings[\"PF\"], mysettings[\"D\"],\n\t\t\t\tos.path.join(mysettings[\"PORTAGE_BUILDDIR\"], \"build-info\"),\n\t\t\t\tmyroot, mysettings, myebuild=mysettings[\"EBUILD\"], mytree=tree,\n\t\t\t\tmydbapi=mydbapi, vartree=vartree, prev_mtimes=prev_mtimes)\n\t\telif mydo==\"merge\":\n\t\t\tretval = spawnebuild(\"install\", actionmap, mysettings, debug,\n\t\t\t\talwaysdep=1, logfile=logfile, fd_pipes=fd_pipes,\n\t\t\t\treturnpid=returnpid)\n\t\t\tif retval != os.EX_OK:\n\t\t\t\t# The merge phase handles this already. Callers don't know how\n\t\t\t\t# far this function got, so we have to call elog_process() here\n\t\t\t\t# so that it's only called once.\n\t\t\t\telog_process(mysettings.mycpv, mysettings)\n\t\t\tif retval == os.EX_OK:\n\t\t\t\t_handle_self_update(mysettings, vartree.dbapi)\n\t\t\t\tretval = merge(mysettings[\"CATEGORY\"], mysettings[\"PF\"],\n\t\t\t\t\tmysettings[\"D\"], os.path.join(mysettings[\"PORTAGE_BUILDDIR\"],\n\t\t\t\t\t\"build-info\"), myroot, mysettings,\n\t\t\t\t\tmyebuild=mysettings[\"EBUILD\"], mytree=tree, mydbapi=mydbapi,\n\t\t\t\t\tvartree=vartree, prev_mtimes=prev_mtimes)\n\t\telse:\n\t\t\twritemsg_stdout(_(\"!!! Unknown mydo: %s\\n\") % mydo, noiselevel=-1)\n\t\t\treturn 1\n\n\t\treturn retval\n\n\tfinally:\n\n\t\tif builddir_lock is not None:\n\t\t\tbuilddir_lock.unlock()\n\t\tif tmpdir:\n\t\t\tmysettings[\"PORTAGE_TMPDIR\"] = tmpdir_orig\n\t\t\tshutil.rmtree(tmpdir)\n\n\t\tmysettings.pop(\"REPLACING_VERSIONS\", None)\n\n\t\t# Make sure that DISTDIR is restored to it's normal value before we return!\n\t\tif \"PORTAGE_ACTUAL_DISTDIR\" in mysettings:\n\t\t\tmysettings[\"DISTDIR\"] = mysettings[\"PORTAGE_ACTUAL_DISTDIR\"]\n\t\t\tdel mysettings[\"PORTAGE_ACTUAL_DISTDIR\"]\n\n\t\tif logfile and not returnpid:\n\t\t\ttry:\n\t\t\t\tif os.stat(logfile).st_size == 0:\n\t\t\t\t\tos.unlink(logfile)\n\t\t\texcept OSError:\n\t\t\t\tpass\n\n\t\tif mydo in (\"digest\", \"manifest\", \"help\"):\n\t\t\t# If necessary, depend phase has been triggered by aux_get calls\n\t\t\t# and the exemption is no longer needed.\n\t\t\tportage._doebuild_manifest_exempt_depend -= 1","def build_all(self):\n self.android_build()\n self.generate_patch_build('')\n self.generate_specs_build()\n self.generate_interfaces()","def beginHypo( self ):\n assert isinstance( self._env, Env )\n assert isinstance( self._steps, list )\n\n if len(self._steps) == 0:\n prevStepLevel = 0\n else:\n prevStepLevel = self._steps[ len(self._steps) - 1 ].level\n\n if self._env.level() not in ( prevStepLevel, prevStepLevel - 1 ):\n raise Exception( 'Cannot nest more than one level in a single step.' )\n\n self._env = Env( self._env.level() + 1, self._env )","def main(*, build, subdir, description, supports_modules=False,\n supports_quick=False):\n parser = argparse.ArgumentParser(description=description)\n group = parser.add_mutually_exclusive_group()\n group.add_argument(\n \"--serve\", action='store_true',\n help=\"Serve the documentation on the given PORT for easy preview.\")\n group.add_argument(\n \"--out_dir\", type=str, metavar=\"DIR\",\n help=\"Generate the documentation to the given output directory.\"\n \" The DIR must be an absolute path.\"\n \" If DIR already exists, then it must be empty.\"\n \" (For regression testing, the DIR can be the magic value <test>,\"\n \" in which case a $TEST_TMPDIR subdir will be used.)\")\n parser.add_argument(\n \"--port\", type=int, metavar=\"PORT\", default=8000,\n help=\"Use a non-default PORT when serving for preview.\")\n parser.add_argument(\n \"--verbose\", action=\"store_true\",\n help=\"Echo detailed commands, progress, etc. to the console\")\n if supports_modules:\n parser.add_argument(\n \"module\", nargs=\"*\",\n help=\"Limit the generated documentation to only these modules and \"\n \"their children. When none are provided, all will be generated. \"\n \"For example, specify drake.math or drake/math for the C++ \"\n \"module, or pydrake.math or pydrake/math for the Python module.\")\n if supports_quick:\n parser.add_argument(\n \"--quick\", action=\"store_true\", default=False,\n help=\"Omit from the output items that are slow to generate. \"\n \"This yields a faster preview, but the output will be incomplete.\")\n args = parser.parse_args()\n if args.verbose:\n global _verbose\n _verbose = True\n curried_build = build\n if supports_modules:\n canonicalized_modules = [\n x.replace('/', '.')\n for x in args.module\n ]\n curried_build = functools.partial(\n curried_build, modules=canonicalized_modules)\n if supports_quick:\n curried_build = functools.partial(\n curried_build, quick=args.quick)\n if args.out_dir is None:\n assert args.serve\n _do_preview(build=curried_build, subdir=subdir, port=args.port)\n else:\n _do_generate(build=curried_build, out_dir=args.out_dir,\n on_error=parser.error)","def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\r\n # pylint: disable=no-member\r\n if depth == 0:\r\n self.get_module.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\r\n else:\r\n self.get_module.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)","def buildStarted(builderName, build):","def work_in_example_project(request):\n return chdir_in_and_out(request, LoslassaProject.EXAMPLE_PROJECT)","def RunStages(self):\n self._RunStage(build_stages.InitSDKStage)\n self.RunSetupBoard()\n self._RunStage(report_stages.RefreshPackageStatusStage)","def main():\n init()\n separator_len = 40\n for s in stage_instances:\n print('='*separator_len)\n print(s.name)\n print('-'*separator_len)\n\n s.add_tasks() # Add tasks from previous stage\n s.revive_or_archive() # Revive killed tasks or move them to failed\n s.schedule_jobs() # Schedule new jobs if needed\n s.print_status()\n print('='*separator_len + '\\n')\n render(stage_instances)","def task_generate_tasks():\n \n yield {\n 'basename': 'generate_tasks',\n 'name': None,\n # 'doc': 'docs for X',\n 'watch': ['trains/'],\n 'task_dep': ['create_folders'],\n }\n \n for root, dirs, files in os.walk('trains/',topdown=False):\n for f in files:\n #print(f)\n yield template_train_model(os.path.join(root,f))","def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\r\n # pylint: disable=no-member\r\n if depth == 0:\r\n self.load_item.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\r\n else:\r\n self.load_item.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)","def docker_build(c):\n cli_tasks.docker_build.run(c)","def test_sections_json_spider_three_levels(self):\n\n title = (\"Taking Action for the Social and Emotional Health of \"\n\t \"Young Children: A Report to the Community from the Denver \"\n\t\t \"Early Childhood Council\")\n\tsummary = (\"Now, Denver has a plan of action to make it easier for \"\n\t \"families to access early childhood mental health \"\n\t\t \"information, intervention and services.\")\n\tbyline = \"Denver Early Childhood Council\"\n story = create_story(title=title, summary=summary, byline=byline)\n section1 = create_section(\"We're ready to take action. Are you?\",\n\t\t\t story=story, weight=7)\n\tsection2 = create_section(\"Ricardo's Story\",\n\t\t\t story=story, weight=2)\n\tsection3 = create_section(\"Meeting the need for better child mental health services\",\n\t\t\t story=story, root=True, weight=1)\n\tsection4 = create_section(\"Healthy Minds Support Strong Futures\",\n\t\t\t story=story, weight=5) \n\tsection5 = create_section(\"Community Voices\",\n\t\t\t story=story, weight=3)\n\tsection6 = create_section(\"Our Vision: That All Children in Denver are Valued, Healthy and Thriving\",\n\t\t\t story=story, weight=4)\n\tsection7 = create_section(\"Defining a \\\"Framework for Change\\\" with Actionable Goals and Strategies\",\n\t\t\t story=story, weight=5) \n section8 = create_section(\"How Can the Plan Make a Difference?\",\n\t\t\t story=story, weight=5)\n\tsection9 = create_section(\"Impact\", story=story, weight=6)\n SectionRelation.objects.create(parent=section6, child=section8,\n weight=0)\n SectionRelation.objects.create(parent=section7, child=section9,\n weight=0)\n SectionRelation.objects.create(parent=section6, child=section7,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section1,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section6,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section4,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section5,\n weight=0)\n SectionRelation.objects.create(parent=section3, child=section2,\n weight=0)\n\tjson_sections = simplejson.loads(story.structure.sections_json(\n\t\tinclude_summary=False, include_call_to_action=False))\n\tself.assertIn(\n\t section8.section_id,\n\t self._get_section(json_sections, section6.section_id)['children'])\n\tself.assertIn(\n\t section9.section_id,\n\t self._get_section(json_sections, section7.section_id)['children'])\n\tself.assertIn(\n\t section7.section_id,\n\t self._get_section(json_sections, section6.section_id)['children'])\n\tself.assertIn(\n\t section1.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])\n\tself.assertIn(\n\t section6.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])\n\tself.assertIn(\n\t section4.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])\n\tself.assertIn(\n\t section5.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])\n\tself.assertIn(\n\t section2.section_id,\n\t self._get_section(json_sections, section3.section_id)['children'])","def main(verbose, debug, names):\n initialize(debug)\n\n echome(names)\n # click.echo(\"hello\")\n # see\n # https://www.brianthicks.com/post/2014/11/03/build-modular-command-line-tools-with-click/","def generate_submissons_all_steps():\n\n\n data_en = read_json_file(\"Test_Data/test-en.json\")\n data_pr = read_json_file(\"Test_Data/test-pr.json\")\n data_es = read_json_file(\"Test_Data/test-es.json\")\n res_en = generate_embeddings_sentence_test_data(data_en, \"Test_Data/embd-en.pkl\")\n res_es = generate_embeddings_sentence_test_data(data_es, \"Test_Data/embd-es.pkl\")\n res_pr = generate_embeddings_sentence_test_data(data_pr, \"Test_Data/embd-pr.pkl\")\n model = load_model(\"model_doc\")\n make_submission(res_es, model, \"submission-es\")\n make_submission(res_pr, model, \"submission-pr\")\n make_submission(res_en, model, \"submission-en\")\n exit()","def cmnd_stage():\n pass","def test_minimalSubProjectLayout(self):\n structure = {\n \"LICENSE\": \"copyright!\",\n \"bin\": {},\n \"twisted\":\n {\"web\": {\"__init__.py\": \"import WEB\",\n \"topfiles\": {\"setup.py\": \"import WEBINSTALL\"}},\n \"plugins\": {}}}\n\n outStructure = {\n \"setup.py\": \"import WEBINSTALL\",\n \"LICENSE\": \"copyright!\",\n \"twisted\": {\"web\": {\"__init__.py\": \"import WEB\"}}}\n\n self.createStructure(self.rootDir, structure)\n\n outputFile = self.builder.buildSubProject(\"web\", \"0.3.0\")\n\n self.assertExtractedStructure(outputFile, outStructure)","def test_expand_experiments():\n template_script = get_template_script()\n experiment_systems = utils.CombinatorialLeaf(['explicit-system', 'implicit-system', 'hydration-system'])\n template_script['experiments']['system'] = experiment_systems\n\n exp_builder = ExperimentBuilder(script=template_script, job_id=1, n_jobs=2)\n experiments = list(exp_builder._expand_experiments())\n assert len(experiments) == 2\n\n exp_builder = ExperimentBuilder(script=template_script, job_id=2, n_jobs=2)\n experiments = list(exp_builder._expand_experiments())\n assert len(experiments) == 1","def build(images, tag, quiet):\n # images to build\n build_images = None\n\n # list of available images\n image_list = build_image_map().keys()\n\n # image specified: check if it exists\n if images:\n build_images = []\n for check_name in images:\n if check_name in image_list:\n build_images.append(check_name)\n continue\n raise click.ClickException(\n \"invalid image name '{}'\".format(check_name))\n click.echo('building images {}'.format(', '.join(build_images)))\n # no image specified: build all\n else:\n click.echo('building images {}'.format(', '.join(image_list)))\n\n manager = Manager('build', tag, images=build_images, verbose=not quiet)\n manager.run()","def nodes_run_cmd(self, group, cmd):\n path_inventory = u'%s/inventories/%s' % (self.ansible_path, self.environment)\n path_lib = u'%s/library/beehive/' % (self.ansible_path)\n runner = Runner(inventory=path_inventory, verbosity=self.verbosity, \n module=path_lib)\n tasks = [\n dict(action=dict(module=u'shell', args=cmd), register=u'shell_out'),\n ]\n runner.run_task(group, tasks=tasks, frmt=u'json')","def walk(node, parent):\n for name, item in node.iteritems():\n if type(item) is dict:\n cat = etree.SubElement(parent, 'menu', id=name, label=name)\n walk (item, cat)\n else:\n menu_item = etree.SubElement(parent, 'item', label=name)\n action = etree.SubElement(menu_item, 'action', name='execute')\n etree.SubElement(action, 'command').text = item","def main(\n output,\n elm_make,\n mount_at,\n exclude,\n force_exclusion,\n validate,\n doit_args,\n project_path,\n include_paths):\n\n if not validate and output is None:\n raise click.BadParameter('please specify --output directory')\n\n def task_build():\n resolved_include_paths = [_resolve_path(path) for path in include_paths]\n exclude_modules = exclude.split(',') if exclude else []\n return create_tasks(\n _resolve_path(project_path),\n _resolve_path(output) if output is not None else None,\n elm_make=_resolve_path(elm_make) if elm_make is not None else None,\n include_paths=resolved_include_paths,\n exclude_modules=exclude_modules,\n force_exclusion=force_exclusion,\n mount_point=mount_at,\n validate=validate)\n\n result = DoitMain(ModuleTaskLoader(locals())).run(\n doit_args.split(' ') if doit_args else [])\n if result is not None and result > 0:\n raise DoitException('', result)","def main():\n parser = argparse.ArgumentParser(description=\"Wrapper for the GROMACS make_ndx module.\",\n formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, width=99999))\n parser.add_argument('-c', '--config', required=False, help=\"This file can be a YAML file, JSON file or JSON string\")\n\n # Specific args of each building block\n required_args = parser.add_argument_group('required arguments')\n required_args.add_argument('--input_structure_path', required=True)\n required_args.add_argument('--output_ndx_path', required=True)\n parser.add_argument('--input_ndx_path', required=False)\n\n args = parser.parse_args()\n config = args.config if args.config else None\n properties = settings.ConfReader(config=config).get_prop_dic()\n\n # Specific call of each building block\n make_ndx(input_structure_path=args.input_structure_path,\n output_ndx_path=args.output_ndx_path,\n input_ndx_path=args.input_ndx_path,\n properties=properties)","def build(self, parent):\n raise NotImplementedError","def build_tree(java_path, verbose):\n logging.info(\"Building in %s \", java_path)\n # special hack for comparing with rel/2.0.0, see HBASE-26063 for more details\n subprocess.check_call([\"sed\", \"-i\", \"2148s/3.0.0/3.0.4/g\", \"pom.xml\"], cwd=java_path)\n mvn_cmd = [\"mvn\", \"--batch-mode\", \"-DskipTests\",\n \"-Dmaven.javadoc.skip=true\", \"package\"]\n if not verbose:\n mvn_cmd.insert(-1, \"--quiet\")\n subprocess.check_call(mvn_cmd, cwd=java_path)","def build (self, buildtype):\n layout = self.xlayout()\n\n # NuGet removes the prefixing v from the version.\n vless_version = self.kv['version']\n if vless_version[0] == 'v':\n vless_version = vless_version[1:]\n\n\n self.stpath = tempfile.mkdtemp(prefix=\"out-\", suffix=\"-%s\" % buildtype,\n dir=\".\")\n\n self.render('librdkafka.redist.nuspec')\n self.copy_template('librdkafka.redist.targets',\n destpath=os.path.join('build', 'native'))\n self.copy_template('librdkafka.redist.props',\n destpath=os.path.join('build', 'native'))\n self.copy_template('librdkafka.redist.props',\n destpath=os.path.join('build', 'net'))\n for f in default_doc:\n shutil.copy(f, self.stpath)\n\n self.extract_artifacts(layout)\n\n print('Tree extracted to %s' % self.stpath)\n\n # After creating a bare-bone nupkg layout containing the artifacts\n # and some spec and props files, call the 'nuget' utility to\n # make a proper nupkg of it (with all the metadata files).\n subprocess.check_call(\"./nuget.sh pack %s -BasePath '%s' -NonInteractive\" % \\\n (os.path.join(self.stpath, 'librdkafka.redist.nuspec'),\n self.stpath), shell=True)\n return ['librdkafka.redist.%s.nupkg' % vless_version]","def info_build_test(self):\n\n self._export(\"H0\", \"0.1\")\n\n self._export(\"H1a\", \"0.1\", deps=[(\"H0/0.1@lu/st\", \"private\")])\n self._export(\"H1b\", \"0.1\", deps=[\"H0/0.1@lu/st\"])\n self._export(\"H1c\", \"0.1\", deps=[(\"H0/0.1@lu/st\", \"private\")])\n\n self._export(\"H2a\", \"0.1\", deps=[\"H1a/0.1@lu/st\"])\n self._export(\"H2c\", \"0.1\", deps=[\"H1c/0.1@lu/st\"])\n\n self._export(\"H3\", \"0.1\", deps=[\"H2a/0.1@lu/st\",\n \"H2c/0.1@lu/st\"])\n\n # If we install H3 we need to build all except H1b\n self.clients[\"H3\"].run(\"info --build missing\")\n self.assert_last_line(self.clients[\"H3\"],\n \"H0/0.1@lu/st, H1a/0.1@lu/st, H1c/0.1@lu/st, H2a/0.1@lu/st, H2c/0.1@lu/st\")\n\n # If we install H0 we need to build nothing (current project)\n self.clients[\"H0\"].run(\"info --build missing\")\n self.assert_last_line(self.clients[\"H0\"], \"\")\n\n # If we install H0 we need to build H0\n self.clients[\"H1a\"].run(\"info --build missing\")\n self.assert_last_line(self.clients[\"H1a\"], \"H0/0.1@lu/st\")\n\n # If we build and upload H1a and H1c, no more H0 (private) is required\n self.clients[\"H3\"].run(\"install H1a/0.1@lu/st --build \")\n self.clients[\"H3\"].run(\"install H1c/0.1@lu/st --build \")\n self.clients[\"H3\"].run(\"upload H1a/0.1@lu/st --all\")\n self.clients[\"H3\"].run(\"upload H1c/0.1@lu/st --all\")\n\n self.clients[\"H3\"].run(\"remove '*' -f\")\n self.clients[\"H3\"].run(\"info --build missing\")\n self.assert_last_line(self.clients[\"H3\"],\n \"H2a/0.1@lu/st, H2c/0.1@lu/st\")\n\n # But if we force to build all, all nodes have to be built\n self.clients[\"H3\"].run(\"remove '*' -f\")\n self.clients[\"H3\"].run(\"info --build\")\n self.assert_last_line(self.clients[\"H3\"],\n \"H0/0.1@lu/st, H1a/0.1@lu/st, H1c/0.1@lu/st, H2a/0.1@lu/st, H2c/0.1@lu/st\")\n\n # Now upgrade the recipe H1a and upload it (but not the package)\n # so the package become outdated\n conanfile_path = os.path.join(self.clients[\"H1a\"].current_folder, CONANFILE)\n conanfile = load(conanfile_path)\n conanfile += \"\\n# MODIFIED\"\n save(conanfile_path, conanfile)\n self.clients[\"H1a\"].run(\"export lu/st\")\n self.clients[\"H1a\"].run(\"upload H1a/0.1@lu/st\") # NOW IS OUTDATED!\n\n # Without build outdated the built packages are the same\n self.clients[\"H3\"].run(\"remove '*' -f\")\n self.clients[\"H3\"].run(\"info --build missing\")\n self.assert_last_line(self.clients[\"H3\"],\n \"H2a/0.1@lu/st, H2c/0.1@lu/st\")\n\n # But with build outdated we have to build the private H0 (but only once) and H1a\n self.clients[\"H3\"].run(\"remove '*' -f\")\n self.clients[\"H3\"].run(\"info --build outdated\")\n self.assert_last_line(self.clients[\"H3\"],\n \"H0/0.1@lu/st, H1a/0.1@lu/st, H2a/0.1@lu/st, H2c/0.1@lu/st\")","def test_workflow_parse(self):\n\n workflow = [{'job_template': 'sample_job1',\n 'success': [{'job_template': 'sample_job2'}],\n 'always': [{'job_template': 'sample_job3'}]}]\n dry_run = True\n extra_vars_arg = {'sample_vars': 'sample'}\n\n top_node = tree.generate_workflow_tree(workflow, dry_run,\n extra_vars_arg)\n correct = 1\n self.assertEqual(top_node.node_id, correct)","def build():\n local('vagrant up')"],"string":"[\n \"def build_step(self):\\n pass\",\n \"def build_step(self):\\n pass\",\n \"def test_build_page_nested(build_resources, cli):\\n books, _ = build_resources\\n src = books.joinpath(\\\"nested\\\")\\n page = src.joinpath(\\\"contents\\\", \\\"markdown.md\\\")\\n html = src.joinpath(\\\"_build\\\", \\\"_page\\\", \\\"contents-markdown\\\", \\\"html\\\")\\n index = html.joinpath(\\\"index.html\\\")\\n result = cli.invoke(commands.build, [page.as_posix(), \\\"-n\\\", \\\"-W\\\", \\\"--keep-going\\\"])\\n assert result.exit_code == 0, result.output\\n assert html.joinpath(\\\"markdown.html\\\").exists()\\n assert not html.joinpath(\\\"extra_page.html\\\").exists()\\n assert 'url=markdown.html\\\" />' in index.read_text(encoding=\\\"utf8\\\")\",\n \"def build_step(self):\\n\\n pass\",\n \"def test_run_tempest(self, tempest_actions, show_step, _):\\n show_step(1)\\n tempest_actions.prepare_and_run_tempest()\",\n \"def stepStarted(build, step):\",\n \"def build_nested_blocks(self):\\n pass\",\n \"def less_nested_example_vanilla():\\n return\",\n \"def build(ctx: typer.Context):\\n from .tasks import build, main\\n\\n sys.argv = sys.argv[:1] + (ctx.args or [\\\"list\\\"])\\n main(vars(build))\",\n \"def build(parameters):\\n\\n\\n print(\\\"In Build module\\\")\",\n \"def actionBuild():\\n\\n #Init builder logger\\n Builder.init()\\n\\n for target in Settings.targets:\\n targetsToBuild, combineLibs, copyToOutput = Builder.getTargetGnPath(target)\\n for platform in Settings.targetPlatforms:\\n for cpu in Settings.targetCPUs:\\n if System.checkIfCPUIsSupportedForPlatform(cpu,platform):\\n for configuration in Settings.targetConfigurations:\\n if not Summary.checkIfActionFailed(ACTION_PREPARE, target, platform, cpu, configuration):\\n Logger.printStartActionMessage('Build ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration,ColoredFormatter.YELLOW)\\n result = Builder.run(target, targetsToBuild, platform, cpu, configuration, combineLibs, copyToOutput)\\n Summary.addSummary(ACTION_BUILD, target, platform, cpu, configuration, result, Builder.executionTime)\\n if result != NO_ERROR:\\n Logger.printEndActionMessage('Failed building ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration,ColoredFormatter.RED)\\n #Terminate script execution if stopExecutionOnError is set to True in userdef\\n shouldEndOnError(result)\\n else:\\n Logger.printEndActionMessage('Build ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration)\\n else:\\n Logger.printColorMessage('Build cannot run because preparation has failed for ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration,ColoredFormatter.YELLOW)\\n Logger.printEndActionMessage('Build not run for ' + target + ' ' + platform + ' ' + cpu + ' ' + configuration,ColoredFormatter.YELLOW)\",\n \"def build_root(event):\\n mode = event.parameters['mode']\\n if mode == 'from config':\\n config = event.parameters['config']\\n\\n elif mode == 'from template':\\n manager = event.workbench.get_plugin('exopy.tasks')\\n view = TemplateSelector(event.parameters.get('widget'),\\n manager=manager)\\n result = view.exec_()\\n if result:\\n path = view.path\\n config, _ = load_template(path)\\n\\n else:\\n msg = 'Invalid mode (%s) for build_root. Valid ones are : %s'\\n raise ValueError(msg % (mode, ('from config', 'from template')))\\n\\n if config:\\n build_dep = event.parameters.get('build_dep', event.workbench)\\n return build_task_from_config(config, build_dep, True)\\n\\n else:\\n raise RuntimeError('No config for building')\",\n \"def show_build_order(c, ignore=False, update=False):\\n\\n print(\\\" # Add this to invoke.yaml\\\")\\n print(\\\" build_order:\\\")\\n for p in _build_order(c, ignore=ignore, update=update):\\n print(f\\\" - {p}\\\")\\n\\n print(\\\"\\\")\",\n \"def main():\\n logging.basicConfig(\\n level=logging.DEBUG, format=\\\"%(levelname)s: %(message)s\\\")\\n root.add_command(all_)\\n root.add_command(build)\\n root.add_command(cleanup)\\n root.add_command(clitest)\\n root.add_command(run)\\n root.add_command(push)\\n root.add_command(unittest)\\n root.add_command(list_images)\\n root.add_command(list_stages)\\n root()\",\n \"def less_nested_example_rst():\\n\\n return\",\n \"def build_step(self, signals):\\n raise BuildError(\\\"OpBuilders must implement a `build_step` function\\\")\",\n \"def build(root):\",\n \"def tree(ctx):\\n hokusai.print_command_tree(ctx.find_root().command)\",\n \"def test_get_scenarios_expanded(self):\\n pass\",\n \"def test_python(width=10):\\n\\n stage_1 = [diamond(sleep=60, inputs=[0])]\\n\\n stage_2 = []\\n for i in range(0, width):\\n stage_2.extend([diamond(sleep=20, inputs=stage_1)])\\n\\n stage_3 = [diamond(sleep=30, inputs=stage_2)]\\n\\n if not stage_3[0].done():\\n time.sleep(30)\\n for sitename in dfk.executors:\\n print(dfk.executors[sitename].status())\",\n \"def ui_root1():\\n return send_build()\",\n \"def run_steps(properties, stream_engine, step_runner, universe_view,\\n engine_flags=None, emit_initial_properties=False):\\n with stream_engine.make_step_stream('setup_build') as s:\\n if emit_initial_properties:\\n for key in sorted(properties.iterkeys()):\\n s.set_build_property(key, json.dumps(properties[key], sort_keys=True))\\n\\n engine = RecipeEngine(\\n step_runner, properties, os.environ, universe_view, engine_flags)\\n\\n # Create all API modules and top level RunSteps function. It doesn't launch\\n # any recipe code yet; RunSteps needs to be called.\\n api = None\\n\\n assert 'recipe' in properties\\n recipe = properties['recipe']\\n\\n root_package = universe_view.universe.package_deps.root_package\\n run_recipe_help_lines = [\\n 'To repro this locally, run the following line from the root of a %r'\\n ' checkout:' % (root_package.name),\\n '',\\n '%s run --properties-file - %s <<EOF' % (\\n os.path.join( '.', root_package.relative_recipes_dir, 'recipes.py'),\\n recipe),\\n '%s' % json.dumps(properties),\\n 'EOF',\\n '',\\n 'To run on Windows, you can put the JSON in a file and redirect the',\\n 'contents of the file into run_recipe.py, with the < operator.',\\n ]\\n\\n with s.new_log_stream('run_recipe') as l:\\n for line in run_recipe_help_lines:\\n l.write_line(line)\\n\\n # Find and load the recipe to run.\\n try:\\n recipe_script = universe_view.load_recipe(recipe, engine=engine)\\n s.write_line('Running recipe with %s' % (properties,))\\n\\n api = loader.create_recipe_api(\\n universe_view.universe.package_deps.root_package,\\n recipe_script.LOADED_DEPS,\\n recipe_script.path,\\n engine,\\n recipe_test_api.DisabledTestData())\\n\\n s.add_step_text('running recipe: \\\"%s\\\"' % recipe)\\n except (loader.LoaderError, ImportError, AssertionError) as e:\\n for line in str(e).splitlines():\\n s.add_step_text(line)\\n s.set_step_status('EXCEPTION')\\n if engine_flags and engine_flags.use_result_proto:\\n return result_pb2.Result(\\n failure=result_pb2.Failure(\\n human_reason=str(e),\\n exception=result_pb2.Exception(\\n traceback=traceback.format_exc().splitlines()\\n )))\\n return RecipeResult({\\n 'status_code': 2,\\n 'reason': str(e),\\n })\\n\\n # The engine will use step_runner to run the steps, and the step_runner in\\n # turn uses stream_engine internally to build steam steps IO.\\n return engine.run(recipe_script, api)\",\n \"def build(ctx):\\n ctx.run(\\\"vsce package\\\", replace_env=False)\",\n \"def test_sections_json_spider_three_levels_with_summary_and_call(self):\\n title = (\\\"Taking Action for the Social and Emotional Health of \\\"\\n\\t \\\"Young Children: A Report to the Community from the Denver \\\"\\n\\t\\t \\\"Early Childhood Council\\\")\\n\\tsummary = (\\\"Now, Denver has a plan of action to make it easier for \\\"\\n\\t \\\"families to access early childhood mental health \\\"\\n\\t\\t \\\"information, intervention and services.\\\")\\n\\tcall_to_action = (\\\"Test call to action.\\\")\\n\\tbyline = \\\"Denver Early Childhood Council\\\"\\n story = create_story(title=title, summary=summary, byline=byline,\\n\\t\\t\\t call_to_action=call_to_action)\\n section1 = create_section(\\\"We're ready to take action. Are you?\\\",\\n\\t\\t\\t story=story, weight=7)\\n\\tsection2 = create_section(\\\"Ricardo's Story\\\",\\n\\t\\t\\t story=story, weight=2)\\n\\tsection3 = create_section(\\\"Meeting the need for better child mental health services\\\",\\n\\t\\t\\t story=story, root=True, weight=1)\\n\\tsection4 = create_section(\\\"Healthy Minds Support Strong Futures\\\",\\n\\t\\t\\t story=story, weight=5) \\n\\tsection5 = create_section(\\\"Community Voices\\\",\\n\\t\\t\\t story=story, weight=3)\\n\\tsection6 = create_section(\\\"Our Vision: That All Children in Denver are Valued, Healthy and Thriving\\\",\\n\\t\\t\\t story=story, weight=4)\\n\\tsection7 = create_section(\\\"Defining a \\\\\\\"Framework for Change\\\\\\\" with Actionable Goals and Strategies\\\",\\n\\t\\t\\t story=story, weight=5) \\n section8 = create_section(\\\"How Can the Plan Make a Difference?\\\",\\n\\t\\t\\t story=story, weight=5)\\n\\tsection9 = create_section(\\\"Impact\\\", story=story, weight=6)\\n SectionRelation.objects.create(parent=section6, child=section8,\\n weight=0)\\n SectionRelation.objects.create(parent=section7, child=section9,\\n weight=0)\\n SectionRelation.objects.create(parent=section6, child=section7,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section1,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section6,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section4,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section5,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section2,\\n weight=0)\\n\\tjson_sections = simplejson.loads(story.structure.sections_json(\\n\\t\\tinclude_summary=True, include_call_to_action=True))\\n\\tself.assertIn(\\n\\t section8.section_id,\\n\\t self._get_section(json_sections, section6.section_id)['children'])\\n\\tself.assertIn(\\n\\t section9.section_id,\\n\\t self._get_section(json_sections, section7.section_id)['children'])\\n\\tself.assertIn(\\n\\t section7.section_id,\\n\\t self._get_section(json_sections, section6.section_id)['children'])\\n\\tself.assertIn(\\n\\t section1.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\\n\\tself.assertIn(\\n\\t section6.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\\n\\tself.assertIn(\\n\\t section4.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\\n\\tself.assertIn(\\n\\t section5.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\\n\\tself.assertIn(\\n\\t section2.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\\n\\tself.assertEqual(json_sections[0]['section_id'], 'summary')\\n\\tself.assertEqual(json_sections[0]['next_section_id'], \\n\\t\\t\\t json_sections[1]['section_id'])\\n\\tself.assertEqual(json_sections[1]['previous_section_id'], 'summary')\\n\\tself.assertEqual(json_sections[-1]['section_id'], 'call-to-action')\\n\\tself.assertEqual(json_sections[-1]['previous_section_id'], \\n\\t\\t\\t json_sections[-2]['section_id'])\\n\\tself.assertEqual(json_sections[-2]['next_section_id'], 'call-to-action')\",\n \"def start(context, project_name):\\n\\n gcc_version = '10-2020-q4-major-'\\n os_extension = ''\\n\\n if platform.system() == 'Linux':\\n if platform.machine() == 'x86_64':\\n os_extension = 'x86_64-linux'\\n else:\\n os_extension = 'aarch64-linux'\\n elif platform.system() == 'Darwin':\\n os_extension = 'mac'\\n elif platform.system() == 'Windows':\\n os_extension = 'win32'\\n\\n final_branch_name = f'{gcc_version}{os_extension}'\\n\\n if not os_extension:\\n click.secho(f'This system {platform.system()}:{platform.machine()} ' +\\n 'is not supported for SJSU-Dev2 ', fg='red', bold=True)\\n return -1\\n\\n click.secho(f'Creating project: {project_name}', fg='white', bold=True)\\n Path(project_name).mkdir()\\n\\n click.echo(f' Creating \\\"{project_name}/.sj2\\\" directory')\\n Path(f'{project_name}/.sj2').mkdir(exist_ok=True)\\n Path(f'{project_name}/.sj2/reserved').touch(exist_ok=True)\\n\\n click.echo(f' Creating \\\"{project_name}/library\\\" directory')\\n Path(f'{project_name}/library').mkdir(exist_ok=True)\\n\\n click.echo(f' Creating \\\"{project_name}/packages\\\" directory')\\n Path(f'{project_name}/packages').mkdir(exist_ok=True)\\n\\n click.echo(f' Creating \\\"{project_name}/main.cpp\\\" source file')\\n Path(f'{project_name}/main.cpp').write_text(BASIC_MAIN_CPP)\\n\\n click.echo('')\\n\\n context.invoke(install, library='libcore', tag='main',\\n project_directory=project_name)\\n context.invoke(install, library='libarmcortex',\\n tag='main', project_directory=project_name)\\n context.invoke(install, library='liblpc40xx', tag='main',\\n project_directory=project_name)\\n context.invoke(install, library='libstm32f10x',\\n tag='main', project_directory=project_name)\\n context.invoke(install, library='gcc-arm-none-eabi-picolibc',\\n tag=final_branch_name, project_directory=project_name)\",\n \"def explore(self, board, args):\\n self.tree.explore(board, *args)\",\n \"def run_steps(stream, build_properties, factory_properties,\\n test_data=recipe_test_api.DisabledTestData()):\\n stream.honor_zero_return_code()\\n\\n # TODO(iannucci): Stop this when blamelist becomes sane data.\\n if ('blamelist_real' in build_properties and\\n 'blamelist' in build_properties):\\n build_properties['blamelist'] = build_properties['blamelist_real']\\n del build_properties['blamelist_real']\\n\\n properties = factory_properties.copy()\\n properties.update(build_properties)\\n\\n # TODO(iannucci): A much better way to do this would be to dynamically\\n # detect if the mirrors are actually available during the execution of the\\n # recipe.\\n if ('use_mirror' not in properties and (\\n 'TESTING_MASTERNAME' in os.environ or\\n 'TESTING_SLAVENAME' in os.environ)):\\n properties['use_mirror'] = False\\n\\n # It's an integration point with a new recipe engine that can run steps\\n # in parallel (that is not implemented yet). Use new engine only if explicitly\\n # asked by setting 'engine' property to 'ParallelRecipeEngine'.\\n engine = RecipeEngine.create(stream, properties, test_data)\\n\\n # Create all API modules and an instance of top level GenSteps generator.\\n # It doesn't launch any recipe code yet (generator needs to be iterated upon\\n # to start executing code).\\n api = None\\n with stream.step('setup_build') as s:\\n assert 'recipe' in factory_properties\\n recipe = factory_properties['recipe']\\n\\n properties_to_print = properties.copy()\\n if 'use_mirror' in properties:\\n del properties_to_print['use_mirror']\\n\\n run_recipe_help_lines = [\\n 'To repro this locally, run the following line from a build checkout:',\\n '',\\n './scripts/tools/run_recipe.py %s --properties-file - <<EOF' % recipe,\\n repr(properties_to_print),\\n 'EOF',\\n '',\\n 'To run on Windows, you can put the JSON in a file and redirect the',\\n 'contents of the file into run_recipe.py, with the < operator.',\\n ]\\n\\n for line in run_recipe_help_lines:\\n s.step_log_line('run_recipe', line)\\n s.step_log_end('run_recipe')\\n\\n try:\\n recipe_module = recipe_loader.load_recipe(recipe)\\n stream.emit('Running recipe with %s' % (properties,))\\n api = recipe_loader.create_recipe_api(recipe_module.DEPS,\\n engine,\\n test_data)\\n steps = recipe_module.GenSteps\\n s.step_text('<br/>running recipe: \\\"%s\\\"' % recipe)\\n except recipe_loader.NoSuchRecipe as e:\\n s.step_text('<br/>recipe not found: %s' % e)\\n s.step_failure()\\n return RecipeExecutionResult(2, None)\\n\\n # Run the steps emitted by a recipe via the engine, emitting annotations\\n # into |stream| along the way.\\n return engine.run(steps, api)\",\n \"def stage(self, stage: osbuild.Stage):\",\n \"def test_quick_build1(self):\\n pass\",\n \"def expand_tasks_with_samples( # pylint: disable=R0913,R0914\\n self,\\n dag,\\n chain_,\\n samples,\\n labels,\\n task_type,\\n adapter_config,\\n level_max_dirs,\\n):\\n LOG.debug(f\\\"expand_tasks_with_samples called with chain,{chain_}\\\\n\\\")\\n # Figure out how many directories there are, make a glob string\\n directory_sizes = uniform_directories(len(samples), bundle_size=1, level_max_dirs=level_max_dirs)\\n\\n glob_path = \\\"*/\\\" * len(directory_sizes)\\n\\n LOG.debug(\\\"creating sample_index\\\")\\n # Write a hierarchy to get the all paths string\\n sample_index = create_hierarchy(\\n len(samples),\\n bundle_size=1,\\n directory_sizes=directory_sizes,\\n root=\\\"\\\",\\n n_digits=len(str(level_max_dirs)),\\n )\\n\\n LOG.debug(\\\"creating sample_paths\\\")\\n sample_paths = sample_index.make_directory_string()\\n\\n LOG.debug(\\\"assembling steps\\\")\\n # the steps in the chain\\n steps = [dag.step(name) for name in chain_]\\n\\n # sub in globs prior to expansion\\n # sub the glob command\\n steps = [\\n step.clone_changing_workspace_and_cmd(cmd_replacement_pairs=parameter_substitutions_for_cmd(glob_path, sample_paths))\\n for step in steps\\n ]\\n\\n # workspaces = [step.get_workspace() for step in steps]\\n # LOG.debug(f\\\"workspaces : {workspaces}\\\")\\n\\n needs_expansion = is_chain_expandable(steps, labels)\\n\\n LOG.debug(f\\\"needs_expansion {needs_expansion}\\\")\\n\\n if needs_expansion:\\n # prepare_chain_workspace(sample_index, steps)\\n sample_index.name = \\\"\\\"\\n LOG.debug(\\\"queuing merlin expansion tasks\\\")\\n found_tasks = False\\n conditions = [\\n lambda c: c.is_great_grandparent_of_leaf,\\n lambda c: c.is_grandparent_of_leaf,\\n lambda c: c.is_parent_of_leaf,\\n lambda c: c.is_leaf,\\n ]\\n for condition in conditions:\\n if not found_tasks:\\n for next_index_path, next_index in sample_index.traverse(conditional=condition):\\n LOG.info(\\n f\\\"generating next step for range {next_index.min}:{next_index.max} {next_index.max-next_index.min}\\\"\\n )\\n next_index.name = next_index_path\\n\\n sig = add_merlin_expanded_chain_to_chord.s(\\n task_type,\\n steps,\\n samples[next_index.min : next_index.max],\\n labels,\\n next_index,\\n adapter_config,\\n next_index.min,\\n )\\n sig.set(queue=steps[0].get_task_queue())\\n\\n if self.request.is_eager:\\n sig.delay()\\n else:\\n LOG.info(f\\\"queuing expansion task {next_index.min}:{next_index.max}\\\")\\n self.add_to_chord(sig, lazy=False)\\n LOG.info(f\\\"merlin expansion task {next_index.min}:{next_index.max} queued\\\")\\n found_tasks = True\\n else:\\n LOG.debug(\\\"queuing simple chain task\\\")\\n add_simple_chain_to_chord(self, task_type, steps, adapter_config)\\n LOG.debug(\\\"simple chain task queued\\\")\",\n \"def run():\\n from cgl.plugins.blender.tasks.rig import parent_mdl_to_rig\\n parent_mdl_to_rig()\",\n \"def test_quick_build(self):\\n pass\",\n \"def main():\\n parser = argparse.ArgumentParser(\\n epilog=main.__doc__, formatter_class=argparse.RawDescriptionHelpFormatter\\n )\\n parser.add_argument(\\n \\\"-d\\\", \\\"--dry-run\\\", action=\\\"store_true\\\", default=0, help=\\\"Dry run mode.\\\"\\n )\\n parser.add_argument(\\n \\\"-v\\\",\\n \\\"--verbose\\\",\\n action=\\\"count\\\",\\n default=0,\\n help=\\\"Verbosity. Default is WARNING level.\\\",\\n )\\n\\n subparsers = parser.add_subparsers(help=\\\"Sub commands\\\", dest=\\\"subparser\\\")\\n subparsers.required = True\\n\\n build_parser = subparsers.add_parser(\\n \\\"build\\\",\\n description=\\\"Build an image from Dockerfile, caching image hierarchy\\\",\\n help=\\\"Build an image from a Dockerfile\\\",\\n )\\n build_parser.add_argument(\\n \\\"path\\\", metavar=\\\"PATH\\\", help=\\\"The build context directory\\\"\\n )\\n build_parser.add_argument(\\n \\\"-f\\\",\\n \\\"--file\\\",\\n help=\\\"Name of the Dockerfile. If not provided, \\\"\\n \\\"will use config.DOCKERFILE_PATH_PATTERN to compute. \\\",\\n )\\n build_parser.add_argument(\\n \\\"-v\\\",\\n \\\"--git-sha\\\",\\n required=True,\\n help=\\\"The version of code to build against, \\\" \\\"will pass as GIT_SHA variable\\\",\\n )\\n build_parser.add_argument(\\n \\\"-n\\\", \\\"--name\\\", required=True, help=\\\"The name of the image to build\\\"\\n )\\n build_parser.add_argument(\\n \\\"--build-arg\\\",\\n metavar=\\\"ARG=VALUE\\\",\\n nargs=\\\"*\\\",\\n default=[],\\n help=\\\"Set extra build-time variables. GIT_SHA, TIMESTAMP will be passed by default.\\\",\\n )\\n build_parser.add_argument(\\n \\\"-r\\\",\\n \\\"--raw\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Whether to use raw docker build command to build, skipping caching logic\\\",\\n )\\n build_parser.add_argument(\\n \\\"--registry\\\",\\n default=config.DOCKER_REGISTRY,\\n help=\\\"Docker registry use to determine the image identity, \\\"\\n \\\"can be set via IMAGE_BUILDER_DOCKER_REGISTRY environment variable, \\\"\\n 'or set DOCKER_REGISTRY in config.py. Default is \\\"%(default)s\\\"',\\n )\\n build_parser.add_argument(\\n \\\"-t\\\",\\n \\\"--tag-pattern\\\",\\n default=config.GIT_SHA_TAG_PATTERN,\\n help=\\\"Tag pattern, can only include one `{git_sha}` placeholder, \\\"\\n 'such as \\\"{git_sha}-new\\\". If the tag exists, we won\\\\'t rebuild it. '\\n 'Default is \\\"%(default)s\\\"',\\n )\\n build_parser.add_argument(\\n \\\"-e\\\",\\n \\\"--extra-tag\\\",\\n nargs=\\\"*\\\",\\n default=[],\\n help=\\\"Extra tags to tag to the final images\\\",\\n )\\n build_parser.add_argument(\\n \\\"--extra-name\\\",\\n nargs=\\\"*\\\",\\n default=[],\\n help=\\\"Extra name and optionally with a tag in the 'name:tag' format\\\",\\n )\\n build_parser.add_argument(\\n \\\"-o\\\", \\\"--output-hash\\\", help=\\\"The output filename of the files hash log.\\\"\\n )\\n build_parser.set_defaults(func=build)\\n\\n args = parser.parse_args()\\n if args.dry_run:\\n # DRY_RUN env will be read in image_builder.libs.process\\n os.environ[\\\"DRY_RUN\\\"] = \\\"1\\\"\\n\\n if args.func == build:\\n args.path = expand_path(args.path)\\n if args.output_hash:\\n args.output_hash = expand_path(args.output_hash)\\n\\n args.file = args.file or locate_dockerfile(args.name)\\n args.file = expand_path(args.file)\\n # set environ for main dockerfile for possibly retrieving later\\n os.environ[\\n config.DOCKERFILE_ENV_PATTERN.format(image_name=args.name)\\n ] = args.file\\n\\n # change CWD to PATH\\n os.chdir(args.path)\\n\\n if not args.registry:\\n parser.error(\\n \\\"--registry should be provied \\\"\\n \\\"or specified by IMAGE_BUILDER_DOCKER_REGISTRY environment variable or set DOCKER_REGISTRY in config.py\\\"\\n )\\n if not all(\\\"=\\\" in kv for kv in args.build_arg):\\n parser.error(\\\"--build_arg must be in ARG=VALUE format\\\")\\n\\n # set git_sha_tag\\n try:\\n args.git_sha_tag = args.tag_pattern.format(git_sha=args.git_sha)\\n except KeyError:\\n parser.error(\\n 'Wrong --tag-pattern provided. Can only include one `{git_sha}` placeholder, such as \\\"{git_sha}-new\\\"'\\n )\\n\\n # setup logging\\n level = logging.WARNING - args.verbose * 10\\n logging.basicConfig(\\n level=level, format=\\\"%(asctime)s %(name)s %(levelname)s %(message)s\\\"\\n )\\n\\n if args.output_hash:\\n h = logging.FileHandler(args.output_hash)\\n h.setLevel(logging.DEBUG)\\n h.setFormatter(logging.Formatter(\\\"%(message)s\\\"))\\n hash_logger.addHandler(h)\\n\\n # Suppress warning when we don't verify ssl\\n import urllib3\\n\\n urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)\\n\\n return args.func(args)\",\n \"def build(c, force=None):\\n for sp_ns in ns_foreach_task_subdir(c):\\n print(\\\"-- running build in \\\", os.getcwd())\\n\\n # sp_ns.tasks.build(c, force)\\n c.run('invoke build')\",\n \"def test_documentation_popxl_nested_session_contexts(self):\\n filename = \\\"nested_session_contexts.py\\\"\\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)\",\n \"def tfrun(args, build_modules, build_workspace, build_env):\\n\\n # loop through each selected module(s) and apply the action as specified by user\\n for m in build_modules:\\n print(\\\"\\\\n\\\\n****************************************************************************\\\")\\n print(\\\"Permforming action \\\\\\\"{0}\\\\\\\" for module {1}\\\".format(args.action, m))\\n print(\\\"****************************************************************************\\\\n\\\\n\\\")\\n run_module(args, m, build_workspace, build_env)\",\n \"def test_documentation_popxl_nested_code_loading(self):\\n filename = \\\"code_loading_nested.py\\\"\\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)\",\n \"def ninja_simulate_block():\\n return '''\\n```sh\\n# In build directory\\nninja && ./simulate\\n```'''\",\n \"def run():\\n build_no_documentation()\\n build_sphinx_build()\\n #build_sphinx_pdf()\\n build_graphviz_files()\",\n \"def buildStarted(self, name, build):\\n if self.isInterestingBuilder(name):\\n return self\",\n \"def test_build(self):\\n self.app.build()\",\n \"def step_impl(context):\\n pass\",\n \"def step_impl(context):\\n pass\",\n \"def process_steps(steplist, build, buildslave, build_status, basedir):\\n for step in steplist:\\n step.setBuild(build)\\n step.setBuildSlave(buildslave)\\n step.setStepStatus(build_status.addStepWithName(step.name))\\n step.setDefaultWorkdir(os.path.join(basedir, 'build'))\\n step.workdir = os.path.join(basedir, 'build')\",\n \"def build(_):\",\n \"def nested(*contexts):\\n with ExitStack() as stack:\\n for ctx in contexts:\\n stack.enter_context(ctx())\\n yield contexts\",\n \"def do_build(self):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\tcfg = self.cfg\\n\\t\\tself.log('PHASE: build, repository work', level=logging.DEBUG)\\n\\t\\tmodule_id_list = self.module_ids()\\n\\t\\tif self.build['deps_only']:\\n\\t\\t\\tmodule_id_list_build_only = filter(lambda x: cfg[x]['shutit.core.module.build'], module_id_list)\\n\\t\\tfor module_id in module_id_list:\\n\\t\\t\\tmodule = self.shutit_map[module_id]\\n\\t\\t\\tself.log('Considering whether to build: ' + module.module_id, level=logging.INFO)\\n\\t\\t\\tif cfg[module.module_id]['shutit.core.module.build']:\\n\\t\\t\\t\\tif self.build['delivery'] not in module.ok_delivery_methods:\\n\\t\\t\\t\\t\\tself.fail('Module: ' + module.module_id + ' can only be built with one of these --delivery methods: ' + str(module.ok_delivery_methods) + '\\\\nSee shutit build -h for more info, or try adding: --delivery <method> to your shutit invocation') # pragma: no cover\\n\\t\\t\\t\\tif self.is_installed(module):\\n\\t\\t\\t\\t\\tself.build['report'] = (self.build['report'] + '\\\\nBuilt already: ' + module.module_id + ' with run order: ' + str(module.run_order))\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# We move to the module directory to perform the build, returning immediately afterwards.\\n\\t\\t\\t\\t\\tif self.build['deps_only'] and module_id == module_id_list_build_only[-1]:\\n\\t\\t\\t\\t\\t\\t# If this is the last module, and we are only building deps, stop here.\\n\\t\\t\\t\\t\\t\\tself.build['report'] = (self.build['report'] + '\\\\nSkipping: ' + module.module_id + ' with run order: ' + str(module.run_order) + '\\\\n\\\\tas this is the final module and we are building dependencies only')\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\trevert_dir = os.getcwd()\\n\\t\\t\\t\\t\\t\\tself.get_current_shutit_pexpect_session_environment().module_root_dir = os.path.dirname(self.shutit_file_map[module_id])\\n\\t\\t\\t\\t\\t\\tself.chdir(self.get_current_shutit_pexpect_session_environment().module_root_dir)\\n\\t\\t\\t\\t\\t\\tself.login(prompt_prefix=module_id,command=shutit_global.shutit_global_object.bash_startup_command,echo=False)\\n\\t\\t\\t\\t\\t\\tself.build_module(module)\\n\\t\\t\\t\\t\\t\\tself.logout(echo=False)\\n\\t\\t\\t\\t\\t\\tself.chdir(revert_dir)\\n\\t\\t\\tif self.is_installed(module):\\n\\t\\t\\t\\tself.log('Starting module',level=logging.DEBUG)\\n\\t\\t\\t\\tif not module.start(self):\\n\\t\\t\\t\\t\\tself.fail(module.module_id + ' failed on start', shutit_pexpect_child=self.get_shutit_pexpect_session_from_id('target_child').pexpect_child) # pragma: no cover\",\n \"def test_sections_json_spider_three_levels_with_summary_and_call(self):\\n title = (\\\"Taking Action for the Social and Emotional Health of \\\"\\n \\\"Young Children: A Report to the Community from the \\\" \\n\\t\\t \\\"Denver Early Childhood Council\\\")\\n summary = (\\\"Now, Denver has a plan of action to make it easier \\\"\\n \\\"for families to access early childhood mental health \\\"\\n \\\"information, intervention and services.\\\")\\n call_to_action = (\\\"Test call to action.\\\")\\n byline = \\\"Denver Early Childhood Council\\\"\\n story = create_story(title=title, summary=summary, byline=byline,\\n\\t\\t\\t call_to_action=call_to_action)\\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\\\"Side by Side\\\")\\n section1 = create_section(\\\"We're ready to take action. Are you?\\\",\\n\\t\\t\\t story=story, layout=layout, weight=7)\\n section2 = create_section(\\\"Ricardo's Story\\\",\\n\\t\\t\\t story=story, layout=layout, weight=2)\\n section3 = create_section(\\\"Meeting the need for better child mental health services\\\",\\n\\t\\t\\t story=story, layout=layout, root=True, weight=1)\\n section4 = create_section(\\\"Healthy Minds Support Strong Futures\\\",\\n\\t\\t\\t story=story, layout=layout, weight=5) \\n section5 = create_section(\\\"Community Voices\\\",\\n\\t\\t\\t story=story, layout=layout, weight=3)\\n section6 = create_section(\\\"Our Vision: That All Children in Denver are Valued, Healthy and Thriving\\\",\\n\\t\\t\\t story=story, layout=layout, weight=4)\\n section7 = create_section(\\\"Defining a \\\\\\\"Framework for Change\\\\\\\" with Actionable Goals and Strategies\\\",\\n\\t\\t\\t story=story, layout=layout, weight=5) \\n section8 = create_section(\\\"How Can the Plan Make a Difference?\\\",\\n\\t\\t\\t story=story, layout=layout, weight=5)\\n section9 = create_section(\\\"Impact\\\", \\n story=story, layout=layout, weight=6)\\n SectionRelation.objects.create(parent=section6, child=section8,\\n weight=0)\\n SectionRelation.objects.create(parent=section7, child=section9,\\n weight=0)\\n SectionRelation.objects.create(parent=section6, child=section7,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section1,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section6,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section4,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section5,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section2,\\n weight=0)\\n json_sections = simplejson.loads(story.structure.sections_json(\\n include_summary=True, include_call_to_action=True))\\n self.assertIn(\\n section8.section_id,\\n self._get_section(json_sections, section6.section_id)['children'])\\n self.assertIn(\\n section9.section_id,\\n self._get_section(json_sections, section7.section_id)['children'])\\n self.assertIn(\\n section7.section_id,\\n self._get_section(json_sections, section6.section_id)['children'])\\n self.assertIn(\\n section1.section_id,\\n self._get_section(json_sections, section3.section_id)['children'])\\n self.assertIn(\\n section6.section_id,\\n self._get_section(json_sections, section3.section_id)['children'])\\n self.assertIn(\\n section4.section_id,\\n self._get_section(json_sections, section3.section_id)['children'])\\n self.assertIn(\\n section5.section_id,\\n self._get_section(json_sections, section3.section_id)['children'])\\n self.assertIn(\\n section2.section_id,\\n self._get_section(json_sections, section3.section_id)['children'])\\n self.assertEqual(json_sections[0]['section_id'], 'summary')\\n self.assertEqual(json_sections[0]['next_section_id'], \\n json_sections[1]['section_id'])\\n self.assertEqual(json_sections[1]['previous_section_id'], 'summary')\\n self.assertEqual(json_sections[-1]['section_id'], 'call-to-action')\\n self.assertEqual(json_sections[-1]['previous_section_id'], \\n json_sections[-2]['section_id'])\\n self.assertEqual(json_sections[-2]['next_section_id'], 'call-to-action')\",\n \"def deploy_steps(self):\\n return [ShellCommand(command=[\\\"node\\\", \\\"medic/build_\\\" + self.platform + \\\".js\\\"], workdir='build', timeout=CONFIG.build_timeout, description='Run tests', name='Run tests')]\",\n \"def build():\",\n \"def do_step(self) -> None:\",\n \"def build():\\n local('wintersmith build')\",\n \"def import_ebuilds ( self, catview, **kwargs ):\\n stats = self.STATS\\n for eview in catview:\\n self._get_package_dir ( eview.name ).import_ebuilds (\\n eview, stats=stats, **kwargs\\n )\",\n \"def stage_run(args):\\n\\n print \\\"stage_run args:\\\", args\\n if args.phase == \\\"split\\\":\\n adapters.split(args.stage, args)\\n if args.phase == \\\"main\\\":\\n adapters.main(args.stage, args)\\n if args.phase == \\\"join\\\":\\n\\n #for key in args.__dict__:\\n # if isinstance(getattr(args, key), list) and len(getattr(args, key)) == 1:\\n # setattr(args, key, getattr(args, key)[0])\\n\\n adapters.join(args.stage, args)\",\n \"def test_explant(install_test_files, data_dir):\\n with make_workdir() as workdir:\\n cl = [\\\"bcbio_nextgen.py\\\",\\n get_post_process_yaml(data_dir, workdir),\\n os.path.join(data_dir, os.pardir, \\\"1_explant\\\"),\\n os.path.join(data_dir, \\\"run_info-explant.yaml\\\")]\\n subprocess.check_call(cl)\",\n \"def ninja_block():\\n return '''\\n```sh\\n# In build directory\\nninja\\n```'''\",\n \"def run(self):\\n self.render_templates()\\n self.create_docker_context()\\n self.build()\\n self.push()\",\n \"def explore(self, *args):\",\n \"def step_by_step_instructions(element, sectionlevel=\\\"##\\\", to_markdown=safe_html_to_markdown):\\n output = \\\"\\\"\\n for step in element:\\n assert step.tag.lower() == \\\"step\\\", \\\"instructions sections can only contain steps\\\"\\n output += sectionlevel + \\\" Step\\\\n\\\"\\n output += to_markdown(step.find(\\\"description\\\"))\\n output += \\\"\\\\n\\\"\\n output += media_section(step)\\n output += \\\"\\\\n\\\\n\\\"\\n return output\",\n \"def test_BuildModel3(self):\\n print(\\\"\\\\nTest 7: Building a more complicated Model\\\")\\n builder = StaticBuilder(\\\"BreakIt\\\")\\n in1 = builder.addInput(10)\\n in2 = builder.addInput(20)\\n enc1 = builder.addInner(3)\\n enc2 = builder.addInner(5, num_islots=2)\\n out1 = builder.addOutput()\\n out2 = builder.addOutput()\\n \\n builder.addDirectedLink(in1, enc1)\\n builder.addDirectedLink(in2, enc2, islot=0)\\n builder.addDirectedLink(enc1, enc2, islot=1)\\n builder.addDirectedLink(enc1, out1)\\n builder.addDirectedLink(enc2, out2)\\n \\n builder.build()\",\n \"def rf_stepMode(self, selTree, treeDict):\\n for step in treeDict['steps']:\\n newStep = TreeNode(nodeType='step', nodeLabel=step, nodeName=step)\\n self.addTopLevelItem(newStep)\\n for node in treeDict['tree']['_order']:\\n newItem = TreeNode(**treeDict['tree'][node])\\n if len(node.split('/')) == 1:\\n newStep.addChild(newItem)\\n else:\\n rootPath = \\\"%s/%s\\\" % (step, '/'.join(node.split('/')[:-1]))\\n parent = self._getItemFromTreePath(rootPath)\\n parent.addChild(newItem)\\n if getattr(newItem, 'nodeType') == 'shotNode':\\n newItem._tree = selTree\\n newItem._step = step\\n newItem._itemPath = node\\n newItem._dataPath = os.path.join(self.pm._treePath, selTree)\\n for fld in node.split('/'):\\n newItem._dataPath = os.path.join(newItem._dataPath, fld)\\n newItem._dataPath = pFile.conformPath(newItem._dataPath)\\n newItem._ltPath = pFile.conformPath(os.path.join(newItem._dataPath, 'lt', step))\\n newItem._dataFile = \\\"%s.py\\\" % newItem._dataPath\",\n \"def run_module_structure_plan(args):\\n step = args.step\\n if step == \\\"generate_images\\\":\\n StructureGenerator = dataset_builder.ImageStructureGenerator(\\n input_directory=args.input_directory, output_directory=args.output_directory\\n )\\n StructureGenerator.run(n_jobs=args.n_jobs, starting_block=args.starting_block)\\n elif step == \\\"generate_dataset\\\":\\n DatasetGenerator = dataset_builder.DatasetGenerator(\\n input_directory=args.input_directory, output_directory=args.output_directory\\n )\\n DatasetGenerator.generate_dataset()\",\n \"def make(repo, component, clean, install, install_prefix, storage_type, with_java):\\n if clean:\\n click.secho(\\\"Cleaning previous build.\\\", fg=\\\"green\\\")\\n cmd = [\\\"make\\\", \\\"clean\\\"]\\n run_shell_cmd(cmd, repo.home)\\n return\\n click.secho(\\n \\\"Before making artifacts, please manually source ENVs from ~/.graphscope_env.\\\",\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n f\\\"Begin the make command, to build components [{component}] of GraphScope, with repo = {repo.home}\\\",\\n fg=\\\"green\\\",\\n )\\n cmd = []\\n workingdir = repo.home\\n if component == \\\"interactive\\\":\\n click.secho(\\\"Building interactive engine.\\\", fg=\\\"green\\\")\\n if storage_type == \\\"experimental\\\":\\n cmd = [\\\"make\\\", \\\"build\\\", 'QUIET_OPT=\\\"\\\"']\\n workingdir = os.path.join(repo.home, \\\"interactive_engine\\\", \\\"compiler\\\")\\n if storage_type == \\\"vineyard\\\":\\n cmd = [\\n \\\"mvn\\\",\\n \\\"install\\\",\\n \\\"-DskipTests\\\",\\n \\\"-Drust.compile.mode=release\\\",\\n \\\"-P\\\",\\n \\\"graphscope,graphscope-assembly\\\",\\n ]\\n workingdir = os.path.join(repo.home, \\\"interactive_engine\\\")\\n run_shell_cmd(cmd, workingdir)\\n cmd = [\\\"tar\\\", \\\"xvzf\\\", \\\"graphscope.tar.gz\\\"]\\n workingdir = os.path.join(\\n repo.home, \\\"interactive_engine\\\", \\\"assembly\\\", \\\"target\\\"\\n )\\n click.secho(f\\\"Begin to extract, from {workingdir}.\\\", fg=\\\"green\\\")\\n run_shell_cmd(cmd, workingdir)\\n click.secho(\\\"GraphScope interactive engine has been built.\\\", fg=\\\"green\\\")\\n if install is True:\\n cmd = [\\n \\\"make\\\",\\n \\\"interactive-install\\\",\\n \\\"INSTALL_PREFIX={}\\\".format(install_prefix),\\n ]\\n run_shell_cmd(cmd, repo.home)\\n click.secho(\\n f\\\"GraphScope interactive engine has been installed to {install_prefix}.\\\",\\n fg=\\\"green\\\",\\n )\\n\\n if component == \\\"analytical\\\":\\n cmd = [\\\"make\\\", \\\"analytical\\\"]\\n if with_java:\\n cmd = [\\\"make\\\", \\\"analytical-java\\\"]\\n run_shell_cmd(cmd, repo.home)\\n click.secho(\\\"GraphScope analytical engine has been built.\\\", fg=\\\"green\\\")\\n if install is True:\\n cmd = [\\n \\\"make\\\",\\n \\\"analytical-install\\\",\\n \\\"INSTALL_PREFIX={}\\\".format(install_prefix),\\n ]\\n run_shell_cmd(cmd, repo.home)\\n click.secho(\\n f\\\"GraphScope analytical engine has been installed to {install_prefix}.\\\",\\n fg=\\\"green\\\",\\n )\\n\\n if component == \\\"client\\\":\\n cmd = [\\\"make\\\", \\\"client\\\"]\\n run_shell_cmd(cmd, repo.home)\\n\\n if component == \\\"coordinator\\\":\\n cmd = [\\\"make\\\", \\\"coordinator\\\"]\\n run_shell_cmd(cmd, repo.home)\\n\\n if component is None:\\n click.secho(\\\"Building all components.\\\", fg=\\\"green\\\")\\n cmd = [\\\"make\\\", \\\"all\\\"]\\n if install is True:\\n cmd = [\\\"make\\\", \\\"install\\\", \\\"INSTALL_PREFIX={}\\\".format(install_prefix)]\\n run_shell_cmd(cmd, repo.home)\",\n \"def go_deeper(cls, *args, **kwargs):\\n\\t\\treturn True\",\n \"def gen_stage_loop(cls, _opts, tests, put_next_stage, _put_result_stage):\\n for test in tests:\\n put_next_stage(test)\",\n \"def execute(self):\\n if len(self._tree) > 0:\\n return self._tour(self._tree.root(),0,[]) # start the recursion\",\n \"def step(self, **kwargs):\\n pass\",\n \"def build(c, path=\\\"../..\\\", name=\\\"testapp\\\"):\\n if not os.name in [\\\"nt\\\", \\\"posix\\\"]:\\n print(\\\"Sorry. this only supports Posix (e.g. Linux, OSX) and Windows OS. \\\")\\n sys.exit()\\n\\n path=os.path.normpath(path)\\n print(\\\"Building : -n {} -p {} \\\".format(name, path))\\n if os.path.exists(os.path.join(path, name)):\\n print(\\\"sorry, path {} exists\\\".format(os.path.abspath(os.path.join(path, name))))\\n r=input(\\\" .. type y or yes, to go ahead deleting the existing: {} ? : \\\".format(os.path.join(path,name)))\\n if r in [\\\"y\\\", \\\"yes\\\"]:\\n import shutil\\n r=shutil.rmtree(os.path.join(path,name))\\n print(40*\\\"-\\\")\\n print(\\\" ..... deleted dir tree: {}\\\".format(os.path.join(path, name)))\\n print(40*\\\"-\\\")\\n build_all(c,name, path)\\n else:\\n print(40*\\\"-\\\")\\n print(\\\" ok, exiting...\\\")\\n print(40*\\\"-\\\")\\n sys.exit()\\n else:\\n # start the build and check\\n build_all(c,name, path)\",\n \"def render(self):\\n self.env.render()\\n #input(\\\"Press enter to take a step \\\")\",\n \"def build():\\n conf_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'conf'))\\n instance_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'instance'))\\n outdir = os.path.join(conf_dir, '..', '_build')\\n\\n options_file = os.path.join(instance_dir, 'site.yaml')\\n if not os.path.exists(options_file):\\n click.echo('ERROR: Could not find %s' % options_file)\\n click.echo('...a sample is located in `conf`')\\n click.echo('...copy `conf/site.yaml` to your instance folder, and modify it as needed')\\n raise click.Abort()\\n\\n options = ruamel.yaml.safe_load(open(options_file).read())\\n\\n if not os.path.isdir(outdir):\\n os.makedirs(outdir)\\n\\n env = Environment(\\n loader=FileSystemLoader(conf_dir),\\n undefined=StrictUndefined)\\n\\n ###########################################################################\\n click.echo('Creating `_build/invoicer-uwsgi.ini')\\n template = env.get_template('invoicer-uwsgi.ini.j2')\\n content = template.render(**options)\\n with open(os.path.join(outdir, 'invoicer-uwsgi.ini'), 'w') as fh:\\n fh.write(content)\\n click.echo('...done')\\n ###########################################################################\\n\\n ###########################################################################\\n click.echo('Creating `_build/invoicer-systemd.service')\\n template = env.get_template('invoicer-systemd.service.j2')\\n content = template.render(**options)\\n with open(os.path.join(outdir, 'invoicer-systemd.service'), 'w') as fh:\\n fh.write(content)\\n click.echo('...done')\\n ###########################################################################\\n\\n ###########################################################################\\n click.echo('Creating `_build/invoicer-upstream.nginx')\\n template = env.get_template('invoicer-upstream.nginx.j2')\\n content = template.render(**options)\\n with open(os.path.join(outdir, 'invoicer-upstream.nginx'), 'w') as fh:\\n fh.write(content)\\n click.echo('...done')\\n\\n click.echo('Creating `_build/invoicer-location.nginx')\\n template = env.get_template('invoicer-location.nginx.j2')\\n content = template.render(**options)\\n with open(os.path.join(outdir, 'invoicer-location.nginx'), 'w') as fh:\\n fh.write(content)\\n click.echo('...done')\\n ###########################################################################\\n\\n ###########################################################################\\n click.echo('Creating `_build/fail2ban/filter.d/invoicer.local')\\n f2b_filter_outdir = os.path.join(outdir, 'fail2ban', 'filter.d')\\n if not os.path.isdir(f2b_filter_outdir):\\n os.makedirs(f2b_filter_outdir)\\n\\n template = env.get_template('fail2ban/filter.d/invoicer.local.j2')\\n content = template.render(**options)\\n with open(os.path.join(f2b_filter_outdir, 'invoicer.local'), 'w') as fh:\\n fh.write(content)\\n click.echo('...done')\\n ###########################################################################\\n\\n ###########################################################################\\n click.echo('Creating `_build/fail2ban/jail.d/invoicer.local')\\n f2b_filter_outdir = os.path.join(outdir, 'fail2ban', 'jail.d')\\n if not os.path.isdir(f2b_filter_outdir):\\n os.makedirs(f2b_filter_outdir)\\n\\n template = env.get_template('fail2ban/jail.d/invoicer.local.j2')\\n content = template.render(**options)\\n with open(os.path.join(f2b_filter_outdir, 'invoicer.local'), 'w') as fh:\\n fh.write(content)\\n click.echo('...done')\\n ###########################################################################\\n\\n ###########################################################################\\n click.echo('Creating `_build/deploy.bash')\\n template = env.get_template('deploy.bash.j2')\\n content = template.render(**options)\\n with open(os.path.join(outdir, 'deploy.bash'), 'w') as fh:\\n fh.write(content)\\n click.echo('...done')\\n ###########################################################################\",\n \"def _close_through_level(self, level):\\n while self._step_stack and self._step_stack[-1].config.nest_level >= level:\\n cur = self._step_stack.pop()\\n if cur.step_result:\\n cur.step_result.presentation.finalize(cur.open_step.stream)\\n cur.open_step.finalize()\",\n \"def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,\\n\\tfetchonly=0, cleanup=0, dbkey=None, use_cache=1, fetchall=0, tree=None,\\n\\tmydbapi=None, vartree=None, prev_mtimes=None,\\n\\tfd_pipes=None, returnpid=False):\\n\\n\\tif settings is None:\\n\\t\\traise TypeError(\\\"settings parameter is required\\\")\\n\\tmysettings = settings\\n\\tmyroot = settings['EROOT']\\n\\n\\tif _unused is not None and _unused != mysettings['EROOT']:\\n\\t\\twarnings.warn(\\\"The third parameter of the \\\"\\n\\t\\t\\t\\\"portage.doebuild() is now unused. Use \\\"\\n\\t\\t\\t\\\"settings['ROOT'] instead.\\\",\\n\\t\\t\\tDeprecationWarning, stacklevel=2)\\n\\n\\tif not tree:\\n\\t\\twritemsg(\\\"Warning: tree not specified to doebuild\\\\n\\\")\\n\\t\\ttree = \\\"porttree\\\"\\n\\t\\n\\t# chunked out deps for each phase, so that ebuild binary can use it \\n\\t# to collapse targets down.\\n\\tactionmap_deps={\\n\\t\\\"pretend\\\" : [],\\n\\t\\\"setup\\\": [\\\"pretend\\\"],\\n\\t\\\"unpack\\\": [\\\"setup\\\"],\\n\\t\\\"prepare\\\": [\\\"unpack\\\"],\\n\\t\\\"configure\\\": [\\\"prepare\\\"],\\n\\t\\\"compile\\\":[\\\"configure\\\"],\\n\\t\\\"test\\\": [\\\"compile\\\"],\\n\\t\\\"install\\\":[\\\"test\\\"],\\n\\t\\\"rpm\\\": [\\\"install\\\"],\\n\\t\\\"package\\\":[\\\"install\\\"],\\n\\t\\\"merge\\\" :[\\\"install\\\"],\\n\\t}\\n\\t\\n\\tif mydbapi is None:\\n\\t\\tmydbapi = portage.db[myroot][tree].dbapi\\n\\n\\tif vartree is None and mydo in (\\\"merge\\\", \\\"qmerge\\\", \\\"unmerge\\\"):\\n\\t\\tvartree = portage.db[myroot][\\\"vartree\\\"]\\n\\n\\tfeatures = mysettings.features\\n\\n\\tclean_phases = (\\\"clean\\\", \\\"cleanrm\\\")\\n\\tvalidcommands = [\\\"help\\\",\\\"clean\\\",\\\"prerm\\\",\\\"postrm\\\",\\\"cleanrm\\\",\\\"preinst\\\",\\\"postinst\\\",\\n\\t \\\"config\\\", \\\"info\\\", \\\"setup\\\", \\\"depend\\\", \\\"pretend\\\",\\n\\t \\\"fetch\\\", \\\"fetchall\\\", \\\"digest\\\",\\n\\t \\\"unpack\\\", \\\"prepare\\\", \\\"configure\\\", \\\"compile\\\", \\\"test\\\",\\n\\t \\\"install\\\", \\\"rpm\\\", \\\"qmerge\\\", \\\"merge\\\",\\n\\t \\\"package\\\",\\\"unmerge\\\", \\\"manifest\\\"]\\n\\n\\tif mydo not in validcommands:\\n\\t\\tvalidcommands.sort()\\n\\t\\twritemsg(\\\"!!! doebuild: '%s' is not one of the following valid commands:\\\" % mydo,\\n\\t\\t\\tnoiselevel=-1)\\n\\t\\tfor vcount in range(len(validcommands)):\\n\\t\\t\\tif vcount%6 == 0:\\n\\t\\t\\t\\twritemsg(\\\"\\\\n!!! \\\", noiselevel=-1)\\n\\t\\t\\twritemsg(validcommands[vcount].ljust(11), noiselevel=-1)\\n\\t\\twritemsg(\\\"\\\\n\\\", noiselevel=-1)\\n\\t\\treturn 1\\n\\n\\tif returnpid and mydo != 'depend':\\n\\t\\twarnings.warn(\\\"portage.doebuild() called \\\" + \\\\\\n\\t\\t\\t\\\"with returnpid parameter enabled. This usage will \\\" + \\\\\\n\\t\\t\\t\\\"not be supported in the future.\\\",\\n\\t\\t\\tDeprecationWarning, stacklevel=2)\\n\\n\\tif mydo == \\\"fetchall\\\":\\n\\t\\tfetchall = 1\\n\\t\\tmydo = \\\"fetch\\\"\\n\\n\\tparallel_fetchonly = mydo in (\\\"fetch\\\", \\\"fetchall\\\") and \\\\\\n\\t\\t\\\"PORTAGE_PARALLEL_FETCHONLY\\\" in mysettings\\n\\n\\tif mydo not in clean_phases and not os.path.exists(myebuild):\\n\\t\\twritemsg(\\\"!!! doebuild: %s not found for %s\\\\n\\\" % (myebuild, mydo),\\n\\t\\t\\tnoiselevel=-1)\\n\\t\\treturn 1\\n\\n\\tglobal _doebuild_manifest_cache\\n\\tpkgdir = os.path.dirname(myebuild)\\n\\tmanifest_path = os.path.join(pkgdir, \\\"Manifest\\\")\\n\\tif tree == \\\"porttree\\\":\\n\\t\\trepo_config = mysettings.repositories.get_repo_for_location(\\n\\t\\t\\tos.path.dirname(os.path.dirname(pkgdir)))\\n\\telse:\\n\\t\\trepo_config = None\\n\\n\\tmf = None\\n\\tif \\\"strict\\\" in features and \\\\\\n\\t\\t\\\"digest\\\" not in features and \\\\\\n\\t\\ttree == \\\"porttree\\\" and \\\\\\n\\t\\tnot repo_config.thin_manifest and \\\\\\n\\t\\tmydo not in (\\\"digest\\\", \\\"manifest\\\", \\\"help\\\") and \\\\\\n\\t\\tnot portage._doebuild_manifest_exempt_depend and \\\\\\n\\t\\tnot (repo_config.allow_missing_manifest and not os.path.exists(manifest_path)):\\n\\t\\t# Always verify the ebuild checksums before executing it.\\n\\t\\tglobal _doebuild_broken_ebuilds\\n\\n\\t\\tif myebuild in _doebuild_broken_ebuilds:\\n\\t\\t\\treturn 1\\n\\n\\t\\t# Avoid checking the same Manifest several times in a row during a\\n\\t\\t# regen with an empty cache.\\n\\t\\tif _doebuild_manifest_cache is None or \\\\\\n\\t\\t\\t_doebuild_manifest_cache.getFullname() != manifest_path:\\n\\t\\t\\t_doebuild_manifest_cache = None\\n\\t\\t\\tif not os.path.exists(manifest_path):\\n\\t\\t\\t\\tout = portage.output.EOutput()\\n\\t\\t\\t\\tout.eerror(_(\\\"Manifest not found for '%s'\\\") % (myebuild,))\\n\\t\\t\\t\\t_doebuild_broken_ebuilds.add(myebuild)\\n\\t\\t\\t\\treturn 1\\n\\t\\t\\tmf = repo_config.load_manifest(pkgdir, mysettings[\\\"DISTDIR\\\"])\\n\\n\\t\\telse:\\n\\t\\t\\tmf = _doebuild_manifest_cache\\n\\n\\t\\ttry:\\n\\t\\t\\tmf.checkFileHashes(\\\"EBUILD\\\", os.path.basename(myebuild))\\n\\t\\texcept KeyError:\\n\\t\\t\\tif not (mf.allow_missing and\\n\\t\\t\\t\\tos.path.basename(myebuild) not in mf.fhashdict[\\\"EBUILD\\\"]):\\n\\t\\t\\t\\tout = portage.output.EOutput()\\n\\t\\t\\t\\tout.eerror(_(\\\"Missing digest for '%s'\\\") % (myebuild,))\\n\\t\\t\\t\\t_doebuild_broken_ebuilds.add(myebuild)\\n\\t\\t\\t\\treturn 1\\n\\t\\texcept FileNotFound:\\n\\t\\t\\tout = portage.output.EOutput()\\n\\t\\t\\tout.eerror(_(\\\"A file listed in the Manifest \\\"\\n\\t\\t\\t\\t\\\"could not be found: '%s'\\\") % (myebuild,))\\n\\t\\t\\t_doebuild_broken_ebuilds.add(myebuild)\\n\\t\\t\\treturn 1\\n\\t\\texcept DigestException as e:\\n\\t\\t\\tout = portage.output.EOutput()\\n\\t\\t\\tout.eerror(_(\\\"Digest verification failed:\\\"))\\n\\t\\t\\tout.eerror(\\\"%s\\\" % e.value[0])\\n\\t\\t\\tout.eerror(_(\\\"Reason: %s\\\") % e.value[1])\\n\\t\\t\\tout.eerror(_(\\\"Got: %s\\\") % e.value[2])\\n\\t\\t\\tout.eerror(_(\\\"Expected: %s\\\") % e.value[3])\\n\\t\\t\\t_doebuild_broken_ebuilds.add(myebuild)\\n\\t\\t\\treturn 1\\n\\n\\t\\tif mf.getFullname() in _doebuild_broken_manifests:\\n\\t\\t\\treturn 1\\n\\n\\t\\tif mf is not _doebuild_manifest_cache and not mf.allow_missing:\\n\\n\\t\\t\\t# Make sure that all of the ebuilds are\\n\\t\\t\\t# actually listed in the Manifest.\\n\\t\\t\\tfor f in os.listdir(pkgdir):\\n\\t\\t\\t\\tpf = None\\n\\t\\t\\t\\tif f[-7:] == '.ebuild':\\n\\t\\t\\t\\t\\tpf = f[:-7]\\n\\t\\t\\t\\tif pf is not None and not mf.hasFile(\\\"EBUILD\\\", f):\\n\\t\\t\\t\\t\\tf = os.path.join(pkgdir, f)\\n\\t\\t\\t\\t\\tif f not in _doebuild_broken_ebuilds:\\n\\t\\t\\t\\t\\t\\tout = portage.output.EOutput()\\n\\t\\t\\t\\t\\t\\tout.eerror(_(\\\"A file is not listed in the \\\"\\n\\t\\t\\t\\t\\t\\t\\t\\\"Manifest: '%s'\\\") % (f,))\\n\\t\\t\\t\\t\\t_doebuild_broken_manifests.add(manifest_path)\\n\\t\\t\\t\\t\\treturn 1\\n\\n\\t\\t# We cache it only after all above checks succeed.\\n\\t\\t_doebuild_manifest_cache = mf\\n\\n\\tlogfile=None\\n\\tbuilddir_lock = None\\n\\ttmpdir = None\\n\\ttmpdir_orig = None\\n\\n\\ttry:\\n\\t\\tif mydo in (\\\"digest\\\", \\\"manifest\\\", \\\"help\\\"):\\n\\t\\t\\t# Temporarily exempt the depend phase from manifest checks, in case\\n\\t\\t\\t# aux_get calls trigger cache generation.\\n\\t\\t\\tportage._doebuild_manifest_exempt_depend += 1\\n\\n\\t\\t# If we don't need much space and we don't need a constant location,\\n\\t\\t# we can temporarily override PORTAGE_TMPDIR with a random temp dir\\n\\t\\t# so that there's no need for locking and it can be used even if the\\n\\t\\t# user isn't in the portage group.\\n\\t\\tif mydo in (\\\"info\\\",):\\n\\t\\t\\ttmpdir = tempfile.mkdtemp()\\n\\t\\t\\ttmpdir_orig = mysettings[\\\"PORTAGE_TMPDIR\\\"]\\n\\t\\t\\tmysettings[\\\"PORTAGE_TMPDIR\\\"] = tmpdir\\n\\n\\t\\tdoebuild_environment(myebuild, mydo, myroot, mysettings, debug,\\n\\t\\t\\tuse_cache, mydbapi)\\n\\n\\t\\tif mydo in clean_phases:\\n\\t\\t\\tbuilddir_lock = None\\n\\t\\t\\tif not returnpid and \\\\\\n\\t\\t\\t\\t'PORTAGE_BUILDIR_LOCKED' not in mysettings:\\n\\t\\t\\t\\tbuilddir_lock = EbuildBuildDir(\\n\\t\\t\\t\\t\\tscheduler=EventLoop(main=False),\\n\\t\\t\\t\\t\\tsettings=mysettings)\\n\\t\\t\\t\\tbuilddir_lock.lock()\\n\\t\\t\\ttry:\\n\\t\\t\\t\\treturn _spawn_phase(mydo, mysettings,\\n\\t\\t\\t\\t\\tfd_pipes=fd_pipes, returnpid=returnpid)\\n\\t\\t\\tfinally:\\n\\t\\t\\t\\tif builddir_lock is not None:\\n\\t\\t\\t\\t\\tbuilddir_lock.unlock()\\n\\n\\t\\t# get possible slot information from the deps file\\n\\t\\tif mydo == \\\"depend\\\":\\n\\t\\t\\twritemsg(\\\"!!! DEBUG: dbkey: %s\\\\n\\\" % str(dbkey), 2)\\n\\t\\t\\tif returnpid:\\n\\t\\t\\t\\treturn _spawn_phase(mydo, mysettings,\\n\\t\\t\\t\\t\\tfd_pipes=fd_pipes, returnpid=returnpid)\\n\\t\\t\\telif isinstance(dbkey, dict):\\n\\t\\t\\t\\twarnings.warn(\\\"portage.doebuild() called \\\" + \\\\\\n\\t\\t\\t\\t\\t\\\"with dict dbkey argument. This usage will \\\" + \\\\\\n\\t\\t\\t\\t\\t\\\"not be supported in the future.\\\",\\n\\t\\t\\t\\t\\tDeprecationWarning, stacklevel=2)\\n\\t\\t\\t\\tmysettings[\\\"dbkey\\\"] = \\\"\\\"\\n\\t\\t\\t\\tpr, pw = os.pipe()\\n\\t\\t\\t\\tfd_pipes = {\\n\\t\\t\\t\\t\\t0:sys.__stdin__.fileno(),\\n\\t\\t\\t\\t\\t1:sys.__stdout__.fileno(),\\n\\t\\t\\t\\t\\t2:sys.__stderr__.fileno(),\\n\\t\\t\\t\\t\\t9:pw}\\n\\t\\t\\t\\tmypids = _spawn_phase(mydo, mysettings, returnpid=True,\\n\\t\\t\\t\\t\\tfd_pipes=fd_pipes)\\n\\t\\t\\t\\tos.close(pw) # belongs exclusively to the child process now\\n\\t\\t\\t\\tf = os.fdopen(pr, 'rb', 0)\\n\\t\\t\\t\\tfor k, v in zip(auxdbkeys,\\n\\t\\t\\t\\t\\t(_unicode_decode(line).rstrip('\\\\n') for line in f)):\\n\\t\\t\\t\\t\\tdbkey[k] = v\\n\\t\\t\\t\\tf.close()\\n\\t\\t\\t\\tretval = os.waitpid(mypids[0], 0)[1]\\n\\t\\t\\t\\tportage.process.spawned_pids.remove(mypids[0])\\n\\t\\t\\t\\t# If it got a signal, return the signal that was sent, but\\n\\t\\t\\t\\t# shift in order to distinguish it from a return value. (just\\n\\t\\t\\t\\t# like portage.process.spawn() would do).\\n\\t\\t\\t\\tif retval & 0xff:\\n\\t\\t\\t\\t\\tretval = (retval & 0xff) << 8\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# Otherwise, return its exit code.\\n\\t\\t\\t\\t\\tretval = retval >> 8\\n\\t\\t\\t\\tif retval == os.EX_OK and len(dbkey) != len(auxdbkeys):\\n\\t\\t\\t\\t\\t# Don't trust bash's returncode if the\\n\\t\\t\\t\\t\\t# number of lines is incorrect.\\n\\t\\t\\t\\t\\tretval = 1\\n\\t\\t\\t\\treturn retval\\n\\t\\t\\telif dbkey:\\n\\t\\t\\t\\tmysettings[\\\"dbkey\\\"] = dbkey\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmysettings[\\\"dbkey\\\"] = \\\\\\n\\t\\t\\t\\t\\tos.path.join(mysettings.depcachedir, \\\"aux_db_key_temp\\\")\\n\\n\\t\\t\\treturn _spawn_phase(mydo, mysettings,\\n\\t\\t\\t\\tfd_pipes=fd_pipes, returnpid=returnpid)\\n\\n\\t\\t# Validate dependency metadata here to ensure that ebuilds with invalid\\n\\t\\t# data are never installed via the ebuild command. Don't bother when\\n\\t\\t# returnpid == True since there's no need to do this every time emerge\\n\\t\\t# executes a phase.\\n\\t\\tif tree == \\\"porttree\\\":\\n\\t\\t\\trval = _validate_deps(mysettings, myroot, mydo, mydbapi)\\n\\t\\t\\tif rval != os.EX_OK:\\n\\t\\t\\t\\treturn rval\\n\\n\\t\\telse:\\n\\t\\t\\t# FEATURES=noauto only makes sense for porttree, and we don't want\\n\\t\\t\\t# it to trigger redundant sourcing of the ebuild for API consumers\\n\\t\\t\\t# that are using binary packages\\n\\t\\t\\tif \\\"noauto\\\" in mysettings.features:\\n\\t\\t\\t\\tmysettings.features.discard(\\\"noauto\\\")\\n\\n\\t\\t# The info phase is special because it uses mkdtemp so and\\n\\t\\t# user (not necessarily in the portage group) can run it.\\n\\t\\tif mydo not in ('info',) and \\\\\\n\\t\\t\\tmydo not in _doebuild_commands_without_builddir:\\n\\t\\t\\trval = _check_temp_dir(mysettings)\\n\\t\\t\\tif rval != os.EX_OK:\\n\\t\\t\\t\\treturn rval\\n\\n\\t\\tif mydo == \\\"unmerge\\\":\\n\\t\\t\\treturn unmerge(mysettings[\\\"CATEGORY\\\"],\\n\\t\\t\\t\\tmysettings[\\\"PF\\\"], myroot, mysettings, vartree=vartree)\\n\\n\\t\\tphases_to_run = set()\\n\\t\\tif \\\"noauto\\\" in mysettings.features or \\\\\\n\\t\\t\\tmydo not in actionmap_deps:\\n\\t\\t\\tphases_to_run.add(mydo)\\n\\t\\telse:\\n\\t\\t\\tphase_stack = [mydo]\\n\\t\\t\\twhile phase_stack:\\n\\t\\t\\t\\tx = phase_stack.pop()\\n\\t\\t\\t\\tif x in phases_to_run:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tphases_to_run.add(x)\\n\\t\\t\\t\\tphase_stack.extend(actionmap_deps.get(x, []))\\n\\t\\t\\tdel phase_stack\\n\\n\\t\\talist = set(mysettings.configdict[\\\"pkg\\\"].get(\\\"A\\\", \\\"\\\").split())\\n\\n\\t\\tunpacked = False\\n\\t\\tif tree != \\\"porttree\\\":\\n\\t\\t\\tpass\\n\\t\\telif \\\"unpack\\\" not in phases_to_run:\\n\\t\\t\\tunpacked = os.path.exists(os.path.join(\\n\\t\\t\\t\\tmysettings[\\\"PORTAGE_BUILDDIR\\\"], \\\".unpacked\\\"))\\n\\t\\telse:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tworkdir_st = os.stat(mysettings[\\\"WORKDIR\\\"])\\n\\t\\t\\texcept OSError:\\n\\t\\t\\t\\tpass\\n\\t\\t\\telse:\\n\\t\\t\\t\\tnewstuff = False\\n\\t\\t\\t\\tif not os.path.exists(os.path.join(\\n\\t\\t\\t\\t\\tmysettings[\\\"PORTAGE_BUILDDIR\\\"], \\\".unpacked\\\")):\\n\\t\\t\\t\\t\\twritemsg_stdout(_(\\n\\t\\t\\t\\t\\t\\t\\\">>> Not marked as unpacked; recreating WORKDIR...\\\\n\\\"))\\n\\t\\t\\t\\t\\tnewstuff = True\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tfor x in alist:\\n\\t\\t\\t\\t\\t\\twritemsg_stdout(\\\">>> Checking %s's mtime...\\\\n\\\" % x)\\n\\t\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\t\\tx_st = os.stat(os.path.join(\\n\\t\\t\\t\\t\\t\\t\\t\\tmysettings[\\\"DISTDIR\\\"], x))\\n\\t\\t\\t\\t\\t\\texcept OSError:\\n\\t\\t\\t\\t\\t\\t\\t# file not fetched yet\\n\\t\\t\\t\\t\\t\\t\\tx_st = None\\n\\n\\t\\t\\t\\t\\t\\tif x_st is None or x_st.st_mtime > workdir_st.st_mtime:\\n\\t\\t\\t\\t\\t\\t\\twritemsg_stdout(_(\\\">>> Timestamp of \\\"\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"%s has changed; recreating WORKDIR...\\\\n\\\") % x)\\n\\t\\t\\t\\t\\t\\t\\tnewstuff = True\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\tif newstuff:\\n\\t\\t\\t\\t\\tif builddir_lock is None and \\\\\\n\\t\\t\\t\\t\\t\\t'PORTAGE_BUILDIR_LOCKED' not in mysettings:\\n\\t\\t\\t\\t\\t\\tbuilddir_lock = EbuildBuildDir(\\n\\t\\t\\t\\t\\t\\t\\tscheduler=EventLoop(main=False),\\n\\t\\t\\t\\t\\t\\t\\tsettings=mysettings)\\n\\t\\t\\t\\t\\t\\tbuilddir_lock.lock()\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\t_spawn_phase(\\\"clean\\\", mysettings)\\n\\t\\t\\t\\t\\tfinally:\\n\\t\\t\\t\\t\\t\\tif builddir_lock is not None:\\n\\t\\t\\t\\t\\t\\t\\tbuilddir_lock.unlock()\\n\\t\\t\\t\\t\\t\\t\\tbuilddir_lock = None\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\twritemsg_stdout(_(\\\">>> WORKDIR is up-to-date, keeping...\\\\n\\\"))\\n\\t\\t\\t\\t\\tunpacked = True\\n\\n\\t\\t# Build directory creation isn't required for any of these.\\n\\t\\t# In the fetch phase, the directory is needed only for RESTRICT=fetch\\n\\t\\t# in order to satisfy the sane $PWD requirement (from bug #239560)\\n\\t\\t# when pkg_nofetch is spawned.\\n\\t\\thave_build_dirs = False\\n\\t\\tif not parallel_fetchonly and \\\\\\n\\t\\t\\tmydo not in ('digest', 'fetch', 'help', 'manifest'):\\n\\t\\t\\tif not returnpid and \\\\\\n\\t\\t\\t\\t'PORTAGE_BUILDIR_LOCKED' not in mysettings:\\n\\t\\t\\t\\tbuilddir_lock = EbuildBuildDir(\\n\\t\\t\\t\\t\\tscheduler=EventLoop(main=False),\\n\\t\\t\\t\\t\\tsettings=mysettings)\\n\\t\\t\\t\\tbuilddir_lock.lock()\\n\\t\\t\\tmystatus = prepare_build_dirs(myroot, mysettings, cleanup)\\n\\t\\t\\tif mystatus:\\n\\t\\t\\t\\treturn mystatus\\n\\t\\t\\thave_build_dirs = True\\n\\n\\t\\t\\t# emerge handles logging externally\\n\\t\\t\\tif not returnpid:\\n\\t\\t\\t\\t# PORTAGE_LOG_FILE is set by the\\n\\t\\t\\t\\t# above prepare_build_dirs() call.\\n\\t\\t\\t\\tlogfile = mysettings.get(\\\"PORTAGE_LOG_FILE\\\")\\n\\n\\t\\tif have_build_dirs:\\n\\t\\t\\trval = _prepare_env_file(mysettings)\\n\\t\\t\\tif rval != os.EX_OK:\\n\\t\\t\\t\\treturn rval\\n\\n\\t\\tif eapi_exports_merge_type(mysettings[\\\"EAPI\\\"]) and \\\\\\n\\t\\t\\t\\\"MERGE_TYPE\\\" not in mysettings.configdict[\\\"pkg\\\"]:\\n\\t\\t\\tif tree == \\\"porttree\\\":\\n\\t\\t\\t\\tmysettings.configdict[\\\"pkg\\\"][\\\"EMERGE_FROM\\\"] = \\\"ebuild\\\"\\n\\t\\t\\t\\tmysettings.configdict[\\\"pkg\\\"][\\\"MERGE_TYPE\\\"] = \\\"source\\\"\\n\\t\\t\\telif tree == \\\"bintree\\\":\\n\\t\\t\\t\\tmysettings.configdict[\\\"pkg\\\"][\\\"EMERGE_FROM\\\"] = \\\"binary\\\"\\n\\t\\t\\t\\tmysettings.configdict[\\\"pkg\\\"][\\\"MERGE_TYPE\\\"] = \\\"binary\\\"\\n\\n\\t\\t# NOTE: It's not possible to set REPLACED_BY_VERSION for prerm\\n\\t\\t# and postrm here, since we don't necessarily know what\\n\\t\\t# versions are being installed. This could be a problem\\n\\t\\t# for API consumers if they don't use dblink.treewalk()\\n\\t\\t# to execute prerm and postrm.\\n\\t\\tif eapi_exports_replace_vars(mysettings[\\\"EAPI\\\"]) and \\\\\\n\\t\\t\\t(mydo in (\\\"postinst\\\", \\\"preinst\\\", \\\"pretend\\\", \\\"setup\\\") or \\\\\\n\\t\\t\\t(\\\"noauto\\\" not in features and not returnpid and \\\\\\n\\t\\t\\t(mydo in actionmap_deps or mydo in (\\\"merge\\\", \\\"package\\\", \\\"qmerge\\\")))):\\n\\t\\t\\tif not vartree:\\n\\t\\t\\t\\twritemsg(\\\"Warning: vartree not given to doebuild. \\\" + \\\\\\n\\t\\t\\t\\t\\t\\\"Cannot set REPLACING_VERSIONS in pkg_{pretend,setup}\\\\n\\\")\\n\\t\\t\\telse:\\n\\t\\t\\t\\tvardb = vartree.dbapi\\n\\t\\t\\t\\tcpv = mysettings.mycpv\\n\\t\\t\\t\\tcpv_slot = \\\"%s%s%s\\\" % \\\\\\n\\t\\t\\t\\t\\t(cpv.cp, portage.dep._slot_separator, cpv.slot)\\n\\t\\t\\t\\tmysettings[\\\"REPLACING_VERSIONS\\\"] = \\\" \\\".join(\\n\\t\\t\\t\\t\\tset(portage.versions.cpv_getversion(match) \\\\\\n\\t\\t\\t\\t\\t\\tfor match in vardb.match(cpv_slot) + \\\\\\n\\t\\t\\t\\t\\t\\tvardb.match('='+cpv)))\\n\\n\\t\\t# if any of these are being called, handle them -- running them out of\\n\\t\\t# the sandbox -- and stop now.\\n\\t\\tif mydo in (\\\"config\\\", \\\"help\\\", \\\"info\\\", \\\"postinst\\\",\\n\\t\\t\\t\\\"preinst\\\", \\\"pretend\\\", \\\"postrm\\\", \\\"prerm\\\"):\\n\\t\\t\\tif mydo in (\\\"preinst\\\", \\\"postinst\\\"):\\n\\t\\t\\t\\tenv_file = os.path.join(os.path.dirname(mysettings[\\\"EBUILD\\\"]),\\n\\t\\t\\t\\t\\t\\\"environment.bz2\\\")\\n\\t\\t\\t\\tif os.path.isfile(env_file):\\n\\t\\t\\t\\t\\tmysettings[\\\"PORTAGE_UPDATE_ENV\\\"] = env_file\\n\\t\\t\\ttry:\\n\\t\\t\\t\\treturn _spawn_phase(mydo, mysettings,\\n\\t\\t\\t\\t\\tfd_pipes=fd_pipes, logfile=logfile, returnpid=returnpid)\\n\\t\\t\\tfinally:\\n\\t\\t\\t\\tmysettings.pop(\\\"PORTAGE_UPDATE_ENV\\\", None)\\n\\n\\t\\tmycpv = \\\"/\\\".join((mysettings[\\\"CATEGORY\\\"], mysettings[\\\"PF\\\"]))\\n\\n\\t\\t# Only try and fetch the files if we are going to need them ...\\n\\t\\t# otherwise, if user has FEATURES=noauto and they run `ebuild clean\\n\\t\\t# unpack compile install`, we will try and fetch 4 times :/\\n\\t\\tneed_distfiles = tree == \\\"porttree\\\" and not unpacked and \\\\\\n\\t\\t\\t(mydo in (\\\"fetch\\\", \\\"unpack\\\") or \\\\\\n\\t\\t\\tmydo not in (\\\"digest\\\", \\\"manifest\\\") and \\\"noauto\\\" not in features)\\n\\t\\tif need_distfiles:\\n\\n\\t\\t\\tsrc_uri, = mydbapi.aux_get(mysettings.mycpv,\\n\\t\\t\\t\\t[\\\"SRC_URI\\\"], mytree=os.path.dirname(os.path.dirname(\\n\\t\\t\\t\\tos.path.dirname(myebuild))))\\n\\t\\t\\tmetadata = {\\n\\t\\t\\t\\t\\\"EAPI\\\" : mysettings[\\\"EAPI\\\"],\\n\\t\\t\\t\\t\\\"SRC_URI\\\" : src_uri,\\n\\t\\t\\t}\\n\\t\\t\\tuse = frozenset(mysettings[\\\"PORTAGE_USE\\\"].split())\\n\\t\\t\\ttry:\\n\\t\\t\\t\\talist = _parse_uri_map(mysettings.mycpv, metadata, use=use)\\n\\t\\t\\t\\taalist = _parse_uri_map(mysettings.mycpv, metadata)\\n\\t\\t\\texcept InvalidDependString as e:\\n\\t\\t\\t\\twritemsg(\\\"!!! %s\\\\n\\\" % str(e), noiselevel=-1)\\n\\t\\t\\t\\twritemsg(_(\\\"!!! Invalid SRC_URI for '%s'.\\\\n\\\") % mycpv,\\n\\t\\t\\t\\t\\tnoiselevel=-1)\\n\\t\\t\\t\\tdel e\\n\\t\\t\\t\\treturn 1\\n\\n\\t\\t\\tif \\\"mirror\\\" in features or fetchall:\\n\\t\\t\\t\\tfetchme = aalist\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfetchme = alist\\n\\n\\t\\t\\tdist_digests = None\\n\\t\\t\\tif mf is not None:\\n\\t\\t\\t\\tdist_digests = mf.getTypeDigests(\\\"DIST\\\")\\n\\t\\t\\tif not fetch(fetchme, mysettings, listonly=listonly,\\n\\t\\t\\t\\tfetchonly=fetchonly, allow_missing_digests=True,\\n\\t\\t\\t\\tdigests=dist_digests):\\n\\t\\t\\t\\tspawn_nofetch(mydbapi, myebuild, settings=mysettings)\\n\\t\\t\\t\\tif listonly:\\n\\t\\t\\t\\t\\t# The convention for listonly mode is to report\\n\\t\\t\\t\\t\\t# success in any case, even though fetch() may\\n\\t\\t\\t\\t\\t# return unsuccessfully in order to trigger the\\n\\t\\t\\t\\t\\t# nofetch phase.\\n\\t\\t\\t\\t\\treturn 0\\n\\t\\t\\t\\treturn 1\\n\\n\\t\\tif need_distfiles:\\n\\t\\t\\t# Files are already checked inside fetch(),\\n\\t\\t\\t# so do not check them again.\\n\\t\\t\\tcheckme = []\\n\\t\\telif unpacked:\\n\\t\\t\\t# The unpack phase is marked as complete, so it\\n\\t\\t\\t# would be wasteful to check distfiles again.\\n\\t\\t\\tcheckme = []\\n\\t\\telse:\\n\\t\\t\\tcheckme = alist\\n\\n\\t\\tif mydo == \\\"fetch\\\" and listonly:\\n\\t\\t\\treturn 0\\n\\n\\t\\ttry:\\n\\t\\t\\tif mydo == \\\"manifest\\\":\\n\\t\\t\\t\\tmf = None\\n\\t\\t\\t\\t_doebuild_manifest_cache = None\\n\\t\\t\\t\\treturn not digestgen(mysettings=mysettings, myportdb=mydbapi)\\n\\t\\t\\telif mydo == \\\"digest\\\":\\n\\t\\t\\t\\tmf = None\\n\\t\\t\\t\\t_doebuild_manifest_cache = None\\n\\t\\t\\t\\treturn not digestgen(mysettings=mysettings, myportdb=mydbapi)\\n\\t\\t\\telif mydo != 'fetch' and \\\\\\n\\t\\t\\t\\t\\\"digest\\\" in mysettings.features:\\n\\t\\t\\t\\t# Don't do this when called by emerge or when called just\\n\\t\\t\\t\\t# for fetch (especially parallel-fetch) since it's not needed\\n\\t\\t\\t\\t# and it can interfere with parallel tasks.\\n\\t\\t\\t\\tmf = None\\n\\t\\t\\t\\t_doebuild_manifest_cache = None\\n\\t\\t\\t\\tdigestgen(mysettings=mysettings, myportdb=mydbapi)\\n\\t\\texcept PermissionDenied as e:\\n\\t\\t\\twritemsg(_(\\\"!!! Permission Denied: %s\\\\n\\\") % (e,), noiselevel=-1)\\n\\t\\t\\tif mydo in (\\\"digest\\\", \\\"manifest\\\"):\\n\\t\\t\\t\\treturn 1\\n\\n\\t\\t# See above comment about fetching only when needed\\n\\t\\tif tree == 'porttree' and \\\\\\n\\t\\t\\tnot digestcheck(checkme, mysettings, \\\"strict\\\" in features, mf=mf):\\n\\t\\t\\treturn 1\\n\\n\\t\\tif mydo == \\\"fetch\\\":\\n\\t\\t\\treturn 0\\n\\n\\t\\t# remove PORTAGE_ACTUAL_DISTDIR once cvs/svn is supported via SRC_URI\\n\\t\\tif tree == 'porttree' and \\\\\\n\\t\\t\\t((mydo != \\\"setup\\\" and \\\"noauto\\\" not in features) \\\\\\n\\t\\t\\tor mydo in (\\\"install\\\", \\\"unpack\\\")):\\n\\t\\t\\t_prepare_fake_distdir(mysettings, alist)\\n\\n\\t\\t#initial dep checks complete; time to process main commands\\n\\t\\tactionmap = _spawn_actionmap(mysettings)\\n\\n\\t\\t# merge the deps in so we have again a 'full' actionmap\\n\\t\\t# be glad when this can die.\\n\\t\\tfor x in actionmap:\\n\\t\\t\\tif len(actionmap_deps.get(x, [])):\\n\\t\\t\\t\\tactionmap[x][\\\"dep\\\"] = ' '.join(actionmap_deps[x])\\n\\n\\t\\tif mydo in actionmap:\\n\\t\\t\\tbintree = None\\n\\t\\t\\tif mydo == \\\"package\\\":\\n\\t\\t\\t\\t# Make sure the package directory exists before executing\\n\\t\\t\\t\\t# this phase. This can raise PermissionDenied if\\n\\t\\t\\t\\t# the current user doesn't have write access to $PKGDIR.\\n\\t\\t\\t\\tif hasattr(portage, 'db'):\\n\\t\\t\\t\\t\\tbintree = portage.db[mysettings['EROOT']]['bintree']\\n\\t\\t\\t\\t\\tmysettings[\\\"PORTAGE_BINPKG_TMPFILE\\\"] = \\\\\\n\\t\\t\\t\\t\\t\\tbintree.getname(mysettings.mycpv) + \\\\\\n\\t\\t\\t\\t\\t\\t\\\".%s\\\" % (os.getpid(),)\\n\\t\\t\\t\\t\\tbintree._ensure_dir(os.path.dirname(\\n\\t\\t\\t\\t\\t\\tmysettings[\\\"PORTAGE_BINPKG_TMPFILE\\\"]))\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tparent_dir = os.path.join(mysettings[\\\"PKGDIR\\\"],\\n\\t\\t\\t\\t\\t\\tmysettings[\\\"CATEGORY\\\"])\\n\\t\\t\\t\\t\\tportage.util.ensure_dirs(parent_dir)\\n\\t\\t\\t\\t\\tif not os.access(parent_dir, os.W_OK):\\n\\t\\t\\t\\t\\t\\traise PermissionDenied(\\n\\t\\t\\t\\t\\t\\t\\t\\\"access('%s', os.W_OK)\\\" % parent_dir)\\n\\t\\t\\tretval = spawnebuild(mydo,\\n\\t\\t\\t\\tactionmap, mysettings, debug, logfile=logfile,\\n\\t\\t\\t\\tfd_pipes=fd_pipes, returnpid=returnpid)\\n\\n\\t\\t\\tif retval == os.EX_OK:\\n\\t\\t\\t\\tif mydo == \\\"package\\\" and bintree is not None:\\n\\t\\t\\t\\t\\tbintree.inject(mysettings.mycpv,\\n\\t\\t\\t\\t\\t\\tfilename=mysettings[\\\"PORTAGE_BINPKG_TMPFILE\\\"])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif \\\"PORTAGE_BINPKG_TMPFILE\\\" in mysettings:\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tos.unlink(mysettings[\\\"PORTAGE_BINPKG_TMPFILE\\\"])\\n\\t\\t\\t\\t\\texcept OSError:\\n\\t\\t\\t\\t\\t\\tpass\\n\\n\\t\\telif mydo==\\\"qmerge\\\":\\n\\t\\t\\t# check to ensure install was run. this *only* pops up when users\\n\\t\\t\\t# forget it and are using ebuild\\n\\t\\t\\tif not os.path.exists(\\n\\t\\t\\t\\tos.path.join(mysettings[\\\"PORTAGE_BUILDDIR\\\"], \\\".installed\\\")):\\n\\t\\t\\t\\twritemsg(_(\\\"!!! mydo=qmerge, but the install phase has not been run\\\\n\\\"),\\n\\t\\t\\t\\t\\tnoiselevel=-1)\\n\\t\\t\\t\\treturn 1\\n\\t\\t\\t# qmerge is a special phase that implies noclean.\\n\\t\\t\\tif \\\"noclean\\\" not in mysettings.features:\\n\\t\\t\\t\\tmysettings.features.add(\\\"noclean\\\")\\n\\t\\t\\t_handle_self_update(mysettings, vartree.dbapi)\\n\\t\\t\\t#qmerge is specifically not supposed to do a runtime dep check\\n\\t\\t\\tretval = merge(\\n\\t\\t\\t\\tmysettings[\\\"CATEGORY\\\"], mysettings[\\\"PF\\\"], mysettings[\\\"D\\\"],\\n\\t\\t\\t\\tos.path.join(mysettings[\\\"PORTAGE_BUILDDIR\\\"], \\\"build-info\\\"),\\n\\t\\t\\t\\tmyroot, mysettings, myebuild=mysettings[\\\"EBUILD\\\"], mytree=tree,\\n\\t\\t\\t\\tmydbapi=mydbapi, vartree=vartree, prev_mtimes=prev_mtimes)\\n\\t\\telif mydo==\\\"merge\\\":\\n\\t\\t\\tretval = spawnebuild(\\\"install\\\", actionmap, mysettings, debug,\\n\\t\\t\\t\\talwaysdep=1, logfile=logfile, fd_pipes=fd_pipes,\\n\\t\\t\\t\\treturnpid=returnpid)\\n\\t\\t\\tif retval != os.EX_OK:\\n\\t\\t\\t\\t# The merge phase handles this already. Callers don't know how\\n\\t\\t\\t\\t# far this function got, so we have to call elog_process() here\\n\\t\\t\\t\\t# so that it's only called once.\\n\\t\\t\\t\\telog_process(mysettings.mycpv, mysettings)\\n\\t\\t\\tif retval == os.EX_OK:\\n\\t\\t\\t\\t_handle_self_update(mysettings, vartree.dbapi)\\n\\t\\t\\t\\tretval = merge(mysettings[\\\"CATEGORY\\\"], mysettings[\\\"PF\\\"],\\n\\t\\t\\t\\t\\tmysettings[\\\"D\\\"], os.path.join(mysettings[\\\"PORTAGE_BUILDDIR\\\"],\\n\\t\\t\\t\\t\\t\\\"build-info\\\"), myroot, mysettings,\\n\\t\\t\\t\\t\\tmyebuild=mysettings[\\\"EBUILD\\\"], mytree=tree, mydbapi=mydbapi,\\n\\t\\t\\t\\t\\tvartree=vartree, prev_mtimes=prev_mtimes)\\n\\t\\telse:\\n\\t\\t\\twritemsg_stdout(_(\\\"!!! Unknown mydo: %s\\\\n\\\") % mydo, noiselevel=-1)\\n\\t\\t\\treturn 1\\n\\n\\t\\treturn retval\\n\\n\\tfinally:\\n\\n\\t\\tif builddir_lock is not None:\\n\\t\\t\\tbuilddir_lock.unlock()\\n\\t\\tif tmpdir:\\n\\t\\t\\tmysettings[\\\"PORTAGE_TMPDIR\\\"] = tmpdir_orig\\n\\t\\t\\tshutil.rmtree(tmpdir)\\n\\n\\t\\tmysettings.pop(\\\"REPLACING_VERSIONS\\\", None)\\n\\n\\t\\t# Make sure that DISTDIR is restored to it's normal value before we return!\\n\\t\\tif \\\"PORTAGE_ACTUAL_DISTDIR\\\" in mysettings:\\n\\t\\t\\tmysettings[\\\"DISTDIR\\\"] = mysettings[\\\"PORTAGE_ACTUAL_DISTDIR\\\"]\\n\\t\\t\\tdel mysettings[\\\"PORTAGE_ACTUAL_DISTDIR\\\"]\\n\\n\\t\\tif logfile and not returnpid:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tif os.stat(logfile).st_size == 0:\\n\\t\\t\\t\\t\\tos.unlink(logfile)\\n\\t\\t\\texcept OSError:\\n\\t\\t\\t\\tpass\\n\\n\\t\\tif mydo in (\\\"digest\\\", \\\"manifest\\\", \\\"help\\\"):\\n\\t\\t\\t# If necessary, depend phase has been triggered by aux_get calls\\n\\t\\t\\t# and the exemption is no longer needed.\\n\\t\\t\\tportage._doebuild_manifest_exempt_depend -= 1\",\n \"def build_all(self):\\n self.android_build()\\n self.generate_patch_build('')\\n self.generate_specs_build()\\n self.generate_interfaces()\",\n \"def beginHypo( self ):\\n assert isinstance( self._env, Env )\\n assert isinstance( self._steps, list )\\n\\n if len(self._steps) == 0:\\n prevStepLevel = 0\\n else:\\n prevStepLevel = self._steps[ len(self._steps) - 1 ].level\\n\\n if self._env.level() not in ( prevStepLevel, prevStepLevel - 1 ):\\n raise Exception( 'Cannot nest more than one level in a single step.' )\\n\\n self._env = Env( self._env.level() + 1, self._env )\",\n \"def main(*, build, subdir, description, supports_modules=False,\\n supports_quick=False):\\n parser = argparse.ArgumentParser(description=description)\\n group = parser.add_mutually_exclusive_group()\\n group.add_argument(\\n \\\"--serve\\\", action='store_true',\\n help=\\\"Serve the documentation on the given PORT for easy preview.\\\")\\n group.add_argument(\\n \\\"--out_dir\\\", type=str, metavar=\\\"DIR\\\",\\n help=\\\"Generate the documentation to the given output directory.\\\"\\n \\\" The DIR must be an absolute path.\\\"\\n \\\" If DIR already exists, then it must be empty.\\\"\\n \\\" (For regression testing, the DIR can be the magic value <test>,\\\"\\n \\\" in which case a $TEST_TMPDIR subdir will be used.)\\\")\\n parser.add_argument(\\n \\\"--port\\\", type=int, metavar=\\\"PORT\\\", default=8000,\\n help=\\\"Use a non-default PORT when serving for preview.\\\")\\n parser.add_argument(\\n \\\"--verbose\\\", action=\\\"store_true\\\",\\n help=\\\"Echo detailed commands, progress, etc. to the console\\\")\\n if supports_modules:\\n parser.add_argument(\\n \\\"module\\\", nargs=\\\"*\\\",\\n help=\\\"Limit the generated documentation to only these modules and \\\"\\n \\\"their children. When none are provided, all will be generated. \\\"\\n \\\"For example, specify drake.math or drake/math for the C++ \\\"\\n \\\"module, or pydrake.math or pydrake/math for the Python module.\\\")\\n if supports_quick:\\n parser.add_argument(\\n \\\"--quick\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"Omit from the output items that are slow to generate. \\\"\\n \\\"This yields a faster preview, but the output will be incomplete.\\\")\\n args = parser.parse_args()\\n if args.verbose:\\n global _verbose\\n _verbose = True\\n curried_build = build\\n if supports_modules:\\n canonicalized_modules = [\\n x.replace('/', '.')\\n for x in args.module\\n ]\\n curried_build = functools.partial(\\n curried_build, modules=canonicalized_modules)\\n if supports_quick:\\n curried_build = functools.partial(\\n curried_build, quick=args.quick)\\n if args.out_dir is None:\\n assert args.serve\\n _do_preview(build=curried_build, subdir=subdir, port=args.port)\\n else:\\n _do_generate(build=curried_build, out_dir=args.out_dir,\\n on_error=parser.error)\",\n \"def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\\r\\n # pylint: disable=no-member\\r\\n if depth == 0:\\r\\n self.get_module.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\\r\\n else:\\r\\n self.get_module.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)\",\n \"def buildStarted(builderName, build):\",\n \"def work_in_example_project(request):\\n return chdir_in_and_out(request, LoslassaProject.EXAMPLE_PROJECT)\",\n \"def RunStages(self):\\n self._RunStage(build_stages.InitSDKStage)\\n self.RunSetupBoard()\\n self._RunStage(report_stages.RefreshPackageStatusStage)\",\n \"def main():\\n init()\\n separator_len = 40\\n for s in stage_instances:\\n print('='*separator_len)\\n print(s.name)\\n print('-'*separator_len)\\n\\n s.add_tasks() # Add tasks from previous stage\\n s.revive_or_archive() # Revive killed tasks or move them to failed\\n s.schedule_jobs() # Schedule new jobs if needed\\n s.print_status()\\n print('='*separator_len + '\\\\n')\\n render(stage_instances)\",\n \"def task_generate_tasks():\\n \\n yield {\\n 'basename': 'generate_tasks',\\n 'name': None,\\n # 'doc': 'docs for X',\\n 'watch': ['trains/'],\\n 'task_dep': ['create_folders'],\\n }\\n \\n for root, dirs, files in os.walk('trains/',topdown=False):\\n for f in files:\\n #print(f)\\n yield template_train_model(os.path.join(root,f))\",\n \"def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\\r\\n # pylint: disable=no-member\\r\\n if depth == 0:\\r\\n self.load_item.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\\r\\n else:\\r\\n self.load_item.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)\",\n \"def docker_build(c):\\n cli_tasks.docker_build.run(c)\",\n \"def test_sections_json_spider_three_levels(self):\\n\\n title = (\\\"Taking Action for the Social and Emotional Health of \\\"\\n\\t \\\"Young Children: A Report to the Community from the Denver \\\"\\n\\t\\t \\\"Early Childhood Council\\\")\\n\\tsummary = (\\\"Now, Denver has a plan of action to make it easier for \\\"\\n\\t \\\"families to access early childhood mental health \\\"\\n\\t\\t \\\"information, intervention and services.\\\")\\n\\tbyline = \\\"Denver Early Childhood Council\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n section1 = create_section(\\\"We're ready to take action. Are you?\\\",\\n\\t\\t\\t story=story, weight=7)\\n\\tsection2 = create_section(\\\"Ricardo's Story\\\",\\n\\t\\t\\t story=story, weight=2)\\n\\tsection3 = create_section(\\\"Meeting the need for better child mental health services\\\",\\n\\t\\t\\t story=story, root=True, weight=1)\\n\\tsection4 = create_section(\\\"Healthy Minds Support Strong Futures\\\",\\n\\t\\t\\t story=story, weight=5) \\n\\tsection5 = create_section(\\\"Community Voices\\\",\\n\\t\\t\\t story=story, weight=3)\\n\\tsection6 = create_section(\\\"Our Vision: That All Children in Denver are Valued, Healthy and Thriving\\\",\\n\\t\\t\\t story=story, weight=4)\\n\\tsection7 = create_section(\\\"Defining a \\\\\\\"Framework for Change\\\\\\\" with Actionable Goals and Strategies\\\",\\n\\t\\t\\t story=story, weight=5) \\n section8 = create_section(\\\"How Can the Plan Make a Difference?\\\",\\n\\t\\t\\t story=story, weight=5)\\n\\tsection9 = create_section(\\\"Impact\\\", story=story, weight=6)\\n SectionRelation.objects.create(parent=section6, child=section8,\\n weight=0)\\n SectionRelation.objects.create(parent=section7, child=section9,\\n weight=0)\\n SectionRelation.objects.create(parent=section6, child=section7,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section1,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section6,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section4,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section5,\\n weight=0)\\n SectionRelation.objects.create(parent=section3, child=section2,\\n weight=0)\\n\\tjson_sections = simplejson.loads(story.structure.sections_json(\\n\\t\\tinclude_summary=False, include_call_to_action=False))\\n\\tself.assertIn(\\n\\t section8.section_id,\\n\\t self._get_section(json_sections, section6.section_id)['children'])\\n\\tself.assertIn(\\n\\t section9.section_id,\\n\\t self._get_section(json_sections, section7.section_id)['children'])\\n\\tself.assertIn(\\n\\t section7.section_id,\\n\\t self._get_section(json_sections, section6.section_id)['children'])\\n\\tself.assertIn(\\n\\t section1.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\\n\\tself.assertIn(\\n\\t section6.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\\n\\tself.assertIn(\\n\\t section4.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\\n\\tself.assertIn(\\n\\t section5.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\\n\\tself.assertIn(\\n\\t section2.section_id,\\n\\t self._get_section(json_sections, section3.section_id)['children'])\",\n \"def main(verbose, debug, names):\\n initialize(debug)\\n\\n echome(names)\\n # click.echo(\\\"hello\\\")\\n # see\\n # https://www.brianthicks.com/post/2014/11/03/build-modular-command-line-tools-with-click/\",\n \"def generate_submissons_all_steps():\\n\\n\\n data_en = read_json_file(\\\"Test_Data/test-en.json\\\")\\n data_pr = read_json_file(\\\"Test_Data/test-pr.json\\\")\\n data_es = read_json_file(\\\"Test_Data/test-es.json\\\")\\n res_en = generate_embeddings_sentence_test_data(data_en, \\\"Test_Data/embd-en.pkl\\\")\\n res_es = generate_embeddings_sentence_test_data(data_es, \\\"Test_Data/embd-es.pkl\\\")\\n res_pr = generate_embeddings_sentence_test_data(data_pr, \\\"Test_Data/embd-pr.pkl\\\")\\n model = load_model(\\\"model_doc\\\")\\n make_submission(res_es, model, \\\"submission-es\\\")\\n make_submission(res_pr, model, \\\"submission-pr\\\")\\n make_submission(res_en, model, \\\"submission-en\\\")\\n exit()\",\n \"def cmnd_stage():\\n pass\",\n \"def test_minimalSubProjectLayout(self):\\n structure = {\\n \\\"LICENSE\\\": \\\"copyright!\\\",\\n \\\"bin\\\": {},\\n \\\"twisted\\\":\\n {\\\"web\\\": {\\\"__init__.py\\\": \\\"import WEB\\\",\\n \\\"topfiles\\\": {\\\"setup.py\\\": \\\"import WEBINSTALL\\\"}},\\n \\\"plugins\\\": {}}}\\n\\n outStructure = {\\n \\\"setup.py\\\": \\\"import WEBINSTALL\\\",\\n \\\"LICENSE\\\": \\\"copyright!\\\",\\n \\\"twisted\\\": {\\\"web\\\": {\\\"__init__.py\\\": \\\"import WEB\\\"}}}\\n\\n self.createStructure(self.rootDir, structure)\\n\\n outputFile = self.builder.buildSubProject(\\\"web\\\", \\\"0.3.0\\\")\\n\\n self.assertExtractedStructure(outputFile, outStructure)\",\n \"def test_expand_experiments():\\n template_script = get_template_script()\\n experiment_systems = utils.CombinatorialLeaf(['explicit-system', 'implicit-system', 'hydration-system'])\\n template_script['experiments']['system'] = experiment_systems\\n\\n exp_builder = ExperimentBuilder(script=template_script, job_id=1, n_jobs=2)\\n experiments = list(exp_builder._expand_experiments())\\n assert len(experiments) == 2\\n\\n exp_builder = ExperimentBuilder(script=template_script, job_id=2, n_jobs=2)\\n experiments = list(exp_builder._expand_experiments())\\n assert len(experiments) == 1\",\n \"def build(images, tag, quiet):\\n # images to build\\n build_images = None\\n\\n # list of available images\\n image_list = build_image_map().keys()\\n\\n # image specified: check if it exists\\n if images:\\n build_images = []\\n for check_name in images:\\n if check_name in image_list:\\n build_images.append(check_name)\\n continue\\n raise click.ClickException(\\n \\\"invalid image name '{}'\\\".format(check_name))\\n click.echo('building images {}'.format(', '.join(build_images)))\\n # no image specified: build all\\n else:\\n click.echo('building images {}'.format(', '.join(image_list)))\\n\\n manager = Manager('build', tag, images=build_images, verbose=not quiet)\\n manager.run()\",\n \"def nodes_run_cmd(self, group, cmd):\\n path_inventory = u'%s/inventories/%s' % (self.ansible_path, self.environment)\\n path_lib = u'%s/library/beehive/' % (self.ansible_path)\\n runner = Runner(inventory=path_inventory, verbosity=self.verbosity, \\n module=path_lib)\\n tasks = [\\n dict(action=dict(module=u'shell', args=cmd), register=u'shell_out'),\\n ]\\n runner.run_task(group, tasks=tasks, frmt=u'json')\",\n \"def walk(node, parent):\\n for name, item in node.iteritems():\\n if type(item) is dict:\\n cat = etree.SubElement(parent, 'menu', id=name, label=name)\\n walk (item, cat)\\n else:\\n menu_item = etree.SubElement(parent, 'item', label=name)\\n action = etree.SubElement(menu_item, 'action', name='execute')\\n etree.SubElement(action, 'command').text = item\",\n \"def main(\\n output,\\n elm_make,\\n mount_at,\\n exclude,\\n force_exclusion,\\n validate,\\n doit_args,\\n project_path,\\n include_paths):\\n\\n if not validate and output is None:\\n raise click.BadParameter('please specify --output directory')\\n\\n def task_build():\\n resolved_include_paths = [_resolve_path(path) for path in include_paths]\\n exclude_modules = exclude.split(',') if exclude else []\\n return create_tasks(\\n _resolve_path(project_path),\\n _resolve_path(output) if output is not None else None,\\n elm_make=_resolve_path(elm_make) if elm_make is not None else None,\\n include_paths=resolved_include_paths,\\n exclude_modules=exclude_modules,\\n force_exclusion=force_exclusion,\\n mount_point=mount_at,\\n validate=validate)\\n\\n result = DoitMain(ModuleTaskLoader(locals())).run(\\n doit_args.split(' ') if doit_args else [])\\n if result is not None and result > 0:\\n raise DoitException('', result)\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\\"Wrapper for the GROMACS make_ndx module.\\\",\\n formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, width=99999))\\n parser.add_argument('-c', '--config', required=False, help=\\\"This file can be a YAML file, JSON file or JSON string\\\")\\n\\n # Specific args of each building block\\n required_args = parser.add_argument_group('required arguments')\\n required_args.add_argument('--input_structure_path', required=True)\\n required_args.add_argument('--output_ndx_path', required=True)\\n parser.add_argument('--input_ndx_path', required=False)\\n\\n args = parser.parse_args()\\n config = args.config if args.config else None\\n properties = settings.ConfReader(config=config).get_prop_dic()\\n\\n # Specific call of each building block\\n make_ndx(input_structure_path=args.input_structure_path,\\n output_ndx_path=args.output_ndx_path,\\n input_ndx_path=args.input_ndx_path,\\n properties=properties)\",\n \"def build(self, parent):\\n raise NotImplementedError\",\n \"def build_tree(java_path, verbose):\\n logging.info(\\\"Building in %s \\\", java_path)\\n # special hack for comparing with rel/2.0.0, see HBASE-26063 for more details\\n subprocess.check_call([\\\"sed\\\", \\\"-i\\\", \\\"2148s/3.0.0/3.0.4/g\\\", \\\"pom.xml\\\"], cwd=java_path)\\n mvn_cmd = [\\\"mvn\\\", \\\"--batch-mode\\\", \\\"-DskipTests\\\",\\n \\\"-Dmaven.javadoc.skip=true\\\", \\\"package\\\"]\\n if not verbose:\\n mvn_cmd.insert(-1, \\\"--quiet\\\")\\n subprocess.check_call(mvn_cmd, cwd=java_path)\",\n \"def build (self, buildtype):\\n layout = self.xlayout()\\n\\n # NuGet removes the prefixing v from the version.\\n vless_version = self.kv['version']\\n if vless_version[0] == 'v':\\n vless_version = vless_version[1:]\\n\\n\\n self.stpath = tempfile.mkdtemp(prefix=\\\"out-\\\", suffix=\\\"-%s\\\" % buildtype,\\n dir=\\\".\\\")\\n\\n self.render('librdkafka.redist.nuspec')\\n self.copy_template('librdkafka.redist.targets',\\n destpath=os.path.join('build', 'native'))\\n self.copy_template('librdkafka.redist.props',\\n destpath=os.path.join('build', 'native'))\\n self.copy_template('librdkafka.redist.props',\\n destpath=os.path.join('build', 'net'))\\n for f in default_doc:\\n shutil.copy(f, self.stpath)\\n\\n self.extract_artifacts(layout)\\n\\n print('Tree extracted to %s' % self.stpath)\\n\\n # After creating a bare-bone nupkg layout containing the artifacts\\n # and some spec and props files, call the 'nuget' utility to\\n # make a proper nupkg of it (with all the metadata files).\\n subprocess.check_call(\\\"./nuget.sh pack %s -BasePath '%s' -NonInteractive\\\" % \\\\\\n (os.path.join(self.stpath, 'librdkafka.redist.nuspec'),\\n self.stpath), shell=True)\\n return ['librdkafka.redist.%s.nupkg' % vless_version]\",\n \"def info_build_test(self):\\n\\n self._export(\\\"H0\\\", \\\"0.1\\\")\\n\\n self._export(\\\"H1a\\\", \\\"0.1\\\", deps=[(\\\"H0/0.1@lu/st\\\", \\\"private\\\")])\\n self._export(\\\"H1b\\\", \\\"0.1\\\", deps=[\\\"H0/0.1@lu/st\\\"])\\n self._export(\\\"H1c\\\", \\\"0.1\\\", deps=[(\\\"H0/0.1@lu/st\\\", \\\"private\\\")])\\n\\n self._export(\\\"H2a\\\", \\\"0.1\\\", deps=[\\\"H1a/0.1@lu/st\\\"])\\n self._export(\\\"H2c\\\", \\\"0.1\\\", deps=[\\\"H1c/0.1@lu/st\\\"])\\n\\n self._export(\\\"H3\\\", \\\"0.1\\\", deps=[\\\"H2a/0.1@lu/st\\\",\\n \\\"H2c/0.1@lu/st\\\"])\\n\\n # If we install H3 we need to build all except H1b\\n self.clients[\\\"H3\\\"].run(\\\"info --build missing\\\")\\n self.assert_last_line(self.clients[\\\"H3\\\"],\\n \\\"H0/0.1@lu/st, H1a/0.1@lu/st, H1c/0.1@lu/st, H2a/0.1@lu/st, H2c/0.1@lu/st\\\")\\n\\n # If we install H0 we need to build nothing (current project)\\n self.clients[\\\"H0\\\"].run(\\\"info --build missing\\\")\\n self.assert_last_line(self.clients[\\\"H0\\\"], \\\"\\\")\\n\\n # If we install H0 we need to build H0\\n self.clients[\\\"H1a\\\"].run(\\\"info --build missing\\\")\\n self.assert_last_line(self.clients[\\\"H1a\\\"], \\\"H0/0.1@lu/st\\\")\\n\\n # If we build and upload H1a and H1c, no more H0 (private) is required\\n self.clients[\\\"H3\\\"].run(\\\"install H1a/0.1@lu/st --build \\\")\\n self.clients[\\\"H3\\\"].run(\\\"install H1c/0.1@lu/st --build \\\")\\n self.clients[\\\"H3\\\"].run(\\\"upload H1a/0.1@lu/st --all\\\")\\n self.clients[\\\"H3\\\"].run(\\\"upload H1c/0.1@lu/st --all\\\")\\n\\n self.clients[\\\"H3\\\"].run(\\\"remove '*' -f\\\")\\n self.clients[\\\"H3\\\"].run(\\\"info --build missing\\\")\\n self.assert_last_line(self.clients[\\\"H3\\\"],\\n \\\"H2a/0.1@lu/st, H2c/0.1@lu/st\\\")\\n\\n # But if we force to build all, all nodes have to be built\\n self.clients[\\\"H3\\\"].run(\\\"remove '*' -f\\\")\\n self.clients[\\\"H3\\\"].run(\\\"info --build\\\")\\n self.assert_last_line(self.clients[\\\"H3\\\"],\\n \\\"H0/0.1@lu/st, H1a/0.1@lu/st, H1c/0.1@lu/st, H2a/0.1@lu/st, H2c/0.1@lu/st\\\")\\n\\n # Now upgrade the recipe H1a and upload it (but not the package)\\n # so the package become outdated\\n conanfile_path = os.path.join(self.clients[\\\"H1a\\\"].current_folder, CONANFILE)\\n conanfile = load(conanfile_path)\\n conanfile += \\\"\\\\n# MODIFIED\\\"\\n save(conanfile_path, conanfile)\\n self.clients[\\\"H1a\\\"].run(\\\"export lu/st\\\")\\n self.clients[\\\"H1a\\\"].run(\\\"upload H1a/0.1@lu/st\\\") # NOW IS OUTDATED!\\n\\n # Without build outdated the built packages are the same\\n self.clients[\\\"H3\\\"].run(\\\"remove '*' -f\\\")\\n self.clients[\\\"H3\\\"].run(\\\"info --build missing\\\")\\n self.assert_last_line(self.clients[\\\"H3\\\"],\\n \\\"H2a/0.1@lu/st, H2c/0.1@lu/st\\\")\\n\\n # But with build outdated we have to build the private H0 (but only once) and H1a\\n self.clients[\\\"H3\\\"].run(\\\"remove '*' -f\\\")\\n self.clients[\\\"H3\\\"].run(\\\"info --build outdated\\\")\\n self.assert_last_line(self.clients[\\\"H3\\\"],\\n \\\"H0/0.1@lu/st, H1a/0.1@lu/st, H2a/0.1@lu/st, H2c/0.1@lu/st\\\")\",\n \"def test_workflow_parse(self):\\n\\n workflow = [{'job_template': 'sample_job1',\\n 'success': [{'job_template': 'sample_job2'}],\\n 'always': [{'job_template': 'sample_job3'}]}]\\n dry_run = True\\n extra_vars_arg = {'sample_vars': 'sample'}\\n\\n top_node = tree.generate_workflow_tree(workflow, dry_run,\\n extra_vars_arg)\\n correct = 1\\n self.assertEqual(top_node.node_id, correct)\",\n \"def build():\\n local('vagrant up')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5666077","0.5666077","0.5635756","0.5634427","0.53961426","0.5334729","0.52571476","0.52398247","0.5215903","0.5194408","0.5111144","0.51089895","0.505281","0.50474066","0.5011156","0.50028014","0.49496236","0.4938487","0.4927877","0.48954463","0.48513916","0.4836588","0.4828846","0.48177338","0.48066425","0.48060808","0.47948453","0.47854248","0.47723517","0.47621235","0.47492793","0.47461206","0.4718794","0.47087473","0.46959135","0.4693809","0.46836978","0.46699852","0.46698827","0.46633774","0.46627277","0.46625575","0.46625575","0.46585703","0.46577778","0.4656488","0.46496347","0.46431005","0.4640208","0.46368885","0.46348667","0.4634819","0.46246248","0.46164972","0.461522","0.46113774","0.4587476","0.45855147","0.4563029","0.45605755","0.455229","0.45360094","0.4533193","0.45320448","0.45311406","0.45292613","0.4524824","0.45072177","0.45034525","0.44985053","0.44955966","0.449517","0.44948965","0.44894043","0.4486887","0.44831055","0.44826013","0.44790655","0.44756812","0.44746765","0.44746503","0.44682714","0.44607314","0.44561926","0.44420224","0.44361055","0.44304103","0.442917","0.4415964","0.44140357","0.44121176","0.44096816","0.44093978","0.4407559","0.44057336","0.44052455","0.43975094","0.4396174","0.43923694","0.43823224"],"string":"[\n \"0.5666077\",\n \"0.5666077\",\n \"0.5635756\",\n \"0.5634427\",\n \"0.53961426\",\n \"0.5334729\",\n \"0.52571476\",\n \"0.52398247\",\n \"0.5215903\",\n \"0.5194408\",\n \"0.5111144\",\n \"0.51089895\",\n \"0.505281\",\n \"0.50474066\",\n \"0.5011156\",\n \"0.50028014\",\n \"0.49496236\",\n \"0.4938487\",\n \"0.4927877\",\n \"0.48954463\",\n \"0.48513916\",\n \"0.4836588\",\n \"0.4828846\",\n \"0.48177338\",\n \"0.48066425\",\n \"0.48060808\",\n \"0.47948453\",\n \"0.47854248\",\n \"0.47723517\",\n \"0.47621235\",\n \"0.47492793\",\n \"0.47461206\",\n \"0.4718794\",\n \"0.47087473\",\n \"0.46959135\",\n \"0.4693809\",\n \"0.46836978\",\n \"0.46699852\",\n \"0.46698827\",\n \"0.46633774\",\n \"0.46627277\",\n \"0.46625575\",\n \"0.46625575\",\n \"0.46585703\",\n \"0.46577778\",\n \"0.4656488\",\n \"0.46496347\",\n \"0.46431005\",\n \"0.4640208\",\n \"0.46368885\",\n \"0.46348667\",\n \"0.4634819\",\n \"0.46246248\",\n \"0.46164972\",\n \"0.461522\",\n \"0.46113774\",\n \"0.4587476\",\n \"0.45855147\",\n \"0.4563029\",\n \"0.45605755\",\n \"0.455229\",\n \"0.45360094\",\n \"0.4533193\",\n \"0.45320448\",\n \"0.45311406\",\n \"0.45292613\",\n \"0.4524824\",\n \"0.45072177\",\n \"0.45034525\",\n \"0.44985053\",\n \"0.44955966\",\n \"0.449517\",\n \"0.44948965\",\n \"0.44894043\",\n \"0.4486887\",\n \"0.44831055\",\n \"0.44826013\",\n \"0.44790655\",\n \"0.44756812\",\n \"0.44746765\",\n \"0.44746503\",\n \"0.44682714\",\n \"0.44607314\",\n \"0.44561926\",\n \"0.44420224\",\n \"0.44361055\",\n \"0.44304103\",\n \"0.442917\",\n \"0.4415964\",\n \"0.44140357\",\n \"0.44121176\",\n \"0.44096816\",\n \"0.44093978\",\n \"0.4407559\",\n \"0.44057336\",\n \"0.44052455\",\n \"0.43975094\",\n \"0.4396174\",\n \"0.43923694\",\n \"0.43823224\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5708708"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8999,"cells":{"query":{"kind":"string","value":"See recipe_api.py for docs."},"document":{"kind":"string","value":"def defer_results(self):\n return recipe_api.defer_results"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_get_recipe_information(self):\n pass","def recipe(self):\n return self.__recipe","def test_get_recipe_information_bulk(self):\n pass","def get_recipe(self, _id):\n raise NotImplementedError()","def test_get_random_recipes(self):\n pass","def test_search_recipes(self):\n pass","def recipes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Recipe]:\n pass","def test_get_recipe_ingredients_by_id(self):\n pass","def list_recipes(environ, start_response):\n return list_entities(environ, start_response, 'list_recipes')","def test_get_analyzed_recipe_instructions(self):\n pass","def test_summarize_recipe(self):\n pass","def test_search_recipes_by_ingredients(self):\n pass","def test_creating_recipe_with_ingredients(self):\n ingredient1 = sample_ingredients(user=self.user, name='Prawns')\n ingredient2 = sample_ingredients(user=self.user, name='Garlic')\n\n payload = {\n 'title': 'Avocado lime cheesecake',\n 'time_minutes': 20,\n 'price': 500.00,\n 'currency': 'NGN',\n 'ingredients': [ingredient1.id, ingredient2.id]\n }\n self.evaluate_recipe(ingredient1, ingredient2, payload, 'ingredient')","def test_create_basic_recipe(self):\n\n payload = {'name': 'Focaccia', 'description': 'Detailed description'}\n\n res = self.client.post(RECIPES_URL, payload)\n\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\n\n recipe = Recipe.objects.get(id=res.data['id'])\n\n self.assertEqual(payload['name'], recipe.name)\n self.assertEqual(payload['description'], recipe.description)","def set_recipe(self, recipe):\n self.__recipe.append(recipe)\n return 'Recipe created successfully'","def add_recipe(self, recipe): \n\t\tfor key, val in self.recipes_list.items():\n\t\t\tif key == recipe.recipe_type:\n\t\t\t\tself.recipes_list[key][recipe.name] = recipe","def sample_recipe(**params):\n defaults = {\n 'name': 'Empanadas',\n 'description': 'Test description to prepare meat empanadas!'\n }\n defaults.update(params)\n\n return Recipe.objects.create(**defaults)","def test_create_recipe_with_ingredients(self):\n\n payload = {\n 'name': 'Gnocchi',\n 'description': 'A detailed description of a yummy recipe!',\n 'ingredients': [\n {'name': 'Potatoes'},\n {'name': 'Flour'},\n {'name': 'Nutmeg'}\n ]\n }\n\n res = self.client.post(RECIPES_URL, payload, format='json')\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\n\n recipe = Recipe.objects.get(id=res.data['id'])\n\n self.assertEqual(payload['name'], recipe.name)\n self.assertEqual(payload['description'], recipe.description)\n self.assertEqual(recipe.ingredients.count(), 3)\n self.assertEqual(recipe.ingredients.first().name, 'Potatoes')","def find_recipe(self, recipe_id):\n return self.find_doc('recipe', 'name', self.get_unique_recipe_name(recipe_id))","def test_recipe(self):\n recipe = recipe_test_utils.create_recipe()\n self.job1.recipe_id = recipe.id\n self.job1.save()\n\n url = '/%s/jobs/?recipe_id=%d' % (self.api, recipe.id)\n response = self.client.generic('GET', url)\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n result = json.loads(response.content)\n self.assertEqual(len(result['results']), 1)\n self.assertEqual(result['results'][0]['id'], self.job1.id)","def __init__(self):\n self.recipeset = {}\n self.hardcoded()","def test_create_recipe_card(self):\n pass","def test_visualize_recipe_ingredients_by_id(self):\n pass","def __init__(self):\n TransformRecipes.__init__(self)","def recipe(id):\n\n selected_recipe = mongo.db.recipes.find_one({'_id': ObjectId(id)})\n\n # Using create list function to display these sections easier\n display_method = create_list(selected_recipe[\"method\"])\n display_ingredients = create_list(selected_recipe[\"ingredients\"])\n display_equipment = create_list(selected_recipe[\"equipment\"])\n\n show_ad = make_comparison(ad_equipment, display_equipment)\n\n return render_template('view_recipe.html', recipe=selected_recipe,\n title='Recipe', display_method=display_method,\n ad_equipment=ad_equipment,\n display_ingredients=display_ingredients,\n display_equipment=display_equipment,\n show_ad=show_ad)","def recipes():\n if request.method == 'GET':\n return Response(\n json.dumps(recipebook.to_json_list()),\n mimetype=\"application/json\")\n elif request.method == 'POST':\n new_dict = request.get_json()\n recipebook.recipes.append(models.Recipe.from_json_dict(new_dict))\n write_out()\n return Response(status=200)","def test_retrieve_recipes(self):\n sample_recipe(name=\"Avocado toast\")\n sample_recipe(name='Baklava')\n\n res = self.client.get(RECIPES_URL)\n\n recipes = Recipe.objects.all()\n serializer = RecipeSerializer(recipes, many=True)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(len(res.data), 2)\n self.assertEqual(res.data, serializer.data)","def new_recipe(self):\n os.system(\"clear\")\n self.name = input(\"Recipe Name: \")\n self.ingredients = None\n self.steps=None\n self.description = None\n self.tags = {}\n self.edit_ingredients()\n self.edit_steps()\n if _yes_no_select(\"Would you like to add a description?\"):\n self.description = input(\"Description: \")\n self.edit_tags()\n while not self.check():\n continue","def test_analyze_recipe_instructions(self):\n pass","def retrive_recipe(self):\n sample_recipe(user=self.user)\n sample_recipe(user=self.user)\n\n res = self.client.get(RECIPE_URL)\n\n recipe = Recipe.objects.all().order_by('-id')\n serailzer = Recipeserializer(recipe,many = True)\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data, serailzer.data)","def test_retrieving_recipes(self):\n sample_recipe(user=self.user)\n sample_recipe(user=self.user)\n\n res = self.client.get(RECIPES_URL)\n\n recipes = Recipe.objects.all().order_by('-id')\n serializer = RecipeSerializer(recipes, many=True)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data, serializer.data)","def recipe(index):\n try:\n if request.method == 'GET':\n return Response(\n json.dumps(recipebook.recipes[index].to_json_dict()),\n mimetype=\"application/json\")\n elif request.method == 'DELETE':\n del recipebook.recipes[index]\n write_out()\n return Response(status=200)\n except IndexError: # recipe with specified index does not exist\n return Response(\n \"{\\\"error\\\":\\\"no such recipe\\\"}\",\n status=404,\n mimetype=\"application/json\")","def getRecipeData(recipeId):\n return Gw2Spidy._request('recipe', str(recipeId))","def test_retrieve_recipes(self):\n sample_recipe(user = self.user)\n sample_recipe(user = self.user)\n\n res = self.client.get(RECIPE_URL)\n\n recipes = Recipe.objects.all().order_by('-id')\n serializer = RecipeSerializer(recipes, many=True) # many=true returns the data as a list\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data, serializer.data)","def test_retrieve_recipes(self):\n sample_recipe(user=self.user)\n sample_recipe(user=self.user, title=\"Beans\")\n\n res = self.client.get(RECIPE_URL)\n\n recipes = Recipe.objects.all().order_by('-id')\n serializer = RecipeSerializer(recipes, many=True)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(len(res.data), 2)\n self.assertEqual(res.data, serializer.data)","def test_creating_recipe_with_tags(self):\n tag1 = sample_tags(user=self.user, name='Vegan')\n tag2 = sample_tags(user=self.user, name='Dessert')\n\n payload = {\n 'title': 'Avocado lime cheesecake',\n 'time_minutes': 60,\n 'price': 5000.00,\n 'currency': 'NGN',\n 'tags': [tag1.id, tag2.id]\n }\n self.evaluate_recipe(tag1, tag2, payload, 'tag')","def save(self):\n self._payload_to_str()\n return self.recipe.client._perform_json(\n \"PUT\", \"/projects/%s/recipes/%s\" % (self.recipe.project_key, self.recipe.recipe_name),\n body=self.data)","def test_get_similar_recipes(self):\n pass","def create_recipe(*, recipe_in: RecipeCreate) -> dict:\n new_entry_id = len(RECIPES) + 1\n recipe_entry = Recipe(\n id=new_entry_id,\n label=recipe_in.label,\n source=recipe_in.source,\n url=recipe_in.url,\n )\n RECIPES.append(recipe_entry.dict())\n\n return recipe_entry","def test_create_new_recipe(self):\n payload = {\n 'title': 'Cheescake',\n 'time_taken': 35,\n 'price': 5\n }\n\n res = self.client.post(RECIPE_URL, payload)\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\n\n recipe = Recipe.objects.get(id=res.data['id'])\n for key in payload.keys():\n self.assertEqual((payload)[key], getattr(recipe, key))\n\n # recipe = get_sample_recipe(self.sample_user)\n # db_recipe =\n\n # self.assertEqual(recipe.title, )","def add_recipe(self, name, factory_method):\n self._recipes[name] = factory_method","def view_recipe(request, recipe, **_kwargs):\n return render(request, \"deployments/disp_recipe.html\", {\"recipe\": recipe})","def test_extract_recipe_from_website(self):\n pass","def test_get_recipe_taste_by_id(self):\n pass","def recipe(self, recipe):\n import hxl.filters\n return hxl.filters.from_recipe(self, recipe)","def test_patch_recipe(self):\n recipe = sample_recipe(self.user)\n recipe.tags.add(sample_tag(self.user))\n tag = sample_tag(self.user, name='bacon')\n\n payload = {\n 'title': 'Ham hack',\n 'tags': tag.id\n }\n res = self.client.patch(detail_url(recipe.id), payload)\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n\n recipe.refresh_from_db()\n serializer = RecipeSerializer(recipe)\n self.assertEqual(res.data, serializer.data)\n self.assertEqual(recipe.title, payload['title'])\n self.assertEqual(serializer.data['tags'], [payload['tags']])\n tags = recipe.tags.all()\n self.assertEqual(len(tags), 1)\n self.assertIn(tag, tags)","def test_create_basic_recipe(self):\n payload = {\n 'title': 'Cake',\n 'time_minutes': 40,\n 'price': 20,\n }\n res = self.client.post(RECIPE_URL, payload)\n\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\n recipe = Recipe.objects.get(id=res.data['id'])\n for key in payload:\n self.assertEqual(payload[key], getattr(recipe, key))\n serializer = RecipeDetailSerializer(recipe)\n self.assertEqual(res.data, serializer.data)","def create(self):\n self._finish_creation_settings()\n return self.project.create_recipe(self.recipe_proto, self.creation_settings)","def test_get_recipes(self):\n r1 = Recipes.objects.create(chef=self.user, name=\"Recipe 1\", draft=True)\n r2 = Recipes.objects.create(chef=self.user, name=\"Recipe 2\", draft=False)\n r3 = Recipes.objects.create(chef=self.user, name=\"Recipe 3\", draft=False)\n book = Book.objects.create(chef=self.user, book_type=Book.TO_SELL)\n book.add_recipe(r3)\n\n url = '/0/chefs/%i/recipes' % self.user.pk\n\n resp = self.client.get(url)\n self.assertPermissionDenied(resp)\n\n headers = self.login()\n resp = self.client.get(url, **headers)\n self.assertEqual(resp.status_code, 200)\n self.assertIn('recipes', resp.data)\n self.assertEqual(1, len(resp.data['recipes']))\n keys = (\"liked\", \"public_url\", \"edit_date\", \"ingredients\", \"shared\", \"tags\", \"commented\",\n \"private\", \"id\", \"chef\", \"reported\", \"nb_shares\", \"added\", \"nb_added\",\n \"nb_comments\", \"draft\", \"commensals\", \"creation_date\", \"nb_likes\", \"name\",\n \"products\", \"prep_time\", \"serves\", \"bought\", \"book_for_sale\", \"description\")\n self.assertEqual(set(keys), set(resp.data['recipes'][0].keys()))\n self.assertEqual(r2.pk, resp.data['recipes'][0]['id'])","def test_recipes_create(self):\n app = self.create_app()\n c = app.test_client()\n\n # test if authorization is required to create a recipe\n rv = c.get('/recipes/create')\n self.assertRedirects(rv, \"/auth/login\")\n\n # test recipe page\n register(c, app.config[\"USERNAME\"], app.config[\"PASSWORD\"])\n login(c, app.config[\"USERNAME\"], app.config[\"PASSWORD\"])\n c.get('/recipes/create')\n self.assert_template_used(\"recipes/create.html\")\n\n # test adding recipe\n recipe = {'author_id': \"unittest\", 'title': \"recipe_unittest2\", 'body': \"Empty body\",\n 'servings': 4, 'tag': \"dessert\", 'ingredients': [{'ingName': \"ing_unittest3_solid\", 'quantity': 180, 'portion': 'g'}, {\n 'ingName': \"ing_unittest1_liquid\", 'quantity': 2, 'portion': 'cup'}]}\n with app.app_context():\n create_recipe(c, recipe)\n self.assert_template_used(\"recipes/index.html\")","def test_retrieve_recipe(self):\n sample_recipe(user=self.user)\n sample_recipe(user=self.user)\n res = self.client.get(RECIPE_URL)\n\n recipes = Recipe.objects.all().order_by('id')\n serializer = RecipeSerializer(recipes,many=True)\n\n print(json.dumps(serializer.data, indent=1))\n print('ok')\n print(json.dumps(res.data, indent=1))\n self.assertTrue(res.status_code,status.HTTP_200_OK)\n self.assertEqual(res.data,serializer.data)","def test_full_update_recipe(self):\n recipe = sample_recipe()\n recipe.ingredients.create(name='Eggs')\n original_description = recipe.description\n\n payload = {\n 'name': 'Vegan gnocchi',\n 'ingredients': [{'name': 'Vegegg'}]\n }\n url = recipe_detail_url(recipe.id)\n self.client.put(url, payload, format='json')\n\n recipe.refresh_from_db()\n self.assertEqual(recipe.name, payload['name'])\n self.assertEqual(recipe.description, original_description)\n self.assertEqual(recipe.ingredients.count(), 1)\n self.assertTrue(recipe.ingredients.first().name, 'Eggs')","def test_get_recipe_equipment_by_id(self):\n pass","def recipe_as(self, recipe):\n prefix, suffix = self._get_jsonp()\n return prefix + JSON.recipe_as(self, recipe) + suffix","def test_get_recipe_by_id(self):\n recipe = self.request_mgr.get_recipe_by_id(35354)\n self.assertIn(\"Guinness\", recipe.get('title'))","def put(environ, start_response):\n recipe_name = web.get_route_value(environ, 'recipe_name')\n recipe_name = web.handle_extension(environ, recipe_name)\n\n recipe = Recipe(recipe_name)\n store = environ['tiddlyweb.store']\n length, _ = web.content_length_and_type(environ)\n\n usersign = environ['tiddlyweb.usersign']\n\n try:\n recipe = store.get(recipe)\n recipe.policy.allows(usersign, 'manage')\n except NoRecipeError:\n create_policy_check(environ, 'recipe', usersign)\n\n try:\n serialize_type = web.get_serialize_type(environ)[0]\n except TypeError:\n raise HTTP400('Content-type header required')\n\n try:\n serializer = Serializer(serialize_type, environ)\n serializer.object = recipe\n content = web.read_request_body(environ, length)\n serializer.from_string(content.decode('utf-8'))\n\n recipe.policy.owner = usersign['name']\n\n _validate_recipe(environ, recipe)\n store.put(recipe)\n except RecipeFormatError as exc:\n raise HTTP400('unable to put recipe: %s' % exc)\n except TypeError as exc:\n raise HTTP400('malformed input: %s' % exc)\n except NoSerializationError:\n raise HTTP415('Content type %s not supported' % serialize_type)\n\n start_response(\"204 No Content\",\n [('Location', web.recipe_url(environ, recipe))])\n\n return []","def add_recipe(self, recipe):\n self.recipe_list[recipe.recipe_type].append(recipe)\n self.last_update = datetime.now","def test_full_update_reecipe(self):\n recipe = sample_recipe(user=self.user)\n recipe.tags.add(sample_tag(user = self.user))\n payload = {\n 'title': 'mutton curry',\n 'time_minuts': 45,\n 'price':450\n\n }\n url = detail_url(recipe.id)\n self.client.put(url , payload)\n\n recipe.refresh_from_db()\n self.assertEqual(recipe.title, payload['title'])\n self.assertEqual(recipe.time_minuts, payload['time_minuts'])\n self.assertEqual(recipe.price, payload['price'])\n tags =recipe.tags.all()\n self.assertEqual(len(tags), 0 )","def post(self, user):\n data = request.json\n return save_new_recipe(data=data, user=user)","def name(self):\n return self.recipe_name","def recipe(db, recipe_factory, ingredient_factory):\n recipe = recipe_factory.create()\n db.session.add(recipe)\n db.session.commit()\n\n ingredients = ingredient_factory.create_batch(10)\n db.session.add_all(ingredients)\n db.session.commit()\n\n for i in ingredients:\n recipe_ingredient = RecipeIngredient(\n recipe_id=recipe.id,\n ingredient_id=i.id,\n )\n db.session.add(recipe_ingredient)\n recipe.ingredients.append(recipe_ingredient)\n db.session.commit()\n\n return recipe","def add_recipe(self, recipe_id, recipe_title, recipe_detail, ingredient_cuisine_doc, user_doc):\n recipe = {\n 'type': 'recipe',\n 'name': self.get_unique_recipe_name(recipe_id),\n 'title': recipe_title.strip(),\n 'instructions': recipe_detail\n }\n recipe = self.add_doc_if_not_exists(recipe, 'name')\n self.record_recipe_request_for_user(recipe, ingredient_cuisine_doc, user_doc)\n return recipe","def _ReadRecipeFromFileObject(\n self, file_object: Union[StringIO, TextIOWrapper, TextIO]) -> Recipe:\n json_dict = json.load(file_object)\n\n description = json_dict['description']\n del json_dict['description']\n\n args = []\n for arg_list in json_dict['args']:\n args.append(RecipeArgs(*arg_list))\n del json_dict['args']\n\n return resources.Recipe(description, json_dict, args)","def test_autocomplete_recipe_search(self):\n pass","def run(self, recipe_script, api):\n self._get_client('paths')._initialize_with_recipe_api(api)\n\n # TODO(martiniss): Remove this once we've transitioned to the new results\n # format\n if self._engine_flags and self._engine_flags.use_result_proto:\n logging.info(\"Using new result proto logic\")\n return self._new_run(recipe_script, api)\n return self._old_run(recipe_script, api)","def test_full_update_recipe(self):\n recipe = sample_recipe(user=self.user)\n recipe.tags.add(sample_tags(user=self.user))\n payload = {\n 'title': 'Jollof Spaghetti',\n 'time_minutes': 30,\n 'price': 5.00,\n 'currency': 'USD',\n }\n url = detail_url(recipe_id=recipe.id)\n self.client.put(url, payload)\n\n recipe.refresh_from_db()\n self.assertEqual(recipe.title, payload['title'])\n self.assertEqual(recipe.time_minutes, payload['time_minutes'])\n self.assertEqual(recipe.price, payload['price'])\n self.assertEqual(recipe.currency, payload['currency'])\n tags = recipe.tags.all()\n self.assertEqual(len(tags), 0)","def test_retrive_recipe_detail(self):\n recipe = create_sample_recipe(user=self.sample_user)\n recipe.tag.add(create_sample_tag(user=self.sample_user))\n recipe.ingredient.add(create_sample_ingredient(user=self.sample_user))\n\n detail_URL = get_detail_URL(recipe.id)\n res = self.client.get(detail_URL)\n\n serializer = RecipeDetailSerializer(recipe)\n\n self.assertEqual(res.data, serializer.data)","def test_full_update_recipe(self):\n recipe = sample_recipe(user=self.user)\n recipe.tag.add(sample_tag(user=self.user))\n payload = {\n 'title':'chicken noodles',\n 'time_minutes':50,\n 'price':12.67,\n }\n url = detail_url(recipe.id)\n self.client.put(url,payload)\n\n recipe.refresh_from_db()\n self.assertEqual(recipe.title,payload['title'])\n self.assertEqual(recipe.time_minutes,payload['time_minutes'])\n self.assertEqual(float(recipe.price),payload['price'])\n tags = recipe.tag.all()\n self.assertEqual(len(tags),0)\n self.assertEqual(recipe.user,self.user)","def __init__(self, recipes=ALLRECIPES_DICT, search_ingredients=SEARCH_INGREDIENTS):\n self.recipes = json.loads(open(recipes).read())\n for (k, v) in json.loads(open(IDEORECIPES_DICT).read()).items():\n self.recipes[k] = v\n self.search_ingredients = [v.strip().lower() for v in open(search_ingredients)]\n self.food_hash = {}\n self.adj = None\n self.sortby_methods = [\"relevance\", \"popular\", \"rating\"]\n self.to_skips = [\"sugar\", \"salt\", \"milk\", \"pepper\", \"butter\"]","def sample_recipe(user, **kwargs):\n defaults = {\n 'title': 'Sample recipe',\n 'time_minutes': 15,\n 'price': 500.00,\n 'currency': 'NGN',\n }\n defaults.update(kwargs)\n return Recipe.objects.create(user=user, **defaults)","def _determine_recipe(environ):\n recipe_name = web.get_route_value(environ, 'recipe_name')\n recipe_name = web.handle_extension(environ, recipe_name)\n recipe = Recipe(recipe_name)\n\n store = environ['tiddlyweb.store']\n\n try:\n recipe = store.get(recipe)\n except NoRecipeError as exc:\n raise HTTP404('%s not found, %s' % (recipe.name, exc))\n\n return recipe","def test_full_update_recipe(self):\n recipe = sample_recipe(user=self.user)\n recipe.tags.add(sample_tag(user=self.user))\n payload = {\n 'title': 'Spaghetti',\n 'time_minutes': 25,\n 'price': 5.00,\n }\n url = detail_url(recipe.id)\n self.client.put(url, payload)\n\n recipe.refresh_from_db()\n self.assertEqual(recipe.title, payload['title'])\n self.assertEqual(recipe.time_minutes, payload['time_minutes'])\n self.assertEqual(recipe.price, payload['price'])\n tags = recipe.tags.all()\n self.assertEqual(len(tags), 0)","def test_create_basic_recipe(self):\n payload = {\"title\": \"Vietnamese Cake\",\n \"time_minutes\": 45,\n \"price\": 5.55}\n res = self.client.post(RECIPE_URL, payload)\n recipe = Recipe.objects.get(id=res.data['id'])\n for key in payload.keys():\n if key == \"price\":\n self.assertEqual(round(Decimal(payload[key]), 2), getattr(recipe, key))\n else:\n self.assertEqual(payload[key], getattr(recipe, key))\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)","def save_recipe(self, recipe):\n\n if self.photo.data:\n recipe.photo = photos.save(self.photo.data.stream)\n\n recipe.title = self.title.data\n recipe.title_slug = slugify(self.title.data)\n recipe.description = self.description.data\n recipe.instructions = self.instructions.data\n recipe.general_ingredients = [\n i.to_model() for i in self.general_ingredients]\n recipe.ingredient_groups = [\n g.to_model() for g in self.ingredient_groups]\n recipe.tags = self.tags.data\n\n recipe.save()","def _validate_recipe(environ, recipe):\n try:\n validate_recipe(recipe, environ)\n except InvalidBagError as exc:\n raise HTTP409('Recipe content is invalid: %s' % exc)","def test_view_recipe_details(self):\n recipe = sample_recipe(user=self.user)\n recipe.tags.add(sample_tag(user=self.user))\n recipe.ingredient.add(sample_ingredient(user=self.user))\n\n url = detail_url(recipe.id)\n res = self.client.get(url)\n\n serailzer = RecipeDetailSerializer(recipe)\n self.assertEqual(res.data, serailzer.data)","def recipe_id(self, recipe_id):\n\n self._recipe_id = recipe_id","def test_retrieve_recipes(self):\n sample_quizz()\n sample_quizz()\n\n res = self.client.get(QUIZZES_URL)\n\n quizzes = Quizz.objects.all()\n serializer = QuizzSerializer(quizzes, many=True)\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data, serializer.data)","def test_recipe_model(self):\n recipe = Recipe(uri=\"testuri\", name=\"testname\", image_url=\"test_image_url\")\n\n db.session.add(recipe)\n db.session.commit()\n\n recipes = Recipe.query.all()\n\n self.assertEqual(len(recipes), 1)\n self.assertEqual(recipes[0].uri, \"testuri\")\n self.assertEqual(recipes[0].name, \"testname\")\n self.assertEqual(recipes[0].image_url, \"test_image_url\")","def _create_ingredient(self, data):\n return Ingredient(**data)","def search_recipe(ingredients):\n\n params = '+'.join(ingredients.split())\n url_search = SEARCH_URL.format(params)\n response = req.get(url_search)\n\n return response.content","def test_create_recipe_with_ingredients(self):\n ingredient1 = sample_ingredient(user=self.user, name = 'bla')\n ingredient2 = sample_ingredient(user=self.user, name = 'blaa')\n payload = {\n 'title': 'red curry',\n 'ingredients': [ingredient1.id, ingredient2.id],\n 'time_minutes': 30,\n 'price': 30.00\n }\n res = self.client.post(RECIPE_URL, payload)\n\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\n recipe = Recipe.objects.get(id=res.data['id'])\n ingredients = recipe.ingredients.all()\n\n self.assertEqual(ingredients.count(), 2)\n self.assertIn(ingredient1, ingredients)\n self.assertIn(ingredient2, ingredients)","def get_product_ingredients(self, driver):\n pass","def test_put_recipe(self):\n recipe = sample_recipe(self.user)\n recipe.tags.add(sample_tag(self.user))\n payload = {\n 'title': 'Ham hack',\n 'time_minutes': 38,\n 'price': 33.00\n }\n res = self.client.put(detail_url(recipe.id), payload)\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n\n recipe.refresh_from_db()\n serializer = RecipeSerializer(recipe)\n self.assertEqual(res.data, serializer.data)\n self.assertEqual(recipe.title, payload['title'])\n tags = recipe.tags.all()\n self.assertEqual(len(tags), 0)","def sample_recipe(user, **params):\n defaults = {\n 'title': 'bread',\n 'time_minutes': 50,\n 'price': 5.00\n }\n defaults.update(params)\n\n return Recipe.objects.create(user=user, **defaults)","def get_recipe(cls, recipeid):\n\n recipe = Recipe.query.filter_by(recipe_id=recipeid).one()\n\n return recipe","def test_creating_recipe_with_ingredients(self):\n ingredient1 = create_sample_ingredient(user=self.user, name=\"Paprika\")\n ingredient2 = create_sample_ingredient(user=self.user, name=\"Salad\")\n\n payload = {\n \"title\": \"Green Salad\",\n \"time_minutes\": 34,\n \"price\": 4.66,\n \"ingredients\": [ingredient1.id, ingredient2.id]\n }\n res = self.client.post(RECIPE_URL, payload)\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\n recipe = Recipe.objects.get(id=res.data['id'])\n ingredients = recipe.ingredients.all()\n self.assertEqual(ingredients.count(), 2)\n self.assertIn(ingredient1, ingredients)\n self.assertIn(ingredient2, ingredients)","def __init__(self, recipe_url):\n self.recipe_url = recipe_url\n self.translator = TranslationClient()","def get_recipe_raw_definition(self):\n return self.recipe_settings","def recipe(self, name_parts: ResourceIdentifier, type_in: Optional[str], data_in: JsonObject, group: Optional[str] = None, conditions: Json = None) -> RecipeContext:\n res = utils.resource_location(self.domain, name_parts)\n self.write((*self.resource_dir, 'data', res.domain, 'recipes', res.path), {\n 'type': type_in,\n 'group': group,\n **data_in,\n 'conditions': utils.recipe_condition(conditions)\n })\n return RecipeContext(self, res)","def test_create_recipe_with_ingredient(self):\n ingredient1 = sample_ingredient(user=self.user, name='Prawns')\n ingrident2 = sample_ingredient(user=self.user, name ='Ginger')\n\n payload = {\n 'title': 'Thai prawn and curry',\n 'ingredient': [ingredient1.id,ingrident2.id],\n 'time_minuts':60,\n 'price': 250\n }\n res = self.client.post(RECIPE_URL,payload)\n\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\n\n recipe = Recipe.objects.get(id=res.data['id'])\n ingredients = recipe.ingredient.all()\n self.assertEqual(ingredients.count(),2)\n self.assertIn(ingredient1, ingredients)\n self.assertIn(ingrident2,ingredients)","def test_search_recipes_by_nutrients(self):\n pass","def test_recipes_limited_to_user(self):\n user2 = get_user_model().objects.create_user(\n email = 'test2@gmail.com',\n password = '123465',\n )\n sample_recipe(user = user2)\n sample_recipe(user = self.user)\n\n res = self.client.get(RECIPE_URL)\n\n recipes = Recipe.objects.filter(user=self.user)\n serializer = RecipeSerializer(recipes, many=True) # although we only have one recipe for this user, we still pass many=true since even if there is one object returned, the list api should always return a data type of list\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(len(res.data), 1)\n self.assertEqual(res.data, serializer.data)","def get(id: int):\r\n filename = Path(__file__).parent / \"recipe-data.csv\"\r\n files = import_file.Files()\r\n recipe_load = files.import_from_csv(filename)\r\n\r\n recipes = Recipes(recipe_load)\r\n a_recipe = recipes.filter_recipes_id(id)\r\n\r\n return jsonify(a_recipe)","def test_create_recipe_with_ingredients(self):\n ing1 = sample_ingredient(user=self.user,name=\"ginger\")\n ing2 = sample_ingredient(user=self.user, name=\"Prawn\")\n payload = {\n 'title':'Prawn curry',\n 'ingredient':[ing1.id,ing2.id],\n 'time_minutes':60,\n 'price':10.00,\n }\n res = self.client.post(RECIPE_URL,payload)\n self.assertEqual(res.status_code,status.HTTP_201_CREATED)\n recipe = Recipe.objects.get(id=res.data['id'])\n ingredients = recipe.ingredient.all()\n self.assertEqual(ingredients.count(),2)\n self.assertIn(ing1,ingredients)\n self.assertIn(ing2,ingredients)","def sample_recipe(user,**params):\n default = {\n 'title' : 'sample title',\n 'time_minutes' : 10,\n 'price' : 5.00,\n }\n default.update(params)\n return Recipe.objects.create(user=user,**default)","def recipes():\n recipes = mongo.db.recipes.find()\n return render_template(\"recipes.html\", recipes=recipes)","def single_recipe_controller(filters, db_conn, host_url):\n try:\n result = db_conn[\"recipes\"].find(filters).sort(\"createdOn\", -1)\n recipe_list = map_response(result, host_url)\n return recipe_list\n\n except Exception as e:\n print(e)\n return {\"success\": False, \"message\": \"Error in api: \" + str(e)}","def __repr__(self):\n\n return \"<Recipe recipe_id=%d user_id=%d recipe_title=%s instructions=%s>\" % (self.recipe_id, self.user_id, self.recipe_title, self.instructions)","def __call__(self):\n context = Context()\n return self.recipe.execute(context, self.cmd, self.cmd_args)"],"string":"[\n \"def test_get_recipe_information(self):\\n pass\",\n \"def recipe(self):\\n return self.__recipe\",\n \"def test_get_recipe_information_bulk(self):\\n pass\",\n \"def get_recipe(self, _id):\\n raise NotImplementedError()\",\n \"def test_get_random_recipes(self):\\n pass\",\n \"def test_search_recipes(self):\\n pass\",\n \"def recipes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Recipe]:\\n pass\",\n \"def test_get_recipe_ingredients_by_id(self):\\n pass\",\n \"def list_recipes(environ, start_response):\\n return list_entities(environ, start_response, 'list_recipes')\",\n \"def test_get_analyzed_recipe_instructions(self):\\n pass\",\n \"def test_summarize_recipe(self):\\n pass\",\n \"def test_search_recipes_by_ingredients(self):\\n pass\",\n \"def test_creating_recipe_with_ingredients(self):\\n ingredient1 = sample_ingredients(user=self.user, name='Prawns')\\n ingredient2 = sample_ingredients(user=self.user, name='Garlic')\\n\\n payload = {\\n 'title': 'Avocado lime cheesecake',\\n 'time_minutes': 20,\\n 'price': 500.00,\\n 'currency': 'NGN',\\n 'ingredients': [ingredient1.id, ingredient2.id]\\n }\\n self.evaluate_recipe(ingredient1, ingredient2, payload, 'ingredient')\",\n \"def test_create_basic_recipe(self):\\n\\n payload = {'name': 'Focaccia', 'description': 'Detailed description'}\\n\\n res = self.client.post(RECIPES_URL, payload)\\n\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\\n\\n recipe = Recipe.objects.get(id=res.data['id'])\\n\\n self.assertEqual(payload['name'], recipe.name)\\n self.assertEqual(payload['description'], recipe.description)\",\n \"def set_recipe(self, recipe):\\n self.__recipe.append(recipe)\\n return 'Recipe created successfully'\",\n \"def add_recipe(self, recipe): \\n\\t\\tfor key, val in self.recipes_list.items():\\n\\t\\t\\tif key == recipe.recipe_type:\\n\\t\\t\\t\\tself.recipes_list[key][recipe.name] = recipe\",\n \"def sample_recipe(**params):\\n defaults = {\\n 'name': 'Empanadas',\\n 'description': 'Test description to prepare meat empanadas!'\\n }\\n defaults.update(params)\\n\\n return Recipe.objects.create(**defaults)\",\n \"def test_create_recipe_with_ingredients(self):\\n\\n payload = {\\n 'name': 'Gnocchi',\\n 'description': 'A detailed description of a yummy recipe!',\\n 'ingredients': [\\n {'name': 'Potatoes'},\\n {'name': 'Flour'},\\n {'name': 'Nutmeg'}\\n ]\\n }\\n\\n res = self.client.post(RECIPES_URL, payload, format='json')\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\\n\\n recipe = Recipe.objects.get(id=res.data['id'])\\n\\n self.assertEqual(payload['name'], recipe.name)\\n self.assertEqual(payload['description'], recipe.description)\\n self.assertEqual(recipe.ingredients.count(), 3)\\n self.assertEqual(recipe.ingredients.first().name, 'Potatoes')\",\n \"def find_recipe(self, recipe_id):\\n return self.find_doc('recipe', 'name', self.get_unique_recipe_name(recipe_id))\",\n \"def test_recipe(self):\\n recipe = recipe_test_utils.create_recipe()\\n self.job1.recipe_id = recipe.id\\n self.job1.save()\\n\\n url = '/%s/jobs/?recipe_id=%d' % (self.api, recipe.id)\\n response = self.client.generic('GET', url)\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n result = json.loads(response.content)\\n self.assertEqual(len(result['results']), 1)\\n self.assertEqual(result['results'][0]['id'], self.job1.id)\",\n \"def __init__(self):\\n self.recipeset = {}\\n self.hardcoded()\",\n \"def test_create_recipe_card(self):\\n pass\",\n \"def test_visualize_recipe_ingredients_by_id(self):\\n pass\",\n \"def __init__(self):\\n TransformRecipes.__init__(self)\",\n \"def recipe(id):\\n\\n selected_recipe = mongo.db.recipes.find_one({'_id': ObjectId(id)})\\n\\n # Using create list function to display these sections easier\\n display_method = create_list(selected_recipe[\\\"method\\\"])\\n display_ingredients = create_list(selected_recipe[\\\"ingredients\\\"])\\n display_equipment = create_list(selected_recipe[\\\"equipment\\\"])\\n\\n show_ad = make_comparison(ad_equipment, display_equipment)\\n\\n return render_template('view_recipe.html', recipe=selected_recipe,\\n title='Recipe', display_method=display_method,\\n ad_equipment=ad_equipment,\\n display_ingredients=display_ingredients,\\n display_equipment=display_equipment,\\n show_ad=show_ad)\",\n \"def recipes():\\n if request.method == 'GET':\\n return Response(\\n json.dumps(recipebook.to_json_list()),\\n mimetype=\\\"application/json\\\")\\n elif request.method == 'POST':\\n new_dict = request.get_json()\\n recipebook.recipes.append(models.Recipe.from_json_dict(new_dict))\\n write_out()\\n return Response(status=200)\",\n \"def test_retrieve_recipes(self):\\n sample_recipe(name=\\\"Avocado toast\\\")\\n sample_recipe(name='Baklava')\\n\\n res = self.client.get(RECIPES_URL)\\n\\n recipes = Recipe.objects.all()\\n serializer = RecipeSerializer(recipes, many=True)\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(res.data), 2)\\n self.assertEqual(res.data, serializer.data)\",\n \"def new_recipe(self):\\n os.system(\\\"clear\\\")\\n self.name = input(\\\"Recipe Name: \\\")\\n self.ingredients = None\\n self.steps=None\\n self.description = None\\n self.tags = {}\\n self.edit_ingredients()\\n self.edit_steps()\\n if _yes_no_select(\\\"Would you like to add a description?\\\"):\\n self.description = input(\\\"Description: \\\")\\n self.edit_tags()\\n while not self.check():\\n continue\",\n \"def test_analyze_recipe_instructions(self):\\n pass\",\n \"def retrive_recipe(self):\\n sample_recipe(user=self.user)\\n sample_recipe(user=self.user)\\n\\n res = self.client.get(RECIPE_URL)\\n\\n recipe = Recipe.objects.all().order_by('-id')\\n serailzer = Recipeserializer(recipe,many = True)\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(res.data, serailzer.data)\",\n \"def test_retrieving_recipes(self):\\n sample_recipe(user=self.user)\\n sample_recipe(user=self.user)\\n\\n res = self.client.get(RECIPES_URL)\\n\\n recipes = Recipe.objects.all().order_by('-id')\\n serializer = RecipeSerializer(recipes, many=True)\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(res.data, serializer.data)\",\n \"def recipe(index):\\n try:\\n if request.method == 'GET':\\n return Response(\\n json.dumps(recipebook.recipes[index].to_json_dict()),\\n mimetype=\\\"application/json\\\")\\n elif request.method == 'DELETE':\\n del recipebook.recipes[index]\\n write_out()\\n return Response(status=200)\\n except IndexError: # recipe with specified index does not exist\\n return Response(\\n \\\"{\\\\\\\"error\\\\\\\":\\\\\\\"no such recipe\\\\\\\"}\\\",\\n status=404,\\n mimetype=\\\"application/json\\\")\",\n \"def getRecipeData(recipeId):\\n return Gw2Spidy._request('recipe', str(recipeId))\",\n \"def test_retrieve_recipes(self):\\n sample_recipe(user = self.user)\\n sample_recipe(user = self.user)\\n\\n res = self.client.get(RECIPE_URL)\\n\\n recipes = Recipe.objects.all().order_by('-id')\\n serializer = RecipeSerializer(recipes, many=True) # many=true returns the data as a list\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(res.data, serializer.data)\",\n \"def test_retrieve_recipes(self):\\n sample_recipe(user=self.user)\\n sample_recipe(user=self.user, title=\\\"Beans\\\")\\n\\n res = self.client.get(RECIPE_URL)\\n\\n recipes = Recipe.objects.all().order_by('-id')\\n serializer = RecipeSerializer(recipes, many=True)\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(res.data), 2)\\n self.assertEqual(res.data, serializer.data)\",\n \"def test_creating_recipe_with_tags(self):\\n tag1 = sample_tags(user=self.user, name='Vegan')\\n tag2 = sample_tags(user=self.user, name='Dessert')\\n\\n payload = {\\n 'title': 'Avocado lime cheesecake',\\n 'time_minutes': 60,\\n 'price': 5000.00,\\n 'currency': 'NGN',\\n 'tags': [tag1.id, tag2.id]\\n }\\n self.evaluate_recipe(tag1, tag2, payload, 'tag')\",\n \"def save(self):\\n self._payload_to_str()\\n return self.recipe.client._perform_json(\\n \\\"PUT\\\", \\\"/projects/%s/recipes/%s\\\" % (self.recipe.project_key, self.recipe.recipe_name),\\n body=self.data)\",\n \"def test_get_similar_recipes(self):\\n pass\",\n \"def create_recipe(*, recipe_in: RecipeCreate) -> dict:\\n new_entry_id = len(RECIPES) + 1\\n recipe_entry = Recipe(\\n id=new_entry_id,\\n label=recipe_in.label,\\n source=recipe_in.source,\\n url=recipe_in.url,\\n )\\n RECIPES.append(recipe_entry.dict())\\n\\n return recipe_entry\",\n \"def test_create_new_recipe(self):\\n payload = {\\n 'title': 'Cheescake',\\n 'time_taken': 35,\\n 'price': 5\\n }\\n\\n res = self.client.post(RECIPE_URL, payload)\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\\n\\n recipe = Recipe.objects.get(id=res.data['id'])\\n for key in payload.keys():\\n self.assertEqual((payload)[key], getattr(recipe, key))\\n\\n # recipe = get_sample_recipe(self.sample_user)\\n # db_recipe =\\n\\n # self.assertEqual(recipe.title, )\",\n \"def add_recipe(self, name, factory_method):\\n self._recipes[name] = factory_method\",\n \"def view_recipe(request, recipe, **_kwargs):\\n return render(request, \\\"deployments/disp_recipe.html\\\", {\\\"recipe\\\": recipe})\",\n \"def test_extract_recipe_from_website(self):\\n pass\",\n \"def test_get_recipe_taste_by_id(self):\\n pass\",\n \"def recipe(self, recipe):\\n import hxl.filters\\n return hxl.filters.from_recipe(self, recipe)\",\n \"def test_patch_recipe(self):\\n recipe = sample_recipe(self.user)\\n recipe.tags.add(sample_tag(self.user))\\n tag = sample_tag(self.user, name='bacon')\\n\\n payload = {\\n 'title': 'Ham hack',\\n 'tags': tag.id\\n }\\n res = self.client.patch(detail_url(recipe.id), payload)\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n\\n recipe.refresh_from_db()\\n serializer = RecipeSerializer(recipe)\\n self.assertEqual(res.data, serializer.data)\\n self.assertEqual(recipe.title, payload['title'])\\n self.assertEqual(serializer.data['tags'], [payload['tags']])\\n tags = recipe.tags.all()\\n self.assertEqual(len(tags), 1)\\n self.assertIn(tag, tags)\",\n \"def test_create_basic_recipe(self):\\n payload = {\\n 'title': 'Cake',\\n 'time_minutes': 40,\\n 'price': 20,\\n }\\n res = self.client.post(RECIPE_URL, payload)\\n\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\\n recipe = Recipe.objects.get(id=res.data['id'])\\n for key in payload:\\n self.assertEqual(payload[key], getattr(recipe, key))\\n serializer = RecipeDetailSerializer(recipe)\\n self.assertEqual(res.data, serializer.data)\",\n \"def create(self):\\n self._finish_creation_settings()\\n return self.project.create_recipe(self.recipe_proto, self.creation_settings)\",\n \"def test_get_recipes(self):\\n r1 = Recipes.objects.create(chef=self.user, name=\\\"Recipe 1\\\", draft=True)\\n r2 = Recipes.objects.create(chef=self.user, name=\\\"Recipe 2\\\", draft=False)\\n r3 = Recipes.objects.create(chef=self.user, name=\\\"Recipe 3\\\", draft=False)\\n book = Book.objects.create(chef=self.user, book_type=Book.TO_SELL)\\n book.add_recipe(r3)\\n\\n url = '/0/chefs/%i/recipes' % self.user.pk\\n\\n resp = self.client.get(url)\\n self.assertPermissionDenied(resp)\\n\\n headers = self.login()\\n resp = self.client.get(url, **headers)\\n self.assertEqual(resp.status_code, 200)\\n self.assertIn('recipes', resp.data)\\n self.assertEqual(1, len(resp.data['recipes']))\\n keys = (\\\"liked\\\", \\\"public_url\\\", \\\"edit_date\\\", \\\"ingredients\\\", \\\"shared\\\", \\\"tags\\\", \\\"commented\\\",\\n \\\"private\\\", \\\"id\\\", \\\"chef\\\", \\\"reported\\\", \\\"nb_shares\\\", \\\"added\\\", \\\"nb_added\\\",\\n \\\"nb_comments\\\", \\\"draft\\\", \\\"commensals\\\", \\\"creation_date\\\", \\\"nb_likes\\\", \\\"name\\\",\\n \\\"products\\\", \\\"prep_time\\\", \\\"serves\\\", \\\"bought\\\", \\\"book_for_sale\\\", \\\"description\\\")\\n self.assertEqual(set(keys), set(resp.data['recipes'][0].keys()))\\n self.assertEqual(r2.pk, resp.data['recipes'][0]['id'])\",\n \"def test_recipes_create(self):\\n app = self.create_app()\\n c = app.test_client()\\n\\n # test if authorization is required to create a recipe\\n rv = c.get('/recipes/create')\\n self.assertRedirects(rv, \\\"/auth/login\\\")\\n\\n # test recipe page\\n register(c, app.config[\\\"USERNAME\\\"], app.config[\\\"PASSWORD\\\"])\\n login(c, app.config[\\\"USERNAME\\\"], app.config[\\\"PASSWORD\\\"])\\n c.get('/recipes/create')\\n self.assert_template_used(\\\"recipes/create.html\\\")\\n\\n # test adding recipe\\n recipe = {'author_id': \\\"unittest\\\", 'title': \\\"recipe_unittest2\\\", 'body': \\\"Empty body\\\",\\n 'servings': 4, 'tag': \\\"dessert\\\", 'ingredients': [{'ingName': \\\"ing_unittest3_solid\\\", 'quantity': 180, 'portion': 'g'}, {\\n 'ingName': \\\"ing_unittest1_liquid\\\", 'quantity': 2, 'portion': 'cup'}]}\\n with app.app_context():\\n create_recipe(c, recipe)\\n self.assert_template_used(\\\"recipes/index.html\\\")\",\n \"def test_retrieve_recipe(self):\\n sample_recipe(user=self.user)\\n sample_recipe(user=self.user)\\n res = self.client.get(RECIPE_URL)\\n\\n recipes = Recipe.objects.all().order_by('id')\\n serializer = RecipeSerializer(recipes,many=True)\\n\\n print(json.dumps(serializer.data, indent=1))\\n print('ok')\\n print(json.dumps(res.data, indent=1))\\n self.assertTrue(res.status_code,status.HTTP_200_OK)\\n self.assertEqual(res.data,serializer.data)\",\n \"def test_full_update_recipe(self):\\n recipe = sample_recipe()\\n recipe.ingredients.create(name='Eggs')\\n original_description = recipe.description\\n\\n payload = {\\n 'name': 'Vegan gnocchi',\\n 'ingredients': [{'name': 'Vegegg'}]\\n }\\n url = recipe_detail_url(recipe.id)\\n self.client.put(url, payload, format='json')\\n\\n recipe.refresh_from_db()\\n self.assertEqual(recipe.name, payload['name'])\\n self.assertEqual(recipe.description, original_description)\\n self.assertEqual(recipe.ingredients.count(), 1)\\n self.assertTrue(recipe.ingredients.first().name, 'Eggs')\",\n \"def test_get_recipe_equipment_by_id(self):\\n pass\",\n \"def recipe_as(self, recipe):\\n prefix, suffix = self._get_jsonp()\\n return prefix + JSON.recipe_as(self, recipe) + suffix\",\n \"def test_get_recipe_by_id(self):\\n recipe = self.request_mgr.get_recipe_by_id(35354)\\n self.assertIn(\\\"Guinness\\\", recipe.get('title'))\",\n \"def put(environ, start_response):\\n recipe_name = web.get_route_value(environ, 'recipe_name')\\n recipe_name = web.handle_extension(environ, recipe_name)\\n\\n recipe = Recipe(recipe_name)\\n store = environ['tiddlyweb.store']\\n length, _ = web.content_length_and_type(environ)\\n\\n usersign = environ['tiddlyweb.usersign']\\n\\n try:\\n recipe = store.get(recipe)\\n recipe.policy.allows(usersign, 'manage')\\n except NoRecipeError:\\n create_policy_check(environ, 'recipe', usersign)\\n\\n try:\\n serialize_type = web.get_serialize_type(environ)[0]\\n except TypeError:\\n raise HTTP400('Content-type header required')\\n\\n try:\\n serializer = Serializer(serialize_type, environ)\\n serializer.object = recipe\\n content = web.read_request_body(environ, length)\\n serializer.from_string(content.decode('utf-8'))\\n\\n recipe.policy.owner = usersign['name']\\n\\n _validate_recipe(environ, recipe)\\n store.put(recipe)\\n except RecipeFormatError as exc:\\n raise HTTP400('unable to put recipe: %s' % exc)\\n except TypeError as exc:\\n raise HTTP400('malformed input: %s' % exc)\\n except NoSerializationError:\\n raise HTTP415('Content type %s not supported' % serialize_type)\\n\\n start_response(\\\"204 No Content\\\",\\n [('Location', web.recipe_url(environ, recipe))])\\n\\n return []\",\n \"def add_recipe(self, recipe):\\n self.recipe_list[recipe.recipe_type].append(recipe)\\n self.last_update = datetime.now\",\n \"def test_full_update_reecipe(self):\\n recipe = sample_recipe(user=self.user)\\n recipe.tags.add(sample_tag(user = self.user))\\n payload = {\\n 'title': 'mutton curry',\\n 'time_minuts': 45,\\n 'price':450\\n\\n }\\n url = detail_url(recipe.id)\\n self.client.put(url , payload)\\n\\n recipe.refresh_from_db()\\n self.assertEqual(recipe.title, payload['title'])\\n self.assertEqual(recipe.time_minuts, payload['time_minuts'])\\n self.assertEqual(recipe.price, payload['price'])\\n tags =recipe.tags.all()\\n self.assertEqual(len(tags), 0 )\",\n \"def post(self, user):\\n data = request.json\\n return save_new_recipe(data=data, user=user)\",\n \"def name(self):\\n return self.recipe_name\",\n \"def recipe(db, recipe_factory, ingredient_factory):\\n recipe = recipe_factory.create()\\n db.session.add(recipe)\\n db.session.commit()\\n\\n ingredients = ingredient_factory.create_batch(10)\\n db.session.add_all(ingredients)\\n db.session.commit()\\n\\n for i in ingredients:\\n recipe_ingredient = RecipeIngredient(\\n recipe_id=recipe.id,\\n ingredient_id=i.id,\\n )\\n db.session.add(recipe_ingredient)\\n recipe.ingredients.append(recipe_ingredient)\\n db.session.commit()\\n\\n return recipe\",\n \"def add_recipe(self, recipe_id, recipe_title, recipe_detail, ingredient_cuisine_doc, user_doc):\\n recipe = {\\n 'type': 'recipe',\\n 'name': self.get_unique_recipe_name(recipe_id),\\n 'title': recipe_title.strip(),\\n 'instructions': recipe_detail\\n }\\n recipe = self.add_doc_if_not_exists(recipe, 'name')\\n self.record_recipe_request_for_user(recipe, ingredient_cuisine_doc, user_doc)\\n return recipe\",\n \"def _ReadRecipeFromFileObject(\\n self, file_object: Union[StringIO, TextIOWrapper, TextIO]) -> Recipe:\\n json_dict = json.load(file_object)\\n\\n description = json_dict['description']\\n del json_dict['description']\\n\\n args = []\\n for arg_list in json_dict['args']:\\n args.append(RecipeArgs(*arg_list))\\n del json_dict['args']\\n\\n return resources.Recipe(description, json_dict, args)\",\n \"def test_autocomplete_recipe_search(self):\\n pass\",\n \"def run(self, recipe_script, api):\\n self._get_client('paths')._initialize_with_recipe_api(api)\\n\\n # TODO(martiniss): Remove this once we've transitioned to the new results\\n # format\\n if self._engine_flags and self._engine_flags.use_result_proto:\\n logging.info(\\\"Using new result proto logic\\\")\\n return self._new_run(recipe_script, api)\\n return self._old_run(recipe_script, api)\",\n \"def test_full_update_recipe(self):\\n recipe = sample_recipe(user=self.user)\\n recipe.tags.add(sample_tags(user=self.user))\\n payload = {\\n 'title': 'Jollof Spaghetti',\\n 'time_minutes': 30,\\n 'price': 5.00,\\n 'currency': 'USD',\\n }\\n url = detail_url(recipe_id=recipe.id)\\n self.client.put(url, payload)\\n\\n recipe.refresh_from_db()\\n self.assertEqual(recipe.title, payload['title'])\\n self.assertEqual(recipe.time_minutes, payload['time_minutes'])\\n self.assertEqual(recipe.price, payload['price'])\\n self.assertEqual(recipe.currency, payload['currency'])\\n tags = recipe.tags.all()\\n self.assertEqual(len(tags), 0)\",\n \"def test_retrive_recipe_detail(self):\\n recipe = create_sample_recipe(user=self.sample_user)\\n recipe.tag.add(create_sample_tag(user=self.sample_user))\\n recipe.ingredient.add(create_sample_ingredient(user=self.sample_user))\\n\\n detail_URL = get_detail_URL(recipe.id)\\n res = self.client.get(detail_URL)\\n\\n serializer = RecipeDetailSerializer(recipe)\\n\\n self.assertEqual(res.data, serializer.data)\",\n \"def test_full_update_recipe(self):\\n recipe = sample_recipe(user=self.user)\\n recipe.tag.add(sample_tag(user=self.user))\\n payload = {\\n 'title':'chicken noodles',\\n 'time_minutes':50,\\n 'price':12.67,\\n }\\n url = detail_url(recipe.id)\\n self.client.put(url,payload)\\n\\n recipe.refresh_from_db()\\n self.assertEqual(recipe.title,payload['title'])\\n self.assertEqual(recipe.time_minutes,payload['time_minutes'])\\n self.assertEqual(float(recipe.price),payload['price'])\\n tags = recipe.tag.all()\\n self.assertEqual(len(tags),0)\\n self.assertEqual(recipe.user,self.user)\",\n \"def __init__(self, recipes=ALLRECIPES_DICT, search_ingredients=SEARCH_INGREDIENTS):\\n self.recipes = json.loads(open(recipes).read())\\n for (k, v) in json.loads(open(IDEORECIPES_DICT).read()).items():\\n self.recipes[k] = v\\n self.search_ingredients = [v.strip().lower() for v in open(search_ingredients)]\\n self.food_hash = {}\\n self.adj = None\\n self.sortby_methods = [\\\"relevance\\\", \\\"popular\\\", \\\"rating\\\"]\\n self.to_skips = [\\\"sugar\\\", \\\"salt\\\", \\\"milk\\\", \\\"pepper\\\", \\\"butter\\\"]\",\n \"def sample_recipe(user, **kwargs):\\n defaults = {\\n 'title': 'Sample recipe',\\n 'time_minutes': 15,\\n 'price': 500.00,\\n 'currency': 'NGN',\\n }\\n defaults.update(kwargs)\\n return Recipe.objects.create(user=user, **defaults)\",\n \"def _determine_recipe(environ):\\n recipe_name = web.get_route_value(environ, 'recipe_name')\\n recipe_name = web.handle_extension(environ, recipe_name)\\n recipe = Recipe(recipe_name)\\n\\n store = environ['tiddlyweb.store']\\n\\n try:\\n recipe = store.get(recipe)\\n except NoRecipeError as exc:\\n raise HTTP404('%s not found, %s' % (recipe.name, exc))\\n\\n return recipe\",\n \"def test_full_update_recipe(self):\\n recipe = sample_recipe(user=self.user)\\n recipe.tags.add(sample_tag(user=self.user))\\n payload = {\\n 'title': 'Spaghetti',\\n 'time_minutes': 25,\\n 'price': 5.00,\\n }\\n url = detail_url(recipe.id)\\n self.client.put(url, payload)\\n\\n recipe.refresh_from_db()\\n self.assertEqual(recipe.title, payload['title'])\\n self.assertEqual(recipe.time_minutes, payload['time_minutes'])\\n self.assertEqual(recipe.price, payload['price'])\\n tags = recipe.tags.all()\\n self.assertEqual(len(tags), 0)\",\n \"def test_create_basic_recipe(self):\\n payload = {\\\"title\\\": \\\"Vietnamese Cake\\\",\\n \\\"time_minutes\\\": 45,\\n \\\"price\\\": 5.55}\\n res = self.client.post(RECIPE_URL, payload)\\n recipe = Recipe.objects.get(id=res.data['id'])\\n for key in payload.keys():\\n if key == \\\"price\\\":\\n self.assertEqual(round(Decimal(payload[key]), 2), getattr(recipe, key))\\n else:\\n self.assertEqual(payload[key], getattr(recipe, key))\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\",\n \"def save_recipe(self, recipe):\\n\\n if self.photo.data:\\n recipe.photo = photos.save(self.photo.data.stream)\\n\\n recipe.title = self.title.data\\n recipe.title_slug = slugify(self.title.data)\\n recipe.description = self.description.data\\n recipe.instructions = self.instructions.data\\n recipe.general_ingredients = [\\n i.to_model() for i in self.general_ingredients]\\n recipe.ingredient_groups = [\\n g.to_model() for g in self.ingredient_groups]\\n recipe.tags = self.tags.data\\n\\n recipe.save()\",\n \"def _validate_recipe(environ, recipe):\\n try:\\n validate_recipe(recipe, environ)\\n except InvalidBagError as exc:\\n raise HTTP409('Recipe content is invalid: %s' % exc)\",\n \"def test_view_recipe_details(self):\\n recipe = sample_recipe(user=self.user)\\n recipe.tags.add(sample_tag(user=self.user))\\n recipe.ingredient.add(sample_ingredient(user=self.user))\\n\\n url = detail_url(recipe.id)\\n res = self.client.get(url)\\n\\n serailzer = RecipeDetailSerializer(recipe)\\n self.assertEqual(res.data, serailzer.data)\",\n \"def recipe_id(self, recipe_id):\\n\\n self._recipe_id = recipe_id\",\n \"def test_retrieve_recipes(self):\\n sample_quizz()\\n sample_quizz()\\n\\n res = self.client.get(QUIZZES_URL)\\n\\n quizzes = Quizz.objects.all()\\n serializer = QuizzSerializer(quizzes, many=True)\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(res.data, serializer.data)\",\n \"def test_recipe_model(self):\\n recipe = Recipe(uri=\\\"testuri\\\", name=\\\"testname\\\", image_url=\\\"test_image_url\\\")\\n\\n db.session.add(recipe)\\n db.session.commit()\\n\\n recipes = Recipe.query.all()\\n\\n self.assertEqual(len(recipes), 1)\\n self.assertEqual(recipes[0].uri, \\\"testuri\\\")\\n self.assertEqual(recipes[0].name, \\\"testname\\\")\\n self.assertEqual(recipes[0].image_url, \\\"test_image_url\\\")\",\n \"def _create_ingredient(self, data):\\n return Ingredient(**data)\",\n \"def search_recipe(ingredients):\\n\\n params = '+'.join(ingredients.split())\\n url_search = SEARCH_URL.format(params)\\n response = req.get(url_search)\\n\\n return response.content\",\n \"def test_create_recipe_with_ingredients(self):\\n ingredient1 = sample_ingredient(user=self.user, name = 'bla')\\n ingredient2 = sample_ingredient(user=self.user, name = 'blaa')\\n payload = {\\n 'title': 'red curry',\\n 'ingredients': [ingredient1.id, ingredient2.id],\\n 'time_minutes': 30,\\n 'price': 30.00\\n }\\n res = self.client.post(RECIPE_URL, payload)\\n\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\\n recipe = Recipe.objects.get(id=res.data['id'])\\n ingredients = recipe.ingredients.all()\\n\\n self.assertEqual(ingredients.count(), 2)\\n self.assertIn(ingredient1, ingredients)\\n self.assertIn(ingredient2, ingredients)\",\n \"def get_product_ingredients(self, driver):\\n pass\",\n \"def test_put_recipe(self):\\n recipe = sample_recipe(self.user)\\n recipe.tags.add(sample_tag(self.user))\\n payload = {\\n 'title': 'Ham hack',\\n 'time_minutes': 38,\\n 'price': 33.00\\n }\\n res = self.client.put(detail_url(recipe.id), payload)\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n\\n recipe.refresh_from_db()\\n serializer = RecipeSerializer(recipe)\\n self.assertEqual(res.data, serializer.data)\\n self.assertEqual(recipe.title, payload['title'])\\n tags = recipe.tags.all()\\n self.assertEqual(len(tags), 0)\",\n \"def sample_recipe(user, **params):\\n defaults = {\\n 'title': 'bread',\\n 'time_minutes': 50,\\n 'price': 5.00\\n }\\n defaults.update(params)\\n\\n return Recipe.objects.create(user=user, **defaults)\",\n \"def get_recipe(cls, recipeid):\\n\\n recipe = Recipe.query.filter_by(recipe_id=recipeid).one()\\n\\n return recipe\",\n \"def test_creating_recipe_with_ingredients(self):\\n ingredient1 = create_sample_ingredient(user=self.user, name=\\\"Paprika\\\")\\n ingredient2 = create_sample_ingredient(user=self.user, name=\\\"Salad\\\")\\n\\n payload = {\\n \\\"title\\\": \\\"Green Salad\\\",\\n \\\"time_minutes\\\": 34,\\n \\\"price\\\": 4.66,\\n \\\"ingredients\\\": [ingredient1.id, ingredient2.id]\\n }\\n res = self.client.post(RECIPE_URL, payload)\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\\n recipe = Recipe.objects.get(id=res.data['id'])\\n ingredients = recipe.ingredients.all()\\n self.assertEqual(ingredients.count(), 2)\\n self.assertIn(ingredient1, ingredients)\\n self.assertIn(ingredient2, ingredients)\",\n \"def __init__(self, recipe_url):\\n self.recipe_url = recipe_url\\n self.translator = TranslationClient()\",\n \"def get_recipe_raw_definition(self):\\n return self.recipe_settings\",\n \"def recipe(self, name_parts: ResourceIdentifier, type_in: Optional[str], data_in: JsonObject, group: Optional[str] = None, conditions: Json = None) -> RecipeContext:\\n res = utils.resource_location(self.domain, name_parts)\\n self.write((*self.resource_dir, 'data', res.domain, 'recipes', res.path), {\\n 'type': type_in,\\n 'group': group,\\n **data_in,\\n 'conditions': utils.recipe_condition(conditions)\\n })\\n return RecipeContext(self, res)\",\n \"def test_create_recipe_with_ingredient(self):\\n ingredient1 = sample_ingredient(user=self.user, name='Prawns')\\n ingrident2 = sample_ingredient(user=self.user, name ='Ginger')\\n\\n payload = {\\n 'title': 'Thai prawn and curry',\\n 'ingredient': [ingredient1.id,ingrident2.id],\\n 'time_minuts':60,\\n 'price': 250\\n }\\n res = self.client.post(RECIPE_URL,payload)\\n\\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)\\n\\n recipe = Recipe.objects.get(id=res.data['id'])\\n ingredients = recipe.ingredient.all()\\n self.assertEqual(ingredients.count(),2)\\n self.assertIn(ingredient1, ingredients)\\n self.assertIn(ingrident2,ingredients)\",\n \"def test_search_recipes_by_nutrients(self):\\n pass\",\n \"def test_recipes_limited_to_user(self):\\n user2 = get_user_model().objects.create_user(\\n email = 'test2@gmail.com',\\n password = '123465',\\n )\\n sample_recipe(user = user2)\\n sample_recipe(user = self.user)\\n\\n res = self.client.get(RECIPE_URL)\\n\\n recipes = Recipe.objects.filter(user=self.user)\\n serializer = RecipeSerializer(recipes, many=True) # although we only have one recipe for this user, we still pass many=true since even if there is one object returned, the list api should always return a data type of list\\n\\n self.assertEqual(res.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(res.data), 1)\\n self.assertEqual(res.data, serializer.data)\",\n \"def get(id: int):\\r\\n filename = Path(__file__).parent / \\\"recipe-data.csv\\\"\\r\\n files = import_file.Files()\\r\\n recipe_load = files.import_from_csv(filename)\\r\\n\\r\\n recipes = Recipes(recipe_load)\\r\\n a_recipe = recipes.filter_recipes_id(id)\\r\\n\\r\\n return jsonify(a_recipe)\",\n \"def test_create_recipe_with_ingredients(self):\\n ing1 = sample_ingredient(user=self.user,name=\\\"ginger\\\")\\n ing2 = sample_ingredient(user=self.user, name=\\\"Prawn\\\")\\n payload = {\\n 'title':'Prawn curry',\\n 'ingredient':[ing1.id,ing2.id],\\n 'time_minutes':60,\\n 'price':10.00,\\n }\\n res = self.client.post(RECIPE_URL,payload)\\n self.assertEqual(res.status_code,status.HTTP_201_CREATED)\\n recipe = Recipe.objects.get(id=res.data['id'])\\n ingredients = recipe.ingredient.all()\\n self.assertEqual(ingredients.count(),2)\\n self.assertIn(ing1,ingredients)\\n self.assertIn(ing2,ingredients)\",\n \"def sample_recipe(user,**params):\\n default = {\\n 'title' : 'sample title',\\n 'time_minutes' : 10,\\n 'price' : 5.00,\\n }\\n default.update(params)\\n return Recipe.objects.create(user=user,**default)\",\n \"def recipes():\\n recipes = mongo.db.recipes.find()\\n return render_template(\\\"recipes.html\\\", recipes=recipes)\",\n \"def single_recipe_controller(filters, db_conn, host_url):\\n try:\\n result = db_conn[\\\"recipes\\\"].find(filters).sort(\\\"createdOn\\\", -1)\\n recipe_list = map_response(result, host_url)\\n return recipe_list\\n\\n except Exception as e:\\n print(e)\\n return {\\\"success\\\": False, \\\"message\\\": \\\"Error in api: \\\" + str(e)}\",\n \"def __repr__(self):\\n\\n return \\\"<Recipe recipe_id=%d user_id=%d recipe_title=%s instructions=%s>\\\" % (self.recipe_id, self.user_id, self.recipe_title, self.instructions)\",\n \"def __call__(self):\\n context = Context()\\n return self.recipe.execute(context, self.cmd, self.cmd_args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7399995","0.7240145","0.7060982","0.69131684","0.68955857","0.6634333","0.6622917","0.6594366","0.6353314","0.63221014","0.63158387","0.6281272","0.6268768","0.62628794","0.6251283","0.6206122","0.6205642","0.61758476","0.61579376","0.6142557","0.6135808","0.61353326","0.61344326","0.61078906","0.61035043","0.60933095","0.608872","0.60832596","0.6071791","0.60535556","0.605283","0.60474753","0.60369325","0.6029343","0.6020101","0.59655184","0.5963838","0.5948853","0.5938817","0.5929235","0.5925952","0.59151","0.5904971","0.59045565","0.5881764","0.58802915","0.5877684","0.58768755","0.5862539","0.58590686","0.58577776","0.5854725","0.58359313","0.5815176","0.5807889","0.5800857","0.57813174","0.5770621","0.5765002","0.57562876","0.57471013","0.57334745","0.5732018","0.57085407","0.57070464","0.5704894","0.56915","0.5690357","0.56891984","0.5686359","0.566926","0.56677824","0.566006","0.566003","0.5659482","0.56551254","0.56484085","0.56313425","0.5630888","0.5629105","0.561848","0.5615964","0.5605291","0.56040084","0.56013733","0.5594902","0.5593484","0.5592246","0.5591969","0.55884343","0.558655","0.5577376","0.55728245","0.557174","0.5563252","0.5557508","0.55553913","0.555078","0.5544834","0.5539509"],"string":"[\n \"0.7399995\",\n \"0.7240145\",\n \"0.7060982\",\n \"0.69131684\",\n \"0.68955857\",\n \"0.6634333\",\n \"0.6622917\",\n \"0.6594366\",\n \"0.6353314\",\n \"0.63221014\",\n \"0.63158387\",\n \"0.6281272\",\n \"0.6268768\",\n \"0.62628794\",\n \"0.6251283\",\n \"0.6206122\",\n \"0.6205642\",\n \"0.61758476\",\n \"0.61579376\",\n \"0.6142557\",\n \"0.6135808\",\n \"0.61353326\",\n \"0.61344326\",\n \"0.61078906\",\n \"0.61035043\",\n \"0.60933095\",\n \"0.608872\",\n \"0.60832596\",\n \"0.6071791\",\n \"0.60535556\",\n \"0.605283\",\n \"0.60474753\",\n \"0.60369325\",\n \"0.6029343\",\n \"0.6020101\",\n \"0.59655184\",\n \"0.5963838\",\n \"0.5948853\",\n \"0.5938817\",\n \"0.5929235\",\n \"0.5925952\",\n \"0.59151\",\n \"0.5904971\",\n \"0.59045565\",\n \"0.5881764\",\n \"0.58802915\",\n \"0.5877684\",\n \"0.58768755\",\n \"0.5862539\",\n \"0.58590686\",\n \"0.58577776\",\n \"0.5854725\",\n \"0.58359313\",\n \"0.5815176\",\n \"0.5807889\",\n \"0.5800857\",\n \"0.57813174\",\n \"0.5770621\",\n \"0.5765002\",\n \"0.57562876\",\n \"0.57471013\",\n \"0.57334745\",\n \"0.5732018\",\n \"0.57085407\",\n \"0.57070464\",\n \"0.5704894\",\n \"0.56915\",\n \"0.5690357\",\n \"0.56891984\",\n \"0.5686359\",\n \"0.566926\",\n \"0.56677824\",\n \"0.566006\",\n \"0.566003\",\n \"0.5659482\",\n \"0.56551254\",\n \"0.56484085\",\n \"0.56313425\",\n \"0.5630888\",\n \"0.5629105\",\n \"0.561848\",\n \"0.5615964\",\n \"0.5605291\",\n \"0.56040084\",\n \"0.56013733\",\n \"0.5594902\",\n \"0.5593484\",\n \"0.5592246\",\n \"0.5591969\",\n \"0.55884343\",\n \"0.558655\",\n \"0.5577376\",\n \"0.55728245\",\n \"0.557174\",\n \"0.5563252\",\n \"0.5557508\",\n \"0.55553913\",\n \"0.555078\",\n \"0.5544834\",\n \"0.5539509\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59413797"},"document_rank":{"kind":"string","value":"38"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":89,"numItemsPerPage":100,"numTotalItems":95772,"offset":8900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDMwNDkxNCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzQzMDg1MTQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.ZqRhGQ3qhNIoirxU2Q6k9fTyrlY1_BfwU7h44NZv8MTO4U2bEXVA5VzjMFKb4lbINh5fxaBRv3kodqOYRGXFCA","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 |
|---|---|---|---|---|---|---|
Create the reference file of a test using the response received. The file will be created in the git references folder provided in the settings file | def create_reference(
self, response_checker=default_checker.default_journey_checker
):
# Check that the file doesn't already exist
filename = self.get_file_name()
filepath = os.path.join(config["REFERENCE_FILE_PATH"], filename)
if os.path.isfile(filepath):
logger.warning(
"NO REF FILE CREATED - {} is already present".format(filepath)
)
else:
# Concatenate reference file info
reference_text = OrderedDict()
reference_text["query"] = self.query.replace(
config["URL_JORMUN"][7:], "localhost"
)
logger.warning("Query: {}".format(self.query))
reference_text["response"] = response_checker.filter(
json.loads(self.full_resp)
)
reference_text["full_response"] = json.loads(
self.full_resp.replace(config["URL_JORMUN"][7:], "localhost")
)
# Write reference file directly in the references folder
with open(filepath, "w") as ref:
ref.write(json.dumps(reference_text, indent=4))
logger.info("Created reference file : {}".format(filepath)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ref(request):\n r = referencepytest.ref(request)\n this_dir = os.path.abspath(os.path.dirname(__file__))\n r.set_data_location(os.path.join(this_dir, '..', 'reference'))\n return r",
"def test_with_new_file(self):\n repository = self.create_repository(tool_name='Test')\n review_requ... | [
"0.65603554",
"0.62640995",
"0.62635124",
"0.62011635",
"0.6008765",
"0.5936762",
"0.5884765",
"0.5857535",
"0.5827133",
"0.5797445",
"0.5793405",
"0.5725234",
"0.57189417",
"0.571022",
"0.5687655",
"0.5664678",
"0.5638524",
"0.56348014",
"0.5630147",
"0.5594338",
"0.55792326... | 0.70232326 | 0 |
Compare the response (which is a dictionary) to the reference First, the function retrieves the reference then filters both ref and resp Finally, it compares them | def compare_with_ref(
self, response, response_checker=default_checker.default_journey_checker
):
def ref_resp2files(output_file, output_json):
"""
Create a file for the filtered response and for the filtered reference
"""
with open(output_file, "w") as reference_text:
reference_text.write(output_json)
def print_diff(ref_file, resp_file):
"""
Print differences between reference and response in console
"""
# open reference
with open(ref_file) as reference_text:
reference = reference_text.readlines()
# open response
with open(resp_file) as response_text:
response = response_text.readlines()
# Print failed test name
print_color("\n\n" + str(file_name) + " failed :" + "\n\n", Colors.PINK)
symbol2color = {"+": Colors.GREEN, "-": Colors.RED}
for line in difflib.unified_diff(reference, response):
print_color(line, symbol2color.get(line[0], Colors.DEFAULT))
# Filtering the answer. (We compare to a reference also filtered with the same filter)
filtered_response = response_checker.filter(response)
# Get the reference
# Create the file name
filename = self.get_file_name()
filepath = os.path.join(config["REFERENCE_FILE_PATH"], filename)
assert os.path.isfile(filepath), "{} is not a file".format(filepath)
with open(filepath, "r") as f:
raw_reference = f.read()
# Transform the string into a dictionary
dict_ref = json.loads(raw_reference)
# Get only the full_response part from the ref
ref_full_response = dict_ref["full_response"]
# Filtering the reference
filtered_reference = response_checker.filter(ref_full_response)
# Compare response and reference
try:
response_checker.compare(filtered_response, filtered_reference)
except AssertionError as e:
# print the assertion error message
logging.error("Assertion Error: %s" % str(e))
# find name of test
file_name = filename.split("/")[-1]
file_name = file_name[:-5]
# create a folder
dir_path = config["RESPONSE_FILE_PATH"]
if not os.path.exists(dir_path):
os.makedirs(dir_path)
# create path to ref and resp
full_file_name_ref = dir_path + "/reference_" + file_name + ".txt"
full_file_name_resp = dir_path + "/response_" + file_name + ".txt"
json_filtered_reference = json.dumps(filtered_reference, indent=4)
json_filtered_response = json.dumps(filtered_response, indent=4)
# Save resp and ref as txt files in folder named outputs
ref_resp2files(full_file_name_ref, json_filtered_reference)
ref_resp2files(full_file_name_resp, json_filtered_response)
# Print difference in console
print_diff(full_file_name_ref, full_file_name_resp)
raise | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare_original_response_with_copy(context):\n original = context.response.json()\n copy = context.response_copy\n\n def compare_top_level_values():\n # get the list of fields that are JSON values not arrays\n keys = [val for val in original.iterkeys() if not isinstance(original[val], (... | [
"0.6025328",
"0.57968277",
"0.57027745",
"0.56979775",
"0.5373415",
"0.532791",
"0.5307729",
"0.52962",
"0.52779275",
"0.5272271",
"0.51982015",
"0.5154221",
"0.514683",
"0.5144544",
"0.51169497",
"0.5078921",
"0.5072906",
"0.5058429",
"0.5058264",
"0.505702",
"0.5056039",
... | 0.7237854 | 0 |
Create a file for the filtered response and for the filtered reference | def ref_resp2files(output_file, output_json):
with open(output_file, "w") as reference_text:
reference_text.write(output_json) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export_file(self):\n if self.args.keyfilter:\n self.filter_keys()\n if self.args.datafilter:\n self.filter_values()\n json.dump(self.outputdata, self.outfile, indent=self.args.indent)\n self.outfile.write('\\n')",
"def create_reference(\n self, respons... | [
"0.602621",
"0.59944147",
"0.5985722",
"0.5863088",
"0.5780173",
"0.5737445",
"0.5735932",
"0.5701409",
"0.56273806",
"0.5584363",
"0.5571645",
"0.55378807",
"0.551075",
"0.54842454",
"0.5458675",
"0.5398169",
"0.5377229",
"0.5367841",
"0.5365113",
"0.5354977",
"0.5352039",
... | 0.631874 | 0 |
Print differences between reference and response in console | def print_diff(ref_file, resp_file):
# open reference
with open(ref_file) as reference_text:
reference = reference_text.readlines()
# open response
with open(resp_file) as response_text:
response = response_text.readlines()
# Print failed test name
print_color("\n\n" + str(file_name) + " failed :" + "\n\n", Colors.PINK)
symbol2color = {"+": Colors.GREEN, "-": Colors.RED}
for line in difflib.unified_diff(reference, response):
print_color(line, symbol2color.get(line[0], Colors.DEFAULT)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare_with_ref(\n self, response, response_checker=default_checker.default_journey_checker\n ):\n\n def ref_resp2files(output_file, output_json):\n \"\"\"\n Create a file for the filtered response and for the filtered reference\n \"\"\"\n with open... | [
"0.6958349",
"0.6202376",
"0.6095348",
"0.5904432",
"0.5885077",
"0.5830992",
"0.5810929",
"0.57152325",
"0.5700688",
"0.5698527",
"0.56759423",
"0.56628805",
"0.56229484",
"0.55711806",
"0.55609244",
"0.55433357",
"0.5525367",
"0.549411",
"0.5481868",
"0.5465276",
"0.5456778... | 0.73701763 | 0 |
Generate a rightclick menu for the items | def context_menu(self, treeview, position):
all_item = get_current_item(self,treeview,single=False)
if len(all_item) == 1:
item = all_item[0]
list_operations = ['Print attrs','-','Plot Hist', 'Plot 2D']
action,actions = get_actions(treeview,position,list_operations)
if action == actions['Print attrs']:
send_dict_to_console(self,item,treeview)
#print_attributes(self,item,treeview)
if action == actions['Plot Hist']:
plot_histogram(self,item,treeview)
if action == actions['Plot 2D']:
plot2d(self,item,treeview)
elif len(all_item) == 2:
item0,item1 = all_item
list_operations = ['Plot Scatter','Plot Line']
action,actions = get_actions(treeview,position,list_operations)
if action == actions['Plot Scatter']:
plot1D(self,item0,item1,treeview,plot='scatter')
if action == actions['Plot Line']:
plot1D(self,item0,item1,treeview,plot='line') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_menus( self ):",
"def create_menu():",
"def addContextMenuItems(*args):",
"def rightClickMenu(controlparent,control,qp,menuarray,rightclickfunction,added_arg):\r\n if menuarray == []:\r\n return 0;\r\n Rmnu = QtGui.QMenu(controlparent)\r\n for i, itm in enumerate(menuarray):\r\n ... | [
"0.7842248",
"0.7701151",
"0.72885704",
"0.7128372",
"0.7125885",
"0.70448405",
"0.70315874",
"0.6985604",
"0.68939555",
"0.68497425",
"0.6840268",
"0.67227817",
"0.6722002",
"0.67210567",
"0.6720659",
"0.67192984",
"0.6679403",
"0.6652344",
"0.6647002",
"0.6645112",
"0.66284... | 0.65835065 | 25 |
Do something to the input and put the result in the output_quueue. | def process(self, input_element: Any) -> None:
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def output(self):\r\n self.logic ( )\r\n return self.output",
"def run(self, input):\n print self.print_meep(input)",
"def process(self, inputs):\n output = None\n return output",
"def handle_output(self, workunit, label, s):\r\n pass",
"def handle_output(self, workunit, label... | [
"0.62992793",
"0.621587",
"0.6168",
"0.60797054",
"0.60797054",
"0.60701555",
"0.6039619",
"0.6010388",
"0.6008327",
"0.5957112",
"0.59085846",
"0.590205",
"0.5835123",
"0.5788597",
"0.57883525",
"0.5769604",
"0.57273495",
"0.57041085",
"0.56851864",
"0.56530696",
"0.56336266... | 0.0 | -1 |
Proces elements from the input queue until empty. | def run(self) -> None:
while True:
try:
input_element = self.input_queue.get_nowait()
self.process(input_element)
except Empty:
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_queue_fast(self):\n while self.queue:\n self.queue.popleft()()",
"def _wait_empty(self):\n while True:\n if self.queue.empty():\n # We still have to wait for the last queue item being processed\n # (queue.empty() returns True before qu... | [
"0.7123321",
"0.6928471",
"0.6863272",
"0.68230313",
"0.681069",
"0.67634106",
"0.6683323",
"0.6645927",
"0.66053593",
"0.66042024",
"0.65760016",
"0.65450245",
"0.65428",
"0.65332437",
"0.64878625",
"0.6477527",
"0.6431174",
"0.63786554",
"0.6355708",
"0.6354153",
"0.6338230... | 0.71853554 | 0 |
Download a single file from the web, singlethreaded. | def single_file_download(url: str, encoding: str = "utf-8") -> str:
recipient = BytesIO() # the stream we will write into
# print("Opening %r . . ." % url)
curl = pycurl.Curl()
curl.setopt(curl.URL, url)
curl.setopt(curl.WRITEDATA, recipient)
curl.perform()
curl.close()
# print("Closed %r." % url)
return recipient.getvalue().decode(encoding) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _download_single(url, to, id):\n if os.path.exists(to):\n error_flags[id] = 1\n return\n\n try:\n request = rq.Request(url=url, headers=forge_agent_header)\n info = rq.urlopen(request).read()\n\n except urllib.error.URLError as e:\n print(url, 'urllib error')\n ... | [
"0.7207766",
"0.7165215",
"0.71526456",
"0.7114009",
"0.7071731",
"0.70129436",
"0.6987536",
"0.6952817",
"0.6934653",
"0.6932239",
"0.6927163",
"0.6924666",
"0.6897304",
"0.68810105",
"0.68735075",
"0.68536335",
"0.6847325",
"0.68178904",
"0.681241",
"0.6794002",
"0.6791782"... | 0.6760712 | 23 |
Get the contents of the file at the given url. | def process(self, url: str) -> None:
text = single_file_download(url, encoding="utf-8")
self.output_queue.put(text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def web_get_file(self, url):\n try:\n print(url)\n response = requests.get(url, verify=False)\n file_buffer = BytesIO(response.content)\n file_buffer.seek(0)\n return file_buffer\n except:\n print(traceback.print_exc())\n re... | [
"0.7789234",
"0.7628709",
"0.7561159",
"0.75399375",
"0.7516315",
"0.73461986",
"0.73405373",
"0.7318421",
"0.7309704",
"0.7293151",
"0.72760564",
"0.71967506",
"0.7170775",
"0.71379685",
"0.713316",
"0.7123545",
"0.71138036",
"0.70557725",
"0.7036462",
"0.70032036",
"0.69976... | 0.0 | -1 |
Pop all elements out of a queue using .get_nowait(). | def get_all_nowait(queue: Queue) -> list:
results = []
while True:
try:
result = queue.get_nowait()
results.append(result)
except Empty:
break
return results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def use_queue():\n q = queue.Queue()\n for i in range(10):\n q.put_nowait(i)\n while q.qsize() > 0:\n element = q.get_nowait()\n sys.stdout.write(\"poping out from queue: {0}\\n\".format(element))",
"def process_queue_fast(self):\n while self.queue:\n self.queue.po... | [
"0.7690526",
"0.7386941",
"0.73390293",
"0.730532",
"0.7302115",
"0.71763545",
"0.71752375",
"0.714329",
"0.70479155",
"0.70476866",
"0.7042465",
"0.7022835",
"0.7013579",
"0.7004436",
"0.6989313",
"0.69627863",
"0.6954468",
"0.6933592",
"0.6921749",
"0.69049203",
"0.6895917"... | 0.7315528 | 3 |
Process every input using the given worker class. | def multiprocess(inputs: list, worker_class: Any, num_threads: int = 40):
input_queue = Queue() # type: ignore
output_queue = Queue() # type: ignore
for input_elm in inputs:
input_queue.put(input_elm)
threads = [worker_class(input_queue, output_queue)
for _ in range(num_threads)]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
return get_all_nowait(output_queue) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def processInputs(self):",
"def process_inputs(self, inputs):",
"def run(self):\n self.class_inst_obj.processor(self.msg)",
"def process(self):\n raise NotImplementedError",
"def run(self) -> None:\n\n while True:\n try:\n input_element = self.input_queue.get_... | [
"0.62040085",
"0.6178794",
"0.5952422",
"0.59248585",
"0.5817719",
"0.56970406",
"0.5652122",
"0.56006",
"0.5596137",
"0.555472",
"0.555472",
"0.555472",
"0.55169404",
"0.54495186",
"0.5403452",
"0.5399591",
"0.5373088",
"0.5360921",
"0.5338759",
"0.53068113",
"0.53002506",
... | 0.64647937 | 0 |
Read a file from the internet, and put it in a folder on disk. | def download(urls: List[str], num_threads: int = 40) -> List[str]:
num_files = len(urls)
start = perf_counter()
print("Starting download of %s files . . ." % num_files)
results = multiprocess(urls, Downloader, num_threads=num_threads)
dur = perf_counter() - start
print("Completed download of %s files after %.3f seconds." % (num_files, dur))
return results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download(self, url):\n try:\n webFile = urllib.urlopen(url)\n localFile = open(self.workdir + \"/\" + url.split('/')[-1], 'w')\n localFile.write(webFile.read())\n webFile.close()\n localFile.close()\n except IOError:\n print(\"coul... | [
"0.6463796",
"0.6256494",
"0.61775124",
"0.6177211",
"0.60822904",
"0.5990596",
"0.5944307",
"0.59229976",
"0.589575",
"0.58864975",
"0.5879225",
"0.58666736",
"0.58587056",
"0.5850899",
"0.5834173",
"0.5821299",
"0.5803716",
"0.5792066",
"0.5764819",
"0.5752733",
"0.5699436"... | 0.0 | -1 |
Simple time series forecaster class | def __init__(self, cfg=None):
if cfg is None:
cfg = (1, 1, "persist")
self.cfg = cfg
self.shift, self.offset, self.avg_type = cfg
self.forecast = self.average_forecast
self.averager = None
if self.avg_type == "mean":
self.averager = np.mean
elif self.avg_type == "median":
self.averager = np.median
elif self.avg_type == "persist":
self.forecast = self.persistence_forecast
elif self.avg_type == "drift":
self.forecast = self.drift_forecast | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def model():\n return TimeSeriesMultiReg()",
"def _build_forecast_series(self,\n points_preds: np.ndarray) -> TimeSeries:\n\n time_index = self._generate_new_dates(len(points_preds))\n\n return TimeSeries.from_times_and_values(time_index, points_preds, freq=self.tra... | [
"0.6148477",
"0.59344846",
"0.5870157",
"0.58571",
"0.5753403",
"0.57533115",
"0.57117873",
"0.5679154",
"0.56493205",
"0.56239253",
"0.56217587",
"0.55675584",
"0.5516488",
"0.55088216",
"0.5477455",
"0.54756147",
"0.5470915",
"0.54526985",
"0.54525316",
"0.5447155",
"0.5422... | 0.0 | -1 |
return info about recently modified events | def __init__(self,
eventRegistry,
maxCount = 500,
mandatoryLang = None,
mandatoryLocation = True,
returnInfo = ReturnInfo()):
QueryParamsBase.__init__(self)
assert maxCount <= 500, "Maximum number of events returned per call is 500"
self._er = eventRegistry
self._setVal("addEvents", True)
self._setVal("addArticles", False)
self._setVal("recentActivityEventsMaxEventCount", maxCount)
self._setVal("recentActivityEventsMandatoryLocation", mandatoryLocation)
# return only events that have at least a story in the specified language
if mandatoryLang != None:
self._setVal("recentActivityEventsMandatoryLang", mandatoryLang)
self._update(returnInfo.getParams("recentActivityEvents")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getChanges():",
"def modified_stats(self):\n return self._counts_per_month('last_modified')",
"def updated_on(self):\n return self.get_time(\"updated_on\")",
"def getLastModifiedTime(self): #$NON-NLS-1$\r",
"def _get_changes_metadata(document):\n return ((el.get(author_attrib),\n ... | [
"0.6769352",
"0.64247614",
"0.6342947",
"0.63398314",
"0.6318615",
"0.63153297",
"0.6308564",
"0.6271734",
"0.6271734",
"0.6271734",
"0.6271734",
"0.6255355",
"0.62016386",
"0.62016386",
"0.61900157",
"0.6164317",
"0.6164317",
"0.61549234",
"0.61546636",
"0.6148851",
"0.60952... | 0.0 | -1 |
Get the latest new or updated events from Event Registry | def getUpdates(self):
# execute the query
ret = self._er.execQuery(self)
if ret and ret.get("recentActivity") and ret["recentActivity"].get("events"):
# return the updated information
return ret["recentActivity"]["events"]
# or empty
return {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_events() -> list[Event]:\n g.ledger.changed()\n return [e for e in g.filtered.entries if isinstance(e, Event)]",
"def get_events():\n url = app.config['EVENTS_ENDPOINT']\n response = requests.get(url, params={})\n if response.status_code == 200:\n return parse_events(response.json()... | [
"0.64524996",
"0.63650477",
"0.6306866",
"0.62387884",
"0.6169891",
"0.6169891",
"0.6113987",
"0.6093191",
"0.60880923",
"0.5969866",
"0.5965109",
"0.59017813",
"0.5898376",
"0.5892461",
"0.58733714",
"0.58715504",
"0.5857285",
"0.5807864",
"0.5802426",
"0.5778328",
"0.575562... | 0.5839551 | 17 |
return info about recently added articles | def __init__(self,
eventRegistry,
maxCount = 500,
mandatorySourceLocation = False,
articleLang = None,
returnInfo = ReturnInfo()):
QueryParamsBase.__init__(self)
assert maxCount <= 500, "Maximum number of articles returned per call is 500"
self._er = eventRegistry
self._setVal("addEvents", False)
self._setVal("addArticles", True)
self._setVal("recentActivityArticlesMaxArticleCount", maxCount)
self._setVal("recentActivityArticlesMandatorySourceLocation", mandatorySourceLocation)
if articleLang != None:
self._setVal("recentActivityArticlesLang", articleLang)
self._update(returnInfo.getParams("recentActivityArticles")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_recently_articles(cls, num):\n return cls.objects.values('title', 'view_times', 'update_time', 'author')\\\n .filter(status=0).order_by('-update_time')[:num]",
"def latest_content(request):\n latest_articles = Article.published_articles()[:5]\n latest_comments = Comment.objects.al... | [
"0.686497",
"0.62624764",
"0.6229607",
"0.6219513",
"0.61116755",
"0.60870814",
"0.6046967",
"0.60119355",
"0.5992242",
"0.5978869",
"0.5909099",
"0.58944285",
"0.58672863",
"0.58509743",
"0.5836655",
"0.5833346",
"0.578833",
"0.5772408",
"0.5724148",
"0.5714202",
"0.57078743... | 0.0 | -1 |
Get the latest new or updated events articles Event Registry. | def getUpdates(self):
# execute the query
ret = self._er.execQuery(self)
if ret and ret.get("recentActivity") and ret["recentActivity"].get("articles"):
# return the latest articles
return ret["recentActivity"]["articles"]["activity"]
# or empty
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_events():\n url = app.config['EVENTS_ENDPOINT']\n response = requests.get(url, params={})\n if response.status_code == 200:\n return parse_events(response.json())\n raise RuntimeError('Error in retrieving events.')",
"def _get_persistent_events(self) -> Dict[uuid.UUID, CronEvent]:\n ... | [
"0.6143702",
"0.6038302",
"0.6023639",
"0.58556026",
"0.58545154",
"0.57816315",
"0.5745347",
"0.5734352",
"0.5734352",
"0.5719633",
"0.5719397",
"0.5698083",
"0.5681828",
"0.5623633",
"0.56198883",
"0.5609583",
"0.5598598",
"0.5597717",
"0.5596118",
"0.5584513",
"0.55138314"... | 0.5413742 | 32 |
Basic landing page for unauthenticated users | def login():
if current_user.is_authenticated:
return redirect(url_for('main.home'))
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user and bcrypt.check_password_hash(user.password, form.password.data):
login_user(user, remember=form.remember_me.data)
next_page = request.args.get('next') # get next url parameter and after login redirect to requested page
flash("Login Successful", 'success')
# if there was request for specific page that needs authorization, then that argument assigned in
# variable `next_page` keeps that and after login automatically user is redirect to that page
return redirect(next_page) if next_page else redirect(url_for('main.home'))
else:
flash("Login Unsuccessful. Please check email and password", "danger")
return redirect(url_for('users.login'))
return render_template('login.html', title='Log In', form=form) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def landing():\n if g.user:\n return render_template('landing.html', user=g.user)\n return redirect(url_for('login'))",
"def home_page():\n if not g.user:\n flash(\"Please login to view.\", \"warning\")\n return redirect('/login')\n return render_template('index.html')",
"def h... | [
"0.7869509",
"0.766923",
"0.7648024",
"0.76207626",
"0.75354123",
"0.7504049",
"0.74748087",
"0.73743373",
"0.72935927",
"0.7250666",
"0.72364444",
"0.7209014",
"0.71815675",
"0.71794057",
"0.7173211",
"0.7159091",
"0.7151061",
"0.71451926",
"0.70916605",
"0.7072187",
"0.7066... | 0.0 | -1 |
Function allows for current user information modification. There is feature for change of default picture that is assigned during registration of new user. Part of change user picture is connected with save_image() function located in `utils.py` where name of original picture file is processing and then saved new_project_form in render_template() return is intentionally located here to allow for rendering tasks.new_project_2 function | def account():
form = UpdateAccountForm()
new_project_form = ProjectForm()
if form.validate_on_submit():
if form.picture.data: # if statement responsible for change of default picture
picture_file = save_image(form.picture.data)
current_user.img_file = picture_file
current_user.user_name = form.user_name.data
current_user.email = form.email.data
db.session.commit()
flash("Changes saved", "success")
return redirect(url_for('users.account'))
elif request.method == "GET":
form.user_name.data = current_user.user_name
form.email.data = current_user.email
img_file = url_for('static', filename='images/' + current_user.img_file)
return render_template('account.html',
title="Account",
form=form,
img_file=img_file,
new_project_form=new_project_form) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def account():\n\n form = UpdateUserForm()\n\n if form.validate_on_submit():\n print(form)\n if form.picture.data:\n username = current_user.username\n pic = add_profile_pic(form.picture.data,username)\n current_user.profile_image = pic\n\n current_user.u... | [
"0.63029945",
"0.6147011",
"0.60409224",
"0.5987003",
"0.5972466",
"0.59428054",
"0.5842993",
"0.5805387",
"0.5803387",
"0.5779269",
"0.57783127",
"0.5758194",
"0.57569313",
"0.5720132",
"0.57105464",
"0.57057136",
"0.56755704",
"0.56709665",
"0.56596",
"0.56305",
"0.5622149"... | 0.6888967 | 0 |
Function that render form for email input that is destination of utils.send_reset_email function responsible for sending email to user with token that is available for specific period of time and reset user's password | def reset_password():
if current_user.is_authenticated:
return redirect(url_for('main.home'))
form = RequestResetForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
send_reset_email(user) # located in utils.py
flash('An email has been sent with instruction to reset your password', 'info')
return redirect(url_for('users.login'))
return render_template('reset_password_request.html', form=form) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_password_request():\n form = ResetPasswordRequestForm()\n if form.validate_on_submit():\n try:\n user = User.query.filter_by(email=form.email.data).first_or_404()\n except Exception:\n flash('This Email ID is Not Registered', 'error')\n return render_t... | [
"0.7280214",
"0.7197617",
"0.7117962",
"0.7043637",
"0.704304",
"0.6989297",
"0.6984096",
"0.69258046",
"0.6875457",
"0.6868493",
"0.6868304",
"0.6856506",
"0.6787877",
"0.6750242",
"0.67212576",
"0.6699849",
"0.66945165",
"0.66842115",
"0.6680731",
"0.66321975",
"0.6630563",... | 0.7324574 | 0 |
Routes handling reset password token (logic is coded in models.py), if token is valid user has chance to change his password and that change is committed to database, but when token is not valid or expired note is rendering to user | def reset_token(token):
if current_user.is_authenticated:
return redirect(url_for('users.home'))
user = User.verify_secret_token(token)
if user is None:
flash('That is invalid or expired token', 'warning')
return redirect(url_for('users.reset_password'))
form = ResetPasswordForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')
user.password = hashed_password
db.session.commit()
return redirect(url_for('users.login'))
return render_template('reset_token.html', form=form) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def password_resetenter(request, uidb64=None, token=None):\n\n\tcontext_dict = {}\n\tif request.method == 'POST':\n\t\tassert uidb64 is not None and token is not None\n\t\tuid = urlsafe_base64_decode(uidb64)\n\t\tuser = models.Teacher.objects.get(\n\t\t\tsoft_delete=False, pk=uid\n\t\t)\n\t\tdb_user = user.user\n\... | [
"0.77497625",
"0.7739758",
"0.7730872",
"0.77258337",
"0.76405317",
"0.75555956",
"0.74249434",
"0.7417758",
"0.7381122",
"0.7303035",
"0.7288763",
"0.72742236",
"0.7218797",
"0.713395",
"0.7124694",
"0.70419747",
"0.69283503",
"0.6910953",
"0.69020367",
"0.6885189",
"0.68811... | 0.73993194 | 8 |
Everything important about the chip | def __init__(self, channel=None, bpe=None, reservoir=None, electrodes=None, fluid_handling_system=None,
material_in_optical_path=None, thickness_in_optical_path=None):
#self.material = material # deprecated so the channel class can hold this information
self.channel = channel
self.bpe = bpe
self.electrodes = electrodes
self.fluid_handling_system = fluid_handling_system
self.material_in_optical_path = material_in_optical_path
self.thickness_in_optical_path = thickness_in_optical_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n ChipData.ChipData.__init__(self)",
"def read_chip_info(self):\n return [self.read_chip_type(), self.read_chip_revision()]",
"def support(self):",
"def show(self):\n # Disable IRQ to improve speed\n with NoIRQ():\n for chip in range(NB_CHIPS):\n ... | [
"0.67811126",
"0.6066584",
"0.5964433",
"0.59339035",
"0.589296",
"0.58123773",
"0.58010674",
"0.57554996",
"0.5728705",
"0.56449646",
"0.56439716",
"0.56414634",
"0.56379575",
"0.56379575",
"0.5594598",
"0.55358076",
"0.5497361",
"0.54925936",
"0.5483349",
"0.5473763",
"0.54... | 0.0 | -1 |
Everything important about the chip | def __init__(self, length=None, width=None, height=None,
material_bottom_wall_surface=None, material_top_wall_surface=None, material_fluid=None):
self.length = length
self.width = width
self.height = height
self.material_bottom_wall_surface = material_bottom_wall_surface # material should only hold relevant electrokinetic data
self.material_top_wall_surface = material_top_wall_surface # material should only hold relevant elect
self.material_fluid = material_fluid # could be a mixture of liquid materials + fluorescent particles | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n ChipData.ChipData.__init__(self)",
"def read_chip_info(self):\n return [self.read_chip_type(), self.read_chip_revision()]",
"def support(self):",
"def show(self):\n # Disable IRQ to improve speed\n with NoIRQ():\n for chip in range(NB_CHIPS):\n ... | [
"0.67811126",
"0.6066584",
"0.5964433",
"0.59339035",
"0.589296",
"0.58123773",
"0.58010674",
"0.57554996",
"0.5728705",
"0.56449646",
"0.56439716",
"0.56414634",
"0.56379575",
"0.56379575",
"0.5594598",
"0.55358076",
"0.5497361",
"0.54925936",
"0.5483349",
"0.5473763",
"0.54... | 0.0 | -1 |
Everything important about the chip | def __init__(self, length=None, width=None, height=None, material=None, adhesion_material=None,
dielectric_coating=None):
self.length = length
self.linspace_x = np.linspace(-length/2, length/2, num=100)
self.width = width
self.height = height
self.material = material
if self.material.thickness:
if self.material.thickness != self.height:
raise ValueError("BPE height must equal BPE material thickness")
# adhesion layer used for thin metal film BPE
self.adhesion_material = adhesion_material
# dielectric coating on top of BPE
if dielectric_coating:
self.dielectric_coating = dielectric_coating
else:
self.dielectric_coating = material_solid(name='no_dielectric', permittivity=1, thickness=1e-12, Ka=6, Kb=2, reaction_site_density=5) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n ChipData.ChipData.__init__(self)",
"def read_chip_info(self):\n return [self.read_chip_type(), self.read_chip_revision()]",
"def support(self):",
"def show(self):\n # Disable IRQ to improve speed\n with NoIRQ():\n for chip in range(NB_CHIPS):\n ... | [
"0.67811126",
"0.6066584",
"0.5964433",
"0.59339035",
"0.589296",
"0.58123773",
"0.58010674",
"0.57554996",
"0.5728705",
"0.56449646",
"0.56439716",
"0.56414634",
"0.56379575",
"0.56379575",
"0.5594598",
"0.55358076",
"0.5497361",
"0.54925936",
"0.5483349",
"0.5473763",
"0.54... | 0.0 | -1 |
details about the optical setup | def __init__(self, basePath=None, source=None, excitation=None, emission=None, dichroic=None, illumination_distribution=None,
calculate_illumination_distribution=False,
illumPath=None, illumSavePath=None, illumSaveName=None, showIllumPlot=False, save_txt=False, save_plot=False, save_image=False):
self.basePath = basePath # this should come from CurlypivTestCollection
self.source = source
self.excitation_wavelength = excitation
self.emission_wavelength = emission
self.dichroic = dichroic
if illumination_distribution is not None:
self.illumination_distribution = illumination_distribution
elif illumPath is not None:
flatfield = io.imread(illumPath, plugin='tifffile')
if len(np.shape(flatfield)) > 2:
flatfield = np.asarray(np.rint(np.mean(flatfield, axis=0)), dtype='uint16')
self.illumination_distribution = flatfield
elif calculate_illumination_distribution and illumination_distribution is None:
self.illumination_distribution = measureIlluminationDistributionXY(basePath=self.basePath, illumPath=illumPath,
show_image=showIllumPlot, save_image=save_image, save_img_type='.tif',
save_txt=save_txt, show_plot=showIllumPlot, save_plot=save_plot,
savePath=illumSavePath, savename=illumSaveName)
else:
self.illumination_distribution = illumination_distribution
self.flatfield = self.illumination_distribution
if self.flatfield is not None:
self.flatfield_mean = np.mean(self.flatfield)
self.flatfield_std = np.std(self.flatfield) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_help(self):\r\n\t\ttext = \"\\tName: ml_scikit_OPTICS\"\r\n\t\ttext += \"\\n\\t\\tThis machine learning plugin uses scikit-learn's OPTICS algorithm.\\n\"\r\n\t\ttext += \"\\n\\t\\tOptional Parameters:\"\r\n\t\ttext += \"\\n\\t\\t\\tOPTICS_skip_normalization: Do NOT perform normalization (scaling) of dat... | [
"0.6185093",
"0.60498106",
"0.60332525",
"0.6013268",
"0.59627753",
"0.592616",
"0.5911552",
"0.58811486",
"0.58507645",
"0.58053464",
"0.5802036",
"0.5802036",
"0.5802036",
"0.5802036",
"0.57227117",
"0.56944853",
"0.56828725",
"0.56805164",
"0.5645888",
"0.56457156",
"0.564... | 0.0 | -1 |
details about dark field image | def __init__(self, basePath, darkframePath=None, flip_image_across_axis=None, show_image=False, save_image=False, save_img_type='.tif',
savePath=None, savename=None, save_plot=False):
self.basePath = basePath
img, mean, std = calculate_darkfield(self.basePath, darkframePath=darkframePath, flip_image_axes=flip_image_across_axis, show_image=show_image, save_image=save_image, save_img_type=save_img_type,
savePath=savePath, savename=savename, save_plot=save_plot)
self.img = img
self.mean = mean
self.std = std | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dark(s='dark'):\n s = s.strip()[:80] #truncate to 80 char to fit in FITS header\n print camera.SetShutter(2)\n camera.status.imgtype = 'DARK'\n camera.status.object = s\n camera.status.update()",
"def im_show(image_path):\n img = cv.imread(image_path, cv.IMREAD_ANYDEPTH)\n cv.namedWindo... | [
"0.6423711",
"0.6173894",
"0.6126788",
"0.61006874",
"0.60167235",
"0.5981014",
"0.58750916",
"0.5868398",
"0.58221865",
"0.57751364",
"0.57402325",
"0.567587",
"0.56675595",
"0.566325",
"0.5617019",
"0.55742323",
"0.5573085",
"0.5560732",
"0.5554698",
"0.5546894",
"0.5545018... | 0.57655007 | 10 |
describes the micrscope setup | def __init__(self, type, objective, illumination, ccd):
self.type = type # e.g. Olympus iX73
self.objective = objective
self.illumination = illumination
self.ccd = ccd | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n p... | [
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6309029",
"0.6301397",
"0.6280084",
"0.62563354",
"0.6255936",
"0.6254392",
"0.62412417",
"0.6226122",
"0.6226122",
... | 0.0 | -1 |
describe the CCD class | def __init__(self, exposure_time, img_acq_rate, EM_gain, name='iXon Ultra 897', img_acq_type='emcdd', darkfield=None, binning=None,
vertical_pixel_shift_speed=0.5e-6, horizontal_pixel_shift_speed=0.1e-6, horizontal_pixel_shift_rate_bits=14,
frame_transfer=True, crop_mode=False, acquisition_mode='kinetic', triggering='internal', readout_mode='image',
pixels=512, pixel_size=16e-6):
self.name = name
self.img_acq_type = img_acq_type
self.exposure_time = exposure_time
self.img_acq_rate = img_acq_rate
self.em_gain = EM_gain
self.darkfield = darkfield
self.binning = binning
# supporting camera acquisition settings
self.vpss = vertical_pixel_shift_speed
self.hpss = horizontal_pixel_shift_speed
self.hpss_bits = horizontal_pixel_shift_rate_bits
self.frame_transfer = frame_transfer
self.crop_mode = crop_mode
self.acquisition_mode = acquisition_mode
self.triggering = triggering
self.readout_mode = readout_mode
if isinstance(pixels, int):
self.pixels = (pixels, pixels)
else:
self.pixels = pixels
self.pixel_size = pixel_size
self.image_area = (self.pixels[0]*pixel_size, self.pixels[1]*pixel_size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def describe(self) -> str:",
"def describe(self):\n raise NotImplementedError()",
"def describe(self):\n raise NotImplementedError()",
"def description(self):\n return '%s and a CD' % self.component.description()",
"def describe(self):\n print(self.description)",
"def describe... | [
"0.6843358",
"0.68146247",
"0.68146247",
"0.671449",
"0.66597164",
"0.66597164",
"0.6572881",
"0.6530383",
"0.6361396",
"0.6335927",
"0.6335927",
"0.6249203",
"0.6237307",
"0.6237307",
"0.6230096",
"0.6198816",
"0.61736053",
"0.6132944",
"0.6123131",
"0.6112898",
"0.6087091",... | 0.0 | -1 |
this class holds images for the microgrid and performs pixel to micron scaling calculations | def __init__(self, gridPath=None, center_to_center_spacing=None, feature_width=None, grid_type='grid', show_grid=False):
if gridPath is not None:
self.gridPath = gridPath
self.spacing = center_to_center_spacing
self.width = feature_width
self.grid_type = grid_type
# find files in directory
file_list = glob.glob(join(self.gridPath, 'grid*.tif'))
if len(file_list) < 1:
raise ValueError("No grid*.tif files found in {}".format(self.gridPath))
img_grid = np.zeros(shape=(512,512))
for f in file_list:
img = io.imread(f, plugin='tifffile')
if len(np.shape(img)) > 2:
img = np.mean(img, axis=0)
img_grid += img
img_grid = img_grid / len(file_list)
self.img_grid = img_grid
if show_grid is True:
fig, ax = plt.subplots()
ax.imshow(img_grid, cmap='gray')
ax.set_xlabel('pixels')
ax.set_ylabel('pixels')
plt.title('grid: 10 um Lines; 50 um Spacing')
plt.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n #calculate platescale of first input image\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.cd)\n pscale = np.sqrt(np.abs(det))*3600.\n except:\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.pc)\n ... | [
"0.69724894",
"0.6320908",
"0.63168067",
"0.6197034",
"0.61356825",
"0.60902923",
"0.60631675",
"0.6053572",
"0.6046153",
"0.60447425",
"0.6000556",
"0.5958693",
"0.5948496",
"0.59227127",
"0.59221554",
"0.59041744",
"0.5895156",
"0.5886209",
"0.58859426",
"0.58822227",
"0.58... | 0.0 | -1 |
the details of the fluroescent particles used | def __init__(self, name=None, materials=None,diameter=None,fluorescence_spectra=None, concentration=None,
electrophoretic_mobility=None, zeta=None):
self.name = name
self.materials=materials
self.concentration=concentration
self.electrophoretic_mobility=electrophoretic_mobility
self.zeta=zeta
self.diameter=diameter
if diameter:
k_b = 1.3806e-23
T=298
mu=0.001
self.diffusivity = k_b*T/(6*np.pi*mu*diameter/2)
self.fluorescence_spectra=fluorescence_spectra | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, particles):\n self.particles = particles",
"def __len__(self):\n return self.nparticles",
"def particles(self):\n if self.data_section is None:\n return None\n data_keys = self.data_section.keys()\n if bool(data_keys)==False:\n return ... | [
"0.62281686",
"0.6164579",
"0.6101659",
"0.6095347",
"0.6041156",
"0.6022373",
"0.59413975",
"0.5927904",
"0.5923357",
"0.59131575",
"0.5900847",
"0.5889833",
"0.5871284",
"0.58277595",
"0.5819351",
"0.5806105",
"0.57995564",
"0.5764965",
"0.5761083",
"0.5722828",
"0.56739026... | 0.0 | -1 |
describes the micrscope setup | def __init__(self, diameter, height, height_of_reservoir=None, material=None):
g = 9.81 # m/s**2
self.material = material
self.diameter = diameter
self.height = height
self.volume = np.pi*self.diameter**2/4
self.height_of_reservoir = height_of_reservoir
if material and height_of_reservoir:
self.hydrostatic_pressure = material.density*g*self.height_of_reservoir | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n pass",
"def setup(self):\n p... | [
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6317719",
"0.6309029",
"0.6301397",
"0.6280084",
"0.62563354",
"0.6255936",
"0.6254392",
"0.62412417",
"0.6226122",
"0.6226122",
... | 0.0 | -1 |
describes the fluid handling system | def __init__(self, fluid_reservoir=None, all_tubing=None, onchip_reservoir=None):
self.fluid_reservoir=fluid_reservoir
self.all_tubing = all_tubing
self.onchip_reservoir = onchip_reservoir | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def system_fleet_dimensioning(self):",
"def define_forms(self):\n\n # Define UFL objects corresponding to the local acceleration\n # if problem is unsteady.\n self.define_ufl_local_inertia()\n self.define_ufl_local_inertia_diff()\n\n # Define UFL objects corresponding to the co... | [
"0.55242515",
"0.5524179",
"0.5290922",
"0.52189064",
"0.51642203",
"0.5117331",
"0.5084165",
"0.50247896",
"0.49878523",
"0.49760827",
"0.49751097",
"0.49734625",
"0.49661058",
"0.4918144",
"0.49163127",
"0.49124214",
"0.4886242",
"0.4886242",
"0.48820427",
"0.48705277",
"0.... | 0.0 | -1 |
describes each segment of tubing | def __init__(self, inner_diameter=None, length=None, material=None):
self.inner_diameter = inner_diameter
self.length = length
self.material = material | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def segment(data):",
"def info(self):\n c = 0\n for s in self.segments:\n c+= len(s.points)\n return \"Nodes : %5i\\nSegments : %5i\\nPoints : %5i\" % (len(self.nodes), len(self.segments), c)",
"def test_getting_segments(self):\n pass",
"def _get_seg_repr(self, se... | [
"0.65298843",
"0.6119681",
"0.5801361",
"0.57355803",
"0.573119",
"0.56613064",
"0.56600964",
"0.55376303",
"0.5510109",
"0.5501271",
"0.5472551",
"0.5463381",
"0.5461672",
"0.5427262",
"0.5396404",
"0.5374486",
"0.5335036",
"0.5311621",
"0.53089184",
"0.5294616",
"0.52887076... | 0.0 | -1 |
this class describes the optical characteristics of any material or element | def __init__(self, passing_wavelengths=None, reflectivity=None):
self.passing_wavelengths=passing_wavelengths
self.reflectivity=reflectivity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAllAttribute(self):\n\n self.shape_type = OpenMaya.MPlug(self.thisObj, self.iShapeType).asShort()\n self.draw_type = OpenMaya.MPlug(self.thisObj, self.iDrawingType).asShort()\n self.up_axis = OpenMaya.MPlug(self.thisObj, self.iUpAxis).asShort()\n self.xRay = OpenMaya.MPlug(self.t... | [
"0.6058424",
"0.5873271",
"0.5822662",
"0.57114613",
"0.5669548",
"0.5591406",
"0.55108035",
"0.5495015",
"0.54344803",
"0.54193187",
"0.5389301",
"0.5373029",
"0.5358729",
"0.5333054",
"0.5332131",
"0.5322646",
"0.53215945",
"0.5312435",
"0.52957547",
"0.52953637",
"0.529432... | 0.0 | -1 |
what value was measured and when | def __init__(self, reference_value=None, measured_value=None):
self.reference_value = reference_value
self.measured_value = measured_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_stat_values(self):",
"def measure(self):\n pass",
"def observation_value(self):\n pass",
"def state(self):\n return self._measure",
"def t_measure_estimate(self):\n ho = self.humidity_oversampling\n to = self.temperature_oversampling\n po = self.pressure_overs... | [
"0.66767734",
"0.6539252",
"0.64366204",
"0.6429938",
"0.64134157",
"0.63915974",
"0.63749766",
"0.6278977",
"0.6275547",
"0.61454076",
"0.61454076",
"0.61454076",
"0.61224276",
"0.6064027",
"0.6003514",
"0.59992427",
"0.59715676",
"0.5941743",
"0.58559453",
"0.58508056",
"0.... | 0.0 | -1 |
Object for storing measurements | def __init__(self, value=None, date=None):
self.value = value
self.date = date | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def measurements(self) -> NONEARRAY:\n pass",
"def measurements(self):\n return self._measurements",
"def measurements(self):\n return self.config['measurements']",
"def getMeasures():",
"def getMeasurements(self):\n return self._Measurements",
"def _measure():\n return {\n... | [
"0.7203409",
"0.6870602",
"0.68244916",
"0.6779195",
"0.6685213",
"0.6621161",
"0.65731907",
"0.6567633",
"0.656311",
"0.65522236",
"0.653955",
"0.65327895",
"0.6467614",
"0.6393451",
"0.6393451",
"0.63583064",
"0.6340271",
"0.6315247",
"0.6288799",
"0.62670773",
"0.62450945"... | 0.0 | -1 |
Object for holding electrode configuration details | def __init__(self, material=None, length=None, entrance_length=None):
self.material = material
self.length = length
self.entrance_length = entrance_length | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def configuration():",
"def config(self):\n raise NotImplementedError",
"def _est_config(self):\n return self._est_method.config",
"def config(self):\n pass",
"def config(self):\n pass",
"def config(self):\n return None",
"def get_config(self):\n return {\"name... | [
"0.70692134",
"0.6935257",
"0.6863148",
"0.68504906",
"0.68504906",
"0.68297553",
"0.6823189",
"0.6751167",
"0.6721291",
"0.6666818",
"0.65857863",
"0.65857863",
"0.6573653",
"0.6544272",
"0.65333617",
"0.65164155",
"0.6505307",
"0.65036625",
"0.64881974",
"0.64446115",
"0.64... | 0.0 | -1 |
everything about a material | def __init__(self, name=None, zeta=None, concentration=None, index_of_refraction=None, transparency=None, fluorescence_spectra=None,
permittivity=None, conductivity=None, thickness=None, youngs_modulus=None, poissons_ratio=None,
density=None, dielectric_strength=None, reaction_site_density=None, Ka=None, Kb=None, width=None, length=None):
# identity
self.name = name
# geometry
self.length = length
self.width = width
self.thickness = thickness
# mechanical
self.density = density
self.concentration = concentration # For a solid, this is % by volume.
self.youngs_modulus = youngs_modulus
self.poissons_ratio = poissons_ratio
# optical
self.index_of_refraction = index_of_refraction
self.fluorescence_spectra = fluorescence_spectra
self.transparency = transparency
if self.transparency:
self.reflectivity = 1 / self.transparency
# electrochemical
self.conductivity = conductivity
if permittivity:
self.permittivity = permittivity
self.zeta = zeta
self.dielectric_strength = dielectric_strength
if reaction_site_density:
self.reaction_site_density = reaction_site_density*1e18 # (#/nm2) surface density of reaction sites: accepts nm2 and converts to m2 (see Squires)
self.Ka = Ka # reaction equilibrium constant - upper bound
self.Kb = Kb # reaction equilibrium constant - lower bound | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def material(self):\n return self._F_Mstr",
"def show_materials(self):\n print('\\nThe materials with known dielectric properties are:\\n')\n pprint.pprint(mats.Electrical.props)\n# pprint.pprint(mats.Electrical.DIELECTRIC)\n print('\\nThe materials with known loss tangents ar... | [
"0.70637417",
"0.6998246",
"0.6904607",
"0.6898203",
"0.6760521",
"0.6738587",
"0.66976964",
"0.663665",
"0.65911734",
"0.6587051",
"0.6576873",
"0.6487353",
"0.64594245",
"0.63723415",
"0.6360623",
"0.63506037",
"0.63310814",
"0.631915",
"0.62650704",
"0.62001616",
"0.619735... | 0.0 | -1 |
everything about a liquid | def __init__(self, name=None, species=None, concentration=None, conductivity=None, pH=None, density=None, viscosity=None,
permittivity=None, temperature=None, valence=1.0):
# identity
self.name = name
# electro/chemical
self.species = species
self.concentration = concentration # (mmol) = (mmol/L) = (mol/m3)
self.conductivity = conductivity
if permittivity:
self.permittivity = permittivity
if pH:
self.pH = pH
self.c_H = 10**-pH * 1e3 # (mmol) = (mmol/L) = (mol/m3); (concentration of Hydrogen ions (H+)
self.valence = valence
# mechanical
self.density = density
self.viscosity = viscosity
self.temperature = temperature
self.diffusivity = 2e-9 # (m^2/s) Diffusivity of KCl in DI water [Soni] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_received_liquidation(self, liquidation):\n pass",
"def liquid_viscosity(id, temperature=298.15, pressure=constants.atm): # noqa: A002\n return rx._misc._get_chemical(id, temperature, pressure).mul # noqa: SLF001",
"def vault(self):",
"def main():\n ## real SWAT tags",
"def capteur_inf... | [
"0.5671805",
"0.5175566",
"0.5175554",
"0.516426",
"0.50640386",
"0.50614387",
"0.50591075",
"0.49937275",
"0.4983017",
"0.49820462",
"0.49783403",
"0.49738714",
"0.49507678",
"0.4948753",
"0.4924024",
"0.48813003",
"0.4849777",
"0.48445272",
"0.483933",
"0.48176083",
"0.4808... | 0.0 | -1 |
Telt de lijst op. | def som(getallenlijst):
total = sum(getallenlijst)
return total | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _ltz(self):\n raise NotImplementedError(\"_ltz is not implemented\")",
"def LDLT(self):\n\t\tpass",
"def l_un_degenerate(self):\n self.right = self.tmp",
"def l_degenerate(self):\n self.tmp = self.right\n self.right = self.left",
"def tilt(self) -> int:",
"def dl2(vec):\n ... | [
"0.54447126",
"0.53171045",
"0.53147423",
"0.5244896",
"0.5144233",
"0.51063067",
"0.50482875",
"0.5036076",
"0.49402636",
"0.49142268",
"0.49142268",
"0.48477957",
"0.48162255",
"0.47698143",
"0.47529215",
"0.47407043",
"0.47301647",
"0.46932566",
"0.46881244",
"0.46654546",
... | 0.0 | -1 |
Tests that 1 + 1 always equals 2. | def test_basic_addition(self):
self.assertEqual(1 + 1, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_sanity(self):\n self.assertEquals(2 + 2, 4)",
"def test_basic_addition(self):\n self.failUnlessEqual(1 + 1, 2)",
"def test_basic_addition(self):\n self.failUnlessEqual(1 + 1, 2)",
"def test_basic_addition(self):\n self.failUnlessEqual(1 + 1, 2)",
"def test_basic_additio... | [
"0.700804",
"0.69351697",
"0.69351697",
"0.69351697",
"0.688757",
"0.688757",
"0.666264",
"0.64881384",
"0.64450884",
"0.64153033",
"0.6410425",
"0.6410405",
"0.6379688",
"0.6379688",
"0.63732797",
"0.6352445",
"0.6350113",
"0.6348631",
"0.6348631",
"0.6348631",
"0.6348631",
... | 0.63992167 | 31 |
Test the flow for 3.6 and up, async generators are not supported in 3.5. | async def test_tornado_list_tables(self):
tables = self.r.table_list().run(self.conn)
assert isinstance(tables, list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def test2(self):\n return True",
"def test_future_event(self):\n pass",
"def test_annotated_async_from_coro(dut):\n v = yield produce.async_annotated(Value(1))\n assert v == 1\n\n try:\n yield produce.async_annotated(Error(SomeException))\n except SomeException:\n... | [
"0.61319363",
"0.59815097",
"0.5970306",
"0.5963432",
"0.59373856",
"0.58596766",
"0.58034384",
"0.5793992",
"0.5694973",
"0.56823844",
"0.5653525",
"0.5652958",
"0.56505305",
"0.5636267",
"0.55687475",
"0.5558097",
"0.54776096",
"0.5461566",
"0.54609054",
"0.5459655",
"0.545... | 0.0 | -1 |
Returns pandas dataframe which has latest record for each manual id after merging all "sheet_name" in the previously indexed_files which are present in "indexed_files_dir" | def zeta0_creation(self, indexed_files_dir, merge_columns):
indexed_files = [file for file in os.listdir(indexed_files_dir) if not file.startswith("~")]
indexed_files_dict = {}
indexed_files_dict.clear()
dateList = []
del dateList[:]
for file in indexed_files:
dated = file.split('_')[-1].split('.')[0]
dated = dated[4:] + dated[:4]
dateList.append(dated)
indexed_files_dict[dated] = file
dataframes = {}
for dated, file in indexed_files_dict.items():
file_name = indexed_files_dir + '\\' + file
dataframes[dated] = pd.read_excel(file_name, sheet_name=0)
dataframes[dated]['file_date'] = dated
dataframes[dated]['mid'] = [int(elem.split('_')[-1]) for elem in dataframes[dated]['manual_id']]
merged_df = pd.concat([dataframes[dated] for dated in dateList], ignore_index=True)
merged_df = merged_df.sort_values('file_date', ascending=False)
zeta0 = merged_df.drop_duplicates(subset='manual_id', keep='first')
pd.set_option('mode.chained_assignment', None)
for col in zeta0.columns:
zeta0[col] = zeta0[col].astype('str')
zeta0 = zeta0.apply(lambda x: x.str.strip() if x.dtype == "object" else x)
zeta0 = zeta0.sort_values('mid', ascending=True)
if "manual_id" not in merge_columns:
merge_columns.append("manual_id")
zeta0 = zeta0[merge_columns]
# print(zeta0)
return zeta0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_walkupseq_files(latest_tsca_id):\n paths = glob.glob('walkupseq_files/*sample_info*')\n\n dfs = []\n for f in paths:\n tmp = pd.read_table(f, encoding='latin1')\n dfs.append(tmp)\n\n df = pd.concat(dfs, axis=0)\n df.to_csv('walkupseq_files/walkupseq_all_combined_%s.txt'%lates... | [
"0.5289423",
"0.52650183",
"0.52591753",
"0.52265924",
"0.51847774",
"0.5076782",
"0.5037608",
"0.50096446",
"0.5009643",
"0.5001173",
"0.4953621",
"0.494462",
"0.493642",
"0.49348438",
"0.49298787",
"0.48461",
"0.48410356",
"0.48382828",
"0.4834661",
"0.48010856",
"0.4796004... | 0.63463265 | 0 |
Attempts to parse a surt string into its component parts. | def __init__(self, surt):
self._surt = surt
try:
self.protocol, surt = surt.split('://(')
except ValueError:
self.protocol = surt
surt = ''
try:
self.domain, surt = surt.split('/', 1)
except ValueError:
self.domain = surt
surt = ''
try:
self.path, surt = surt.split('?')
except ValueError:
self.path = surt
self.query = ''
surt = ''
try:
self.query, self.hash = surt.split('#')
except ValueError:
if surt != '':
self.query = surt
self.hash = ''
surt = ''
if self.path:
self.path_parts = self.path.split('/')
self.path_parts = [part for part in self.path_parts if part != '']
else:
self.path_parts = []
if self.domain:
self.domain_parts = self.domain.replace(')', '').split(',')
self.domain_parts = [
part for part in self.domain_parts if part != '']
else:
self.domain_parts = []
self.parts = []
self.parts.append(self.protocol + '://(')
for domain_part in self.domain_parts:
self.parts.append('{},'.format(domain_part))
self.parts[-1] = '{})'.format(self.parts[-1])
for path_part in self.path_parts:
self.parts.append('/{}'.format(path_part))
self.parts.append(self.query)
self.parts.append(self.hash)
self.parts = [part for part in self.parts if part != ''] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse(s):\n return s",
"def parseString(self, s):\n pass",
"def parse(cls, s):\n raise NotImplementedError",
"def parse_string(self, in_str):\n match = MAIN_REGEX.search(in_str)\n if not match:\n err_str = \"Unable to parse string: %s\" % in_str\n ... | [
"0.60741115",
"0.60195297",
"0.59897935",
"0.5646392",
"0.5526063",
"0.5425705",
"0.5401909",
"0.5301537",
"0.52829874",
"0.52163225",
"0.5190413",
"0.5171466",
"0.5171442",
"0.5124075",
"0.50967103",
"0.5088532",
"0.5067676",
"0.50537384",
"0.50519437",
"0.50450486",
"0.5031... | 0.55399895 | 4 |
UCB1 algorithm ucb1 = winrate + sqrt(2lnn / ni) | def ucbScore(self,totalPlayedTimes):
winRate = self.winRate()
#print totalPlayedTimes
#print self.playedTimes
confidenceInterval = math.sqrt(2 * math.log(totalPlayedTimes,math.e) / self.playedTimes)
return winRate + confidenceInterval | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def algo_UCB(mu, Na):\n i = 0\n while i < Na.size:\n if Na[i] < 1:\n return i\n else:\n i+= 1\n t = Na.sum()\n return np.argmax(mu + np.sqrt(2*np.log(t)/Na))",
"def _ucb(self, s, k):\n if self.confidence_method == 'ucb-standard':\n ucb_factor = self._ucb_st... | [
"0.63876575",
"0.633093",
"0.6154798",
"0.6075605",
"0.5960223",
"0.58998066",
"0.58998066",
"0.5878511",
"0.582961",
"0.5794877",
"0.5789813",
"0.5785925",
"0.57034636",
"0.5690178",
"0.5688557",
"0.56797487",
"0.56768996",
"0.5637333",
"0.5628463",
"0.56043136",
"0.5594184"... | 0.55336875 | 25 |
Custom displayhook for the exec in default(), which prevents assignment of the _ variable in the builtins. | def displayhook(self, obj):
# reproduce the behavior of the standard displayhook, not printing None
if obj is not None:
print >> self.stdout, repr(obj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def displayhook(arg):\n if arg is not None:\n __builtin__._ = None\n print stringify_func(arg)\n __builtin__._ = arg",
"def __displayhook__(*args, **kwargs): # real signature unknown\n pass",
"def displayhook(p_object): # real signature unknown; restored from __doc__\... | [
"0.7744383",
"0.6542661",
"0.6142525",
"0.58426565",
"0.578165",
"0.5749669",
"0.55891895",
"0.55188674",
"0.550801",
"0.5497482",
"0.54949677",
"0.54631275",
"0.53636926",
"0.5337594",
"0.53103167",
"0.53094953",
"0.52910274",
"0.5272987",
"0.5272368",
"0.52542436",
"0.52296... | 0.56435174 | 6 |
Produce a reasonable default. | def defaultFile(self):
filename = _odb.getCurrentFrame().filename
if filename == '<string>' and self.mainpyfile:
filename = self.mainpyfile
return filename | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDefault():",
"def Default():\n return _DEFAULT",
"def default():",
"def f_default(self, default = 1) :\n pass",
"def default():\n return DefaultSwh.default()",
"def _defaulted(cls, value, default):\n return default if value is None else value",
"def default(str):\n ret... | [
"0.77582496",
"0.7588288",
"0.7476828",
"0.7380406",
"0.7205692",
"0.70597076",
"0.6892593",
"0.686635",
"0.68469757",
"0.6833807",
"0.67760617",
"0.67025155",
"0.6625156",
"0.65530145",
"0.65388095",
"0.65117794",
"0.65041345",
"0.64939255",
"0.64847153",
"0.64734393",
"0.64... | 0.0 | -1 |
Helper function for break/clear parsing may be overridden. lookupmodule() translates (possibly incomplete) file or module name into an absolute file name. | def lookupmodule(self, filename):
if os.path.isabs(filename) and os.path.exists(filename):
return filename
f = os.path.join(sys.path[0], filename)
if os.path.exists(f) and self.canonic(f) == self.mainpyfile:
return f
root, ext = os.path.splitext(filename)
if ext == '':
filename = filename + '.py'
if os.path.isabs(filename):
return filename
for dirname in sys.path:
while os.path.islink(dirname):
dirname = os.readlink(dirname)
fullname = os.path.join(dirname, filename)
if os.path.exists(fullname):
return fullname
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lookup_module(filename):\r\n\r\n # stolen from pdb\r\n import os\r\n import sys\r\n\r\n if os.path.isabs(filename) and os.path.exists(filename):\r\n return filename\r\n f = os.path.join(sys.path[0], filename)\r\n if os.path.exists(f): # and self.canonic(f) == self.mainpyfile:\r\n ... | [
"0.6935571",
"0.6808267",
"0.62503785",
"0.620861",
"0.60548043",
"0.5981422",
"0.59169036",
"0.58730257",
"0.58359164",
"0.5832401",
"0.58213973",
"0.5811231",
"0.5761079",
"0.5698767",
"0.5639836",
"0.5639836",
"0.56236005",
"0.55848193",
"0.5536372",
"0.5535091",
"0.550816... | 0.7024272 | 0 |
Pure implement of heap sort algorithm in Python | def heap_sort(collection):
n = len(collection)
for i in range(n // 2 - 1, -1, -1):
heapify(collection, i, n)
for i in range(n - 1, 0, -1):
collection[0], collection[i] = collection[i], collection[0]
heapify(collection, 0, i)
return collection | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def heap_sort(list):\n pass",
"def heap_sort(arr):\n if not isinstance(arr, list) or len(arr) == 0:\n return\n for i in range(len(arr) // 2 - 1, -1, -1):\n heapify(arr, i, len(arr))\n for i in range(len(arr) - 1, 0, -1):\n arr[0], arr[i] = arr[i], arr[0]\n heapify(arr, 0, ... | [
"0.82783955",
"0.8089301",
"0.8086552",
"0.8035019",
"0.8015355",
"0.7985793",
"0.7985793",
"0.7959204",
"0.7954446",
"0.7736345",
"0.7736345",
"0.7707003",
"0.77046126",
"0.77045786",
"0.7695088",
"0.7671767",
"0.76464075",
"0.7600847",
"0.75952286",
"0.7574346",
"0.7545443"... | 0.7628612 | 17 |
Wait n seconds before returning ok | def timeout(n):
time.sleep(int(n))
return 'ok', 200 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait(n=3):\n sleep(n)",
"def waitUntilSuccess():",
"def functionThatWillTimeOut():\n time.sleep(5)",
"def wait_for(test, timeout_seconds=DEFAULT_TIMEOUT):\n start = time.time()\n while True:\n if test():\n return True\n if time.time() - start > timeout_seconds... | [
"0.71733505",
"0.7147747",
"0.68212134",
"0.6718219",
"0.6702025",
"0.6661689",
"0.6661689",
"0.6661689",
"0.6635981",
"0.65762943",
"0.65646064",
"0.6553791",
"0.65345186",
"0.649197",
"0.6484155",
"0.64481616",
"0.6447762",
"0.6443559",
"0.6374297",
"0.63630664",
"0.6290266... | 0.8150463 | 0 |
/menu should return information about accesible menu elements | def test_normal(self, fake_app):
result = fake_app.get(self.url)
assert result.json == {
'menu': [{
'elements': [{
'is_active': False,
'name': 'not_logged_home',
'text': 'Home',
'url': '#/'
}],
'name':
'Menu'
}]
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_menu_items():\n\n pass",
"def get_menus():\n\n pass",
"def get_all_menu():",
"def get_menu(menu_name):\n\n pass",
"def present_menu (self, menu, groupName = 'main'):\n \n if not hasattr (cherrypy.request, 'nav'):\n cherrypy.request.nav = {}\n\n if not groupName in ch... | [
"0.76196367",
"0.75381",
"0.7521898",
"0.74221736",
"0.70497966",
"0.6988888",
"0.67294633",
"0.6726015",
"0.66863775",
"0.66313416",
"0.6611032",
"0.66060996",
"0.658206",
"0.6521646",
"0.6520005",
"0.6460026",
"0.63582134",
"0.6333034",
"0.6328714",
"0.63178813",
"0.6314692... | 0.0 | -1 |
/menu should return information about accesible menu elements for authenticated user | def test_authenticated_user(self, fake_app, authenticated_user, jwt):
result = fake_app.get(self.url, headers={'JWT': jwt})
assert result.json == {
'menu': [{
'elements': [{
'is_active': False,
'name': 'dashboard_home',
'text': 'Wallets',
'url': '#/dashboard'
}],
'name':
'Dashboard'
}]
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def menu():\n user_id = session[\"user_id\"]\n if not user_id:\n session.clear()\n redirect(\"/\")\n database = db.db_connect()\n user = g.user\n return render_template(\"menu.html\", username=user[\"username\"])",
"def get_menus():\n\n pass",
"def menu(self):\n menu = list()... | [
"0.71579736",
"0.7013057",
"0.69366163",
"0.6936209",
"0.6905796",
"0.6846141",
"0.6812014",
"0.6768968",
"0.67572683",
"0.67403543",
"0.67125106",
"0.65609455",
"0.6558285",
"0.65495783",
"0.6461598",
"0.64251655",
"0.6414871",
"0.640194",
"0.6364668",
"0.63646626",
"0.63447... | 0.0 | -1 |
Sample pytest test function with the pytest fixture as an argument. | def test_example(decorated_example):
import visual_coding_2p_analysis | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pytest(context):\n exec_cmd = \"pytest\"\n run_cmd(context, exec_cmd)",
"def pytest_generate_tests(metafunc):\n if \"retrospective\" in metafunc.fixturenames:\n metafunc.parametrize(\"retrospective\", [False, True])\n if \"test_type\" in metafunc.fixturenames:\n metafunc.parametrize... | [
"0.70208406",
"0.6849156",
"0.6716318",
"0.6693665",
"0.65544575",
"0.6513483",
"0.64935595",
"0.645806",
"0.64294404",
"0.6421675",
"0.6402381",
"0.6400902",
"0.63715297",
"0.63665515",
"0.63603586",
"0.6353915",
"0.6353915",
"0.6350933",
"0.6348224",
"0.6341979",
"0.6335460... | 0.0 | -1 |
int ploidy return all possible genotypes, completely determined by ploidy | def all_genotype(ploidy):
return ["".join(comb) for comb in cwr("ACGT-", ploidy)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def genotype(args) :\n from genotyper import genotype_samples\n genotype_samples(args)",
"def collapse_genotypes(pL,gL):\n if len(gL) < 2:\n return gL\n else:\n uniqueL = [] # list of unique genotypes relative to ploidy\n for g in gL:\n s = ''\n for i in xra... | [
"0.69029266",
"0.6711919",
"0.6711495",
"0.6549798",
"0.5954817",
"0.59225327",
"0.57624036",
"0.5698024",
"0.56348896",
"0.5612911",
"0.5511534",
"0.54864615",
"0.5481483",
"0.5451472",
"0.54416704",
"0.542101",
"0.5358761",
"0.5353916",
"0.53418523",
"0.53012073",
"0.529263... | 0.78792745 | 0 |
str genotype str base return P(base in genotype) | def prob_t_N(genotype, base):
cnter = Counter(genotype)
return cnter.get(base, 0) * 1/len(genotype) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_label(genotype_type):\n if genotype_type == \"Hom\":\n return 0\n elif genotype_type == \"Het\":\n return 1\n elif genotype_type == \"Hom_alt\":\n return 2",
"def all_genotype(ploidy):\n return [\"\".join(comb) for comb in cwr(\"ACGT-\", ploidy)]",
"def genotype(args) :... | [
"0.60589737",
"0.5741285",
"0.5715102",
"0.5583383",
"0.5533688",
"0.55254024",
"0.5489838",
"0.5393062",
"0.5336175",
"0.5331854",
"0.5328015",
"0.5308519",
"0.5293455",
"0.5247759",
"0.5218406",
"0.5206605",
"0.5196159",
"0.51130825",
"0.5110904",
"0.50777864",
"0.50563097"... | 0.5752146 | 1 |
str genotype iterableobj bases_all_reads, list or np.array return P(data|genotype) == likelihood | def likelihood_genotype(genotype, bases_all_reads, error_rates):
likelihood = 1
for observed_base in bases_all_reads:
p = 0
for base in "ACGT-":
l = prob_t_N(genotype, base) * error_rates[base][observed_base]
p += l
likelihood *= p
return likelihood | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def genotype(args) :\n from genotyper import genotype_samples\n genotype_samples(args)",
"def calculate_genotype_probabilities(self):\n for name, member in self.members.items():\n member.genotype_probabilities = self.genotype_probabilities_of(name)",
"def genotypes(self):\n retur... | [
"0.58311933",
"0.5258182",
"0.51413745",
"0.51239264",
"0.50704426",
"0.5054357",
"0.50419044",
"0.50068015",
"0.49709237",
"0.49687204",
"0.49641567",
"0.4958727",
"0.4943448",
"0.49398604",
"0.49218807",
"0.49215811",
"0.4891338",
"0.48754093",
"0.4873586",
"0.48568666",
"0... | 0.702063 | 0 |
The base exception class. | def __init__(self, error_msg):
super(SdkException, self).__init__()
self.error_msg = error_msg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exception(self, e):\n pass",
"def exception(self, *args, **kwargs):",
"def unexpectedException(self):",
"def WrappedException(self) -> object:",
"def throw(self):\n pass",
"def create_exception(self, msg: str):",
"def test_exception_class_hierarchy(self) -> None:\n\n try:\n ... | [
"0.71715826",
"0.71011615",
"0.6953176",
"0.6914926",
"0.6909566",
"0.6883063",
"0.68702894",
"0.67892045",
"0.6786502",
"0.678649",
"0.67474914",
"0.67397016",
"0.6701096",
"0.67004186",
"0.6674386",
"0.6668861",
"0.6599745",
"0.658252",
"0.65630275",
"0.6521229",
"0.6506521... | 0.6374392 | 32 |
The base exception class of connection exceptions. | def __init__(self, error_msg):
super(ConnectionException, self).__init__(error_msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, msg):\n\n super(DBConnectionError, self).__init__(msg)\n self.msg = msg",
"def _create_exception(self, pgres=None, msg=None, cursor=None):\n assert pgres is None or cursor is None, \\\n \"cannot specify pgres and cursor together\"\n\n if cursor and cursor... | [
"0.6604351",
"0.6386638",
"0.6341203",
"0.6303432",
"0.62695044",
"0.62493557",
"0.6177012",
"0.6173146",
"0.6118006",
"0.60822475",
"0.60723776",
"0.60721236",
"0.6066645",
"0.60590744",
"0.60276735",
"0.60103536",
"0.59800124",
"0.5904314",
"0.5867853",
"0.58674383",
"0.586... | 0.7421417 | 0 |
The base exception class of service response exceptions. | def __init__(self, status_code, sdk_error):
super(ServiceResponseException, self).__init__(sdk_error.error_msg)
self.status_code = status_code
self.error_code = sdk_error.error_code
self.request_id = sdk_error.request_id | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generic_service_exception(*args):\n exception_tuple = LambdaErrorResponses.ServiceException\n\n return BaseLocalService.service_response(\n LambdaErrorResponses._construct_error_response_body(LambdaErrorResponses.SERVICE_ERROR, \"ServiceException\"),\n LambdaErrorResponses._... | [
"0.6928329",
"0.6750525",
"0.649088",
"0.64422554",
"0.6438557",
"0.64162624",
"0.63747215",
"0.6354716",
"0.63448566",
"0.6343094",
"0.6330691",
"0.6311043",
"0.6306453",
"0.62536937",
"0.6228462",
"0.61860454",
"0.61826175",
"0.6169226",
"0.6168609",
"0.6157098",
"0.6143242... | 0.6739744 | 2 |
The base exception class of timeout exceptions. | def __init__(self, error_msg):
super(RequestTimeoutException, self).__init__(error_msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_timeout_elapsed_exception(self):\n deadline = Deadline(-MS)\n with self.assertRaises(TimeoutError):\n deadline.timeout()",
"def cancelled_exception_class(cls) -> type[BaseException]:",
"def test_wait_timeout_inheritance():\n # confirm subclassed from pypyr root error\n e... | [
"0.69130844",
"0.6805417",
"0.6787926",
"0.6741076",
"0.6446688",
"0.6242404",
"0.6146727",
"0.6146727",
"0.6110175",
"0.61099267",
"0.6053876",
"0.59915215",
"0.5957881",
"0.59220225",
"0.59039843",
"0.58413595",
"0.58341813",
"0.58033925",
"0.5766664",
"0.5763779",
"0.57505... | 0.6499626 | 4 |
Returns a string representation of a path | def render_path(path_to_item):
result = ""
for pth in path_to_item:
if isinstance(pth, six.integer_types):
result += "[{0}]".format(pth)
else:
result += "['{0}']".format(pth)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def path_str(path):\n\toutput = \"PATH: \"\n\tif path:\n\t\tfor i in path:\n\t\t\toutput += str(i.data) + \" -> \"\n\telse:\n\t\toutput += \"Empty\"\n\treturn output",
"def path_to_str(path):\n if hasattr(path, '__fspath__'):\n path = as_str_any(path.__fspath__())\n return path",
"def as_string(pa... | [
"0.79950243",
"0.77772427",
"0.76012766",
"0.75008774",
"0.7465539",
"0.73858505",
"0.724589",
"0.7177473",
"0.71564364",
"0.70764357",
"0.70681226",
"0.70649594",
"0.70468634",
"0.70299315",
"0.6943011",
"0.69423383",
"0.6906489",
"0.6906489",
"0.69057655",
"0.68910974",
"0.... | 0.0 | -1 |
Raises an exception for TypeErrors | def __init__(self, msg, path_to_item=None, valid_classes=None,
key_type=None):
self.path_to_item = path_to_item
self.valid_classes = valid_classes
self.key_type = key_type
full_msg = msg
if path_to_item:
full_msg = "%s at %s" % (msg, render_path(path_to_item))
super(ApiTypeError, self).__init__(full_msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_type_error(self):\n self._error_test(TypeError)",
"def test__specification_type_to_python_type_unsupported_type(self):\n with self.assertRaises(TypeError):\n _specification_type_to_python_type(\"unsupported_type\")",
"def throw(self, type, value=None, traceback=None):\n ... | [
"0.80643433",
"0.7329728",
"0.72639966",
"0.7262278",
"0.7229491",
"0.72008634",
"0.71786124",
"0.6970523",
"0.6896439",
"0.688244",
"0.6782924",
"0.6753176",
"0.67404634",
"0.6738435",
"0.67235684",
"0.66774726",
"0.6669857",
"0.6658878",
"0.6629325",
"0.6617021",
"0.6593539... | 0.0 | -1 |
Reloads the Polls file. | def reloadpolls(self, irc, msg, args):
try:
self.polls = yaml.load(open(self.pollFile, 'r'), Loader=yamlordereddictloader.Loader)
except FileNotFoundError as e:
log.warning("Couldn't open file: %s" % e)
raise | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reloadfile(self, ):\n self.loadfile()",
"def refresh(self):\n self.config.read(self.filename)\n self.loadRecentFiles()",
"def reload(self):\n puts('Reloading application...')\n local('touch ../reload.txt')",
"def reload(self):\n\n pass",
"def reload(self):",
... | [
"0.74811375",
"0.6804164",
"0.6666194",
"0.66235316",
"0.65775543",
"0.65775543",
"0.65237594",
"0.64763457",
"0.6454685",
"0.6289295",
"0.62368816",
"0.6080593",
"0.6055079",
"0.60324496",
"0.5997774",
"0.5995909",
"0.59953433",
"0.5965536",
"0.5963405",
"0.59284127",
"0.589... | 0.7334716 | 1 |
Lists current polls. For a breakdown via statuses, see ' Vote votes' | def listpolls(self, irc, msg, args, channel):
if channel and msg.args[0] in irc.state.channels:
if self.polls is None:
self.polls = []
if self.polls is []:
irc.reply("No Polls.")
for idx, entry in enumerate(self.polls[channel]):
entry_string = []
question = entry['question']
yays = entry['yays']
nays = entry['nays']
added_by = entry['added_by']
# concluded = entry['concluded']
entry_string.append("%d: %s" % (idx, question))
entry_string.append("Yes: %s" % (' '.join(yays) if yays != [] else 'none'))
entry_string.append("No: %s" % (' '.join(nays) if nays != [] else 'none'))
entry_string.append("Question asked by %s" % added_by)
irc.reply(' / '.join(entry_string), notice=True, private=True, prefixNick=False)
else:
try:
if ircdb.checkCapability(msg.prefix, 'admin') or ircdb.checkCapability(msg.prefix, 'owner'):
if self.polls is None:
self.polls = []
if self.polls is []:
irc.reply("No Polls.")
for idx, entry in enumerate(self.polls[channel]):
entry_string = []
question = entry['question']
yays = entry['yays']
nays = entry['nays']
added_by = entry['added_by']
# concluded = entry['concluded']
entry_string.append("%d: %s" % (idx, question))
entry_string.append("Yays: %s" % (' '.join(yays) if yays != [] else 'none'))
entry_string.append("Nays: %s" % (' '.join(nays) if nays != [] else 'none'))
entry_string.append("Question asked by %s" % added_by)
irc.reply(' / '.join(entry_string), notice=True, private=True, prefixNick=False)
else:
irc.errorInvalid('argument', channel)
except KeyError:
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index(request, count=10, template_name=\"pollit/index.html\"):\n polls = Poll.objects.get_latest_polls(count=count, include_expired=True)\n \n return render_to_response(template_name,\n {'poll_list': polls},\n context_instance=RequestContext(re... | [
"0.68773824",
"0.67399997",
"0.63377434",
"0.6063946",
"0.5996496",
"0.5898129",
"0.5813151",
"0.5798766",
"0.56912804",
"0.5689598",
"0.5687956",
"0.56795925",
"0.5662718",
"0.5646899",
"0.5646899",
"0.5614585",
"0.55864877",
"0.5577538",
"0.55622435",
"0.55242187",
"0.54779... | 0.66753453 | 2 |
[channel] Vote on a poll. Channel is only needed if used in a PM. | def vote(self, irc, msg, args, channel, pid, yaynay):
if yaynay not in ['yay', 'nay']:
irc.error("Valid Answers are 'yay' or 'nay'.")
return
if channel in self.polls.keys():
if self.polls[channel][pid]['concluded']:
irc.reply("Poll #%s is finished, it does not accept updates." % pid)
return
if self._vote(irc, channel, msg.nick, pid, yaynay):
irc.reply("Successfully voted on %s" % self.polls[channel][pid]['question'])
else:
log.debug('Not dumping due to no change.')
else:
irc.error("'%s' has no polls." % channel) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def votes(self, irc, msg, args, channel, pid):\n if channel and msg.args[0] in irc.state.channels:\n if msg.args[0] != channel:\n if ircdb.checkCapability(msg.prefix, 'admin') or ircdb.checkCapability(msg.prefix, 'owner'):\n irc.error(\"Not Implemented\")\n ... | [
"0.6393847",
"0.6147241",
"0.59954494",
"0.5947859",
"0.5874632",
"0.5840181",
"0.5776968",
"0.5758922",
"0.5722969",
"0.57202333",
"0.5576358",
"0.5565325",
"0.5534625",
"0.548925",
"0.54667646",
"0.5447865",
"0.539419",
"0.53278154",
"0.53092563",
"0.53039765",
"0.528682",
... | 0.6149552 | 1 |
[channel] Retrieves the vote count for a poll. | def votes(self, irc, msg, args, channel, pid):
if channel and msg.args[0] in irc.state.channels:
if msg.args[0] != channel:
if ircdb.checkCapability(msg.prefix, 'admin') or ircdb.checkCapability(msg.prefix, 'owner'):
irc.error("Not Implemented")
else:
irc.errorInvalid('argument', channel)
elif msg.args[0] == channel:
irc.error("Not Implemented") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_vote_count(self, post):\n return post.vote_set.count()",
"async def _vote_count(\n self, ctx: Context, *, channel: discord.TextChannel = None\n ):\n\n guild: discord.Guild = ctx.guild\n\n if not channel:\n channel = await self.get_vote_channel(guild)\n ... | [
"0.6773994",
"0.6712171",
"0.66255003",
"0.64222467",
"0.64080846",
"0.6403009",
"0.6307542",
"0.627525",
"0.62508446",
"0.6187831",
"0.6187831",
"0.61792505",
"0.6178627",
"0.61383927",
"0.61028653",
"0.6074583",
"0.60575265",
"0.60141224",
"0.6011861",
"0.60046905",
"0.6000... | 0.0 | -1 |
Marks a poll as finished. This is limited to channel ops. | def conclude(self, irc, msg, args, channel, pid):
if msg.nick in irc.state.channels[channel].ops:
if channel in self.polls.keys():
try:
self.polls[channel][pid]['concluded'] = True
self._dump(self.polls)
irc.reply("Marked poll #%s (%s) as concluded." % (pid, self.polls[channel][pid]['question']))
except IndexError:
irc.error("'%s' does not have a poll with that index.")
except KeyError:
irc.error("This may be a bug with the bot or poll file, please submit an issue at\
<https://github.com/IotaSpencer/supyplugins> with all pertinent information.")
else:
irc.error("Access Denied.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finish(self):\n self.cond.acquire()\n try:\n self.closed = True\n self.cond.notify()\n finally:\n self.cond.release()",
"def finish(self):\n with self._lock: # just to be tidy; lock not really needed to set a boolean\n self._done = True... | [
"0.66311806",
"0.6554593",
"0.65156335",
"0.6456887",
"0.6304259",
"0.62279236",
"0.6223889",
"0.6176054",
"0.61735076",
"0.61373097",
"0.6120679",
"0.60965186",
"0.60947",
"0.6072286",
"0.5981773",
"0.5979095",
"0.5972629",
"0.59477633",
"0.5941002",
"0.59198123",
"0.5911216... | 0.0 | -1 |
Removes a poll entirely. | def rempoll(self, irc, msg, args, channel, pid):
if msg.nick in irc.state.channels[channel].ops:
del self.polls[channel][pid]
self._dump(self.polls) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self):\n if self.removed:\n return\n self._remove()\n self.removed = True",
"async def will_remove_from_hass(self) -> None:\n if self.unsub_update:\n self.unsub_update()\n self.unsub_update = None",
"async def async_will_remove_from_hass(s... | [
"0.5543764",
"0.55292016",
"0.54858243",
"0.5470905",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54448193",
"0.54426503",
"0.5439495",
... | 0.0 | -1 |
Lists all the RuntimeConfig resources within project. | def ListConfigs(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list():\n project_root = get_project_root()\n config_file = os.path.join(project_root, CONFIG_DIR, CONFIG_FILE)\n if os.path.exists(config_file):\n kwargs = load_yaml_file(config_file)\n if PACKAGE_INDEX_KEY in kwargs:\n packages = load_yaml_url(kwargs[PACKAGE_INDEX_KEY])\n ... | [
"0.6564698",
"0.6287851",
"0.61679363",
"0.6095816",
"0.5989894",
"0.5769178",
"0.5736151",
"0.57051367",
"0.5691854",
"0.5687537",
"0.5679123",
"0.5675863",
"0.56112176",
"0.55890656",
"0.5550873",
"0.5547206",
"0.5533986",
"0.5531299",
"0.55280936",
"0.5521363",
"0.5520824"... | 0.5060501 | 81 |
Gets information about a RuntimeConfig resource. | def GetConfig(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def runtime_config(self) -> str:\n return self._node[\"app_data\"].get(\"runtime_config\")",
"def get_resource_config(target=False, force=None):\n return get_stored_property(ctx, 'resource_config', target, force)",
"def config(self):\n annotations = IAnnotations(self.context)\n return a... | [
"0.7309697",
"0.63536143",
"0.61861",
"0.61123216",
"0.60506386",
"0.6046548",
"0.60022986",
"0.59997743",
"0.59895045",
"0.5969095",
"0.5955346",
"0.5955346",
"0.5955346",
"0.5955346",
"0.5955346",
"0.5955346",
"0.5955346",
"0.5955346",
"0.5955346",
"0.5955346",
"0.5955346",... | 0.0 | -1 |
Creates a new RuntimeConfig resource. The configuration name must be unique within project. | def CreateConfig(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, config):\n config_name = config.get(\"LaunchConfigurationName\", self._name)\n assert config_name == self._name, \"Config name mismatch {} {}\".format(config_name, self._name)\n config[\"LaunchConfigurationName\"] = self._name\n self._client.create_launch_configuration(... | [
"0.6188884",
"0.6090293",
"0.6090293",
"0.58227265",
"0.57470423",
"0.57029325",
"0.5658915",
"0.55869395",
"0.55303633",
"0.5527195",
"0.5509801",
"0.5489197",
"0.5486522",
"0.544036",
"0.54257023",
"0.5423881",
"0.54184675",
"0.5381031",
"0.5323874",
"0.532296",
"0.5305365"... | 0.0 | -1 |
Updates a RuntimeConfig resource. The configuration must exist beforehand. | def UpdateConfig(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(name, config, backend, storage, debug):\n setup_lithops_logger(logging.DEBUG)\n\n verify_runtime_name(name)\n\n if config:\n config = load_yaml_config(config)\n\n config_ow = set_config_ow(backend, storage, runtime_name=name)\n config = default_config(config, config_ow)\n\n if c... | [
"0.66292256",
"0.60551757",
"0.5964276",
"0.59138215",
"0.5715593",
"0.55989873",
"0.5577988",
"0.55546343",
"0.5550815",
"0.54435796",
"0.5437534",
"0.5437106",
"0.5432855",
"0.5415902",
"0.54149926",
"0.5393029",
"0.5393029",
"0.5380091",
"0.53799874",
"0.53699434",
"0.5356... | 0.49852085 | 76 |
Deletes a RuntimeConfig resource. | def DeleteConfig(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_global_system_config_delete(self, resource_id, resource_dict):\n pass",
"def post_global_vrouter_config_delete(self, resource_id, resource_dict):\n pass",
"def delete(name, config, backend, storage, debug):\n setup_lithops_logger(logging.DEBUG)\n\n verify_runtime_name(name)\n\n ... | [
"0.63476586",
"0.6339625",
"0.6323798",
"0.6240317",
"0.62242293",
"0.619534",
"0.61792046",
"0.61713314",
"0.6144527",
"0.6141145",
"0.6128976",
"0.60849786",
"0.6033858",
"0.60115296",
"0.5929646",
"0.57731843",
"0.5771558",
"0.5689029",
"0.5676266",
"0.5670987",
"0.5560764... | 0.56942225 | 17 |
Lists variables within given a configuration, matching any provided filters. This only lists variable names, not the values, unless `return_values` is true, in which case only variables that user has IAM permission to GetVariable will be returned. | def ListVariables(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_variables(self, request, context):\n response = ListVariablesResponse()\n for variable in self._delegator.list_variables(request.component):\n response.variables.append(variable)\n return response",
"def Run(self, args):\n variable_client = util.VariableClient()\n m... | [
"0.6380369",
"0.5820642",
"0.57636815",
"0.56829864",
"0.5545043",
"0.552599",
"0.5512235",
"0.54310113",
"0.5424095",
"0.5416049",
"0.5415185",
"0.5367262",
"0.53486437",
"0.53446084",
"0.5319058",
"0.52849674",
"0.52658916",
"0.5254456",
"0.5228465",
"0.520828",
"0.5206558"... | 0.5790898 | 2 |
Gets information about a single variable. | def GetVariable(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getVar(self, id):\n if id in self.variables:\n return self.variables[id]",
"def getVariable(self, varName):\n return self[varName]",
"def get_data(self, variable):\n return self.data.get(variable)",
"async def getVariable(ctx, var):\n if ctx.message.channel.name != \"st... | [
"0.6939153",
"0.6936482",
"0.69092554",
"0.68890536",
"0.6884928",
"0.67508674",
"0.6643614",
"0.65952235",
"0.6536052",
"0.6496712",
"0.64882463",
"0.6455315",
"0.6429799",
"0.64095783",
"0.63759357",
"0.63599",
"0.63293916",
"0.6292426",
"0.6292426",
"0.6292426",
"0.6207993... | 0.0 | -1 |
Watches a specific variable and waits for a change in the variable's value. When there is a change, this method returns the new value or times out. If a variable is deleted while being watched, the `variableState` state is set to `DELETED` and the method returns the last known variable `value`. If you set the deadline for watching to a larger value than internal timeout (60 seconds), the current variable value is returned and the `variableState` will be `VARIABLE_STATE_UNSPECIFIED`. To learn more about creating a watcher, read the [Watching a Variable for Changes](/deploymentmanager/runtimeconfigurator/watchingavariable) documentation. | def WatchVariable(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait_for_variable(self, name, pred, timeout=None):\n if not hasattr(pred,\"__call__\"):\n v=pred\n if isinstance(pred,(tuple,list,set,dict)):\n pred=lambda x: x in v\n else:\n pred=lambda x: x==v\n ctl=threadprop.current_controller()\... | [
"0.63492364",
"0.60993075",
"0.55610037",
"0.5458114",
"0.5403095",
"0.52911294",
"0.52841663",
"0.5238075",
"0.50422585",
"0.49651515",
"0.48968446",
"0.48794204",
"0.48586887",
"0.48463622",
"0.4791569",
"0.4787551",
"0.46988493",
"0.46986935",
"0.46816027",
"0.46677256",
"... | 0.46302924 | 23 |
Creates a variable within the given configuration. You cannot create a variable with a name that is a prefix of an existing variable name, or a name that has an existing variable name as a prefix. To learn more about creating a variable, read the [Setting and Getting Data](/deploymentmanager/runtimeconfigurator/setandgetvariables) documentation. | def CreateVariable(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, app_id, service_name, env_var_name, value):\n\n if not _is_valid_env_var_name(env_var_name):\n raise exceptions.InvalidParameter('env_var_name', env_var_name)\n\n services = self.service.get_all_by_application(app_id)\n service_id = [i['id'] for i in services if i['... | [
"0.6057225",
"0.5921494",
"0.5921494",
"0.5910765",
"0.58916956",
"0.57897204",
"0.5695237",
"0.5639612",
"0.55724275",
"0.557233",
"0.55559117",
"0.5538004",
"0.551758",
"0.55008006",
"0.5477593",
"0.54400873",
"0.54192346",
"0.5404222",
"0.54034936",
"0.5355584",
"0.5355295... | 0.48706943 | 78 |
Updates an existing variable with a new value. | def UpdateVariable(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_variable(value):\n return value",
"def updateValue(self):\n self.value = self.var.get()",
"def update_variable(value):\n return value + 1",
"def updateVar(self, id, value, type_):\n if id in self.variables:\n symbol = self.variables[id]\n symbol = sym.Symb... | [
"0.8306532",
"0.770032",
"0.7636661",
"0.74136305",
"0.7011678",
"0.68405515",
"0.67276084",
"0.6489138",
"0.6488961",
"0.64369726",
"0.6304455",
"0.6286994",
"0.6245881",
"0.6235783",
"0.62295234",
"0.6209103",
"0.617981",
"0.6172482",
"0.61659956",
"0.615926",
"0.6130616",
... | 0.6769582 | 6 |
Deletes a variable or multiple variables. If you specify a variable name, then that variable is deleted. If you specify a prefix and `recursive` is true, then all variables with that prefix are deleted. You must set a `recursive` to true if you delete variables by prefix. | def DeleteVariable(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _delete(self, variables):\n required_vars = ['container']\n variables_dict = self._get_vars(variables, required=required_vars)\n\n container_name = variables_dict.pop('container')\n object_name = variables_dict.pop('object', None)\n\n if object_name:\n self.swift.d... | [
"0.6082754",
"0.5931479",
"0.5894654",
"0.57672286",
"0.5762076",
"0.566055",
"0.560499",
"0.545678",
"0.53137845",
"0.5311779",
"0.52954566",
"0.5270962",
"0.52198213",
"0.51949286",
"0.5131959",
"0.51042974",
"0.5100813",
"0.5093037",
"0.5086412",
"0.5080377",
"0.5057334",
... | 0.5528326 | 7 |
List waiters within the given configuration. | def ListWaiters(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def waiters(self):\n waiters = []\n\n for name, item in self._definition.get('waiters', {}).items():\n name = self._get_name('waiter', Waiter.PREFIX + name)\n waiters.append(Waiter(name, item))\n\n return waiters",
"def get_list_of_configlets(configlets):\n\n futures... | [
"0.71054786",
"0.6426477",
"0.586981",
"0.57586163",
"0.5726431",
"0.5626258",
"0.55491465",
"0.5529439",
"0.5473015",
"0.54290795",
"0.5414866",
"0.53946763",
"0.53753406",
"0.536865",
"0.5325333",
"0.5261703",
"0.5254371",
"0.5234681",
"0.52307975",
"0.51577234",
"0.5136059... | 0.6771325 | 1 |
Gets information about a single waiter. | def GetWaiter(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_waiter(waiter_name=None):\n pass",
"def get_waiter(waiter_name=None):\n pass",
"def get_waiter(waiter_name=None):\n pass",
"def get_waiter(waiter_name=None):\n pass",
"def get_waiter(waiter_name=None):\n pass",
"def get_waiter(waiter_name=None):\n pass",
"def get_waiter(waiter... | [
"0.732819",
"0.732819",
"0.732819",
"0.732819",
"0.732819",
"0.732819",
"0.732819",
"0.732819",
"0.732819",
"0.732819",
"0.732819",
"0.732819",
"0.7034089",
"0.7034089",
"0.7034089",
"0.58368564",
"0.5562174",
"0.545833",
"0.5453501",
"0.5453501",
"0.51552576",
"0.500022",
... | 0.51276976 | 21 |
Creates a Waiter resource. This operation returns a longrunning Operation resource which can be polled for completion. However, a waiter with the given name will exist (and can be retrieved) prior to the operation completing. If the operation fails, the failed Waiter resource will still exist and must be deleted prior to subsequent creation attempts. | def CreateWaiter(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_waiter(self, waiter_name: str = None) -> Waiter:\n pass",
"def get_waiter(self, waiter_name: str = None) -> Waiter:\n pass",
"def get_waiter(self, waiter_name: str = None) -> Waiter:\n pass",
"def wait_operation(\n self,\n ) -> Callable[[operations_pb2.WaitOperationRequ... | [
"0.639531",
"0.639531",
"0.639531",
"0.61406636",
"0.5927985",
"0.5927985",
"0.5927985",
"0.5927985",
"0.5927985",
"0.5927985",
"0.5927985",
"0.5927985",
"0.5927985",
"0.5927985",
"0.5927985",
"0.5927985",
"0.573098",
"0.5721729",
"0.55530214",
"0.5279856",
"0.5229172",
"0.... | 0.57157534 | 18 |
Deletes the waiter with the specified name. | def DeleteWaiter(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, name):\n with self._lock:\n self._delete(name)",
"def delete(self, name):\n\n pass",
"def delete(self, name=None):\n raise NotImplementedError",
"def delete(self, name):\n self.connect()\n self._write('DEL %s\\r\\n' % name)\n return self._... | [
"0.7185444",
"0.69208735",
"0.6794032",
"0.67044383",
"0.6475918",
"0.62396824",
"0.6199465",
"0.6158003",
"0.6086726",
"0.60831106",
"0.60684264",
"0.60101855",
"0.60017025",
"0.597735",
"0.596643",
"0.5948519",
"0.59348965",
"0.59313756",
"0.59124154",
"0.5899736",
"0.58956... | 0.57201225 | 31 |
Save seed into temp file. | def saveseed(self, seed):
savefile = gettempdir() + '/last_test_seed_fate.tmp'
if args.verbose:
print('Saving run into ' + savefile)
with open(savefile, 'w') as f:
f.write(str(seed)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_seed(self, seed: np.ndarray):\n print(\"Reconstructed trace saved as seed to \", CONFIG_DIR)\n np.savetxt(CONFIG_DIR / self.name_seed, seed.view(float).reshape(-1, 2))",
"def insert_test( hash, random, seq ):\n try:\n with open(os.path.join(SEED_DIRECTORY, \"%s_%s\" % (hash, 0)),... | [
"0.71522933",
"0.6273968",
"0.62532884",
"0.6251843",
"0.604025",
"0.60345274",
"0.60236645",
"0.6002649",
"0.5998057",
"0.5997992",
"0.5983726",
"0.5970545",
"0.5964728",
"0.5925001",
"0.5925001",
"0.5902035",
"0.5890514",
"0.58809185",
"0.5874178",
"0.58705467",
"0.5869121"... | 0.8186387 | 0 |
Run the test based on given seed. | def run_test(self, seed, commands_per_run):
if args.verbose:
print('Sample text:\n' + str(self.document.text))
print('Starting selection: ' + str(self.document.selection))
for i in range(commands_per_run):
userinput = self.document.ui.getinput()
if args.verbose:
try:
name = userinput.__name__
except AttributeError:
name = str(userinput)
print('{}: Input = {}, Mode = {}'.format(i + 1, name, self.document.mode))
try:
self.document.mode.processinput(self.document, userinput)
except:
print('Current text:\n{}'.format(self.document.text))
print('Current selection: {}'.format(self.document.selection))
print('Current pattern: {}'.format(self.document.search_pattern))
raise
self.successes += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def random_test(self, source):\r\n ret = 1\r\n for seed in range(1, 40):\r\n if source.run(temp_params={\"fitness_function\": (lambda x: -np.sum(x)**2+10),\r\n \"population_size\": 10,\r\n \"time_constraint\": 2,\r... | [
"0.72557",
"0.7165194",
"0.7157774",
"0.7147115",
"0.71157515",
"0.70374316",
"0.6993909",
"0.6993909",
"0.6942664",
"0.6942664",
"0.68477833",
"0.6824419",
"0.6699443",
"0.66688615",
"0.6521962",
"0.64988214",
"0.64300764",
"0.6428376",
"0.64246386",
"0.6414504",
"0.6401042"... | 0.656294 | 14 |
Model to embed books and wikilinks using the functional API. Trained to discern if a tag is present in a article | def anime_embedding_model(anime_index, tag_index, embedding_size=50, classification=False):
# Both inputs are 1-dimensional
anime = Input(name='anime', shape=[1])
tag = Input(name='tag', shape=[1])
# Embedding the anime (shape will be (None, 1, 50))
anime_embedding = Embedding(name='anime_embedding',
input_dim=len(anime_index),
output_dim=embedding_size)(anime)
# Embedding the tag (shape will be (None, 1, 50))
tag_embedding = Embedding(name='tag_embedding',
input_dim=len(tag_index),
output_dim=embedding_size)(tag)
# Merge the layers with a dot product along the second axis (shape will be (None, 1, 1))
merged = Dot(name='dot_product', normalize=True, axes=2)([anime_embedding, tag_embedding])
# Reshape to be a single number (shape will be (None, 1))
merged = Reshape(target_shape=[1])(merged)
# If classifcation, add extra layer and loss function is binary cross entropy
if classification:
merged = Dense(1, activation='sigmoid')(merged)
model = Model(inputs=[anime, tag], outputs=merged)
model.compile(optimizer='Adam', loss='binary_crossentropy', metrics=['accuracy'])
# Otherwise loss function is mean squared error
else:
model = Model(inputs=[anime, tag], outputs=merged)
model.compile(optimizer='Adam', loss='mse')
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, name, isbn, author, tags=None):\n super().__init__(name, isbn, tags)\n self.author = author\n self.resource_type = \"Book\"",
"def tagged(request,slug):\n\n tag = get_object_or_404(Tag, slug=slug)\n books = Book.objects.filter(tags=tag)\n \n for book in books:\... | [
"0.5442478",
"0.53429097",
"0.52412236",
"0.51314247",
"0.51292527",
"0.5036361",
"0.5019173",
"0.49803144",
"0.4961309",
"0.49558708",
"0.49364054",
"0.49175373",
"0.4890888",
"0.48781618",
"0.48643574",
"0.48554486",
"0.48543897",
"0.48376718",
"0.48289764",
"0.48264697",
"... | 0.0 | -1 |
Returns an HTML script element for including a script from the admin media url (or other location if an absolute url is given). | def include_admin_script(script_path):
if not absolute_url_re.match(script_path):
script_path = '%s%s' % (settings.ADMIN_MEDIA_PREFIX, script_path)
return '<script type="text/javascript" src="%s"></script>' % script_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resource_js(self):\n \n portal_url = getSite().absolute_url()\n \n return \"\"\"\n <script type=\"text/javascript\" src=\"%s/++resource++swfobject.js\"></script>\n <script type=\"text/javascript\" src=\"%s/++resource++audio_player.js\"></script> \n <script type... | [
"0.5999079",
"0.56655055",
"0.5653992",
"0.56134677",
"0.5572652",
"0.5382267",
"0.5336885",
"0.5328502",
"0.53220886",
"0.53072685",
"0.5276165",
"0.52621883",
"0.5245122",
"0.5236014",
"0.523167",
"0.5201591",
"0.51624304",
"0.51335704",
"0.51318634",
"0.51224566",
"0.51154... | 0.7652485 | 0 |
r""" Description Compute ChebNet layer. | def forward(self, graph, feat, lambda_max=None):
def unnLaplacian(feat, D_invsqrt, graph):
""" Operation Feat * D^-1/2 A D^-1/2 但是如果写成矩阵乘法：D^-1/2 A D^-1/2 Feat"""
graph.ndata['h'] = feat * D_invsqrt
graph.update_all(fn.copy_u('h', 'm'), fn.sum('m', 'h'))
return graph.ndata.pop('h') * D_invsqrt
with graph.local_scope():
#一点修改，这是原来的代码
if self.is_mnist:
graph.update_all(fn.copy_edge('v','m'), fn.sum('m','h')) # 'v'与coordinate.py有关
D_invsqrt = th.pow(graph.ndata.pop('h').float().clamp(min=1), -0.5).unsqueeze(-1).to(feat.device)
#D_invsqrt = th.pow(graph.in_degrees().float().clamp(
# min=1), -0.5).unsqueeze(-1).to(feat.device)
#print("in_degree : ",graph.in_degrees().shape)
else:
D_invsqrt = th.pow(graph.in_degrees().float().clamp(min=1), -0.5).unsqueeze(-1).to(feat.device)
#print("D_invsqrt : ",D_invsqrt.shape)
#print("ndata : ",graph.ndata['h'].shape)
if lambda_max is None:
try:
lambda_max = laplacian_lambda_max(graph)
except BaseException:
# if the largest eigenvalue is not found
dgl_warning(
"Largest eigonvalue not found, using default value 2 for lambda_max",
RuntimeWarning)
lambda_max = th.Tensor(2).to(feat.device)
if isinstance(lambda_max, list):
lambda_max = th.Tensor(lambda_max).to(feat.device)
if lambda_max.dim() == 1:
lambda_max = lambda_max.unsqueeze(-1) # (B,) to (B, 1)
# broadcast from (B, 1) to (N, 1)
lambda_max = broadcast_nodes(graph, lambda_max)
re_norm = 2. / lambda_max
# X_0 is the raw feature, Xt refers to the concatenation of X_0, X_1, ... X_t
Xt = X_0 = feat
# X_1(f)
if self._k > 1:
h = unnLaplacian(X_0, D_invsqrt, graph)
X_1 = - re_norm * h + X_0 * (re_norm - 1)
# Concatenate Xt and X_1
Xt = th.cat((Xt, X_1), 1)
# Xi(x), i = 2...k
for _ in range(2, self._k):
h = unnLaplacian(X_1, D_invsqrt, graph)
X_i = - 2 * re_norm * h + X_1 * 2 * (re_norm - 1) - X_0
# Concatenate Xt and X_i
Xt = th.cat((Xt, X_i), 1)
X_1, X_0 = X_i, X_1
# linear projection
h = self.linear(Xt)
# activation
if self.activation:
h = self.activation(h)
#print('ChebConv.py Line163 h : ',h.shape)
return h | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_bisenet(inputs, num_classes):\n\n ### The spatial path\n ### The number of feature maps for each convolution is not specified in the paper\n ### It was chosen here to be equal to the number of feature maps of a classification\n ### model at each corresponding stage\n # spatial_net = fl... | [
"0.63327324",
"0.62027663",
"0.61002606",
"0.6070533",
"0.59601736",
"0.59473467",
"0.5912948",
"0.5911498",
"0.58962667",
"0.58913976",
"0.58264315",
"0.58224165",
"0.5808085",
"0.58010757",
"0.5788575",
"0.5781931",
"0.5776973",
"0.57699645",
"0.57483983",
"0.57286537",
"0.... | 0.0 | -1 |
This is some other solution from codewars to test against. | def my_fizz_buzz_cuckoo_clock(time):
hours, minutes = map(int, time.split(":"))
sounds = {0: " ".join(["Cuckoo"] * (hours % 12 or 12)), 15: "Fizz Buzz", 30: "Cuckoo", 45: "Fizz Buzz"}
if minutes in sounds:
return sounds[minutes]
return "Fizz" if minutes % 3 == 0 else "Buzz" if minutes % 5 == 0 else "tick" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exercise_b2_53():\r\n pass",
"def exercise_b2_106():\r\n pass",
"def exercise_b2_113():\r\n pass",
"def exercise_b2_107():\r\n pass",
"def test_4_4_1_1(self):\n pass",
"def exercise_b2_69():\r\n pass",
"def exercise_b2_52():\r\n pass",
"def exercise_b2_56():\r\n pass",... | [
"0.63127756",
"0.6088745",
"0.607841",
"0.60318285",
"0.5995737",
"0.5885328",
"0.586407",
"0.577447",
"0.57653236",
"0.57585347",
"0.57469904",
"0.57358444",
"0.56477886",
"0.564617",
"0.5639498",
"0.55612564",
"0.55611384",
"0.5469325",
"0.5427286",
"0.5421196",
"0.5418454"... | 0.0 | -1 |
The index view, for the home page. Shows Campaigns this UserProfile is in. | def index(request):
context = dict()
if request.user.is_authenticated():
context['campaigns'] = [
CampaignSerializer(c).serialize() for c in
request.user.userprofile.campaigns.order_by('pk')]
return render(request, 'voter_validation/index.html', context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index(request): \n \n all_projects = models.Project.objects.all()\n projects = get_objects_for_user(request.user, 'view_project', all_projects)\n \n fbads_settings = FacebookAdsSettings.objects.first()\n return render_to_response('index.html',{\n 'projects': p... | [
"0.6278449",
"0.5947191",
"0.57573825",
"0.57182586",
"0.5707867",
"0.5703257",
"0.56390655",
"0.5605963",
"0.55317235",
"0.5515906",
"0.5514333",
"0.5508371",
"0.54833335",
"0.5471401",
"0.5455781",
"0.54364294",
"0.5406502",
"0.5397928",
"0.53924406",
"0.53866136",
"0.53479... | 0.6828237 | 0 |
The logout view. Redirects to home page after. | def logout(request):
if request.user.is_authenticated():
auth_logout(request)
return HttpResponseRedirect(reverse("voter_validation:index")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logout_view(request):\n logout(request)\n return redirect('home')",
"def logout_view(request):\n auth_logout(request)\n return redirect('home')",
"def logout_view(request):\n \n logout(request)\n return HttpResponseRedirect(reverse(\"index\"))",
"def logout_view(request):\n logout... | [
"0.8744168",
"0.8659496",
"0.8525579",
"0.8507581",
"0.8489514",
"0.8458301",
"0.8458301",
"0.84309167",
"0.84134465",
"0.83970946",
"0.8394286",
"0.8385555",
"0.83608264",
"0.83608264",
"0.83596367",
"0.8345407",
"0.8336058",
"0.83315647",
"0.83303416",
"0.8329741",
"0.83283... | 0.7844669 | 100 |
Shows validation UI for a given campaign, if this UserProfile is authorized to do data entry for the specified Campaign. This is also the endpoint for searching for Voters as part of validation. If doing a search, assume that a sufficient number of the specified fields is present (taken care of in frontend form validation). | def validate(request, campaign_id):
if not request.user.userprofile.in_campaign(campaign_id):
return HttpResponseRedirect(reverse("voter_validation:index"))
campaign_id = int(campaign_id)
campaign = get_object_or_404(Campaign, id=campaign_id)
# Get the number of signatures validated by the current user for this
# campaign, and also for the past 24 hours.
val_sigs_set = ValidationRecord.objects.filter(
validator=request.user.userprofile, campaign=campaign)
val_sigs_24h = val_sigs_set.filter(
last_updated__gte=datetime.now(SERVER_TIME_ZONE) - timedelta(hours=24))
context = {
"campaign_name": campaign.name,
"campaign_id": campaign_id,
"val_sigs": val_sigs_set.count(),
"val_sigs_24h": val_sigs_24h.count(),
}
# Search if specified in POST
search = request.POST.get("search", "false")
if search.lower() == "true":
name = request.POST.get("name", None)
address = request.POST.get("address", None)
res_zip = request.POST.get("zip", None)
# Pass in campaign_id so we can check the Voter was previously validated
voters = voter_search(name, address, res_zip, campaign_id=campaign_id)
context.update({
"name": name,
"address": address,
"zip": res_zip,
"results": voters,
})
return render(request, "voter_validation/validation.html", context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index(request):\n context = dict()\n if request.user.is_authenticated():\n context['campaigns'] = [\n CampaignSerializer(c).serialize() for c in\n request.user.userprofile.campaigns.order_by('pk')]\n return render(request, 'voter_validation/index.html', context)",
"def v... | [
"0.5706519",
"0.5386401",
"0.5315525",
"0.530953",
"0.51058286",
"0.51058286",
"0.48647565",
"0.4818601",
"0.47097164",
"0.46946898",
"0.46497676",
"0.4634922",
"0.46242386",
"0.45637044",
"0.449959",
"0.44929436",
"0.44728902",
"0.44613764",
"0.44438702",
"0.4442745",
"0.443... | 0.62158144 | 0 |
this test only works if ANs fall within separate bins, | def test_iter_bins_API_input_missing_bin(pqo_STRING, args_dict, foreground, background, enrichment_method):
# foreground, background, enrichment_method = fixture_fg_bg_iter_bins
fg = format_for_REST_API(foreground[foreground.notnull()])
bg = format_for_REST_API(background.loc[background.background.notnull(), "background"])
in_ = format_for_REST_API(background.loc[background.intensity.notnull(), "intensity"])
# ui = userinput.REST_API_input(pqo=pqo_STRING, foreground_string=fg, background_string=bg, background_intensity=in_, num_bins=NUM_BINS, enrichment_method=enrichment_method)
args_dict_temp = args_dict.copy()
args_dict_temp.update({"foreground":fg, "background":bg, "intensity":in_, "num_bins":NUM_BINS, "enrichment_method":enrichment_method})
ui = userinput.REST_API_input(pqo_STRING, args_dict=args_dict_temp)
counter = 0
for ans, weight_fac in ui.iter_bins():
# every weighting factor is a float
assert isinstance(weight_fac, float) or isinstance(weight_fac, int)
counter += 1
# since integers instead of floats are being used for test data, the number of unique bins can be determined by sets
num_min_iterations_expected = len({int(ele) for ele in ui.foreground["intensity"].tolist()})
assert counter >= num_min_iterations_expected | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bins(self):\n\n \n for filename in ['data/population_padang_1.asc', \n 'data/test_grid.asc']: \n \n R = read_coverage(filename)\n \n min, max = R.get_extrema() #use_numeric=True)\n \n for N in [2,3,5,7,10,16]:\n ... | [
"0.67321396",
"0.6631882",
"0.612074",
"0.60527307",
"0.5962843",
"0.5934379",
"0.5913258",
"0.5909307",
"0.57914376",
"0.5731966",
"0.5723782",
"0.5706618",
"0.56629616",
"0.5644072",
"0.5630398",
"0.562626",
"0.562407",
"0.561191",
"0.5604084",
"0.55954075",
"0.5590886",
... | 0.0 | -1 |
This is the base Exception class for all step failures. It can be manually raised from recipe code to cause the build to turn red. | def StepFailure(self):
return recipe_api.StepFailure | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def raise_step_error(self, error: Exception, step: str):\n error_message = \"{}\\nFailed: Error={}\".format(step, str(error))\n logging.error(error_message)\n self.slacker.send_thread_reply(error_message)\n raise Exception(error_message)",
"def raise_on_error(self):\n if not self... | [
"0.65778327",
"0.6160697",
"0.6118424",
"0.6045226",
"0.6028757",
"0.59925586",
"0.59890693",
"0.5984237",
"0.5979543",
"0.5880542",
"0.58220655",
"0.58042306",
"0.58023226",
"0.57811123",
"0.57735544",
"0.56904095",
"0.56897426",
"0.5686951",
"0.56869185",
"0.5652853",
"0.56... | 0.6969654 | 0 |
StepWarning is a subclass of StepFailure, and will translate to a yellow build. | def StepWarning(self):
return recipe_api.StepWarning | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _warn(self, warning=None):\r\n debug.err('Warning: %s' % warning)\r\n\r\n if core.FW_conf['settings'].TestRun.ExecutionMode == 'Leader' and warning != None:\r\n executeInFollower(\"self.warn('%s')\" % (warning,))\r\n\r\n if type(warning) != types.ListType:\r\n warning... | [
"0.680333",
"0.6467354",
"0.6363371",
"0.6182617",
"0.6118767",
"0.60774654",
"0.6036392",
"0.6019372",
"0.6014528",
"0.6010554",
"0.5999503",
"0.5906176",
"0.5892281",
"0.5887475",
"0.5859568",
"0.5821751",
"0.5817227",
"0.5793164",
"0.5664179",
"0.5653461",
"0.5625123",
"... | 0.792026 | 0 |
InfraFailure is a subclass of StepFailure, and will translate to a purple build. This exception is raised from steps which are marked as `infra_step`s when they fail. | def InfraFailure(self):
return recipe_api.InfraFailure | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _identify_fail(failure):\n logger.warning(failure.getErrorMessage())\n logger.warning(\"Failed to setup & obtain identity\")\n return",
"def failure_exception(cls, state, exception):\r\n return PlatformMessage(method=\"__reply__\", kwargs={\"__result__\": \"fail\", \"state\": state, \"errcode... | [
"0.5803383",
"0.5730745",
"0.565321",
"0.5649556",
"0.56122845",
"0.5440349",
"0.5320383",
"0.52736396",
"0.5240046",
"0.5213798",
"0.5201333",
"0.5083693",
"0.50791305",
"0.50574607",
"0.5027117",
"0.50205135",
"0.5006612",
"0.5000682",
"0.49848235",
"0.49722403",
"0.4962557... | 0.6850455 | 0 |
StepTimeout is a subclass of StepFailure and is raised when a step times out. | def StepTimeout(self):
return recipe_api.StepTimeout | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def raise_timeout(self, *args, **kwargs):\n\n self.log.error(\"Task timeout encountered.\")\n raise TimeoutError",
"def handler(*args, **kwargs):\n raise TimeoutException(\"Test aborted due to timeout. Test was \" +\n \"expected to finish in less than {} second(s).\".format(time_l... | [
"0.6783338",
"0.6670357",
"0.6458349",
"0.6233549",
"0.620531",
"0.6151229",
"0.61305606",
"0.6103031",
"0.59383696",
"0.5915559",
"0.5886344",
"0.5850895",
"0.58435684",
"0.58397263",
"0.5815907",
"0.5812256",
"0.576869",
"0.5734896",
"0.5714007",
"0.56782407",
"0.56605077",... | 0.7499932 | 0 |
The currently active (open) result from the last step that was run. This is a `types.StepData` object. | def active_result(self):
return self.step_client.previous_step_result() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def result(self):\n # most pythonic way to get last in last is -1\n return self.history[-1]",
"def current_progress_data(self):\n return self._current_progress_data",
"def previous_step_result(self):\n return self._previous_step_result",
"def cur_step(self):\n return self._cur_... | [
"0.7012832",
"0.6931432",
"0.6929647",
"0.67603475",
"0.66973376",
"0.6685482",
"0.66834754",
"0.66508675",
"0.66325194",
"0.65645987",
"0.6562965",
"0.65574545",
"0.65385914",
"0.6496028",
"0.6484237",
"0.6467374",
"0.6467374",
"0.6467374",
"0.64124614",
"0.6401742",
"0.6391... | 0.78945726 | 0 |
Nest allows you to nest steps hierarchically on the build UI. Calling ```python | def nest(self, name):
step_result = self(name, [])
with self.m.context(name_prefix=name, increment_nest_level=True):
yield step_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_step(self):\n pass",
"def build_step(self):\n pass",
"def test_build_page_nested(build_resources, cli):\n books, _ = build_resources\n src = books.joinpath(\"nested\")\n page = src.joinpath(\"contents\", \"markdown.md\")\n html = src.joinpath(\"_build\", \"_page\", \"content... | [
"0.5666077",
"0.5666077",
"0.5635756",
"0.5634427",
"0.53961426",
"0.5334729",
"0.52571476",
"0.52398247",
"0.5215903",
"0.5194408",
"0.5111144",
"0.51089895",
"0.505281",
"0.50474066",
"0.5011156",
"0.50028014",
"0.49496236",
"0.4938487",
"0.4927877",
"0.48954463",
"0.485139... | 0.5708708 | 0 |
See recipe_api.py for docs. | def defer_results(self):
return recipe_api.defer_results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_recipe_information(self):\n pass",
"def recipe(self):\n return self.__recipe",
"def test_get_recipe_information_bulk(self):\n pass",
"def get_recipe(self, _id):\n raise NotImplementedError()",
"def test_get_random_recipes(self):\n pass",
"def test_search_re... | [
"0.7399995",
"0.7240145",
"0.7060982",
"0.69131684",
"0.68955857",
"0.6634333",
"0.6622917",
"0.6594366",
"0.6353314",
"0.63221014",
"0.63158387",
"0.6281272",
"0.6268768",
"0.62628794",
"0.6251283",
"0.6206122",
"0.6205642",
"0.61758476",
"0.61579376",
"0.6142557",
"0.613580... | 0.59413797 | 38 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.