InferResult:\",\n \"def inference(self, inputs):\\n # test_2\\n memory = self.get_go_frame(inputs)\\n memory = self._update_memory(memory)\\n\\n self._init_states(inputs, mask=None)\\n self.attention.init_states(inputs)\\n\\n outputs, stop_tokens, alignments, t = [], [], [], 0\\n while True:\\n memory = self.prenet(memory)\\n decoder_output, alignment, stop_token = self.decode(memory)\\n stop_token = torch.sigmoid(stop_token.data)\\n outputs += [decoder_output.squeeze(1)]\\n stop_tokens += [stop_token]\\n alignments += [alignment]\\n\\n if stop_token > self.stop_threshold and t > inputs.shape[0] // 2:\\n break\\n if len(outputs) == self.max_decoder_steps:\\n print(\\\" | > Decoder stopped with 'max_decoder_steps\\\")\\n break\\n\\n memory = self._update_memory(decoder_output)\\n t += 1\\n\\n outputs, stop_tokens, alignments = self._parse_outputs(\\n outputs, stop_tokens, alignments)\\n\\n return outputs, alignments, stop_tokens\",\n \"def inference_context(model):\\n training_mode = model.training\\n model.eval()\\n yield\\n model.train(training_mode)\",\n \"def main():\\n \\\"\\\"\\\"\\n This is just for testing the functions\\n \\\"\\\"\\\"\\n\\n x1 = np.array([1, 1, 1, 1, -1, -1, 1, 1, 1])\\n x2 = np.array([1, -1, 1, 1, 1, 1, 1, -1, 1])\\n x3 = np.array([-1, 1, -1, -1, 1, -1, -1, 1, -1])\\n train_set = np.vstack((x1, x2))\\n train_set = np.vstack((train_set, x3))\\n\\n\\n params = {\\n \\\"epochs\\\": 100,\\n \\\"neurons\\\": len(x1),\\n \\\"learn_method\\\": 'classic'\\n }\\n\\n hop = hop_net.HopfieldNet(train_set, **params)\\n hop.batch_train()\\n show_trained(train_set)\\n\\n x4d = [1,1,1,1,1,1,1,1,1]\\n x5d = [1,1,1,1,-1,-1,1,-1,-1]\\n x45d = np.vstack((x4d, x5d))\\n test_set = np.vstack((x45d, train_set))\\n recalled_set = hop.recall(test_set)\\n for i in range(test_set.shape[0]):\\n show_tested(test_set[i], recalled_set[i])\",\n \"def test_file_inference(self):\\n pp = ParlaiParser(True, True)\\n opt = pp.parse_args(\\n ['--model-file', 'zoo:unittest/transformer_generator2/model']\\n )\\n agent = create_agent(opt, True)\\n self.assertEqual(agent.opt['inference'], 'greedy')\\n\\n pp = ParlaiParser(True, True)\\n opt = pp.parse_args(\\n [\\n '--model-file',\\n 'zoo:unittest/transformer_generator2/model',\\n '--beam-size',\\n '5',\\n ]\\n )\\n agent = create_agent(opt, True)\\n self.assertEqual(agent.opt['inference'], 'beam')\",\n \"def run_infer(infer_model, model_dir, infer_sess):\\n with infer_model.graph.as_default():\\n loaded_infer_model, global_step = model_helper.create_or_load_model(\\n model_dir, infer_model.model, infer_sess)\\n \\n output_tuple = loaded_infer_model.infer(infer_sess)\\n return output_tuple\",\n \"def get_ige_inference(\\n inputs, output_spec, y0_inference_fn=None,\\n energy_fn=get_combined_energy, inner_opt_fn=UnrolledSGD,\\n y0_model_weights_path=None):\\n p2 = inputs['pose_2d']\\n if y0_inference_fn is None:\\n from ige.hpe.models import get_baseline_inference\\n y0_inference_fn = get_baseline_inference\\n y0 = y0_inference_fn(p2, output_spec)\\n\\n # load weights\\n y0_model = tf.keras.models.Model(inputs=p2, outputs=y0)\\n if y0_model_weights_path is not None:\\n y0_model_weights_path = os.path.expanduser(y0_model_weights_path)\\n if os.path.isdir(y0_model_weights_path):\\n from ige.callbacks import restore_model\\n restore_model(y0_model, y0_model_weights_path)\\n else:\\n y0_model.load_weights(y0_model_weights_path)\\n logging.info('Restored weights from %s' % y0_model_weights_path)\\n \\n inner_opt = inner_opt_fn(\\n energy_fn, num_optimized=1)\\n \\n intrinsics = inputs['intrinsics']\\n final_pred, predictions = inner_opt([\\n y0,\\n intrinsics['radial_dist_coeff'],\\n intrinsics['tangential_dist_coeff'],\\n p2])\\n del final_pred\\n predictions = tf.keras.layers.Concatenate(axis=0)([\\n tf.keras.layers.Lambda(tf.expand_dims, arguments=dict(axis=0))(y0),\\n predictions])\\n return predictions\",\n \"def _train_or_inference(self, hparams, res):\\n\\t\\tif self.mode == 'train':\\n\\t\\t\\tself.sample_id = res[1]\\n\\t\\t\\tself.loss = res[2]\\n\\t\\t\\tself.loss_per_token = res[3]\\n\\t\\t\\tself.kl_loss = res[4]\\n\\t\\telif self.mode == 'eval':\\n\\t\\t\\tself.loss = res[2]\\n\\t\\telif self.mode == 'infer':\\n\\t\\t\\tself.infer_logtis, self.sample_id = res[0], res[1]\\n\\n\\t\\tif self.mode != 'infer':\\n\\t\\t\\tself.predict_count = tf.reduce_sum(self.seq_length_decoder_input_data)\\n\\t\\t\\n\\t\\tif self.enable_vae and not self.pre_train:\\n\\t\\t\\tparams = get_scpecific_scope_params('dynamic_seq2seq/transfer')\\n\\t\\telse:\\n\\t\\t\\tparams = tf.trainable_variables()\\n\\t\\t\\n\\t\\t# set learning rate\\n\\t\\tif self.mode == 'train':\\n\\t\\t\\tself.learning_rate = tf.constant(hparams.learning_rate)\\n\\t\\t\\t# warm-up or decay\\n\\t\\t\\tself.learning_rate = self._get_learning_rate_warmup_decay(hparams)\\n\\n\\t\\t\\t# Optimier\\n\\t\\t\\tif hparams.optimizer == 'sgd':\\n\\t\\t\\t\\topt = tf.train.GradientDescentOptimizer(self.learning_rate)\\n\\t\\t\\telif hparams.optimizer == 'adam':\\n\\t\\t\\t\\topt = tf.train.AdamOptimizer(self.learning_rate)\\n\\t\\t\\telse:\\n\\t\\t\\t\\t_error('Unknown optimizer type {}'.format(hparams.optimizer))\\n\\t\\t\\t\\traise ValueError\\n\\t\\t\\t\\n\\t\\t\\t# Gradients\\n\\t\\t\\tgradients = tf.gradients(self.loss, params)\\n\\t\\t\\tclipped_gradients, _ = tf.clip_by_global_norm(\\n\\t\\t\\t\\tgradients, 5.0)\\n\\t\\t\\tself.update = opt.apply_gradients(zip(clipped_gradients, params), global_step=self.global_step)\\n\\t\\t\\t\\t\\n\\t\\t\\t# Summary\\n\\t\\t\\tself.train_summary = tf.summary.merge(\\n\\t\\t\\t\\t[tf.summary.scalar('lr', self.learning_rate),\\n\\t\\t\\t\\ttf.summary.scalar('loss', self.loss)])\",\n \"def __call__(self, x_input):\\n reuse = True if self.built else None\\n\\n scopes = [\\n inception.inception_v3_arg_scope(), inception_v3.inception_v3_arg_scope(),\\n inception_resnet_v2.inception_resnet_v2_arg_scope()]\\n models = [\\n inception.inception_v3, inception_v3.inception_v3,\\n inception_resnet_v2.inception_resnet_v2]\\n weights = [0.2, 0.2, 0.6]\\n for idx, scope in enumerate(scopes):\\n with slim.arg_scope(scope):\\n model = models[idx]\\n weight = weights[idx]\\n result = model(x_input, num_classes=self.num_classes, is_training=False, reuse=reuse)\\n if idx == 0:\\n logits = result[0] * weight\\n aux_logits = result[1]['AuxLogits'] * weight\\n else:\\n logits += result[0] * weight\\n aux_logits += result[1]['AuxLogits'] * weight\\n\\n self.built = True\\n predictions = layers_lib.softmax(logits, scope='Predictions')\\n return logits, aux_logits, predictions\",\n \"def evaluate_model(\\n self,\\n model_file: Path,\\n vcf_snippy: Path = None,\\n vcf_ont: Path = None,\\n stats_ont: Path = None,\\n dir_snippy: Path = None,\\n dir_ont: Path = None,\\n caller: str = 'clair',\\n prefix: str = \\\"prefix\\\",\\n break_complex: bool = True,\\n mask_weak: float = 0.8\\n ):\\n\\n self.evaluation_dir.mkdir(parents=True, exist_ok=True)\\n\\n model, use_features = self.load_model(model_file=model_file)\\n\\n if dir_snippy and dir_ont:\\n comparisons = self.get_evaluation_comparisons(dir_snippy=dir_snippy, dir_ont=dir_ont)\\n stats_ont = None\\n else:\\n comparisons = [vcf_snippy, vcf_ont]\\n stats_ont = stats_ont\\n\\n self.logger.info(f\\\"Reading files from reference (Snippy) and variant (ONT) callers\\\")\\n ont_with_truth, snippies, _ = self.get_data_from_comparisons(\\n comparisons=comparisons, caller=caller, break_complex=break_complex, outdir=self.evaluation_dir,\\n prefix=prefix, stats=stats_ont # none if from directory\\n )\\n\\n self.logger.info(f\\\"Parsing features from variant calls for prediction\\\")\\n _, ont_with_features = self.parse_features(ont_calls=ont_with_truth) # same order as snippy_samples\\n\\n classifier_truth_summaries = []\\n application_truth_summaries = []\\n for i, ont in enumerate(ont_with_features):\\n snippy = snippies[i]\\n self.logger.info(\\n f\\\"Predict SNP validity on sample: {ont.name}\\\"\\n )\\n\\n ont = self.predict_with_model(ont, model, use_features, mask_weak=mask_weak)\\n\\n ont.features['classifier_evaluation'] = ont.features.apply(self.classify_snp_prediction, axis=1)\\n\\n classifier_prediction_evaluations = ont.features.classifier_evaluation.value_counts()\\n\\n classifier_truth_summary = self.get_truth_summary(\\n true_positives=classifier_prediction_evaluations.get('true_positive'),\\n true_negatives=classifier_prediction_evaluations.get('true_negative'),\\n false_positives=classifier_prediction_evaluations.get('false_positive'),\\n false_negatives=classifier_prediction_evaluations.get('false_negative'),\\n snippy=None, ont_data=ont.features, name=ont.name\\n )\\n classifier_truth_summaries.append(classifier_truth_summary)\\n\\n self.logger.info(\\n f\\\"Evaluate classifier application to sample {ont.name} vs Snippy reference {snippy.name}\\\"\\n )\\n\\n # Subset the SNPs by feature prediction as if classifier was applied to sample\\n ont.filtered = ont.features[ont.features.prediction == True]\\n\\n # Recompute truth against Snippy reference SNPs\\n ont, app_summary = self.find_true_snps(\\n snippy=snippy, ont=ont, caller=caller, filtered=True\\n ) # after RFF, calls get truth summary internally\\n\\n application_truth_summaries.append(app_summary)\\n\\n classifier_truth_all = pd.DataFrame(classifier_truth_summaries)\\\\\\n .set_index('name').sort_values(by=['name'])\\n\\n application_truth_all = pd.DataFrame(application_truth_summaries)\\\\\\n .set_index('name').sort_values(by=['name'])\\n\\n print(classifier_truth_all)\\n print(application_truth_all)\\n\\n classifier_truth_all.to_csv(self.evaluation_dir / f\\\"{prefix}_classifier_truth.tsv\\\", sep=\\\"\\\\t\\\")\\n application_truth_all.to_csv(self.evaluation_dir / f\\\"{prefix}_application_truth.tsv\\\", sep=\\\"\\\\t\\\")\",\n \"def __call__(self, x_input):\\n reuse = True if self.built else None\\n\\n scopes = [\\n inception.inception_v3_arg_scope(), inception_v3.inception_v3_arg_scope(),\\n inception_resnet_v2.inception_resnet_v2_arg_scope()]\\n models = [\\n inception.inception_v3, inception_v3.inception_v3,\\n inception_resnet_v2.inception_resnet_v2]\\n weights = [0.1, 0.2, 0.7]\\n for idx, scope in enumerate(scopes):\\n with slim.arg_scope(scope):\\n model = models[idx]\\n weight = weights[idx]\\n result = model(x_input, num_classes=self.num_classes, is_training=False, reuse=reuse)\\n if idx == 0:\\n logits = result[0] * weight\\n aux_logits = result[1]['AuxLogits'] * weight\\n else:\\n logits += result[0] * weight\\n aux_logits += result[1]['AuxLogits'] * weight\\n\\n self.built = True\\n predictions = layers_lib.softmax(logits, scope='Predictions')\\n return logits, aux_logits, predictions\",\n \"def dovetail(inference_results):\\n assert inference_results\\n code_tree = inference_results[0].code_tree\\n code_sequence = inference_results[0].code_sequence\\n assert all(res.info.keys() == {'trees_checked', 'candidates'} for res in inference_results)\\n candidates = []\\n for i in count():\\n done = True\\n for res in inference_results:\\n if i < len(res.info['candidates']):\\n candidates.append(res.info['candidates'][i])\\n done = False\\n if done:\\n break\\n trees_checked = sum(res.info['trees_checked'] for res in inference_results)\\n return InferenceResult(code_tree=code_tree, code_sequence=code_sequence, info=dict(trees_checked=trees_checked, candidates=candidates))\",\n \"def infer_step(self, enc_input, dec_input, sampling_bias):\\n # Variable values passed to the model graph\\n feed_dict = {\\n self.model.encoder.input_idx: enc_input,\\n self.model.encoder.static_keep_prob: 1.0,\\n self.model.encoder.rnn_keep_prob: 1.0,\\n self.model.decoder.input_idx: dec_input,\\n self.model.decoder.static_keep_prob: 1.0,\\n self.model.decoder.rnn_keep_prob: 1.0,\\n self.model.decoder.sampling_bias: sampling_bias\\n }\\n # OPs called within the model graph\\n ops = [self.model.predicted_scores, self.model.predicted_idx_eos, self.model.last_prediction]\\n # OP output is returned as numpy arrays\\n predicted_scores, predicted_idx_eos, last_prediction = self.session.run(ops, feed_dict=feed_dict)\\n return predicted_scores, predicted_idx_eos, last_prediction\",\n \"def inference(model, image, batch_size):\\n image = Variable(image)\\n image = image.cuda()\\n return common.time_inference(inference_func=model, \\n inference_func_args={'x': image}, \\n batch_size=batch_size)\",\n \"def image_inference(self, model_name: str, input_data):\\n exec_net, image_input, image_info_input, (n, c, h, w), postprocessor = self.model_loading.load_model(model_name)\\n cap, visualizer, tracker, presenter = self.image_visualizer.visualizer(input_data,model_name)\\n\\n while cap.isOpened():\\n ret, frame = cap.read()\\n if not ret:\\n break\\n # Resize the image to keep the same aspect ratio and to fit it to a window of a target size.\\n scale_x = scale_y = min(h / frame.shape[0], w / frame.shape[1])\\n input_image = cv2.resize(frame, None, fx=scale_x, fy=scale_y)\\n\\n input_image_size = input_image.shape[:2]\\n input_image = np.pad(input_image, ((0, h - input_image_size[0]),\\n (0, w - input_image_size[1]),\\n (0, 0)),\\n mode='constant', constant_values=0)\\n # Change data layout from HWC to CHW.\\n input_image = input_image.transpose((2, 0, 1))\\n input_image = input_image.reshape((n, c, h, w)).astype(np.float32)\\n input_image_info = np.asarray([[input_image_size[0], input_image_size[1], 1]], dtype=np.float32)\\n # Run the net.\\n feed_dict = {image_input: input_image}\\n if image_info_input:\\n feed_dict[image_info_input] = input_image_info\\n outputs = exec_net.infer(feed_dict)\\n # Parse detection results of the current request\\n scores, classes, boxes, masks = postprocessor(\\n outputs, scale_x, scale_y, *frame.shape[:2], h, w, 0.5)\\n os.remove(input_data.filename)\\n class_labels = self.fetch_labels.get_labels(model_name)\\n\\n t = 0\\n for key2 in [class_labels[i] for i in classes]:\\n x1 = str(boxes[t][0])\\n y1 = str(boxes[t][1])\\n x2 = str(boxes[t][2])\\n y2 = str(boxes[t][3])\\n\\n if key2 in self.prediction.keys():\\n value_init = self.prediction.get(key2)\\n self.prediction[key2] = x1, y1, x2, y2\\n value = value_init, self.prediction.get(key2)\\n self.prediction[key2] = value\\n\\n else:\\n self.prediction[key2] = x1, y1, x2, y2\\n\\n t = t + 1\\n\\n with open('./final_json.json', 'w') as file:\\n json.dump(self.prediction, file)\\n\\n with open('./final_json.json','r') as file:\\n json_object = json.load(file)\\n\\n return json_object\\n cv2.destroyAllWindows()\\n cap.release()\",\n \"def evaluate_deep_model(onnx_model, inputs, rt_type=None):\\n if rt_type is None:\\n rt_type = find_inference_engine()\\n if rt_type == rt_onnxruntime:\\n return _evaluate_onnxruntime(onnx_model, inputs)\\n if rt_type == rt_cntk:\\n return _evaluate_cntk(onnx_model, inputs)\\n elif rt_type == rt_caffe2:\\n return _evaluate_caffe2(onnx_model, inputs)\\n else:\\n raise ImportError(\\\"No runtime found. Need either CNTK or Caffe2\\\")\",\n \"def do_parallel_inference(args):\\n from treehmm import random_params, do_inference, plot_params, plot_energy, load_params\\n from treehmm.vb_mf import normalize_trans\\n from treehmm.static import float_type\\n\\n _x = sp.load(args.observe_matrix[0])\\n args.continuous_observations = _x.dtype != sp.int8\\n args.I, _, args.L = _x.shape\\n I = args.I\\n K = args.K\\n L = args.L\\n args.T = 'all'\\n args.free_energy = []\\n args.observe = 'all.npy'\\n args.last_free_energy = 0\\n args.emit_sum = sp.zeros((K, L), dtype=float_type)\\n\\n args.out_dir = args.out_dir.format(timestamp=time.strftime('%x_%X').replace('/', '-'), **args.__dict__)\\n try:\\n print 'making', args.out_dir\\n os.makedirs(args.out_dir)\\n except OSError:\\n pass\\n\\n if args.warm_start:\\n # args.last_free_energy, args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum = load_params(args)\\n # args.warm_start = False\\n print '# loading previous params for warm start from %s' % args.warm_start\\n tmpargs = copy.deepcopy(args)\\n tmpargs.out_dir = args.warm_start\\n tmpargs.observe = 'all.npy'\\n args.free_energy, args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum = load_params(tmpargs)\\n\\n try:\\n args.free_energy = list(args.free_energy)\\n except TypeError: # no previous free energy\\n args.free_energy = []\\n print 'done'\\n args.warm_start = False\\n else:\\n (args.theta, args.alpha, args.beta, args.gamma, args.emit_probs) = \\\\\\n random_params(args.I, args.K, args.L, args.separate_theta)\\n for p in ['free_energy', 'theta', 'alpha', 'beta', 'gamma', 'emit_probs', 'last_free_energy', 'emit_sum']:\\n sp.save(os.path.join(args.out_dir, args.out_params.format(param=p, **args.__dict__)),\\n args.__dict__[p])\\n\\n \\n args.iteration = 0\\n plot_params(args)\\n print '# setting up job arguments'\\n # set up new versions of args for other jobs\\n job_args = [copy.copy(args) for i in range(len(args.observe_matrix))]\\n for j, a in enumerate(job_args):\\n a.observe_matrix = args.observe_matrix[j]\\n a.observe = os.path.split(args.observe_matrix[j])[1]\\n a.subtask = True\\n a.func = None\\n a.iteration = 0\\n a.max_iterations = 1\\n a.quiet_mode = True\\n if j % 1000 == 0:\\n print j\\n\\n if args.run_local:\\n pool = multiprocessing.Pool()\\n else:\\n pool = sge.SGEPool()\\n #job_handle = pool.imap_unordered(do_inference, job_args)\\n\\n converged = False\\n for args.iteration in range(args.max_iterations):\\n # import ipdb; ipdb.set_trace()\\n # fresh parameters-- to be aggregated after jobs are run\\n print 'iteration', args.iteration\\n total_free = 0\\n if args.separate_theta:\\n args.theta = sp.zeros((I - 1, K, K, K), dtype=float_type)\\n else:\\n args.theta = sp.zeros((K, K, K), dtype=float_type)\\n\\n args.alpha = sp.zeros((K, K), dtype=float_type)\\n args.beta = sp.zeros((K, K), dtype=float_type)\\n args.gamma = sp.zeros((K), dtype=float_type)\\n args.emit_probs = sp.zeros((K, L), dtype=float_type)\\n if True: # args.approx == 'clique':\\n args.emit_sum = sp.zeros_like(args.emit_probs, dtype=float_type)\\n else:\\n args.emit_sum = sp.zeros((K, L), dtype=float_type)\\n\\n if args.run_local:\\n iterator = pool.imap_unordered(do_inference, job_args, chunksize=args.chunksize)\\n # wait for jobs to finish\\n for result in iterator:\\n pass\\n else:\\n jobs_handle = pool.map_async(do_inference, job_args, chunksize=args.chunksize)\\n # wait for all jobs to finish\\n for j in jobs_handle:\\n j.wait()\\n\\n # sum free energies and parameters from jobs\\n for a in job_args:\\n # print '# loading from %s' % a.observe\\n free_energy, theta, alpha, beta, gamma, emit_probs, emit_sum = load_params(a)\\n # print 'free energy for this part:', free_energy\\n if len(free_energy) > 0:\\n last_free_energy = free_energy[-1]\\n else:\\n last_free_energy = 0\\n total_free += last_free_energy\\n args.theta += theta\\n args.alpha += alpha\\n args.beta += beta\\n args.gamma += gamma\\n args.emit_probs += emit_probs\\n args.emit_sum += emit_sum\\n\\n # renormalize and plot\\n print 'normalize aggregation... total free energy is:', total_free\\n args.free_energy.append(total_free)\\n if len(args.free_energy) > 1 and args.free_energy[-1] != 0 and args.free_energy[-2] != 0 \\\\\\n and abs((args.free_energy[-2] - args.free_energy[-1]) / args.free_energy[-2]) < args.epsilon:\\n print 'converged. free energy diff:', args.free_energy, abs(args.free_energy[-2] - args.free_energy[-1]) / args.free_energy[-2]\\n converged = True\\n normalize_trans(args.theta, args.alpha, args.beta, args.gamma)\\n # if True: #args.approx == 'clique':\\n # #print 'clique emit renorm'\\n # args.emit_probs[:] = args.emit_probs / args.emit_sum\\n # else:\\n # args.emit_probs[:] = sp.dot(sp.diag(1./args.emit_sum), args.emit_probs)\\n args.emit_probs[:] = sp.dot(sp.diag(1. / args.emit_sum), args.emit_probs)\\n for a in job_args:\\n a.theta, a.alpha, a.beta, a.gamma, a.emit_probs, a.emit_sum = args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum\\n\\n for p in ['free_energy', 'theta', 'alpha', 'beta', 'gamma', 'emit_probs', 'lmd', 'tau']:\\n try:\\n sp.save(os.path.join(args.out_dir, args.out_params.format(param=p, **args.__dict__)),\\n args.__dict__[p])\\n except KeyError:\\n pass\\n plot_params(args)\\n plot_energy(args)\\n\\n if args.save_Q >= 3:\\n print '# reconstructing chromosomes from *chunk*',\\n in_order = {}\\n # Q_chr16_all.trimmed.chunk*.npy => Q_chr16_all.trimmed.npy\\n all_chunks = glob.glob(os.path.join(args.out_dir, '*_Q_*chunk*.npy'))\\n for chunk in all_chunks:\\n print chunk\\n chunk_num = int(re.search(r'chunk(\\\\d+)', chunk).groups()[0])\\n chrom_out = re.sub('chunk(\\\\d+)\\\\.', '', chunk)\\n if chrom_out not in in_order:\\n in_order[chrom_out] = {}\\n in_order[chrom_out][chunk_num] = sp.load(chunk)\\n for chrom_out in in_order:\\n print 'reconstructing chromosomes from', in_order[chrom_out]\\n if len(in_order[chrom_out]) > 1:\\n final_array = sp.concatenate((in_order[chrom_out][0], in_order[chrom_out][1]), axis=1)\\n for i in range(2, max(in_order[chrom_out])):\\n final_array = sp.concatenate((final_array, in_order[chrom_out][i]), axis=1)\\n else:\\n final_array = in_order[chrom_out][0]\\n sp.save(chrom_out, final_array)\\n\\n if converged:\\n break\",\n \"def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2, num_code_units, filter_size, batch_size=BATCH_SIZE):\\n shape = tuple([None]+list(input_shape[1:]))\\n print(shape)\\n l_in = lasagne.layers.InputLayer(shape=shape)\\n\\n print(\\\"Input shape: \\\",lasagne.layers.get_output_shape(l_in))\\n\\n # print(shaped_units)\\n # shaped_units = shaped_units[0]\\n shaped_units = 2800\\n\\n # print(shape)\\n\\n l_conv2D_1 = lasagne.layers.Conv2DLayer(\\n l_in, \\n num_filters=8,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n print(\\\"Conv 2D shape: \\\",lasagne.layers.get_output_shape(l_conv2D_1))\\n\\n l_reshape_1 = lasagne.layers.ReshapeLayer(\\n l_conv2D_1,\\n shape=(([0], -1))\\n )\\n\\n print(\\\"Reshape 1 shape: \\\", lasagne.layers.get_output_shape(l_reshape_1))\\n\\n l_hidden_1 = lasagne.layers.DenseLayer(\\n l_reshape_1,\\n num_units= num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 1 shape: \\\", lasagne.layers.get_output_shape(l_hidden_1))\\n\\n l_code_layer = lasagne.layers.DenseLayer(\\n l_hidden_1,\\n num_units=num_code_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Code layer shape: \\\",lasagne.layers.get_output_shape(l_code_layer))\\n\\n l_hidden_2 = lasagne.layers.DenseLayer(\\n l_code_layer,\\n num_units=num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 2 shape: \\\",lasagne.layers.get_output_shape(l_hidden_2))\\n\\n l_hidden_3 = lasagne.layers.DenseLayer(\\n l_hidden_2,\\n num_units=shaped_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 3 shape: \\\",lasagne.layers.get_output_shape(l_hidden_3))\\n\\n l_reshape_2 = lasagne.layers.ReshapeLayer(\\n l_hidden_3,\\n shape=(([0],8,7,50))\\n )\\n\\n print(\\\"Reshape 2 shape: \\\",lasagne.layers.get_output_shape(l_reshape_2))\\n\\n l_out = lasagne.layers.Conv2DLayer(\\n l_reshape_2, \\n num_filters=1,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n # print(\\\"Deconv shape: \\\",lasagne.layers.get_output_shape(l_deconv2D_1))\\n\\n print(\\\"Output shape: \\\",lasagne.layers.get_output_shape(l_out))\\n\\n return l_out\",\n \"def do_inference(self, init_y = None, init_z = None, output_file = None):\\n BaseSampler.do_inference(self, output_file=None)\\n if init_y is None:\\n init_y = np.random.randint(0, 2, (self.k, self.d))\\n else:\\n assert(type(init_y) is np.ndarray)\\n assert(init_y.shape == (self.k, self.d))\\n if init_z is None:\\n init_z = np.random.randint(0, 2, (len(self.obs), self.k))\\n else:\\n assert(type(init_z) is np.ndarray)\\n assert(init_z.shape == (len(self.obs), self.k))\\n\\n if self.cl_mode:\\n timing_stats = self._cl_infer_yz(init_y, init_z, output_file)\\n else:\\n timing_stats = self._infer_yz(init_y, init_z, output_file)\\n\\n # report the results\\n if output_file is sys.stdout:\\n if self.record_best:\\n final_y, final_z = self.best_sample[0]\\n num_of_feats = final_z.shape[1]\\n print('parameter,value',\\n 'alpha,%f' % self.alpha, 'lambda,%f' % self.lam, 'theta,%f' % self.theta,\\n 'epislon,%f' % self.epislon, 'inferred_K,%d' % num_of_feats,\\n 'gpu_time,%f' % timing_stats[0], 'total_time,%f' % timing_stats[1],\\n file = output_file, sep='\\\\n')\\n\\n np.savetxt(output_file, final_z, fmt=\\\"%d\\\", comments='', delimiter=',',\\n header=','.join(['feature%d' % _ for _ in range(num_of_feats)]))\\n\\n for k in xrange(num_of_feats):\\n print('Feature %d\\\\n---------' % k, file = output_file)\\n np.savetxt(output_file, final_y[k].reshape(self.img_w, self.img_h),\\n fmt=\\\"%d\\\", delimiter=',')\\n \\n else:\\n if self.record_best:\\n final_y, final_z = self.best_sample[0]\\n num_of_feats = final_z.shape[1]\\n try: os.mkdir(output_file)\\n except: pass\\n print('parameter,value',\\n 'alpha,%f' % self.alpha, 'lambda,%f' % self.lam, 'theta,%f' % self.theta,\\n 'epislon,%f' % self.epislon, 'inferred_K,%d' % num_of_feats,\\n 'gpu_time,%f' % timing_stats[0], 'total_time,%f' % timing_stats[1],\\n file = gzip.open(output_file + 'parameters.csv.gz', 'w'), sep = '\\\\n')\\n \\n np.savetxt(gzip.open(output_file + 'feature_ownership.csv.gz', 'w'), final_z,\\n fmt=\\\"%d\\\", comments='', delimiter=',',\\n header=','.join(['feature%d' % _ for _ in range(num_of_feats)]))\\n\\n for k in xrange(num_of_feats):\\n np.savetxt(gzip.open(output_file + 'feature_%d_image.csv.gz' % k, 'w'),\\n final_y[k].reshape(self.img_w, self.img_h), fmt=\\\"%d\\\", delimiter=',')\\n else:\\n try: os.mkdir(output_file)\\n except: pass\\n print('parameter,value',\\n 'alpha,%f' % self.alpha, 'lambda,%f' % self.lam, 'theta,%f' % self.theta,\\n 'epislon,%f' % self.epislon,\\n 'gpu_time,%f' % timing_stats[0], 'total_time,%f' % timing_stats[1],\\n file = gzip.open(output_file + 'parameters.csv.gz', 'w'), sep = '\\\\n')\\n np.savez_compressed(output_file + 'feature_ownership.npz', self.samples['z'])\\n np.savez_compressed(output_file + 'feature_images.npz', self.samples['y'])\\n\\n return timing_stats\",\n \"def run_neural_network(mode, arg_placeholders, arg_data, arg_hyperparams, arg_paths_extensions, **kwargs):\\n\\n\\tif verbose: print('model_tensorflow.run_neural_network() called')\\n\\n\\t# Placeholders\\n\\tx, y = arg_placeholders['x'], arg_placeholders['y'] \\n\\tkeep_prob = arg_placeholders['keep_prob']\\n\\t# Data\\n\\tx_trn, y_trn, x_vld, y_vld = (arg_data['x_trn'], arg_data['y_trn'], \\n\\t\\t\\t\\t\\t\\t\\t\\t arg_data['x_vld'], arg_data['y_vld'])\\n\\tx_tst, y_tst = arg_data['x_tst'], arg_data['y_tst']\\n\\t# Hyperparameters\\n\\tuse_stored_weights, user_model = (arg_hyperparams['use_stored_weights'], \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t arg_hyperparams['user_model'])\\n\\tlayer_sizes, val_perc, mini_batch_size, epochs, seed = (arg_hyperparams['layer_sizes'], \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\targ_hyperparams['val_perc'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\targ_hyperparams['mini_batch_size'], \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\targ_hyperparams['epochs'], \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\targ_hyperparams['seed'])\\n\\tlrn_rate, kp = arg_hyperparams['lrn_rate'], arg_hyperparams['kp']\\n\\t# Paths and extensions \\n\\tstore_path, out_ext, fv_ext = (arg_paths_extensions['store_path'], \\n\\t\\t\\t\\t\\t\\t\\t\\t arg_paths_extensions['out_ext'], \\n\\t\\t\\t\\t\\t\\t\\t\\t arg_paths_extensions['fv_ext'])\\n\\t# Weights\\n\\tweights_biases = {}\\n\\tif mode == trn or mode == tst:\\n\\t\\tweights_biases = create_neural_network(mode, layer_sizes, use_stored_weights, store_path)\\n\\telif mode == app:\\n\\t\\tweights_biases = kwargs['weights_biases']\\n#\\tprint('(1) initial weights W1:')\\n#\\tprint('W1', sess.run(weights_biases['weights']['W1'][0]))\\n\\n\\t# Logits (linear output from the network's output layer), softmaxes, accuracy\\n\\tlogits = evaluate_neural_network(x, keep_prob, len(layer_sizes) - 1, seed,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t weights_biases['weights'], weights_biases['biases'])\\n\\tsoftm = tf.nn.softmax(logits)\\n\\tpred_class = tf.argmax(softm)\\n\\tcorrect = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1))\\n\\taccuracy = tf.reduce_mean(tf.cast(correct, 'float'))\\n\\n\\tif mode == trn or mode == tst:\\t\\t\\n\\t\\tif mode == trn:\\n\\t\\t\\t# Declare cost and optimizer here: optimizer has global variables that must be initialised (see below)\\n\\t\\t\\tcost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))\\n\\t\\t\\toptimizer = tf.train.AdamOptimizer(learning_rate=lrn_rate).minimize(cost)\\n\\n\\t\\t# Initialise all global variables that have not been initialised yet (e.g., variables for Adam). See \\n\\t\\t# https://stackoverflow.com/questions/35164529/in-tensorflow-is-there-any-way-to-just-initialize-uninitialised-variables\\n\\t\\t# (answer by Salvador Dali) \\n\\t\\tglobal_vars = tf.global_variables()\\n\\t\\tis_not_initialized = sess.run([tf.is_variable_initialized(var) for var in global_vars])\\n\\t\\tnot_initialized_vars = [v for (v, f) in zip(global_vars, is_not_initialized) if not f]\\n\\t\\tif verbose: print('uninitialised variables:', [str(i.name) for i in not_initialized_vars])\\n\\t\\tif len(not_initialized_vars):\\n\\t\\t\\tsess.run(tf.variables_initializer(not_initialized_vars))\\n\\t\\tif verbose: print('uninitialised variables:', sess.run(tf.report_uninitialized_variables()))\\n\\n\\t\\tsaver = tf.train.Saver()\\n\\n\\t# Save weights and model output (softmaxes)\\n\\tif mode == trn:\\n\\t\\tif val_perc != 0:\\n\\t\\t\\t# Logits (linear output from the network's output layer), softmaxes, accuracy\\n\\t\\t\\tlogits_vld = evaluate_neural_network(x, keep_prob, len(layer_sizes) - 1, seed,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t weights_biases['weights'], weights_biases['biases'])\\n\\t\\t\\tsoftm_vld = tf.nn.softmax(logits_vld)\\n\\t\\t\\tpred_class_vld = tf.argmax(softm_vld)\\n\\t\\t\\tcorrect_vld = tf.equal(tf.argmax(logits_vld, 1), tf.argmax(y, 1))\\n\\t\\t\\taccuracy_vld = tf.reduce_mean(tf.cast(correct_vld, 'float'))\\n#\\t\\tprint('(2) weights W1 before training (should be the same as (1))')\\n#\\t\\tprint('W1', sess.run(weights_biases['weights']['W1'][0]))\\n\\n\\t\\ttotal_cost = []\\n\\t\\taccs_trn = []\\n\\t\\taccs_vld = []\\n\\t\\tbest_acc = 0.0\\t\\t\\n\\t\\tfor epoch in range(epochs): # one epoch is one fwd-bwd propagation over the complete dataset\\n\\t\\t\\tepoch_loss = 0\\n\\t\\t\\tfor _ in range(int(len(x_trn)/mini_batch_size)):\\n\\t\\t\\t\\tepoch_x, epoch_y = x_trn, y_trn\\n\\t\\t\\t\\t_, c, acc_trn, sm_trn = sess.run([optimizer, cost, accuracy, softm], \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t feed_dict = {x: epoch_x, y: epoch_y, keep_prob: kp})\\n\\t\\t\\t\\tepoch_loss += c\\n\\n\\t\\t\\t\\tif check_accuracies and (epoch == 10 or epoch == 20):\\n\\t\\t\\t\\t\\tprint('Accuracy check (trn)')\\n\\t\\t\\t\\t\\tprint('acc_trn :', acc_trn)\\n\\t\\t\\t\\t\\tcheck_accuracy(epoch_x, epoch_y, sm_trn)\\n#\\t\\t\\tprint('(3) updated weights W1 after one training epoch (should be different from (2))')\\n#\\t\\t\\tprint('W1', sess.run(weights_biases['weights']['W1'][0]))\\n\\n\\t\\t\\t# In case of mini-batch gradient descent, accumulate the results from the mini batches\\n\\t\\t\\t# acc_trn = ...\\n\\t\\t\\t# sm_trn_comb = ...\\n\\t\\t\\t# sm_trn = sm_trn_comb \\n\\n\\t\\t\\tprint('epoch', str(epoch) + '/' + str(epochs), 'completed: loss =', epoch_loss, 'acc =', acc_trn)\\n\\n\\t\\t\\t# Non-user model (model selection) case: save weights and softmaxes for the current epoch \\n\\t\\t\\t# if its acc_vld is the highest so far. Check acc_vld every tenth epoch\\n\\t\\t\\tif not user_model and epoch % 10 == 0:\\n\\t\\t\\t\\ttotal_cost.append(epoch_loss)\\n\\t\\t\\t\\taccs_trn.append(acc_trn)\\n\\t\\t\\t\\tif val_perc != 0:\\n\\t\\t\\t\\t\\tif arg_hyperparams['ismir_2018']:\\n\\t\\t\\t\\t\\t\\t# This is incorrect: sess.run() should not be run again (see loop over the mini \\n\\t\\t\\t\\t\\t\\t# batches) on accuracy and softm, which are for calculating trn results, but on \\n\\t\\t\\t\\t\\t\\t# accuracy_vld and softm_vld. Rerunning leads to unwanted changes in tensor calculations\\n\\t\\t\\t\\t\\t\\t# NB: for the ISMIR paper, sm_vld is not calculated\\n\\t\\t\\t\\t\\t\\tacc_vld, sm_vld = sess.run([accuracy, softm],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\t\\tfeed_dict={x: x_vld, y: y_vld, keep_prob: 1.0})\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tacc_vld, sm_vld = sess.run([accuracy_vld, softm_vld],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\t\\tfeed_dict={x: x_vld, y: y_vld, keep_prob: 1.0})\\n\\t\\t\\t\\t\\taccs_vld.append(acc_vld)\\n\\n\\t\\t\\t\\t\\tif check_accuracies and (epoch == 10 or epoch == 20):\\n\\t\\t\\t\\t\\t\\tprint('Accuracy check (vld)')\\n\\t\\t\\t\\t\\t\\tprint('acc_vld :', acc_vld)\\n\\t\\t\\t\\t\\t\\tcheck_accuracy(x_vld, y_vld, sm_vld)\\n\\n\\t\\t\\t\\t\\tif acc_vld > best_acc:\\n\\t\\t\\t\\t\\t\\tbest_acc = acc_vld\\n\\t\\t\\t\\t\\t\\t# Save weights\\n\\t\\t\\t\\t\\t\\tsave_path = saver.save(sess, store_path + 'weights/' + 'trained.ckpt')\\n\\t\\t\\t\\t\\t\\t# Save softmaxes (trn and vld)\\n\\t\\t\\t\\t\\t\\tif arg_hyperparams['ismir_2018']:\\n\\t\\t\\t\\t\\t\\t\\t# This is incorrect: sess.run() should not be run again (see loop over the mini \\n\\t\\t\\t\\t\\t\\t\\t# batches) on softm. Rerunning leads to unwanted changes in tensor calculations \\n\\t\\t\\t\\t\\t\\t\\tsoftmaxes_trn = sess.run([softm, pred_class], \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t feed_dict={x: x_trn, keep_prob: kp})[0]\\n\\t\\t\\t\\t\\t\\t\\tnp.savetxt(store_path + out_ext, softmaxes_trn, delimiter=',')\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tnp.savetxt(store_path + out_ext, sm_trn, delimiter=',')\\n\\t\\t\\t\\t\\t\\tnp.savetxt(store_path + out_ext.replace('trn', 'vld'), sm_vld, delimiter=',')\\n\\t\\t\\t\\t\\t\\t# Save best epoch\\n\\t\\t\\t\\t\\t\\twith open(store_path + 'best_epoch.txt', 'w') as text_file:\\n\\t\\t\\t\\t\\t\\t\\ttext_file.write('highest accuracy on the validation set (' + \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tstr(best_acc) + ') in epoch ' + str(epoch))\\n\\t\\t\\t\\t\\t\\tnp.savetxt(store_path + 'best_epoch.csv', [[int(epoch), acc_vld]], delimiter=',')\\n\\n\\t\\t# User model case: save weights and softmaxes for the final epoch \\n\\t\\tif user_model:\\n\\t\\t\\tsave_path = saver.save(sess, store_path + 'weights/' + 'trained.ckpt')\\n\\t\\t\\tnp.savetxt(store_path + out_ext, sm_trn, delimiter=',')\\n\\n\\t\\t# Plot the trn and vld accuracy\\n\\t\\tif plot_or_not:\\n\\t\\t\\tplt.plot(np.squeeze(accs_trn))\\n\\t\\t\\tplt.plot(np.squeeze(accs_vld))\\n\\t\\t\\tplt.ylabel('acc')\\n\\t\\t\\tplt.xlabel('epochs (/10)')\\n\\t\\t\\tax = plt.subplot(111)\\n\\t\\t\\tax.set_prop_cycle('color', ['red', 'green'])\\n#\\t\\t\\tplt.gca().set_prop_cycle(['red', 'green'])\\n\\t\\t\\tplt.title('accuracy on training and validation set')\\n\\t\\t\\tplt.legend(['trn', 'vld'], loc='lower right')\\n\\t\\t\\tplt.savefig(store_path + 'trn_and_vld_acc.png')\\n\\n\\t# Save model output (softmaxes)\\n\\tif mode == tst:\\n\\t\\tacc_tst, sm_tst = sess.run([accuracy, softm], feed_dict={x: x_tst, y: y_tst, keep_prob: kp})\\n\\t\\tnp.savetxt(store_path + out_ext, sm_tst, delimiter=',')\\n\\t\\tif check_accuracies:\\n\\t\\t\\tprint('Accuracy check (tst)')\\n\\t\\t\\tprint('acc_tst :', acc_tst)\\n\\t\\t\\tcheck_accuracy(x_tst, y_tst, sm_tst)\\n\\n\\t# Save or return model output (softmaxes)\\n\\tif mode == app:\\n\\t\\tload_and_save_features = False\\n\\t\\t# Get features and reshape to get required shape (1, number of features)\\n\\t\\tx_app = (genfromtxt(store_path + fv_ext, delimiter=',') if load_and_save_features else \\n\\t\\t\\t\\t np.array(kwargs['feature_vector']))\\n\\t\\tx_app = x_app.reshape(1, -1)\\n\\t\\tsm_app = sess.run(softm, feed_dict={x: x_app, keep_prob: kp})\\n\\t\\tif load_and_save_features:\\n\\t\\t\\tnp.savetxt(store_path + out_ext, sm_app, delimiter=',')\\n\\t\\telse:\\n\\t\\t\\treturn sm_app[0]\",\n \"def create_inference_session(self):\\n sess_options = onnxruntime.SessionOptions()\\n sess_options.graph_optimization_level = onnxruntime.GraphOptimizationLevel.ORT_DISABLE_ALL\\n self.infer_session = onnxruntime.InferenceSession(\\n self.augmented_model_path,\\n sess_options=sess_options,\\n providers=self.execution_providers,\\n )\",\n \"def evaluate_model():\\n\\n # Get the processed data (in proper format to evaluate the NER model)\\n data = get_json_from_file_path(PROCESSED_DATA_PATH)\\n # Split the dataset for training and test as we did for training\\n train_data, test_data = train_test_split(data, train_size=0.7, \\n random_state=4)\\n\\n # Load the model trained\\n try:\\n ner_model = spacy.load(OUTPUT_MODEL_PATH)\\n except Exception as err:\\n msg = f'Could not load the model. Error: {err}'\\n raise Exception(msg)\\n\\n # Compute evaluation scores\\n print('Computing metrics...')\\n scores = evaluate(ner_model, test_data)\\n # General metrics of the model\\n f_score = scores.get('ents_f')\\n precision = scores.get('ents_p')\\n recall = scores.get('ents_r')\\n print('\\\\nScoring:')\\n print(f'F-score: {f_score}')\\n print(f'Precision: {precision}')\\n print(f'Recall: {recall}')\\n\\n # Get the specific scores for each entity \\n scores_per_entity = scores.get('ents_per_type')\\n # Get the F-score of the entities\\n f_scores_of_entities = []\\n for entity_scores in scores_per_entity.values():\\n f_scores_of_entities.append(entity_scores['f'])\\n # Compute the macro averaged F-score\\n macro_avg_f_score = sum(f_scores_of_entities)/len(f_scores_of_entities)\\n print(f'Macro averaged F-score: {macro_avg_f_score}')\\n \\n print('\\\\nScores per entity;')\\n print('{:<15} {:<10} {:<10} {:<10}'.format('Entity','F-score','Precision','Recall'))\\n for key, value in scores_per_entity.items():\\n entity = key\\n f, p, r = value['f'], value['p'], value['r']\\n print('{:<15} {:<10.2f} {:<10.2f} {:<10.2f}'.format(entity, f, p, r))\",\n \"def __call__(self, initial_lr, step, epoch):\\n\\n pass\",\n \"def initial_inference(self, observations: np.ndarray) -> typing.Tuple[np.ndarray, np.ndarray, float]:\\n # Pad batch dimension\\n observations = observations[np.newaxis, ...]\\n\\n s_0, pi, v = self.neural_net.forward.predict(observations)\\n\\n # Cast bins to scalar\\n v_real = support_to_scalar(v, self.net_args.support_size)\\n\\n return s_0[0], pi[0], np.ndarray.item(v_real)\",\n \"def _do_infer(stream_manager_api, data_input):\\n stream_name = b'segmentation'\\n unique_id = stream_manager_api.SendData(\\n stream_name, 0, data_input)\\n if unique_id < 0:\\n raise RuntimeError(\\\"Failed to send data to stream.\\\")\\n\\n keys = [b\\\"mxpi_tensorinfer0\\\"]\\n keyVec = StringVector()\\n for key in keys:\\n keyVec.push_back(key)\\n infer_result = stream_manager_api.GetProtobuf(stream_name, 0, keyVec)\\n print(infer_result)\\n if infer_result.size() == 0:\\n print(\\\"infer_result is null\\\")\\n exit()\\n\\n TensorList = MxpiDataType.MxpiTensorPackageList()\\n TensorList.ParseFromString(infer_result[0].messageBuf)\\n data = np.frombuffer(\\n TensorList.tensorPackageVec[0].tensorVec[0].dataStr, dtype=np.float32)\\n data = data.reshape(1, 19, 1024, 2048)\\n return data\",\n \"def hard_judge(self, infer_result=None):\\r\\n raise NotImplementedError\",\n \"def make_inference_functions(encode_model, predict_model, pretrained_model, attention_model=None):\\n pretrained_layers = {l.name: l for l in pretrained_model.layers}\\n\\n print(encode_model.get_weights())\\n \\n encode_weights = []\\n predict_weights = []\\n attention_weights = []\\n\\n for l in encode_model.get_weights():\\n lname = l.name\\n try:\\n encode_weights.append(pretrained_layers[lname].get_weights())\\n print('Got encoder weight for layer {}'.format(lname))\\n except:\\n print('Encoder skipping layer {}'.format(lname))\\n\\n for l in predict_model.layers:\\n lname = l.name\\n try:\\n predict_weights.append(pretrained_layers[lname].get_weights())\\n print('Got predict weight for layer {}'.format(lname))\\n except:\\n print('Encoder skipping layer {}'.format(lname))\\n\\n if attention_model is not None:\\n for l in attention_model.layers:\\n lname = l.name\\n attention_weights.append(pretrained_layers[lname].get_weights())\\n print('Got attention weight for layer {}'.format(lname))\\n\\n # for lname, l in pretrained_layers.items():\\n # w = l.get_weights()\\n # if 'encoder' in lname or 'deep' in lname:\\n # try:\\n # # encode_model.get_layer(lname).set_weights(w)\\n # print('Got encoder weight for layer {}'.format(lname))\\n # encode_weights.append(w)\\n # except:\\n # pass\\n \\n # if 'encoder' not in lname:\\n # try:\\n # # predict_model.get_layer(lname).set_weights(w)\\n # print('Got predict weight for layer {}'.format(lname))\\n # predict_weights.append(w)\\n # except:\\n # pass\\n\\n # if (attention_model is not None) and ('encoder' not in lname):\\n # try:\\n # # attention_model.get_layer(lname).set_weights(w)\\n # print('Got attention weight for layer {}'.format(lname))\\n # attention_weights.append(w)\\n # except:\\n # pass\\n\\n encode_model.set_weights(encode_weights)\\n predict_model.set_weights(predict_weights)\\n\\n if attention_model is not None:\\n attention_model.set_weights(attention_weights)\\n return encode_model, predict_model, attention_model\\n else:\\n return encode_model, predict_model\",\n \"def run():\\n\\n df = read_input() # the parameters\\n df = add_time_period(df) # a feature\\n df = is_holiday(df) # a feature\\n df = scale_continous(df) # continous feature transformation\\n df = encode_dummy(df) # categorical feature transformation\\n df = order_columns(df) # ordering model inputs\\n model = load_model() # the multiple linear regression model\\n prediction = int(model.predict(df)) # form a prediction\\n return prediction # return the prediction\",\n \"def evaluate():\\n global_step = tf.Variable(0, name='global_step', trainable=False)\\n\\n # randomize the inputs look\\n x, y_, data, keep_prob = blood_model.prepare_input()\\n # Get images and labels for blood_model.\\n conv_output, W_conv1, W_conv2, h_conv1, h_conv2 = blood_model.inference(data, keep_prob)\\n conv_predictions = blood_model.predictions(conv_output)\\n\\n sess = tf.InteractiveSession()\\n\\n sess.run(tf.initialize_all_variables())\\n\\n saver = tf.train.Saver()\\n\\n ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)\\n if ckpt and ckpt.model_checkpoint_path:\\n # Restores from checkpoint\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n # extract global_step from it.\\n global_step_number = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])\\n print(\\\"checkpoint found at step %d\\\", global_step_number)\\n else:\\n print('No checkpoint file found')\\n return\\n\\n blood_dataset = np.load('../../labeller/data/wbc_p4-1_p.npy')\\n blood_dataset = np.transpose(blood_dataset, (0, 2, 3, 1))\\n predictions = sess.run(conv_predictions, feed_dict={x: blood_dataset, keep_prob: 1.0})\\n np.save('../results/predictions.npy', np.argmax(predictions, 1))\\n display_predictions(blood_dataset, np.argmax(predictions, 1))\",\n \"def infer(self, x, batch_size=None, **kwargs):\\n if not batch_size:\\n batch_size = self.batch_size\\n return self.model.predict(x, batch_size, **kwargs)\",\n \"def net(net_params, inference=False):\\n model_name = net_params['global']['model_name'].lower()\\n num_classes = net_params['global']['num_classes']\\n if num_classes == 1:\\n warnings.warn(\\\"config specified that number of classes is 1, but model will be instantiated\\\"\\n \\\" with a minimum of two regardless (will assume that 'background' exists)\\\")\\n num_classes = 2\\n msg = f'Number of bands specified incompatible with this model. Requires 3 band data.'\\n state_dict_path = ''\\n if model_name == 'unetsmall':\\n model = unet.UNetSmall(num_classes,\\n net_params['global']['number_of_bands'],\\n net_params['training']['dropout'],\\n net_params['training']['dropout_prob'])\\n elif model_name == 'unet':\\n model = unet.UNet(num_classes,\\n net_params['global']['number_of_bands'],\\n net_params['training']['dropout'],\\n net_params['training']['dropout_prob'])\\n elif model_name == 'ternausnet':\\n assert net_params['global']['number_of_bands'] == 3, msg\\n model = TernausNet.ternausnet(num_classes)\\n elif model_name == 'checkpointed_unet':\\n model = checkpointed_unet.UNetSmall(num_classes,\\n net_params['global']['number_of_bands'],\\n net_params['training']['dropout'],\\n net_params['training']['dropout_prob'])\\n elif model_name == 'inception':\\n model = inception.Inception3(num_classes,\\n net_params['global']['number_of_bands'])\\n elif model_name == 'fcn_resnet101':\\n assert net_params['global']['number_of_bands'] == 3, msg\\n coco_model = models.segmentation.fcn_resnet101(pretrained=True, progress=True, num_classes=21, aux_loss=None)\\n model = models.segmentation.fcn_resnet101(pretrained=False, progress=True, num_classes=num_classes,\\n aux_loss=None)\\n chopped_dict = chop_layer(coco_model.state_dict(), layer_names=['classifier.4'])\\n del coco_model\\n # load the new state dict\\n # When strict=False, allows to load only the variables that are identical between the two models irrespective of\\n # whether one is subset/superset of the other.\\n model.load_state_dict(chopped_dict, strict=False)\\n elif model_name == 'deeplabv3_resnet101':\\n assert net_params['global']['number_of_bands'] == 3, msg\\n # pretrained on coco (21 classes)\\n coco_model = models.segmentation.deeplabv3_resnet101(pretrained=True, progress=True,\\n num_classes=21, aux_loss=None)\\n model = models.segmentation.deeplabv3_resnet101(pretrained=False, progress=True,\\n num_classes=num_classes, aux_loss=None)\\n chopped_dict = chop_layer(coco_model.state_dict(), layer_names=['classifier.4'])\\n del coco_model\\n model.load_state_dict(chopped_dict, strict=False)\\n else:\\n raise ValueError(f'The model name {model_name} in the config.yaml is not defined.')\\n\\n coordconv_convert = get_key_def('coordconv_convert', net_params['global'], False)\\n if coordconv_convert:\\n centered = get_key_def('coordconv_centered', net_params['global'], True)\\n normalized = get_key_def('coordconv_normalized', net_params['global'], True)\\n noise = get_key_def('coordconv_noise', net_params['global'], None)\\n radius_channel = get_key_def('coordconv_radius_channel', net_params['global'], False)\\n scale = get_key_def('coordconv_scale', net_params['global'], 1.0)\\n # note: this operation will not attempt to preserve already-loaded model parameters!\\n model = coordconv.swap_coordconv_layers(model, centered=centered, normalized=normalized, noise=noise,\\n radius_channel=radius_channel, scale=scale)\\n\\n if net_params['training']['state_dict_path']:\\n state_dict_path = net_params['training']['state_dict_path']\\n checkpoint = load_checkpoint(state_dict_path)\\n elif inference:\\n state_dict_path = net_params['inference']['state_dict_path']\\n checkpoint = load_checkpoint(state_dict_path)\\n else:\\n checkpoint = None\\n\\n return model, checkpoint, model_name\",\n \"def evaluate(args):\\n dataset_param_filepath = os.path.join(args.model, 'dataset.params')\\n dataset_params = putils.load_params(dataset_param_filepath)\\n source_vocab_filepath = os.path.join(args.model, 'source.vocab')\\n source_vocab = Vocab(vocab_filepath=source_vocab_filepath)\\n target_vocab_filepath = os.path.join(args.model, 'target.vocab')\\n target_vocab = Vocab(vocab_filepath=target_vocab_filepath)\\n model_params_filepath = os.path.join(args.model, 'model.params')\\n model_params = putils.load_params(model_params_filepath)\\n checkpoint_filepath = os.path.join(args.model, 'checkpoint.tar')\\n if not torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location=const.DEVICE)\\n elif torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n elif torch.cuda.is_available() and not model_params['cuda']:\\n logger.info('Loading a CPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location='cuda:0')\\n else:\\n logger.info('Loading a CPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n encoder = Encoder(model_type=checkpoint['encoder']['model_type'],\\n input_size=checkpoint['encoder']['input_size'],\\n hidden_size=checkpoint['encoder']['hidden_size'],\\n num_layers=checkpoint['encoder']['num_layers'],\\n nonlinearity=checkpoint['encoder']['nonlinearity'],\\n bias=checkpoint['encoder']['bias'],\\n dropout=checkpoint['encoder']['dropout'],\\n bidirectional=checkpoint['encoder']['bidirectional'])\\n if checkpoint['with_attention']:\\n decoder = Attention(model_type=checkpoint['decoder']['model_type'],\\n hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n max_seq_len=dataset_params['max_seq_len'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'],\\n bidirectional=checkpoint['decoder']['bidirectional'])\\n else:\\n decoder = Decoder(model_type=checkpoint['decoder']['model_type'],\\n hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'],\\n bidirectional=checkpoint['decoder']['bidirectional'])\\n encoder.load_state_dict(checkpoint['encoder_state_dict'])\\n decoder.load_state_dict(checkpoint['decoder_state_dict'])\\n if torch.cuda.is_available():\\n encoder.to(const.DEVICE)\\n decoder.to(const.DEVICE)\\n encoder.eval()\\n decoder.eval()\\n indexes = putils.index_dataset(\\n args.data, source_vocab.item2idx, target_vocab.item2idx,\\n dataset_params['is_character_based'], dataset_params['max_seq_len'],\\n dataset_params['is_reversed'])\\n if args.random > 0:\\n random.shuffle(indexes)\\n for seq_num in range(args.random):\\n seq = indexes[seq_num]\\n print('-'*80)\\n print('>', ' '.join([source_vocab.idx2item[idx]\\n for idx in seq[0]]))\\n print('=', ' '.join([target_vocab.idx2item[idx]\\n for idx in seq[1]]))\\n # TODO: add support for OOV\\n predicted_idx, _ = _decode(seq[0], encoder, decoder,\\n checkpoint['with_attention'],\\n dataset_params['max_seq_len'])\\n print('<', ' '.join([target_vocab.idx2item[idx]\\n for idx in predicted_idx]))\\n else:\\n _evaluate(indexes, encoder, decoder, target_vocab, checkpoint,\\n dataset_params)\",\n \"def inference(self, states, actions, next_states):\\n assert states.shape == next_states.shape\\n if states.ndim == 1:\\n states = np.expand_dims(states, axis=0)\\n next_states = np.expand_dims(next_states, axis=0)\\n inputs = np.concatenate((states, next_states), axis=1)\\n return self._inference_body(inputs)\",\n \"def __call__(self, *args, **kwargs):\\n is_learning = kwargs.get('is_learning', True)\\n if is_learning:\\n return self.encoder_learning_model(args[0])\\n else:\\n return self.encoder_inference_model(args[0])\",\n \"def __call__(self, *args, **kwargs):\\n is_learning = kwargs.get('is_learning', True)\\n if is_learning:\\n return self.encoder_learning_model(args[0])\\n else:\\n return self.encoder_inference_model(args[0])\",\n \"def interAct(model, encoded_query, dataloader_tester, params_runtime , args,mark='Interactive', verbose=False):\\n # set model to evaluation mode\\n model.eval()\\n predictions = []\\n for batch in dataloader_tester:\\n \\n batch = tuple(b.to(params_runtime.device) for b in batch)\\n \\n inputs = {'input_ids': batch[0],\\n 'attention_mask': batch[1],\\n }\\n \\n outputs = model(**inputs)\\n logits = outputs[0]\\n #loss_val_total += loss.item()\\n sm = nn.Softmax(dim=1)\\n logits = sm(logits)\\n \\n logits = logits.detach().cpu().numpy()\\n predictions.append(logits)\\n predictions = np.concatenate(predictions, axis=0)\\n \\n with open(args.pretrained_dir+'/params.json', 'r') as fp:\\n label_dict = json.load(fp)\\n pred_label = get_label(predictions, label_dict)\\n \\n \\n return(pred_label)\",\n \"def inference(self, x, w, relaxed=False, return_energy=False):\\n self._check_size_w(w)\\n self.inference_calls += 1\\n unary_potentials = self._get_unary_potentials(x, w)\\n pairwise_potentials = self._get_pairwise_potentials(x, w)\\n edges = self._get_edges(x)\\n return inference_dispatch(unary_potentials, pairwise_potentials, edges,\\n self.inference_method, relaxed=relaxed,\\n return_energy=return_energy)\",\n \"def main(\\n dataset,\\n backbone,\\n method,\\n train_aug,\\n train_n_way,\\n test_n_way,\\n n_shot,\\n n_query,\\n split,\\n save_iter,\\n num_classes,\\n stop_epoch,\\n start_epoch,\\n shallow,\\n resume,\\n warmup,\\n optimizer,\\n learning_rate,\\n n_episode,\\n n_iter,\\n adaptation,\\n random_seed,\\n output_dir,\\n n_swaps,\\n trained_model,\\n):\\n if trained_model is None:\\n step_to_trained_model = MethodTraining(\\n dataset,\\n backbone,\\n method,\\n train_n_way,\\n test_n_way,\\n n_shot,\\n train_aug,\\n shallow,\\n num_classes,\\n start_epoch,\\n stop_epoch,\\n resume,\\n warmup,\\n optimizer,\\n learning_rate,\\n n_episode,\\n random_seed,\\n output_dir,\\n n_swaps,\\n )\\n else:\\n step_to_trained_model = FetchModel(trained_model)\\n\\n embedding_step = Embedding(\\n dataset,\\n backbone,\\n method,\\n train_n_way,\\n test_n_way,\\n n_shot,\\n train_aug,\\n shallow,\\n split,\\n save_iter,\\n output_dir,\\n random_seed,\\n )\\n\\n evaluation_step = MethodEvaluation(\\n dataset,\\n backbone,\\n method,\\n train_n_way,\\n test_n_way,\\n n_shot,\\n n_query,\\n train_aug,\\n split,\\n save_iter,\\n n_iter,\\n adaptation,\\n random_seed,\\n n_swaps,\\n )\\n\\n model_state = step_to_trained_model.apply()\\n features_and_labels = embedding_step.apply(model_state)\\n evaluation_step.apply(model_state, features_and_labels)\",\n \"def music_inference_model(LSTM_cell,densor,n_values=78,n_a=64,Ty=100):\\n x0 = Input(shape=(1,n_values))\\n \\n a0 = Input(shape=(n_a,),name='a0')\\n c0 = Input(shape=(n_a,),name='c0')\\n a = a0\\n c = c0\\n x = x0\\n \\n #step1\\n outputs = []\\n \\n #step2\\n for t in range(Ty):\\n #2.A Perform one step of LSTM_cell\\n a,_,c = LSTM_cell(x, initial_state=[a,c])\\n\\n #2.B Apply Dense layer to the hidden state output of the LSTM_cell\\n out = densor(a)\\n \\n #2.C Append the prediction \\\"out\\\" to \\\"outputs\\\". out.shape = (None, 78)\\n outputs.append(out)\\n \\n #2.D: Select the next value according to \\\"out\\\", and set \\\"x\\\" to be the one-hot representation of the\\n # selected value, which will be passed as the input to LSTM_cell on the next step. We have provided \\n # the line of code you need to do this.\\n x = Lambda(one_hot)(out)\\n \\n #step3\\n inference_model = Model(inputs=[x0,a0,c0],outputs=outputs)\\n\\n return inference_model\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7005118","0.68879014","0.6468674","0.63714975","0.63685554","0.63409275","0.62861687","0.62818676","0.6193505","0.61855865","0.6120753","0.6109425","0.6101459","0.60623956","0.6023192","0.6022813","0.6013857","0.60059744","0.59605026","0.5955767","0.5950503","0.59371036","0.5915506","0.590566","0.58964247","0.58790374","0.5857744","0.58570117","0.58471626","0.5823522","0.5784342","0.57682765","0.575075","0.5747545","0.574622","0.5743193","0.57331514","0.5731549","0.57206994","0.5718588","0.57106316","0.5704518","0.5696661","0.5673201","0.56724465","0.5649814","0.56406724","0.5621547","0.561427","0.56137836","0.5596368","0.559305","0.55922395","0.55915993","0.5573319","0.5571754","0.5570871","0.55707055","0.5563726","0.5558437","0.55559635","0.5550667","0.5548687","0.5546972","0.5545825","0.5541221","0.55402917","0.5518793","0.550159","0.54967755","0.54960585","0.5494801","0.5476511","0.54661095","0.54585546","0.5458279","0.5443728","0.54396605","0.5435964","0.5435415","0.5433715","0.5419258","0.54151833","0.54150665","0.5407886","0.54042673","0.5401046","0.5401041","0.5397691","0.5397269","0.5393034","0.53924626","0.53832656","0.53714764","0.53657836","0.53657836","0.5360518","0.53581005","0.5357127","0.5352749"],"string":"[\n \"0.7005118\",\n \"0.68879014\",\n \"0.6468674\",\n \"0.63714975\",\n \"0.63685554\",\n \"0.63409275\",\n \"0.62861687\",\n \"0.62818676\",\n \"0.6193505\",\n \"0.61855865\",\n \"0.6120753\",\n \"0.6109425\",\n \"0.6101459\",\n \"0.60623956\",\n \"0.6023192\",\n \"0.6022813\",\n \"0.6013857\",\n \"0.60059744\",\n \"0.59605026\",\n \"0.5955767\",\n \"0.5950503\",\n \"0.59371036\",\n \"0.5915506\",\n \"0.590566\",\n \"0.58964247\",\n \"0.58790374\",\n \"0.5857744\",\n \"0.58570117\",\n \"0.58471626\",\n \"0.5823522\",\n \"0.5784342\",\n \"0.57682765\",\n \"0.575075\",\n \"0.5747545\",\n \"0.574622\",\n \"0.5743193\",\n \"0.57331514\",\n \"0.5731549\",\n \"0.57206994\",\n \"0.5718588\",\n \"0.57106316\",\n \"0.5704518\",\n \"0.5696661\",\n \"0.5673201\",\n \"0.56724465\",\n \"0.5649814\",\n \"0.56406724\",\n \"0.5621547\",\n \"0.561427\",\n \"0.56137836\",\n \"0.5596368\",\n \"0.559305\",\n \"0.55922395\",\n \"0.55915993\",\n \"0.5573319\",\n \"0.5571754\",\n \"0.5570871\",\n \"0.55707055\",\n \"0.5563726\",\n \"0.5558437\",\n \"0.55559635\",\n \"0.5550667\",\n \"0.5548687\",\n \"0.5546972\",\n \"0.5545825\",\n \"0.5541221\",\n \"0.55402917\",\n \"0.5518793\",\n \"0.550159\",\n \"0.54967755\",\n \"0.54960585\",\n \"0.5494801\",\n \"0.5476511\",\n \"0.54661095\",\n \"0.54585546\",\n \"0.5458279\",\n \"0.5443728\",\n \"0.54396605\",\n \"0.5435964\",\n \"0.5435415\",\n \"0.5433715\",\n \"0.5419258\",\n \"0.54151833\",\n \"0.54150665\",\n \"0.5407886\",\n \"0.54042673\",\n \"0.5401046\",\n \"0.5401041\",\n \"0.5397691\",\n \"0.5397269\",\n \"0.5393034\",\n \"0.53924626\",\n \"0.53832656\",\n \"0.53714764\",\n \"0.53657836\",\n \"0.53657836\",\n \"0.5360518\",\n \"0.53581005\",\n \"0.5357127\",\n \"0.5352749\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5622197"},"document_rank":{"kind":"string","value":"47"}}},{"rowIdx":6378,"cells":{"query":{"kind":"string","value":"Summarize the replicate runs and convert the parameters estimates into meaningful numbers."},"document":{"kind":"string","value":"def summarize(self, locuslen):\n # First, calculate the mean of the parameter estimates from each\n # of the replicates\n hot_means = []\n for r_t in zip(*self.hot_params):\n v = [x for x in r_t if not math.isnan(x)]\n hot_means.append(sum(v)/len(v))\n cold_means = []\n for r_t in zip(*self.cold_params):\n v = [x for x in r_t if not math.isnan(x)]\n cold_means.append(sum(v)/len(v))\n bfgs_means = []\n for r_t in zip(*self.opt_params):\n v = [x for x in r_t if not math.isnan(x)]\n bfgs_means.append(sum(v)/len(v))\n theta_mean = sum(self.theta) / len(self.theta)\n # Then, convert the parameters into meaningful values\n # the theta estimate is 4*Na*u*L\n anc_ne = theta_mean / (4 * 3e-9 * locuslen)\n # Then, the parameters are scaled by that. Population sizes are scaled\n # by theta (4Na), and times and migration rates are given in units of\n # 2N.\n scaled_params = []\n for name, val in zip(self.params['Names'], bfgs_means):\n if name.startswith('N'):\n scaled_params.append(val * anc_ne)\n elif name.startswith('m'):\n scaled_params.append(val /(anc_ne * 2))\n elif name.startswith('T'):\n scaled_params.append(val * anc_ne * 2)\n else:\n scaled_params.append(val)\n # Write these values into the class data\n self.hot_mean = hot_means\n self.cold_mean = cold_means\n self.bfgs_mean = bfgs_means\n self.theta_mean = theta_mean\n self.Na = anc_ne\n self.scaled_params = scaled_params\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def run_mcts(self, runs_per_round):\n for i in range(runs_per_round):\n self.select(self.env, 'r')\n self.env_reset()\n counts = [self.Nsa[('r', a)] for a in range(self.actions)]\n # print(\"counts \", counts)\n # print(\"Q-values\", [self.Qsa[('r', a)] for a in range(self.actions)])\n # print()\n return np.argmax(counts)","def experiment_runs (ins, exp) :\n return experiment_info.experiment_runs(ins, exp)","def load_run_summary(self):\n vrun_attrs = {}\n print 'Loading summary of {:} runs for {:} from SQL database'.format( \\\n len(self.runs),self.exp)\n print 'Estimate loading time ~{:} sec'.format(len(self.runs)/4)\n for run in range(1,self.runs[-1]['num']+1):\n run_attr = experiment_info.run_attributes(self.instrument,self.exp,run)\n for a in run_attr:\n if a['name'] not in vrun_attrs:\n vrun_attrs[a['name']] = {'class': a['class'], 'desc': a['descr'], \n 'type': a['type'], 'val': \n [None for i in range(1,run)]} \n vrun_attrs[a['name']]['val'].append(a['val'])\n self.run_summary = vrun_attrs","def test(self, n_test_runs: int = 10) -> None:\n steps: np.ndarray = np.zeros(n_test_runs)\n rewards: np.ndarray = np.zeros(n_test_runs)\n for t in range(n_test_runs):\n steps[t], rewards[t] = self.step(collect=False)\n\n self.get_logger().warn('---------- TEST RUN RESULTS ----------')\n self.get_logger().warn(f'Average: {steps.mean()}')\n self.get_logger().warn(f'STD: {steps.std()}')\n self.get_logger().warn(f'Median: {np.median(steps)}')\n self.get_logger().warn(f'Average Reward: {rewards.mean()}')","def LogRun(ss, dt):\n run = ss.TrainEnv.Run.Cur # this is NOT triggered by increment yet -- use Cur\n row = dt.Rows\n dt.SetNumRows(row + 1)\n\n epclog = ss.TrnEpcLog\n epcix = etable.NewIdxView(epclog)\n # compute mean over last N epochs for run level\n nlast = 5\n if nlast > epcix.Len()-1:\n nlast = epcix.Len() - 1\n epcix.Idxs = go.Slice_int(epcix.Idxs[epcix.Len()-nlast:])\n\n params = ss.Learn.name + \"_\" + ss.Pats.name\n\n dt.SetCellFloat(\"Run\", row, float(run))\n dt.SetCellString(\"Params\", row, params)\n dt.SetCellFloat(\"FirstZero\", row, float(ss.FirstZero))\n dt.SetCellFloat(\"SSE\", row, agg.Mean(epcix, \"SSE\")[0])\n dt.SetCellFloat(\"AvgSSE\", row, agg.Mean(epcix, \"AvgSSE\")[0])\n dt.SetCellFloat(\"PctErr\", row, agg.Mean(epcix, \"PctErr\")[0])\n dt.SetCellFloat(\"PctCor\", row, agg.Mean(epcix, \"PctCor\")[0])\n dt.SetCellFloat(\"CosDiff\", row, agg.Mean(epcix, \"CosDiff\")[0])\n\n runix = etable.NewIdxView(dt)\n spl = split.GroupBy(runix, go.Slice_string([\"Params\"]))\n split.Desc(spl, \"FirstZero\")\n split.Desc(spl, \"PctCor\")\n ss.RunStats = spl.AggsToTable(etable.AddAggName)\n\n # note: essential to use Go version of update when called from another goroutine\n if ss.RunPlot != 0:\n ss.RunPlot.GoUpdate()\n if ss.RunFile != 0:\n if row == 0:\n dt.WriteCSVHeaders(ss.RunFile, etable.Tab)\n dt.WriteCSVRow(ss.RunFile, row, etable.Tab)","def evaluate(self, runs=100):\n score_record = []\n \n print('Evaluation in progress...')\n for i in range(runs):\n score = self.run_evaluation_episode()\n score_record.append(score)\n \n ave_score = np.mean(score_record)\n \n print('System evaluated with an average score of {} in {} runs'.format(ave_score, runs))","def multi_run(replications: int, iters: List, n: int):\n global call_count\n kwargs = {\n # 'alpha': 0.75,\n # 'rho': 'VaR',\n 'alpha': 0.75,\n 'rho': 'CVaR',\n 'x0': 2,\n 'n0': n,\n 'mu_1': -15,\n 'mu_2': 10,\n 'sigma_1': 4,\n 'sigma_2': 2\n }\n\n out_dict = {\n 'SA': dict(),\n 'SA_SAA': dict(),\n 'NM': dict(),\n 'NM_SAA': dict(),\n 'LBFGS': dict(),\n 'LBFGS_SAA': dict(),\n 'EI': dict(),\n 'EI_SAA': dict()\n }\n total_calls = dict()\n for key in out_dict.keys():\n total_calls[key] = dict()\n for it_count in iters:\n kwargs['iter_count'] = it_count\n for key in out_dict.keys():\n out_dict[key][it_count] = dict()\n total_calls[key][it_count] = 0\n i = 0\n while i < replications:\n try:\n out_dict['SA'][it_count][i] = SA_run(seed=i, **kwargs)\n total_calls['SA'][it_count] += call_count\n call_count = 0\n out_dict['SA_SAA'][it_count][i] = SA_run(seed=i, **kwargs, SAA_seed=i)\n total_calls['SA_SAA'][it_count] += call_count\n call_count = 0\n out_dict['NM'][it_count][i] = NM_run(seed=i, **kwargs)\n total_calls['NM'][it_count] += call_count\n call_count = 0\n out_dict['NM_SAA'][it_count][i] = NM_run(seed=i, **kwargs, SAA_seed=i)\n total_calls['NM_SAA'][it_count] += call_count\n call_count = 0\n out_dict['LBFGS'][it_count][i] = LBFGS_run(seed=i, **kwargs)\n total_calls['LBFGS'][it_count] += call_count\n call_count = 0\n out_dict['LBFGS_SAA'][it_count][i] = LBFGS_run(seed=i, **kwargs, SAA_seed=i)\n total_calls['LBFGS_SAA'][it_count] += call_count\n call_count = 0\n out_dict['EI'][it_count][i] = EI_run(seed=i, **kwargs)\n total_calls['EI'][it_count] += call_count\n call_count = 0\n out_dict['EI_SAA'][it_count][i] = EI_run(seed=i, **kwargs, SAA_seed=i)\n total_calls['EI_SAA'][it_count] += call_count\n call_count = 0\n i += 1\n except:\n continue\n np.save('call_counts_cvar_%d.npy' % n, total_calls)\n evaluate(out_dict, n)","def make_runs(start_run=0, end_run=25,\n base_dir=DEFAULT_BASE_DIR):\n for i, reshuffle_mod in enumerate([1, 5, 25, 125, 10000]):\n for j in range(start_run, end_run):\n # Remove all handlers associated with the root logger object.\n # Allows to write the log in another folder.\n for handler in logging.root.handlers[:]:\n logging.root.removeHandler(handler)\n\n path_exp = \"{}/exp_{}/run_{:02d}\".format(base_dir, i, j)\n me.make_exps(reshuffle_mod, path_exp)\n # If one wants to plot again already made results.\n # me.load_results_and_plot(path_exp)\n out_folder_list = [\"{}/exp_{}/run_{:02d}\".format(base_dir, i, j)\n for j in range(start_run, end_run)]\n me.load_all_results_and_plot(out_folder_list, type_plot=\"average\")\n me.load_all_results_and_plot(out_folder_list, type_plot=\"quantile\")","def run(self):\n # Convert the dataset, index: Recovered, column: log10(Susceptible)\n sr_df = self.sr_df.copy()\n sr_df[self.S] = np.log10(sr_df[self.S].astype(np.float64))\n df = sr_df.pivot_table(index=self.R, values=self.S, aggfunc=\"last\")\n # Convert index to serial numbers\n serial_df = pd.DataFrame(np.arange(1, df.index.max() + 1, 1))\n serial_df.index += 1\n df = pd.merge(\n df, serial_df, left_index=True, right_index=True, how=\"outer\"\n )\n series = df.reset_index(drop=True).iloc[:, 0]\n series = series.interpolate(limit_direction=\"both\")\n # Sampling to reduce run-time of Ruptures\n samples = np.linspace(\n 0, series.index.max(), len(self.sr_df), dtype=np.int64\n )\n series = series[samples]\n # Detection with Ruptures\n algorithm = rpt.Pelt(model=\"rbf\", jump=2, min_size=self.min_size)\n results = algorithm.fit_predict(series.values, pen=0.5)\n # Convert index values to Susceptible values\n reset_series = series.reset_index(drop=True)\n reset_series.index += 1\n susceptible_df = reset_series[results].reset_index()\n # Convert Susceptible values to dates\n df = pd.merge_asof(\n susceptible_df.sort_values(self.S),\n sr_df.reset_index().sort_values(self.S),\n on=self.S, direction=\"nearest\"\n )\n found_list = df[self.DATE].sort_values()[:-1]\n # Only use dates when the previous phase has more than {min_size + 1} days\n delta_days = timedelta(days=self.min_size)\n first_obj = self.to_date_obj(self.dates[0])\n last_obj = self.to_date_obj(self.dates[-1])\n effective_list = [first_obj]\n for found in found_list:\n if effective_list[-1] + delta_days < found:\n effective_list.append(found)\n # The last change date must be under the last date of records {- min_size} days\n if effective_list[-1] >= last_obj - delta_days:\n effective_list = effective_list[:-1]\n # Set change points\n self._change_dates = [\n date.strftime(self.DATE_FORMAT) for date in effective_list[1:]\n ]\n return self","def evaluate(self, runs = 5, use_gui = False):\n self.env.render(use_gui)\n\n evaluation_results = {\n \"runs\" : runs,\n \"unfinished_runs\" : 0,\n \"average_delay\" : [],\n \"episode_mean_delays\" : [],\n \"episode_delay_lists\" : []\n }\n\n for i in range(runs):\n\n print('Evaluate {} -- running episode {} / {}'.format(self.connection_label,\n i+1,\n runs))\n all_trans, mean_delay, vehicle_delays = self.ddqn.evaluate(env = self.env,\n policy = \"greedy\")\n\n evaluation_results[\"episode_delay_lists\"].append(vehicle_delays)\n evaluation_results[\"episode_mean_delays\"].append(mean_delay)\n\n if mean_delay != -1:\n evaluation_results[\"average_delay\"].append(mean_delay)\n else:\n evaluation_results[\"unfinished_runs\"] += 1\n\n runs -= evaluation_results[\"unfinished_runs\"]\n\n if runs == 0:\n evaluation_results[\"average_delay\"].append(-1)\n else:\n evaluation_results[\"average_delay\"] = sum(evaluation_results[\"average_delay\"])/runs\n\n # print(self.ddqn.q_network.get_weights())\n\n return evaluation_results","def replicate(self,simulation_run):\n\n return self._runModel(params=simulation_run.params)","def get_mojo_run_info():\n \n #get movies from the db and calulate run info\n run_info_df = movie_helper.get_movie_run_info()\n \n with tqdm(total=len(run_info_df)) as pbar:\n for index, row in run_info_df.iterrows():\n #update the database\n updates = {\"end_weekend\" : row['end_weekend'], \n \"total_weekends\" : row['total_weekends'], \n \"total_release_weeks\" : row['total_release_weeks'], \n \"first_run_end\" : row['first_run_end'],\n \"first_run_weeks\" : row['first_run_weeks']}\n \n selects = {\"movieId\" : row[\"movieId\"]}\n database_helper.update_data(\"movies\", update_params = updates, select_params = selects)\n \n pbar.update(1)","def run_simulation(self, number_runs = 1):\n for i in range(0, number_runs):\n self.ques = [self.start for i in range(0, self.numQueues)]\n run = self.__single_sim_results()\n run_results = pd.DataFrame({'simulation':i,\n 'num_items': len(run),\n 'wait_count': len(run[run['wait_time']>datetime.timedelta(seconds=0)]),\n 'avg_wait_time': run.wait_time.mean(),\n 'close_time': max(run['appt_end_time'])}, index=[i])\n self.results = pd.concat([self.results, run_results], ignore_index=True)\n self.results['last_appt_to_close_minutes'] = (self.results['close_time']-self.end).dt.total_seconds().div(60)\n return","def summarize(self):\n \n print self._num_tests, \"tests ran with\", len(self._failed_tests), \"failures:\", sorted(list(self._failed_tests))\n\n self._num_tests = 0\n self._failed_tests = set()","def _get_traces(\n run, runs, running_runs, all_cses, trace_type='deconvolved', length_fr=15,\n pad_fr=31, offset_fr=1, running_threshold_cms=4., correct_trials=False,\n lick_cutoff=-1, lick_window=(-1, 0), running_fraction=0.3,\n max_n_onsets=-1, remove_stim=True, activity_scale=None):\n if run not in running_runs:\n # Prepare running baseline data.\n # NOTE: running thresholding is done differently here than later during\n # stimulus runs.\n out = {'other-running': _get_run_onsets(\n runs=running_runs,\n length_fr=length_fr,\n pad_fr=pad_fr,\n offset_fr=offset_fr,\n running_threshold_cms=running_threshold_cms)}\n\n for training_run in runs:\n t2p = training_run.trace2p()\n\n # Get the trace from which to extract time points\n trs = t2p.trace(trace_type)\n\n if activity_scale is not None:\n trs = (trs.T*activity_scale).T\n\n # If the target run is also a training run, make sure that we aren't\n # training on the same data that will later be used for comparison\n if remove_stim or training_run != run:\n # Search through all stimulus onsets, correctly coding them\n for ncs in t2p.cses(): # t.cses(self._pars['add-ensure-quinine']):\n if ncs in all_cses:\n # Remap cs name if needed\n # NOTE: blank trials are just labeled 'other' and not\n # checked for running.\n cs = all_cses[ncs]\n # Initialize output\n if cs not in out:\n out[cs] = []\n\n ons = t2p.csonsets(\n ncs, 0 if correct_trials else -1, lick_cutoff,\n lick_window)\n\n for on in ons:\n start = on + offset_fr\n toappend = trs[:, start:start + length_fr]\n # Make sure interval didn't run off the end.\n if toappend.shape[1] == length_fr:\n out[cs].append(toappend)\n\n # If the target run is in the training runs, don't use the times\n # that will later be used for comparison.\n if training_run != run:\n # Add all onsets of \"other\" frames\n others = t2p.nocs(length_fr, pad_fr, -1)\n\n if len(t2p.speed()) > 0:\n running = t2p.speed() > running_threshold_cms\n for ot in others:\n start = ot + offset_fr\n if nanmean(running[start:start + length_fr]) > \\\n running_fraction:\n out['other-running'].append(\n trs[:, start:start + length_fr])\n else:\n if 'other' not in out:\n out['other'] = []\n out['other'].append(\n trs[:, start:start + length_fr])\n\n # Selectively remove onsets if necessary\n if max_n_onsets > 0:\n for cs in out:\n if 'other' not in cs:\n print('WARNING: Have not yet checked new timing version')\n\n # Account for shape of array\n if len(out[cs]) > max_n_onsets:\n out[cs] = np.random.choice(\n out[cs], max_n_onsets, replace=False)\n\n for cs in out:\n out[cs] = np.array(out[cs])\n\n return out","def trial_setup(params):\n runs = []\n trials = []\n for run in range(params['runs']):\n runs = runs + [run]*params['trials_per_run']\n for trial in range(params['trials_per_run']):\n trials.append(trial)\n return(runs,trials)","def simulationTwoDrugsDelayedTreatment(numTrials):\n #Initialization\n delayList = [300, 150, 75, 0]\n #delayList = [150]\n #Patient init variables\n numViruses = 100\n maxPop = 1000\n #Virus init variables\n maxBirthProb = 0.1\n clearProb = 0.05\n #clearProb = 0.10\n resistances = { 'guttagonol': False, 'grimpex' : False }\n #mutProb = 0.005\n mutProb = 0.010\n \n results = {}\n \n for n in delayList:\n cured = 0\n popList = []\n print \"Running trials for delay %(delay)d\" % {'delay' : n}\n for i in range(numTrials):\n #print \"Trial: \" + str(i)\n pop = runTrialTwoDrugs(n, numViruses, maxPop, maxBirthProb, clearProb, resistances, mutProb)\n popList.append(pop)\n if pop < 50:\n cured +=1\n results[n] = popList\n #print popList\n print \"Delay : %(delay)d Percentage cured %(percent)2f\" % {\"delay\" : n, \"percent\" : cured/float(numTrials) }\n \n\n drawHist(results, numTrials)","def add_runs(self,runs):\n for r in runs:\n self.add(r)","def Repeater(algorithm, runs, nationtxt, schemeIn):\n\n scores = {}\n\n # Make sure appropriate range is used for scores\n\n scoreRange = range(0, 10000)\n\n # score range has to be between these two numbers\n for i in scoreRange:\n scores.update({i : 0})\n\n #~ print \"Running \" + str(algorithm)[0:-18] + \"> \" + str(runs) + \" times...\\n\"\n\n\n minScore = 10**40\n\n\n scheme = schemeIn\n avg = (scheme[0] + scheme[1] + scheme[2] + scheme[3] + scheme[4] + scheme[5] + scheme[6]) / 7.\n p0 = (scheme[0] - avg)**2\n p1 = (scheme[1] - avg)**2\n p2 = (scheme[2] - avg)**2\n p3 = (scheme[3] - avg)**2\n p4 = (scheme[4] - avg)**2\n p5 = (scheme[5] - avg)**2\n p6 = (scheme[6] - avg)**2\n var = (p0 + p1 + p2 + p3 + p4 + p5 + p6) / 7.\n sDev = var**0.5\n\n\n q0 = scheme[1] - scheme[0]\n q1 = scheme[2] - scheme[1]\n q2 = scheme[3] - scheme[2]\n q3 = scheme[4] - scheme[3]\n q4 = scheme[5] - scheme[4]\n q5 = scheme[6] - scheme[5]\n\n for i in range(runs):\n nation = algorithm(nationtxt)\n\n score = randScoreFunction(nation, scheme)\n scores[score] += 1\n\n # keep track of best scores and nation\n if score < minScore:\n minScore = score\n bestNation = nation\n\n maxFreq = 0\n\n scoreCount = 0\n\n for score in scores:\n if scores[score] > maxFreq:\n maxFreq = scores[score]\n maxFreqScore = score\n if score == minScore:\n minScoreFreq = scores[score]\n if scores[score] >= 1:\n scoreCount += 1\n\n\n usedTrans = []\n fivePlus = 0\n fivePlusNoDuplicate = 0\n\n one = 0\n two = 0\n three = 0\n four = 0\n five = 0\n six = 0\n seven = 0\n\n for province in bestNation:\n\n if bestNation[province][1] == 1:\n one += 1\n if bestNation[province][1] == 2:\n two += 1\n if bestNation[province][1] == 3:\n three += 1\n if bestNation[province][1] == 4:\n four += 1\n if bestNation[province][1] == 5:\n five += 1\n if bestNation[province][1] == 6:\n six += 1\n if bestNation[province][1] == 7:\n seven += 1\n\n\n if five > 0 or six > 0 or seven > 0:\n fivePlus += 1\n if scheme[3] != scheme[4]:\n fivePlusNoDuplicate += 1\n\n usedTrans.append([one, two, three, four, five, six, seven])\n\n\n return minScore, minScoreFreq, scheme, fivePlus, fivePlusNoDuplicate, usedTrans, scoreCount, sDev, q0, q1, q2, q3, q4, q5, avg","def simulationDelayedTreatment(numTrials):\n \n #Initialization\n #delayList = [300, 150, 75, 0]\n delayList = [150]\n #Patient init variables\n numViruses = 100\n maxPop = 1000\n #Virus init variables\n maxBirthProb = 0.1\n clearProb = 0.05\n #clearProb = 0.10\n resistances = { 'guttagonol': True }\n mutProb = 0.005\n \n results = {}\n \n for n in delayList:\n cured = 0\n popList = []\n for i in range(numTrials):\n pop = runTrial(n, numViruses, maxPop, maxBirthProb, clearProb, resistances, mutProb)\n popList.append(pop)\n if pop == 0:\n cured +=1\n results[n] = popList\n #print popList\n print \"Delay : %(delay)d Percentage cured %(percent)2f\" % {\"delay\" : n, \"percent\" : cured/float(numTrials) }\n \n\n drawHist(results, numTrials)","def _extract_results_from_run_history(self, run_history: RunHistory) -> None:\n\n for run_key, run_value in run_history.data.items():\n config = run_history.ids_config[run_key.config_id]\n self._update(config=config, run_key=run_key, run_value=run_value)\n\n self._check_null_in_optional_inference_choices()\n\n self.rank_opt_scores = scipy.stats.rankdata(\n -1 * self._metric._sign * self.opt_scores, # rank order\n method='min'\n )","def simulate_run(run, maker, all_data, train_mask, test_mask, instances, independent, mixture):\n\n train_data = all_data.masked(train_mask)\n test_data = all_data.masked(test_mask)\n\n if instances is not None:\n ids = sorted(train_data.run_lists, key = lambda _: numpy.random.rand())[:instances]\n train_data = train_data.filter(*ids)\n\n if independent:\n train_data = train_data.collect_independent(mixture).only_nonempty()\n else:\n train_data = train_data.collect_systematic(mixture).only_nonempty()\n\n budget = test_data.common_budget\n #budget = test_data.common_budget / 2 # XXX\n suite = borg.fake.FakeSuite(test_data)\n\n if maker.subname == \"preplanning-dir\":\n model_kwargs = {\"K\": 64}\n\n if \"set_alpha\" in maker.variants:\n model_kwargs[\"alpha\"] = 1e-2\n else:\n model_kwargs = {}\n\n solver = maker(suite, train_data, model_kwargs = model_kwargs)\n successes = []\n\n for (i, instance_id) in enumerate(test_data.run_lists):\n logger.info(\"simulating run %i/%i on %s\", i, len(test_data), instance_id)\n\n with suite.domain.task_from_path(instance_id) as instance:\n with borg.accounting() as accountant:\n answer = solver.start(instance).run_then_stop(budget)\n\n succeeded = suite.domain.is_final(instance, answer)\n\n logger.info(\n \"%s %s on %s (%.2f CPU s)\",\n maker.name,\n \"succeeded\" if succeeded else \"failed\",\n os.path.basename(instance),\n accountant.total.cpu_seconds,\n )\n\n if succeeded:\n successes.append(accountant.total.cpu_seconds)\n\n logger.info(\n \"%s had %i successes over %i instances\",\n maker.name,\n len(successes),\n len(test_data),\n )\n\n description = \"{0} ({1})\".format(mixture, \"Sep.\" if independent else \"Sys.\")\n\n return (\n description,\n maker.name,\n instances,\n len(successes),\n numpy.mean(successes),\n numpy.median(successes),\n )","def evaluate_benchmarks(self):\n\n # iterate over replicates\n results = {}\n for replicate_id, replicate in self.replicates:\n\n # evaluate benchmark for current replicate\n bmark = SimulationBenchmark(replicate.copy(),\n graph=self.graphs[replicate_id],\n **self.params)\n\n # store results\n results[replicate_id] = dict(\n\n labels_MAE=bmark.scores['labels'].MAE,\n level_only_MAE=bmark.scores['level_only'].MAE,\n spatial_only_MAE=bmark.scores['spatial_only'].MAE,\n community_MAE=bmark.scores['labels_comm'].MAE,\n\n labels_PCT=bmark.scores['labels'].percent_correct,\n level_only_PCT=bmark.scores['level_only'].percent_correct,\n spatial_only_PCT=bmark.scores['spatial_only'].percent_correct,\n community_PCT=bmark.scores['labels_comm'].percent_correct)\n\n # compile dataframe\n results = pd.DataFrame.from_dict(results, orient='index')\n results.index.set_names(self.multiindex, inplace=True)\n\n return results","def dict_of_recs_for_run (ins, exp, runnum) :\n return calibration_runs(ins, exp)[runnum]","def sum_simulated_test():\n f = open(\"./results/simulated_sigmoid_sum.csv\", \"w\")\n #f1 = open(\"./results/avg_pres.txt\", \"w\")\n #f.write(\"num. of qubits; precision\\n\")\n\n\n computable_qubits = 27\n num_subtest = 1000\n\n acum_precision = 0\n coeffs = []\n temp = -10\n while temp < 11:\n coeffs.append(temp)\n temp += 0.25\n #for coeff in coeffs:\n # variables.c_summation = coeff\n # print(coeff)\n for i in range(2, computable_qubits):\n #print(\"qubit: \", i)\n precision = 0\n x = []\n for j in range(num_subtest):\n\n random_dict = get_random_dict(i)\n\n # compute real answer\n real_answer = 0\n for value in random_dict.values():\n real_answer += value\n # f1.write(str(real_answer)+\";\")\n x.append(real_answer)\n\n # assign spin value to real_answer\n if real_answer < 0:\n real_answer = -1\n elif real_answer > 0:\n real_answer = 1\n else:\n real_answer = 0\n bqm = get_bqm()\n quantum_sigmoid_sum(bqm, random_dict, \"target\")\n sampler = get_simulated_sampler()\n result = sampler.sample(bqm)\n if real_answer == 0:\n precision += 1\n # f1.write(\"1\\n\")\n elif real_answer == result.first.sample['target']:\n precision += 1\n # f1.write(\"1\\n\")\n# else:\n # f1.write(\"0\\n\")\n\n precision /= num_subtest\n # acum_precision+= precision\n\n f.write(str(i) + \";\" + str(precision) + \"\\n\")\n f.close()\n #f1.write(str(coeff)+\";\"+ str(round(acum_precision/(computable_qubits-1), 4)) + \"\\n\")\n # acum_precision = 0\n #f1.close()","def train_multiple_runs_eps(self, env, runs=3, no_episodes=200, horizon=1000, lr=0.1):\n\t\tr_mat = []\n\t\tinfo = {}\n\t\t\n\t\tfor i in range(runs):\n\n\t\t\t# Resetting agent to default before each run\n\t\t\tself.reset()\n\n\t\t\t# Training the agent for ts_max\n\t\t\tr_vec, _ = self.train_multiple_eps(env, no_episodes=no_episodes, horizon=horizon, lr=lr)\n\n\t\t\t# Storing the results in a matrix\n\t\t\tr_mat.append(r_vec)\n\n\t\t# Finding the mean and standard deviation \n\t\tinfo['mean'] = np.mean(np.array(r_mat), axis=0)\n\t\tinfo['std'] = np.std(np.array(r_mat), axis=0)\n\n\t\treturn r_mat, info","def timings_across_runs(self):\n\n\t\t# first determine individual run duration (to make sure that stimulus timings of all runs are correct)\n\t\trun_duration = []\n\t\tfor r in [self.runList[i] for i in self.conditionDict['WMM']]:\n\t\t\tniiFile = NiftiImage(self.runFile(stage = 'processed/mri', run = r))\n\t\t\ttr, nr_trs = round(niiFile.rtime*1)/1000.0, niiFile.timepoints\n\t\t\trun_duration.append(tr * nr_trs)\n\t\trun_duration = np.r_[0,np.cumsum(np.array(run_duration))]\n\n\t\t# timing information stimuli\n\t\tstim_info = []\n\t\trun = 0\n\t\tfor r in [self.runList[i] for i in self.conditionDict['WMM']]:\n\t\t\tstim_events = np.loadtxt(self.runFile(stage = 'processed/behavior', run = r, extension = '.txt', postFix = ['stim' ,'all','task']))\n\t\t\tstim_events[:,:2] += run_duration[run]\n\t\t\tstim_info.append(stim_events)\n\t\t\trun += 1\n\n\t\t# save stim_info as text_file\t\n\t\tnp.savetxt(self.runFile(stage = 'processed/behavior', postFix = ['stim_info_all'],extension = '.txt'), np.vstack(stim_info), fmt = '%3.2f', delimiter = '\\t')","def num_trials(self):","def aggregate_results(results):\n\n for (config,con,dec),folds in results.iteritems():\n m = MODEL_PATTERN.match(config)\n if m:\n mode = m.groupdict()['mode'] # mle, rl, mrt, ...\n model = m.groupdict()['model'] # haem, hacm, hard, ...\n align = m.groupdict()['align'] # crp, cls ...\n else:\n mode, model, align = '', '', ''\n # mean accuracies across seeds for each fold\n foldaccuracies = []\n # we count number of models over folds and seeds\n num_individual_models = 0\n\n for foldname,fold in folds.items():\n if 'Q' in options.mode:\n seedaccurracies = fold.values()[:1] if fold.values() else [] # pick one\n# SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\n else:\n seedaccurracies = []\n for seed_acc in fold.values():\n seedaccurracies.append(seed_acc)\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\n # aggregate on fold level\n fold['__MEAN__'] = float(np.mean(seedaccurracies))\n fold['__SD__'] = float(np.std(seedaccurracies))\n l = len(seedaccurracies)\n num_individual_models += l\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__MEAN__')] += l\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__SD__')] += l\n\n # statistics over seeds for this fold\n fold['__STATS__'] = fold['__MEAN__'], fold['__SD__'], l\n foldaccuracies.append(fold['__MEAN__'])\n # aggregate on (config, condition, decoding) level\n folds['__MEAN__'] = float(np.mean(foldaccuracies))\n folds['__SD__'] = float(np.std(foldaccuracies))\n # statistics over folds for this (config, condition, decoding)\n folds['__STATS__'] = folds['__MEAN__'], folds['__SD__'], num_individual_models","def evaluate_model(args, eval_runs, warm_runs, metrics=['psnr', 'ssim', 'fps']):\n upsampler = Upsampler(args)\n if warm_runs > 0:\n print(\"Warming up for evaluation\")\n for i in range(warm_runs):\n print(\"Performing warm-up run\", str(i+1))\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\n upsampler.run_dir(bix_dir, reset=False)\n \n time = 0.\n psnrs = []\n ssims = []\n for i in range(eval_runs):\n run_psnrs = []\n run_ssims = []\n print(\"Performing evaluation run\", str(i+1))\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\n gt_dir = os.path.join(VID4_DIR, 'GT', sequence)\n print(\"Evaluating on\", bix_dir)\n time += upsampler.run_dir(bix_dir, reset=False)\n vid_psnrs, vid_ssims = _eval_sr_perf(os.path.join(bix_dir, 'up'), gt_dir)\n run_psnrs += vid_psnrs\n run_ssims += vid_ssims\n if i == eval_runs-1:\n with open(os.path.join(upsampler.get_model_dir(), \"psnr.txt\"), \"w\") as f:\n f.writelines(str(psnr) + '\\n' for psnr in run_psnrs)\n with open(os.path.join(upsampler.get_model_dir(), \"ssim.txt\"), \"w\") as f:\n f.writelines(str(ssim) + '\\n' for ssim in run_ssims)\n psnrs += run_psnrs\n ssims += run_ssims\n\n fps = VID4_LENGTH/ (time/eval_runs)\n return Performance(psnr=psnrs, ssim=ssims, fps=fps)","def _compute_experiment_statistics(self):\n pass","def get_run_info_miseq( instrument_model, application_version, tree ):\n run_stats = {}\n\n setup_node = tree.getroot().find(\"Setup\")\n if setup_node is None:\n setup_node = tree.getroot()\n\n # Get required tree nodes.\n flowcell_node = tree.getroot().find(\"FlowcellRFIDTag\")\n reads_node = tree.getroot().find('Reads')\n\n # Now actually populate various stats\n run_stats['flow_cell_id'] = flowcell_node.find('SerialNumber').text\n run_stats['date'] = tree.getroot().find('RunStartDate').text\n run_stats['instrument'] = tree.getroot().find('ScannerID').text\n run_stats['lanes'] = int(setup_node.find('NumLanes').text)\n run_stats['run_id'] = tree.getroot().find('RunID').text\n\n read_len = []\n index_len = []\n for read_info in reads_node.findall('RunInfoRead'):\n attrib = read_info.attrib\n if( attrib['IsIndexedRead'] == 'Y' ):\n index_len.append( int( attrib['NumCycles'] ) )\n else:\n read_len.append( int( attrib['NumCycles'] ) )\n\n run_stats['r1_length'] = read_len[0]\n run_stats['p7_index_length'] = index_len[0]\n\n run_stats['paired_end'] = False\n if( len( read_len ) == 2 ):\n run_stats['r1_length'] = read_len[1]\n run_stats['p5_index_length'] = index_len[1]\n run_stats['paired_end'] = True\n\n run_stats['instrument_type'] = instrument_model\n run_stats['reverse_complement_i5'] = False\n\n return run_stats","def explore_runs(df, option, gamma, alpha):\n\n n_states = len(np.unique(df.objnum))\n SR_matrices = {}\n M = np.zeros([n_states, n_states])\n\n # This option allows the SR matrix to persist in Part 1 and Part 2,\n # but resets it between them.\n if option == \"reset\":\n for part in np.unique(df.part):\n if part == 2:\n M = np.zeros([n_states, n_states])\n for run in np.unique(df.loc[df.part == part, 'run']):\n envstep = df.loc[(df.part == part) & (df.run == run),\n 'objnum'].values\n M = np.array(run_experiment(envstep, gamma, alpha, np.copy(M),\n n_states))\n M = M / np.sum(M)\n SR_matrices[(part, run)] = M\n\n # This option resets the SR matrix between each run.\n if option == \"independent\":\n for part in np.unique(df.part):\n for run in np.unique(df.loc[df.part == part, 'run']):\n M = np.zeros([n_states, n_states])\n envstep = df.loc[(df.part == part) & (df.run == run),\n 'objnum'].values\n M = np.array(run_experiment(envstep, gamma, alpha, np.copy(M),\n n_states))\n M = M / np.sum(M)\n SR_matrices[(part, run)] = M\n\n return SR_matrices","def AllindividualRuns():\n #800 nm\n RunData(getFiles(mintime=(15, 40, 07), maxtime=(15, 45, 14), folder='data/29Jul/'), out='I800nm')\n RunData(getFiles(mintime=(15, 12, 20), maxtime=(15, 24, 16), folder='data/31Jul/'), out='I800nm5k')\n RunData(getFiles(mintime=(15, 28, 40), maxtime=(15, 39, 21), folder='data/31Jul/'), out='I800nm10k')\n RunData(getFiles(mintime=(15, 43, 24), maxtime=(15, 51, 47), folder='data/31Jul/'), out='I800nm20k')\n RunData(getFiles(mintime=(15, 56, 11), maxtime=(16, 02, 58), folder='data/31Jul/'), out='I800nm30k')\n RunData(getFiles(mintime=(16, 12, 39), maxtime=(16, 18, 25), folder='data/31Jul/'), out='I800nm38k')\n RunData(getFiles(mintime=(16, 21, 52), maxtime=(16, 26, 16), folder='data/31Jul/'), out='I800nm50k')\n RunData(getFiles(mintime=(16, 32, 02), maxtime=(16, 35, 23), folder='data/31Jul/'), out='I800nm54k')\n #700 nm\n RunData(getFiles(mintime=(17, 20, 17), maxtime=(17, 33, 17), folder='data/30Jul/'), out='I700nm5k')\n RunData(getFiles(mintime=(17, 37, 35), maxtime=(17, 46, 51), folder='data/30Jul/'), out='I700nm9k')\n RunData(getFiles(mintime=(17, 48, 35), maxtime=(17, 56, 03), folder='data/30Jul/'), out='I700nm52k')\n RunData(getFiles(mintime=(17, 58, 18), maxtime=(17, 59, 31), folder='data/30Jul/'), out='I700nm32k')\n #600 nm\n RunData(getFiles(mintime=(15, 22, 00), maxtime=(15, 36, 32), folder='data/30Jul/'), out='I600nm5k')\n RunData(getFiles(mintime=(15, 39, 58), maxtime=(15, 47, 58), folder='data/30Jul/'), out='I600nm54k')\n RunData(getFiles(mintime=(15, 52, 07), maxtime=(16, 06, 32), folder='data/30Jul/'), out='I600nm10k')\n #890 nm\n RunData(getFiles(mintime=(13, 37, 37), maxtime=(13, 50, 58), folder='data/01Aug/'), out='I890nm5k')\n RunData(getFiles(mintime=(14, 00, 58), maxtime=(14, 11, 54), folder='data/01Aug/'), out='I890nm10k')\n RunData(getFiles(mintime=(14, 17, 57), maxtime=(14, 25, 49), folder='data/01Aug/'), out='I890nm30k')\n RunData(getFiles(mintime=(14, 30, 03), maxtime=(14, 34, 37), folder='data/01Aug/'), out='I890nm50k')","def plot_average_SA(repetitions, runs):\n\n\ttotalscores = []\n\n\t# for each repetition\n\tfor i in range(repetitions):\n\n\t\t# create empty list\n\t\talgorithm_scores = []\n\n\t\t# create random schedule and perform simulated annealing with geman coolingscheme\n\t\tchambers, allcourses, student_list, schedule = create_schedule()\n\n\t\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, scores = simulated_annealing(geman, runs, chambers, allcourses, student_list, schedule)\n\n\t\t# create random schedule and perform simulated annealing with linear coolingscheme\n\t\tchambers, allcourses, student_list, schedule = create_schedule()\n\t\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, linear_scores = simulated_annealing(linear, runs, chambers, allcourses, student_list, schedule)\n\n\t\t# create random schedule and perform simulated annealing with sigmoidal coolingscheme\n\t\tchambers, allcourses, student_list, schedule = create_schedule()\n\t\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, sigmoidal_scores = simulated_annealing(sigmoidal, runs, chambers, allcourses, student_list, schedule)\n\n\t\t# create random schedule and perform simulated annealing with exponential coolingscheme\n\t\tchambers, allcourses, student_list, schedule = create_schedule()\n\t\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, exponential_scores = simulated_annealing(exponential, runs, chambers, allcourses, student_list, schedule)\n\n\t\t# add scores to alogrithm list\n\t\talgorithm_scores.append([geman_scores, linear_scores, sigmoidal_scores, exponential_scores])\n\n\t\t# add algorithm list to totalscore\n\t\ttotalscores.append(algorithm_scores)\n\n\t# create empty lists for score per coolingscheme\n\tall_geman_scores = []\n\tall_linear_scores = []\n\tall_sigmoidal_scores = []\n\tall_exponential_scores = []\n\n\t# add single scores coolingschem into lists with all scores\n\tfor i in range(repetitions):\n\t\tall_geman_scores.append(totalscores[i][0][0])\n\t\tall_linear_scores.append(totalscores[i][0][1])\n\t\tall_sigmoidal_scores.append(totalscores[i][0][2])\n\t\tall_exponential_scores.append(totalscores[i][0][3])\n\n\t# create empty lists for sorted scores\n\tgeman_sorted_scores = []\n\tlinear_sorted_scores = []\n\tsigmoidal_sorted_scores = []\n\texponential_sorted_scores = []\n\n\t# for each run\n\tfor i in range(runs):\n\n\t\t# create empty lists for selected scores\n\t\tgeman_selected_score = []\n\t\tlinear_selected_score = []\n\t\tsigmoidal_selected_score = []\n\t\texponential_selected_score = []\n\n\t\t# for each repetition\n\t\tfor j in range(repetitions):\n\n\t\t\t# add selected score to all score list of coolingscheme\n\t\t\tgeman_selected_score.append(all_geman_scores[j][i])\n\t\t\tlinear_selected_score.append(all_linear_scores[j][i])\n\t\t\tsigmoidal_selected_score.append(all_sigmoidal_scores[j][i])\n\t\t\texponential_selected_score.append(all_exponential_scores[j][i])\n\n\t\t# add selected scores into sorted score\n\t\tgeman_sorted_scores.append(geman_selected_score)\n\t\tlinear_sorted_scores.append(linear_selected_score)\n\t\tsigmoidal_sorted_scores.append(sigmoidal_selected_score)\n\t\texponential_sorted_scores.append(exponential_selected_score)\n\n\t# calculate average for each sorted scores\n\tgeman_average_scores = []\n\tfor scores in geman_sorted_scores:\n\t\tgeman_average_scores.append(sum(scores)/len(scores))\n\n\tlinear_average_scores = []\n\tfor scores in linear_sorted_scores:\n\t\tlinear_average_scores.append(sum(scores)/len(scores))\n\n\tsigmoidal_average_scores = []\n\tfor scores in sigmoidal_sorted_scores:\n\t\tsigmoidal_average_scores.append(sum(scores)/len(scores))\n\n\texponential_average_scores = []\n\tfor scores in exponential_sorted_scores:\n\t\texponential_average_scores.append(sum(scores)/len(scores))\n\n\t# store average scores in one list\n\taverage_scores = [geman_average_scores, linear_average_scores, sigmoidal_average_scores, exponential_average_scores]\n\n\t# create plot with multiple lines of all coolingschemes\n\tmultiple_simulated_annealing(average_scores)","def make_simulations(self):\n pass","def report(results, n_top=1):\n for i in range(1, n_top + 1):\n candidates = np.flatnonzero(results['rank_test_score'] == i)\n for candidate in candidates:\n print(f\"Model with rank: {i}\")\n print(f\"Mean validation score: {results['mean_test_score'][candidate]} (std: {results['std_test_score'][candidate]}\")\n print(f\"Parameters: {results['params'][candidate]}\")","def get_repeated_outputs(df,\n model_name,\n parameters,\n input_path,\n inputs,\n targets,\n n_repeats,\n zero_flag,\n neonate,\n tolerance=None,\n limit=None,\n frac=None,\n openopt_path=None,\n offset=None,\n distance='euclidean'\n ):\n p_names = list(parameters.keys())\n sorted_df = df.sort_values(by=distance)\n\n if tolerance:\n accepted_limit = sum(df[distance].values < tolerance)\n elif limit:\n accepted_limit = limit\n elif frac:\n accepted_limit = frac_calculator(sorted_df, frac)\n else:\n raise ValueError('No limit or fraction given.')\n\n df_list = []\n if n_repeats > accepted_limit:\n print(\n \"Setting number of repeats to quarter of the posterior size\\n\",\n file=sys.stderr)\n n_repeats = int(accepted_limit / 4)\n d0 = import_actual_data(input_path)\n input_data = inputParse(d0, inputs)\n\n true_data = pd.read_csv(input_path)\n times = true_data['t'].values\n\n if openopt_path:\n openopt_data = pd.read_csv(openopt_path)\n\n if n_repeats > accepted_limit:\n raise ValueError(\n \"Number of requested model runs greater than posterior size:\"\n \"\\n\\tPosterior Size: {}\\n\\tNumber of runs: {}\".format(\n accepted_limit, n_repeats))\n\n rand_selection = list(range(accepted_limit))\n random.shuffle(rand_selection)\n\n outputs_list = []\n\n posteriors = sorted_df.iloc[:accepted_limit][p_names].values\n select_idx = 0\n with Timer(\"Running repeat outputs\"):\n while len(outputs_list) < n_repeats:\n try:\n idx = rand_selection.pop()\n p = dict(zip(p_names, posteriors[idx]))\n if offset:\n p = {**p, **offset}\n output = get_output(\n model_name,\n p,\n times,\n input_data,\n d0,\n targets,\n distance=distance,\n zero_flag=zero_flag)\n outputs_list.append(output)\n print(\"Sample {}, idx:{}\".format(len(outputs_list), idx))\n\n except (TimeoutError, TimeoutExpired) as e:\n print(\"Timed out for Sample {}, idx:{}\".format(\n len(outputs_list), idx))\n pprint.pprint(p)\n rand_selection.insert(0, idx)\n except (CalledProcessError) as e:\n print(\"CalledProcessError for Sample {}, idx:{}\".format(\n len(outputs_list), idx))\n pprint.pprint(p)\n rand_selection.insert(0, idx)\n\n d = {\"Errors\": {}, \"Outputs\": {}}\n d['Errors']['Average'] = np.nanmean(\n [o[0]['TOTAL'] for o in outputs_list])\n for target in targets:\n d['Errors'][target] = np.nanmean(\n [o[0][target] for o in outputs_list])\n d['Outputs'][target] = [o[1][target] for o in outputs_list]\n\n for ii, target in enumerate(targets):\n x = [j for j in times for n in range(len(d['Outputs'][target]))]\n with Timer('Transposing {}'.format(target)):\n y = np.array(d['Outputs'][target]).transpose()\n y = y.ravel()\n with Timer(\"Crafting DataFrame for {}\".format(target)):\n model_name_col = [neonate]*len(x)\n target_col = [target]*len(x)\n df1 = pd.DataFrame(\n {\"Time\": x, \"Posterior\": y, \"Neonate\": model_name_col, \"Output\": target_col})\n with Timer(\"Appending dataframe for {}\".format(target)):\n df_list.append(df1.copy())\n del df1\n return pd.concat(df_list), true_data","def run_attributes (ins, exp, run) :\n t0_sec = time()\n list_of_dicts = experiment_info.run_attributes(ins, exp, run)\n #print 'run_attributes for %s %s run:%d, t(sec) = %f' % (ins, exp, run, time()-t0_sec)\n return list_of_dicts","def list_of_runnums (ins, exp) :\n try : expruns = experiment_info.experiment_runs(ins, exp)\n #if exp == 'xcs83814' : return []\n except : return []\n\n return [int(rec['num']) for rec in expruns]\n #runs = experiment_info.experiment_runs(ins, exp)\n #lst = []\n #for rec in runs :\n # lst.append( int(rec['num']) )\n #return lst","def classify():\n yes_dataset = df[df[\"_class\"] == 1] # 470588\n no_dataset = df[df[\"_class\"] == 0] # 1971\n\n parameter_analysis = list()\n for criterion in np.arange(0.05, 0.91, 0.05):\n print(\"doing experiment at criterion = %s ...\" % criterion)\n rate_list = list()\n for i in range(10):\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\n yes_index = yes_dataset.index.tolist()\n random.shuffle(yes_index)\n no_index = no_dataset.index.tolist()\n random.shuffle(no_index)\n \n # concatenate 90%yes + 90%no, 10%yes + 10%no\n train = pd.concat([\n yes_dataset.loc[yes_index[:1774], :],\n no_dataset.loc[no_index[:423530], :]\n ])\n test = pd.concat([\n yes_dataset.loc[yes_index[1774:], :],\n no_dataset.loc[no_index[423530:], :]\n ]) \n \n # split data and label\n train_data, train_label = (train[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n train[\"_class\"])\n test_data, test_label = (test[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n test[\"_class\"])\n \n # apply classifier\n clf = GaussianNB()\n clf.fit(train_data, train_label)\n probability = clf.predict_proba(test_data).T[1]\n \n result = pd.DataFrame()\n result[\"_class\"] = test_label\n result[\"_predict\"] = probability >= criterion\n \n result_yes = result[result[\"_class\"] == 1]\n yes_yes_rate = sum(result_yes[\"_class\"] == result_yes[\"_predict\"])/len(result_yes[\"_predict\"])\n \n result_no = result[result[\"_class\"] == 0]\n no_no_rate = sum(result_no[\"_class\"] == result_no[\"_predict\"])/len(result_no[\"_predict\"])\n \n rate_list.append((yes_yes_rate, no_no_rate))\n\n rate_list = pd.DataFrame(rate_list)\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\n \n # save data to excel spreadsheet\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\"criterion\", \"yes_yes_rate\", \"no_no_rate\"])\n writer = pd.ExcelWriter(\"parameter_analysis.xlsx\")\n parameter_analysis.to_excel(writer, \"parameter_analysis\", index=False)\n writer.save()","def estimator(dataset, routine, n_neighbors=5, n_runs=1, n_resamplings=10):\r\n\troutine_length = len(routine)\r\n\testimates = []\t\r\n\tX = np.ones((routine_length, 2))\r\n\tX[:, 0] = [np.log(x) for x in routine]\r\n\tfor _ in range(n_runs):\r\n\t\tmean_lengths = np.zeros(routine_length)\r\n\t\tfor index, n_points in enumerate(routine):\r\n\t\t\tmean_lengths[index] = np.log(mean_sample_length(dataset, n_points, n_neighbors, n_resamplings)) \r\n\t\tmodel = LinearRegression().fit(X, mean_lengths)\r\n\t\testimates.append(1/(1-model.coef_[0]))\r\n\treturn int(round(sum(estimates)/n_runs))","def arb_units(wb_run,sample_run,ei_guess,rebin,map_file,**kwargs):\n global reducer, rm_zero,inst_name,van_mass,bleed_switch,rate,pixels\n print 'DGreduce run for ',inst_name,'run number ',sample_run\n try:\n n,r=funcreturns.lhs_info('both')\n #n,r=lhs('both')\n wksp_out=r[0]\n except:\n if sample_run == 0:\n #deal with the current run being parsed as 0 rather than 00000\n sample_run='00000'\n wksp_out=inst_name+str(sample_run)+'.spe'\n if kwargs.has_key('sum') and kwargs.get('sum')==True:\n wksp_out=inst_name+str(sample_run[0])+'sum'+'.spe'\n \n start_time=time.time()\n \n if sample_run=='00000' and mtd.doesExist(inst_name+'00000.raw')==True:\n print 'Deleteing previous instance of temp data'\n DeleteWorkspace(Workspace=inst_name+'00000.raw')\n \n #repopulate defualts\n if kwargs.has_key('norm_method'):\n reducer.normalise_method = kwargs.get('norm_method')\n print 'Setting normalisation method to ', kwargs.get('norm_method')\n else:\n reducer.normalise_method = 'monitor-1'\n if kwargs.has_key('mask_run'):\n mask_run = kwargs.get('mask_run')\n print 'Using run ', kwargs.get('mask_run'),' for diag'\n else:\n mask_run=sample_run\n \n if kwargs.has_key('background'):\n reducer.background = kwargs.get('background')\n print 'Setting background option to ', kwargs.get('background')\n else:\n reducer.background = False\n \n if kwargs.has_key('fixei'):\n reducer.fix_ei = kwargs.get('fixei')\n print 'Setting fixei to ', kwargs.get('fixei')\n else:\n reducer.fix_ei = False\n \n if kwargs.has_key('save_format'):\n reducer.save_formats = kwargs.get('save_format')\n print 'Setting save format to ', kwargs.get('save_format')\n else:\n reducer.save_formats = ['.spe']\n #Set parameters for the run\n \n if kwargs.has_key('detector_van_range'):\n reducer.wb_integr_range = kwargs.get('detector_van_range')\n print 'Setting detector van int range to ', kwargs.get('detector_van_range')\n else:\n reducer.wb_integr_range=[20,100]\n #-------------DIAG------------------------\n if kwargs.has_key('bkgd_range'):\n background_range = kwargs.get('bkgd_range')\n print 'Setting background intergration to ', kwargs.get('bkgd_range')\n else:\n background_range=[15000,19000]\n \n if kwargs.has_key('tiny'):\n tinyval = kwargs.get('tiny')\n print 'Setting tiny ratelimit to ', kwargs.get('tiny')\n else:\n tinyval=1e-10\n \n if kwargs.has_key('large'):\n largeval = kwargs.get('large')\n print 'Setting large limit to ', kwargs.get('large')\n else:\n largeval=1e10\n \n if kwargs.has_key('diag_remove_zero'):\n sampzero = kwargs.get('diag_remove_zero')\n print 'Setting diag to reject zero backgrounds '\n else:\n sampzero =False\n \n if kwargs.has_key('diag_van_median_rate_limit_hi'):\n vanouthi = kwargs.get('diag_van_median_rate_limit_hi')\n print 'Setting diag_van_median_rate_limit_hi to ', kwargs.get('diag_van_median_rate_limit_hi')\n else:\n vanouthi=100\n \n if kwargs.has_key('diag_van_median_rate_limit_lo'):\n vanoutlo = kwargs.get('diag_van_median_rate_limit_lo')\n print 'Setting diag_van_median_rate_limit_lo to ', kwargs.get('diag_van_median_rate_limit_lo')\n else:\n vanoutlo=0.01\n \n if kwargs.has_key('diag_van_median_sigma_lo'):\n vanlo = kwargs.get('diag_van_median_sigma_lo')\n print 'Setting diag_van_median_sigma_lo to ', kwargs.get('diag_van_median_sigma_lo')\n else:\n vanlo=0.1\n \n if kwargs.has_key('diag_van_median_sigma_hi'):\n vanhi = kwargs.get('diag_van_median_sigma_hi')\n print 'Setting diag_van_median_sigma_hi to ', kwargs.get('diag_van_median_sigma_hi')\n else:\n vanhi=1.5\n \n if kwargs.has_key('diag_van_median_sigma'):\n vansig = kwargs.get('diag_van_median_sigma')\n print 'Setting diag_van_median_sigma to ', kwargs.get('diag_van_median_sigma')\n else:\n vansig=0.0\n \n if kwargs.has_key('diag_samp_median_sigma_lo'):\n samplo = kwargs.get('diag_samp_median_sigma_lo')\n print 'Setting diag_samp_median_sigma_lo to ', kwargs.get('diag_samp_median_sigma_lo')\n else:\n samplo=0.0\n \n if kwargs.has_key('diag_samp_median_sigma_hi'):\n samphi = kwargs.get('diag_samp_median_sigma_hi')\n print 'Setting diag_samp_median_sigma_hi to ', kwargs.get('diag_samp_median_sigma_hi')\n else:\n samphi=2.0\n \n if kwargs.has_key('diag_samp_median_sigma'):\n sampsig = kwargs.get('diag_samp_median_sigma')\n print 'Setting diag_samp_median_sigma to ', kwargs.get('diag_samp_median_sigma')\n else:\n sampsig=3.0\n \n if kwargs.has_key('bleed'):\n bleed_switch = kwargs.get('bleed')\n print 'Setting bleed ', kwargs.get('bleed')\n else:\n print 'bleed set to default'\n #---------------END of DIAG--------------------\n if kwargs.has_key('det_cal_file'):\n reducer.det_cal_file = kwargs.get('det_cal_file')\n reducer.relocate_dets = True\n print 'Setting detector calibration file to ', kwargs.get('det_cal_file')\n else:\n print 'Setting detector calibration to detector block info from ', sample_run\n reducer.det_cal_file =None\n reducer.relocate_dets = False\n \n if mtd.doesExist(str(sample_run))==True and kwargs.has_key('det_cal_file')==False:\n print 'For data input type: workspace detector calibration must be specified'\n print 'use Keyword det_cal_file with a valid detctor file or run number'\n return\n \n \n \n if kwargs.has_key('one2one'):\n reducer.map_file =None\n print 'one2one selected'\n \n else:\n fileName, fileExtension = os.path.splitext(map_file)\n if (not fileExtension):\n map_file=map_file+'.map' \n reducer.map_file = map_file\n\n reducer.energy_bins = rebin\n \n if float(str.split(rebin,',')[2])>=float(ei_guess):\n print 'error rebin range exceeds ei'\n return\n \n print 'output will be normalised to', reducer.normalise_method\n if (numpy.size(sample_run)) > 1 and kwargs.has_key('sum') and kwargs.get('sum')==True:\n #this sums the runs together before passing the summed file to the rest of the reduction\n #this circumvents the inbuilt method of summing which fails to sum the files for diag\n \n sumfilename=str(sample_run[0])+'sum'\n accum=sum_files(sumfilename, sample_run)\n #the D.E.C. tries to be too clever so we have to fool it into thinking the raw file is already exists as a workpsace\n RenameWorkspace(InputWorkspace=accum,OutputWorkspace=inst_name+str(sample_run[0])+'.raw')\n sample_run=sample_run[0]\n \n if kwargs.has_key('hardmaskPlus'):\n HardMaskFile = kwargs.get('hardmaskPlus')\n print 'Use hardmask from ', HardMaskFile\n #hardMaskSpec=common.load_mask(HardMaskFile)\n #MaskDetectors(Workspace='masking',SpectraList=hardMaskSpec)\n else:\n HardMaskFile=None\n \n if kwargs.has_key('hardmaskOnly'):\n totalmask = kwargs.get('hardmaskOnly')\n print 'Using hardmask from ', totalmask\n #next stable version can replace this with loadmask algoritum\n specs=diag_load_mask(totalmask)\n CloneWorkspace(InputWorkspace=sample_run,OutputWorkspace='mask_wksp')\n MaskDetectors(Workspace='mask_wksp',SpectraList=specs)\n masking=mtd['mask_wksp']\n else:\n \n masking = reducer.diagnose(wb_run, \n sample=mask_run,\n second_white = None,\n tiny=tinyval, \n huge=largeval, \n van_out_lo=vanoutlo,\n van_out_hi=vanouthi,\n van_lo=vanlo,\n van_hi=vanhi,\n van_sig=vansig,\n samp_zero=sampzero,\n samp_lo=samplo,\n samp_hi=samphi,\n samp_sig=sampsig,\n bkgd_range=background_range, \n variation=1.1,\n print_results=True,\n bleed_test=bleed_switch,\n bleed_maxrate=rate,\n bleed_pixels=pixels,\n hard_mask=HardMaskFile)\n \n reducer.spectra_masks=masking\n #fail_list=get_failed_spectra_list(masking)\n fail_list,n_total_spectra =get_failed_spectra_list_from_masks(masking)\n \n print 'Diag found ', len(fail_list),'bad spectra'\n \n #Run the conversion\n deltaE_wkspace = reducer.convert_to_energy(sample_run, ei_guess, wb_run)\n end_time=time.time()\n results_name=str(sample_run)+'.spe'\n \n ei= (deltaE_wkspace.getRun().getLogData(\"Ei\").value)\n \n if mtd.doesExist('_wksp.spe-white')==True:\n DeleteWorkspace(Workspace='_wksp.spe-white')\n \n if mtd.doesExist(results_name)==False:\n RenameWorkspace(InputWorkspace=deltaE_wkspace,OutputWorkspace=results_name)\n \n print 'Incident energy found ',ei,' meV'\n print 'Elapsed time =',end_time-start_time, 's'\n #get the name that convert to energy will use\n \n \n RenameWorkspace(InputWorkspace=results_name,OutputWorkspace=wksp_out)\n \n return mtd[wksp_out]","def generate_run_data(session, run, baseurl, num_comparison_runs=0,\n result=None, compare_to=None, baseline=None,\n aggregation_fn=lnt.util.stats.safe_min,\n confidence_lv=.05, styles=dict(), classes=dict()):\n assert num_comparison_runs >= 0\n\n start_time = time.time()\n\n ts = run.testsuite\n machine = run.machine\n machine_parameters = machine.parameters\n\n if baseline is None:\n # If a baseline has not been given, look up the run closest to\n # the default baseline revision for which this machine also\n # reported.\n baseline = machine.get_baseline_run(session)\n\n # If the baseline is the same as the comparison run, ignore it.\n visible_note = None\n if baseline is compare_to:\n visible_note = \"Baseline and compare_to are the same: \" \\\n \"disabling baseline.\"\n baseline = None\n\n # Gather the runs to use for statistical data.\n comparison_start_run = compare_to or run\n comparison_window = list(ts.get_previous_runs_on_machine(\n session, comparison_start_run, num_comparison_runs))\n if baseline:\n baseline_window = list(ts.get_previous_runs_on_machine(\n session, baseline, num_comparison_runs))\n else:\n baseline_window = []\n\n # If we don't have an explicit baseline run or a comparison run, use the\n # previous run.\n if compare_to is None and comparison_window:\n compare_to = comparison_window[0]\n\n # Create the run info analysis object.\n runs_to_load = set(r.id for r in comparison_window)\n for r in baseline_window:\n runs_to_load.add(r.id)\n runs_to_load.add(run.id)\n if compare_to:\n runs_to_load.add(compare_to.id)\n if baseline:\n runs_to_load.add(baseline.id)\n sri = lnt.server.reporting.analysis.RunInfo(\n session, ts, runs_to_load, aggregation_fn, confidence_lv)\n\n # Get the test names, metric fields and total test counts.\n test_names = session.query(ts.Test.name, ts.Test.id).\\\n order_by(ts.Test.name).\\\n filter(ts.Test.id.in_(sri.test_ids)).all()\n metric_fields = list(ts.Sample.get_metric_fields())\n num_total_tests = len(metric_fields) * len(test_names)\n\n # Gather the run-over-run changes to report, organized by field and then\n # collated by change type.\n run_to_run_info, test_results = _get_changes_by_type(\n ts, run, compare_to, metric_fields, test_names, num_comparison_runs,\n sri)\n\n # If we have a baseline, gather the run-over-baseline results and\n # changes.\n if baseline:\n run_to_baseline_info, baselined_results = _get_changes_by_type(\n ts, run, baseline, metric_fields, test_names, num_comparison_runs,\n sri)\n else:\n run_to_baseline_info = baselined_results = None\n\n # Gather the run-over-run changes to report.\n\n # Collect the simplified results, if desired, for sending back to clients.\n if result is not None:\n pset_results = []\n result['test_results'] = [{'pset': (), 'results': pset_results}]\n for field, field_results in test_results:\n for _, bucket, _ in field_results:\n for name, cr, _ in bucket:\n # FIXME: Include additional information about performance\n # changes.\n pset_results.append((\"%s.%s\" % (name, field.name),\n cr.get_test_status(),\n cr.get_value_status()))\n\n # Aggregate counts across all bucket types for our num item\n # display\n def aggregate_counts_across_all_bucket_types(i, name):\n num_items = sum(len(field_results[i][1])\n for _, field_results in test_results)\n if baseline:\n num_items_vs_baseline = sum(\n len(field_results[i][1])\n for _, field_results in baselined_results)\n else:\n num_items_vs_baseline = None\n\n return i, name, num_items, num_items_vs_baseline\n\n num_item_buckets = [aggregate_counts_across_all_bucket_types(x[0], x[1][0])\n for x in enumerate(test_results[0][1])]\n\n def maybe_sort_bucket(bucket, bucket_name, show_perf):\n if not bucket or bucket_name == 'Unchanged Test' or not show_perf:\n return bucket\n else:\n return sorted(\n bucket,\n key=lambda bucket_entry: -abs(bucket_entry.cr.pct_delta))\n\n def prioritize_buckets(test_results):\n prioritized = [(priority, field, bucket_name,\n maybe_sort_bucket(bucket, bucket_name, show_perf),\n [name for name, _, __ in bucket], show_perf)\n for field, field_results in test_results\n for priority, (bucket_name, bucket,\n show_perf) in enumerate(field_results)]\n prioritized.sort(key=lambda item: (item[0], item[1].name))\n return prioritized\n\n # Generate prioritized buckets for run over run and run over baseline data.\n prioritized_buckets_run_over_run = prioritize_buckets(test_results)\n if baseline:\n prioritized_buckets_run_over_baseline = \\\n prioritize_buckets(baselined_results)\n else:\n prioritized_buckets_run_over_baseline = None\n\n # Prepare auxillary variables for rendering.\n # Create Subject\n subject = \"\"\"%s test results\"\"\" % (machine.name,)\n\n # Define URLS.\n if baseurl[-1] == '/':\n baseurl = baseurl[:-1]\n ts_url = \"\"\"%s/v4/%s\"\"\" % (baseurl, ts.name)\n run_url = \"\"\"%s/%d\"\"\" % (ts_url, run.id)\n report_url = run_url\n url_fields = []\n if compare_to:\n url_fields.append(('compare_to', str(compare_to.id)))\n if baseline:\n url_fields.append(('baseline', str(baseline.id)))\n report_url = \"%s?%s\" % (run_url, \"&\".join(\"%s=%s\" % (k, v)\n for k, v in url_fields))\n\n # Compute static CSS styles for elemenets. We use the style directly on\n # elements instead of via a stylesheet to support major email clients (like\n # Gmail) which can't deal with embedded style sheets.\n #\n # These are derived from the static style.css file we use elsewhere.\n #\n # These are just defaults however, and the caller can override them with\n # the 'styles' and 'classes' kwargs.\n styles_ = {\n \"body\": (\"color:#000000; background-color:#ffffff; \"\n \"font-family: Helvetica, sans-serif; font-size:9pt\"),\n \"h1\": (\"font-size: 14pt\"),\n \"table\": \"font-size:9pt; border-spacing: 0px; border: 1px solid black\",\n \"th\": (\"background-color:#eee; color:#666666; font-weight: bold; \"\n \"cursor: default; text-align:center; font-weight: bold; \"\n \"font-family: Verdana; padding:5px; padding-left:8px\"),\n \"td\": \"padding:5px; padding-left:8px\",\n }\n classes_ = {\n }\n\n styles_.update(styles)\n classes_.update(classes)\n\n data = {\n 'ts': ts,\n 'subject': subject,\n 'report_url': report_url,\n 'ts_url': ts_url,\n 'compare_to': compare_to,\n 'run': run,\n 'run_url': run_url,\n 'baseline': baseline,\n 'machine': machine,\n 'machine_parameters': machine_parameters,\n 'num_item_buckets': num_item_buckets,\n 'num_total_tests': num_total_tests,\n 'run_to_run_info': run_to_run_info,\n 'prioritized_buckets_run_over_run': prioritized_buckets_run_over_run,\n 'run_to_baseline_info': run_to_baseline_info,\n 'prioritized_buckets_run_over_baseline':\n prioritized_buckets_run_over_baseline,\n 'styles': styles_,\n 'classes': classes_,\n 'start_time': start_time,\n 'sri': sri,\n 'visible_note': visible_note,\n }\n return data","def main():\n\tresults = []\n\n\tconfig = configparser.ConfigParser()\n\tconfig.read(\"simulation.ini\")\n\tsettings = config['sim']\n\n\tcompleted_obj_hw = int(settings[\"ClientsPerCampaign\"]) * float(settings[\"CompletedPctgHW\"])\n\texceeded_obj_hw = float(settings[\"ExceededPctgHW\"])\n\tsignificance_level = float(settings[\"SignificanceLevel\"])\n\tz_val_two_tails = scipy.stats.norm.ppf(1 - (significance_level / 2))\n\n\tprint(\"Completed Target HW: \" + str(completed_obj_hw))\n\tprint(\"Exceeded Target HW: \" + str(exceeded_obj_hw))\n\n\tcompleted_vals = []\n\texceeded_vals = []\n\tdone = False\n\n\tcompleted_avg = 0\n\texceeded_avg = 0\n\tcompleted_hw = 0\n\texceeded_hw = 0\n\n\ti = 0\n\twhile not done:\n\t\tprint(\"RUN: \" + str(i + 1))\n\t\tenv = simpy.Environment()\n\t\tsim = Simulation(env, settings, i == 0)\n\t\tsim.run()\n\t\tresults.append(sim.results)\n\t\ti += 1\n\n\t\tif settings['RunOnce'] == 'yes':\n\t\t\tprint(\"RUN ONCE\")\n\t\t\tsys.exit()\n\n\t\tcompleted_vals.append(sim.results['completed_count'])\n\t\texceeded_vals.append(sim.results['exceeded_proportion'])\n\n\t\tif i < 2:\n\t\t\tprint(\"---------------\")\n\t\t\tcontinue\n\n\t\tcompleted_avg = sum(completed_vals) / len(completed_vals)\n\t\tcompleted_S = sum([(v - completed_avg) ** 2 for v in completed_vals]) / (i - 1)\n\t\tcompleted_S = math.sqrt(completed_S)\n\t\tcompleted_hw = (z_val_two_tails * completed_S) / math.sqrt(i)\n\t\tprint(\"runs: \" + str(i) + \" completed HW: \" + str(completed_hw))\n\n\t\texceeded_avg = sum(exceeded_vals) / len(exceeded_vals)\n\t\texceeded_S = math.sqrt(exceeded_avg * (1 - exceeded_avg))\n\t\texceeded_hw = (z_val_two_tails * exceeded_S) / math.sqrt(i)\n\t\tprint(\"runs: \" + str(i) + \" exceeded HW: \" + str(exceeded_hw))\n\n\t\tif completed_hw < completed_obj_hw and exceeded_hw < exceeded_obj_hw:\n\t\t\tprint(\"END ITERATIONS\")\n\t\t\tdone = True\n\n\t\tprint(\"---------------\")\n\n\n\tfilename = 'results/Results_' + settings['FileSizeGB'] + '_' + settings['TorrentThreshold'] + '_' + settings['HTTPDownThreshold'] \\\n\t\t+ '_' + settings['HTTPUp'] + '_' + str(random.randint(0,10000)) + '.xlsx'\n\n\tprint(\"Saving XLSX to: \" + filename)\n\twb = xs.Workbook(filename)\n\n\tws = wb.add_worksheet()\n\n\tws.write(0, 1, 'Exceded')\n\tws.write(0, 2, 'Completed')\n\n\ti = 1\n\tfor result in results:\n\t\tws.write(i, 0, i)\n\t\tws.write(i, 1, result['exceeded_proportion'])\n\t\tws.write(i, 2, result['completed_count'])\n\t\ti += 1\n\n\tws.write(i, 0, 'average')\n\tws.write(i, 1, exceeded_avg)\n\tws.write(i, 2, completed_avg)\n\ti += 1\n\tws.write(i, 0, 'half width')\n\tws.write(i, 1, exceeded_hw)\n\tws.write(i, 2, completed_hw)\n\n\twb.close()","def print_run_perfs(verbose_dico):\n for item_strat, v1 in verbose_dico.items():\n print(item_strat)\n list_of_perfs = []\n list_of_prints = []\n for skill_strat, v2 in v1.items():\n list_of_params = []\n acpl_perfs = []\n acpr_perfs = []\n for param_value, v3 in v2.items():\n list_of_params.append(param_value)\n for period, v4 in v3.items():\n strat_perf = np.mean(verbose_dico[item_strat][skill_strat][param_value][period])\n if period == \"learning\":\n acpl_perfs.append(strat_perf)\n if period == \"retention\":\n acpr_perfs.append(strat_perf)\n # Find best parameters\n best_param_index = np.argmax(acpr_perfs)\n list_of_perfs.append(np.around(acpr_perfs[best_param_index],3))\n list_of_prints.append(\"\\t {0:>26} | Best param : {1:>3} | ACPL = {2:>6} | ACPR = {3:>6}\".format(skill_strat,\n np.around(list_of_params[best_param_index],2),\n np.around(acpl_perfs[best_param_index],3),\n np.around(acpr_perfs[best_param_index],3)))\n for strat_index in np.argsort(list_of_perfs)[::-1]:\n print(list_of_prints[strat_index])","def multiple_runs(self, n: int, **kwargs: tp.Any) -> tp.Dict[str, tp.List[tp.Tuple[ARR, ARR]]]:\n predictions = [self.single_run(**kwargs) for i in range(n)]\n return {\n 'train': [pred['train'] for pred in predictions],\n 'test': [pred['test'] for pred in predictions]\n }","def create_trials(self):\n self.trial_list=[]\n \n #simple tools to check subject responses online\n self.correct_responses = 0\n self.total_responses = 0\n self.dot_count = 0\n \n bar_orientations = np.array(self.settings['PRF stimulus settings']['Bar orientations'])\n #create as many trials as TRs. 5 extra TRs at beginning + bar passes + blanks\n self.trial_number = 5 + self.settings['PRF stimulus settings']['Bar pass steps']*len(np.where(bar_orientations != -1)[0]) + self.settings['PRF stimulus settings']['Blanks length']*len(np.where(bar_orientations == -1)[0])\n \n print(\"Expected number of TRs: %d\"%self.trial_number)\n #create bar orientation list at each TR (this can be done in many different ways according to necessity)\n #for example, currently blank periods have same length as bar passes. this can easily be changed here\n steps_array=self.settings['PRF stimulus settings']['Bar pass steps']*np.ones(len(bar_orientations))\n blanks_array=self.settings['PRF stimulus settings']['Blanks length']*np.ones(len(bar_orientations))\n \n repeat_times=np.where(bar_orientations == -1, blanks_array, steps_array).astype(int)\n \n self.bar_orientation_at_TR = np.concatenate((-1*np.ones(5), np.repeat(bar_orientations, repeat_times)))\n \n \n #calculation of positions depend on whether code is run on mac\n if self.settings['operating system'] == 'mac':\n bar_pos_array = (self.win.size[1]/2)*np.linspace(-0.5,0.5, self.settings['PRF stimulus settings']['Bar pass steps'])\n else:\n bar_pos_array = self.win.size[1]*np.linspace(-0.5,0.5, self.settings['PRF stimulus settings']['Bar pass steps'])\n \n \n blank_array = np.zeros(self.settings['PRF stimulus settings']['Blanks length'])\n \n #the 5 empty trials at beginning\n self.bar_pos_in_ori=np.zeros(5)\n \n #bar position at TR\n for i in range(len(bar_orientations)):\n if bar_orientations[i]==-1:\n self.bar_pos_in_ori=np.append(self.bar_pos_in_ori, blank_array)\n else:\n self.bar_pos_in_ori=np.append(self.bar_pos_in_ori, bar_pos_array)\n \n \n #random bar direction at each step. could also make this time-based\n self.bar_direction_at_TR = np.round(np.random.rand(self.trial_number))\n \n #trial list\n for i in range(self.trial_number):\n \n self.trial_list.append(PRFTrial(session=self,\n trial_nr=i,\n \n bar_orientation=self.bar_orientation_at_TR[i],\n bar_position_in_ori=self.bar_pos_in_ori[i],\n bar_direction=self.bar_direction_at_TR[i]\n #,tracker=self.tracker\n ))\n\n\n #times for dot color change. continue the task into the topup\n self.total_time = self.trial_number*self.bar_step_length \n \n if self.settings['mri']['topup_scan']==True:\n self.total_time += self.topup_scan_duration\n \n \n #DOT COLOR CHANGE TIMES \n self.dot_switch_color_times = np.arange(3, self.total_time, float(self.settings['Task settings']['color switch interval']))\n self.dot_switch_color_times += (2*np.random.rand(len(self.dot_switch_color_times))-1)\n \n \n #needed to keep track of which dot to print\n self.current_dot_time=0\n self.next_dot_time=1\n\n #only for testing purposes\n np.save(opj(self.output_dir, self.output_str+'_DotSwitchColorTimes.npy'), self.dot_switch_color_times)\n print(self.win.size)","def _get_initial_run_stats(self):\r\n return OrderedDict([('linesWithRecommendations', 0),\r\n ('linesAnalyzed', 0),\r\n ('linesRead', 0),\r\n ('dexTime', datetime.utcnow()),\r\n ('logSource', None),\r\n ('timeRange', OrderedDict([('start', None),\r\n ('end', None)])),\r\n ('unparsableLineInfo', OrderedDict([('unparsableLines', 0),\r\n ('unparsableLinesWithoutTime', 0),\r\n ('unparsableLinesWithTime', 0),\r\n ('unparsedTimeMillis', 0),\r\n ('unparsedAvgTimeMillis', 0)]))])","def train_multiple_runs(self, env, runs=3, ts_max=10000, horizon=1000, lr=0.1):\n\t\tr_mat = []\n\t\tinfo = {}\n\t\t\n\t\tfor i in range(runs):\n\n\t\t\t# Resetting agent to default before each run\n\t\t\tself.reset()\n\n\t\t\t# Training the agent for ts_max\n\t\t\tr_vec = self.train_multiple_ts(env, ts_max=ts_max, horizon=horizon, lr=lr)\n\n\t\t\t# Storing the results in a matrix\n\t\t\tr_mat.append(r_vec)\n\n\t\t# Finding the mean and standard deviation \n\t\tinfo['mean'] = np.mean(np.array(r_mat), axis=0)\n\t\tinfo['std'] = np.std(np.array(r_mat), axis=0)\n\n\t\treturn r_mat, info","def runs(self):\n return {\n 'passed': self._runs_passed,\n 'failed': self._runs_failed,\n 'missed': self._runs_missed,\n }","def run_numbers():\n if run_nos:\n # Get task names\n tasks = []\n for rn in dcm_dict.keys():\n tasks.append(dcm_dict[rn]['task_name'])\n # Assign run numbers\n for tsk in set(tasks):\n n_runs = sum(i == tsk for i in tasks)\n if n_runs == 1:\n for rn in dcm_dict.keys():\n if dcm_dict[rn]['task_name'] == tsk:\n # Add in the 'task' prefix required by BIDS format if missing from name\n if not tsk[0:4] == 'task':\n dcm_dict[rn]['out_name'] = 'task-'+tsk+'_run-01'\n else:\n dcm_dict[rn]['out_name'] = tsk+'_run-01'\n elif n_runs > 1:\n task_runs = []\n run_times = []\n for rn in dcm_dict.keys():\n if dcm_dict[rn]['task_name'] == tsk:\n task_runs.append(rn)\n run_times.append(dcm_dict[rn]['start_time'].timestamp())\n idx_order = sorted(range(len(run_times)), key=lambda k: run_times[k])\n for i in idx_order:\n if not tsk[0:4] == 'task':\n dcm_dict[task_runs[i]]['out_name'] = 'task-'+tsk+'_run-0'+str(i+1)\n else:\n dcm_dict[task_runs[i]]['out_name'] = tsk+'_run-0'+str(i+1)\n else:\n for rn in dcm_dict.keys():\n dcm_dict[rn]['out_name'] = dcm_dict[rn]['task_name']","def _output_summary(self, run_id):\n time = self._summary.get_time_taken()\n time_delta = None\n num_tests_run_delta = None\n num_failures_delta = None\n values = [(\"id\", run_id, None)]\n failures = self._summary.get_num_failures()\n previous_summary = self._get_previous_summary()\n if failures:\n if previous_summary:\n num_failures_delta = failures - previous_summary.get_num_failures()\n values.append((\"failures\", failures, num_failures_delta))\n if previous_summary:\n num_tests_run_delta = self._summary.testsRun - previous_summary.testsRun\n if time:\n previous_time_taken = previous_summary.get_time_taken()\n if previous_time_taken:\n time_delta = time - previous_time_taken\n skips = len(self._summary.skipped)\n if skips:\n values.append((\"skips\", skips, None))\n output.output_summary(\n not bool(failures),\n self._summary.testsRun,\n num_tests_run_delta,\n time,\n time_delta,\n values,\n output=self.stream,\n )","def target_portfolio_simulation(num_of_years=30, trials=100, method='normal'):\n print(\"Running method target_portfolio_simulation()\")\n\n sim_fia_cv = pd.DataFrame(index=range(num_of_years + 1))\n\n sim_base_total = pd.DataFrame(index=range(num_of_years + 1))\n sim_base_income = pd.DataFrame(index=range(num_of_years + 1))\n\n sim_port_total = pd.DataFrame(index=range(num_of_years + 1))\n sim_port_income = pd.DataFrame(index=range(num_of_years + 1))\n\n read_income_inputs = pd.read_excel(src + \"portfolio_information.xlsx\", sheet_name='income_model_inputs',\n index_col=[0])\n\n read_returns_est = pd.read_excel(src + \"portfolio_information.xlsx\", sheet_name='income_assets_returns_estimates',\n index_col=[0])\n\n read_asset_weights = pd.read_excel(src + \"portfolio_information.xlsx\", sheet_name='asset_weights',\n index_col=[0])\n\n # read_asset_weights.drop(read_asset_weights.index[-1], axis=0, inplace=True)\n\n # read random returns for simulation\n read_normal = pd.read_csv(src + 'median_returns_unsorted.csv', index_col=[0], parse_dates=True)\n cols = [read_normal.columns[c].split('_')[1] for c in np.arange(len(read_normal.columns))]\n read_normal.rename(columns=dict(zip(list(read_normal.columns), cols)), inplace=True)\n\n read_small = pd.read_csv(src + 'median_returns_smallest.csv', index_col=[0], parse_dates=True)\n read_small.rename(columns=dict(zip(list(read_small.columns), cols)), inplace=True)\n\n read_large = pd.read_csv(src + 'median_returns_largest.csv', index_col=[0], parse_dates=True)\n read_large.rename(columns=dict(zip(list(read_large.columns), cols)), inplace=True)\n\n assets_col_names = list(read_normal.columns)\n\n tickers = list(read_asset_weights.index)\n wts = np.array(read_asset_weights.loc[:, 'base'])\n\n def asset_median_returns(data, ticker):\n return data.filter(regex=ticker).median(axis=1)\n\n # dataframe for unsorted returns (normal)\n median_returns_normal = read_normal.copy()\n median_returns_normal.loc[:, 'portfolio_return'] = median_returns_normal.dot(wts)\n median_normal_fia = pd.DataFrame({'FIA': asset_median_returns(read_normal, 'FIA')})\n\n # dataframe for smallest to largest returns\n median_returns_smallest = read_small.copy()\n median_returns_smallest.loc[:, 'portfolio_return'] = median_returns_smallest.dot(wts)\n median_smallest_fia = pd.DataFrame({'FIA': asset_median_returns(read_small, 'FIA')})\n\n # dataframe for largest to smallest returns\n median_returns_largest = read_large.copy()\n median_returns_largest.loc[:, 'portfolio_return'] = median_returns_largest.dot(wts)\n median_largest_fia = pd.DataFrame({'FIA': asset_median_returns(read_large, 'FIA')})\n\n years = list(range(0, num_of_years + 1))\n income_cols = ['year', 'strategy_term', 'index_returns', 'term_ret', 'term_ret_with_par', 'term_annualize',\n 'ann_net_spread', 'term_ret_netspr', 'high_inc_benefit_base', 'rider_fee', 'eoy_income',\n 'contract_value']\n\n term = int(read_income_inputs.loc['term', 'inputs'])\n fia_ret = read_returns_est.loc[read_returns_est.index[-1], 'Annualized Returns']\n fia_risk = read_returns_est.loc[read_returns_est.index[-1], 'Annualized Risk']\n par_rate = float(read_income_inputs.loc['par_rate', 'inputs'])\n spread = float(read_income_inputs.loc['spread', 'inputs'])\n bonus_term = int(read_income_inputs.loc['bonus_term', 'inputs'])\n premium = float(read_income_inputs.loc['premium', 'inputs'])\n income_bonus = float(read_income_inputs.loc['income_bonus', 'inputs'])\n\n income_starts = int(read_income_inputs.loc['start_income_years', 'inputs'])\n income_growth = float(read_income_inputs.loc['income_growth', 'inputs'])\n rider_fee = float(read_income_inputs.loc['rider_fee', 'inputs'])\n inc_payout_factor = float(read_income_inputs.loc['income_payout_factor', 'inputs'])\n contract_bonus = float(read_income_inputs.loc['contract_bonus', 'inputs'])\n social = float(read_income_inputs.loc['social', 'inputs'])\n inflation = float(read_income_inputs.loc['inflation', 'inputs'])\n wtd_cpn_yield = float(read_income_inputs.loc['wtd_coupon_yld', 'inputs'])\n life_expectancy = int(read_income_inputs.loc['life_expectancy_age', 'inputs'])\n clients_age = int(read_income_inputs.loc['clients_age', 'inputs'])\n\n # ---------------INCOME MODEL--------------------------------------------\n runs = 0\n returns_dict = {}\n asset_dict = {}\n fia_dict = {}\n\n income_df = pd.DataFrame(index=years, columns=income_cols)\n income_df.loc[:, 'year'] = years\n income_df.loc[:, 'strategy_term'] = income_df.loc[:, 'year'] % term\n income_df.loc[:, 'strategy_term'] = income_df['strategy_term'].apply(lambda x: 1 if x == 0 else 0)\n\n if method == 'normal':\n income_df.loc[:, 'index_returns'] = read_normal.loc[:, 'FIA']\n\n elif method == 'smallest':\n income_df.loc[:, 'index_returns'] = read_small.loc[:, 'FIA']\n\n else:\n income_df.loc[:, 'index_returns'] = read_large.loc[:, 'FIA']\n\n # income_df.loc[:, 'index_returns'] = np.random.normal(fia_ret, fia_risk, size=(len(years), 1))\n\n cumprod = (1. + income_df['index_returns']).rolling(window=term).agg(lambda x: x.prod()) - 1\n income_df.loc[:, 'term_ret'] = np.where(income_df.loc[:, 'strategy_term'] == 1, cumprod, 0)\n income_df.loc[:, 'term_ret_with_par'] = income_df.loc[:, 'term_ret'] * par_rate\n income_df.loc[:, 'term_annualize'] = income_df.loc[:, 'term_ret_with_par'].apply(\n lambda x: (1 + x) ** (1 / term) - 1)\n income_df.loc[:, 'ann_net_spread'] = income_df.loc[:, 'term_annualize'] - spread\n income_df.loc[:, 'ann_net_spread'] = np.where(income_df.loc[:, 'strategy_term'] == 1,\n income_df.loc[:, 'ann_net_spread'], 0)\n income_df.loc[:, 'term_ret_netspr'] = income_df.loc[:, 'ann_net_spread'].apply(lambda x: (1 + x) ** term - 1)\n\n for counter in years:\n if counter == 0:\n income_df.loc[counter, 'high_inc_benefit_base'] = premium * (1 + income_bonus)\n\n elif counter <= min(bonus_term, income_starts):\n income_df.loc[counter, 'high_inc_benefit_base'] = income_df.loc[counter - 1, 'high_inc_benefit_base'] * \\\n (1 + income_growth)\n else:\n income_df.loc[counter, 'high_inc_benefit_base'] = income_df.loc[counter - 1, 'high_inc_benefit_base']\n\n income_df.loc[:, 'rider_fee'] = income_df.loc[:, 'high_inc_benefit_base'] * rider_fee\n income_df.loc[:, 'eoy_income'] = np.where(income_df.loc[:, 'year'] > income_starts,\n income_df.loc[:, 'high_inc_benefit_base'] * inc_payout_factor, 0)\n\n for counter in years:\n if counter == 0:\n income_df.loc[counter, 'contract_value'] = premium * (1 + contract_bonus)\n\n elif income_df.loc[counter, 'strategy_term'] == 1:\n x1 = income_df.loc[counter - 1, 'contract_value'] - income_df.loc[counter, 'rider_fee']\n x2 = (x1 * (1 + income_df.loc[counter, 'term_ret_netspr'])) - income_df.loc[counter, 'eoy_income']\n income_df.loc[counter, 'contract_value'] = x2\n\n else:\n x1 = income_df.loc[counter - 1, 'contract_value'] - income_df.loc[counter, 'rider_fee'] - \\\n income_df.loc[counter, 'eoy_income']\n\n income_df.loc[counter, 'contract_value'] = x1\n\n # variable stores the income number that is used in the base and fia portfolio calcs.\n\n income_from_fia = income_df.loc[income_df.index[-1], 'eoy_income']\n\n income_df.loc[:, 'contract_value'] = income_df.loc[:, 'contract_value'].apply(lambda x: 0 if x <= 0 else x)\n\n sim_fia_cv.loc[:, str(runs)] = income_df.loc[:, 'contract_value']\n\n # --------------------BASE MODEL---------------------------------------------\n base_wts = read_asset_weights.loc[:, 'base']\n base_assets = list(base_wts.index)\n base_weights = list(base_wts.values)\n base_returns = list(read_returns_est.loc[:, 'Annualized Returns'].values)\n base_std = list(read_returns_est.loc[:, 'Annualized Risk'].values)\n\n base_investment = float(read_income_inputs.loc['risky_assets', 'Base'])\n adv_fees = float(read_income_inputs.loc['advisor_fees', 'Base'])\n\n # -------------------required income----------------------------------\n req_annual_income = float(read_income_inputs.loc['annual_income', 'inputs'])\n income_needed = req_annual_income - social\n income_net_fia_income = max(0, income_needed - income_from_fia)\n cpn_income_base = base_investment * wtd_cpn_yield\n\n # ----------------------RANDOM RETURNS--------------------------\n r_cols = base_assets\n boy_value = ['bv_{}'.format(name) for name in base_assets]\n eoy_value = ['ev_{}'.format(name) for name in base_assets]\n\n random_returns = pd.DataFrame(index=income_df.index, columns=r_cols)\n\n for c in range(len(r_cols)):\n ret = np.random.normal(base_returns[c], base_std[c], size=(len(random_returns.index), 1))\n\n if method == 'smallest':\n random_returns = read_small.copy()\n\n elif method == 'largest':\n random_returns = read_large.copy()\n\n else:\n random_returns = read_normal.copy()\n\n base_df = random_returns.copy()\n fia_portfolio_df = random_returns.copy()\n port_investment = float(read_income_inputs.loc['risky_assets', 'FIA'])\n cpn_income_port = port_investment * wtd_cpn_yield\n\n # -------------BASE PORTFOLIO----------------------------\n for name in boy_value:\n base_df.loc[:, name] = 0.0\n\n for counter in years:\n period_returns = list(random_returns.loc[counter, :])\n if counter == 0:\n\n base_df.loc[counter, boy_value] = [base_weights[c] * base_investment for c in range(len(boy_value))]\n\n base_df.loc[counter, 'total'] = base_df.loc[counter, boy_value].sum()\n base_df.loc[counter, 'total_net_fees'] = 0.0\n base_df.loc[counter, 'income'] = 0.0\n base_investment = base_df.loc[counter, boy_value].sum()\n\n elif (counter > 0) and (counter < income_starts):\n\n base_df.loc[counter, boy_value] = [base_weights[c] * base_investment * (1 + period_returns[c])\n for c in range(len(boy_value))]\n base_df.loc[counter, 'total'] = base_df.loc[counter, boy_value].sum()\n base_df.loc[counter, 'adv_fees'] = base_df.loc[counter, 'total'] * adv_fees\n base_df.loc[counter, 'total_net_fees'] = base_df.loc[counter, 'total'] - base_df.loc[\n counter, 'adv_fees']\n\n # --coupon payment is invested back into the risky portfolio until the income is withdrawn----\n base_investment = base_df.loc[counter, 'total_net_fees'] + cpn_income_base\n\n else:\n\n base_df.loc[counter, boy_value] = [base_weights[c] * base_investment * (1 + period_returns[c])\n for c in range(len(boy_value))]\n base_df.loc[counter, 'total'] = base_df.loc[counter, boy_value].sum()\n base_df.loc[counter, 'adv_fees'] = base_df.loc[counter, 'total'] * adv_fees\n\n # ---req. income is adjusted for inflation from the second year of withdrawal. Reinvestment of coupon\n # stops from the year income starts. Req. income is reduced by the coupon payments\n\n if counter == income_starts:\n\n income_needed = req_annual_income - social\n base_df.loc[counter, 'income'] = income_needed - cpn_income_base\n income_needed = req_annual_income\n\n else:\n income_needed = income_needed * (1 + inflation) - social\n base_df.loc[counter, 'income'] = income_needed - cpn_income_base\n income_needed = income_needed + social\n\n base_df.loc[counter, 'total_net_fees'] = base_df.loc[counter, 'total'] - \\\n base_df.loc[counter, 'adv_fees'] - \\\n base_df.loc[counter, 'income']\n\n base_investment = base_df.loc[counter, 'total_net_fees']\n\n base_df.loc[:, 'adj_total'] = base_df.loc[:, 'total_net_fees'].apply(lambda x: x if x > 0 else 0)\n sim_base_total.loc[:, 's_{}'.format(str(runs))] = base_df.loc[:, 'total_net_fees']\n sim_base_income.loc[:, 's_{}'.format(str(runs))] = base_df.loc[:, 'income']\n\n # ----------------------------FIA PORTFOLIO----------------------------------------------\n for name in boy_value:\n fia_portfolio_df.loc[:, name] = 0.0\n\n for counter in years:\n period_returns = list(random_returns.loc[counter, :])\n if counter == 0:\n\n fia_portfolio_df.loc[counter, boy_value] = [base_weights[c] * port_investment\n for c in range(len(boy_value))]\n fia_portfolio_df.loc[counter, 'total'] = fia_portfolio_df.loc[counter, boy_value].sum()\n fia_portfolio_df.loc[counter, 'total_net_fees'] = 0.0\n fia_portfolio_df.loc[counter, 'income'] = 0.0\n port_investment = fia_portfolio_df.loc[counter, boy_value].sum()\n\n elif (counter > 0) and (counter < income_starts):\n\n fia_portfolio_df.loc[counter, boy_value] = [base_weights[c] * port_investment * (1 + period_returns[c])\n for c in range(len(boy_value))]\n fia_portfolio_df.loc[counter, 'total'] = fia_portfolio_df.loc[counter, boy_value].sum()\n fia_portfolio_df.loc[counter, 'adv_fees'] = fia_portfolio_df.loc[counter, 'total'] * adv_fees\n fia_portfolio_df.loc[counter, 'total_net_fees'] = fia_portfolio_df.loc[counter, 'total'] - \\\n fia_portfolio_df.loc[counter, 'adv_fees']\n\n port_investment = fia_portfolio_df.loc[counter, 'total_net_fees'] + cpn_income_port\n\n else:\n fia_portfolio_df.loc[counter, boy_value] = [base_weights[c] * port_investment * (1 + period_returns[c])\n for c in range(len(boy_value))]\n fia_portfolio_df.loc[counter, 'total'] = fia_portfolio_df.loc[counter, boy_value].sum()\n fia_portfolio_df.loc[counter, 'adv_fees'] = fia_portfolio_df.loc[counter, 'total'] * adv_fees\n\n # ---req. income is adjusted for inflation from the second year of withdrawal. Reinvestment of coupon\n # stops from the year income starts. Req. income is reduced by the coupon payments\n\n if counter == income_starts:\n\n income_needed = req_annual_income - social\n income_net_fia_income = max(0, income_needed - income_from_fia)\n fia_portfolio_df.loc[counter, 'income'] = max(0, income_net_fia_income - cpn_income_port)\n income_needed = req_annual_income\n\n else:\n income_needed = income_needed * (1 + inflation) - social\n income_net_fia_income = max(0, income_needed - income_from_fia)\n fia_portfolio_df.loc[counter, 'income'] = max(0, income_net_fia_income - cpn_income_port)\n income_needed = income_needed + social\n\n fia_portfolio_df.loc[counter, 'total_net_fees'] = fia_portfolio_df.loc[counter, 'total'] - \\\n fia_portfolio_df.loc[counter, 'adv_fees'] - \\\n fia_portfolio_df.loc[counter, 'income']\n\n port_investment = fia_portfolio_df.loc[counter, 'total_net_fees']\n\n sim_port_total.loc[:, 's_{}'.format(str(runs))] = fia_portfolio_df.loc[:, 'total_net_fees'] + \\\n income_df.loc[:, 'contract_value']\n\n sim_port_income.loc[:, 's_{}'.format(str(runs))] = fia_portfolio_df.loc[:, 'income']\n\n fia_portfolio_df.loc[:, 'adj_total'] = fia_portfolio_df.loc[:, 'total_net_fees'].apply(\n lambda x: x if x > 0 else 0)\n\n # ---------income breakdown for Base portfolio----------------------------------\n base_df.to_csv(src + 'base_port_detail.csv')\n sim_base_total.to_csv(src + 'base_ending_values.csv')\n income_breakdown_base = pd.DataFrame(sim_base_total.quantile(0.5, axis=1))\n income_breakdown_base.loc[:, 'income_from_portfolio'] = sim_base_income.quantile(0.5, axis=1)\n income_breakdown_base.loc[:, 'fia_income'] = 0.0\n income_breakdown_base.loc[:, 'social_security_income'] = social\n income_breakdown_base.loc[:, 'coupon_income'] = cpn_income_base\n\n income_breakdown_base.rename(columns={income_breakdown_base.columns[0]: 'portfolio_ending_value'}, inplace=True)\n income_breakdown_base.loc[:, 'income_from_portfolio'][\n income_breakdown_base.loc[:, 'portfolio_ending_value'] <= 0] = 0\n income_breakdown_base.loc[:, 'total_income'] = income_breakdown_base.loc[:, income_breakdown_base.columns[1:]].sum(\n axis=1)\n\n # ------------Block Ends-------------------------------------------------------------\n\n # ---------income breakdown for FIA portfolio----------------------------------\n fia_portfolio_df.to_csv(src + 'fia_port_detail.csv')\n sim_port_total.to_csv(src + 'fiaport_ending_values.csv')\n\n income_breakdown_port = pd.DataFrame(sim_port_total.quantile(0.5, axis=1))\n income_breakdown_port.loc[:, 'income_from_portfolio'] = sim_port_income.quantile(0.5, axis=1)\n income_breakdown_port.loc[:, 'fia_income'] = income_from_fia\n income_breakdown_port.loc[:, 'social_security_income'] = social\n income_breakdown_port.loc[:, 'coupon_income'] = cpn_income_port\n\n income_breakdown_port.rename(columns={income_breakdown_port.columns[0]: 'portfolio_ending_value'}, inplace=True)\n income_breakdown_port.loc[:, 'income_from_portfolio'][\n income_breakdown_port.loc[:, 'portfolio_ending_value'] <= 0] = 0\n income_breakdown_port.loc[:, 'total_income'] = income_breakdown_port.loc[:, income_breakdown_port.columns[1:]].sum(\n axis=1)\n\n # ------------Block Ends-------------------------------------------------------------\n q_cut = [0.0, 0.05, 0.25, 0.5, 0.75, 0.95, 1.0]\n sim_base_income[sim_base_total < income_needed] = 0.0\n\n sim_port_income[sim_port_total < income_net_fia_income] = 0\n\n sim_port_income = sim_port_income + income_from_fia\n\n # base_quantile = sim_base_total.loc[sim_base_total.index[-1]].quantile([0.05, 0.25, 0.50, 0.75, 0.90])\n\n # port_quantile = sim_port_total.loc[sim_port_total.index[-1]].quantile([0.05, 0.25, 0.50, 0.75, 0.90])\n\n base_quantile = sim_base_total.loc[sim_base_total.index[-1]].quantile(q_cut)\n\n port_quantile = sim_port_total.loc[sim_port_total.index[-1]].quantile(q_cut)\n\n # q_cut = [0.0, .05, 0.25, 0.5, 0.75, 0.95, 1.0]\n cols = ['Min', '5th', '25th', '50th', '75th', '90th', 'Max']\n\n # ----drop year 0--------\n sim_base_total = sim_base_total[1:]\n sim_port_total = sim_port_total[1:]\n\n # ----------------quantile analysis for base terminal value--------------------------\n base_qcut = pd.DataFrame(index=sim_base_total.index, columns=cols)\n for c in range(len(cols)):\n base_qcut.loc[:, cols[c]] = sim_base_total.quantile(q_cut[c], axis=1)\n\n base_qcut.clip(lower=0, inplace=True)\n\n # ----------------------quantile analysis for base income----------------------------\n base_income_qcut = pd.DataFrame(index=sim_base_income.index, columns=cols)\n for c in range(len(cols)):\n base_income_qcut.loc[:, cols[c]] = sim_base_income.quantile(q_cut[c], axis=1)\n\n # ----Remove NaN's prior to the income start years------------\n # base_income_qcut = base_income_qcut.loc[income_starts:]\n\n # -------------quantile analysis for portfolio terminal value ----------------\n port_qcut = pd.DataFrame(index=sim_port_total.index, columns=cols)\n for c in range(len(cols)):\n port_qcut.loc[:, cols[c]] = sim_port_total.quantile(q_cut[c], axis=1)\n\n port_qcut.clip(lower=0, inplace=True)\n\n # ---------------quantile analysis for portfolio income----------------------------\n port_income_qcut = pd.DataFrame(index=sim_port_income.index, columns=cols)\n for c in range(len(cols)):\n port_income_qcut.loc[:, cols[c]] = sim_port_income.quantile(q_cut[c], axis=1)\n\n # ----Remove NaN's prior to the income start years------------\n # port_income_qcut = port_income_qcut.loc[income_starts:]\n\n # ----------probability ending value will be less than 0 at the end of the horizon -----------------------\n base_legacy_risk = (sim_base_total.loc[sim_base_total.index[life_expectancy - clients_age]] < 0).sum() / (\n trials + 1)\n port_legacy_risk = (sim_port_total.loc[sim_port_total.index[life_expectancy - clients_age]] < 0).sum() / (\n trials + 1)\n\n legacy_risk = pd.DataFrame([base_legacy_risk, port_legacy_risk,\n 'Prob. of portfolio value less than 0 at the end of the expected life'],\n index=['base', 'fia_portfolio', 'Notes'],\n columns=['Ruin Probability'])\n\n # -----------Year-wise probability of ending value greater than 0 -----------------\n base_psuccess = sim_base_total.apply(lambda x: x > 0).sum(axis=1) / (trials + 1)\n port_psuccess = sim_port_total.apply(lambda x: x > 0).sum(axis=1) / (trials + 1)\n\n # -----------------------WRITING FILES TO EXCEL ---------------------------\n col_names = ['50th', 'age', 'comment']\n writer = pd.ExcelWriter(src + method + '_simulated_income_summary.xlsx', engine='xlsxwriter')\n read_income_inputs.to_excel(writer, sheet_name='inputs_for_income')\n\n read_returns_est.to_excel(writer, sheet_name='asset_returns_estimates')\n\n age_index = list(range(clients_age + 1, clients_age + len(base_qcut) + 1))\n base_qcut.loc[:, 'age'] = age_index\n base_qcut.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\n base_qcut.loc[income_starts:, col_names].to_excel(writer, sheet_name='base_ending_value_quantiles')\n\n base_income_qcut = base_income_qcut.loc[1:, :]\n base_income_qcut.loc[:, 'age'] = age_index\n base_income_qcut.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\n base_income_qcut.loc[income_starts:, col_names].to_excel(writer, sheet_name='base_income_quantiles')\n\n port_qcut.loc[:, 'age'] = age_index\n port_qcut.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\n port_qcut.loc[income_starts:, col_names].to_excel(writer, sheet_name='fia_port_ending_value_quantiles')\n\n port_income_qcut = port_income_qcut.loc[1:, :]\n port_income_qcut.loc[:, 'age'] = age_index\n port_income_qcut.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\n # port_income_qcut.loc[:, 'ending_contract_value'] = sim_fia_cv\n port_income_qcut.loc[income_starts:, col_names].to_excel(writer, sheet_name='fia_port_income_quantiles')\n\n # prob_success_df = pd.concat([base_psuccess, port_psuccess], axis=1)\n # prob_success_df.rename(columns={prob_success_df.columns[0]: 'prob(ending_value>0)_base',\n # prob_success_df.columns[1]: 'prob(ending_value>0)_port'}, inplace=True)\n\n # prob_success_df.loc[:, 'age'] = age_index\n # prob_success_df.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\n # prob_success_df.to_excel(writer, sheet_name='success_probability')\n\n income_breakdown_base = income_breakdown_base.loc[1:, :]\n income_breakdown_base.loc[:, 'age'] = age_index\n income_breakdown_base.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\n income_breakdown_base.loc[income_starts:, :].to_excel(writer, sheet_name='base_income_breakdown_median')\n\n income_breakdown_port = income_breakdown_port.loc[1:, :]\n income_breakdown_port.loc[:, 'age'] = age_index\n income_breakdown_port.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\n income_breakdown_port.loc[:, 'ending_contract_value'] = income_df.loc[:, 'contract_value']\n income_breakdown_port.loc[income_starts:, :].to_excel(writer, sheet_name='fia_income_breakdown_median')\n\n if method == 'normal':\n # median_returns_normal.loc[:, 'fia_median_returns'] = median_normal_fia\n median_returns_normal.to_excel(writer, sheet_name='gr_port_median_normal')\n\n elif method == 'smallest':\n # median_returns_smallest.loc[:, 'fia_median_returns'] = median_smallest_fia\n median_returns_smallest.to_excel(writer, sheet_name='gr_port_median_asc')\n\n else:\n # median_returns_largest.loc[:, 'fia_median_returns'] = median_largest_fia\n median_returns_largest.to_excel(writer, sheet_name='gr_port_median_desc')\n\n terminal_val = pd.read_csv(src + 'terminal_values.csv', index_col=[0])\n ending_val = pd.read_csv(src + 'ending_values.csv', index_col=[0])\n ending_val_ror = pd.read_csv(src + 'ending_values_ror.csv', index_col=[0])\n\n terminal_val.to_excel(writer, sheet_name='terminal_values')\n ending_val.to_excel(writer, sheet_name='port_ending_values')\n ending_val_ror.to_excel(writer, sheet_name='port_annual_growth')\n\n writer.save()\n\n # -----------------Plotting charts--------------------------------------------\n base_qcut.loc[income_starts:].plot(grid=True, title='Quantile Terminal Value - Base Portfolio')\n plt.savefig(src + \"quantile_terminal_base.png\")\n plt.close('all')\n\n base_income_qcut.plot(grid=True, title='Quantile Income - Base Portfolio')\n plt.savefig(src + \"quantile_income_base.png\")\n plt.close('all')\n\n base_psuccess.plot(grid=True, title='Probability of Success (Portfolio Ending Value > 0) - Base Portfolio')\n plt.savefig(src + \"success_probabilty_base.png\")\n plt.close('all')\n\n (1 - base_psuccess).plot(grid=True, title='Probability of Ruin (Portfolio Ending Value < 0) - Base Portfolio')\n plt.savefig(src + \"ruin_probability_base.png\")\n plt.close('all')\n\n port_qcut.loc[income_starts:].plot(grid=True, title='Quantile Terminal Value - FIA Portfolio')\n plt.savefig(src + \"quantile_terminal_fia.png\")\n plt.close('all')\n\n port_income_qcut.plot(grid=True, title='Quantile Income - FIA Portfolio')\n plt.savefig(src + \"quantile_income_fia.png\")\n plt.close('all')\n\n port_psuccess.plot(grid=True, title='Probability of Success (Portfolio Ending Value > 0) - FIA Portfolio')\n plt.savefig(src + \"success_probabilty_fia.png\")\n plt.close('all')\n\n (1 - port_psuccess).plot(grid=True, title='Probability of Ruin (Portfolio Ending Value < 0) - FIA Portfolio')\n plt.savefig(src + \"ruin_probability_fia.png\")\n plt.close('all')\n\n print(\"simulation completed for {}\".format(method))","def batch_simulation(self, iters=10000):\n power_cnt = 0\n correct_sign_cnt = 0\n\n for i in range(iters):\n if (self.verbose) and (i>0) and (i % (iters/10) == 0):\n print(i, \" / \", iters)\n f_stat, p_value, effect_point_estimates = self.simulate()\n power_cnt += (p_value < self.alpha)\n correct_sign_cnt += (effect_point_estimates * self.absolute_effect > 0)\n\n if self.verbose: print(iters, \" / \", iters)\n power = round(power_cnt / float(iters), 5)\n pct_correct_sign = round(correct_sign_cnt / float(iters), 5)\n return power, pct_correct_sign","def create_state_df(runs, iters=100000):\n df_st = pd.DataFrame()\n for l in runs.keys():\n for i in range(runs[l].shape[0]):\n df = pd.DataFrame()\n df[\"Step\"] = np.arange(iters)\n df[\"Maximum\"] = np.maximum.accumulate(runs[l][i].flatten())\n df[\"run-type\"] = \"Short Burst\" if float(l) > 1 else \"Biased Run\" if float(l) < 1 else \"Unbiased Run\"\n df[\"param\"] = \"b = {}\".format(l) if float(l) > 1 else \"q = {}\".format(l)\n df_st = df_st.append(df, ignore_index=True)\n return df_st","def after_run(self, run_context, run_values):\n train_step = run_values.results\n if train_step < 40000:\n self._lrn_rate = 0.1\n elif train_step < 60000:\n self._lrn_rate = 0.01\n elif train_step < 80000:\n self._lrn_rate = 0.001\n else:\n self._lrn_rate = 0.0001","def train_multiple_runs_eps_dynamic(self, env, runs=3, no_episodes=200, ng_int=50, horizon=1000, lr=0.1):\n\t\tr_mat = []\n\t\tinfo = {}\n\t\t\n\t\tfor i in tqdm(range(runs)):\n\n\t\t\t# Resetting agent to default before each run\n\t\t\tif(hasattr(self, 'reset_task')):\n\t\t\t\tself.reset_task()\n\t\t\telse:\n\t\t\t\tself.reset()\n\n\t\t\t# Training the agent for ts_max\n\t\t\tr_vec, _ = self.train_multiple_eps_dynamic(env, no_episodes=no_episodes, ng_int=ng_int, horizon=horizon, lr=lr)\n\n\t\t\t# Storing the results in a matrix\n\t\t\tr_mat.append(r_vec)\n\n\t\t# Finding the mean and standard deviation \n\t\tinfo['mean'] = np.mean(np.array(r_mat), axis=0)\n\t\tinfo['std'] = np.std(np.array(r_mat), axis=0)\n\n\t\treturn r_mat, info","def log_summary(self, no_run_list):\n self.log_message('Entries not run' ,step='summary',status='start',name='config_file_reader')\n for name in no_run_list.keys():\n self.log_message('Did not run: '+name+', '+no_run_list[name],status='running')\n \n ret_total = 0\n for x in xrange(2):\n for ent in self.entries[x]:\n ret_total = ret_total + 0 if ent.return_val == None else ent.return_val\n self.log_message('Summary Complete, Run Time = ('+str(self.total_time)+')',status='complete')\n return ret_total","def simulationTwoDrugsDelayedTreatment(numTrials):\n results = []\n gutresults = []\n \n for a in range(375):\n results.append([])\n gutresults.append([])\n \n for b in range(numTrials):\n viruses = []\n for c in range(100):\n resistances = {'guttagonol': False, 'grimpex': False}\n vir = ResistantVirus(.1, .05, resistances, .02)\n viruses.append(vir)\n \n Mark = TreatedPatient(viruses, 1000)\n \n for d in range(150):\n pop = Mark.update()\n results[d].append(pop)\n gutpop = Mark.getResistPop(['guttagonol'])\n gutresults[d].append(gutpop)\n \n Mark.addPrescription('guttagonol')\n \n for e in range(150, 225):\n newpop = Mark.update()\n results[e].append(newpop)\n newgutpop = Mark.getResistPop(['guttagonol'])\n gutresults[e].append(newgutpop)\n \n Mark.addPrescription('grimpex')\n \n for f in range(225, 375):\n newpop = Mark.update()\n results[f].append(newpop)\n \n \n FinalResults = results[374]\n print len(FinalResults)\n \n \n pylab.figure(6)\n pylab.hist(FinalResults, bins = 10)\n pylab.title('300 day delay')\n pylab.xlabel('Virus Population')\n pylab.ylabel('Number of Trials with Population') \n pylab.show()","def summarizeReactorStats(self):\n totalMass = 0.0\n fissileMass = 0.0\n heavyMetalMass = 0.0\n totalVolume = 0.0\n numBlocks = len(self.getBlocks())\n for block in self.getBlocks():\n totalMass += block.getMass()\n fissileMass += block.getFissileMass()\n heavyMetalMass += block.getHMMass()\n totalVolume += block.getVolume()\n totalMass = totalMass * self.powerMultiplier / 1000.0\n fissileMass = fissileMass * self.powerMultiplier / 1000.0\n heavyMetalMass = heavyMetalMass * self.powerMultiplier / 1000.0\n totalVolume = totalVolume * self.powerMultiplier\n runLog.extra(\n \"Summary of {}\\n\".format(self)\n + tabulate.tabulate(\n [\n (\"Number of Blocks\", numBlocks),\n (\"Total Volume (cc)\", totalVolume),\n (\"Total Mass (kg)\", totalMass),\n (\"Fissile Mass (kg)\", fissileMass),\n (\"Heavy Metal Mass (kg)\", heavyMetalMass),\n ],\n tablefmt=\"armi\",\n )\n )","def simulationDelayedTreatment(numTrials):\n \n \n results = []\n gutresults = []\n for a in range(300):\n results.append([])\n gutresults.append([])\n for b in range(numTrials):\n viruses = []\n for c in range(10000):\n resistances = {'guttagonol': False}\n vir = ResistantVirus(.1, .05, resistances, .005)\n viruses.append(vir)\n \n Mark = TreatedPatient(viruses, 1000)\n \n for d in range(150):\n pop = Mark.update()\n results[d].append(pop)\n gutpop = Mark.getResistPop(['guttagonol'])\n gutresults[d].append(gutpop)\n \n Mark.addPrescription('guttagonol')\n \n for e in range(150, 300):\n newpop = Mark.update()\n results[e].append(newpop)\n newgutpop = Mark.getResistPop(['guttagonol'])\n gutresults[e].append(newgutpop)\n \n FinalResults = results[299]\n print len(FinalResults)\n \n \n \n pylab.figure(5)\n pylab.hist(FinalResults, bins = 10)\n pylab.title('Simulation with Drugs - Frequency')\n pylab.xlabel('Virus Population')\n pylab.ylabel('Number of Trials with Population') \n pylab.legend()\n pylab.show()","def num_of_stim_reps(subject, stimulus_class, data_dir, save_dir, save_fig=True):\n\tif stimulus_class == 'TIMIT':\n\t\tresp_dict, stim_dict = loadEEGh5('MT0002', 'TIMIT', data_dir, eeg_epochs=True, resp_mean = True, binarymat=False, \n\t\tbinaryfeatmat = True, envelope=True, pitch=True, gabor_pc10=False, spectrogram=False, binned_pitches=False, spectrogram_scaled=False, scene_cut=False) #load full model. Do not average across trials. \n\t\ttest_set = ['fcaj0_si1479.wav', 'fcaj0_si1804.wav', 'fdfb0_si1948.wav', \n\t\t'fdxw0_si2141.wav', 'fisb0_si2209.wav', 'mbbr0_si2315.wav', \n\t\t'mdlc2_si2244.wav', 'mdls0_si998.wav', 'mjdh0_si1984.wav', \n\t\t'mjmm0_si625.wav']\n\t\t\n\t\tstim_list = []\n\t\tfor key in resp_dict.keys():\n\t\t\tprint(key)\n\t\t\tstim_list.append(key)\n\t\tall_stimuli = [k for k in stim_list if len(resp_dict[k]) > 0]\n\t\ttraining_set = np.setdiff1d(all_stimuli, test_set)\n\t\tprint(training_set)\n\n\n\tif stimulus_class == 'MovieTrailers':\n\n\t\tresp_dict_MT0002, stim_dict = loadEEGh5('MT0002', 'MovieTrailers', data_dir, eeg_epochs=True, \n\t\t\t\t\t\t\t\t resp_mean = False, binaryfeatmat = True, binarymat=False, envelope=True,\n\t\t\t\t\t\t\t\t pitch=True, spectrogram=False)\n\t\tresp_dict_MT0020, stim_dict = loadEEGh5('MT0020', 'MovieTrailers', data_dir, eeg_epochs=True, \n\t\t\t\t\t\t\t\t resp_mean = False, binaryfeatmat = True, binarymat=False, envelope=True,\n\t\t\t\t\t\t\t\t pitch=True, spectrogram=False)\n\t\t\n\t\ttrailers_list = ['angrybirds-tlr1_a720p.wav', 'bighero6-tlr1_a720p.wav', 'bighero6-tlr2_a720p.wav', \n\t\t'bighero6-tlr3_a720p.wav', 'cars-3-trailer-4_a720p.wav', 'coco-trailer-1_a720p.wav', \n\t\t'ferdinand-trailer-2_a720p.wav', 'ferdinand-trailer-3_a720p.wav', 'ice-dragon-trailer-1_a720p.wav', \n\t\t'incredibles-2-trailer-1_a720p.wav', 'incredibles-2-trailer-2_a720p.wav', 'insideout-tlr2zzyy32_a720p.wav',\n\t\t'insideout-usca-tlr2_a720p.wav', 'moana-clip-youre-welcome_a720p.wav', 'paddington-2-trailer-1_a720p.wav', \n\t\t'pandas-trailer-2_a720p.wav', 'pele-tlr1_a720p.wav', 'the-breadwinner-trailer-1_a720p.wav', \n\t\t'the-lego-ninjago-movie-trailer-1_a720p.wav', 'the-lego-ninjago-movie-trailer-2_a720p.wav', \n\t\t'thelittleprince-tlr_a720p.wav', 'trolls-tlr1_a720p.wav']\n\n\t\tresp_dict = {}\n\n\t\tfor k in trailers_list:\n\t\t\tresp_dict[k] = [np.concatenate((resp_dict_MT0002[k][0], resp_dict_MT0020[k][0]), axis=0)]\n\t\ttest_set = ['paddington-2-trailer-1_a720p.wav', 'insideout-tlr2zzyy32_a720p.wav'] #the test set for the remaining MTs\n\n\t\tall_stimuli = trailers_list\n\t\ttraining_set = np.setdiff1d(all_stimuli, test_set)\n\t\tprint(training_set)\n\n\tval_inds = np.zeros((len(all_stimuli),), dtype=np.bool) \n\ttrain_inds = np.zeros((len(all_stimuli),), dtype=np.bool)\n\tfor i in np.arange(len(all_stimuli)):\n\t\tif all_stimuli[i] in test_set:\n\t\t\tprint(all_stimuli[i])\n\t\t\tval_inds[i] = True\n\t\telse:\n\t\t\ttrain_inds[i] = True\n\n\tprint(\"Total number of training sentences:\")\n\tprint(sum(train_inds))\n\tprint(\"Total number of validation sentences:\")\n\tprint(sum(val_inds))\n\n\ttrain_inds = np.where(train_inds==True)[0]\n\tval_inds = np.where(val_inds==True)[0]\n\n\tprint(\"Training indices:\")\n\tprint(train_inds)\n\tprint(\"Validation indices:\")\n\tprint(val_inds)\n\n\t# For logging compute times, debug messages\n\n\tlogging.basicConfig(level=logging.DEBUG) \n\n\t#time delays used in STRF\n\tdelay_min = 0.0\n\tdelay_max = 0.6\n\twt_pad = 0.1 # Amount of padding for delays, since edge artifacts can make weights look weird\n\n\tfs = 128.0\n\tdelays = np.arange(np.floor((delay_min-wt_pad)*fs), np.ceil((delay_max+wt_pad)*fs), dtype=np.int) #create array to pass time delays in\n\n\tprint(\"Delays:\", delays)\n\n\t# Regularization parameters (alphas - also sometimes called lambda)\n\talphas = np.hstack((0, np.logspace(2,8,20))) # Gives you 15 values between 10^2 and 10^8\n\n\tnalphas = len(alphas)\n\tuse_corr = True # Use correlation between predicted and validation set as metric for goodness of fit\n\tsingle_alpha = True # Use the same alpha value for all electrodes (helps with comparing across sensors)\n\tnboots = 20 # How many bootstraps to do. (This is number of times you take a subset of the training data to find the best ridge parameter)\n\n\tall_wts = [] # STRF weights (this will be ndelays x channels)\n\tall_corrs = [] # correlation performance of length [nchans]\n\tall_corrs_shuff = [] # List of lists, how good is a random model\n\n\t# train_inds and val_inds are defined in the cell above, and is based on getting 80% of the trials\n\t# for each unique stimulus to be in the training set, and the remaining 20% to be in \n\t# the validation set\n\tcurrent_stim_list_train = np.array([all_stimuli[r][0] for r in train_inds])\n\tcurrent_stim_list_val = np.array([all_stimuli[r][0] for r in val_inds])\n\n\t# Create training and validation response matrices\n\tprint(resp_dict[training_set[0]][0].shape)\n\tprint(test_set)\n\n\tprint(len(training_set))\n\tfor r in training_set:\n\t\tprint(r)\n\n\n\t# tResp = np.hstack([resp_dict[r][0] for r in training_set]).T\n\t# vResp = np.hstack([resp_dict[r][0] for r in test_set]).T\n\n\n\t# Create training and validation stimulus matrices\n\n\ttStim_temp = np.atleast_2d(np.vstack([np.vstack(stim_dict[r]).T for r in training_set]))\n\tvStim_temp = np.atleast_2d(np.vstack([np.vstack(stim_dict[r]).T for r in test_set if resp_dict[r][0].shape[0] >= 10]))\n\ttStim_temp = tStim_temp/tStim_temp.max(0)\n\tvStim_temp = vStim_temp/vStim_temp.max(0)\n\tprint('**********************************')\n\tprint(tStim_temp.max(0).shape)\n\tprint(vStim_temp.max(0).shape)\n\tprint('**********************************')\n\n\ttStim = make_delayed(tStim_temp, delays)\n\tvStim = make_delayed(vStim_temp, delays)\n\n\tchunklen = np.int(len(delays)*3) # We will randomize the data in chunks \n\tnchunks = np.floor(0.2*tStim.shape[0]/chunklen).astype('int')\n\n\n\t\n\tvResp_numtrials = [resp_dict[r][0].shape[0] for r in test_set if resp_dict[r][0].shape[0] >= 10]\n\t#print(vResp)\n\tprint(vResp_numtrials)\n\tntrials = np.min(vResp_numtrials)\n\tprint(ntrials)\n\t\n\tvreps = np.arange(1,ntrials+1) # From 1 to 10 repeats of the validation set\n\tnboots = 10\n\tcorrs_reps = dict()\n\tfor v in vreps:\n\t\tcorrs_reps[v] = []\n\t\tprint('*****************************')\n\t\tprint('Now on repetition # %d' %(v))\n\t\tprint('*****************************')\n\t\ttResp = np.hstack([resp_dict[r][0].mean(0) for r in training_set]).T\n\t\tnchans = tResp.shape[1] # Number of electrodes/sensors\n\t\t\n\t\ttrial_combos = [k for k in itools.combinations(np.arange(ntrials), v)]\n\t\tfor t in trial_combos:\n\t\t\tvResp_temp = [resp_dict[r][0][t,:,:].mean(0) for r in test_set if resp_dict[r][0].shape[0] >= 10]\n\n\t\t\tvResp = np.hstack((vResp_temp)).T\n\t\t\tprint(vResp.shape)\n\t\t\t# Fit the STRFs - RUNNING THE MODEL HERE!\n\t\t\twt, corrs, valphas, allRcorrs, valinds, pred, Pstim = bootstrap_ridge(tStim, tResp, vStim, vResp, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t alphas, nboots, chunklen, nchunks, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t use_corr=use_corr, single_alpha = single_alpha, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t use_svd=False, corrmin = 0.05,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t joined=[np.array(np.arange(nchans))])\n\t\t\tcorrs_reps[v].append(corrs)\n\t\t\tplt.plot(v, corrs.mean(), '.')\n\t\t\t\n\tplt.xlabel('Number repeats')\n\tplt.ylabel('Average corr')\n\n\tcorrs_reps_avg = []\n\tcorrs_reps_std = []\n\tfor i in np.arange(1, ntrials+1):\n\t\tcorrs_reps_avg.append(np.mean(corrs_reps[i]))\n\t\tprint(np.array(corrs_reps[i])[:,23])\n\t\tcorrs_reps_std.append(np.std(corrs_reps[i])/np.sqrt(len(vreps)))\n\n\n\tplt.fill_between(vreps, np.array(corrs_reps_avg)+np.array(corrs_reps_std), np.array(corrs_reps_avg)-np.array(corrs_reps_std), alpha=0.5)\n\n\tplt.plot(vreps, corrs_reps_avg)\n\n\tplt.xlabel('Number repeats')\n\tplt.ylabel('Average validation correlation')\n\n\t#save corrs_reps into .h5 file for each repetition as individual key. Will save out as either TIMIT or MT reps\n\twith h5py.File('%s/%s_corrs_reps.hf5' %(data_dir, stimulus_class), 'w') as g:\n\t\tfor idx, s in enumerate(corrs_reps.items()): \n\t\t\tg.create_dataset('/rep%d' %(idx), data=np.array(s[1]))\n\n\tif save_fig:\n\t\tplt.savefig('%s/%s_10bootStReps.pdf' %(save_dir, stimulus_class))\n\n\treturn corrs_reps","def summarize(self):\n self.smalltalk += \"\\n Data IDs in this bundle: \\n\"\n self._files = {}\n inv_dict = {}\n # sort IDs to make sure pdfs are printed in same oder as they were\n # taken\n for k, v in self.stage_summaries.items():\n for qc_id in flatten_list(v):\n inv_dict[qc_id] = k\n sorted_ids = list(flatten_list(self.stage_summaries.values()))\n sorted_ids.sort(key=int)\n # for stage, value in self.stage_summaries.items():\n for qc_run_id in sorted_ids:\n # stage = inv_dict[qc_run_id]\n # if stage[0:7] == 'failed_':\n # stage = stage[7:]\n # try:\n # s = self.comments[qc_run_id]\n # except KeyError:\n # s = ''\n # self.comments[qc_run_id] = 'Classified as poor result.\\n' + s\n ds = Dataset(qc_run_id, self.db_name)\n device_name = ds.device_name\n f_folder = os.path.join(self.db_folder, \"tuning_results\", device_name)\n # for qc_run_id in flatten_list(value):\n self.smalltalk += str(qc_run_id) + \", \"\n\n # filename = stage + '_fit_ds'\n # filename += str(qc_run_id) + '.png'\n filename = os.path.join(f_folder, str(ds.ds.guid) + \".png\")\n\n self._files[str(qc_run_id)] = filename","def run_many_fits(spectrum,rms,guesses,nruns):\n tk_fit = []\n tex_fit = []\n ntot_fit = []\n width_fit = []\n for i in range(nruns):\n noisy_spectrum = add_noise(spectrum,rms)\n noisy_spectrum.specfit(fittype='cold_ammonia',guesses=guesses,fixed=[F,F,F,F,F,T])\n parcopy = copy.deepcopy(noisy_spectrum.specfit.parinfo)\n tk_fit = np.append(tk_fit,parcopy[0].value)\n tex_fit = np.append(tex_fit,parcopy[1].value)\n ntot_fit = np.append(ntot_fit,parcopy[2].value)\n width_fit = np.append(width_fit,parcopy[3].value)\n return tk_fit,tex_fit,ntot_fit,width_fit","def validation_summaries(self, step):\n dnn_summary_writer = self.dnn_summary_writer\n gan_summary_writer = self.gan_summary_writer\n DNN = self.DNN\n D = self.D\n train_dataset = self.train_dataset\n validation_dataset = self.validation_dataset\n\n self.evaluation_epoch(DNN, train_dataset, dnn_summary_writer, '2 Train Error')\n dnn_validation_mae = self.evaluation_epoch(DNN, validation_dataset, dnn_summary_writer, '1 Validation Error')\n self.evaluation_epoch(D, train_dataset, gan_summary_writer, '2 Train Error')\n self.evaluation_epoch(D, validation_dataset, gan_summary_writer, '1 Validation Error',\n comparison_value=dnn_validation_mae)","def log_evaluation(tester, name, description):\r\n\tfor dataset, output in tester.preds.items():\r\n\t\tresults = pandas.DataFrame.from_dict(output)\r\n\t\tpath = os.path.join(\r\n\t\t\tEXPERIMENT_PATH, tester.config[\"name\"] + '-' + dataset)\r\n\t\twith open(path + \".csv\", \"w\") as f:\r\n\t\t\tresults.to_csv(f, sep=\"\\t\", encoding='utf-8',\r\n\t\t\t\tfloat_format='%.3f', index=False)","def compute_and_print_eval_metrics(self):\n s = ('%20s' + '%12s' * 6) % ('Class', 'Images', 'Targets', 'P', 'R', 'mAP@.5', 'mAP@.5:.95')\n precision, recall, f1, mean_precision, mean_recall, map50, map = 0., 0., 0., 0., 0., 0., 0.\n ap = []\n eval_stats = [np.concatenate(x, 0) for x in zip(*self.eval_stats)]\n if len(eval_stats) and eval_stats[0].any():\n precision, recall, ap, f1, ap_class = ap_per_class(*eval_stats)\n precision, recall, ap50, ap = precision[:, 0], recall[:, 0], ap[:, 0], ap.mean(1)\n mean_precision, mean_recall, map50, map = precision.mean(), recall.mean(), ap50.mean(), ap.mean()\n nt = np.bincount(eval_stats[3].astype(np.int64), minlength=len(self.class_names)) # number of targets per class\n else:\n nt = np.zeros(1)\n\n pf = '%20s' + '%12.5g' * 6 # print format\n print(\"\\n EVALUTAION \\n\")\n print(s)\n print(pf % ('all', self.seen, nt.sum(), mean_precision, mean_recall, map50, map))\n if self.cfg.eval.verbose:\n for indx, cls in enumerate(ap_class):\n print(pf % (self.class_names[cls], self.seen, nt[cls], precision[indx], recall[indx], ap50[indx], ap[indx]))","def plotDifferentSettings():\n\t#save location of the results\n\tresloc = 'Different_settings_results'\n\n\t#the numrows limits\n\tnrows_lims = [1e4, 1e7]\n\tnbits = 30\n\t\n\t#string for the file names of the to be saved files\n\tsettingsstr = 'nrows={:.0e}--{:.0e}_nbits={}'.format(nrows_lims[0], nrows_lims[1], nbits)\n\t\n\t#the relative approximation error for the different counting algorithms\n\tll_RAE = []\n\tprob_RAE = []\n\tcomb_RAE = []\n\t#the runtime for the different algorithms\n\ttc_runtime = []\n\tll_runtime = []\n\tprob_runtime = []\n\tcomb_runtime = []\n\n\t#the different settings we want to test\n\tnumrows = np.linspace(nrows_lims[0], nrows_lims[1], num = 15, dtype = int)\n\tnumbits = np.array([nbits])\n\t\n\tlooplength = len(numrows)\n\t\n\ttry:\n\t\t(ll_RAE, prob_RAE, comb_RAE, tc_runtime, ll_runtime, prob_runtime, comb_runtime) = np.loadtxt('./{0}/diffset_results_{1}.txt'.format(resloc, settingsstr))\n\texcept:\n\t\tfor i in np.arange(len(numrows)):\n\t\t\toF.progress(i, looplength)\n\t\t\tfor j in np.arange(len(numbits)):\n\t\t\t\tresults = runCounts(numrows[i], numbits[j], doprints = False)\n\t\t\t\n\t\t\t\tll_RAE = np.append(ll_RAE, results[0])\n\t\t\t\tprob_RAE = np.append(prob_RAE, results[1])\n\t\t\t\tcomb_RAE = np.append(comb_RAE, results[2])\n\t\t\t\n\t\t\t\ttc_runtime = np.append(tc_runtime, results[3])\n\t\t\t\tll_runtime = np.append(ll_runtime, results[4])\n\t\t\t\tprob_runtime = np.append(prob_runtime, results[5])\n\t\t\t\tcomb_runtime = np.append(comb_runtime, results[6])\n\t\t\t\n\t\tnp.savetxt('./{0}/diffset_results_{1}.txt'.format(resloc, settingsstr), \n\t\t\tnp.array([ll_RAE, prob_RAE, comb_RAE, tc_runtime, ll_runtime, prob_runtime, comb_runtime]), \n\t\t\theader = '#ll_RAE, prob_RAE, comb_RAE, tc_runtime, ll_runtime, prob_runtime, comb_runtime')\n\t\n\tplotTwoValues(numrows, ll_RAE, ll_runtime, 'Number of rows', 'RAE [\\%]', 'Runtime [s]', 'RAE and runtime of loglog count for different number of rows. \\nNumbits = {}'.format(nbits), 'RAEandRuntime_loglog_{0}.pdf'.format(settingsstr))\n\t\n\tplotTwoValues(numrows, prob_RAE, prob_runtime, 'Number of rows', 'RAE [\\%]', 'Runtime [s]', 'RAE and runtime of probabilisic count for different \\nnumber of rows. Numbits = {}'.format(nbits), 'RAEandRuntime_prob_{0}.pdf'.format(settingsstr))","def results_psavg_sims():\n posterior_means = [[1.18040327516, 7.55106444832, 3.27420103073, 3.51998795534, 0.67212630002],\n [0.619197296326, 6.49420626987, 2.22495505139, 2.27682390376, 0.678172183554],\n [0.856628471666, 5.94732402905, 3.97580346111, 3.85788708662, 0.690090617623],\n [0.774906025167, 7.34275742443, 2.69729821931, 2.97994334746, 0.663015258594]]\n\n\n sgr1900_results.results_psavg_sims(posterior_means, [5,6,8,12], \"sgr1806\")\n\n return","def resampleParams(self, caliStep, iterNO=-1):\n names = self.getNames()\n smcSamples = self.smcSamples[iterNO]\n numSamples = self.numSamples\n numThreads = self.threads if self.threads else cpu_count()\n # posterior probability at caliStep is used as the proposal distribution\n proposal = self.posterior[:, caliStep]\n newSmcSamples, newparamsFile, gmm, maxNumComponents = \\\n resampledParamsTable(keys=names, smcSamples=smcSamples, proposal=proposal, num=numSamples,\n threads=numThreads,\n maxNumComponents=self.__maxNumComponents, priorWeight=self.__priorWeight,\n covType=self.__covType,\n tableName='smcTable%i.txt' % (iterNO + 1))\n self.smcSamples.append(newSmcSamples)\n self.paramsFiles.append(newparamsFile)\n return gmm, maxNumComponents","def _set_n_runs(self, n_runs):\n if not isinstance(n_runs, int) or n_runs < 1:\n raise ValueError(\"'n_runs' must be a positive integer.\")\n \n self.n_runs = n_runs\n # reset measurement results\n self._set_runtimes()\n self._tmean = np.nan\n self._tstdev = np.nan\n # block access to results\n self.__hasrun = False","def reduce_run():","def simulationDelayedTreatment(numTrials):\n pop_list = {}\n resistant_pop_list = {}\n init_step_list = [300, 150, 75, 0]\n for index, init_step in enumerate(init_step_list):\n pop_list[init_step] = get_pop_list(init_step, numTrials)\n pylab.subplot(2, 2, index + 1)\n pylab.hist(pop_list[init_step])\n pylab.title('histogram of init step ' + str(init_step))\n pylab.xlabel('bin')\n pylab.ylabel('frequency')\n pylab.show()\n return pop_list\n \n # TODO","def simulationDelayedTreatment(numTrials):\n\n delays = [300,150,75,0]\n results = [[],[],[],[]]\n for place in range(0, 4):\n for trial in range(numTrials):\n viruses = []\n for num in range(100):\n viruses.append(ResistantVirus(0.1,0.05, {'guttagonol': False}, 0.005))\n patient = TreatedPatient(viruses, 1000)\n for delay in range(delays[place]):\n patient.update()\n patient.addPrescription(\"guttagonol\") \n for l in range(150):\n patient.update()\n results[place].append(patient.getTotalPop())\n pylab.hist(results[0])\n pylab.hist(results[1])\n pylab.hist(results[2])\n pylab.hist(results[3])\n pylab.show()\n for x in range(0, 10):","def calculate_average_run_accuracy(self):\n overall_true_rate, true_positive_rate, true_negative_rate, false_positive_rate, false_negative_rate, true_positive_rate_cutoff, true_negative_rate_cutoff, \\\n false_positive_rate_cutoff, false_negative_rate_cutoff, unclassified_cutoff, matthews_correlation_coefficient, brier_score, auc_score, fit_time, hmeasure = [0] * 15\n balanced_accuracy_arr = []\n auc_arr = []\n hmeasure_arr = []\n brier_score_arr = []\n fit_time_arr = []\n mcc_arr = []\n true_positive_arr = []\n true_negative_arr = []\n false_positive_arr = []\n false_negative_arr = []\n\n count = 0\n for result_dictionary in self.errors:\n for z in range(len(result_dictionary[\"balanced_accuracy_arr\"])):\n overall_true_rate += result_dictionary[\"balanced_accuracy_arr\"][z]\n true_positive_rate += result_dictionary[\"true_positive_rate_arr\"][z]\n true_negative_rate += result_dictionary[\"true_negative_rate_arr\"][z]\n false_positive_rate += result_dictionary[\"false_positive_rate_arr\"][z]\n false_negative_rate += result_dictionary[\"false_negative_rate_arr\"][z]\n matthews_correlation_coefficient += result_dictionary[\"mcc_arr\"][z]\n auc_score += result_dictionary[\"auc_arr\"][z]\n brier_score += result_dictionary[\"brier_score_arr\"][z]\n fit_time += result_dictionary[\"fit_time_arr\"][z]\n hmeasure += result_dictionary[\"hmeasure_arr\"][z]\n count += 1\n\n true_positive_rate_cutoff += result_dictionary[\"avg_true_positive_rate_with_prob_cutoff\"]\n true_negative_rate_cutoff += result_dictionary[\"avg_true_negative_rate_with_prob_cutoff\"]\n false_positive_rate_cutoff += result_dictionary[\"avg_false_positive_rate_with_prob_cutoff\"]\n false_negative_rate_cutoff += result_dictionary[\"avg_false_negative_rate_with_prob_cutoff\"]\n unclassified_cutoff += result_dictionary[\"avg_false_negative_rate_with_prob_cutoff\"]\n balanced_accuracy_arr += result_dictionary[\"balanced_accuracy_arr\"]\n hmeasure_arr += result_dictionary[\"hmeasure_arr\"]\n auc_arr += result_dictionary[\"auc_arr\"]\n brier_score_arr += result_dictionary[\"brier_score_arr\"]\n fit_time_arr += result_dictionary[\"fit_time_arr\"]\n mcc_arr += result_dictionary[\"mcc_arr\"]\n true_positive_arr += result_dictionary[\"true_positive_rate_arr\"]\n true_negative_arr += result_dictionary[\"true_negative_rate_arr\"]\n false_positive_arr += result_dictionary[\"false_positive_rate_arr\"]\n false_negative_arr += result_dictionary[\"false_negative_rate_arr\"]\n\n avg_run_results = [None] * 31\n avg_run_results[0] = matthews_correlation_coefficient / float(count)\n avg_run_results[1] = brier_score / float(count)\n avg_run_results[2] = overall_true_rate / float(count)\n avg_run_results[3] = true_positive_rate / float(count)\n avg_run_results[4] = true_negative_rate / float(count)\n avg_run_results[5] = false_positive_rate / float(count)\n avg_run_results[6] = false_negative_rate / float(count)\n avg_run_results[7] = true_positive_rate_cutoff / float(len(self.errors))\n avg_run_results[8] = true_negative_rate_cutoff / float(len(self.errors))\n avg_run_results[9] = false_positive_rate_cutoff / float(len(self.errors))\n avg_run_results[10] = false_negative_rate_cutoff / float(len(self.errors))\n avg_run_results[11] = unclassified_cutoff / float(len(self.errors))\n avg_run_results[12] = fit_time / float(count)\n avg_run_results[14] = balanced_accuracy_arr\n avg_run_results[15] = auc_score / float(count)\n avg_run_results[16] = auc_arr\n avg_run_results[17] = brier_score_arr\n avg_run_results[18] = fit_time_arr\n avg_run_results[19] = mcc_arr\n avg_run_results[13] = self.calculate_std_deviation(balanced_accuracy_arr)\n avg_run_results[20] = self.calculate_std_deviation(mcc_arr)\n avg_run_results[21] = self.calculate_std_deviation(brier_score_arr)\n avg_run_results[22] = self.calculate_std_deviation(auc_arr)\n avg_run_results[23] = self.calculate_std_deviation(fit_time_arr)\n avg_run_results[24] = self.calculate_std_deviation(true_positive_arr)\n avg_run_results[25] = self.calculate_std_deviation(true_negative_arr)\n avg_run_results[26] = self.calculate_std_deviation(false_positive_arr)\n avg_run_results[27] = self.calculate_std_deviation(false_negative_arr)\n avg_run_results[28] = hmeasure / float(count)\n avg_run_results[29] = self.calculate_std_deviation(hmeasure_arr)\n avg_run_results[30] = hmeasure_arr\n\n return avg_run_results","def train_and_report_metrics(xs, ys, num_repeat, extractor_class, useless_var_for_hparam_search=None):\n\n all_val_auc = []\n all_val_accuracy = []\n\n for i in range(num_repeat):\n single_train_metrics = extractor_class().train_single_run(xs, ys, i)\n\n all_val_auc.append(single_train_metrics['val_auc'])\n all_val_accuracy.append(single_train_metrics['val_accuracy'])\n\n metrics = {\n \"mean_val_auc\": np.mean(all_val_auc),\n \"mean_val_accuracy\": np.mean(all_val_accuracy),\n \"val_auc_std\": np.std(all_val_auc),\n \"val_accuracy_std\": np.std(all_val_accuracy)\n }\n\n print(metrics, flush=True)\n\n hpt = hypertune.HyperTune()\n hpt.report_hyperparameter_tuning_metric(\n hyperparameter_metric_tag='mean_val_auc',\n metric_value=metrics['mean_val_auc'])\n\n return metrics","def repeatexp(n, d, grid_size, reps, tho_scale=0.1, is_classification=True, no_signal=True):\n \n datasetList = ['Train', 'Holdout', 'Test']\n colList = ['perm', 'performance', 'dataset']\n \n df_list_std = []\n df_list_tho = []\n \n for perm in tqdm(range(reps)):\n \n vals_std, vals_tho = fitModels_paramTuning(n, d, grid_size,\n is_classification=is_classification,\n tho_scale=tho_scale,\n no_signal=no_signal)\n for i, ds in enumerate(datasetList):\n df_list_std.append((perm, vals_std[i], ds))\n df_list_tho.append((perm, vals_tho[i], ds))\n\n df_std = pd.DataFrame(df_list_std, columns=colList)\n df_tho = pd.DataFrame(df_list_tho, columns=colList)\n return df_std, df_tho","def one_experiment():\n\n # set the name of the experiment\n now = datetime.datetime.now()\n experiment_id = str(now.day) + \"_\" + str(now.month) + \"_\" + str(now.hour) + \".\" + str(now.minute)\n experiment_name = 'overfit_' + str(experiment_id)\n\n # define if you want to use preprocessed data from file\n use_prep_data = False\n if use_prep_data:\n set_params(preproc_data_id='16_5_10.16.47')\n\n # define the changing parameter and its value\n changing_param_name = 'class_weights'\n changing_param_value = [{0: 15, 1: 85}]\n # {0:15, 1:85}]#, {0:4, 1:100}, {0:3, 1:100}, {0:2, 1:100}, {0:1, 1:100}] #[{0:1, 1:1}, {0:15, 1:85}]#\n\n features_to_use = ['user', 'countries', 'session', 'format', 'token']\n # set constant parameters\n set_params(use_word_emb=1)\n set_params(epochs=40)\n set_params(features_to_use=features_to_use)\n\n # save constant parameters to a new \"experiment_..\" filgithx+P@2ub\n save_constant_parameters(experiment_name, changing_param_name)\n\n # run experiment for every parameter value\n for value in changing_param_value:\n process = psutil.Process(os.getpid())\n print(\"-----MEMORY before starting experiment ------\", int(process.memory_info().rss/(8*10**3)), \"KB\")\n\n # update the parameter value\n set_params(class_weights_1=value)\n\n # update the model_id for this new model\n now = datetime.datetime.now()\n new_model_id = str(now.day) + \"_\" + str(now.month) + \"_\" + str(now.hour) + \".\" + str(now.minute) + \".\" + str(now.second)\n\n set_params(model_id=new_model_id)\n\n # evaluate the new model and save the results in the experiment file\n oneExperiment = Process(target=run_experiment, args=(experiment_name,\n new_model_id, changing_param_name, value,))\n oneExperiment.start()\n oneExperiment.join()","def experiment(agent, steps, runs, initialize=None):\n result = 0\n for r in range(runs):\n result += simulate(agent, steps, initialize)\n return result / runs","def measure(self):\n # --- perform repeated runs\n for i_run in range(self.n_runs):\n if self.verbosity > 0:\n print(\"Run {0} / {1} ...\".format(i_run, self.n_runs), end = '')\n tdelta = self._timed_execute()\n self._run_times[i_run] = tdelta\n\t\t\t\n if self.verbosity == 2:\n print(tdelta)\n \n # calculate mean\n self._tmean = np.mean(self._run_times)\n # calculate standard deviation\n self._tstdev = np.std(self._run_times)\n # allow access to results\n self.__hasrun = True","def update(self,x): #update the estimate of rewards and number of esteps run\n\t\tself.N += 1\n\t\tself.estimate_mean = (1.0-1.0/self.N)*self.estimate_mean + (1.0/self.N)*x #recurence relation for averages","def test_print_results(self):\n calculated = super().predict_and_print()\n self.assertEqual(calculated, EXP_PRINT_OUTPUT_BASE.format(.18, .1, 0.186, self.test_model.model.train_time) +\n \"Max tree max_depth: 1\\n\"\n \"Number of n_estimators: 1\\n\"\n \"Impurity method: entropy\\n\")","def list_of_runstrings (ins, exp) :\n runs = experiment_info.experiment_runs(ins, exp)\n lst = []\n for rec in runs :\n lst.append( '%04d'%rec['num'] )\n return lst","def analyze_trial(trial_num, starting_replication_num=1, design_filename='design.csv'):\r\n design_name_root = design_filename.split('.')[0]\r\n\r\n # check for filename accessibility\r\n # ... if file already exists, it will be overwritten, so be careful\r\n trial_level_results_filename = f\"{results_directory}/trial_results_{trial_num}.{design_name_root}.npy\"\r\n # if permission denied or folder doesn't exist, will raise error; let it\r\n f = open(trial_level_results_filename, 'wb')\r\n f.close()\r\n\r\n num_replications = constants.NUM_REPLICATIONS\r\n\r\n design = load_design_file(design_filename) # need these to build edge list\r\n trial_settings = get_trial_settings(trial_num, design)\r\n\r\n # init replication-level results container\r\n # t_max + 1 to account for initial state\r\n replication_level_results = np.zeros(\r\n (constants.NUM_REPLICATIONS, constants.MAX_TIME_STEPS + 1, data_processors.number_of_measures, 2))\r\n\r\n # array of replication times, just for minor perfomance analytics\r\n rep_times_array = np.full(num_replications, np.nan, dtype=np.float16)\r\n\r\n # want replication numbers to start at 1, like trial numbers\r\n for rep in range(starting_replication_num, num_replications + 1):\r\n start_time = time.time()\r\n\r\n # test output file access\r\n # will be reading this one\r\n replication_raw_data_filename = f\"{results_directory}/replication_raw_data_{trial_num}_{rep}.{design_name_root}.npy\"\r\n\r\n # to resume analysis later, need to save these\r\n replication_level_results_filename = f\"{results_directory}/replication_results_{trial_num}_{rep}.{design_name_root}.npy\"\r\n f = open(replication_level_results_filename, 'wb')\r\n f.close()\r\n\r\n # here, we're rebuilding the network graph by the same approach as the model init\r\n network_parameters = trial_settings['network_parameters']\r\n rg = RandomGenerator(PCG64(REPLICATION_ISEED_STREAM_ARRAY[rep], RNGStream.GRAPH_GENERATOR + 1))\r\n network_rg = RandomGenRandomInterface(rg)\r\n G = getattr(networks, network_parameters[0])(*network_parameters[1], network_rg)\r\n G = networks.prepare_graph_for_trial(G, network_rg) # make directed, connected, & free of self-loops\r\n\r\n # load raw data file\r\n raw_data = np.load(replication_raw_data_filename)\r\n\r\n # minor data validation\r\n if raw_data.min() < constants.MIN_OPINION:\r\n print(f\"Warning: raw_data for replication {rep} contains values below MIN_OPINION!\")\r\n if raw_data.max() > constants.MAX_OPINION:\r\n print(f\"Warning: raw_data for replication {rep} contains values below MIN_OPINION!\")\r\n\r\n # we compute agent-level entropy values on the raw data\r\n # init agent-level container(s), with shape(N, t, num_rv)\r\n agent_level_entropy = data_processors.process_raw_data_into_entropy_timeseries(raw_data, G)\r\n \r\n # now with a N x t x (# entropy array), we average each time step per entropy across all N agents\r\n replication_level_entropy = np.stack(\r\n (agent_level_entropy.mean(axis=0), agent_level_entropy.std(axis=0)), axis=2) # shape(t, num_rv, 2)\r\n\r\n # now we have the replication-level results -- 1 time series per entropy measure (plus st.dev)\r\n # we will save these to file if replication_level_output_filename is set (it is 'can store' data)\r\n np.save(replication_level_results_filename, replication_level_entropy)\r\n\r\n # but in either case, we save these in an array\r\n # -1 to account for my choice to start reps at 1\r\n replication_level_results[rep - 1] = replication_level_entropy[:] # shape(num_rep, t, num_rv, 2)\r\n\r\n rep_times_array[rep - 1] = time.time() - start_time\r\n\r\n # next rep\r\n\r\n if starting_replication_num > 1:\r\n # not all replications are present in replication_level_entropy. the missing data ought to have\r\n # been saved to file on previous (partial) runs of this script, so recover them\r\n for rep in range(1, starting_replication_num):\r\n replication_level_results[rep - 1] = np.load(f\"{results_directory}/replication_results_{trial_num}_{rep}.{design_name_root}.npy\")\r\n\r\n # finally, average (and standardly deviate) across all replications to\r\n # produce trial-level response variables (1 time series per entropy measure (6)) plus stdev\r\n #\r\n # , 0] to only take mean of means, not mean of stdevs\r\n mean_replication_level_results = replication_level_results[:, :, :, 0].mean(axis=0)\r\n stdev_replication_level_results = replication_level_results[:, :, :, 0].std(axis=0)\r\n trial_level_response_variables = np.stack(\r\n (mean_replication_level_results, stdev_replication_level_results), axis=2) # shape(t, num_rv, 2)\r\n\r\n # and preserve our hard work!\r\n np.save(trial_level_results_filename, trial_level_response_variables)\r\n\r\n rep_times_array = rep_times_array[~np.isnan(rep_times_array)] # filter out empty values in case of a partial run\r\n\r\n print(f\"Analysis of Trial {trial_num} complete ({rep_times_array.size} replications).\\n\"\r\n f\"Time elapsed: {rep_times_array.sum()} sec; per replication: {rep_times_array.mean()} +/- {rep_times_array.std()}.\\n\\n\")\r\n\r\n return","def sample_run(df, n_epochs = 10, window_size = 500, com = 12, p_anoms = .5):\n import numpy as np\n\n # create arrays that will hold the results of batch AD (y_true) and online AD (y_pred)\n y_true = []\n y_pred = []\n run_times = []\n \n # check which unique machines, sensors, and timestamps we have in the dataset\n machineIDs = df['machineID'].unique()\n sensors = df.columns[2:]\n timestamps = df['datetime'].unique()[window_size:]\n \n # sample n_machines_test random machines and sensors \n random_machines = np.random.choice(machineIDs, n_epochs)\n random_sensors = np.random.choice(sensors, n_epochs)\n\n # we intialize an array with that will later hold a sample of timetamps\n random_timestamps = np.random.choice(timestamps, n_epochs)\n \n for i in range(0, n_epochs):\n # take a slice of the dataframe that only contains the measures of one random machine\n df_s = df[df['machineID'] == random_machines[i]]\n \n # smooth the values of one random sensor, using our run_avg function\n smooth_values = run_avg(df_s[random_sensors[i]].values, com)\n \n # create a data frame with two columns: timestamp, and smoothed values\n df_smooth = pd.DataFrame(data={'timestamp': df_s['datetime'].values, 'value': smooth_values})\n\n # load the results of batch AD for this machine and sensor\n anoms_s = anoms_batch[((anoms_batch['machineID'] == random_machines[i]) & (anoms_batch['errorID'] == random_sensors[i]))]\n \n # find the location of the t'th random timestamp in the data frame\n if np.random.random() < p_anoms:\n anoms_timestamps = anoms_s['datetime'].values\n np.random.shuffle(anoms_timestamps)\n counter = 0\n while anoms_timestamps[0] < timestamps[0]:\n if counter > 100:\n return 0.0, 9999.0\n np.random.shuffle(anoms_timestamps)\n counter += 1\n random_timestamps[i] = anoms_timestamps[0]\n \n # select the test case\n test_case = df_smooth[df_smooth['timestamp'] == random_timestamps[i]]\n test_case_index = test_case.index.values[0]\n\n\n # check whether the batch AD found an anomaly at that time stamps and copy into y_true at idx\n y_true_i = random_timestamps[i] in anoms_s['datetime'].values\n\n # perform online AD, and write result to y_pred\n y_pred_i, run_times_i = detect_ts_online(df_smooth, window_size, test_case_index)\n \n y_true.append(y_true_i)\n y_pred.append(y_pred_i)\n run_times.append(run_times_i)\n \n return fbeta_score(y_true, y_pred, beta=2), np.mean(run_times)","def get_average_scores(self):\n models = self.eval_parameters['average_experiment']['models']\n metrics = self.eval_parameters['average_experiment']['metrics_list']\n metrics_keys = list(metrics.keys())\n print(r\"\\begin{table}[]\")\n print(\"\\centering\")\n print(r\"\\tiny\")\n print(\"\\caption{Average results over 85 topics. Each row represents a different run (top 10 runs of each model). Each column represents a different assessments aggregation.}\")\n print(\"\\label{tab:average_results}\")\n print(r\"\\begin{tabular}{@{}\"+''.join(['l']*(len(metrics_keys)+1))+\"@{}}\")\n print(\"runid\", '&'.join(metric.replace('_','\\_')for metric in metrics_keys),sep='&')\n print(r\"\\\\ \\midrule\")\n for model in models:\n runs = self.get_list_files(self.eval_parameters['average_experiment']['runs_folder'] + model+\"/\")\n for file in runs:\n val = []\n for metric_id in metrics_keys:\n out1 = subprocess.check_output(\n ['../trec_eval-master/trec_eval', '-m', metrics[metric_id]['metric'],\n metrics[metric_id]['qrels'], file])\n val += [str(out1.rstrip().split()[2]).replace('b\\'', '').replace('\\'', '')]\n print(file.replace(self.eval_parameters['average_experiment']['runs_folder'],'').replace('_','\\_'),'&', '&'.join(val),r\"\\\\\")\n print(r\"\\bottomrule\")\n print(r\"\\end{tabular}\")\n print(r\"\\end{table}\")","def main():\n parser = argparse.ArgumentParser(description=\"Process the results of an experiment.\")\n parser.add_argument(\"experiment\")\n arguments = parser.parse_args()\n path = f\"experiments/{arguments.experiment}\"\n if not os.path.exists(path):\n raise SystemExit(f\"Path {path} does not exists.\")\n\n # For efficiency, one should generate the results from the parts without merging them.\n files = [file for file in os.listdir(path) if os.path.isfile(os.path.join(path, file))]\n frames = []\n for file in files:\n device, experiment, _ = file.split(\".\")\n frame = pandas.read_csv(\n os.path.join(path, file),\n index_col=\"variable\",\n usecols=[\"variable\", \"group_index\", \"value_i\"], dtype={\"value_i\": \"Int64\"}\n )\n frame[\"board\"] = device\n frame[\"experiment\"] = experiment\n frames.append(frame)\n dataframe = pandas.concat(frames)\n frames = None\n\n current_grouping = dataframe.groupby([\"group_index\", \"variable\"])\n \n data = current_grouping.agg([\n numpy.median,\n _percentile_factory(95),\n numpy.mean,\n numpy.std,\n \"count\"\n ])\n\n print(data)\n \n data = data.droplevel([0], axis=1)\n data = data.unstack()\n data.columns = data.columns.map('_'.join)\n data.to_csv(f\"{arguments.experiment}.csv\")","def _generate_report(self):\n total_duration = 0.0\n total_nb_tests = 0\n total_nb_success = 0\n nb_modules = 0\n payload = []\n\n res_table = prettytable.PrettyTable(\n padding_width=2,\n field_names=['Module', 'Duration', 'nb. Test Run', 'Success'])\n res_table.align['Module'] = \"l\"\n res_table.align['Duration'] = \"r\"\n res_table.align['Success'] = \"r\"\n\n # for each scenario we draw a row for the table\n for item in self.summary:\n if item['task_status'] is True:\n nb_modules += 1\n total_duration += item['overall_duration']\n total_nb_tests += item['nb_tests']\n total_nb_success += item['nb_success']\n try:\n success_avg = 100 * item['nb_success'] / item['nb_tests']\n except ZeroDivisionError:\n success_avg = 0\n success_str = f\"{success_avg:0.2f}%\"\n duration_str = time.strftime(\"%H:%M:%S\",\n time.gmtime(item['overall_duration']))\n res_table.add_row([item['test_name'], duration_str,\n item['nb_tests'], success_str])\n payload.append({'module': item['test_name'],\n 'details': {'duration': item['overall_duration'],\n 'nb tests': item['nb_tests'],\n 'success rate': success_str,\n 'success': item['success'],\n 'failures': item['failures']}})\n\n total_duration_str = time.strftime(\"%H:%M:%S\",\n time.gmtime(total_duration))\n try:\n self.result = 100 * total_nb_success / total_nb_tests\n except ZeroDivisionError:\n self.result = 100\n success_rate = f\"{self.result:0.2f}\"\n success_rate_str = str(success_rate) + '%'\n res_table.add_row([\"\", \"\", \"\", \"\"])\n res_table.add_row([\"TOTAL:\", total_duration_str, total_nb_tests,\n success_rate_str])\n\n LOGGER.info(\"Rally Summary Report:\\n\\n%s\\n\", res_table.get_string())\n LOGGER.info(\"Rally '%s' success_rate is %s%% in %s/%s modules\",\n self.case_name, success_rate, nb_modules,\n len(self.summary))\n self.details['summary'] = {'duration': total_duration,\n 'nb tests': total_nb_tests,\n 'nb success': success_rate}\n self.details[\"modules\"] = payload","def _on_train_begins(self, val):\n self.global_rmse.append(self._compute_rmse(self.ratings))\n header_string = '{} \\t | \\t {} \\t '.format('Iteration', 'RMSE')\n num_dashes = 40\n if val is not None:\n header_string += ' \\t | \\t {}'.format('Validation RMSE')\n self.validation_rmse.append(self._compute_rmse(val))\n num_dashes = 70\n print(num_dashes*'-')\n print(header_string)\n print(num_dashes*'-')","def _run_permutation(self, params):\n iter_df, iter_xyz = params\n iter_xyz = np.squeeze(iter_xyz)\n iter_df[[\"x\", \"y\", \"z\"]] = iter_xyz\n stat_values = self._compute_summarystat(iter_df)\n return stat_values","def run(self):\n self.evaluate()\n self.accumulate()\n self.summarize()","def test_num_evals(self):\n\t\tdetails = self.watcher.describe()\t\t\n\t\tself.assertTrue((details.M * details.rf == details.num_evals).all())","def test_num_evals(self):\n\t\tdetails = self.watcher.describe()\t\t\n\t\tself.assertTrue((details.M * details.rf == details.num_evals).all())","def experiment1_outliers():\n\tdata_folder = \"ckan_subset/prepared_learnset/\"\n\ttest_folder = 'ckan_subset/testset/xml_csv/'\n\tgm = Graph_Maker()\n\tgm.store()\n\trounds = 5\n\tx = [\"Fingerprint\", \"Syntax Feature Model\", \"Word2Vec Matcher\"]\n\t\n\tnumber_of_classes = 15\n\texamples_per_class = 0\n\taccuracies = []\n\tprecisions = []\n\trecalls = []\n\tfmeasures = []\n\tsf_main = Storage_Files(data_folder, classes)\n\ttmp_acc = []\n\ttmp_prec = []\n\ttmp_rec = []\n\ttmp_fmeasure = []\n\ttotal_actual = []\n\ttotal_predicted = []\n\n\tfor i in range(0, rounds):\n\t\tprint(\"Fingerprint\")\n\t\t# --- Fingerprint\n\t\tccc = Column_Classification_Config()\n\t\tccc.add_feature('feature_main', 'Fingerprint', [sf_main, number_of_classes, examples_per_class, False, False])\n\n\t\tccc.add_matcher('matcher', 'Fingerprint_Matcher', {'feature_main': 'fingerprint'}) # main classifier\n\t\tsm = Schema_Matcher(ccc)\n\t\tactual, predicted = execute_test_ckan(sm, test_folder, False)\n\t\ttotal_actual += actual\n\t\ttotal_predicted += predicted\n\t\taccuracy = accuracy_score(actual, predicted)\n\t\ttmp_acc.append(accuracy)\n\t\ttmp_prec.append(precision(actual, predicted))\n\t\ttmp_rec.append(recall(actual, predicted))\n\t\ttmp_fmeasure.append(f_measure(actual, predicted))\n\n\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\n\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\n\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\n\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\n\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\n\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\n\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\n\t\n\ttmp_acc = []\n\ttmp_prec = []\n\ttmp_rec = []\n\ttmp_fmeasure = []\n\ttotal_actual = []\n\ttotal_predicted = []\n\tfor i in range(0, rounds):\n\t\tprint(\"SFM\")\n\t\t# --- Syntax Feature Model\n\t\tccc = Column_Classification_Config()\n\t\tccc.add_feature('feature_main', 'Syntax_Feature_Model', [sf_main, 1, 0, False, False])\n\n\t\tccc.add_matcher('matcher', 'Syntax_Matcher', {'feature_main': 'syntax'}) # main classifier\n\t\tsm = Schema_Matcher(ccc)\n\t\tactual, predicted = execute_test_ckan(sm, test_folder, False)\n\t\ttotal_actual += actual\n\t\ttotal_predicted += predicted\n\t\taccuracy = accuracy_score(actual, predicted)\n\t\ttmp_acc.append(accuracy)\n\t\ttmp_prec.append(precision(actual, predicted))\n\t\ttmp_rec.append(recall(actual, predicted))\n\t\ttmp_fmeasure.append(f_measure(actual, predicted))\n\n\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\n\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\n\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\n\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\n\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\n\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\n\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\n\n\ttmp_acc = []\n\ttmp_prec = []\n\ttmp_rec = []\n\ttmp_fmeasure = []\n\ttotal_actual = []\n\ttotal_predicted = []\n\tfor i in range(0, rounds):\n\t\tprint(\"W2V\")\n\t\t# --- Word2Vec Matcher\n\t\tccc = Column_Classification_Config()\n\t\tccc.add_feature('feature_main', 'Corpus', [sf_main, number_of_classes, examples_per_class, False, False])\n\n\t\tccc.add_matcher('matcher', 'Word2Vec_Matcher', {'feature_main': 'corpus'}) # main classifier\n\t\tsm = Schema_Matcher(ccc)\n\t\tactual, predicted = execute_test_ckan(sm, test_folder, False)\n\t\ttotal_actual += actual\n\t\ttotal_predicted += predicted\n\t\taccuracy = accuracy_score(actual, predicted)\n\t\ttmp_acc.append(accuracy)\n\t\ttmp_prec.append(precision(actual, predicted))\n\t\ttmp_rec.append(recall(actual, predicted))\n\t\ttmp_fmeasure.append(f_measure(actual, predicted))\n\n\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\n\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\n\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\n\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\n\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\n\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\n\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\n\n\tgm.add_x(x)\n\t# accuracies = [0.4, 0.4, 0.4]\n\t# precisions = [0.5, 0.5, 0.5]\n\t# recalls = [0.62, 0.62, 0.62]\n\t# fmeasures = [0.23, 0.23, 0.28]\n\tgm.append_y(accuracies)\n\tgm.append_y(precisions)\n\tgm.append_y(recalls)\n\tgm.append_y(fmeasures)\n\tgm.store()\n\tsubtitle = \"Scores were averaged over \" + str(rounds) + \" tests with \" + str(len(classes)) + \" classes. \" + \\\n\t\"Number of simulated columns per class: \" + str(number_of_classes)\n\tlabels = [\"Accuracy\", \"Precision\", \"Recall\", \"F-Measure\"]\n\tgm.plot_bar_n(\"Matcher Type\", \"Score\", \"Accuracy of Matchers\", labels, subtitle=subtitle)","def simulationWithDrug(numViruses, maxPop, maxBirthProb, clearProb, resistances,\n mutProb, numTrials):\n \n #create viruses list\n viruses = []\n for i in range(numViruses):\n viruses.append(ResistantVirus(maxBirthProb, clearProb, resistances, mutProb))\n \n #create test patient P1\n results = np.zeros(numTrials*300).reshape(300,numTrials)\n resultsPopResist = np.zeros(numTrials*300).reshape(300,numTrials)\n \n #runs numTrials of 300 steps, putting results in an array of 300 lines, \n # numTrials columns\n for t in range(numTrials) :\n P1 = TreatedPatient(viruses, maxPop)\n for s in range(150):\n P1.update()\n results[s][numTrials-1] += P1.getTotalPop()\n resultsPopResist[s][numTrials-1] += P1.getResistPop(['guttagonol'])\n \n P1.addPrescription('guttagonol')\n for s in range(150,300):\n P1.update()\n results[s][numTrials-1]+=P1.getTotalPop()\n resultsPopResist[s][numTrials-1] += P1.getResistPop(['guttagonol'])\n \n \n #calculating average of virus population size at each step \n yValues1 = []\n for i in range(300):\n a = sum(results[i].tolist())/len(results[i])\n yValues1.append(a)\n \n yValues2 = []\n for i in range(300):\n a = sum(resultsPopResist[i].tolist())/len(resultsPopResist[i])\n yValues2.append(a)\n\n pylab.plot(yValues1,label='pop average')\n pylab.plot(yValues2,'r--',label = 'resistant virus population')\n pylab.title('virus pop average at each step')\n pylab.legend()\n pylab.xlabel('Time Steps')\n pylab.ylabel('pop #')\n pylab.show()","def SkoptPaperStats(maxIters, numRuns):\n\n comm = MPI.COMM_WORLD\n rank = comm.Get_rank()\n\n assert comm.Get_size() == numRuns, \"Please ensure there is one process running per run i.e \" + str(numRuns) + \" processes.\"\n \n # Define the problem bounds.\n skoptBounds = [(10, 1300), (40, 230), (0, 90), (0, 90)]\n\n # Use the same seed list as previously.\n seedList = [572505, 357073, 584216, 604873, 854690, 573165, 298975, 650770, 243921, 191168]\n\n # The target for each algorithm. This was determined by using the values in the literature, so there is clearly some deviation either due to the detuning or computation.\n globalFoM = 1.033\n\n if rank == 0:\n timeList = []\n iterationList = []\n\n # Define which solver will be used.\n optimiser = skopt.Optimizer(skoptBounds, base_estimator = \"GP\", n_initial_points = int(np.ceil(maxIters/10)), random_state = seedList[rank])\n\n # Start timing.\n startTime = time.time()\n timeElapsed = None\n iterationSuccess = None\n\n # Start optimisation.\n for iteration in range(maxIters):\n\n # Make one suggestion.\n nextParams = optimiser.ask()\n\n # Check what FoM this gives. Go negative as this is a minimisation routine.\n fEval = FitnessSkopt(nextParams)\n\n # Update best FoM.\n if abs(fEval) >= globalFoM:\n # The algorithm has managed to surpass or equal the paper value.\n iterationSuccess = iteration\n timeElapsed = time.time() - startTime\n \n if rank == 0:\n iterationList.append(iterationSuccess)\n timeList.append(timeElapsed)\n\n break\n \n # Tell the optimiser about the result.\n optimiser.tell(nextParams, fEval)\n\n # Run complete. Send results to main process. Tags are unique identifiers.\n if rank != 0:\n comm.send(timeElapsed, dest = 0, tag = 1)\n comm.send(iterationSuccess, dest = 0, tag = 2)\n\n # Wait for all the processes to end.\n comm.Barrier()\n\n if rank == 0:\n # Aggregate the data.\n for process in range(comm.Get_size() - 1):\n # Get the data.\n individualTime = None\n individualTime = comm.recv(individualTime, source = process + 1, tag = 1)\n\n individualIter = None\n individualIter = comm.recv(individualIter, source = process + 1, tag = 2)\n\n if individualIter is not None:\n # Both values must therefore be non-null.\n iterationList.append(individualIter)\n timeList.append(individualTime)\n\n avgRuntime = np.average(timeList)\n avgIters = np.average(iterationList)\n try:\n\n fastestTime = np.min(timeList)\n\n except ValueError:\n \n # List is empty.\n fastestTime = float('NaN')\n\n numSuccess = len(iterationList)\n successRate = numSuccess/numRuns\n\n print(\"Bayesian optimisation paper testing complete! Here are the stats:\")\n print(\"Number of successful runs: \" + str(numSuccess) + \" (Success rate of \" + str(successRate) + \")\")\n print(\"Average iterations required for success: \" + str(avgIters))\n print(\"Average time required for success: \" + str(avgRuntime))\n print(\"Fastest convergence time: \" + str(fastestTime))\n print(\"------------------------------------------------------------------------------------------------------------------\")\n \n return","def run():\n trials = 100\n\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\n\n mean_penalty = []\n median_penalty = []\n std_penalty = []\n\n mean_trial_time = []\n median_trial_time = []\n std_trial_time = []\n\n mean_success_rate = []\n median_success_rate = []\n std_success_rate = []\n\n for m in multipliers:\n all_penalties = [] # All penalties from trail sets\n all_average_trial_time = []\n all_success_rates = []\n\n for i in range(0, 20):\n # print \"Trial set:\", i\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n agent = e.create_agent(LearnerAgent) # create agent\n agent.mult = m\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\n\n sim.run(n_trials=trials) # run for a specified number of trials\n\n all_penalties.append(agent.all_trails_penalties)\n all_average_trial_time.append(agent.time/float(trials))\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\n\n mean_penalty.append(np.mean(all_penalties))\n median_penalty.append(np.median(all_penalties))\n std_penalty.append(np.std(all_penalties))\n\n mean_trial_time.append(np.mean(all_average_trial_time))\n median_trial_time.append(np.median(all_average_trial_time))\n std_trial_time.append(np.std(all_average_trial_time))\n\n mean_success_rate.append(np.mean(all_success_rates))\n median_success_rate.append(np.median(all_success_rates))\n std_success_rate.append(np.std(all_success_rates))\n\n for i in range(0, len(multipliers)):\n print \"\"\n print \"Multiplier:\", multipliers[i]\n print \"\"\n print \"Mean penalty per {} trials:\".format(trials), mean_penalty[i]\n print \"Median penalty per {} trials:\".format(trials), median_penalty[i]\n print \"Std.Dev. penalty per {} trials:\".format(trials), std_penalty[i]\n\n print \"\"\n print \"Mean trial time:\", mean_trial_time[i]\n print \"Median trial time:\", median_trial_time[i]\n print \"Std.Dev. trial time:\", std_trial_time[i]\n\n print \"\"\n print \"Mean success rate per {} trials:\".format(trials), mean_success_rate[i]\n print \"Median success rate per {} trials:\".format(trials), median_success_rate[i]\n print \"Std.Dev. success rate per {} trials:\".format(trials), std_success_rate[i]","def _run_one_iteration(self, iteration):\n statistics = iteration_statistics.IterationStatistics()\n logging.info('Starting iteration %d', iteration)\n num_episodes_train, average_reward_train, average_steps_per_second = (\n self._run_train_phase(statistics))\n active_num_episodes_eval, active_average_reward_eval = self._run_eval_phase(\n statistics, 'active')\n passive_num_episodes_eval, passive_average_reward_eval = (\n self._run_eval_phase(statistics, 'passive'))\n\n self._save_tensorboard_summaries(iteration, num_episodes_train,\n average_reward_train,\n active_num_episodes_eval,\n active_average_reward_eval,\n passive_num_episodes_eval,\n passive_average_reward_eval,\n average_steps_per_second)\n return statistics.data_lists","def run_tests(augmenter, images, nb_runs):\n results = np.zeros((nb_runs,))\n for i in range(nb_runs):\n start = time.time()\n augmenter.augment_batch(images)\n results[i] = time.time() - start\n print(\"Run %d: %.8fs\" % (i, results[i]))\n print(\"Mean: %.8fs\" % (results.mean(),))\n print(\"Sum: %.8fs\" % (results.sum(),))"],"string":"[\n \"def run_mcts(self, runs_per_round):\\n for i in range(runs_per_round):\\n self.select(self.env, 'r')\\n self.env_reset()\\n counts = [self.Nsa[('r', a)] for a in range(self.actions)]\\n # print(\\\"counts \\\", counts)\\n # print(\\\"Q-values\\\", [self.Qsa[('r', a)] for a in range(self.actions)])\\n # print()\\n return np.argmax(counts)\",\n \"def experiment_runs (ins, exp) :\\n return experiment_info.experiment_runs(ins, exp)\",\n \"def load_run_summary(self):\\n vrun_attrs = {}\\n print 'Loading summary of {:} runs for {:} from SQL database'.format( \\\\\\n len(self.runs),self.exp)\\n print 'Estimate loading time ~{:} sec'.format(len(self.runs)/4)\\n for run in range(1,self.runs[-1]['num']+1):\\n run_attr = experiment_info.run_attributes(self.instrument,self.exp,run)\\n for a in run_attr:\\n if a['name'] not in vrun_attrs:\\n vrun_attrs[a['name']] = {'class': a['class'], 'desc': a['descr'], \\n 'type': a['type'], 'val': \\n [None for i in range(1,run)]} \\n vrun_attrs[a['name']]['val'].append(a['val'])\\n self.run_summary = vrun_attrs\",\n \"def test(self, n_test_runs: int = 10) -> None:\\n steps: np.ndarray = np.zeros(n_test_runs)\\n rewards: np.ndarray = np.zeros(n_test_runs)\\n for t in range(n_test_runs):\\n steps[t], rewards[t] = self.step(collect=False)\\n\\n self.get_logger().warn('---------- TEST RUN RESULTS ----------')\\n self.get_logger().warn(f'Average: {steps.mean()}')\\n self.get_logger().warn(f'STD: {steps.std()}')\\n self.get_logger().warn(f'Median: {np.median(steps)}')\\n self.get_logger().warn(f'Average Reward: {rewards.mean()}')\",\n \"def LogRun(ss, dt):\\n run = ss.TrainEnv.Run.Cur # this is NOT triggered by increment yet -- use Cur\\n row = dt.Rows\\n dt.SetNumRows(row + 1)\\n\\n epclog = ss.TrnEpcLog\\n epcix = etable.NewIdxView(epclog)\\n # compute mean over last N epochs for run level\\n nlast = 5\\n if nlast > epcix.Len()-1:\\n nlast = epcix.Len() - 1\\n epcix.Idxs = go.Slice_int(epcix.Idxs[epcix.Len()-nlast:])\\n\\n params = ss.Learn.name + \\\"_\\\" + ss.Pats.name\\n\\n dt.SetCellFloat(\\\"Run\\\", row, float(run))\\n dt.SetCellString(\\\"Params\\\", row, params)\\n dt.SetCellFloat(\\\"FirstZero\\\", row, float(ss.FirstZero))\\n dt.SetCellFloat(\\\"SSE\\\", row, agg.Mean(epcix, \\\"SSE\\\")[0])\\n dt.SetCellFloat(\\\"AvgSSE\\\", row, agg.Mean(epcix, \\\"AvgSSE\\\")[0])\\n dt.SetCellFloat(\\\"PctErr\\\", row, agg.Mean(epcix, \\\"PctErr\\\")[0])\\n dt.SetCellFloat(\\\"PctCor\\\", row, agg.Mean(epcix, \\\"PctCor\\\")[0])\\n dt.SetCellFloat(\\\"CosDiff\\\", row, agg.Mean(epcix, \\\"CosDiff\\\")[0])\\n\\n runix = etable.NewIdxView(dt)\\n spl = split.GroupBy(runix, go.Slice_string([\\\"Params\\\"]))\\n split.Desc(spl, \\\"FirstZero\\\")\\n split.Desc(spl, \\\"PctCor\\\")\\n ss.RunStats = spl.AggsToTable(etable.AddAggName)\\n\\n # note: essential to use Go version of update when called from another goroutine\\n if ss.RunPlot != 0:\\n ss.RunPlot.GoUpdate()\\n if ss.RunFile != 0:\\n if row == 0:\\n dt.WriteCSVHeaders(ss.RunFile, etable.Tab)\\n dt.WriteCSVRow(ss.RunFile, row, etable.Tab)\",\n \"def evaluate(self, runs=100):\\n score_record = []\\n \\n print('Evaluation in progress...')\\n for i in range(runs):\\n score = self.run_evaluation_episode()\\n score_record.append(score)\\n \\n ave_score = np.mean(score_record)\\n \\n print('System evaluated with an average score of {} in {} runs'.format(ave_score, runs))\",\n \"def multi_run(replications: int, iters: List, n: int):\\n global call_count\\n kwargs = {\\n # 'alpha': 0.75,\\n # 'rho': 'VaR',\\n 'alpha': 0.75,\\n 'rho': 'CVaR',\\n 'x0': 2,\\n 'n0': n,\\n 'mu_1': -15,\\n 'mu_2': 10,\\n 'sigma_1': 4,\\n 'sigma_2': 2\\n }\\n\\n out_dict = {\\n 'SA': dict(),\\n 'SA_SAA': dict(),\\n 'NM': dict(),\\n 'NM_SAA': dict(),\\n 'LBFGS': dict(),\\n 'LBFGS_SAA': dict(),\\n 'EI': dict(),\\n 'EI_SAA': dict()\\n }\\n total_calls = dict()\\n for key in out_dict.keys():\\n total_calls[key] = dict()\\n for it_count in iters:\\n kwargs['iter_count'] = it_count\\n for key in out_dict.keys():\\n out_dict[key][it_count] = dict()\\n total_calls[key][it_count] = 0\\n i = 0\\n while i < replications:\\n try:\\n out_dict['SA'][it_count][i] = SA_run(seed=i, **kwargs)\\n total_calls['SA'][it_count] += call_count\\n call_count = 0\\n out_dict['SA_SAA'][it_count][i] = SA_run(seed=i, **kwargs, SAA_seed=i)\\n total_calls['SA_SAA'][it_count] += call_count\\n call_count = 0\\n out_dict['NM'][it_count][i] = NM_run(seed=i, **kwargs)\\n total_calls['NM'][it_count] += call_count\\n call_count = 0\\n out_dict['NM_SAA'][it_count][i] = NM_run(seed=i, **kwargs, SAA_seed=i)\\n total_calls['NM_SAA'][it_count] += call_count\\n call_count = 0\\n out_dict['LBFGS'][it_count][i] = LBFGS_run(seed=i, **kwargs)\\n total_calls['LBFGS'][it_count] += call_count\\n call_count = 0\\n out_dict['LBFGS_SAA'][it_count][i] = LBFGS_run(seed=i, **kwargs, SAA_seed=i)\\n total_calls['LBFGS_SAA'][it_count] += call_count\\n call_count = 0\\n out_dict['EI'][it_count][i] = EI_run(seed=i, **kwargs)\\n total_calls['EI'][it_count] += call_count\\n call_count = 0\\n out_dict['EI_SAA'][it_count][i] = EI_run(seed=i, **kwargs, SAA_seed=i)\\n total_calls['EI_SAA'][it_count] += call_count\\n call_count = 0\\n i += 1\\n except:\\n continue\\n np.save('call_counts_cvar_%d.npy' % n, total_calls)\\n evaluate(out_dict, n)\",\n \"def make_runs(start_run=0, end_run=25,\\n base_dir=DEFAULT_BASE_DIR):\\n for i, reshuffle_mod in enumerate([1, 5, 25, 125, 10000]):\\n for j in range(start_run, end_run):\\n # Remove all handlers associated with the root logger object.\\n # Allows to write the log in another folder.\\n for handler in logging.root.handlers[:]:\\n logging.root.removeHandler(handler)\\n\\n path_exp = \\\"{}/exp_{}/run_{:02d}\\\".format(base_dir, i, j)\\n me.make_exps(reshuffle_mod, path_exp)\\n # If one wants to plot again already made results.\\n # me.load_results_and_plot(path_exp)\\n out_folder_list = [\\\"{}/exp_{}/run_{:02d}\\\".format(base_dir, i, j)\\n for j in range(start_run, end_run)]\\n me.load_all_results_and_plot(out_folder_list, type_plot=\\\"average\\\")\\n me.load_all_results_and_plot(out_folder_list, type_plot=\\\"quantile\\\")\",\n \"def run(self):\\n # Convert the dataset, index: Recovered, column: log10(Susceptible)\\n sr_df = self.sr_df.copy()\\n sr_df[self.S] = np.log10(sr_df[self.S].astype(np.float64))\\n df = sr_df.pivot_table(index=self.R, values=self.S, aggfunc=\\\"last\\\")\\n # Convert index to serial numbers\\n serial_df = pd.DataFrame(np.arange(1, df.index.max() + 1, 1))\\n serial_df.index += 1\\n df = pd.merge(\\n df, serial_df, left_index=True, right_index=True, how=\\\"outer\\\"\\n )\\n series = df.reset_index(drop=True).iloc[:, 0]\\n series = series.interpolate(limit_direction=\\\"both\\\")\\n # Sampling to reduce run-time of Ruptures\\n samples = np.linspace(\\n 0, series.index.max(), len(self.sr_df), dtype=np.int64\\n )\\n series = series[samples]\\n # Detection with Ruptures\\n algorithm = rpt.Pelt(model=\\\"rbf\\\", jump=2, min_size=self.min_size)\\n results = algorithm.fit_predict(series.values, pen=0.5)\\n # Convert index values to Susceptible values\\n reset_series = series.reset_index(drop=True)\\n reset_series.index += 1\\n susceptible_df = reset_series[results].reset_index()\\n # Convert Susceptible values to dates\\n df = pd.merge_asof(\\n susceptible_df.sort_values(self.S),\\n sr_df.reset_index().sort_values(self.S),\\n on=self.S, direction=\\\"nearest\\\"\\n )\\n found_list = df[self.DATE].sort_values()[:-1]\\n # Only use dates when the previous phase has more than {min_size + 1} days\\n delta_days = timedelta(days=self.min_size)\\n first_obj = self.to_date_obj(self.dates[0])\\n last_obj = self.to_date_obj(self.dates[-1])\\n effective_list = [first_obj]\\n for found in found_list:\\n if effective_list[-1] + delta_days < found:\\n effective_list.append(found)\\n # The last change date must be under the last date of records {- min_size} days\\n if effective_list[-1] >= last_obj - delta_days:\\n effective_list = effective_list[:-1]\\n # Set change points\\n self._change_dates = [\\n date.strftime(self.DATE_FORMAT) for date in effective_list[1:]\\n ]\\n return self\",\n \"def evaluate(self, runs = 5, use_gui = False):\\n self.env.render(use_gui)\\n\\n evaluation_results = {\\n \\\"runs\\\" : runs,\\n \\\"unfinished_runs\\\" : 0,\\n \\\"average_delay\\\" : [],\\n \\\"episode_mean_delays\\\" : [],\\n \\\"episode_delay_lists\\\" : []\\n }\\n\\n for i in range(runs):\\n\\n print('Evaluate {} -- running episode {} / {}'.format(self.connection_label,\\n i+1,\\n runs))\\n all_trans, mean_delay, vehicle_delays = self.ddqn.evaluate(env = self.env,\\n policy = \\\"greedy\\\")\\n\\n evaluation_results[\\\"episode_delay_lists\\\"].append(vehicle_delays)\\n evaluation_results[\\\"episode_mean_delays\\\"].append(mean_delay)\\n\\n if mean_delay != -1:\\n evaluation_results[\\\"average_delay\\\"].append(mean_delay)\\n else:\\n evaluation_results[\\\"unfinished_runs\\\"] += 1\\n\\n runs -= evaluation_results[\\\"unfinished_runs\\\"]\\n\\n if runs == 0:\\n evaluation_results[\\\"average_delay\\\"].append(-1)\\n else:\\n evaluation_results[\\\"average_delay\\\"] = sum(evaluation_results[\\\"average_delay\\\"])/runs\\n\\n # print(self.ddqn.q_network.get_weights())\\n\\n return evaluation_results\",\n \"def replicate(self,simulation_run):\\n\\n return self._runModel(params=simulation_run.params)\",\n \"def get_mojo_run_info():\\n \\n #get movies from the db and calulate run info\\n run_info_df = movie_helper.get_movie_run_info()\\n \\n with tqdm(total=len(run_info_df)) as pbar:\\n for index, row in run_info_df.iterrows():\\n #update the database\\n updates = {\\\"end_weekend\\\" : row['end_weekend'], \\n \\\"total_weekends\\\" : row['total_weekends'], \\n \\\"total_release_weeks\\\" : row['total_release_weeks'], \\n \\\"first_run_end\\\" : row['first_run_end'],\\n \\\"first_run_weeks\\\" : row['first_run_weeks']}\\n \\n selects = {\\\"movieId\\\" : row[\\\"movieId\\\"]}\\n database_helper.update_data(\\\"movies\\\", update_params = updates, select_params = selects)\\n \\n pbar.update(1)\",\n \"def run_simulation(self, number_runs = 1):\\n for i in range(0, number_runs):\\n self.ques = [self.start for i in range(0, self.numQueues)]\\n run = self.__single_sim_results()\\n run_results = pd.DataFrame({'simulation':i,\\n 'num_items': len(run),\\n 'wait_count': len(run[run['wait_time']>datetime.timedelta(seconds=0)]),\\n 'avg_wait_time': run.wait_time.mean(),\\n 'close_time': max(run['appt_end_time'])}, index=[i])\\n self.results = pd.concat([self.results, run_results], ignore_index=True)\\n self.results['last_appt_to_close_minutes'] = (self.results['close_time']-self.end).dt.total_seconds().div(60)\\n return\",\n \"def summarize(self):\\n \\n print self._num_tests, \\\"tests ran with\\\", len(self._failed_tests), \\\"failures:\\\", sorted(list(self._failed_tests))\\n\\n self._num_tests = 0\\n self._failed_tests = set()\",\n \"def _get_traces(\\n run, runs, running_runs, all_cses, trace_type='deconvolved', length_fr=15,\\n pad_fr=31, offset_fr=1, running_threshold_cms=4., correct_trials=False,\\n lick_cutoff=-1, lick_window=(-1, 0), running_fraction=0.3,\\n max_n_onsets=-1, remove_stim=True, activity_scale=None):\\n if run not in running_runs:\\n # Prepare running baseline data.\\n # NOTE: running thresholding is done differently here than later during\\n # stimulus runs.\\n out = {'other-running': _get_run_onsets(\\n runs=running_runs,\\n length_fr=length_fr,\\n pad_fr=pad_fr,\\n offset_fr=offset_fr,\\n running_threshold_cms=running_threshold_cms)}\\n\\n for training_run in runs:\\n t2p = training_run.trace2p()\\n\\n # Get the trace from which to extract time points\\n trs = t2p.trace(trace_type)\\n\\n if activity_scale is not None:\\n trs = (trs.T*activity_scale).T\\n\\n # If the target run is also a training run, make sure that we aren't\\n # training on the same data that will later be used for comparison\\n if remove_stim or training_run != run:\\n # Search through all stimulus onsets, correctly coding them\\n for ncs in t2p.cses(): # t.cses(self._pars['add-ensure-quinine']):\\n if ncs in all_cses:\\n # Remap cs name if needed\\n # NOTE: blank trials are just labeled 'other' and not\\n # checked for running.\\n cs = all_cses[ncs]\\n # Initialize output\\n if cs not in out:\\n out[cs] = []\\n\\n ons = t2p.csonsets(\\n ncs, 0 if correct_trials else -1, lick_cutoff,\\n lick_window)\\n\\n for on in ons:\\n start = on + offset_fr\\n toappend = trs[:, start:start + length_fr]\\n # Make sure interval didn't run off the end.\\n if toappend.shape[1] == length_fr:\\n out[cs].append(toappend)\\n\\n # If the target run is in the training runs, don't use the times\\n # that will later be used for comparison.\\n if training_run != run:\\n # Add all onsets of \\\"other\\\" frames\\n others = t2p.nocs(length_fr, pad_fr, -1)\\n\\n if len(t2p.speed()) > 0:\\n running = t2p.speed() > running_threshold_cms\\n for ot in others:\\n start = ot + offset_fr\\n if nanmean(running[start:start + length_fr]) > \\\\\\n running_fraction:\\n out['other-running'].append(\\n trs[:, start:start + length_fr])\\n else:\\n if 'other' not in out:\\n out['other'] = []\\n out['other'].append(\\n trs[:, start:start + length_fr])\\n\\n # Selectively remove onsets if necessary\\n if max_n_onsets > 0:\\n for cs in out:\\n if 'other' not in cs:\\n print('WARNING: Have not yet checked new timing version')\\n\\n # Account for shape of array\\n if len(out[cs]) > max_n_onsets:\\n out[cs] = np.random.choice(\\n out[cs], max_n_onsets, replace=False)\\n\\n for cs in out:\\n out[cs] = np.array(out[cs])\\n\\n return out\",\n \"def trial_setup(params):\\n runs = []\\n trials = []\\n for run in range(params['runs']):\\n runs = runs + [run]*params['trials_per_run']\\n for trial in range(params['trials_per_run']):\\n trials.append(trial)\\n return(runs,trials)\",\n \"def simulationTwoDrugsDelayedTreatment(numTrials):\\n #Initialization\\n delayList = [300, 150, 75, 0]\\n #delayList = [150]\\n #Patient init variables\\n numViruses = 100\\n maxPop = 1000\\n #Virus init variables\\n maxBirthProb = 0.1\\n clearProb = 0.05\\n #clearProb = 0.10\\n resistances = { 'guttagonol': False, 'grimpex' : False }\\n #mutProb = 0.005\\n mutProb = 0.010\\n \\n results = {}\\n \\n for n in delayList:\\n cured = 0\\n popList = []\\n print \\\"Running trials for delay %(delay)d\\\" % {'delay' : n}\\n for i in range(numTrials):\\n #print \\\"Trial: \\\" + str(i)\\n pop = runTrialTwoDrugs(n, numViruses, maxPop, maxBirthProb, clearProb, resistances, mutProb)\\n popList.append(pop)\\n if pop < 50:\\n cured +=1\\n results[n] = popList\\n #print popList\\n print \\\"Delay : %(delay)d Percentage cured %(percent)2f\\\" % {\\\"delay\\\" : n, \\\"percent\\\" : cured/float(numTrials) }\\n \\n\\n drawHist(results, numTrials)\",\n \"def add_runs(self,runs):\\n for r in runs:\\n self.add(r)\",\n \"def Repeater(algorithm, runs, nationtxt, schemeIn):\\n\\n scores = {}\\n\\n # Make sure appropriate range is used for scores\\n\\n scoreRange = range(0, 10000)\\n\\n # score range has to be between these two numbers\\n for i in scoreRange:\\n scores.update({i : 0})\\n\\n #~ print \\\"Running \\\" + str(algorithm)[0:-18] + \\\"> \\\" + str(runs) + \\\" times...\\\\n\\\"\\n\\n\\n minScore = 10**40\\n\\n\\n scheme = schemeIn\\n avg = (scheme[0] + scheme[1] + scheme[2] + scheme[3] + scheme[4] + scheme[5] + scheme[6]) / 7.\\n p0 = (scheme[0] - avg)**2\\n p1 = (scheme[1] - avg)**2\\n p2 = (scheme[2] - avg)**2\\n p3 = (scheme[3] - avg)**2\\n p4 = (scheme[4] - avg)**2\\n p5 = (scheme[5] - avg)**2\\n p6 = (scheme[6] - avg)**2\\n var = (p0 + p1 + p2 + p3 + p4 + p5 + p6) / 7.\\n sDev = var**0.5\\n\\n\\n q0 = scheme[1] - scheme[0]\\n q1 = scheme[2] - scheme[1]\\n q2 = scheme[3] - scheme[2]\\n q3 = scheme[4] - scheme[3]\\n q4 = scheme[5] - scheme[4]\\n q5 = scheme[6] - scheme[5]\\n\\n for i in range(runs):\\n nation = algorithm(nationtxt)\\n\\n score = randScoreFunction(nation, scheme)\\n scores[score] += 1\\n\\n # keep track of best scores and nation\\n if score < minScore:\\n minScore = score\\n bestNation = nation\\n\\n maxFreq = 0\\n\\n scoreCount = 0\\n\\n for score in scores:\\n if scores[score] > maxFreq:\\n maxFreq = scores[score]\\n maxFreqScore = score\\n if score == minScore:\\n minScoreFreq = scores[score]\\n if scores[score] >= 1:\\n scoreCount += 1\\n\\n\\n usedTrans = []\\n fivePlus = 0\\n fivePlusNoDuplicate = 0\\n\\n one = 0\\n two = 0\\n three = 0\\n four = 0\\n five = 0\\n six = 0\\n seven = 0\\n\\n for province in bestNation:\\n\\n if bestNation[province][1] == 1:\\n one += 1\\n if bestNation[province][1] == 2:\\n two += 1\\n if bestNation[province][1] == 3:\\n three += 1\\n if bestNation[province][1] == 4:\\n four += 1\\n if bestNation[province][1] == 5:\\n five += 1\\n if bestNation[province][1] == 6:\\n six += 1\\n if bestNation[province][1] == 7:\\n seven += 1\\n\\n\\n if five > 0 or six > 0 or seven > 0:\\n fivePlus += 1\\n if scheme[3] != scheme[4]:\\n fivePlusNoDuplicate += 1\\n\\n usedTrans.append([one, two, three, four, five, six, seven])\\n\\n\\n return minScore, minScoreFreq, scheme, fivePlus, fivePlusNoDuplicate, usedTrans, scoreCount, sDev, q0, q1, q2, q3, q4, q5, avg\",\n \"def simulationDelayedTreatment(numTrials):\\n \\n #Initialization\\n #delayList = [300, 150, 75, 0]\\n delayList = [150]\\n #Patient init variables\\n numViruses = 100\\n maxPop = 1000\\n #Virus init variables\\n maxBirthProb = 0.1\\n clearProb = 0.05\\n #clearProb = 0.10\\n resistances = { 'guttagonol': True }\\n mutProb = 0.005\\n \\n results = {}\\n \\n for n in delayList:\\n cured = 0\\n popList = []\\n for i in range(numTrials):\\n pop = runTrial(n, numViruses, maxPop, maxBirthProb, clearProb, resistances, mutProb)\\n popList.append(pop)\\n if pop == 0:\\n cured +=1\\n results[n] = popList\\n #print popList\\n print \\\"Delay : %(delay)d Percentage cured %(percent)2f\\\" % {\\\"delay\\\" : n, \\\"percent\\\" : cured/float(numTrials) }\\n \\n\\n drawHist(results, numTrials)\",\n \"def _extract_results_from_run_history(self, run_history: RunHistory) -> None:\\n\\n for run_key, run_value in run_history.data.items():\\n config = run_history.ids_config[run_key.config_id]\\n self._update(config=config, run_key=run_key, run_value=run_value)\\n\\n self._check_null_in_optional_inference_choices()\\n\\n self.rank_opt_scores = scipy.stats.rankdata(\\n -1 * self._metric._sign * self.opt_scores, # rank order\\n method='min'\\n )\",\n \"def simulate_run(run, maker, all_data, train_mask, test_mask, instances, independent, mixture):\\n\\n train_data = all_data.masked(train_mask)\\n test_data = all_data.masked(test_mask)\\n\\n if instances is not None:\\n ids = sorted(train_data.run_lists, key = lambda _: numpy.random.rand())[:instances]\\n train_data = train_data.filter(*ids)\\n\\n if independent:\\n train_data = train_data.collect_independent(mixture).only_nonempty()\\n else:\\n train_data = train_data.collect_systematic(mixture).only_nonempty()\\n\\n budget = test_data.common_budget\\n #budget = test_data.common_budget / 2 # XXX\\n suite = borg.fake.FakeSuite(test_data)\\n\\n if maker.subname == \\\"preplanning-dir\\\":\\n model_kwargs = {\\\"K\\\": 64}\\n\\n if \\\"set_alpha\\\" in maker.variants:\\n model_kwargs[\\\"alpha\\\"] = 1e-2\\n else:\\n model_kwargs = {}\\n\\n solver = maker(suite, train_data, model_kwargs = model_kwargs)\\n successes = []\\n\\n for (i, instance_id) in enumerate(test_data.run_lists):\\n logger.info(\\\"simulating run %i/%i on %s\\\", i, len(test_data), instance_id)\\n\\n with suite.domain.task_from_path(instance_id) as instance:\\n with borg.accounting() as accountant:\\n answer = solver.start(instance).run_then_stop(budget)\\n\\n succeeded = suite.domain.is_final(instance, answer)\\n\\n logger.info(\\n \\\"%s %s on %s (%.2f CPU s)\\\",\\n maker.name,\\n \\\"succeeded\\\" if succeeded else \\\"failed\\\",\\n os.path.basename(instance),\\n accountant.total.cpu_seconds,\\n )\\n\\n if succeeded:\\n successes.append(accountant.total.cpu_seconds)\\n\\n logger.info(\\n \\\"%s had %i successes over %i instances\\\",\\n maker.name,\\n len(successes),\\n len(test_data),\\n )\\n\\n description = \\\"{0} ({1})\\\".format(mixture, \\\"Sep.\\\" if independent else \\\"Sys.\\\")\\n\\n return (\\n description,\\n maker.name,\\n instances,\\n len(successes),\\n numpy.mean(successes),\\n numpy.median(successes),\\n )\",\n \"def evaluate_benchmarks(self):\\n\\n # iterate over replicates\\n results = {}\\n for replicate_id, replicate in self.replicates:\\n\\n # evaluate benchmark for current replicate\\n bmark = SimulationBenchmark(replicate.copy(),\\n graph=self.graphs[replicate_id],\\n **self.params)\\n\\n # store results\\n results[replicate_id] = dict(\\n\\n labels_MAE=bmark.scores['labels'].MAE,\\n level_only_MAE=bmark.scores['level_only'].MAE,\\n spatial_only_MAE=bmark.scores['spatial_only'].MAE,\\n community_MAE=bmark.scores['labels_comm'].MAE,\\n\\n labels_PCT=bmark.scores['labels'].percent_correct,\\n level_only_PCT=bmark.scores['level_only'].percent_correct,\\n spatial_only_PCT=bmark.scores['spatial_only'].percent_correct,\\n community_PCT=bmark.scores['labels_comm'].percent_correct)\\n\\n # compile dataframe\\n results = pd.DataFrame.from_dict(results, orient='index')\\n results.index.set_names(self.multiindex, inplace=True)\\n\\n return results\",\n \"def dict_of_recs_for_run (ins, exp, runnum) :\\n return calibration_runs(ins, exp)[runnum]\",\n \"def sum_simulated_test():\\n f = open(\\\"./results/simulated_sigmoid_sum.csv\\\", \\\"w\\\")\\n #f1 = open(\\\"./results/avg_pres.txt\\\", \\\"w\\\")\\n #f.write(\\\"num. of qubits; precision\\\\n\\\")\\n\\n\\n computable_qubits = 27\\n num_subtest = 1000\\n\\n acum_precision = 0\\n coeffs = []\\n temp = -10\\n while temp < 11:\\n coeffs.append(temp)\\n temp += 0.25\\n #for coeff in coeffs:\\n # variables.c_summation = coeff\\n # print(coeff)\\n for i in range(2, computable_qubits):\\n #print(\\\"qubit: \\\", i)\\n precision = 0\\n x = []\\n for j in range(num_subtest):\\n\\n random_dict = get_random_dict(i)\\n\\n # compute real answer\\n real_answer = 0\\n for value in random_dict.values():\\n real_answer += value\\n # f1.write(str(real_answer)+\\\";\\\")\\n x.append(real_answer)\\n\\n # assign spin value to real_answer\\n if real_answer < 0:\\n real_answer = -1\\n elif real_answer > 0:\\n real_answer = 1\\n else:\\n real_answer = 0\\n bqm = get_bqm()\\n quantum_sigmoid_sum(bqm, random_dict, \\\"target\\\")\\n sampler = get_simulated_sampler()\\n result = sampler.sample(bqm)\\n if real_answer == 0:\\n precision += 1\\n # f1.write(\\\"1\\\\n\\\")\\n elif real_answer == result.first.sample['target']:\\n precision += 1\\n # f1.write(\\\"1\\\\n\\\")\\n# else:\\n # f1.write(\\\"0\\\\n\\\")\\n\\n precision /= num_subtest\\n # acum_precision+= precision\\n\\n f.write(str(i) + \\\";\\\" + str(precision) + \\\"\\\\n\\\")\\n f.close()\\n #f1.write(str(coeff)+\\\";\\\"+ str(round(acum_precision/(computable_qubits-1), 4)) + \\\"\\\\n\\\")\\n # acum_precision = 0\\n #f1.close()\",\n \"def train_multiple_runs_eps(self, env, runs=3, no_episodes=200, horizon=1000, lr=0.1):\\n\\t\\tr_mat = []\\n\\t\\tinfo = {}\\n\\t\\t\\n\\t\\tfor i in range(runs):\\n\\n\\t\\t\\t# Resetting agent to default before each run\\n\\t\\t\\tself.reset()\\n\\n\\t\\t\\t# Training the agent for ts_max\\n\\t\\t\\tr_vec, _ = self.train_multiple_eps(env, no_episodes=no_episodes, horizon=horizon, lr=lr)\\n\\n\\t\\t\\t# Storing the results in a matrix\\n\\t\\t\\tr_mat.append(r_vec)\\n\\n\\t\\t# Finding the mean and standard deviation \\n\\t\\tinfo['mean'] = np.mean(np.array(r_mat), axis=0)\\n\\t\\tinfo['std'] = np.std(np.array(r_mat), axis=0)\\n\\n\\t\\treturn r_mat, info\",\n \"def timings_across_runs(self):\\n\\n\\t\\t# first determine individual run duration (to make sure that stimulus timings of all runs are correct)\\n\\t\\trun_duration = []\\n\\t\\tfor r in [self.runList[i] for i in self.conditionDict['WMM']]:\\n\\t\\t\\tniiFile = NiftiImage(self.runFile(stage = 'processed/mri', run = r))\\n\\t\\t\\ttr, nr_trs = round(niiFile.rtime*1)/1000.0, niiFile.timepoints\\n\\t\\t\\trun_duration.append(tr * nr_trs)\\n\\t\\trun_duration = np.r_[0,np.cumsum(np.array(run_duration))]\\n\\n\\t\\t# timing information stimuli\\n\\t\\tstim_info = []\\n\\t\\trun = 0\\n\\t\\tfor r in [self.runList[i] for i in self.conditionDict['WMM']]:\\n\\t\\t\\tstim_events = np.loadtxt(self.runFile(stage = 'processed/behavior', run = r, extension = '.txt', postFix = ['stim' ,'all','task']))\\n\\t\\t\\tstim_events[:,:2] += run_duration[run]\\n\\t\\t\\tstim_info.append(stim_events)\\n\\t\\t\\trun += 1\\n\\n\\t\\t# save stim_info as text_file\\t\\n\\t\\tnp.savetxt(self.runFile(stage = 'processed/behavior', postFix = ['stim_info_all'],extension = '.txt'), np.vstack(stim_info), fmt = '%3.2f', delimiter = '\\\\t')\",\n \"def num_trials(self):\",\n \"def aggregate_results(results):\\n\\n for (config,con,dec),folds in results.iteritems():\\n m = MODEL_PATTERN.match(config)\\n if m:\\n mode = m.groupdict()['mode'] # mle, rl, mrt, ...\\n model = m.groupdict()['model'] # haem, hacm, hard, ...\\n align = m.groupdict()['align'] # crp, cls ...\\n else:\\n mode, model, align = '', '', ''\\n # mean accuracies across seeds for each fold\\n foldaccuracies = []\\n # we count number of models over folds and seeds\\n num_individual_models = 0\\n\\n for foldname,fold in folds.items():\\n if 'Q' in options.mode:\\n seedaccurracies = fold.values()[:1] if fold.values() else [] # pick one\\n# SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\\n else:\\n seedaccurracies = []\\n for seed_acc in fold.values():\\n seedaccurracies.append(seed_acc)\\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,foldname)] += 1\\n # aggregate on fold level\\n fold['__MEAN__'] = float(np.mean(seedaccurracies))\\n fold['__SD__'] = float(np.std(seedaccurracies))\\n l = len(seedaccurracies)\\n num_individual_models += l\\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__MEAN__')] += l\\n SUPPORT_STATISTICS[(config,con,dec,model,align,mode,'__SD__')] += l\\n\\n # statistics over seeds for this fold\\n fold['__STATS__'] = fold['__MEAN__'], fold['__SD__'], l\\n foldaccuracies.append(fold['__MEAN__'])\\n # aggregate on (config, condition, decoding) level\\n folds['__MEAN__'] = float(np.mean(foldaccuracies))\\n folds['__SD__'] = float(np.std(foldaccuracies))\\n # statistics over folds for this (config, condition, decoding)\\n folds['__STATS__'] = folds['__MEAN__'], folds['__SD__'], num_individual_models\",\n \"def evaluate_model(args, eval_runs, warm_runs, metrics=['psnr', 'ssim', 'fps']):\\n upsampler = Upsampler(args)\\n if warm_runs > 0:\\n print(\\\"Warming up for evaluation\\\")\\n for i in range(warm_runs):\\n print(\\\"Performing warm-up run\\\", str(i+1))\\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\\n upsampler.run_dir(bix_dir, reset=False)\\n \\n time = 0.\\n psnrs = []\\n ssims = []\\n for i in range(eval_runs):\\n run_psnrs = []\\n run_ssims = []\\n print(\\\"Performing evaluation run\\\", str(i+1))\\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\\n gt_dir = os.path.join(VID4_DIR, 'GT', sequence)\\n print(\\\"Evaluating on\\\", bix_dir)\\n time += upsampler.run_dir(bix_dir, reset=False)\\n vid_psnrs, vid_ssims = _eval_sr_perf(os.path.join(bix_dir, 'up'), gt_dir)\\n run_psnrs += vid_psnrs\\n run_ssims += vid_ssims\\n if i == eval_runs-1:\\n with open(os.path.join(upsampler.get_model_dir(), \\\"psnr.txt\\\"), \\\"w\\\") as f:\\n f.writelines(str(psnr) + '\\\\n' for psnr in run_psnrs)\\n with open(os.path.join(upsampler.get_model_dir(), \\\"ssim.txt\\\"), \\\"w\\\") as f:\\n f.writelines(str(ssim) + '\\\\n' for ssim in run_ssims)\\n psnrs += run_psnrs\\n ssims += run_ssims\\n\\n fps = VID4_LENGTH/ (time/eval_runs)\\n return Performance(psnr=psnrs, ssim=ssims, fps=fps)\",\n \"def _compute_experiment_statistics(self):\\n pass\",\n \"def get_run_info_miseq( instrument_model, application_version, tree ):\\n run_stats = {}\\n\\n setup_node = tree.getroot().find(\\\"Setup\\\")\\n if setup_node is None:\\n setup_node = tree.getroot()\\n\\n # Get required tree nodes.\\n flowcell_node = tree.getroot().find(\\\"FlowcellRFIDTag\\\")\\n reads_node = tree.getroot().find('Reads')\\n\\n # Now actually populate various stats\\n run_stats['flow_cell_id'] = flowcell_node.find('SerialNumber').text\\n run_stats['date'] = tree.getroot().find('RunStartDate').text\\n run_stats['instrument'] = tree.getroot().find('ScannerID').text\\n run_stats['lanes'] = int(setup_node.find('NumLanes').text)\\n run_stats['run_id'] = tree.getroot().find('RunID').text\\n\\n read_len = []\\n index_len = []\\n for read_info in reads_node.findall('RunInfoRead'):\\n attrib = read_info.attrib\\n if( attrib['IsIndexedRead'] == 'Y' ):\\n index_len.append( int( attrib['NumCycles'] ) )\\n else:\\n read_len.append( int( attrib['NumCycles'] ) )\\n\\n run_stats['r1_length'] = read_len[0]\\n run_stats['p7_index_length'] = index_len[0]\\n\\n run_stats['paired_end'] = False\\n if( len( read_len ) == 2 ):\\n run_stats['r1_length'] = read_len[1]\\n run_stats['p5_index_length'] = index_len[1]\\n run_stats['paired_end'] = True\\n\\n run_stats['instrument_type'] = instrument_model\\n run_stats['reverse_complement_i5'] = False\\n\\n return run_stats\",\n \"def explore_runs(df, option, gamma, alpha):\\n\\n n_states = len(np.unique(df.objnum))\\n SR_matrices = {}\\n M = np.zeros([n_states, n_states])\\n\\n # This option allows the SR matrix to persist in Part 1 and Part 2,\\n # but resets it between them.\\n if option == \\\"reset\\\":\\n for part in np.unique(df.part):\\n if part == 2:\\n M = np.zeros([n_states, n_states])\\n for run in np.unique(df.loc[df.part == part, 'run']):\\n envstep = df.loc[(df.part == part) & (df.run == run),\\n 'objnum'].values\\n M = np.array(run_experiment(envstep, gamma, alpha, np.copy(M),\\n n_states))\\n M = M / np.sum(M)\\n SR_matrices[(part, run)] = M\\n\\n # This option resets the SR matrix between each run.\\n if option == \\\"independent\\\":\\n for part in np.unique(df.part):\\n for run in np.unique(df.loc[df.part == part, 'run']):\\n M = np.zeros([n_states, n_states])\\n envstep = df.loc[(df.part == part) & (df.run == run),\\n 'objnum'].values\\n M = np.array(run_experiment(envstep, gamma, alpha, np.copy(M),\\n n_states))\\n M = M / np.sum(M)\\n SR_matrices[(part, run)] = M\\n\\n return SR_matrices\",\n \"def AllindividualRuns():\\n #800 nm\\n RunData(getFiles(mintime=(15, 40, 07), maxtime=(15, 45, 14), folder='data/29Jul/'), out='I800nm')\\n RunData(getFiles(mintime=(15, 12, 20), maxtime=(15, 24, 16), folder='data/31Jul/'), out='I800nm5k')\\n RunData(getFiles(mintime=(15, 28, 40), maxtime=(15, 39, 21), folder='data/31Jul/'), out='I800nm10k')\\n RunData(getFiles(mintime=(15, 43, 24), maxtime=(15, 51, 47), folder='data/31Jul/'), out='I800nm20k')\\n RunData(getFiles(mintime=(15, 56, 11), maxtime=(16, 02, 58), folder='data/31Jul/'), out='I800nm30k')\\n RunData(getFiles(mintime=(16, 12, 39), maxtime=(16, 18, 25), folder='data/31Jul/'), out='I800nm38k')\\n RunData(getFiles(mintime=(16, 21, 52), maxtime=(16, 26, 16), folder='data/31Jul/'), out='I800nm50k')\\n RunData(getFiles(mintime=(16, 32, 02), maxtime=(16, 35, 23), folder='data/31Jul/'), out='I800nm54k')\\n #700 nm\\n RunData(getFiles(mintime=(17, 20, 17), maxtime=(17, 33, 17), folder='data/30Jul/'), out='I700nm5k')\\n RunData(getFiles(mintime=(17, 37, 35), maxtime=(17, 46, 51), folder='data/30Jul/'), out='I700nm9k')\\n RunData(getFiles(mintime=(17, 48, 35), maxtime=(17, 56, 03), folder='data/30Jul/'), out='I700nm52k')\\n RunData(getFiles(mintime=(17, 58, 18), maxtime=(17, 59, 31), folder='data/30Jul/'), out='I700nm32k')\\n #600 nm\\n RunData(getFiles(mintime=(15, 22, 00), maxtime=(15, 36, 32), folder='data/30Jul/'), out='I600nm5k')\\n RunData(getFiles(mintime=(15, 39, 58), maxtime=(15, 47, 58), folder='data/30Jul/'), out='I600nm54k')\\n RunData(getFiles(mintime=(15, 52, 07), maxtime=(16, 06, 32), folder='data/30Jul/'), out='I600nm10k')\\n #890 nm\\n RunData(getFiles(mintime=(13, 37, 37), maxtime=(13, 50, 58), folder='data/01Aug/'), out='I890nm5k')\\n RunData(getFiles(mintime=(14, 00, 58), maxtime=(14, 11, 54), folder='data/01Aug/'), out='I890nm10k')\\n RunData(getFiles(mintime=(14, 17, 57), maxtime=(14, 25, 49), folder='data/01Aug/'), out='I890nm30k')\\n RunData(getFiles(mintime=(14, 30, 03), maxtime=(14, 34, 37), folder='data/01Aug/'), out='I890nm50k')\",\n \"def plot_average_SA(repetitions, runs):\\n\\n\\ttotalscores = []\\n\\n\\t# for each repetition\\n\\tfor i in range(repetitions):\\n\\n\\t\\t# create empty list\\n\\t\\talgorithm_scores = []\\n\\n\\t\\t# create random schedule and perform simulated annealing with geman coolingscheme\\n\\t\\tchambers, allcourses, student_list, schedule = create_schedule()\\n\\n\\t\\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, scores = simulated_annealing(geman, runs, chambers, allcourses, student_list, schedule)\\n\\n\\t\\t# create random schedule and perform simulated annealing with linear coolingscheme\\n\\t\\tchambers, allcourses, student_list, schedule = create_schedule()\\n\\t\\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, linear_scores = simulated_annealing(linear, runs, chambers, allcourses, student_list, schedule)\\n\\n\\t\\t# create random schedule and perform simulated annealing with sigmoidal coolingscheme\\n\\t\\tchambers, allcourses, student_list, schedule = create_schedule()\\n\\t\\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, sigmoidal_scores = simulated_annealing(sigmoidal, runs, chambers, allcourses, student_list, schedule)\\n\\n\\t\\t# create random schedule and perform simulated annealing with exponential coolingscheme\\n\\t\\tchambers, allcourses, student_list, schedule = create_schedule()\\n\\t\\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, exponential_scores = simulated_annealing(exponential, runs, chambers, allcourses, student_list, schedule)\\n\\n\\t\\t# add scores to alogrithm list\\n\\t\\talgorithm_scores.append([geman_scores, linear_scores, sigmoidal_scores, exponential_scores])\\n\\n\\t\\t# add algorithm list to totalscore\\n\\t\\ttotalscores.append(algorithm_scores)\\n\\n\\t# create empty lists for score per coolingscheme\\n\\tall_geman_scores = []\\n\\tall_linear_scores = []\\n\\tall_sigmoidal_scores = []\\n\\tall_exponential_scores = []\\n\\n\\t# add single scores coolingschem into lists with all scores\\n\\tfor i in range(repetitions):\\n\\t\\tall_geman_scores.append(totalscores[i][0][0])\\n\\t\\tall_linear_scores.append(totalscores[i][0][1])\\n\\t\\tall_sigmoidal_scores.append(totalscores[i][0][2])\\n\\t\\tall_exponential_scores.append(totalscores[i][0][3])\\n\\n\\t# create empty lists for sorted scores\\n\\tgeman_sorted_scores = []\\n\\tlinear_sorted_scores = []\\n\\tsigmoidal_sorted_scores = []\\n\\texponential_sorted_scores = []\\n\\n\\t# for each run\\n\\tfor i in range(runs):\\n\\n\\t\\t# create empty lists for selected scores\\n\\t\\tgeman_selected_score = []\\n\\t\\tlinear_selected_score = []\\n\\t\\tsigmoidal_selected_score = []\\n\\t\\texponential_selected_score = []\\n\\n\\t\\t# for each repetition\\n\\t\\tfor j in range(repetitions):\\n\\n\\t\\t\\t# add selected score to all score list of coolingscheme\\n\\t\\t\\tgeman_selected_score.append(all_geman_scores[j][i])\\n\\t\\t\\tlinear_selected_score.append(all_linear_scores[j][i])\\n\\t\\t\\tsigmoidal_selected_score.append(all_sigmoidal_scores[j][i])\\n\\t\\t\\texponential_selected_score.append(all_exponential_scores[j][i])\\n\\n\\t\\t# add selected scores into sorted score\\n\\t\\tgeman_sorted_scores.append(geman_selected_score)\\n\\t\\tlinear_sorted_scores.append(linear_selected_score)\\n\\t\\tsigmoidal_sorted_scores.append(sigmoidal_selected_score)\\n\\t\\texponential_sorted_scores.append(exponential_selected_score)\\n\\n\\t# calculate average for each sorted scores\\n\\tgeman_average_scores = []\\n\\tfor scores in geman_sorted_scores:\\n\\t\\tgeman_average_scores.append(sum(scores)/len(scores))\\n\\n\\tlinear_average_scores = []\\n\\tfor scores in linear_sorted_scores:\\n\\t\\tlinear_average_scores.append(sum(scores)/len(scores))\\n\\n\\tsigmoidal_average_scores = []\\n\\tfor scores in sigmoidal_sorted_scores:\\n\\t\\tsigmoidal_average_scores.append(sum(scores)/len(scores))\\n\\n\\texponential_average_scores = []\\n\\tfor scores in exponential_sorted_scores:\\n\\t\\texponential_average_scores.append(sum(scores)/len(scores))\\n\\n\\t# store average scores in one list\\n\\taverage_scores = [geman_average_scores, linear_average_scores, sigmoidal_average_scores, exponential_average_scores]\\n\\n\\t# create plot with multiple lines of all coolingschemes\\n\\tmultiple_simulated_annealing(average_scores)\",\n \"def make_simulations(self):\\n pass\",\n \"def report(results, n_top=1):\\n for i in range(1, n_top + 1):\\n candidates = np.flatnonzero(results['rank_test_score'] == i)\\n for candidate in candidates:\\n print(f\\\"Model with rank: {i}\\\")\\n print(f\\\"Mean validation score: {results['mean_test_score'][candidate]} (std: {results['std_test_score'][candidate]}\\\")\\n print(f\\\"Parameters: {results['params'][candidate]}\\\")\",\n \"def get_repeated_outputs(df,\\n model_name,\\n parameters,\\n input_path,\\n inputs,\\n targets,\\n n_repeats,\\n zero_flag,\\n neonate,\\n tolerance=None,\\n limit=None,\\n frac=None,\\n openopt_path=None,\\n offset=None,\\n distance='euclidean'\\n ):\\n p_names = list(parameters.keys())\\n sorted_df = df.sort_values(by=distance)\\n\\n if tolerance:\\n accepted_limit = sum(df[distance].values < tolerance)\\n elif limit:\\n accepted_limit = limit\\n elif frac:\\n accepted_limit = frac_calculator(sorted_df, frac)\\n else:\\n raise ValueError('No limit or fraction given.')\\n\\n df_list = []\\n if n_repeats > accepted_limit:\\n print(\\n \\\"Setting number of repeats to quarter of the posterior size\\\\n\\\",\\n file=sys.stderr)\\n n_repeats = int(accepted_limit / 4)\\n d0 = import_actual_data(input_path)\\n input_data = inputParse(d0, inputs)\\n\\n true_data = pd.read_csv(input_path)\\n times = true_data['t'].values\\n\\n if openopt_path:\\n openopt_data = pd.read_csv(openopt_path)\\n\\n if n_repeats > accepted_limit:\\n raise ValueError(\\n \\\"Number of requested model runs greater than posterior size:\\\"\\n \\\"\\\\n\\\\tPosterior Size: {}\\\\n\\\\tNumber of runs: {}\\\".format(\\n accepted_limit, n_repeats))\\n\\n rand_selection = list(range(accepted_limit))\\n random.shuffle(rand_selection)\\n\\n outputs_list = []\\n\\n posteriors = sorted_df.iloc[:accepted_limit][p_names].values\\n select_idx = 0\\n with Timer(\\\"Running repeat outputs\\\"):\\n while len(outputs_list) < n_repeats:\\n try:\\n idx = rand_selection.pop()\\n p = dict(zip(p_names, posteriors[idx]))\\n if offset:\\n p = {**p, **offset}\\n output = get_output(\\n model_name,\\n p,\\n times,\\n input_data,\\n d0,\\n targets,\\n distance=distance,\\n zero_flag=zero_flag)\\n outputs_list.append(output)\\n print(\\\"Sample {}, idx:{}\\\".format(len(outputs_list), idx))\\n\\n except (TimeoutError, TimeoutExpired) as e:\\n print(\\\"Timed out for Sample {}, idx:{}\\\".format(\\n len(outputs_list), idx))\\n pprint.pprint(p)\\n rand_selection.insert(0, idx)\\n except (CalledProcessError) as e:\\n print(\\\"CalledProcessError for Sample {}, idx:{}\\\".format(\\n len(outputs_list), idx))\\n pprint.pprint(p)\\n rand_selection.insert(0, idx)\\n\\n d = {\\\"Errors\\\": {}, \\\"Outputs\\\": {}}\\n d['Errors']['Average'] = np.nanmean(\\n [o[0]['TOTAL'] for o in outputs_list])\\n for target in targets:\\n d['Errors'][target] = np.nanmean(\\n [o[0][target] for o in outputs_list])\\n d['Outputs'][target] = [o[1][target] for o in outputs_list]\\n\\n for ii, target in enumerate(targets):\\n x = [j for j in times for n in range(len(d['Outputs'][target]))]\\n with Timer('Transposing {}'.format(target)):\\n y = np.array(d['Outputs'][target]).transpose()\\n y = y.ravel()\\n with Timer(\\\"Crafting DataFrame for {}\\\".format(target)):\\n model_name_col = [neonate]*len(x)\\n target_col = [target]*len(x)\\n df1 = pd.DataFrame(\\n {\\\"Time\\\": x, \\\"Posterior\\\": y, \\\"Neonate\\\": model_name_col, \\\"Output\\\": target_col})\\n with Timer(\\\"Appending dataframe for {}\\\".format(target)):\\n df_list.append(df1.copy())\\n del df1\\n return pd.concat(df_list), true_data\",\n \"def run_attributes (ins, exp, run) :\\n t0_sec = time()\\n list_of_dicts = experiment_info.run_attributes(ins, exp, run)\\n #print 'run_attributes for %s %s run:%d, t(sec) = %f' % (ins, exp, run, time()-t0_sec)\\n return list_of_dicts\",\n \"def list_of_runnums (ins, exp) :\\n try : expruns = experiment_info.experiment_runs(ins, exp)\\n #if exp == 'xcs83814' : return []\\n except : return []\\n\\n return [int(rec['num']) for rec in expruns]\\n #runs = experiment_info.experiment_runs(ins, exp)\\n #lst = []\\n #for rec in runs :\\n # lst.append( int(rec['num']) )\\n #return lst\",\n \"def classify():\\n yes_dataset = df[df[\\\"_class\\\"] == 1] # 470588\\n no_dataset = df[df[\\\"_class\\\"] == 0] # 1971\\n\\n parameter_analysis = list()\\n for criterion in np.arange(0.05, 0.91, 0.05):\\n print(\\\"doing experiment at criterion = %s ...\\\" % criterion)\\n rate_list = list()\\n for i in range(10):\\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\\n yes_index = yes_dataset.index.tolist()\\n random.shuffle(yes_index)\\n no_index = no_dataset.index.tolist()\\n random.shuffle(no_index)\\n \\n # concatenate 90%yes + 90%no, 10%yes + 10%no\\n train = pd.concat([\\n yes_dataset.loc[yes_index[:1774], :],\\n no_dataset.loc[no_index[:423530], :]\\n ])\\n test = pd.concat([\\n yes_dataset.loc[yes_index[1774:], :],\\n no_dataset.loc[no_index[423530:], :]\\n ]) \\n \\n # split data and label\\n train_data, train_label = (train[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n train[\\\"_class\\\"])\\n test_data, test_label = (test[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n test[\\\"_class\\\"])\\n \\n # apply classifier\\n clf = GaussianNB()\\n clf.fit(train_data, train_label)\\n probability = clf.predict_proba(test_data).T[1]\\n \\n result = pd.DataFrame()\\n result[\\\"_class\\\"] = test_label\\n result[\\\"_predict\\\"] = probability >= criterion\\n \\n result_yes = result[result[\\\"_class\\\"] == 1]\\n yes_yes_rate = sum(result_yes[\\\"_class\\\"] == result_yes[\\\"_predict\\\"])/len(result_yes[\\\"_predict\\\"])\\n \\n result_no = result[result[\\\"_class\\\"] == 0]\\n no_no_rate = sum(result_no[\\\"_class\\\"] == result_no[\\\"_predict\\\"])/len(result_no[\\\"_predict\\\"])\\n \\n rate_list.append((yes_yes_rate, no_no_rate))\\n\\n rate_list = pd.DataFrame(rate_list)\\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\\n \\n # save data to excel spreadsheet\\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\\\"criterion\\\", \\\"yes_yes_rate\\\", \\\"no_no_rate\\\"])\\n writer = pd.ExcelWriter(\\\"parameter_analysis.xlsx\\\")\\n parameter_analysis.to_excel(writer, \\\"parameter_analysis\\\", index=False)\\n writer.save()\",\n \"def estimator(dataset, routine, n_neighbors=5, n_runs=1, n_resamplings=10):\\r\\n\\troutine_length = len(routine)\\r\\n\\testimates = []\\t\\r\\n\\tX = np.ones((routine_length, 2))\\r\\n\\tX[:, 0] = [np.log(x) for x in routine]\\r\\n\\tfor _ in range(n_runs):\\r\\n\\t\\tmean_lengths = np.zeros(routine_length)\\r\\n\\t\\tfor index, n_points in enumerate(routine):\\r\\n\\t\\t\\tmean_lengths[index] = np.log(mean_sample_length(dataset, n_points, n_neighbors, n_resamplings)) \\r\\n\\t\\tmodel = LinearRegression().fit(X, mean_lengths)\\r\\n\\t\\testimates.append(1/(1-model.coef_[0]))\\r\\n\\treturn int(round(sum(estimates)/n_runs))\",\n \"def arb_units(wb_run,sample_run,ei_guess,rebin,map_file,**kwargs):\\n global reducer, rm_zero,inst_name,van_mass,bleed_switch,rate,pixels\\n print 'DGreduce run for ',inst_name,'run number ',sample_run\\n try:\\n n,r=funcreturns.lhs_info('both')\\n #n,r=lhs('both')\\n wksp_out=r[0]\\n except:\\n if sample_run == 0:\\n #deal with the current run being parsed as 0 rather than 00000\\n sample_run='00000'\\n wksp_out=inst_name+str(sample_run)+'.spe'\\n if kwargs.has_key('sum') and kwargs.get('sum')==True:\\n wksp_out=inst_name+str(sample_run[0])+'sum'+'.spe'\\n \\n start_time=time.time()\\n \\n if sample_run=='00000' and mtd.doesExist(inst_name+'00000.raw')==True:\\n print 'Deleteing previous instance of temp data'\\n DeleteWorkspace(Workspace=inst_name+'00000.raw')\\n \\n #repopulate defualts\\n if kwargs.has_key('norm_method'):\\n reducer.normalise_method = kwargs.get('norm_method')\\n print 'Setting normalisation method to ', kwargs.get('norm_method')\\n else:\\n reducer.normalise_method = 'monitor-1'\\n if kwargs.has_key('mask_run'):\\n mask_run = kwargs.get('mask_run')\\n print 'Using run ', kwargs.get('mask_run'),' for diag'\\n else:\\n mask_run=sample_run\\n \\n if kwargs.has_key('background'):\\n reducer.background = kwargs.get('background')\\n print 'Setting background option to ', kwargs.get('background')\\n else:\\n reducer.background = False\\n \\n if kwargs.has_key('fixei'):\\n reducer.fix_ei = kwargs.get('fixei')\\n print 'Setting fixei to ', kwargs.get('fixei')\\n else:\\n reducer.fix_ei = False\\n \\n if kwargs.has_key('save_format'):\\n reducer.save_formats = kwargs.get('save_format')\\n print 'Setting save format to ', kwargs.get('save_format')\\n else:\\n reducer.save_formats = ['.spe']\\n #Set parameters for the run\\n \\n if kwargs.has_key('detector_van_range'):\\n reducer.wb_integr_range = kwargs.get('detector_van_range')\\n print 'Setting detector van int range to ', kwargs.get('detector_van_range')\\n else:\\n reducer.wb_integr_range=[20,100]\\n #-------------DIAG------------------------\\n if kwargs.has_key('bkgd_range'):\\n background_range = kwargs.get('bkgd_range')\\n print 'Setting background intergration to ', kwargs.get('bkgd_range')\\n else:\\n background_range=[15000,19000]\\n \\n if kwargs.has_key('tiny'):\\n tinyval = kwargs.get('tiny')\\n print 'Setting tiny ratelimit to ', kwargs.get('tiny')\\n else:\\n tinyval=1e-10\\n \\n if kwargs.has_key('large'):\\n largeval = kwargs.get('large')\\n print 'Setting large limit to ', kwargs.get('large')\\n else:\\n largeval=1e10\\n \\n if kwargs.has_key('diag_remove_zero'):\\n sampzero = kwargs.get('diag_remove_zero')\\n print 'Setting diag to reject zero backgrounds '\\n else:\\n sampzero =False\\n \\n if kwargs.has_key('diag_van_median_rate_limit_hi'):\\n vanouthi = kwargs.get('diag_van_median_rate_limit_hi')\\n print 'Setting diag_van_median_rate_limit_hi to ', kwargs.get('diag_van_median_rate_limit_hi')\\n else:\\n vanouthi=100\\n \\n if kwargs.has_key('diag_van_median_rate_limit_lo'):\\n vanoutlo = kwargs.get('diag_van_median_rate_limit_lo')\\n print 'Setting diag_van_median_rate_limit_lo to ', kwargs.get('diag_van_median_rate_limit_lo')\\n else:\\n vanoutlo=0.01\\n \\n if kwargs.has_key('diag_van_median_sigma_lo'):\\n vanlo = kwargs.get('diag_van_median_sigma_lo')\\n print 'Setting diag_van_median_sigma_lo to ', kwargs.get('diag_van_median_sigma_lo')\\n else:\\n vanlo=0.1\\n \\n if kwargs.has_key('diag_van_median_sigma_hi'):\\n vanhi = kwargs.get('diag_van_median_sigma_hi')\\n print 'Setting diag_van_median_sigma_hi to ', kwargs.get('diag_van_median_sigma_hi')\\n else:\\n vanhi=1.5\\n \\n if kwargs.has_key('diag_van_median_sigma'):\\n vansig = kwargs.get('diag_van_median_sigma')\\n print 'Setting diag_van_median_sigma to ', kwargs.get('diag_van_median_sigma')\\n else:\\n vansig=0.0\\n \\n if kwargs.has_key('diag_samp_median_sigma_lo'):\\n samplo = kwargs.get('diag_samp_median_sigma_lo')\\n print 'Setting diag_samp_median_sigma_lo to ', kwargs.get('diag_samp_median_sigma_lo')\\n else:\\n samplo=0.0\\n \\n if kwargs.has_key('diag_samp_median_sigma_hi'):\\n samphi = kwargs.get('diag_samp_median_sigma_hi')\\n print 'Setting diag_samp_median_sigma_hi to ', kwargs.get('diag_samp_median_sigma_hi')\\n else:\\n samphi=2.0\\n \\n if kwargs.has_key('diag_samp_median_sigma'):\\n sampsig = kwargs.get('diag_samp_median_sigma')\\n print 'Setting diag_samp_median_sigma to ', kwargs.get('diag_samp_median_sigma')\\n else:\\n sampsig=3.0\\n \\n if kwargs.has_key('bleed'):\\n bleed_switch = kwargs.get('bleed')\\n print 'Setting bleed ', kwargs.get('bleed')\\n else:\\n print 'bleed set to default'\\n #---------------END of DIAG--------------------\\n if kwargs.has_key('det_cal_file'):\\n reducer.det_cal_file = kwargs.get('det_cal_file')\\n reducer.relocate_dets = True\\n print 'Setting detector calibration file to ', kwargs.get('det_cal_file')\\n else:\\n print 'Setting detector calibration to detector block info from ', sample_run\\n reducer.det_cal_file =None\\n reducer.relocate_dets = False\\n \\n if mtd.doesExist(str(sample_run))==True and kwargs.has_key('det_cal_file')==False:\\n print 'For data input type: workspace detector calibration must be specified'\\n print 'use Keyword det_cal_file with a valid detctor file or run number'\\n return\\n \\n \\n \\n if kwargs.has_key('one2one'):\\n reducer.map_file =None\\n print 'one2one selected'\\n \\n else:\\n fileName, fileExtension = os.path.splitext(map_file)\\n if (not fileExtension):\\n map_file=map_file+'.map' \\n reducer.map_file = map_file\\n\\n reducer.energy_bins = rebin\\n \\n if float(str.split(rebin,',')[2])>=float(ei_guess):\\n print 'error rebin range exceeds ei'\\n return\\n \\n print 'output will be normalised to', reducer.normalise_method\\n if (numpy.size(sample_run)) > 1 and kwargs.has_key('sum') and kwargs.get('sum')==True:\\n #this sums the runs together before passing the summed file to the rest of the reduction\\n #this circumvents the inbuilt method of summing which fails to sum the files for diag\\n \\n sumfilename=str(sample_run[0])+'sum'\\n accum=sum_files(sumfilename, sample_run)\\n #the D.E.C. tries to be too clever so we have to fool it into thinking the raw file is already exists as a workpsace\\n RenameWorkspace(InputWorkspace=accum,OutputWorkspace=inst_name+str(sample_run[0])+'.raw')\\n sample_run=sample_run[0]\\n \\n if kwargs.has_key('hardmaskPlus'):\\n HardMaskFile = kwargs.get('hardmaskPlus')\\n print 'Use hardmask from ', HardMaskFile\\n #hardMaskSpec=common.load_mask(HardMaskFile)\\n #MaskDetectors(Workspace='masking',SpectraList=hardMaskSpec)\\n else:\\n HardMaskFile=None\\n \\n if kwargs.has_key('hardmaskOnly'):\\n totalmask = kwargs.get('hardmaskOnly')\\n print 'Using hardmask from ', totalmask\\n #next stable version can replace this with loadmask algoritum\\n specs=diag_load_mask(totalmask)\\n CloneWorkspace(InputWorkspace=sample_run,OutputWorkspace='mask_wksp')\\n MaskDetectors(Workspace='mask_wksp',SpectraList=specs)\\n masking=mtd['mask_wksp']\\n else:\\n \\n masking = reducer.diagnose(wb_run, \\n sample=mask_run,\\n second_white = None,\\n tiny=tinyval, \\n huge=largeval, \\n van_out_lo=vanoutlo,\\n van_out_hi=vanouthi,\\n van_lo=vanlo,\\n van_hi=vanhi,\\n van_sig=vansig,\\n samp_zero=sampzero,\\n samp_lo=samplo,\\n samp_hi=samphi,\\n samp_sig=sampsig,\\n bkgd_range=background_range, \\n variation=1.1,\\n print_results=True,\\n bleed_test=bleed_switch,\\n bleed_maxrate=rate,\\n bleed_pixels=pixels,\\n hard_mask=HardMaskFile)\\n \\n reducer.spectra_masks=masking\\n #fail_list=get_failed_spectra_list(masking)\\n fail_list,n_total_spectra =get_failed_spectra_list_from_masks(masking)\\n \\n print 'Diag found ', len(fail_list),'bad spectra'\\n \\n #Run the conversion\\n deltaE_wkspace = reducer.convert_to_energy(sample_run, ei_guess, wb_run)\\n end_time=time.time()\\n results_name=str(sample_run)+'.spe'\\n \\n ei= (deltaE_wkspace.getRun().getLogData(\\\"Ei\\\").value)\\n \\n if mtd.doesExist('_wksp.spe-white')==True:\\n DeleteWorkspace(Workspace='_wksp.spe-white')\\n \\n if mtd.doesExist(results_name)==False:\\n RenameWorkspace(InputWorkspace=deltaE_wkspace,OutputWorkspace=results_name)\\n \\n print 'Incident energy found ',ei,' meV'\\n print 'Elapsed time =',end_time-start_time, 's'\\n #get the name that convert to energy will use\\n \\n \\n RenameWorkspace(InputWorkspace=results_name,OutputWorkspace=wksp_out)\\n \\n return mtd[wksp_out]\",\n \"def generate_run_data(session, run, baseurl, num_comparison_runs=0,\\n result=None, compare_to=None, baseline=None,\\n aggregation_fn=lnt.util.stats.safe_min,\\n confidence_lv=.05, styles=dict(), classes=dict()):\\n assert num_comparison_runs >= 0\\n\\n start_time = time.time()\\n\\n ts = run.testsuite\\n machine = run.machine\\n machine_parameters = machine.parameters\\n\\n if baseline is None:\\n # If a baseline has not been given, look up the run closest to\\n # the default baseline revision for which this machine also\\n # reported.\\n baseline = machine.get_baseline_run(session)\\n\\n # If the baseline is the same as the comparison run, ignore it.\\n visible_note = None\\n if baseline is compare_to:\\n visible_note = \\\"Baseline and compare_to are the same: \\\" \\\\\\n \\\"disabling baseline.\\\"\\n baseline = None\\n\\n # Gather the runs to use for statistical data.\\n comparison_start_run = compare_to or run\\n comparison_window = list(ts.get_previous_runs_on_machine(\\n session, comparison_start_run, num_comparison_runs))\\n if baseline:\\n baseline_window = list(ts.get_previous_runs_on_machine(\\n session, baseline, num_comparison_runs))\\n else:\\n baseline_window = []\\n\\n # If we don't have an explicit baseline run or a comparison run, use the\\n # previous run.\\n if compare_to is None and comparison_window:\\n compare_to = comparison_window[0]\\n\\n # Create the run info analysis object.\\n runs_to_load = set(r.id for r in comparison_window)\\n for r in baseline_window:\\n runs_to_load.add(r.id)\\n runs_to_load.add(run.id)\\n if compare_to:\\n runs_to_load.add(compare_to.id)\\n if baseline:\\n runs_to_load.add(baseline.id)\\n sri = lnt.server.reporting.analysis.RunInfo(\\n session, ts, runs_to_load, aggregation_fn, confidence_lv)\\n\\n # Get the test names, metric fields and total test counts.\\n test_names = session.query(ts.Test.name, ts.Test.id).\\\\\\n order_by(ts.Test.name).\\\\\\n filter(ts.Test.id.in_(sri.test_ids)).all()\\n metric_fields = list(ts.Sample.get_metric_fields())\\n num_total_tests = len(metric_fields) * len(test_names)\\n\\n # Gather the run-over-run changes to report, organized by field and then\\n # collated by change type.\\n run_to_run_info, test_results = _get_changes_by_type(\\n ts, run, compare_to, metric_fields, test_names, num_comparison_runs,\\n sri)\\n\\n # If we have a baseline, gather the run-over-baseline results and\\n # changes.\\n if baseline:\\n run_to_baseline_info, baselined_results = _get_changes_by_type(\\n ts, run, baseline, metric_fields, test_names, num_comparison_runs,\\n sri)\\n else:\\n run_to_baseline_info = baselined_results = None\\n\\n # Gather the run-over-run changes to report.\\n\\n # Collect the simplified results, if desired, for sending back to clients.\\n if result is not None:\\n pset_results = []\\n result['test_results'] = [{'pset': (), 'results': pset_results}]\\n for field, field_results in test_results:\\n for _, bucket, _ in field_results:\\n for name, cr, _ in bucket:\\n # FIXME: Include additional information about performance\\n # changes.\\n pset_results.append((\\\"%s.%s\\\" % (name, field.name),\\n cr.get_test_status(),\\n cr.get_value_status()))\\n\\n # Aggregate counts across all bucket types for our num item\\n # display\\n def aggregate_counts_across_all_bucket_types(i, name):\\n num_items = sum(len(field_results[i][1])\\n for _, field_results in test_results)\\n if baseline:\\n num_items_vs_baseline = sum(\\n len(field_results[i][1])\\n for _, field_results in baselined_results)\\n else:\\n num_items_vs_baseline = None\\n\\n return i, name, num_items, num_items_vs_baseline\\n\\n num_item_buckets = [aggregate_counts_across_all_bucket_types(x[0], x[1][0])\\n for x in enumerate(test_results[0][1])]\\n\\n def maybe_sort_bucket(bucket, bucket_name, show_perf):\\n if not bucket or bucket_name == 'Unchanged Test' or not show_perf:\\n return bucket\\n else:\\n return sorted(\\n bucket,\\n key=lambda bucket_entry: -abs(bucket_entry.cr.pct_delta))\\n\\n def prioritize_buckets(test_results):\\n prioritized = [(priority, field, bucket_name,\\n maybe_sort_bucket(bucket, bucket_name, show_perf),\\n [name for name, _, __ in bucket], show_perf)\\n for field, field_results in test_results\\n for priority, (bucket_name, bucket,\\n show_perf) in enumerate(field_results)]\\n prioritized.sort(key=lambda item: (item[0], item[1].name))\\n return prioritized\\n\\n # Generate prioritized buckets for run over run and run over baseline data.\\n prioritized_buckets_run_over_run = prioritize_buckets(test_results)\\n if baseline:\\n prioritized_buckets_run_over_baseline = \\\\\\n prioritize_buckets(baselined_results)\\n else:\\n prioritized_buckets_run_over_baseline = None\\n\\n # Prepare auxillary variables for rendering.\\n # Create Subject\\n subject = \\\"\\\"\\\"%s test results\\\"\\\"\\\" % (machine.name,)\\n\\n # Define URLS.\\n if baseurl[-1] == '/':\\n baseurl = baseurl[:-1]\\n ts_url = \\\"\\\"\\\"%s/v4/%s\\\"\\\"\\\" % (baseurl, ts.name)\\n run_url = \\\"\\\"\\\"%s/%d\\\"\\\"\\\" % (ts_url, run.id)\\n report_url = run_url\\n url_fields = []\\n if compare_to:\\n url_fields.append(('compare_to', str(compare_to.id)))\\n if baseline:\\n url_fields.append(('baseline', str(baseline.id)))\\n report_url = \\\"%s?%s\\\" % (run_url, \\\"&\\\".join(\\\"%s=%s\\\" % (k, v)\\n for k, v in url_fields))\\n\\n # Compute static CSS styles for elemenets. We use the style directly on\\n # elements instead of via a stylesheet to support major email clients (like\\n # Gmail) which can't deal with embedded style sheets.\\n #\\n # These are derived from the static style.css file we use elsewhere.\\n #\\n # These are just defaults however, and the caller can override them with\\n # the 'styles' and 'classes' kwargs.\\n styles_ = {\\n \\\"body\\\": (\\\"color:#000000; background-color:#ffffff; \\\"\\n \\\"font-family: Helvetica, sans-serif; font-size:9pt\\\"),\\n \\\"h1\\\": (\\\"font-size: 14pt\\\"),\\n \\\"table\\\": \\\"font-size:9pt; border-spacing: 0px; border: 1px solid black\\\",\\n \\\"th\\\": (\\\"background-color:#eee; color:#666666; font-weight: bold; \\\"\\n \\\"cursor: default; text-align:center; font-weight: bold; \\\"\\n \\\"font-family: Verdana; padding:5px; padding-left:8px\\\"),\\n \\\"td\\\": \\\"padding:5px; padding-left:8px\\\",\\n }\\n classes_ = {\\n }\\n\\n styles_.update(styles)\\n classes_.update(classes)\\n\\n data = {\\n 'ts': ts,\\n 'subject': subject,\\n 'report_url': report_url,\\n 'ts_url': ts_url,\\n 'compare_to': compare_to,\\n 'run': run,\\n 'run_url': run_url,\\n 'baseline': baseline,\\n 'machine': machine,\\n 'machine_parameters': machine_parameters,\\n 'num_item_buckets': num_item_buckets,\\n 'num_total_tests': num_total_tests,\\n 'run_to_run_info': run_to_run_info,\\n 'prioritized_buckets_run_over_run': prioritized_buckets_run_over_run,\\n 'run_to_baseline_info': run_to_baseline_info,\\n 'prioritized_buckets_run_over_baseline':\\n prioritized_buckets_run_over_baseline,\\n 'styles': styles_,\\n 'classes': classes_,\\n 'start_time': start_time,\\n 'sri': sri,\\n 'visible_note': visible_note,\\n }\\n return data\",\n \"def main():\\n\\tresults = []\\n\\n\\tconfig = configparser.ConfigParser()\\n\\tconfig.read(\\\"simulation.ini\\\")\\n\\tsettings = config['sim']\\n\\n\\tcompleted_obj_hw = int(settings[\\\"ClientsPerCampaign\\\"]) * float(settings[\\\"CompletedPctgHW\\\"])\\n\\texceeded_obj_hw = float(settings[\\\"ExceededPctgHW\\\"])\\n\\tsignificance_level = float(settings[\\\"SignificanceLevel\\\"])\\n\\tz_val_two_tails = scipy.stats.norm.ppf(1 - (significance_level / 2))\\n\\n\\tprint(\\\"Completed Target HW: \\\" + str(completed_obj_hw))\\n\\tprint(\\\"Exceeded Target HW: \\\" + str(exceeded_obj_hw))\\n\\n\\tcompleted_vals = []\\n\\texceeded_vals = []\\n\\tdone = False\\n\\n\\tcompleted_avg = 0\\n\\texceeded_avg = 0\\n\\tcompleted_hw = 0\\n\\texceeded_hw = 0\\n\\n\\ti = 0\\n\\twhile not done:\\n\\t\\tprint(\\\"RUN: \\\" + str(i + 1))\\n\\t\\tenv = simpy.Environment()\\n\\t\\tsim = Simulation(env, settings, i == 0)\\n\\t\\tsim.run()\\n\\t\\tresults.append(sim.results)\\n\\t\\ti += 1\\n\\n\\t\\tif settings['RunOnce'] == 'yes':\\n\\t\\t\\tprint(\\\"RUN ONCE\\\")\\n\\t\\t\\tsys.exit()\\n\\n\\t\\tcompleted_vals.append(sim.results['completed_count'])\\n\\t\\texceeded_vals.append(sim.results['exceeded_proportion'])\\n\\n\\t\\tif i < 2:\\n\\t\\t\\tprint(\\\"---------------\\\")\\n\\t\\t\\tcontinue\\n\\n\\t\\tcompleted_avg = sum(completed_vals) / len(completed_vals)\\n\\t\\tcompleted_S = sum([(v - completed_avg) ** 2 for v in completed_vals]) / (i - 1)\\n\\t\\tcompleted_S = math.sqrt(completed_S)\\n\\t\\tcompleted_hw = (z_val_two_tails * completed_S) / math.sqrt(i)\\n\\t\\tprint(\\\"runs: \\\" + str(i) + \\\" completed HW: \\\" + str(completed_hw))\\n\\n\\t\\texceeded_avg = sum(exceeded_vals) / len(exceeded_vals)\\n\\t\\texceeded_S = math.sqrt(exceeded_avg * (1 - exceeded_avg))\\n\\t\\texceeded_hw = (z_val_two_tails * exceeded_S) / math.sqrt(i)\\n\\t\\tprint(\\\"runs: \\\" + str(i) + \\\" exceeded HW: \\\" + str(exceeded_hw))\\n\\n\\t\\tif completed_hw < completed_obj_hw and exceeded_hw < exceeded_obj_hw:\\n\\t\\t\\tprint(\\\"END ITERATIONS\\\")\\n\\t\\t\\tdone = True\\n\\n\\t\\tprint(\\\"---------------\\\")\\n\\n\\n\\tfilename = 'results/Results_' + settings['FileSizeGB'] + '_' + settings['TorrentThreshold'] + '_' + settings['HTTPDownThreshold'] \\\\\\n\\t\\t+ '_' + settings['HTTPUp'] + '_' + str(random.randint(0,10000)) + '.xlsx'\\n\\n\\tprint(\\\"Saving XLSX to: \\\" + filename)\\n\\twb = xs.Workbook(filename)\\n\\n\\tws = wb.add_worksheet()\\n\\n\\tws.write(0, 1, 'Exceded')\\n\\tws.write(0, 2, 'Completed')\\n\\n\\ti = 1\\n\\tfor result in results:\\n\\t\\tws.write(i, 0, i)\\n\\t\\tws.write(i, 1, result['exceeded_proportion'])\\n\\t\\tws.write(i, 2, result['completed_count'])\\n\\t\\ti += 1\\n\\n\\tws.write(i, 0, 'average')\\n\\tws.write(i, 1, exceeded_avg)\\n\\tws.write(i, 2, completed_avg)\\n\\ti += 1\\n\\tws.write(i, 0, 'half width')\\n\\tws.write(i, 1, exceeded_hw)\\n\\tws.write(i, 2, completed_hw)\\n\\n\\twb.close()\",\n \"def print_run_perfs(verbose_dico):\\n for item_strat, v1 in verbose_dico.items():\\n print(item_strat)\\n list_of_perfs = []\\n list_of_prints = []\\n for skill_strat, v2 in v1.items():\\n list_of_params = []\\n acpl_perfs = []\\n acpr_perfs = []\\n for param_value, v3 in v2.items():\\n list_of_params.append(param_value)\\n for period, v4 in v3.items():\\n strat_perf = np.mean(verbose_dico[item_strat][skill_strat][param_value][period])\\n if period == \\\"learning\\\":\\n acpl_perfs.append(strat_perf)\\n if period == \\\"retention\\\":\\n acpr_perfs.append(strat_perf)\\n # Find best parameters\\n best_param_index = np.argmax(acpr_perfs)\\n list_of_perfs.append(np.around(acpr_perfs[best_param_index],3))\\n list_of_prints.append(\\\"\\\\t {0:>26} | Best param : {1:>3} | ACPL = {2:>6} | ACPR = {3:>6}\\\".format(skill_strat,\\n np.around(list_of_params[best_param_index],2),\\n np.around(acpl_perfs[best_param_index],3),\\n np.around(acpr_perfs[best_param_index],3)))\\n for strat_index in np.argsort(list_of_perfs)[::-1]:\\n print(list_of_prints[strat_index])\",\n \"def multiple_runs(self, n: int, **kwargs: tp.Any) -> tp.Dict[str, tp.List[tp.Tuple[ARR, ARR]]]:\\n predictions = [self.single_run(**kwargs) for i in range(n)]\\n return {\\n 'train': [pred['train'] for pred in predictions],\\n 'test': [pred['test'] for pred in predictions]\\n }\",\n \"def create_trials(self):\\n self.trial_list=[]\\n \\n #simple tools to check subject responses online\\n self.correct_responses = 0\\n self.total_responses = 0\\n self.dot_count = 0\\n \\n bar_orientations = np.array(self.settings['PRF stimulus settings']['Bar orientations'])\\n #create as many trials as TRs. 5 extra TRs at beginning + bar passes + blanks\\n self.trial_number = 5 + self.settings['PRF stimulus settings']['Bar pass steps']*len(np.where(bar_orientations != -1)[0]) + self.settings['PRF stimulus settings']['Blanks length']*len(np.where(bar_orientations == -1)[0])\\n \\n print(\\\"Expected number of TRs: %d\\\"%self.trial_number)\\n #create bar orientation list at each TR (this can be done in many different ways according to necessity)\\n #for example, currently blank periods have same length as bar passes. this can easily be changed here\\n steps_array=self.settings['PRF stimulus settings']['Bar pass steps']*np.ones(len(bar_orientations))\\n blanks_array=self.settings['PRF stimulus settings']['Blanks length']*np.ones(len(bar_orientations))\\n \\n repeat_times=np.where(bar_orientations == -1, blanks_array, steps_array).astype(int)\\n \\n self.bar_orientation_at_TR = np.concatenate((-1*np.ones(5), np.repeat(bar_orientations, repeat_times)))\\n \\n \\n #calculation of positions depend on whether code is run on mac\\n if self.settings['operating system'] == 'mac':\\n bar_pos_array = (self.win.size[1]/2)*np.linspace(-0.5,0.5, self.settings['PRF stimulus settings']['Bar pass steps'])\\n else:\\n bar_pos_array = self.win.size[1]*np.linspace(-0.5,0.5, self.settings['PRF stimulus settings']['Bar pass steps'])\\n \\n \\n blank_array = np.zeros(self.settings['PRF stimulus settings']['Blanks length'])\\n \\n #the 5 empty trials at beginning\\n self.bar_pos_in_ori=np.zeros(5)\\n \\n #bar position at TR\\n for i in range(len(bar_orientations)):\\n if bar_orientations[i]==-1:\\n self.bar_pos_in_ori=np.append(self.bar_pos_in_ori, blank_array)\\n else:\\n self.bar_pos_in_ori=np.append(self.bar_pos_in_ori, bar_pos_array)\\n \\n \\n #random bar direction at each step. could also make this time-based\\n self.bar_direction_at_TR = np.round(np.random.rand(self.trial_number))\\n \\n #trial list\\n for i in range(self.trial_number):\\n \\n self.trial_list.append(PRFTrial(session=self,\\n trial_nr=i,\\n \\n bar_orientation=self.bar_orientation_at_TR[i],\\n bar_position_in_ori=self.bar_pos_in_ori[i],\\n bar_direction=self.bar_direction_at_TR[i]\\n #,tracker=self.tracker\\n ))\\n\\n\\n #times for dot color change. continue the task into the topup\\n self.total_time = self.trial_number*self.bar_step_length \\n \\n if self.settings['mri']['topup_scan']==True:\\n self.total_time += self.topup_scan_duration\\n \\n \\n #DOT COLOR CHANGE TIMES \\n self.dot_switch_color_times = np.arange(3, self.total_time, float(self.settings['Task settings']['color switch interval']))\\n self.dot_switch_color_times += (2*np.random.rand(len(self.dot_switch_color_times))-1)\\n \\n \\n #needed to keep track of which dot to print\\n self.current_dot_time=0\\n self.next_dot_time=1\\n\\n #only for testing purposes\\n np.save(opj(self.output_dir, self.output_str+'_DotSwitchColorTimes.npy'), self.dot_switch_color_times)\\n print(self.win.size)\",\n \"def _get_initial_run_stats(self):\\r\\n return OrderedDict([('linesWithRecommendations', 0),\\r\\n ('linesAnalyzed', 0),\\r\\n ('linesRead', 0),\\r\\n ('dexTime', datetime.utcnow()),\\r\\n ('logSource', None),\\r\\n ('timeRange', OrderedDict([('start', None),\\r\\n ('end', None)])),\\r\\n ('unparsableLineInfo', OrderedDict([('unparsableLines', 0),\\r\\n ('unparsableLinesWithoutTime', 0),\\r\\n ('unparsableLinesWithTime', 0),\\r\\n ('unparsedTimeMillis', 0),\\r\\n ('unparsedAvgTimeMillis', 0)]))])\",\n \"def train_multiple_runs(self, env, runs=3, ts_max=10000, horizon=1000, lr=0.1):\\n\\t\\tr_mat = []\\n\\t\\tinfo = {}\\n\\t\\t\\n\\t\\tfor i in range(runs):\\n\\n\\t\\t\\t# Resetting agent to default before each run\\n\\t\\t\\tself.reset()\\n\\n\\t\\t\\t# Training the agent for ts_max\\n\\t\\t\\tr_vec = self.train_multiple_ts(env, ts_max=ts_max, horizon=horizon, lr=lr)\\n\\n\\t\\t\\t# Storing the results in a matrix\\n\\t\\t\\tr_mat.append(r_vec)\\n\\n\\t\\t# Finding the mean and standard deviation \\n\\t\\tinfo['mean'] = np.mean(np.array(r_mat), axis=0)\\n\\t\\tinfo['std'] = np.std(np.array(r_mat), axis=0)\\n\\n\\t\\treturn r_mat, info\",\n \"def runs(self):\\n return {\\n 'passed': self._runs_passed,\\n 'failed': self._runs_failed,\\n 'missed': self._runs_missed,\\n }\",\n \"def run_numbers():\\n if run_nos:\\n # Get task names\\n tasks = []\\n for rn in dcm_dict.keys():\\n tasks.append(dcm_dict[rn]['task_name'])\\n # Assign run numbers\\n for tsk in set(tasks):\\n n_runs = sum(i == tsk for i in tasks)\\n if n_runs == 1:\\n for rn in dcm_dict.keys():\\n if dcm_dict[rn]['task_name'] == tsk:\\n # Add in the 'task' prefix required by BIDS format if missing from name\\n if not tsk[0:4] == 'task':\\n dcm_dict[rn]['out_name'] = 'task-'+tsk+'_run-01'\\n else:\\n dcm_dict[rn]['out_name'] = tsk+'_run-01'\\n elif n_runs > 1:\\n task_runs = []\\n run_times = []\\n for rn in dcm_dict.keys():\\n if dcm_dict[rn]['task_name'] == tsk:\\n task_runs.append(rn)\\n run_times.append(dcm_dict[rn]['start_time'].timestamp())\\n idx_order = sorted(range(len(run_times)), key=lambda k: run_times[k])\\n for i in idx_order:\\n if not tsk[0:4] == 'task':\\n dcm_dict[task_runs[i]]['out_name'] = 'task-'+tsk+'_run-0'+str(i+1)\\n else:\\n dcm_dict[task_runs[i]]['out_name'] = tsk+'_run-0'+str(i+1)\\n else:\\n for rn in dcm_dict.keys():\\n dcm_dict[rn]['out_name'] = dcm_dict[rn]['task_name']\",\n \"def _output_summary(self, run_id):\\n time = self._summary.get_time_taken()\\n time_delta = None\\n num_tests_run_delta = None\\n num_failures_delta = None\\n values = [(\\\"id\\\", run_id, None)]\\n failures = self._summary.get_num_failures()\\n previous_summary = self._get_previous_summary()\\n if failures:\\n if previous_summary:\\n num_failures_delta = failures - previous_summary.get_num_failures()\\n values.append((\\\"failures\\\", failures, num_failures_delta))\\n if previous_summary:\\n num_tests_run_delta = self._summary.testsRun - previous_summary.testsRun\\n if time:\\n previous_time_taken = previous_summary.get_time_taken()\\n if previous_time_taken:\\n time_delta = time - previous_time_taken\\n skips = len(self._summary.skipped)\\n if skips:\\n values.append((\\\"skips\\\", skips, None))\\n output.output_summary(\\n not bool(failures),\\n self._summary.testsRun,\\n num_tests_run_delta,\\n time,\\n time_delta,\\n values,\\n output=self.stream,\\n )\",\n \"def target_portfolio_simulation(num_of_years=30, trials=100, method='normal'):\\n print(\\\"Running method target_portfolio_simulation()\\\")\\n\\n sim_fia_cv = pd.DataFrame(index=range(num_of_years + 1))\\n\\n sim_base_total = pd.DataFrame(index=range(num_of_years + 1))\\n sim_base_income = pd.DataFrame(index=range(num_of_years + 1))\\n\\n sim_port_total = pd.DataFrame(index=range(num_of_years + 1))\\n sim_port_income = pd.DataFrame(index=range(num_of_years + 1))\\n\\n read_income_inputs = pd.read_excel(src + \\\"portfolio_information.xlsx\\\", sheet_name='income_model_inputs',\\n index_col=[0])\\n\\n read_returns_est = pd.read_excel(src + \\\"portfolio_information.xlsx\\\", sheet_name='income_assets_returns_estimates',\\n index_col=[0])\\n\\n read_asset_weights = pd.read_excel(src + \\\"portfolio_information.xlsx\\\", sheet_name='asset_weights',\\n index_col=[0])\\n\\n # read_asset_weights.drop(read_asset_weights.index[-1], axis=0, inplace=True)\\n\\n # read random returns for simulation\\n read_normal = pd.read_csv(src + 'median_returns_unsorted.csv', index_col=[0], parse_dates=True)\\n cols = [read_normal.columns[c].split('_')[1] for c in np.arange(len(read_normal.columns))]\\n read_normal.rename(columns=dict(zip(list(read_normal.columns), cols)), inplace=True)\\n\\n read_small = pd.read_csv(src + 'median_returns_smallest.csv', index_col=[0], parse_dates=True)\\n read_small.rename(columns=dict(zip(list(read_small.columns), cols)), inplace=True)\\n\\n read_large = pd.read_csv(src + 'median_returns_largest.csv', index_col=[0], parse_dates=True)\\n read_large.rename(columns=dict(zip(list(read_large.columns), cols)), inplace=True)\\n\\n assets_col_names = list(read_normal.columns)\\n\\n tickers = list(read_asset_weights.index)\\n wts = np.array(read_asset_weights.loc[:, 'base'])\\n\\n def asset_median_returns(data, ticker):\\n return data.filter(regex=ticker).median(axis=1)\\n\\n # dataframe for unsorted returns (normal)\\n median_returns_normal = read_normal.copy()\\n median_returns_normal.loc[:, 'portfolio_return'] = median_returns_normal.dot(wts)\\n median_normal_fia = pd.DataFrame({'FIA': asset_median_returns(read_normal, 'FIA')})\\n\\n # dataframe for smallest to largest returns\\n median_returns_smallest = read_small.copy()\\n median_returns_smallest.loc[:, 'portfolio_return'] = median_returns_smallest.dot(wts)\\n median_smallest_fia = pd.DataFrame({'FIA': asset_median_returns(read_small, 'FIA')})\\n\\n # dataframe for largest to smallest returns\\n median_returns_largest = read_large.copy()\\n median_returns_largest.loc[:, 'portfolio_return'] = median_returns_largest.dot(wts)\\n median_largest_fia = pd.DataFrame({'FIA': asset_median_returns(read_large, 'FIA')})\\n\\n years = list(range(0, num_of_years + 1))\\n income_cols = ['year', 'strategy_term', 'index_returns', 'term_ret', 'term_ret_with_par', 'term_annualize',\\n 'ann_net_spread', 'term_ret_netspr', 'high_inc_benefit_base', 'rider_fee', 'eoy_income',\\n 'contract_value']\\n\\n term = int(read_income_inputs.loc['term', 'inputs'])\\n fia_ret = read_returns_est.loc[read_returns_est.index[-1], 'Annualized Returns']\\n fia_risk = read_returns_est.loc[read_returns_est.index[-1], 'Annualized Risk']\\n par_rate = float(read_income_inputs.loc['par_rate', 'inputs'])\\n spread = float(read_income_inputs.loc['spread', 'inputs'])\\n bonus_term = int(read_income_inputs.loc['bonus_term', 'inputs'])\\n premium = float(read_income_inputs.loc['premium', 'inputs'])\\n income_bonus = float(read_income_inputs.loc['income_bonus', 'inputs'])\\n\\n income_starts = int(read_income_inputs.loc['start_income_years', 'inputs'])\\n income_growth = float(read_income_inputs.loc['income_growth', 'inputs'])\\n rider_fee = float(read_income_inputs.loc['rider_fee', 'inputs'])\\n inc_payout_factor = float(read_income_inputs.loc['income_payout_factor', 'inputs'])\\n contract_bonus = float(read_income_inputs.loc['contract_bonus', 'inputs'])\\n social = float(read_income_inputs.loc['social', 'inputs'])\\n inflation = float(read_income_inputs.loc['inflation', 'inputs'])\\n wtd_cpn_yield = float(read_income_inputs.loc['wtd_coupon_yld', 'inputs'])\\n life_expectancy = int(read_income_inputs.loc['life_expectancy_age', 'inputs'])\\n clients_age = int(read_income_inputs.loc['clients_age', 'inputs'])\\n\\n # ---------------INCOME MODEL--------------------------------------------\\n runs = 0\\n returns_dict = {}\\n asset_dict = {}\\n fia_dict = {}\\n\\n income_df = pd.DataFrame(index=years, columns=income_cols)\\n income_df.loc[:, 'year'] = years\\n income_df.loc[:, 'strategy_term'] = income_df.loc[:, 'year'] % term\\n income_df.loc[:, 'strategy_term'] = income_df['strategy_term'].apply(lambda x: 1 if x == 0 else 0)\\n\\n if method == 'normal':\\n income_df.loc[:, 'index_returns'] = read_normal.loc[:, 'FIA']\\n\\n elif method == 'smallest':\\n income_df.loc[:, 'index_returns'] = read_small.loc[:, 'FIA']\\n\\n else:\\n income_df.loc[:, 'index_returns'] = read_large.loc[:, 'FIA']\\n\\n # income_df.loc[:, 'index_returns'] = np.random.normal(fia_ret, fia_risk, size=(len(years), 1))\\n\\n cumprod = (1. + income_df['index_returns']).rolling(window=term).agg(lambda x: x.prod()) - 1\\n income_df.loc[:, 'term_ret'] = np.where(income_df.loc[:, 'strategy_term'] == 1, cumprod, 0)\\n income_df.loc[:, 'term_ret_with_par'] = income_df.loc[:, 'term_ret'] * par_rate\\n income_df.loc[:, 'term_annualize'] = income_df.loc[:, 'term_ret_with_par'].apply(\\n lambda x: (1 + x) ** (1 / term) - 1)\\n income_df.loc[:, 'ann_net_spread'] = income_df.loc[:, 'term_annualize'] - spread\\n income_df.loc[:, 'ann_net_spread'] = np.where(income_df.loc[:, 'strategy_term'] == 1,\\n income_df.loc[:, 'ann_net_spread'], 0)\\n income_df.loc[:, 'term_ret_netspr'] = income_df.loc[:, 'ann_net_spread'].apply(lambda x: (1 + x) ** term - 1)\\n\\n for counter in years:\\n if counter == 0:\\n income_df.loc[counter, 'high_inc_benefit_base'] = premium * (1 + income_bonus)\\n\\n elif counter <= min(bonus_term, income_starts):\\n income_df.loc[counter, 'high_inc_benefit_base'] = income_df.loc[counter - 1, 'high_inc_benefit_base'] * \\\\\\n (1 + income_growth)\\n else:\\n income_df.loc[counter, 'high_inc_benefit_base'] = income_df.loc[counter - 1, 'high_inc_benefit_base']\\n\\n income_df.loc[:, 'rider_fee'] = income_df.loc[:, 'high_inc_benefit_base'] * rider_fee\\n income_df.loc[:, 'eoy_income'] = np.where(income_df.loc[:, 'year'] > income_starts,\\n income_df.loc[:, 'high_inc_benefit_base'] * inc_payout_factor, 0)\\n\\n for counter in years:\\n if counter == 0:\\n income_df.loc[counter, 'contract_value'] = premium * (1 + contract_bonus)\\n\\n elif income_df.loc[counter, 'strategy_term'] == 1:\\n x1 = income_df.loc[counter - 1, 'contract_value'] - income_df.loc[counter, 'rider_fee']\\n x2 = (x1 * (1 + income_df.loc[counter, 'term_ret_netspr'])) - income_df.loc[counter, 'eoy_income']\\n income_df.loc[counter, 'contract_value'] = x2\\n\\n else:\\n x1 = income_df.loc[counter - 1, 'contract_value'] - income_df.loc[counter, 'rider_fee'] - \\\\\\n income_df.loc[counter, 'eoy_income']\\n\\n income_df.loc[counter, 'contract_value'] = x1\\n\\n # variable stores the income number that is used in the base and fia portfolio calcs.\\n\\n income_from_fia = income_df.loc[income_df.index[-1], 'eoy_income']\\n\\n income_df.loc[:, 'contract_value'] = income_df.loc[:, 'contract_value'].apply(lambda x: 0 if x <= 0 else x)\\n\\n sim_fia_cv.loc[:, str(runs)] = income_df.loc[:, 'contract_value']\\n\\n # --------------------BASE MODEL---------------------------------------------\\n base_wts = read_asset_weights.loc[:, 'base']\\n base_assets = list(base_wts.index)\\n base_weights = list(base_wts.values)\\n base_returns = list(read_returns_est.loc[:, 'Annualized Returns'].values)\\n base_std = list(read_returns_est.loc[:, 'Annualized Risk'].values)\\n\\n base_investment = float(read_income_inputs.loc['risky_assets', 'Base'])\\n adv_fees = float(read_income_inputs.loc['advisor_fees', 'Base'])\\n\\n # -------------------required income----------------------------------\\n req_annual_income = float(read_income_inputs.loc['annual_income', 'inputs'])\\n income_needed = req_annual_income - social\\n income_net_fia_income = max(0, income_needed - income_from_fia)\\n cpn_income_base = base_investment * wtd_cpn_yield\\n\\n # ----------------------RANDOM RETURNS--------------------------\\n r_cols = base_assets\\n boy_value = ['bv_{}'.format(name) for name in base_assets]\\n eoy_value = ['ev_{}'.format(name) for name in base_assets]\\n\\n random_returns = pd.DataFrame(index=income_df.index, columns=r_cols)\\n\\n for c in range(len(r_cols)):\\n ret = np.random.normal(base_returns[c], base_std[c], size=(len(random_returns.index), 1))\\n\\n if method == 'smallest':\\n random_returns = read_small.copy()\\n\\n elif method == 'largest':\\n random_returns = read_large.copy()\\n\\n else:\\n random_returns = read_normal.copy()\\n\\n base_df = random_returns.copy()\\n fia_portfolio_df = random_returns.copy()\\n port_investment = float(read_income_inputs.loc['risky_assets', 'FIA'])\\n cpn_income_port = port_investment * wtd_cpn_yield\\n\\n # -------------BASE PORTFOLIO----------------------------\\n for name in boy_value:\\n base_df.loc[:, name] = 0.0\\n\\n for counter in years:\\n period_returns = list(random_returns.loc[counter, :])\\n if counter == 0:\\n\\n base_df.loc[counter, boy_value] = [base_weights[c] * base_investment for c in range(len(boy_value))]\\n\\n base_df.loc[counter, 'total'] = base_df.loc[counter, boy_value].sum()\\n base_df.loc[counter, 'total_net_fees'] = 0.0\\n base_df.loc[counter, 'income'] = 0.0\\n base_investment = base_df.loc[counter, boy_value].sum()\\n\\n elif (counter > 0) and (counter < income_starts):\\n\\n base_df.loc[counter, boy_value] = [base_weights[c] * base_investment * (1 + period_returns[c])\\n for c in range(len(boy_value))]\\n base_df.loc[counter, 'total'] = base_df.loc[counter, boy_value].sum()\\n base_df.loc[counter, 'adv_fees'] = base_df.loc[counter, 'total'] * adv_fees\\n base_df.loc[counter, 'total_net_fees'] = base_df.loc[counter, 'total'] - base_df.loc[\\n counter, 'adv_fees']\\n\\n # --coupon payment is invested back into the risky portfolio until the income is withdrawn----\\n base_investment = base_df.loc[counter, 'total_net_fees'] + cpn_income_base\\n\\n else:\\n\\n base_df.loc[counter, boy_value] = [base_weights[c] * base_investment * (1 + period_returns[c])\\n for c in range(len(boy_value))]\\n base_df.loc[counter, 'total'] = base_df.loc[counter, boy_value].sum()\\n base_df.loc[counter, 'adv_fees'] = base_df.loc[counter, 'total'] * adv_fees\\n\\n # ---req. income is adjusted for inflation from the second year of withdrawal. Reinvestment of coupon\\n # stops from the year income starts. Req. income is reduced by the coupon payments\\n\\n if counter == income_starts:\\n\\n income_needed = req_annual_income - social\\n base_df.loc[counter, 'income'] = income_needed - cpn_income_base\\n income_needed = req_annual_income\\n\\n else:\\n income_needed = income_needed * (1 + inflation) - social\\n base_df.loc[counter, 'income'] = income_needed - cpn_income_base\\n income_needed = income_needed + social\\n\\n base_df.loc[counter, 'total_net_fees'] = base_df.loc[counter, 'total'] - \\\\\\n base_df.loc[counter, 'adv_fees'] - \\\\\\n base_df.loc[counter, 'income']\\n\\n base_investment = base_df.loc[counter, 'total_net_fees']\\n\\n base_df.loc[:, 'adj_total'] = base_df.loc[:, 'total_net_fees'].apply(lambda x: x if x > 0 else 0)\\n sim_base_total.loc[:, 's_{}'.format(str(runs))] = base_df.loc[:, 'total_net_fees']\\n sim_base_income.loc[:, 's_{}'.format(str(runs))] = base_df.loc[:, 'income']\\n\\n # ----------------------------FIA PORTFOLIO----------------------------------------------\\n for name in boy_value:\\n fia_portfolio_df.loc[:, name] = 0.0\\n\\n for counter in years:\\n period_returns = list(random_returns.loc[counter, :])\\n if counter == 0:\\n\\n fia_portfolio_df.loc[counter, boy_value] = [base_weights[c] * port_investment\\n for c in range(len(boy_value))]\\n fia_portfolio_df.loc[counter, 'total'] = fia_portfolio_df.loc[counter, boy_value].sum()\\n fia_portfolio_df.loc[counter, 'total_net_fees'] = 0.0\\n fia_portfolio_df.loc[counter, 'income'] = 0.0\\n port_investment = fia_portfolio_df.loc[counter, boy_value].sum()\\n\\n elif (counter > 0) and (counter < income_starts):\\n\\n fia_portfolio_df.loc[counter, boy_value] = [base_weights[c] * port_investment * (1 + period_returns[c])\\n for c in range(len(boy_value))]\\n fia_portfolio_df.loc[counter, 'total'] = fia_portfolio_df.loc[counter, boy_value].sum()\\n fia_portfolio_df.loc[counter, 'adv_fees'] = fia_portfolio_df.loc[counter, 'total'] * adv_fees\\n fia_portfolio_df.loc[counter, 'total_net_fees'] = fia_portfolio_df.loc[counter, 'total'] - \\\\\\n fia_portfolio_df.loc[counter, 'adv_fees']\\n\\n port_investment = fia_portfolio_df.loc[counter, 'total_net_fees'] + cpn_income_port\\n\\n else:\\n fia_portfolio_df.loc[counter, boy_value] = [base_weights[c] * port_investment * (1 + period_returns[c])\\n for c in range(len(boy_value))]\\n fia_portfolio_df.loc[counter, 'total'] = fia_portfolio_df.loc[counter, boy_value].sum()\\n fia_portfolio_df.loc[counter, 'adv_fees'] = fia_portfolio_df.loc[counter, 'total'] * adv_fees\\n\\n # ---req. income is adjusted for inflation from the second year of withdrawal. Reinvestment of coupon\\n # stops from the year income starts. Req. income is reduced by the coupon payments\\n\\n if counter == income_starts:\\n\\n income_needed = req_annual_income - social\\n income_net_fia_income = max(0, income_needed - income_from_fia)\\n fia_portfolio_df.loc[counter, 'income'] = max(0, income_net_fia_income - cpn_income_port)\\n income_needed = req_annual_income\\n\\n else:\\n income_needed = income_needed * (1 + inflation) - social\\n income_net_fia_income = max(0, income_needed - income_from_fia)\\n fia_portfolio_df.loc[counter, 'income'] = max(0, income_net_fia_income - cpn_income_port)\\n income_needed = income_needed + social\\n\\n fia_portfolio_df.loc[counter, 'total_net_fees'] = fia_portfolio_df.loc[counter, 'total'] - \\\\\\n fia_portfolio_df.loc[counter, 'adv_fees'] - \\\\\\n fia_portfolio_df.loc[counter, 'income']\\n\\n port_investment = fia_portfolio_df.loc[counter, 'total_net_fees']\\n\\n sim_port_total.loc[:, 's_{}'.format(str(runs))] = fia_portfolio_df.loc[:, 'total_net_fees'] + \\\\\\n income_df.loc[:, 'contract_value']\\n\\n sim_port_income.loc[:, 's_{}'.format(str(runs))] = fia_portfolio_df.loc[:, 'income']\\n\\n fia_portfolio_df.loc[:, 'adj_total'] = fia_portfolio_df.loc[:, 'total_net_fees'].apply(\\n lambda x: x if x > 0 else 0)\\n\\n # ---------income breakdown for Base portfolio----------------------------------\\n base_df.to_csv(src + 'base_port_detail.csv')\\n sim_base_total.to_csv(src + 'base_ending_values.csv')\\n income_breakdown_base = pd.DataFrame(sim_base_total.quantile(0.5, axis=1))\\n income_breakdown_base.loc[:, 'income_from_portfolio'] = sim_base_income.quantile(0.5, axis=1)\\n income_breakdown_base.loc[:, 'fia_income'] = 0.0\\n income_breakdown_base.loc[:, 'social_security_income'] = social\\n income_breakdown_base.loc[:, 'coupon_income'] = cpn_income_base\\n\\n income_breakdown_base.rename(columns={income_breakdown_base.columns[0]: 'portfolio_ending_value'}, inplace=True)\\n income_breakdown_base.loc[:, 'income_from_portfolio'][\\n income_breakdown_base.loc[:, 'portfolio_ending_value'] <= 0] = 0\\n income_breakdown_base.loc[:, 'total_income'] = income_breakdown_base.loc[:, income_breakdown_base.columns[1:]].sum(\\n axis=1)\\n\\n # ------------Block Ends-------------------------------------------------------------\\n\\n # ---------income breakdown for FIA portfolio----------------------------------\\n fia_portfolio_df.to_csv(src + 'fia_port_detail.csv')\\n sim_port_total.to_csv(src + 'fiaport_ending_values.csv')\\n\\n income_breakdown_port = pd.DataFrame(sim_port_total.quantile(0.5, axis=1))\\n income_breakdown_port.loc[:, 'income_from_portfolio'] = sim_port_income.quantile(0.5, axis=1)\\n income_breakdown_port.loc[:, 'fia_income'] = income_from_fia\\n income_breakdown_port.loc[:, 'social_security_income'] = social\\n income_breakdown_port.loc[:, 'coupon_income'] = cpn_income_port\\n\\n income_breakdown_port.rename(columns={income_breakdown_port.columns[0]: 'portfolio_ending_value'}, inplace=True)\\n income_breakdown_port.loc[:, 'income_from_portfolio'][\\n income_breakdown_port.loc[:, 'portfolio_ending_value'] <= 0] = 0\\n income_breakdown_port.loc[:, 'total_income'] = income_breakdown_port.loc[:, income_breakdown_port.columns[1:]].sum(\\n axis=1)\\n\\n # ------------Block Ends-------------------------------------------------------------\\n q_cut = [0.0, 0.05, 0.25, 0.5, 0.75, 0.95, 1.0]\\n sim_base_income[sim_base_total < income_needed] = 0.0\\n\\n sim_port_income[sim_port_total < income_net_fia_income] = 0\\n\\n sim_port_income = sim_port_income + income_from_fia\\n\\n # base_quantile = sim_base_total.loc[sim_base_total.index[-1]].quantile([0.05, 0.25, 0.50, 0.75, 0.90])\\n\\n # port_quantile = sim_port_total.loc[sim_port_total.index[-1]].quantile([0.05, 0.25, 0.50, 0.75, 0.90])\\n\\n base_quantile = sim_base_total.loc[sim_base_total.index[-1]].quantile(q_cut)\\n\\n port_quantile = sim_port_total.loc[sim_port_total.index[-1]].quantile(q_cut)\\n\\n # q_cut = [0.0, .05, 0.25, 0.5, 0.75, 0.95, 1.0]\\n cols = ['Min', '5th', '25th', '50th', '75th', '90th', 'Max']\\n\\n # ----drop year 0--------\\n sim_base_total = sim_base_total[1:]\\n sim_port_total = sim_port_total[1:]\\n\\n # ----------------quantile analysis for base terminal value--------------------------\\n base_qcut = pd.DataFrame(index=sim_base_total.index, columns=cols)\\n for c in range(len(cols)):\\n base_qcut.loc[:, cols[c]] = sim_base_total.quantile(q_cut[c], axis=1)\\n\\n base_qcut.clip(lower=0, inplace=True)\\n\\n # ----------------------quantile analysis for base income----------------------------\\n base_income_qcut = pd.DataFrame(index=sim_base_income.index, columns=cols)\\n for c in range(len(cols)):\\n base_income_qcut.loc[:, cols[c]] = sim_base_income.quantile(q_cut[c], axis=1)\\n\\n # ----Remove NaN's prior to the income start years------------\\n # base_income_qcut = base_income_qcut.loc[income_starts:]\\n\\n # -------------quantile analysis for portfolio terminal value ----------------\\n port_qcut = pd.DataFrame(index=sim_port_total.index, columns=cols)\\n for c in range(len(cols)):\\n port_qcut.loc[:, cols[c]] = sim_port_total.quantile(q_cut[c], axis=1)\\n\\n port_qcut.clip(lower=0, inplace=True)\\n\\n # ---------------quantile analysis for portfolio income----------------------------\\n port_income_qcut = pd.DataFrame(index=sim_port_income.index, columns=cols)\\n for c in range(len(cols)):\\n port_income_qcut.loc[:, cols[c]] = sim_port_income.quantile(q_cut[c], axis=1)\\n\\n # ----Remove NaN's prior to the income start years------------\\n # port_income_qcut = port_income_qcut.loc[income_starts:]\\n\\n # ----------probability ending value will be less than 0 at the end of the horizon -----------------------\\n base_legacy_risk = (sim_base_total.loc[sim_base_total.index[life_expectancy - clients_age]] < 0).sum() / (\\n trials + 1)\\n port_legacy_risk = (sim_port_total.loc[sim_port_total.index[life_expectancy - clients_age]] < 0).sum() / (\\n trials + 1)\\n\\n legacy_risk = pd.DataFrame([base_legacy_risk, port_legacy_risk,\\n 'Prob. of portfolio value less than 0 at the end of the expected life'],\\n index=['base', 'fia_portfolio', 'Notes'],\\n columns=['Ruin Probability'])\\n\\n # -----------Year-wise probability of ending value greater than 0 -----------------\\n base_psuccess = sim_base_total.apply(lambda x: x > 0).sum(axis=1) / (trials + 1)\\n port_psuccess = sim_port_total.apply(lambda x: x > 0).sum(axis=1) / (trials + 1)\\n\\n # -----------------------WRITING FILES TO EXCEL ---------------------------\\n col_names = ['50th', 'age', 'comment']\\n writer = pd.ExcelWriter(src + method + '_simulated_income_summary.xlsx', engine='xlsxwriter')\\n read_income_inputs.to_excel(writer, sheet_name='inputs_for_income')\\n\\n read_returns_est.to_excel(writer, sheet_name='asset_returns_estimates')\\n\\n age_index = list(range(clients_age + 1, clients_age + len(base_qcut) + 1))\\n base_qcut.loc[:, 'age'] = age_index\\n base_qcut.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\\n base_qcut.loc[income_starts:, col_names].to_excel(writer, sheet_name='base_ending_value_quantiles')\\n\\n base_income_qcut = base_income_qcut.loc[1:, :]\\n base_income_qcut.loc[:, 'age'] = age_index\\n base_income_qcut.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\\n base_income_qcut.loc[income_starts:, col_names].to_excel(writer, sheet_name='base_income_quantiles')\\n\\n port_qcut.loc[:, 'age'] = age_index\\n port_qcut.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\\n port_qcut.loc[income_starts:, col_names].to_excel(writer, sheet_name='fia_port_ending_value_quantiles')\\n\\n port_income_qcut = port_income_qcut.loc[1:, :]\\n port_income_qcut.loc[:, 'age'] = age_index\\n port_income_qcut.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\\n # port_income_qcut.loc[:, 'ending_contract_value'] = sim_fia_cv\\n port_income_qcut.loc[income_starts:, col_names].to_excel(writer, sheet_name='fia_port_income_quantiles')\\n\\n # prob_success_df = pd.concat([base_psuccess, port_psuccess], axis=1)\\n # prob_success_df.rename(columns={prob_success_df.columns[0]: 'prob(ending_value>0)_base',\\n # prob_success_df.columns[1]: 'prob(ending_value>0)_port'}, inplace=True)\\n\\n # prob_success_df.loc[:, 'age'] = age_index\\n # prob_success_df.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\\n # prob_success_df.to_excel(writer, sheet_name='success_probability')\\n\\n income_breakdown_base = income_breakdown_base.loc[1:, :]\\n income_breakdown_base.loc[:, 'age'] = age_index\\n income_breakdown_base.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\\n income_breakdown_base.loc[income_starts:, :].to_excel(writer, sheet_name='base_income_breakdown_median')\\n\\n income_breakdown_port = income_breakdown_port.loc[1:, :]\\n income_breakdown_port.loc[:, 'age'] = age_index\\n income_breakdown_port.loc[life_expectancy - clients_age, 'comment'] = 'expected_life'\\n income_breakdown_port.loc[:, 'ending_contract_value'] = income_df.loc[:, 'contract_value']\\n income_breakdown_port.loc[income_starts:, :].to_excel(writer, sheet_name='fia_income_breakdown_median')\\n\\n if method == 'normal':\\n # median_returns_normal.loc[:, 'fia_median_returns'] = median_normal_fia\\n median_returns_normal.to_excel(writer, sheet_name='gr_port_median_normal')\\n\\n elif method == 'smallest':\\n # median_returns_smallest.loc[:, 'fia_median_returns'] = median_smallest_fia\\n median_returns_smallest.to_excel(writer, sheet_name='gr_port_median_asc')\\n\\n else:\\n # median_returns_largest.loc[:, 'fia_median_returns'] = median_largest_fia\\n median_returns_largest.to_excel(writer, sheet_name='gr_port_median_desc')\\n\\n terminal_val = pd.read_csv(src + 'terminal_values.csv', index_col=[0])\\n ending_val = pd.read_csv(src + 'ending_values.csv', index_col=[0])\\n ending_val_ror = pd.read_csv(src + 'ending_values_ror.csv', index_col=[0])\\n\\n terminal_val.to_excel(writer, sheet_name='terminal_values')\\n ending_val.to_excel(writer, sheet_name='port_ending_values')\\n ending_val_ror.to_excel(writer, sheet_name='port_annual_growth')\\n\\n writer.save()\\n\\n # -----------------Plotting charts--------------------------------------------\\n base_qcut.loc[income_starts:].plot(grid=True, title='Quantile Terminal Value - Base Portfolio')\\n plt.savefig(src + \\\"quantile_terminal_base.png\\\")\\n plt.close('all')\\n\\n base_income_qcut.plot(grid=True, title='Quantile Income - Base Portfolio')\\n plt.savefig(src + \\\"quantile_income_base.png\\\")\\n plt.close('all')\\n\\n base_psuccess.plot(grid=True, title='Probability of Success (Portfolio Ending Value > 0) - Base Portfolio')\\n plt.savefig(src + \\\"success_probabilty_base.png\\\")\\n plt.close('all')\\n\\n (1 - base_psuccess).plot(grid=True, title='Probability of Ruin (Portfolio Ending Value < 0) - Base Portfolio')\\n plt.savefig(src + \\\"ruin_probability_base.png\\\")\\n plt.close('all')\\n\\n port_qcut.loc[income_starts:].plot(grid=True, title='Quantile Terminal Value - FIA Portfolio')\\n plt.savefig(src + \\\"quantile_terminal_fia.png\\\")\\n plt.close('all')\\n\\n port_income_qcut.plot(grid=True, title='Quantile Income - FIA Portfolio')\\n plt.savefig(src + \\\"quantile_income_fia.png\\\")\\n plt.close('all')\\n\\n port_psuccess.plot(grid=True, title='Probability of Success (Portfolio Ending Value > 0) - FIA Portfolio')\\n plt.savefig(src + \\\"success_probabilty_fia.png\\\")\\n plt.close('all')\\n\\n (1 - port_psuccess).plot(grid=True, title='Probability of Ruin (Portfolio Ending Value < 0) - FIA Portfolio')\\n plt.savefig(src + \\\"ruin_probability_fia.png\\\")\\n plt.close('all')\\n\\n print(\\\"simulation completed for {}\\\".format(method))\",\n \"def batch_simulation(self, iters=10000):\\n power_cnt = 0\\n correct_sign_cnt = 0\\n\\n for i in range(iters):\\n if (self.verbose) and (i>0) and (i % (iters/10) == 0):\\n print(i, \\\" / \\\", iters)\\n f_stat, p_value, effect_point_estimates = self.simulate()\\n power_cnt += (p_value < self.alpha)\\n correct_sign_cnt += (effect_point_estimates * self.absolute_effect > 0)\\n\\n if self.verbose: print(iters, \\\" / \\\", iters)\\n power = round(power_cnt / float(iters), 5)\\n pct_correct_sign = round(correct_sign_cnt / float(iters), 5)\\n return power, pct_correct_sign\",\n \"def create_state_df(runs, iters=100000):\\n df_st = pd.DataFrame()\\n for l in runs.keys():\\n for i in range(runs[l].shape[0]):\\n df = pd.DataFrame()\\n df[\\\"Step\\\"] = np.arange(iters)\\n df[\\\"Maximum\\\"] = np.maximum.accumulate(runs[l][i].flatten())\\n df[\\\"run-type\\\"] = \\\"Short Burst\\\" if float(l) > 1 else \\\"Biased Run\\\" if float(l) < 1 else \\\"Unbiased Run\\\"\\n df[\\\"param\\\"] = \\\"b = {}\\\".format(l) if float(l) > 1 else \\\"q = {}\\\".format(l)\\n df_st = df_st.append(df, ignore_index=True)\\n return df_st\",\n \"def after_run(self, run_context, run_values):\\n train_step = run_values.results\\n if train_step < 40000:\\n self._lrn_rate = 0.1\\n elif train_step < 60000:\\n self._lrn_rate = 0.01\\n elif train_step < 80000:\\n self._lrn_rate = 0.001\\n else:\\n self._lrn_rate = 0.0001\",\n \"def train_multiple_runs_eps_dynamic(self, env, runs=3, no_episodes=200, ng_int=50, horizon=1000, lr=0.1):\\n\\t\\tr_mat = []\\n\\t\\tinfo = {}\\n\\t\\t\\n\\t\\tfor i in tqdm(range(runs)):\\n\\n\\t\\t\\t# Resetting agent to default before each run\\n\\t\\t\\tif(hasattr(self, 'reset_task')):\\n\\t\\t\\t\\tself.reset_task()\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.reset()\\n\\n\\t\\t\\t# Training the agent for ts_max\\n\\t\\t\\tr_vec, _ = self.train_multiple_eps_dynamic(env, no_episodes=no_episodes, ng_int=ng_int, horizon=horizon, lr=lr)\\n\\n\\t\\t\\t# Storing the results in a matrix\\n\\t\\t\\tr_mat.append(r_vec)\\n\\n\\t\\t# Finding the mean and standard deviation \\n\\t\\tinfo['mean'] = np.mean(np.array(r_mat), axis=0)\\n\\t\\tinfo['std'] = np.std(np.array(r_mat), axis=0)\\n\\n\\t\\treturn r_mat, info\",\n \"def log_summary(self, no_run_list):\\n self.log_message('Entries not run' ,step='summary',status='start',name='config_file_reader')\\n for name in no_run_list.keys():\\n self.log_message('Did not run: '+name+', '+no_run_list[name],status='running')\\n \\n ret_total = 0\\n for x in xrange(2):\\n for ent in self.entries[x]:\\n ret_total = ret_total + 0 if ent.return_val == None else ent.return_val\\n self.log_message('Summary Complete, Run Time = ('+str(self.total_time)+')',status='complete')\\n return ret_total\",\n \"def simulationTwoDrugsDelayedTreatment(numTrials):\\n results = []\\n gutresults = []\\n \\n for a in range(375):\\n results.append([])\\n gutresults.append([])\\n \\n for b in range(numTrials):\\n viruses = []\\n for c in range(100):\\n resistances = {'guttagonol': False, 'grimpex': False}\\n vir = ResistantVirus(.1, .05, resistances, .02)\\n viruses.append(vir)\\n \\n Mark = TreatedPatient(viruses, 1000)\\n \\n for d in range(150):\\n pop = Mark.update()\\n results[d].append(pop)\\n gutpop = Mark.getResistPop(['guttagonol'])\\n gutresults[d].append(gutpop)\\n \\n Mark.addPrescription('guttagonol')\\n \\n for e in range(150, 225):\\n newpop = Mark.update()\\n results[e].append(newpop)\\n newgutpop = Mark.getResistPop(['guttagonol'])\\n gutresults[e].append(newgutpop)\\n \\n Mark.addPrescription('grimpex')\\n \\n for f in range(225, 375):\\n newpop = Mark.update()\\n results[f].append(newpop)\\n \\n \\n FinalResults = results[374]\\n print len(FinalResults)\\n \\n \\n pylab.figure(6)\\n pylab.hist(FinalResults, bins = 10)\\n pylab.title('300 day delay')\\n pylab.xlabel('Virus Population')\\n pylab.ylabel('Number of Trials with Population') \\n pylab.show()\",\n \"def summarizeReactorStats(self):\\n totalMass = 0.0\\n fissileMass = 0.0\\n heavyMetalMass = 0.0\\n totalVolume = 0.0\\n numBlocks = len(self.getBlocks())\\n for block in self.getBlocks():\\n totalMass += block.getMass()\\n fissileMass += block.getFissileMass()\\n heavyMetalMass += block.getHMMass()\\n totalVolume += block.getVolume()\\n totalMass = totalMass * self.powerMultiplier / 1000.0\\n fissileMass = fissileMass * self.powerMultiplier / 1000.0\\n heavyMetalMass = heavyMetalMass * self.powerMultiplier / 1000.0\\n totalVolume = totalVolume * self.powerMultiplier\\n runLog.extra(\\n \\\"Summary of {}\\\\n\\\".format(self)\\n + tabulate.tabulate(\\n [\\n (\\\"Number of Blocks\\\", numBlocks),\\n (\\\"Total Volume (cc)\\\", totalVolume),\\n (\\\"Total Mass (kg)\\\", totalMass),\\n (\\\"Fissile Mass (kg)\\\", fissileMass),\\n (\\\"Heavy Metal Mass (kg)\\\", heavyMetalMass),\\n ],\\n tablefmt=\\\"armi\\\",\\n )\\n )\",\n \"def simulationDelayedTreatment(numTrials):\\n \\n \\n results = []\\n gutresults = []\\n for a in range(300):\\n results.append([])\\n gutresults.append([])\\n for b in range(numTrials):\\n viruses = []\\n for c in range(10000):\\n resistances = {'guttagonol': False}\\n vir = ResistantVirus(.1, .05, resistances, .005)\\n viruses.append(vir)\\n \\n Mark = TreatedPatient(viruses, 1000)\\n \\n for d in range(150):\\n pop = Mark.update()\\n results[d].append(pop)\\n gutpop = Mark.getResistPop(['guttagonol'])\\n gutresults[d].append(gutpop)\\n \\n Mark.addPrescription('guttagonol')\\n \\n for e in range(150, 300):\\n newpop = Mark.update()\\n results[e].append(newpop)\\n newgutpop = Mark.getResistPop(['guttagonol'])\\n gutresults[e].append(newgutpop)\\n \\n FinalResults = results[299]\\n print len(FinalResults)\\n \\n \\n \\n pylab.figure(5)\\n pylab.hist(FinalResults, bins = 10)\\n pylab.title('Simulation with Drugs - Frequency')\\n pylab.xlabel('Virus Population')\\n pylab.ylabel('Number of Trials with Population') \\n pylab.legend()\\n pylab.show()\",\n \"def num_of_stim_reps(subject, stimulus_class, data_dir, save_dir, save_fig=True):\\n\\tif stimulus_class == 'TIMIT':\\n\\t\\tresp_dict, stim_dict = loadEEGh5('MT0002', 'TIMIT', data_dir, eeg_epochs=True, resp_mean = True, binarymat=False, \\n\\t\\tbinaryfeatmat = True, envelope=True, pitch=True, gabor_pc10=False, spectrogram=False, binned_pitches=False, spectrogram_scaled=False, scene_cut=False) #load full model. Do not average across trials. \\n\\t\\ttest_set = ['fcaj0_si1479.wav', 'fcaj0_si1804.wav', 'fdfb0_si1948.wav', \\n\\t\\t'fdxw0_si2141.wav', 'fisb0_si2209.wav', 'mbbr0_si2315.wav', \\n\\t\\t'mdlc2_si2244.wav', 'mdls0_si998.wav', 'mjdh0_si1984.wav', \\n\\t\\t'mjmm0_si625.wav']\\n\\t\\t\\n\\t\\tstim_list = []\\n\\t\\tfor key in resp_dict.keys():\\n\\t\\t\\tprint(key)\\n\\t\\t\\tstim_list.append(key)\\n\\t\\tall_stimuli = [k for k in stim_list if len(resp_dict[k]) > 0]\\n\\t\\ttraining_set = np.setdiff1d(all_stimuli, test_set)\\n\\t\\tprint(training_set)\\n\\n\\n\\tif stimulus_class == 'MovieTrailers':\\n\\n\\t\\tresp_dict_MT0002, stim_dict = loadEEGh5('MT0002', 'MovieTrailers', data_dir, eeg_epochs=True, \\n\\t\\t\\t\\t\\t\\t\\t\\t resp_mean = False, binaryfeatmat = True, binarymat=False, envelope=True,\\n\\t\\t\\t\\t\\t\\t\\t\\t pitch=True, spectrogram=False)\\n\\t\\tresp_dict_MT0020, stim_dict = loadEEGh5('MT0020', 'MovieTrailers', data_dir, eeg_epochs=True, \\n\\t\\t\\t\\t\\t\\t\\t\\t resp_mean = False, binaryfeatmat = True, binarymat=False, envelope=True,\\n\\t\\t\\t\\t\\t\\t\\t\\t pitch=True, spectrogram=False)\\n\\t\\t\\n\\t\\ttrailers_list = ['angrybirds-tlr1_a720p.wav', 'bighero6-tlr1_a720p.wav', 'bighero6-tlr2_a720p.wav', \\n\\t\\t'bighero6-tlr3_a720p.wav', 'cars-3-trailer-4_a720p.wav', 'coco-trailer-1_a720p.wav', \\n\\t\\t'ferdinand-trailer-2_a720p.wav', 'ferdinand-trailer-3_a720p.wav', 'ice-dragon-trailer-1_a720p.wav', \\n\\t\\t'incredibles-2-trailer-1_a720p.wav', 'incredibles-2-trailer-2_a720p.wav', 'insideout-tlr2zzyy32_a720p.wav',\\n\\t\\t'insideout-usca-tlr2_a720p.wav', 'moana-clip-youre-welcome_a720p.wav', 'paddington-2-trailer-1_a720p.wav', \\n\\t\\t'pandas-trailer-2_a720p.wav', 'pele-tlr1_a720p.wav', 'the-breadwinner-trailer-1_a720p.wav', \\n\\t\\t'the-lego-ninjago-movie-trailer-1_a720p.wav', 'the-lego-ninjago-movie-trailer-2_a720p.wav', \\n\\t\\t'thelittleprince-tlr_a720p.wav', 'trolls-tlr1_a720p.wav']\\n\\n\\t\\tresp_dict = {}\\n\\n\\t\\tfor k in trailers_list:\\n\\t\\t\\tresp_dict[k] = [np.concatenate((resp_dict_MT0002[k][0], resp_dict_MT0020[k][0]), axis=0)]\\n\\t\\ttest_set = ['paddington-2-trailer-1_a720p.wav', 'insideout-tlr2zzyy32_a720p.wav'] #the test set for the remaining MTs\\n\\n\\t\\tall_stimuli = trailers_list\\n\\t\\ttraining_set = np.setdiff1d(all_stimuli, test_set)\\n\\t\\tprint(training_set)\\n\\n\\tval_inds = np.zeros((len(all_stimuli),), dtype=np.bool) \\n\\ttrain_inds = np.zeros((len(all_stimuli),), dtype=np.bool)\\n\\tfor i in np.arange(len(all_stimuli)):\\n\\t\\tif all_stimuli[i] in test_set:\\n\\t\\t\\tprint(all_stimuli[i])\\n\\t\\t\\tval_inds[i] = True\\n\\t\\telse:\\n\\t\\t\\ttrain_inds[i] = True\\n\\n\\tprint(\\\"Total number of training sentences:\\\")\\n\\tprint(sum(train_inds))\\n\\tprint(\\\"Total number of validation sentences:\\\")\\n\\tprint(sum(val_inds))\\n\\n\\ttrain_inds = np.where(train_inds==True)[0]\\n\\tval_inds = np.where(val_inds==True)[0]\\n\\n\\tprint(\\\"Training indices:\\\")\\n\\tprint(train_inds)\\n\\tprint(\\\"Validation indices:\\\")\\n\\tprint(val_inds)\\n\\n\\t# For logging compute times, debug messages\\n\\n\\tlogging.basicConfig(level=logging.DEBUG) \\n\\n\\t#time delays used in STRF\\n\\tdelay_min = 0.0\\n\\tdelay_max = 0.6\\n\\twt_pad = 0.1 # Amount of padding for delays, since edge artifacts can make weights look weird\\n\\n\\tfs = 128.0\\n\\tdelays = np.arange(np.floor((delay_min-wt_pad)*fs), np.ceil((delay_max+wt_pad)*fs), dtype=np.int) #create array to pass time delays in\\n\\n\\tprint(\\\"Delays:\\\", delays)\\n\\n\\t# Regularization parameters (alphas - also sometimes called lambda)\\n\\talphas = np.hstack((0, np.logspace(2,8,20))) # Gives you 15 values between 10^2 and 10^8\\n\\n\\tnalphas = len(alphas)\\n\\tuse_corr = True # Use correlation between predicted and validation set as metric for goodness of fit\\n\\tsingle_alpha = True # Use the same alpha value for all electrodes (helps with comparing across sensors)\\n\\tnboots = 20 # How many bootstraps to do. (This is number of times you take a subset of the training data to find the best ridge parameter)\\n\\n\\tall_wts = [] # STRF weights (this will be ndelays x channels)\\n\\tall_corrs = [] # correlation performance of length [nchans]\\n\\tall_corrs_shuff = [] # List of lists, how good is a random model\\n\\n\\t# train_inds and val_inds are defined in the cell above, and is based on getting 80% of the trials\\n\\t# for each unique stimulus to be in the training set, and the remaining 20% to be in \\n\\t# the validation set\\n\\tcurrent_stim_list_train = np.array([all_stimuli[r][0] for r in train_inds])\\n\\tcurrent_stim_list_val = np.array([all_stimuli[r][0] for r in val_inds])\\n\\n\\t# Create training and validation response matrices\\n\\tprint(resp_dict[training_set[0]][0].shape)\\n\\tprint(test_set)\\n\\n\\tprint(len(training_set))\\n\\tfor r in training_set:\\n\\t\\tprint(r)\\n\\n\\n\\t# tResp = np.hstack([resp_dict[r][0] for r in training_set]).T\\n\\t# vResp = np.hstack([resp_dict[r][0] for r in test_set]).T\\n\\n\\n\\t# Create training and validation stimulus matrices\\n\\n\\ttStim_temp = np.atleast_2d(np.vstack([np.vstack(stim_dict[r]).T for r in training_set]))\\n\\tvStim_temp = np.atleast_2d(np.vstack([np.vstack(stim_dict[r]).T for r in test_set if resp_dict[r][0].shape[0] >= 10]))\\n\\ttStim_temp = tStim_temp/tStim_temp.max(0)\\n\\tvStim_temp = vStim_temp/vStim_temp.max(0)\\n\\tprint('**********************************')\\n\\tprint(tStim_temp.max(0).shape)\\n\\tprint(vStim_temp.max(0).shape)\\n\\tprint('**********************************')\\n\\n\\ttStim = make_delayed(tStim_temp, delays)\\n\\tvStim = make_delayed(vStim_temp, delays)\\n\\n\\tchunklen = np.int(len(delays)*3) # We will randomize the data in chunks \\n\\tnchunks = np.floor(0.2*tStim.shape[0]/chunklen).astype('int')\\n\\n\\n\\t\\n\\tvResp_numtrials = [resp_dict[r][0].shape[0] for r in test_set if resp_dict[r][0].shape[0] >= 10]\\n\\t#print(vResp)\\n\\tprint(vResp_numtrials)\\n\\tntrials = np.min(vResp_numtrials)\\n\\tprint(ntrials)\\n\\t\\n\\tvreps = np.arange(1,ntrials+1) # From 1 to 10 repeats of the validation set\\n\\tnboots = 10\\n\\tcorrs_reps = dict()\\n\\tfor v in vreps:\\n\\t\\tcorrs_reps[v] = []\\n\\t\\tprint('*****************************')\\n\\t\\tprint('Now on repetition # %d' %(v))\\n\\t\\tprint('*****************************')\\n\\t\\ttResp = np.hstack([resp_dict[r][0].mean(0) for r in training_set]).T\\n\\t\\tnchans = tResp.shape[1] # Number of electrodes/sensors\\n\\t\\t\\n\\t\\ttrial_combos = [k for k in itools.combinations(np.arange(ntrials), v)]\\n\\t\\tfor t in trial_combos:\\n\\t\\t\\tvResp_temp = [resp_dict[r][0][t,:,:].mean(0) for r in test_set if resp_dict[r][0].shape[0] >= 10]\\n\\n\\t\\t\\tvResp = np.hstack((vResp_temp)).T\\n\\t\\t\\tprint(vResp.shape)\\n\\t\\t\\t# Fit the STRFs - RUNNING THE MODEL HERE!\\n\\t\\t\\twt, corrs, valphas, allRcorrs, valinds, pred, Pstim = bootstrap_ridge(tStim, tResp, vStim, vResp, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t alphas, nboots, chunklen, nchunks, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t use_corr=use_corr, single_alpha = single_alpha, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t use_svd=False, corrmin = 0.05,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t joined=[np.array(np.arange(nchans))])\\n\\t\\t\\tcorrs_reps[v].append(corrs)\\n\\t\\t\\tplt.plot(v, corrs.mean(), '.')\\n\\t\\t\\t\\n\\tplt.xlabel('Number repeats')\\n\\tplt.ylabel('Average corr')\\n\\n\\tcorrs_reps_avg = []\\n\\tcorrs_reps_std = []\\n\\tfor i in np.arange(1, ntrials+1):\\n\\t\\tcorrs_reps_avg.append(np.mean(corrs_reps[i]))\\n\\t\\tprint(np.array(corrs_reps[i])[:,23])\\n\\t\\tcorrs_reps_std.append(np.std(corrs_reps[i])/np.sqrt(len(vreps)))\\n\\n\\n\\tplt.fill_between(vreps, np.array(corrs_reps_avg)+np.array(corrs_reps_std), np.array(corrs_reps_avg)-np.array(corrs_reps_std), alpha=0.5)\\n\\n\\tplt.plot(vreps, corrs_reps_avg)\\n\\n\\tplt.xlabel('Number repeats')\\n\\tplt.ylabel('Average validation correlation')\\n\\n\\t#save corrs_reps into .h5 file for each repetition as individual key. Will save out as either TIMIT or MT reps\\n\\twith h5py.File('%s/%s_corrs_reps.hf5' %(data_dir, stimulus_class), 'w') as g:\\n\\t\\tfor idx, s in enumerate(corrs_reps.items()): \\n\\t\\t\\tg.create_dataset('/rep%d' %(idx), data=np.array(s[1]))\\n\\n\\tif save_fig:\\n\\t\\tplt.savefig('%s/%s_10bootStReps.pdf' %(save_dir, stimulus_class))\\n\\n\\treturn corrs_reps\",\n \"def summarize(self):\\n self.smalltalk += \\\"\\\\n Data IDs in this bundle: \\\\n\\\"\\n self._files = {}\\n inv_dict = {}\\n # sort IDs to make sure pdfs are printed in same oder as they were\\n # taken\\n for k, v in self.stage_summaries.items():\\n for qc_id in flatten_list(v):\\n inv_dict[qc_id] = k\\n sorted_ids = list(flatten_list(self.stage_summaries.values()))\\n sorted_ids.sort(key=int)\\n # for stage, value in self.stage_summaries.items():\\n for qc_run_id in sorted_ids:\\n # stage = inv_dict[qc_run_id]\\n # if stage[0:7] == 'failed_':\\n # stage = stage[7:]\\n # try:\\n # s = self.comments[qc_run_id]\\n # except KeyError:\\n # s = ''\\n # self.comments[qc_run_id] = 'Classified as poor result.\\\\n' + s\\n ds = Dataset(qc_run_id, self.db_name)\\n device_name = ds.device_name\\n f_folder = os.path.join(self.db_folder, \\\"tuning_results\\\", device_name)\\n # for qc_run_id in flatten_list(value):\\n self.smalltalk += str(qc_run_id) + \\\", \\\"\\n\\n # filename = stage + '_fit_ds'\\n # filename += str(qc_run_id) + '.png'\\n filename = os.path.join(f_folder, str(ds.ds.guid) + \\\".png\\\")\\n\\n self._files[str(qc_run_id)] = filename\",\n \"def run_many_fits(spectrum,rms,guesses,nruns):\\n tk_fit = []\\n tex_fit = []\\n ntot_fit = []\\n width_fit = []\\n for i in range(nruns):\\n noisy_spectrum = add_noise(spectrum,rms)\\n noisy_spectrum.specfit(fittype='cold_ammonia',guesses=guesses,fixed=[F,F,F,F,F,T])\\n parcopy = copy.deepcopy(noisy_spectrum.specfit.parinfo)\\n tk_fit = np.append(tk_fit,parcopy[0].value)\\n tex_fit = np.append(tex_fit,parcopy[1].value)\\n ntot_fit = np.append(ntot_fit,parcopy[2].value)\\n width_fit = np.append(width_fit,parcopy[3].value)\\n return tk_fit,tex_fit,ntot_fit,width_fit\",\n \"def validation_summaries(self, step):\\n dnn_summary_writer = self.dnn_summary_writer\\n gan_summary_writer = self.gan_summary_writer\\n DNN = self.DNN\\n D = self.D\\n train_dataset = self.train_dataset\\n validation_dataset = self.validation_dataset\\n\\n self.evaluation_epoch(DNN, train_dataset, dnn_summary_writer, '2 Train Error')\\n dnn_validation_mae = self.evaluation_epoch(DNN, validation_dataset, dnn_summary_writer, '1 Validation Error')\\n self.evaluation_epoch(D, train_dataset, gan_summary_writer, '2 Train Error')\\n self.evaluation_epoch(D, validation_dataset, gan_summary_writer, '1 Validation Error',\\n comparison_value=dnn_validation_mae)\",\n \"def log_evaluation(tester, name, description):\\r\\n\\tfor dataset, output in tester.preds.items():\\r\\n\\t\\tresults = pandas.DataFrame.from_dict(output)\\r\\n\\t\\tpath = os.path.join(\\r\\n\\t\\t\\tEXPERIMENT_PATH, tester.config[\\\"name\\\"] + '-' + dataset)\\r\\n\\t\\twith open(path + \\\".csv\\\", \\\"w\\\") as f:\\r\\n\\t\\t\\tresults.to_csv(f, sep=\\\"\\\\t\\\", encoding='utf-8',\\r\\n\\t\\t\\t\\tfloat_format='%.3f', index=False)\",\n \"def compute_and_print_eval_metrics(self):\\n s = ('%20s' + '%12s' * 6) % ('Class', 'Images', 'Targets', 'P', 'R', 'mAP@.5', 'mAP@.5:.95')\\n precision, recall, f1, mean_precision, mean_recall, map50, map = 0., 0., 0., 0., 0., 0., 0.\\n ap = []\\n eval_stats = [np.concatenate(x, 0) for x in zip(*self.eval_stats)]\\n if len(eval_stats) and eval_stats[0].any():\\n precision, recall, ap, f1, ap_class = ap_per_class(*eval_stats)\\n precision, recall, ap50, ap = precision[:, 0], recall[:, 0], ap[:, 0], ap.mean(1)\\n mean_precision, mean_recall, map50, map = precision.mean(), recall.mean(), ap50.mean(), ap.mean()\\n nt = np.bincount(eval_stats[3].astype(np.int64), minlength=len(self.class_names)) # number of targets per class\\n else:\\n nt = np.zeros(1)\\n\\n pf = '%20s' + '%12.5g' * 6 # print format\\n print(\\\"\\\\n EVALUTAION \\\\n\\\")\\n print(s)\\n print(pf % ('all', self.seen, nt.sum(), mean_precision, mean_recall, map50, map))\\n if self.cfg.eval.verbose:\\n for indx, cls in enumerate(ap_class):\\n print(pf % (self.class_names[cls], self.seen, nt[cls], precision[indx], recall[indx], ap50[indx], ap[indx]))\",\n \"def plotDifferentSettings():\\n\\t#save location of the results\\n\\tresloc = 'Different_settings_results'\\n\\n\\t#the numrows limits\\n\\tnrows_lims = [1e4, 1e7]\\n\\tnbits = 30\\n\\t\\n\\t#string for the file names of the to be saved files\\n\\tsettingsstr = 'nrows={:.0e}--{:.0e}_nbits={}'.format(nrows_lims[0], nrows_lims[1], nbits)\\n\\t\\n\\t#the relative approximation error for the different counting algorithms\\n\\tll_RAE = []\\n\\tprob_RAE = []\\n\\tcomb_RAE = []\\n\\t#the runtime for the different algorithms\\n\\ttc_runtime = []\\n\\tll_runtime = []\\n\\tprob_runtime = []\\n\\tcomb_runtime = []\\n\\n\\t#the different settings we want to test\\n\\tnumrows = np.linspace(nrows_lims[0], nrows_lims[1], num = 15, dtype = int)\\n\\tnumbits = np.array([nbits])\\n\\t\\n\\tlooplength = len(numrows)\\n\\t\\n\\ttry:\\n\\t\\t(ll_RAE, prob_RAE, comb_RAE, tc_runtime, ll_runtime, prob_runtime, comb_runtime) = np.loadtxt('./{0}/diffset_results_{1}.txt'.format(resloc, settingsstr))\\n\\texcept:\\n\\t\\tfor i in np.arange(len(numrows)):\\n\\t\\t\\toF.progress(i, looplength)\\n\\t\\t\\tfor j in np.arange(len(numbits)):\\n\\t\\t\\t\\tresults = runCounts(numrows[i], numbits[j], doprints = False)\\n\\t\\t\\t\\n\\t\\t\\t\\tll_RAE = np.append(ll_RAE, results[0])\\n\\t\\t\\t\\tprob_RAE = np.append(prob_RAE, results[1])\\n\\t\\t\\t\\tcomb_RAE = np.append(comb_RAE, results[2])\\n\\t\\t\\t\\n\\t\\t\\t\\ttc_runtime = np.append(tc_runtime, results[3])\\n\\t\\t\\t\\tll_runtime = np.append(ll_runtime, results[4])\\n\\t\\t\\t\\tprob_runtime = np.append(prob_runtime, results[5])\\n\\t\\t\\t\\tcomb_runtime = np.append(comb_runtime, results[6])\\n\\t\\t\\t\\n\\t\\tnp.savetxt('./{0}/diffset_results_{1}.txt'.format(resloc, settingsstr), \\n\\t\\t\\tnp.array([ll_RAE, prob_RAE, comb_RAE, tc_runtime, ll_runtime, prob_runtime, comb_runtime]), \\n\\t\\t\\theader = '#ll_RAE, prob_RAE, comb_RAE, tc_runtime, ll_runtime, prob_runtime, comb_runtime')\\n\\t\\n\\tplotTwoValues(numrows, ll_RAE, ll_runtime, 'Number of rows', 'RAE [\\\\%]', 'Runtime [s]', 'RAE and runtime of loglog count for different number of rows. \\\\nNumbits = {}'.format(nbits), 'RAEandRuntime_loglog_{0}.pdf'.format(settingsstr))\\n\\t\\n\\tplotTwoValues(numrows, prob_RAE, prob_runtime, 'Number of rows', 'RAE [\\\\%]', 'Runtime [s]', 'RAE and runtime of probabilisic count for different \\\\nnumber of rows. Numbits = {}'.format(nbits), 'RAEandRuntime_prob_{0}.pdf'.format(settingsstr))\",\n \"def results_psavg_sims():\\n posterior_means = [[1.18040327516, 7.55106444832, 3.27420103073, 3.51998795534, 0.67212630002],\\n [0.619197296326, 6.49420626987, 2.22495505139, 2.27682390376, 0.678172183554],\\n [0.856628471666, 5.94732402905, 3.97580346111, 3.85788708662, 0.690090617623],\\n [0.774906025167, 7.34275742443, 2.69729821931, 2.97994334746, 0.663015258594]]\\n\\n\\n sgr1900_results.results_psavg_sims(posterior_means, [5,6,8,12], \\\"sgr1806\\\")\\n\\n return\",\n \"def resampleParams(self, caliStep, iterNO=-1):\\n names = self.getNames()\\n smcSamples = self.smcSamples[iterNO]\\n numSamples = self.numSamples\\n numThreads = self.threads if self.threads else cpu_count()\\n # posterior probability at caliStep is used as the proposal distribution\\n proposal = self.posterior[:, caliStep]\\n newSmcSamples, newparamsFile, gmm, maxNumComponents = \\\\\\n resampledParamsTable(keys=names, smcSamples=smcSamples, proposal=proposal, num=numSamples,\\n threads=numThreads,\\n maxNumComponents=self.__maxNumComponents, priorWeight=self.__priorWeight,\\n covType=self.__covType,\\n tableName='smcTable%i.txt' % (iterNO + 1))\\n self.smcSamples.append(newSmcSamples)\\n self.paramsFiles.append(newparamsFile)\\n return gmm, maxNumComponents\",\n \"def _set_n_runs(self, n_runs):\\n if not isinstance(n_runs, int) or n_runs < 1:\\n raise ValueError(\\\"'n_runs' must be a positive integer.\\\")\\n \\n self.n_runs = n_runs\\n # reset measurement results\\n self._set_runtimes()\\n self._tmean = np.nan\\n self._tstdev = np.nan\\n # block access to results\\n self.__hasrun = False\",\n \"def reduce_run():\",\n \"def simulationDelayedTreatment(numTrials):\\n pop_list = {}\\n resistant_pop_list = {}\\n init_step_list = [300, 150, 75, 0]\\n for index, init_step in enumerate(init_step_list):\\n pop_list[init_step] = get_pop_list(init_step, numTrials)\\n pylab.subplot(2, 2, index + 1)\\n pylab.hist(pop_list[init_step])\\n pylab.title('histogram of init step ' + str(init_step))\\n pylab.xlabel('bin')\\n pylab.ylabel('frequency')\\n pylab.show()\\n return pop_list\\n \\n # TODO\",\n \"def simulationDelayedTreatment(numTrials):\\n\\n delays = [300,150,75,0]\\n results = [[],[],[],[]]\\n for place in range(0, 4):\\n for trial in range(numTrials):\\n viruses = []\\n for num in range(100):\\n viruses.append(ResistantVirus(0.1,0.05, {'guttagonol': False}, 0.005))\\n patient = TreatedPatient(viruses, 1000)\\n for delay in range(delays[place]):\\n patient.update()\\n patient.addPrescription(\\\"guttagonol\\\") \\n for l in range(150):\\n patient.update()\\n results[place].append(patient.getTotalPop())\\n pylab.hist(results[0])\\n pylab.hist(results[1])\\n pylab.hist(results[2])\\n pylab.hist(results[3])\\n pylab.show()\\n for x in range(0, 10):\",\n \"def calculate_average_run_accuracy(self):\\n overall_true_rate, true_positive_rate, true_negative_rate, false_positive_rate, false_negative_rate, true_positive_rate_cutoff, true_negative_rate_cutoff, \\\\\\n false_positive_rate_cutoff, false_negative_rate_cutoff, unclassified_cutoff, matthews_correlation_coefficient, brier_score, auc_score, fit_time, hmeasure = [0] * 15\\n balanced_accuracy_arr = []\\n auc_arr = []\\n hmeasure_arr = []\\n brier_score_arr = []\\n fit_time_arr = []\\n mcc_arr = []\\n true_positive_arr = []\\n true_negative_arr = []\\n false_positive_arr = []\\n false_negative_arr = []\\n\\n count = 0\\n for result_dictionary in self.errors:\\n for z in range(len(result_dictionary[\\\"balanced_accuracy_arr\\\"])):\\n overall_true_rate += result_dictionary[\\\"balanced_accuracy_arr\\\"][z]\\n true_positive_rate += result_dictionary[\\\"true_positive_rate_arr\\\"][z]\\n true_negative_rate += result_dictionary[\\\"true_negative_rate_arr\\\"][z]\\n false_positive_rate += result_dictionary[\\\"false_positive_rate_arr\\\"][z]\\n false_negative_rate += result_dictionary[\\\"false_negative_rate_arr\\\"][z]\\n matthews_correlation_coefficient += result_dictionary[\\\"mcc_arr\\\"][z]\\n auc_score += result_dictionary[\\\"auc_arr\\\"][z]\\n brier_score += result_dictionary[\\\"brier_score_arr\\\"][z]\\n fit_time += result_dictionary[\\\"fit_time_arr\\\"][z]\\n hmeasure += result_dictionary[\\\"hmeasure_arr\\\"][z]\\n count += 1\\n\\n true_positive_rate_cutoff += result_dictionary[\\\"avg_true_positive_rate_with_prob_cutoff\\\"]\\n true_negative_rate_cutoff += result_dictionary[\\\"avg_true_negative_rate_with_prob_cutoff\\\"]\\n false_positive_rate_cutoff += result_dictionary[\\\"avg_false_positive_rate_with_prob_cutoff\\\"]\\n false_negative_rate_cutoff += result_dictionary[\\\"avg_false_negative_rate_with_prob_cutoff\\\"]\\n unclassified_cutoff += result_dictionary[\\\"avg_false_negative_rate_with_prob_cutoff\\\"]\\n balanced_accuracy_arr += result_dictionary[\\\"balanced_accuracy_arr\\\"]\\n hmeasure_arr += result_dictionary[\\\"hmeasure_arr\\\"]\\n auc_arr += result_dictionary[\\\"auc_arr\\\"]\\n brier_score_arr += result_dictionary[\\\"brier_score_arr\\\"]\\n fit_time_arr += result_dictionary[\\\"fit_time_arr\\\"]\\n mcc_arr += result_dictionary[\\\"mcc_arr\\\"]\\n true_positive_arr += result_dictionary[\\\"true_positive_rate_arr\\\"]\\n true_negative_arr += result_dictionary[\\\"true_negative_rate_arr\\\"]\\n false_positive_arr += result_dictionary[\\\"false_positive_rate_arr\\\"]\\n false_negative_arr += result_dictionary[\\\"false_negative_rate_arr\\\"]\\n\\n avg_run_results = [None] * 31\\n avg_run_results[0] = matthews_correlation_coefficient / float(count)\\n avg_run_results[1] = brier_score / float(count)\\n avg_run_results[2] = overall_true_rate / float(count)\\n avg_run_results[3] = true_positive_rate / float(count)\\n avg_run_results[4] = true_negative_rate / float(count)\\n avg_run_results[5] = false_positive_rate / float(count)\\n avg_run_results[6] = false_negative_rate / float(count)\\n avg_run_results[7] = true_positive_rate_cutoff / float(len(self.errors))\\n avg_run_results[8] = true_negative_rate_cutoff / float(len(self.errors))\\n avg_run_results[9] = false_positive_rate_cutoff / float(len(self.errors))\\n avg_run_results[10] = false_negative_rate_cutoff / float(len(self.errors))\\n avg_run_results[11] = unclassified_cutoff / float(len(self.errors))\\n avg_run_results[12] = fit_time / float(count)\\n avg_run_results[14] = balanced_accuracy_arr\\n avg_run_results[15] = auc_score / float(count)\\n avg_run_results[16] = auc_arr\\n avg_run_results[17] = brier_score_arr\\n avg_run_results[18] = fit_time_arr\\n avg_run_results[19] = mcc_arr\\n avg_run_results[13] = self.calculate_std_deviation(balanced_accuracy_arr)\\n avg_run_results[20] = self.calculate_std_deviation(mcc_arr)\\n avg_run_results[21] = self.calculate_std_deviation(brier_score_arr)\\n avg_run_results[22] = self.calculate_std_deviation(auc_arr)\\n avg_run_results[23] = self.calculate_std_deviation(fit_time_arr)\\n avg_run_results[24] = self.calculate_std_deviation(true_positive_arr)\\n avg_run_results[25] = self.calculate_std_deviation(true_negative_arr)\\n avg_run_results[26] = self.calculate_std_deviation(false_positive_arr)\\n avg_run_results[27] = self.calculate_std_deviation(false_negative_arr)\\n avg_run_results[28] = hmeasure / float(count)\\n avg_run_results[29] = self.calculate_std_deviation(hmeasure_arr)\\n avg_run_results[30] = hmeasure_arr\\n\\n return avg_run_results\",\n \"def train_and_report_metrics(xs, ys, num_repeat, extractor_class, useless_var_for_hparam_search=None):\\n\\n all_val_auc = []\\n all_val_accuracy = []\\n\\n for i in range(num_repeat):\\n single_train_metrics = extractor_class().train_single_run(xs, ys, i)\\n\\n all_val_auc.append(single_train_metrics['val_auc'])\\n all_val_accuracy.append(single_train_metrics['val_accuracy'])\\n\\n metrics = {\\n \\\"mean_val_auc\\\": np.mean(all_val_auc),\\n \\\"mean_val_accuracy\\\": np.mean(all_val_accuracy),\\n \\\"val_auc_std\\\": np.std(all_val_auc),\\n \\\"val_accuracy_std\\\": np.std(all_val_accuracy)\\n }\\n\\n print(metrics, flush=True)\\n\\n hpt = hypertune.HyperTune()\\n hpt.report_hyperparameter_tuning_metric(\\n hyperparameter_metric_tag='mean_val_auc',\\n metric_value=metrics['mean_val_auc'])\\n\\n return metrics\",\n \"def repeatexp(n, d, grid_size, reps, tho_scale=0.1, is_classification=True, no_signal=True):\\n \\n datasetList = ['Train', 'Holdout', 'Test']\\n colList = ['perm', 'performance', 'dataset']\\n \\n df_list_std = []\\n df_list_tho = []\\n \\n for perm in tqdm(range(reps)):\\n \\n vals_std, vals_tho = fitModels_paramTuning(n, d, grid_size,\\n is_classification=is_classification,\\n tho_scale=tho_scale,\\n no_signal=no_signal)\\n for i, ds in enumerate(datasetList):\\n df_list_std.append((perm, vals_std[i], ds))\\n df_list_tho.append((perm, vals_tho[i], ds))\\n\\n df_std = pd.DataFrame(df_list_std, columns=colList)\\n df_tho = pd.DataFrame(df_list_tho, columns=colList)\\n return df_std, df_tho\",\n \"def one_experiment():\\n\\n # set the name of the experiment\\n now = datetime.datetime.now()\\n experiment_id = str(now.day) + \\\"_\\\" + str(now.month) + \\\"_\\\" + str(now.hour) + \\\".\\\" + str(now.minute)\\n experiment_name = 'overfit_' + str(experiment_id)\\n\\n # define if you want to use preprocessed data from file\\n use_prep_data = False\\n if use_prep_data:\\n set_params(preproc_data_id='16_5_10.16.47')\\n\\n # define the changing parameter and its value\\n changing_param_name = 'class_weights'\\n changing_param_value = [{0: 15, 1: 85}]\\n # {0:15, 1:85}]#, {0:4, 1:100}, {0:3, 1:100}, {0:2, 1:100}, {0:1, 1:100}] #[{0:1, 1:1}, {0:15, 1:85}]#\\n\\n features_to_use = ['user', 'countries', 'session', 'format', 'token']\\n # set constant parameters\\n set_params(use_word_emb=1)\\n set_params(epochs=40)\\n set_params(features_to_use=features_to_use)\\n\\n # save constant parameters to a new \\\"experiment_..\\\" filgithx+P@2ub\\n save_constant_parameters(experiment_name, changing_param_name)\\n\\n # run experiment for every parameter value\\n for value in changing_param_value:\\n process = psutil.Process(os.getpid())\\n print(\\\"-----MEMORY before starting experiment ------\\\", int(process.memory_info().rss/(8*10**3)), \\\"KB\\\")\\n\\n # update the parameter value\\n set_params(class_weights_1=value)\\n\\n # update the model_id for this new model\\n now = datetime.datetime.now()\\n new_model_id = str(now.day) + \\\"_\\\" + str(now.month) + \\\"_\\\" + str(now.hour) + \\\".\\\" + str(now.minute) + \\\".\\\" + str(now.second)\\n\\n set_params(model_id=new_model_id)\\n\\n # evaluate the new model and save the results in the experiment file\\n oneExperiment = Process(target=run_experiment, args=(experiment_name,\\n new_model_id, changing_param_name, value,))\\n oneExperiment.start()\\n oneExperiment.join()\",\n \"def experiment(agent, steps, runs, initialize=None):\\n result = 0\\n for r in range(runs):\\n result += simulate(agent, steps, initialize)\\n return result / runs\",\n \"def measure(self):\\n # --- perform repeated runs\\n for i_run in range(self.n_runs):\\n if self.verbosity > 0:\\n print(\\\"Run {0} / {1} ...\\\".format(i_run, self.n_runs), end = '')\\n tdelta = self._timed_execute()\\n self._run_times[i_run] = tdelta\\n\\t\\t\\t\\n if self.verbosity == 2:\\n print(tdelta)\\n \\n # calculate mean\\n self._tmean = np.mean(self._run_times)\\n # calculate standard deviation\\n self._tstdev = np.std(self._run_times)\\n # allow access to results\\n self.__hasrun = True\",\n \"def update(self,x): #update the estimate of rewards and number of esteps run\\n\\t\\tself.N += 1\\n\\t\\tself.estimate_mean = (1.0-1.0/self.N)*self.estimate_mean + (1.0/self.N)*x #recurence relation for averages\",\n \"def test_print_results(self):\\n calculated = super().predict_and_print()\\n self.assertEqual(calculated, EXP_PRINT_OUTPUT_BASE.format(.18, .1, 0.186, self.test_model.model.train_time) +\\n \\\"Max tree max_depth: 1\\\\n\\\"\\n \\\"Number of n_estimators: 1\\\\n\\\"\\n \\\"Impurity method: entropy\\\\n\\\")\",\n \"def list_of_runstrings (ins, exp) :\\n runs = experiment_info.experiment_runs(ins, exp)\\n lst = []\\n for rec in runs :\\n lst.append( '%04d'%rec['num'] )\\n return lst\",\n \"def analyze_trial(trial_num, starting_replication_num=1, design_filename='design.csv'):\\r\\n design_name_root = design_filename.split('.')[0]\\r\\n\\r\\n # check for filename accessibility\\r\\n # ... if file already exists, it will be overwritten, so be careful\\r\\n trial_level_results_filename = f\\\"{results_directory}/trial_results_{trial_num}.{design_name_root}.npy\\\"\\r\\n # if permission denied or folder doesn't exist, will raise error; let it\\r\\n f = open(trial_level_results_filename, 'wb')\\r\\n f.close()\\r\\n\\r\\n num_replications = constants.NUM_REPLICATIONS\\r\\n\\r\\n design = load_design_file(design_filename) # need these to build edge list\\r\\n trial_settings = get_trial_settings(trial_num, design)\\r\\n\\r\\n # init replication-level results container\\r\\n # t_max + 1 to account for initial state\\r\\n replication_level_results = np.zeros(\\r\\n (constants.NUM_REPLICATIONS, constants.MAX_TIME_STEPS + 1, data_processors.number_of_measures, 2))\\r\\n\\r\\n # array of replication times, just for minor perfomance analytics\\r\\n rep_times_array = np.full(num_replications, np.nan, dtype=np.float16)\\r\\n\\r\\n # want replication numbers to start at 1, like trial numbers\\r\\n for rep in range(starting_replication_num, num_replications + 1):\\r\\n start_time = time.time()\\r\\n\\r\\n # test output file access\\r\\n # will be reading this one\\r\\n replication_raw_data_filename = f\\\"{results_directory}/replication_raw_data_{trial_num}_{rep}.{design_name_root}.npy\\\"\\r\\n\\r\\n # to resume analysis later, need to save these\\r\\n replication_level_results_filename = f\\\"{results_directory}/replication_results_{trial_num}_{rep}.{design_name_root}.npy\\\"\\r\\n f = open(replication_level_results_filename, 'wb')\\r\\n f.close()\\r\\n\\r\\n # here, we're rebuilding the network graph by the same approach as the model init\\r\\n network_parameters = trial_settings['network_parameters']\\r\\n rg = RandomGenerator(PCG64(REPLICATION_ISEED_STREAM_ARRAY[rep], RNGStream.GRAPH_GENERATOR + 1))\\r\\n network_rg = RandomGenRandomInterface(rg)\\r\\n G = getattr(networks, network_parameters[0])(*network_parameters[1], network_rg)\\r\\n G = networks.prepare_graph_for_trial(G, network_rg) # make directed, connected, & free of self-loops\\r\\n\\r\\n # load raw data file\\r\\n raw_data = np.load(replication_raw_data_filename)\\r\\n\\r\\n # minor data validation\\r\\n if raw_data.min() < constants.MIN_OPINION:\\r\\n print(f\\\"Warning: raw_data for replication {rep} contains values below MIN_OPINION!\\\")\\r\\n if raw_data.max() > constants.MAX_OPINION:\\r\\n print(f\\\"Warning: raw_data for replication {rep} contains values below MIN_OPINION!\\\")\\r\\n\\r\\n # we compute agent-level entropy values on the raw data\\r\\n # init agent-level container(s), with shape(N, t, num_rv)\\r\\n agent_level_entropy = data_processors.process_raw_data_into_entropy_timeseries(raw_data, G)\\r\\n \\r\\n # now with a N x t x (# entropy array), we average each time step per entropy across all N agents\\r\\n replication_level_entropy = np.stack(\\r\\n (agent_level_entropy.mean(axis=0), agent_level_entropy.std(axis=0)), axis=2) # shape(t, num_rv, 2)\\r\\n\\r\\n # now we have the replication-level results -- 1 time series per entropy measure (plus st.dev)\\r\\n # we will save these to file if replication_level_output_filename is set (it is 'can store' data)\\r\\n np.save(replication_level_results_filename, replication_level_entropy)\\r\\n\\r\\n # but in either case, we save these in an array\\r\\n # -1 to account for my choice to start reps at 1\\r\\n replication_level_results[rep - 1] = replication_level_entropy[:] # shape(num_rep, t, num_rv, 2)\\r\\n\\r\\n rep_times_array[rep - 1] = time.time() - start_time\\r\\n\\r\\n # next rep\\r\\n\\r\\n if starting_replication_num > 1:\\r\\n # not all replications are present in replication_level_entropy. the missing data ought to have\\r\\n # been saved to file on previous (partial) runs of this script, so recover them\\r\\n for rep in range(1, starting_replication_num):\\r\\n replication_level_results[rep - 1] = np.load(f\\\"{results_directory}/replication_results_{trial_num}_{rep}.{design_name_root}.npy\\\")\\r\\n\\r\\n # finally, average (and standardly deviate) across all replications to\\r\\n # produce trial-level response variables (1 time series per entropy measure (6)) plus stdev\\r\\n #\\r\\n # , 0] to only take mean of means, not mean of stdevs\\r\\n mean_replication_level_results = replication_level_results[:, :, :, 0].mean(axis=0)\\r\\n stdev_replication_level_results = replication_level_results[:, :, :, 0].std(axis=0)\\r\\n trial_level_response_variables = np.stack(\\r\\n (mean_replication_level_results, stdev_replication_level_results), axis=2) # shape(t, num_rv, 2)\\r\\n\\r\\n # and preserve our hard work!\\r\\n np.save(trial_level_results_filename, trial_level_response_variables)\\r\\n\\r\\n rep_times_array = rep_times_array[~np.isnan(rep_times_array)] # filter out empty values in case of a partial run\\r\\n\\r\\n print(f\\\"Analysis of Trial {trial_num} complete ({rep_times_array.size} replications).\\\\n\\\"\\r\\n f\\\"Time elapsed: {rep_times_array.sum()} sec; per replication: {rep_times_array.mean()} +/- {rep_times_array.std()}.\\\\n\\\\n\\\")\\r\\n\\r\\n return\",\n \"def sample_run(df, n_epochs = 10, window_size = 500, com = 12, p_anoms = .5):\\n import numpy as np\\n\\n # create arrays that will hold the results of batch AD (y_true) and online AD (y_pred)\\n y_true = []\\n y_pred = []\\n run_times = []\\n \\n # check which unique machines, sensors, and timestamps we have in the dataset\\n machineIDs = df['machineID'].unique()\\n sensors = df.columns[2:]\\n timestamps = df['datetime'].unique()[window_size:]\\n \\n # sample n_machines_test random machines and sensors \\n random_machines = np.random.choice(machineIDs, n_epochs)\\n random_sensors = np.random.choice(sensors, n_epochs)\\n\\n # we intialize an array with that will later hold a sample of timetamps\\n random_timestamps = np.random.choice(timestamps, n_epochs)\\n \\n for i in range(0, n_epochs):\\n # take a slice of the dataframe that only contains the measures of one random machine\\n df_s = df[df['machineID'] == random_machines[i]]\\n \\n # smooth the values of one random sensor, using our run_avg function\\n smooth_values = run_avg(df_s[random_sensors[i]].values, com)\\n \\n # create a data frame with two columns: timestamp, and smoothed values\\n df_smooth = pd.DataFrame(data={'timestamp': df_s['datetime'].values, 'value': smooth_values})\\n\\n # load the results of batch AD for this machine and sensor\\n anoms_s = anoms_batch[((anoms_batch['machineID'] == random_machines[i]) & (anoms_batch['errorID'] == random_sensors[i]))]\\n \\n # find the location of the t'th random timestamp in the data frame\\n if np.random.random() < p_anoms:\\n anoms_timestamps = anoms_s['datetime'].values\\n np.random.shuffle(anoms_timestamps)\\n counter = 0\\n while anoms_timestamps[0] < timestamps[0]:\\n if counter > 100:\\n return 0.0, 9999.0\\n np.random.shuffle(anoms_timestamps)\\n counter += 1\\n random_timestamps[i] = anoms_timestamps[0]\\n \\n # select the test case\\n test_case = df_smooth[df_smooth['timestamp'] == random_timestamps[i]]\\n test_case_index = test_case.index.values[0]\\n\\n\\n # check whether the batch AD found an anomaly at that time stamps and copy into y_true at idx\\n y_true_i = random_timestamps[i] in anoms_s['datetime'].values\\n\\n # perform online AD, and write result to y_pred\\n y_pred_i, run_times_i = detect_ts_online(df_smooth, window_size, test_case_index)\\n \\n y_true.append(y_true_i)\\n y_pred.append(y_pred_i)\\n run_times.append(run_times_i)\\n \\n return fbeta_score(y_true, y_pred, beta=2), np.mean(run_times)\",\n \"def get_average_scores(self):\\n models = self.eval_parameters['average_experiment']['models']\\n metrics = self.eval_parameters['average_experiment']['metrics_list']\\n metrics_keys = list(metrics.keys())\\n print(r\\\"\\\\begin{table}[]\\\")\\n print(\\\"\\\\centering\\\")\\n print(r\\\"\\\\tiny\\\")\\n print(\\\"\\\\caption{Average results over 85 topics. Each row represents a different run (top 10 runs of each model). Each column represents a different assessments aggregation.}\\\")\\n print(\\\"\\\\label{tab:average_results}\\\")\\n print(r\\\"\\\\begin{tabular}{@{}\\\"+''.join(['l']*(len(metrics_keys)+1))+\\\"@{}}\\\")\\n print(\\\"runid\\\", '&'.join(metric.replace('_','\\\\_')for metric in metrics_keys),sep='&')\\n print(r\\\"\\\\\\\\ \\\\midrule\\\")\\n for model in models:\\n runs = self.get_list_files(self.eval_parameters['average_experiment']['runs_folder'] + model+\\\"/\\\")\\n for file in runs:\\n val = []\\n for metric_id in metrics_keys:\\n out1 = subprocess.check_output(\\n ['../trec_eval-master/trec_eval', '-m', metrics[metric_id]['metric'],\\n metrics[metric_id]['qrels'], file])\\n val += [str(out1.rstrip().split()[2]).replace('b\\\\'', '').replace('\\\\'', '')]\\n print(file.replace(self.eval_parameters['average_experiment']['runs_folder'],'').replace('_','\\\\_'),'&', '&'.join(val),r\\\"\\\\\\\\\\\")\\n print(r\\\"\\\\bottomrule\\\")\\n print(r\\\"\\\\end{tabular}\\\")\\n print(r\\\"\\\\end{table}\\\")\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\\"Process the results of an experiment.\\\")\\n parser.add_argument(\\\"experiment\\\")\\n arguments = parser.parse_args()\\n path = f\\\"experiments/{arguments.experiment}\\\"\\n if not os.path.exists(path):\\n raise SystemExit(f\\\"Path {path} does not exists.\\\")\\n\\n # For efficiency, one should generate the results from the parts without merging them.\\n files = [file for file in os.listdir(path) if os.path.isfile(os.path.join(path, file))]\\n frames = []\\n for file in files:\\n device, experiment, _ = file.split(\\\".\\\")\\n frame = pandas.read_csv(\\n os.path.join(path, file),\\n index_col=\\\"variable\\\",\\n usecols=[\\\"variable\\\", \\\"group_index\\\", \\\"value_i\\\"], dtype={\\\"value_i\\\": \\\"Int64\\\"}\\n )\\n frame[\\\"board\\\"] = device\\n frame[\\\"experiment\\\"] = experiment\\n frames.append(frame)\\n dataframe = pandas.concat(frames)\\n frames = None\\n\\n current_grouping = dataframe.groupby([\\\"group_index\\\", \\\"variable\\\"])\\n \\n data = current_grouping.agg([\\n numpy.median,\\n _percentile_factory(95),\\n numpy.mean,\\n numpy.std,\\n \\\"count\\\"\\n ])\\n\\n print(data)\\n \\n data = data.droplevel([0], axis=1)\\n data = data.unstack()\\n data.columns = data.columns.map('_'.join)\\n data.to_csv(f\\\"{arguments.experiment}.csv\\\")\",\n \"def _generate_report(self):\\n total_duration = 0.0\\n total_nb_tests = 0\\n total_nb_success = 0\\n nb_modules = 0\\n payload = []\\n\\n res_table = prettytable.PrettyTable(\\n padding_width=2,\\n field_names=['Module', 'Duration', 'nb. Test Run', 'Success'])\\n res_table.align['Module'] = \\\"l\\\"\\n res_table.align['Duration'] = \\\"r\\\"\\n res_table.align['Success'] = \\\"r\\\"\\n\\n # for each scenario we draw a row for the table\\n for item in self.summary:\\n if item['task_status'] is True:\\n nb_modules += 1\\n total_duration += item['overall_duration']\\n total_nb_tests += item['nb_tests']\\n total_nb_success += item['nb_success']\\n try:\\n success_avg = 100 * item['nb_success'] / item['nb_tests']\\n except ZeroDivisionError:\\n success_avg = 0\\n success_str = f\\\"{success_avg:0.2f}%\\\"\\n duration_str = time.strftime(\\\"%H:%M:%S\\\",\\n time.gmtime(item['overall_duration']))\\n res_table.add_row([item['test_name'], duration_str,\\n item['nb_tests'], success_str])\\n payload.append({'module': item['test_name'],\\n 'details': {'duration': item['overall_duration'],\\n 'nb tests': item['nb_tests'],\\n 'success rate': success_str,\\n 'success': item['success'],\\n 'failures': item['failures']}})\\n\\n total_duration_str = time.strftime(\\\"%H:%M:%S\\\",\\n time.gmtime(total_duration))\\n try:\\n self.result = 100 * total_nb_success / total_nb_tests\\n except ZeroDivisionError:\\n self.result = 100\\n success_rate = f\\\"{self.result:0.2f}\\\"\\n success_rate_str = str(success_rate) + '%'\\n res_table.add_row([\\\"\\\", \\\"\\\", \\\"\\\", \\\"\\\"])\\n res_table.add_row([\\\"TOTAL:\\\", total_duration_str, total_nb_tests,\\n success_rate_str])\\n\\n LOGGER.info(\\\"Rally Summary Report:\\\\n\\\\n%s\\\\n\\\", res_table.get_string())\\n LOGGER.info(\\\"Rally '%s' success_rate is %s%% in %s/%s modules\\\",\\n self.case_name, success_rate, nb_modules,\\n len(self.summary))\\n self.details['summary'] = {'duration': total_duration,\\n 'nb tests': total_nb_tests,\\n 'nb success': success_rate}\\n self.details[\\\"modules\\\"] = payload\",\n \"def _on_train_begins(self, val):\\n self.global_rmse.append(self._compute_rmse(self.ratings))\\n header_string = '{} \\\\t | \\\\t {} \\\\t '.format('Iteration', 'RMSE')\\n num_dashes = 40\\n if val is not None:\\n header_string += ' \\\\t | \\\\t {}'.format('Validation RMSE')\\n self.validation_rmse.append(self._compute_rmse(val))\\n num_dashes = 70\\n print(num_dashes*'-')\\n print(header_string)\\n print(num_dashes*'-')\",\n \"def _run_permutation(self, params):\\n iter_df, iter_xyz = params\\n iter_xyz = np.squeeze(iter_xyz)\\n iter_df[[\\\"x\\\", \\\"y\\\", \\\"z\\\"]] = iter_xyz\\n stat_values = self._compute_summarystat(iter_df)\\n return stat_values\",\n \"def run(self):\\n self.evaluate()\\n self.accumulate()\\n self.summarize()\",\n \"def test_num_evals(self):\\n\\t\\tdetails = self.watcher.describe()\\t\\t\\n\\t\\tself.assertTrue((details.M * details.rf == details.num_evals).all())\",\n \"def test_num_evals(self):\\n\\t\\tdetails = self.watcher.describe()\\t\\t\\n\\t\\tself.assertTrue((details.M * details.rf == details.num_evals).all())\",\n \"def experiment1_outliers():\\n\\tdata_folder = \\\"ckan_subset/prepared_learnset/\\\"\\n\\ttest_folder = 'ckan_subset/testset/xml_csv/'\\n\\tgm = Graph_Maker()\\n\\tgm.store()\\n\\trounds = 5\\n\\tx = [\\\"Fingerprint\\\", \\\"Syntax Feature Model\\\", \\\"Word2Vec Matcher\\\"]\\n\\t\\n\\tnumber_of_classes = 15\\n\\texamples_per_class = 0\\n\\taccuracies = []\\n\\tprecisions = []\\n\\trecalls = []\\n\\tfmeasures = []\\n\\tsf_main = Storage_Files(data_folder, classes)\\n\\ttmp_acc = []\\n\\ttmp_prec = []\\n\\ttmp_rec = []\\n\\ttmp_fmeasure = []\\n\\ttotal_actual = []\\n\\ttotal_predicted = []\\n\\n\\tfor i in range(0, rounds):\\n\\t\\tprint(\\\"Fingerprint\\\")\\n\\t\\t# --- Fingerprint\\n\\t\\tccc = Column_Classification_Config()\\n\\t\\tccc.add_feature('feature_main', 'Fingerprint', [sf_main, number_of_classes, examples_per_class, False, False])\\n\\n\\t\\tccc.add_matcher('matcher', 'Fingerprint_Matcher', {'feature_main': 'fingerprint'}) # main classifier\\n\\t\\tsm = Schema_Matcher(ccc)\\n\\t\\tactual, predicted = execute_test_ckan(sm, test_folder, False)\\n\\t\\ttotal_actual += actual\\n\\t\\ttotal_predicted += predicted\\n\\t\\taccuracy = accuracy_score(actual, predicted)\\n\\t\\ttmp_acc.append(accuracy)\\n\\t\\ttmp_prec.append(precision(actual, predicted))\\n\\t\\ttmp_rec.append(recall(actual, predicted))\\n\\t\\ttmp_fmeasure.append(f_measure(actual, predicted))\\n\\n\\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\\n\\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\\n\\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\\n\\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\\n\\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\\n\\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\\n\\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\\n\\t\\n\\ttmp_acc = []\\n\\ttmp_prec = []\\n\\ttmp_rec = []\\n\\ttmp_fmeasure = []\\n\\ttotal_actual = []\\n\\ttotal_predicted = []\\n\\tfor i in range(0, rounds):\\n\\t\\tprint(\\\"SFM\\\")\\n\\t\\t# --- Syntax Feature Model\\n\\t\\tccc = Column_Classification_Config()\\n\\t\\tccc.add_feature('feature_main', 'Syntax_Feature_Model', [sf_main, 1, 0, False, False])\\n\\n\\t\\tccc.add_matcher('matcher', 'Syntax_Matcher', {'feature_main': 'syntax'}) # main classifier\\n\\t\\tsm = Schema_Matcher(ccc)\\n\\t\\tactual, predicted = execute_test_ckan(sm, test_folder, False)\\n\\t\\ttotal_actual += actual\\n\\t\\ttotal_predicted += predicted\\n\\t\\taccuracy = accuracy_score(actual, predicted)\\n\\t\\ttmp_acc.append(accuracy)\\n\\t\\ttmp_prec.append(precision(actual, predicted))\\n\\t\\ttmp_rec.append(recall(actual, predicted))\\n\\t\\ttmp_fmeasure.append(f_measure(actual, predicted))\\n\\n\\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\\n\\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\\n\\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\\n\\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\\n\\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\\n\\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\\n\\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\\n\\n\\ttmp_acc = []\\n\\ttmp_prec = []\\n\\ttmp_rec = []\\n\\ttmp_fmeasure = []\\n\\ttotal_actual = []\\n\\ttotal_predicted = []\\n\\tfor i in range(0, rounds):\\n\\t\\tprint(\\\"W2V\\\")\\n\\t\\t# --- Word2Vec Matcher\\n\\t\\tccc = Column_Classification_Config()\\n\\t\\tccc.add_feature('feature_main', 'Corpus', [sf_main, number_of_classes, examples_per_class, False, False])\\n\\n\\t\\tccc.add_matcher('matcher', 'Word2Vec_Matcher', {'feature_main': 'corpus'}) # main classifier\\n\\t\\tsm = Schema_Matcher(ccc)\\n\\t\\tactual, predicted = execute_test_ckan(sm, test_folder, False)\\n\\t\\ttotal_actual += actual\\n\\t\\ttotal_predicted += predicted\\n\\t\\taccuracy = accuracy_score(actual, predicted)\\n\\t\\ttmp_acc.append(accuracy)\\n\\t\\ttmp_prec.append(precision(actual, predicted))\\n\\t\\ttmp_rec.append(recall(actual, predicted))\\n\\t\\ttmp_fmeasure.append(f_measure(actual, predicted))\\n\\n\\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\\n\\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\\n\\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\\n\\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\\n\\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\\n\\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\\n\\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\\n\\n\\tgm.add_x(x)\\n\\t# accuracies = [0.4, 0.4, 0.4]\\n\\t# precisions = [0.5, 0.5, 0.5]\\n\\t# recalls = [0.62, 0.62, 0.62]\\n\\t# fmeasures = [0.23, 0.23, 0.28]\\n\\tgm.append_y(accuracies)\\n\\tgm.append_y(precisions)\\n\\tgm.append_y(recalls)\\n\\tgm.append_y(fmeasures)\\n\\tgm.store()\\n\\tsubtitle = \\\"Scores were averaged over \\\" + str(rounds) + \\\" tests with \\\" + str(len(classes)) + \\\" classes. \\\" + \\\\\\n\\t\\\"Number of simulated columns per class: \\\" + str(number_of_classes)\\n\\tlabels = [\\\"Accuracy\\\", \\\"Precision\\\", \\\"Recall\\\", \\\"F-Measure\\\"]\\n\\tgm.plot_bar_n(\\\"Matcher Type\\\", \\\"Score\\\", \\\"Accuracy of Matchers\\\", labels, subtitle=subtitle)\",\n \"def simulationWithDrug(numViruses, maxPop, maxBirthProb, clearProb, resistances,\\n mutProb, numTrials):\\n \\n #create viruses list\\n viruses = []\\n for i in range(numViruses):\\n viruses.append(ResistantVirus(maxBirthProb, clearProb, resistances, mutProb))\\n \\n #create test patient P1\\n results = np.zeros(numTrials*300).reshape(300,numTrials)\\n resultsPopResist = np.zeros(numTrials*300).reshape(300,numTrials)\\n \\n #runs numTrials of 300 steps, putting results in an array of 300 lines, \\n # numTrials columns\\n for t in range(numTrials) :\\n P1 = TreatedPatient(viruses, maxPop)\\n for s in range(150):\\n P1.update()\\n results[s][numTrials-1] += P1.getTotalPop()\\n resultsPopResist[s][numTrials-1] += P1.getResistPop(['guttagonol'])\\n \\n P1.addPrescription('guttagonol')\\n for s in range(150,300):\\n P1.update()\\n results[s][numTrials-1]+=P1.getTotalPop()\\n resultsPopResist[s][numTrials-1] += P1.getResistPop(['guttagonol'])\\n \\n \\n #calculating average of virus population size at each step \\n yValues1 = []\\n for i in range(300):\\n a = sum(results[i].tolist())/len(results[i])\\n yValues1.append(a)\\n \\n yValues2 = []\\n for i in range(300):\\n a = sum(resultsPopResist[i].tolist())/len(resultsPopResist[i])\\n yValues2.append(a)\\n\\n pylab.plot(yValues1,label='pop average')\\n pylab.plot(yValues2,'r--',label = 'resistant virus population')\\n pylab.title('virus pop average at each step')\\n pylab.legend()\\n pylab.xlabel('Time Steps')\\n pylab.ylabel('pop #')\\n pylab.show()\",\n \"def SkoptPaperStats(maxIters, numRuns):\\n\\n comm = MPI.COMM_WORLD\\n rank = comm.Get_rank()\\n\\n assert comm.Get_size() == numRuns, \\\"Please ensure there is one process running per run i.e \\\" + str(numRuns) + \\\" processes.\\\"\\n \\n # Define the problem bounds.\\n skoptBounds = [(10, 1300), (40, 230), (0, 90), (0, 90)]\\n\\n # Use the same seed list as previously.\\n seedList = [572505, 357073, 584216, 604873, 854690, 573165, 298975, 650770, 243921, 191168]\\n\\n # The target for each algorithm. This was determined by using the values in the literature, so there is clearly some deviation either due to the detuning or computation.\\n globalFoM = 1.033\\n\\n if rank == 0:\\n timeList = []\\n iterationList = []\\n\\n # Define which solver will be used.\\n optimiser = skopt.Optimizer(skoptBounds, base_estimator = \\\"GP\\\", n_initial_points = int(np.ceil(maxIters/10)), random_state = seedList[rank])\\n\\n # Start timing.\\n startTime = time.time()\\n timeElapsed = None\\n iterationSuccess = None\\n\\n # Start optimisation.\\n for iteration in range(maxIters):\\n\\n # Make one suggestion.\\n nextParams = optimiser.ask()\\n\\n # Check what FoM this gives. Go negative as this is a minimisation routine.\\n fEval = FitnessSkopt(nextParams)\\n\\n # Update best FoM.\\n if abs(fEval) >= globalFoM:\\n # The algorithm has managed to surpass or equal the paper value.\\n iterationSuccess = iteration\\n timeElapsed = time.time() - startTime\\n \\n if rank == 0:\\n iterationList.append(iterationSuccess)\\n timeList.append(timeElapsed)\\n\\n break\\n \\n # Tell the optimiser about the result.\\n optimiser.tell(nextParams, fEval)\\n\\n # Run complete. Send results to main process. Tags are unique identifiers.\\n if rank != 0:\\n comm.send(timeElapsed, dest = 0, tag = 1)\\n comm.send(iterationSuccess, dest = 0, tag = 2)\\n\\n # Wait for all the processes to end.\\n comm.Barrier()\\n\\n if rank == 0:\\n # Aggregate the data.\\n for process in range(comm.Get_size() - 1):\\n # Get the data.\\n individualTime = None\\n individualTime = comm.recv(individualTime, source = process + 1, tag = 1)\\n\\n individualIter = None\\n individualIter = comm.recv(individualIter, source = process + 1, tag = 2)\\n\\n if individualIter is not None:\\n # Both values must therefore be non-null.\\n iterationList.append(individualIter)\\n timeList.append(individualTime)\\n\\n avgRuntime = np.average(timeList)\\n avgIters = np.average(iterationList)\\n try:\\n\\n fastestTime = np.min(timeList)\\n\\n except ValueError:\\n \\n # List is empty.\\n fastestTime = float('NaN')\\n\\n numSuccess = len(iterationList)\\n successRate = numSuccess/numRuns\\n\\n print(\\\"Bayesian optimisation paper testing complete! Here are the stats:\\\")\\n print(\\\"Number of successful runs: \\\" + str(numSuccess) + \\\" (Success rate of \\\" + str(successRate) + \\\")\\\")\\n print(\\\"Average iterations required for success: \\\" + str(avgIters))\\n print(\\\"Average time required for success: \\\" + str(avgRuntime))\\n print(\\\"Fastest convergence time: \\\" + str(fastestTime))\\n print(\\\"------------------------------------------------------------------------------------------------------------------\\\")\\n \\n return\",\n \"def run():\\n trials = 100\\n\\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\\n\\n mean_penalty = []\\n median_penalty = []\\n std_penalty = []\\n\\n mean_trial_time = []\\n median_trial_time = []\\n std_trial_time = []\\n\\n mean_success_rate = []\\n median_success_rate = []\\n std_success_rate = []\\n\\n for m in multipliers:\\n all_penalties = [] # All penalties from trail sets\\n all_average_trial_time = []\\n all_success_rates = []\\n\\n for i in range(0, 20):\\n # print \\\"Trial set:\\\", i\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n agent = e.create_agent(LearnerAgent) # create agent\\n agent.mult = m\\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\\n\\n sim.run(n_trials=trials) # run for a specified number of trials\\n\\n all_penalties.append(agent.all_trails_penalties)\\n all_average_trial_time.append(agent.time/float(trials))\\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\\n\\n mean_penalty.append(np.mean(all_penalties))\\n median_penalty.append(np.median(all_penalties))\\n std_penalty.append(np.std(all_penalties))\\n\\n mean_trial_time.append(np.mean(all_average_trial_time))\\n median_trial_time.append(np.median(all_average_trial_time))\\n std_trial_time.append(np.std(all_average_trial_time))\\n\\n mean_success_rate.append(np.mean(all_success_rates))\\n median_success_rate.append(np.median(all_success_rates))\\n std_success_rate.append(np.std(all_success_rates))\\n\\n for i in range(0, len(multipliers)):\\n print \\\"\\\"\\n print \\\"Multiplier:\\\", multipliers[i]\\n print \\\"\\\"\\n print \\\"Mean penalty per {} trials:\\\".format(trials), mean_penalty[i]\\n print \\\"Median penalty per {} trials:\\\".format(trials), median_penalty[i]\\n print \\\"Std.Dev. penalty per {} trials:\\\".format(trials), std_penalty[i]\\n\\n print \\\"\\\"\\n print \\\"Mean trial time:\\\", mean_trial_time[i]\\n print \\\"Median trial time:\\\", median_trial_time[i]\\n print \\\"Std.Dev. trial time:\\\", std_trial_time[i]\\n\\n print \\\"\\\"\\n print \\\"Mean success rate per {} trials:\\\".format(trials), mean_success_rate[i]\\n print \\\"Median success rate per {} trials:\\\".format(trials), median_success_rate[i]\\n print \\\"Std.Dev. success rate per {} trials:\\\".format(trials), std_success_rate[i]\",\n \"def _run_one_iteration(self, iteration):\\n statistics = iteration_statistics.IterationStatistics()\\n logging.info('Starting iteration %d', iteration)\\n num_episodes_train, average_reward_train, average_steps_per_second = (\\n self._run_train_phase(statistics))\\n active_num_episodes_eval, active_average_reward_eval = self._run_eval_phase(\\n statistics, 'active')\\n passive_num_episodes_eval, passive_average_reward_eval = (\\n self._run_eval_phase(statistics, 'passive'))\\n\\n self._save_tensorboard_summaries(iteration, num_episodes_train,\\n average_reward_train,\\n active_num_episodes_eval,\\n active_average_reward_eval,\\n passive_num_episodes_eval,\\n passive_average_reward_eval,\\n average_steps_per_second)\\n return statistics.data_lists\",\n \"def run_tests(augmenter, images, nb_runs):\\n results = np.zeros((nb_runs,))\\n for i in range(nb_runs):\\n start = time.time()\\n augmenter.augment_batch(images)\\n results[i] = time.time() - start\\n print(\\\"Run %d: %.8fs\\\" % (i, results[i]))\\n print(\\\"Mean: %.8fs\\\" % (results.mean(),))\\n print(\\\"Sum: %.8fs\\\" % (results.sum(),))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.596659","0.5817768","0.57848805","0.5778032","0.5736855","0.5722777","0.5721804","0.56309265","0.5599941","0.5561327","0.5554734","0.5542044","0.55361605","0.55108637","0.5486883","0.5457525","0.544647","0.542683","0.5396689","0.53914917","0.5365846","0.53630924","0.5362303","0.53572017","0.53560716","0.53171176","0.5314839","0.530668","0.5274999","0.52711713","0.52610487","0.52446944","0.5236576","0.52211875","0.52164066","0.5215632","0.52136517","0.5187748","0.5187202","0.5181244","0.51806694","0.51797867","0.5166662","0.5146342","0.51406175","0.51383716","0.5137452","0.51356196","0.5129472","0.5129467","0.51277137","0.5122218","0.51141816","0.51121247","0.5110988","0.5105525","0.5105429","0.51047474","0.51042545","0.5094303","0.50937045","0.50910115","0.5087711","0.50837475","0.50834864","0.507266","0.50724846","0.50686884","0.5064891","0.5063429","0.5060372","0.5057005","0.5055492","0.505239","0.50516766","0.504942","0.50459516","0.5041525","0.5041357","0.5037535","0.5035378","0.5034394","0.5033334","0.5031921","0.5031077","0.50151783","0.50079846","0.5007674","0.50055116","0.5005038","0.499827","0.49920914","0.49896428","0.49896428","0.49895197","0.49873385","0.49857455","0.49852887","0.49810395","0.49751127"],"string":"[\n \"0.596659\",\n \"0.5817768\",\n \"0.57848805\",\n \"0.5778032\",\n \"0.5736855\",\n \"0.5722777\",\n \"0.5721804\",\n \"0.56309265\",\n \"0.5599941\",\n \"0.5561327\",\n \"0.5554734\",\n \"0.5542044\",\n \"0.55361605\",\n \"0.55108637\",\n \"0.5486883\",\n \"0.5457525\",\n \"0.544647\",\n \"0.542683\",\n \"0.5396689\",\n \"0.53914917\",\n \"0.5365846\",\n \"0.53630924\",\n \"0.5362303\",\n \"0.53572017\",\n \"0.53560716\",\n \"0.53171176\",\n \"0.5314839\",\n \"0.530668\",\n \"0.5274999\",\n \"0.52711713\",\n \"0.52610487\",\n \"0.52446944\",\n \"0.5236576\",\n \"0.52211875\",\n \"0.52164066\",\n \"0.5215632\",\n \"0.52136517\",\n \"0.5187748\",\n \"0.5187202\",\n \"0.5181244\",\n \"0.51806694\",\n \"0.51797867\",\n \"0.5166662\",\n \"0.5146342\",\n \"0.51406175\",\n \"0.51383716\",\n \"0.5137452\",\n \"0.51356196\",\n \"0.5129472\",\n \"0.5129467\",\n \"0.51277137\",\n \"0.5122218\",\n \"0.51141816\",\n \"0.51121247\",\n \"0.5110988\",\n \"0.5105525\",\n \"0.5105429\",\n \"0.51047474\",\n \"0.51042545\",\n \"0.5094303\",\n \"0.50937045\",\n \"0.50910115\",\n \"0.5087711\",\n \"0.50837475\",\n \"0.50834864\",\n \"0.507266\",\n \"0.50724846\",\n \"0.50686884\",\n \"0.5064891\",\n \"0.5063429\",\n \"0.5060372\",\n \"0.5057005\",\n \"0.5055492\",\n \"0.505239\",\n \"0.50516766\",\n \"0.504942\",\n \"0.50459516\",\n \"0.5041525\",\n \"0.5041357\",\n \"0.5037535\",\n \"0.5035378\",\n \"0.5034394\",\n \"0.5033334\",\n \"0.5031921\",\n \"0.5031077\",\n \"0.50151783\",\n \"0.50079846\",\n \"0.5007674\",\n \"0.50055116\",\n \"0.5005038\",\n \"0.499827\",\n \"0.49920914\",\n \"0.49896428\",\n \"0.49896428\",\n \"0.49895197\",\n \"0.49873385\",\n \"0.49857455\",\n \"0.49852887\",\n \"0.49810395\",\n \"0.49751127\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58705"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":6379,"cells":{"query":{"kind":"string","value":"Write some output summaries for the dadi runs."},"document":{"kind":"string","value":"def write_out(self, niter, locuslen):\n try:\n handle = open(self.output, 'w')\n except OSError:\n print 'Error, you do not have permission to write files here.'\n extit(1)\n # First, write the pop names\n handle.write('#Pop 1: ' + self.popnames[0] + '\\n')\n handle.write('#Pop 2: ' + self.popnames[1] + '\\n')\n # Then write the run parameters\n handle.write('#Model: ' + self.modelname + '\\n')\n handle.write('#Max iterations: ' + str(niter) + '\\n')\n # Then write some model summaries\n handle.write('#Data Likelihoods: ' + ' '.join([str(s) for s in self.mod_like]) + '\\n')\n handle.write('#Optimized Likelihoods: ' + ' '.join([str(s) for s in self.opt_like]) + '\\n')\n handle.write('#AIC: ' + ' '.join([str(s) for s in self.aic]) + '\\n')\n handle.write('#LocusLem: ' + str(locuslen) + '\\n')\n handle.write('#4*Na*u*L: ' + str(self.theta_mean) + '\\n')\n handle.write('#Na: ' + str(self.Na) + '\\n')\n for name, val in zip(self.params['Names'], self.scaled_params):\n towrite = '#' + name + ': ' + str(val) + '\\n'\n handle.write(towrite)\n # Then a table of the parameters that were found\n handle.write('Iteration\\t' + '\\t'.join(self.params['Names']) + '\\n')\n handle.write('Initial\\t' + '\\t'.join([str(s) for s in self.params['Values']]) + '\\n')\n # Write the perturbed parameters\n for index, vals in enumerate(self.p_init):\n name = 'Perturbed_' + str(index) + '\\t'\n handle.write(name + '\\t'.join([str(s) for s in vals]) + '\\n')\n # And the hot annealed values\n for index, vals in enumerate(self.hot_params):\n name = 'Hot_Anneal_' + str(index) + '\\t'\n handle.write(name + '\\t'.join([str(s) for s in vals]) + '\\n')\n # And the cold annealed values\n for index, vals in enumerate(self.cold_params):\n name = 'Cold_Anneal_' + str(index) + '\\t'\n handle.write(name + '\\t'.join([str(s) for s in vals]) + '\\n')\n # And the BFGS parameters\n for index, vals in enumerate(self.opt_params):\n name = 'BFGS_' + str(index) + '\\t'\n handle.write(name + '\\t'.join([str(s) for s in vals]) + '\\n')\n # And the final params\n handle.write('Hot_Mean\\t' + '\\t'.join([str(s) for s in self.hot_mean]) + '\\n')\n handle.write('Cold_Mean\\t' + '\\t'.join([str(s) for s in self.cold_mean]) + '\\n')\n handle.write('BFGS_Mean\\t' + '\\t'.join([str(s) for s in self.bfgs_mean]) + '\\n')\n handle.flush()\n handle.close()\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _output_summary(self, run_id):\n time = self._summary.get_time_taken()\n time_delta = None\n num_tests_run_delta = None\n num_failures_delta = None\n values = [(\"id\", run_id, None)]\n failures = self._summary.get_num_failures()\n previous_summary = self._get_previous_summary()\n if failures:\n if previous_summary:\n num_failures_delta = failures - previous_summary.get_num_failures()\n values.append((\"failures\", failures, num_failures_delta))\n if previous_summary:\n num_tests_run_delta = self._summary.testsRun - previous_summary.testsRun\n if time:\n previous_time_taken = previous_summary.get_time_taken()\n if previous_time_taken:\n time_delta = time - previous_time_taken\n skips = len(self._summary.skipped)\n if skips:\n values.append((\"skips\", skips, None))\n output.output_summary(\n not bool(failures),\n self._summary.testsRun,\n num_tests_run_delta,\n time,\n time_delta,\n values,\n output=self.stream,\n )","def printResults(self):\n if self.statiFile and len(self.printOrder) > 0:\n try:\n file = open(abspath(self.statiFile), \"w\")\n except Exception as e:\n raise ErrorOutput(e)\n else:\n for stat in self.printOrder:\n if stat == Stati.INST:\n file.write(str(self.instCount)+\"\\n\")\n elif stat == Stati.VAR:\n var_count = self.countVars()\n file.write(str(var_count) + \"\\n\")\n file.close()","def log_summary(self, no_run_list):\n self.log_message('Entries not run' ,step='summary',status='start',name='config_file_reader')\n for name in no_run_list.keys():\n self.log_message('Did not run: '+name+', '+no_run_list[name],status='running')\n \n ret_total = 0\n for x in xrange(2):\n for ent in self.entries[x]:\n ret_total = ret_total + 0 if ent.return_val == None else ent.return_val\n self.log_message('Summary Complete, Run Time = ('+str(self.total_time)+')',status='complete')\n return ret_total","def write_summaries(self, summary_outputs, iteration_number):\r\n for _, summary in summary_outputs.items():\r\n self._writer.add_summary(summary, global_step=iteration_number)","def summarize(self):\n self.smalltalk += \"\\n Data IDs in this bundle: \\n\"\n self._files = {}\n inv_dict = {}\n # sort IDs to make sure pdfs are printed in same oder as they were\n # taken\n for k, v in self.stage_summaries.items():\n for qc_id in flatten_list(v):\n inv_dict[qc_id] = k\n sorted_ids = list(flatten_list(self.stage_summaries.values()))\n sorted_ids.sort(key=int)\n # for stage, value in self.stage_summaries.items():\n for qc_run_id in sorted_ids:\n # stage = inv_dict[qc_run_id]\n # if stage[0:7] == 'failed_':\n # stage = stage[7:]\n # try:\n # s = self.comments[qc_run_id]\n # except KeyError:\n # s = ''\n # self.comments[qc_run_id] = 'Classified as poor result.\\n' + s\n ds = Dataset(qc_run_id, self.db_name)\n device_name = ds.device_name\n f_folder = os.path.join(self.db_folder, \"tuning_results\", device_name)\n # for qc_run_id in flatten_list(value):\n self.smalltalk += str(qc_run_id) + \", \"\n\n # filename = stage + '_fit_ds'\n # filename += str(qc_run_id) + '.png'\n filename = os.path.join(f_folder, str(ds.ds.guid) + \".png\")\n\n self._files[str(qc_run_id)] = filename","def printResults(self, stream=sys.stdout):\n # Only master writes.\n if MPICommons.isMaster():\n stream.write(\"%15s %15s %15s %12s\\n\"%(\" time (t)\", \" count (n)\", \"(dn/dt) \", \"stdErr\"))\n n_tot = 0\n\t actualTot = 0\n t = 0.0\n for i,n in enumerate(self.__data):\n # Calculate the values to present.\n t = i * self.__time_interval\n actualTot += n\n dt = self.__time_interval\n n_tot += n\n dn = n\n rateEst = self.__floatAnalInterval*dn/dt\n stdErr = self.__floatAnalInterval*math.sqrt(dn)/dt\n # Only for times != zero.\n if (i > 0):\n stream.write(\"%15.5f %15i\"%(t, n_tot) +\" \"+ \"{:.6E}\".format(rateEst) +\" \"+\"{:.3E}\".format(stdErr) +\"\\n\")\n eqTime = self.__finalTime - self.__initialTime\n stream.write(\"\\nOverall we counted the following number of counts in the following amount of time: \" + \"%6i\"%(actualTot) + \" \" + \"{:.6E}\".format(eqTime))","def run_all(self):\n self.formatter.section_start('Scratch Memory Info')\n self.formatter.section_start('Per priority')\n self.analyse_per_priority()\n self.formatter.section_end()\n self.formatter.section_start('Per task')\n self.analyse_per_task()\n self.formatter.section_end()\n self.formatter.section_end()","def __printSummary(self, queryTargetId, rD, atomMap):\n logger.info(\"\\n---------------------------- %s -----------------------\", queryTargetId)\n outN = [\"bond_outliers\", \"angle_outliers\", \"torsion_outliers\", \"ring_outliers\"]\n for ind in outN:\n logger.info(\"Type: %-20s Outlier count: %4d\", ind, rD[ind])\n #\n outL = [\"bond_list\", \"angle_list\", \"torsion_list\", \"ring_list\"]\n for ind in outL:\n ll = rD[ind]\n logger.info(\"Feature: %-20s total count: %4d\", ind, len(ll))\n for dD in ll:\n if dD[\"unusual\"]:\n mappedAtomL = self.__mapAtomNames(dD[\"atom_labels\"], atomMap) if atomMap else dD[\"atom_labels\"]\n if dD[\"type\"] in [\"bond\", \"angle\"]:\n logger.info(\"%20s %20s %.4f %.4f %.4f %.4f\", dD[\"atom_labels\"], mappedAtomL, dD[\"value\"], dD[\"mean\"], dD[\"standard_deviation\"], dD[\"z_score\"])\n else:\n logger.info(\"%20s %20s %.4f %.4f %.4f %.4f\", dD[\"atom_labels\"], mappedAtomL, dD[\"value\"], dD[\"mean\"], dD[\"standard_deviation\"], dD[\"local_density\"])","def complete_run(self) -> None:\n super().complete_run()\n\n # Inspired by \"nox\"\n prefix = 'doit> '\n self.write(f'\\n{prefix}Summary:\\n')\n not_run_kwargs = {'exit_code': _TaskExitCode.NOT_RUN}\n for task_name in self._all_tasks:\n task_summary = self._task_summaries.get(task_name, _TaskSummary(name=task_name, **not_run_kwargs))\n self.write(prefix + _format_task_summary(task_summary) + '\\n')","def summarize(self):\n \n print self._num_tests, \"tests ran with\", len(self._failed_tests), \"failures:\", sorted(list(self._failed_tests))\n\n self._num_tests = 0\n self._failed_tests = set()","def write_output_summary(outfile, read_scores, args):\n\theader = ['sim_info_file', 'sim_sam_file', 'analysis_info_file', 'results_file', 'junc_type', 'score_type', \n\t\t\t 'true_positives', 'true_negatives', 'false_positives', 'false_negatives']\n\t\t\t \n\tfilenames = [args.sim_info, args.sim_sam, args.analysis_info, args.output]\n\ttypes = ['tp', 'tn', 'fp', 'fn']\n\t\t\t \n\twith open(args.output_summary, \"w\") as outfile:\n\t\toutfile.write(\"\\t\".join(header) + \"\\n\")\n\t\t\n\t\tfor score_type in read_scores:\n\t\t\tfor junc_type in read_scores[score_type]:\n\t\t\t\tif junc_type == 'discord':\n\t\t\t\t\tscores = [str(read_scores[score_type][junc_type][type]/2) for type in types]\n\t\t\t\telse:\n\t\t\t\t\tscores = [str(read_scores[score_type][junc_type][type]) for type in types]\n\t\t\t\tline = filenames + [junc_type, score_type] + scores\n\t\t\t\toutfile.write(\"\\t\".join(line) + \"\\n\")","def final_output_analysis(samples_dict, dir_results_path):\n with open(path.join(dir_results_path, 'corrupted_processes.txt'), 'w', encoding='utf-8', errors='replace') as c_out:\n with open(path.join(dir_results_path, 'analysis.txt'), 'w', encoding='utf-8', errors='replace') as i_out:\n with open(path.join(dir_results_path, 'syscalls.txt'), 'w', encoding='utf-8', errors='replace') as s_out:\n for uuid in sorted(samples_dict.keys()):\n reduced_sample = samples_dict[uuid]\n\n i_out.write('{} {}\\n'.format(string_utils.filename, uuid))\n s_out.write('{} {}\\n'.format(string_utils.filename, uuid))\n c_out.write('{} {}\\n'.format(string_utils.filename, uuid))\n\n # corrupted processes section\n process_repr = '\\t\\t{:15s}\\t{:10d}\\t{:15s}\\tby:\\t{:15s}\\t{:10d}\\n'\n for process in reduced_sample.corrupted_processes:\n c_out.write(process_repr.format(process[0],\n process[1],\n process[2],\n process[3],\n process[4]))\n\n # instruction count section\n i_out.write(string_utils.out_final + '\\t' + str(reduced_sample.total_instruction) + '\\n')\n i_out.write(string_utils.out_terminating + '\\t' + str(reduced_sample.terminate_all) + '\\t')\n i_out.write(string_utils.out_sleeping + '\\t' + str(reduced_sample.sleep_all) + '\\t')\n i_out.write(string_utils.out_crashing + '\\t' + str(reduced_sample.crash_all) + '\\t')\n i_out.write(string_utils.out_raising_error + '\\t' + str(reduced_sample.error_all) + '\\t')\n i_out.write(string_utils.out_writes_file + '\\t' + str(reduced_sample.write_file) + '\\n')\n\n # system calls count section\n s_out.write(string_utils.syscall_final + '\\t' + str(reduced_sample.total_syscalls) + '\\n')\n\n i_out.write('\\n')\n s_out.write('\\n')\n c_out.write('\\n')","def _generate_run_end_text(self) -> str:\n # Write the run summary:\n text = \"\\n####Run final summary - epoch {}:\".format(self._epochs)\n for property_name, property_value in self._extract_epoch_results().items():\n text += \"\\n * **{}**: {}\".format(\n property_name.capitalize(),\n self._markdown_print(value=property_value, tabs=2),\n )\n\n # Add the context final state:\n if self._context is not None:\n text += \"\\n####Context final state: ({})\".format(\n self._generate_context_link(context=self._context)\n )\n for property_name, property_value in self._extract_properties_from_context(\n context=self._context\n ).items():\n text += \"\\n * **{}**: {}\".format(\n property_name.capitalize(),\n self._markdown_print(value=property_value, tabs=2),\n )\n return text","def write_final_summary_text(self):\n # Log the run's final summary:\n self._write_text_to_tensorboard(\n tag=\"MLRun\",\n text=self._generate_run_end_text(),\n step=(\n self._validation_iterations\n if self._training_iterations == 0\n else self._training_iterations\n ),\n )","def print_summary(self):\n #outcomes = self.get_outcomes()\n #passes = 'Passes: %i' % sum(1 for outcome in outcomes if outcome == Result.PASS)\n #untested = 'Untested: %i' % sum(1 for outcome in outcomes if outcome == Result.UNTESTED)\n #errors = 'Errors: %i' % sum(1 for outcome in outcomes if outcome == Result.ERROR)\n #fails = 'Fails: %i' % sum(1 for outcome in outcomes if outcome == Result.FAIL)\n print('')\n print ('Passes: %i' % self.get_pass_count())\n print ('Fails: %i' % self.get_fail_count())\n print ('Errors: %i' % self.get_error_count())\n print ('Untested: %i' % self.get_untested_count())\n print ('Skipped: %i' % self.get_skipped_count())","def print_summary(self, write_files=True):\n\n assert self.info\n\n if not self.info.categories[\"integrated\"]:\n util.main_log(\n self.info.logfile,\n \"NO IMAGES SUCCESSFULLY PROCESSSED!\",\n (not self.gui_mode),\n )\n return\n\n summary = []\n summary.append(\"\\n\\n{:-^80}\\n\".format(\"SUMMARY\"))\n categories = [\n \"total\",\n \"failed_triage\",\n \"have_diffraction\",\n \"failed_spotfinding\",\n \"failed_indexing\",\n \"failed_grid_search\",\n \"failed_integration\",\n \"failed_filter\",\n \"integrated\",\n ]\n for cat in categories:\n lst, fail, fn, _ = self.info.categories[cat]\n path = os.path.join(self.info.int_base, fn)\n if len(lst) > 0 or cat in (\"integrated\", \"diffraction\"):\n summary.append(\"{: <20}: {}\".format(\"{} \".format(fail), len(lst)))\n with open(path, \"w\") as cf:\n for item in lst:\n if isinstance(item, tuple) or isinstance(item, list):\n item = \", \".join([str(i) for i in item])\n cf.write(\"{}\\n\".format(item))\n if cat == \"integrated\" and write_files:\n if not hasattr(self, \"prime_data_path\"):\n self.prime_data_path = path\n\n summary.append(\"\\n\\nIOTA version {0}\".format(iota_version))\n summary.append(\"{}\\n\".format(now))\n\n for item in summary:\n util.main_log(self.info.logfile, \"{}\".format(item), False)\n self.info.update(summary=summary)","def _show_summary(self):\n print 'Summary:'\n print ' Reports downloaded successfully: %d' % self.counts\n print ' Reports not downloaded: %d\\n' % self.failed","def write_stats(self, filestream):\n if not self.summary:\n self.summarize()\n\n print(self.scores, file=filestream)","def _write_ir_summaries(run_dir: str,\n timing: sample_summary_pb2.SampleTimingProto,\n summary_path: str):\n args = []\n\n unoptimized_path = os.path.join(run_dir, 'sample.ir')\n if os.path.exists(unoptimized_path):\n args.append('--unoptimized_ir=' + unoptimized_path)\n\n optimized_path = os.path.join(run_dir, 'sample.opt.ir')\n if os.path.exists(optimized_path):\n args.append('--optimized_ir=' + optimized_path)\n if not args:\n return\n\n subprocess.run(\n [\n SUMMARIZE_IR_MAIN_PATH,\n '--logtostderr',\n '--minloglevel=2',\n '--summary_file=' + summary_path,\n '--timing=' + str(timing),\n ] + args,\n check=False)","def _write_ir_summaries(run_dir: str,\n timing: sample_summary_pb2.SampleTimingProto,\n summary_path: str):\n args = []\n\n unoptimized_path = os.path.join(run_dir, 'sample.ir')\n if os.path.exists(unoptimized_path):\n args.append('--unoptimized_ir=' + unoptimized_path)\n\n optimized_path = os.path.join(run_dir, 'sample.opt.ir')\n if os.path.exists(optimized_path):\n args.append('--optimized_ir=' + optimized_path)\n if not args:\n return\n\n subprocess.run(\n [\n SUMMARIZE_IR_MAIN_PATH,\n '--logtostderr',\n '--minloglevel=2',\n '--summary_file=' + summary_path,\n '--timing=' + str(timing),\n ] + args,\n check=False)","def write_run(run):\n r=Run(run)\n r.write_all()","def _print_summary(case, summary):\n for dof, data in summary.items():\n b4b = data[\"Bit for Bit\"]\n conf = data[\"Configurations\"]\n stdout = data[\"Std. Out Files\"]\n print(\" \" + case + \" \" + str(dof))\n print(\" --------------------\")\n print(\" Bit for bit matches : \" + str(b4b[0]) + \" of \" + str(b4b[1]))\n print(\" Configuration matches : \" + str(conf[0]) + \" of \" + str(conf[1]))\n print(\" Std. Out files parsed : \" + str(stdout))\n print(\"\")","def summarize(self):\n info(\"Running \" + self.title + \" generator\")","def _printSummary(self):\n\t\t### COP OUT\n\t\tif self.params['background'] is True:\n\t\t\tself.stats['count'] += 1\n\t\t\treturn\n\n\t\t### THIS NEEDS TO BECOME MUCH MORE GENERAL, e.g. Peaks\n\t\ttdiff = time.time()-self.stats['startseries']\n\t\tif not self.params['continue'] or tdiff > 0.1:\n\t\t\tcount = self.stats['count']\n\t\t\t#if(count != self.stats['lastcount']):\n\t\t\tsys.stderr.write(\"\\n\\tSUMMARY: \"+self.functionname+\"\\n\")\n\t\t\tself._printLine()\n\t\t\tsys.stderr.write(\"\\tTIME: \\t\"+apDisplay.timeString(tdiff)+\"\\n\")\n\t\t\tself.stats['timesum'] = self.stats['timesum'] + tdiff\n\t\t\tself.stats['timesumsq'] = self.stats['timesumsq'] + (tdiff**2)\n\t\t\ttimesum = self.stats['timesum']\n\t\t\ttimesumsq = self.stats['timesumsq']\n\t\t\tif(count > 1):\n\t\t\t\ttimeavg = float(timesum)/float(count)\n\t\t\t\ttimestdev = math.sqrt(float(count*timesumsq - timesum**2) / float(count*(count-1)))\n\t\t\t\ttimeremain = (float(timeavg)+float(timestdev))*self.stats['seriesleft']\n\t\t\t\tsys.stderr.write(\"\\tAVG TIME: \\t\"+apDisplay.timeString(timeavg,timestdev)+\"\\n\")\n\t\t\t\t#print \"\\t(- TOTAL:\",apDisplay.timeString(timesum),\" -)\"\n\t\t\t\tif(self.stats['seriesleft'] > 0):\n\t\t\t\t\tsys.stderr.write(\"\\t(- REMAINING TIME: \"+apDisplay.timeString(timeremain)+\" for \"\n\t\t\t\t\t\t+str(self.stats['seriesleft'])+\" series -)\\n\")\n\t\t\t#print \"\\tMEM: \",(mem.active()-startmem)/1024,\"M (\",(mem.active()-startmem)/(1024*count),\"M)\"\n\t\t\tself.stats['count'] += 1\n\t\t\tself._printLine()","def output_run(run_data, name):\n\n print(json.dumps(run_data, indent=4))\n ret = run_data.get('return', {})\n display_output(\n {name: ret}, \n\tout=run_data.get('out', 'nested'),\n\topts = salt.config.minion_config('/dev/null'))","def pytest_terminal_summary(self, terminalreporter, exitstatus):\n # pylint: disable=unused-argument\n terminalreporter.section(\"Test Information\")\n for test, info in self._info.items():\n for datum in info:\n terminalreporter.write(\"{}: {}\\n\".format(test, datum))","def do_write(self, args):\n\t\tasplit = args.split(\" \")\n\t\tfname = asplit[0]\n\t\twhat = asplit[1]\n\n\t\tif what == \"summary\" or what == \"oldsummary\":\n\t\t\twith open(fname, 'w') as f:\n\t\t\t\tform = DresherInterface.summary_format if what == \"summary\" else DresherInterface.oldsummary_format\n\t\t\t\tfor i, x in enumerate(form):\n\t\t\t\t\tf.write(x)\n\t\t\t\t\tif i == len(form)-1:\n\t\t\t\t\t\tf.write(\"\\n\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t#for lang in sorted(self.languages, key = lambda l: len(l._phones.keys())):\n\t\t\t\t#\tdw.writerow(dict(zip(form, [self.get_language_info(lang, x) for x in form])))\n\t\t\t\tfor lang in sorted(self.languages, key = lambda l: len(l._phones.keys())):\n\t\t\t\t\tfor i, x in enumerate(form):\n\t\t\t\t\t\tf.write(str(self.get_language_info(lang, x)))\n\t\t\t\t\t\tif i == len(form)-1:\n\t\t\t\t\t\t\tf.write(\"\\n\")\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tf.write(\"\\t\")\n\t\tif what == \"hierarchies\":\n\t\t\t# format: #vowels, langname, hierarchy, len(hier), #of marks, lfeats, inv, freq, \n\t\t\t# how many times each feat marked, the actual marks, vowel:feature set, unused features\n\t\t\t# take fname to be name of directory to write outfiles to\n\t\t\tif not os.path.exists(fname):\n\t\t\t\tos.mkdir(fname)\n\t\t\tfor lang in self.languages:\n\t\t\t\tnum_vowels = self.get_language_info(lang, \"linv\")\n\t\t\t\tname = lang.name\n\t\t\t\tnum_feats = self.get_language_info(lang, \"lfeats\")\n\t\t\t\tinv = self.get_language_info(lang, \"inv\")\n\t\t\t\tfreq = self.get_language_info(lang, \"freq\")\n\t\t\t\tinv_feats = lang.phone_feat_dict\n\t\t\t\twith open(os.path.join(fname,name.replace(\" \",\"\")+\".txt\"), 'w') as f:\n\t\t\t\t\tf.write(\"num_vowels\\tname\\thierarchy\\tlen_hier\\tnum_marks\\tnumfeats\\tinv\\tfreq\\tfeat_marks\\tinv_marks\\tinv_feats\\tunused_feats\\n\")\n\t\t\t\t\tfor h in lang.hierarchies:\n\t\t\t\t\t\tf.write(str(num_vowels))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(name)\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(h))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(len(h)))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tspec = SDA(lang._phones, lang._features, h)\n\t\t\t\t\t\tmarkedness = sum([x for phone in spec.keys() for x in spec[phone] if x == 1])\n\t\t\t\t\t\tf.write(str(markedness))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(num_feats))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(inv))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(freq))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tfeat_counts = {f:sum([spec[phone][i] for phone in spec.keys() if spec[phone][i] == 1]) for i, f in enumerate(h)}\n\t\t\t\t\t\tf.write(str(feat_counts))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(spec))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(inv_feats))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(list(set(lang._features)-set(h))))\n\t\t\t\t\t\tf.write(\"\\n\")\n\t\t# make sure all the threads that need to be finished have finished\n\t\t# using .join() on the appropriate groups of threads","def printSummary(self):\n pass","def basic ( ) :\n \n die_file_paths = _sort_all_apropriate_files(options.input)\n \n for die_file_path in die_file_paths :\n \n print\n #print (\"loading die information from file: \" + die_file_path)\n die_description, die_roll_dict = _read_die_file (die_file_path)\n \n print (\"data for die with description: \" + die_description.strip())\n \n print \n \n print (\"raw roll data:\")\n for roll_value in sorted(die_roll_dict.keys()) :\n print (\"rolled \\t\" + str(roll_value) + \"\\t on the die \\t\"\n + str(die_roll_dict[roll_value]) + \"\\t time(s)\")\n \n print \n \n print (\"simple roll histogram:\")\n for roll_value in sorted(die_roll_dict.keys()) :\n bar_text = \"*\" * die_roll_dict[roll_value]\n print (str(roll_value) + \"\\t\" + bar_text)\n \n print \n \n side_val = numpy.array(die_roll_dict.keys( ), dtype=numpy.float)\n rolls = numpy.array(die_roll_dict.values( ), dtype=numpy.float)\n num_rolls = float(numpy.sum(rolls))\n avg_result = numpy.sum(rolls * side_val) / num_rolls\n \n print (\"average roll: \" + str(avg_result))\n \n print (\"------------\")","def dump_total_results(statistic_entries):\n individual_tests = sum([entry['correct answers'] + entry['wrong answers']\n for entry in statistic_entries])\n average_per_test = sum([entry['total time (s)'] for entry in statistic_entries]) \\\n / float(individual_tests)\n average_per_run = sum([entry['total time (s)'] for entry in statistic_entries]) \\\n / float(len(statistic_entries))\n\n best_time = min([entry['best time (s)'] for entry in statistic_entries])\n worst_time = max([entry['worst time (s)'] for entry in statistic_entries])\n\n print(\"\\nSummary for all done tests:\")\n print(\" %5d total test runs\" % len(statistic_entries))\n print(\" %5d individual tests\" % individual_tests)\n print(\" %5.1f individual tests per run\" % (individual_tests / float(len(statistic_entries))))\n print(\" %5.2f seconds per answer (average)\" % average_per_test)\n print(\" %5.2f seconds per run (average)\" % average_per_run)\n print(\" %5.2f seconds was best time.\" % best_time)\n print(\" %5.2f seconds was worst time.\" % worst_time)","def write_training_summaries(self):\n for metric, epochs in self._training_summaries.items():\n self._write_scalar_to_tensorboard(\n name=f\"{self._Sections.SUMMARY}/training_{metric}\",\n value=epochs[-1],\n step=self._epochs,\n )","def print_tests_results(self):\n\n for test in self.test_report:\n for detail in test:\n print detail + ': ', test[detail]","def write_background_stats(self, out_dir, all_output_lines):\r\n out_file = os.path.join(out_dir, \"simulations_stats.csv\")\r\n with open(out_file, \"w\") as file:\r\n col_names = \"sim_id,round,best_score,avg_score,solutions,elitist_candidates,elitism_rate,discard_rate,\" \\\r\n \"mutation_rate,colors\\n\"\r\n file.write(col_names)\r\n for lines_of_one_simulation in all_output_lines:\r\n for line in lines_of_one_simulation:\r\n file.write(line)","def summary(args, json_logs, all_logs):\n all_data = process_logs(json_logs)\n if args.debug:\n print(json.dumps(all_data))\n\n buf = io.StringIO()\n\n start = args.start.strftime(\"%m/%d/%Y %H:%M:%S\")\n end = args.end.strftime(\"%m/%d/%Y %H:%M:%S\")\n print(f\"Test Summary Report: {start} -> {end}\\n\", file=buf)\n\n # Calculate test failures per day/scenario\n all_days = {} # dict of per-scenario counts\n days = {} # dict of per-day -> per-scenario counts and test names\n top_failed = {} # dict of per-test failure counts\n top_flakes = {} # dict of per-test flake counts\n for day in sorted(all_data.keys()):\n days[day] = {}\n for scenario in sorted(all_data[day].keys()):\n if scenario not in all_days:\n all_days[scenario] = {\"success\": 0, \"missing\": 0, \"failed\": 0, \"flakes\": 0}\n\n # Figure out how many were successful, failed, or were flakes\n success, missing, failed, flakes = check_tests(all_data[day][scenario])\n\n days[day][scenario] = {\n \"success\": len(success),\n \"missing\": len(missing),\n \"failed\": len(failed),\n \"flakes\": len(flakes),\n \"missing-tests\": missing,\n \"failed-tests\": failed,\n \"flaky-tests\": flakes}\n all_days[scenario][\"success\"] += len(success)\n all_days[scenario][\"missing\"] += len(missing)\n all_days[scenario][\"failed\"] += len(failed)\n all_days[scenario][\"flakes\"] += len(flakes)\n\n for n in failed:\n top_failed[n] = top_failed.get(n, 0) + 1\n\n for n in flakes:\n top_flakes[n] = top_flakes.get(n, 0) + 1\n\n\n # Summary of tests per scenario\n print(\"Weekly summary\", file=buf)\n print(\"==============\", file=buf)\n for scenario in sorted(all_days.keys()):\n success = all_days[scenario][\"success\"]\n missing = all_days[scenario][\"missing\"]\n failed = all_days[scenario][\"failed\"]\n flakes = all_days[scenario][\"flakes\"]\n\n print(f\"{scenario}: Ran {success+failed+missing} tests. {success} passed, {failed} failed, {missing} missing, {flakes} flakes.\", file=buf)\n print(\"\\n\", file=buf)\n\n print(\"Top 5 failed tests for the week\", file=buf)\n for n in sorted((n for n in top_failed), key=lambda x: top_failed[x], reverse=True)[:5]:\n print(f\" {n} - {top_failed[n]}\", file=buf)\n print(\"\\n\", file=buf)\n\n print(\"Top 5 flaky tests for the week\", file=buf)\n for n in sorted((n for n in top_flakes), key=lambda x: top_flakes[x], reverse=True)[:5]:\n print(f\" {n} - {top_flakes[n]}\", file=buf)\n print(\"\\n\", file=buf)\n\n # Print daily stats\n for day in sorted(days.keys()):\n print(datetime.strptime(day, \"%Y%m%d\").strftime(\"%m/%d/%Y\"), file=buf)\n for scenario in sorted(days[day].keys()):\n s = days[day][scenario]\n success = s[\"success\"]\n missing = s[\"missing\"]\n failed = s[\"failed\"]\n total = success + failed + missing\n flakes = s[\"flakes\"]\n print(f\" {scenario} (Ran {total}, {success} passed, {failed} failed, {missing} missing. {flakes} flakes) :\", file=buf)\n if s[\"missing-tests\"]:\n print(\" Missing:\", file=buf)\n for n in s[\"missing-tests\"]:\n print(f\" {n}\", file=buf)\n if s[\"failed-tests\"]:\n print(\" Failed:\", file=buf)\n for n in sorted(s[\"failed-tests\"].keys()):\n print(f\" {n}\", file=buf)\n if s[\"flaky-tests\"]:\n print(\" Flakes:\", file=buf)\n for n in sorted(s[\"flaky-tests\"].keys()):\n print(f\" {n}\", file=buf)\n print(\"\\n\", file=buf)\n\n # Print the failure details for each scenario, on each day.\n for scenario in sorted(all_days.keys()):\n success = all_days[scenario][\"success\"]\n failed = all_days[scenario][\"failed\"]\n flakes = all_days[scenario][\"flakes\"]\n\n msg = f\"{scenario}: Ran {success+failed} tests. {success} passed, {failed} failed, {flakes} flakes.\"\n print(\"=\" * len(msg), file=buf)\n print(msg, file=buf)\n print(\"=\" * len(msg), file=buf)\n\n if args.flake_details:\n print(\"Failed test details\", file=buf)\n print(\"-------------------\", file=buf)\n print_test_details(scenario, days, \"failed-tests\", buf)\n\n if args.flake_details:\n print(\"\\nFlake test details\", file=buf)\n print(\"-------------------\", file=buf)\n print_test_details(scenario, days, \"flaky-tests\", buf)\n\n print(\"\\n\", file=buf)\n\n\n # Save the logs for the failures and flakes if a path is specified\n try:\n if args.archive_logs:\n archive_test_logs(days, args.archive_logs, all_logs)\n except RuntimeError as e:\n print(f\"\\nERROR: Problem archiving test logs - {e}\", file=buf)\n\n return buf.getvalue()","def print_acts_summary(master_results_data,\n master_results_pass,\n master_results_fail,\n master_results_unknown,\n pass_counter,\n fail_counter,\n unknown_counter,\n split_results=False,\n ):\n widths = [max(map(len, col)) for col in zip(*master_results_data)]\n if not split_results:\n for row in master_results_data:\n print(' '.join((val.ljust(width) for val, width in zip(row,\n widths))))\n print('')\n print('Pass: %s '\n 'Fail: %s '\n 'Unknown: %s '\n 'Total: %s' % (pass_counter,\n fail_counter,\n unknown_counter,\n pass_counter+fail_counter+unknown_counter))\n else:\n print('')\n for row in master_results_pass:\n print(' '.join((val.ljust(width) for val, width in zip(row,\n widths))))\n print('Pass: %s' % pass_counter)\n\n print('')\n for row in master_results_fail:\n print(' '.join((val.ljust(width) for val, width in zip(row,\n widths))))\n print('Fail: %s' % fail_counter)\n if unknown_counter is not 0:\n print('')\n for row in master_results_unknown:\n print(' '.join((val.ljust(width)\n for val, width in zip(row, widths))))\n print('Unknown: %s' % unknown_counter)","def makereport(reslist, file=sys.stdout, hasTOI=False, hasRuns=False):\n\n if not hasRuns: reslist=[reslist]\n \n for irun, resrun in enumerate(reslist):\n file.write(\"Run: %d\\n\" % irun)\n for det, res in resrun.items():\n file.write(\"%d\" % det)\n\n try:\n if not hasTOI: \n val = res[1][0]\n sig = res[1][1]\n else:\n val = res[-1][1][0]\n sig = res[-1][1][1]\n \n for (v, s) in zip(val, sig):\n file.write(\" %f +- %f\" % (v, s))\n except:\n print(\"\\n... when running \", irun, det, end=' ')\n print(\"Unexpected error:\", sys.exc_info()[0])\n \n file.write(\"\\n\")","def create_summary_statistics(forward_accuracy, backward_accuracy, merged_accuracy):\n summary_statistics = open(f'summary_statistics.txt', 'a')\n summary_statistics.write(f'The forward model has an accuracy of: {forward_accuracy}\\n')\n summary_statistics.write(f'The backward model has an accuracy of: {backward_accuracy}\\n')\n summary_statistics.write(f'The merged model has an accuracy of: {merged_accuracy}\\n')\n summary_statistics.close()","def write_epoch_summary_text(self):\n self._write_text_to_tensorboard(\n tag=\"MLRun\",\n text=self._generate_epoch_text(),\n step=self._training_iterations,\n )","def print_analysis(self,version,results,tests,test_details,test_order,\n output_dir,diffs_only):\n def format_result(r):\n return '%s %s' % (r.outcome,r.get_cause())\n\n main_template = makolookup.get_template(\"main.mako\")\n detail_template = makolookup.get_template(\"detail.mako\")\n\n f = open(os.path.join(output_dir,'index.html'),'w')\n try:\n f.write(main_template.render(version=version,results=results,tests=tests,\n test_details=test_details,test_order=test_order,\n time2datetime=time2datetime))\n finally:\n f.close()\n\n for test_id,test_detail in test_details.items():\n #print ('Detail: %s' % test_id)\n f = open(os.path.join(output_dir,test_id+'.html'),'w')\n try:\n f.write(detail_template.render(version=version,test_id=test_id,\n test_detail=test_detail,diffs_only=diffs_only))\n except:\n f.write(\"Error while processing output.\")\n finally:\n f.close()","def main() -> int:\n parser = argparse.ArgumentParser()\n parser.add_argument('--dir-metadata',\n type=pathlib.Path, required=True)\n\n args = parser.parse_args()\n\n with LockedMetadata(args.dir_metadata, __file__) as md:\n summary_dict = {}\n passing_tests = []\n failing_tests = []\n for f in md.tests_pickle_files:\n try:\n trr = TestRunResult.construct_from_pickle(f)\n summary_dict[f\"{trr.testname}.{trr.seed}\"] = \\\n ('PASS' if trr.passed else\n 'FAILED' + (\" {T}\" if (trr.failure_mode == Failure_Modes.TIMEOUT) else \"\"))\n if trr.passed:\n passing_tests.append(trr)\n else:\n failing_tests.append(trr)\n except RuntimeError as e:\n failing_tests.append(\n TestRunResult(\n name='broken_test',\n failure_message=str(e)\n ))\n\n md.regr_log = md.dir_run/'regr.log'\n md.regr_log_junit = md.dir_run/'regr_junit.xml'\n md.regr_log_junit_merged = md.dir_run/'regr_junit_merged.xml'\n\n # Write results as junit_xml\n with open(md.regr_log_junit,\n 'w',\n encoding='UTF-8') as junit_xml,\\\n open(md.regr_log_junit_merged,\n 'w',\n encoding='UTF-8') as junit_merged_xml:\n output_run_results_junit_xml(passing_tests, failing_tests,\n junit_xml,\n junit_merged_xml)\n\n with open(md.regr_log, 'w', encoding='UTF-8') as outfile:\n # Write results as regr.log (custom logfile format)\n output_results_text(passing_tests, failing_tests, summary_dict,\n outfile)\n\n test_summary_dict = create_test_summary_dict(passing_tests +\n failing_tests)\n\n cov_summary_dict = {}\n if md.simulator == \"xlm\":\n cov_summary_dict = create_cov_summary_dict(md)\n else:\n print(\"Warning: Not generating coverage summary, unsupported \" \\\n f\"simulator {md.simulator}\")\n\n html_report_filename = md.dir_run/'report.html'\n with open(html_report_filename, 'w') as outfile:\n output_results_html(md, passing_tests + failing_tests,\n test_summary_dict, cov_summary_dict, outfile)\n\n json_report_filename = md.dir_run/'report.json'\n with open(json_report_filename, 'w') as json_report_file:\n output_results_dvsim_json(md, test_summary_dict, cov_summary_dict,\n json_report_file)\n\n svg_summary_filename = md.dir_run/'summary.svg'\n with open(svg_summary_filename, 'w') as svg_summary_file:\n output_results_svg(test_summary_dict, cov_summary_dict,\n svg_summary_file)\n\n # Print a summary line to the terminal\n print(gen_summary_line(passing_tests, failing_tests))\n\n # Succeed if no tests failed\n return 1 if failing_tests else 0","def print_activity_run_details(activity_run):\n print(\"\\n\\tActivity run details\\n\")\n print(\"\\tActivity run status: {}\".format(activity_run.status))\n if activity_run.status == 'Succeeded':\n print(\"\\tNumber of bytes read: {}\".format(activity_run.output['dataRead']))\n print(\"\\tNumber of bytes written: {}\".format(activity_run.output['dataWritten']))\n print(\"\\tCopy duration: {}\".format(activity_run.output['copyDuration']))\n else:\n print(\"\\tErrors: {}\".format(activity_run.error['message']))","def display_results(summary):\n print ('Total running time %.2f secs (includes DB checks)'\n % summary.total_time)\n\n print 'OK:', summary.ok\n print 'Errors:', summary.errors\n\n # Display stats\n print 'Changes stats:'\n for var, s in summary.stats.iteritems():\n print '\\t%s:' % var,\n for x in s.iteritems():\n print '%s=%.2f' % x,\n print\n\n # Display profiling data\n print 'Profiling data:'\n for name, data in summary.profile.iteritems():\n print '\\t%s: %d calls, %.2fms' % (name, data['callcount'],\n data['time'] * 1000)","def write_results_dat(self, output_path):\n\n def fstr(nb):\n data = '%E' % nb\n if data == 'NAN':\n nb, power = 0,0\n else:\n nb, power = data.split('E')\n nb = float(nb) /10\n power = int(power) + 1\n return '%.5fE%+03i' %(nb,power)\n\n line = '%s %s %s %i %i %i %i %s %s %s %s %s %i\\n' % (fstr(self.axsec), fstr(self.xerru), \n fstr(self.xerrc), self.nevents, self.nw, self.maxit, self.nunwgt,\n fstr(self.luminosity), fstr(self.wgt), fstr(self.xsec), fstr(self.maxwgt),\n fstr(self.th_maxwgt), self.th_nunwgt) \n fsock = open(output_path,'w') \n fsock.writelines(line)\n for i in range(len(self.ysec_iter)):\n line = '%s %s %s %s %s %s\\n' % (i+1, self.ysec_iter[i], self.yerr_iter[i], \n self.eff_iter[i], self.maxwgt_iter[i], self.yasec_iter[i]) \n fsock.writelines(line)","def _publish_results(self):\n\n doc = Document()\n date = get_stamp()\n\n labels = ExperimentTemplateBase.parameters_to_string(self._topology_parameters_list)\n\n title = 'Mutual Information labels vs ' + self._experiment_name\n self.plot_save(title,\n self._mutual_info,\n self._baseline_mutual_info,\n 'Norm. mutual information',\n labels, date, self._docs_folder, doc)\n\n title = 'Weak classifier accuracy labels vs ' + self._experiment_name\n self.plot_save(title,\n self._classifier_accuracy,\n self._baseline_classifier_accuracy,\n 'Classifier accuracy',\n labels, date, self._docs_folder, doc) #, smoothing_size=3)\n\n title = 'average delta'\n f = plot_multiple_runs(\n self._different_steps[0], # here the X axes are identical\n self._average_delta,\n title=title,\n ylabel='log(delta)',\n xlabel='steps',\n labels=labels\n )\n add_fig_to_doc(f, path.join(self._docs_folder, title), doc)\n\n title = 'average boosting duration'\n f = plot_multiple_runs(\n self._different_steps[0],\n self._average_boosting_dur,\n title=title,\n ylabel='duration',\n xlabel='steps',\n labels=labels\n )\n add_fig_to_doc(f, path.join(self._docs_folder, title), doc)\n\n doc.write_file(path.join(self._docs_folder, to_safe_name(self._complete_name() + date + \".html\")))\n\n print('done')","def summarise(thislog):\n\n # Logfile name\n print(\"Summary for \" + thislog.filename() + \"\\n\")\n # Was it from CCP4i?\n if thislog.isccp4i():\n print(\"This is a CCP4i logfile\\n\")\n # Number of programs or pseudo-programs\n print(str(thislog.nfragments()) + \" logfile fragments\\n\")\n print(\"Fragments:\")\n for i in range(0, thislog.nfragments()):\n fragment = thislog.fragment(i)\n if fragment.isprogram():\n if fragment.has_attribute(\"name\"):\n print(\"\\tProgram: \" + str(fragment.name))\n else:\n print(\"\\tProgram: <no name>\")\n else:\n if fragment.isccp4i_info():\n print(\"\\tCCP4i info\")\n elif fragment.isfragment():\n print(\"\\tFragment\")\n if fragment.ntables():\n print(\"\\t\\t\" + str(fragment.ntables()) + \" tables\")\n if fragment.nkeytexts():\n print(\"\\t\\t\" + str(fragment.nkeytexts()) + \" keytexts\")\n\n print(\"\")\n # Summarise program logfile fragments\n if thislog.nprograms() > 0:\n print(str(thislog.nprograms()) + \" program logfiles\\n\")\n print(\"Programs:\")\n for i in range(0, thislog.nprograms()):\n prog = thislog.program(i)\n # Is it a CCP4 program?\n if prog.isccp4():\n # Print name, version (and CCP4 version)\n print(\n \"\\t\"\n + prog.name\n + \"\\tv\"\n + prog.version\n + \"\\t(CCP4 \"\n + prog.ccp4version\n + \")\"\n )\n else:\n # Print name and version\n if prog.has_attribute(\"name\") and prog.has_attribute(\"version\"):\n print(\"\\t\" + prog.name + \"\\t\" + prog.version)\n else:\n print(\"\\t<No name and/or version>\")\n if prog.termination():\n print(\"\\tTerminated with: \" + prog.termination_message)\n else:\n print(\"\\tNo termination message found\")\n # Keytexts\n if prog.nkeytexts():\n print(\"\\n\\t\\tKeytext messages:\")\n for j in range(0, prog.nkeytexts()):\n print(\n \"\\t\\t\"\n + str(prog.keytext(j).name())\n + ': \"'\n + str(prog.keytext(j).message())\n + '\"'\n )\n # Tables\n if prog.ntables():\n print(\"\\n\\t\\tTables:\")\n for table in prog.tables():\n print('\\t\\tTable: \"' + table.title() + '\"')\n print(\"\")\n else:\n print(\"No program logfiles found\")\n print(\"\")\n # Total set of CCP4i information messages in the file\n print(\"CCP4i messages in file:\")\n if thislog.nccp4i_info():\n for i in range(0, thislog.nccp4i_info()):\n print('\\tCCP4i info: \"' + thislog.ccp4i_info(i).message + '\"')\n else:\n print(\"\\tNo messages found\")\n print(\"\")\n # Total set of tables in the file\n print(\"Tables in file:\")\n if thislog.ntables():\n for table in thislog.tables():\n print('\\tTable: \"' + table.title() + '\" (' + str(table.nrows()) + \" rows)\")\n else:\n print(\"\\tNo tables found\")\n print(\"\")\n # Total set of keytexts in the file\n print(\"Keytext messages in file:\")\n if thislog.nkeytexts():\n for i in range(0, thislog.nkeytexts()):\n print(\n \"\\t\"\n + str(thislog.keytext(i).name())\n + ': \"'\n + thislog.keytext(i).message()\n + '\"'\n )\n else:\n print(\"\\tNo keytext messages found\")\n print(\"\")","def write_validation_summaries(self):\n for metric, epochs in self._validation_summaries.items():\n self._write_scalar_to_tensorboard(\n name=f\"{self._Sections.SUMMARY}/validation_{metric}\",\n value=epochs[-1],\n step=self._epochs,\n )","def debug_file(self, pkt_count, attack_count, data_list, ds_calc_time, ds_vals, metric_means, distances):\n # Current frame no. //\n # Current frame metric data //\n # Current sliding window data\n # Distances for each metric\n # DS probabilities, BPA's, time to calculate\n # Fusion results for each metric\n # Averages for each metric\n # Final result for frame\n # Current number of malicious frames detected\n metric_list = ['RSSI', 'Rate', 'NAV', 'Seq', 'TTL']\n x = [1, 2, 3, 4, 5]\n with open('debug.txt', 'a') as debug_file:\n debug_file.write('\\nFrame number: %d\\n' % pkt_count)\n debug_file.write('Current frame data. \\n')\n debug_file.writelines('%s : %d \\n ' % (metric, value) for metric, value in zip(self._features_to_analyse,\n data_list))\n debug_file.write('\\nCurrent sliding window data: \\n')\n debug_file.writelines('\\n%s:\\n %s \\nMean value = %f \\n' % (str(metric_array[0]), str(metric_array[1]), mean) for metric_array, mean in zip(self._sw_dict.items(), metric_means))\n debug_file.write('\\nDempster Shafer calculation times: \\n')\n\n if self._ds_timer is True:\n debug_file.writelines('Iteration %d time (s) = %f\\n' % (count, ds_time) for count, ds_time in zip(x, ds_calc_time))\n debug_file.write('Total time to calculate DS = %f (s)\\n' % sum(ds_calc_time))\n\n debug_file.write('Number of malicious frames detected: %d \\n' % attack_count)\n\n\n debug_file.close()","def _print_results_header(self):\n print(\"\\033[94m\"+\"Summary\\n\"+\"-\"*32+\"\\033[0m\")\n print(\"Subroutine: {}\".format(self.mc_sample.__name__))\n print(\"Num Runs: {:2.1e}\".format(self.num_runs))\n print(\"-\"*32+'\\n')","def execute_summary(self, step):\n with self.summary_writer.as_default():\n tf.summary.scalar('bias', self.core.fmlayer.b, step=step)\n tf.summary.scalar('regularization_penalty', self.regularization, step=step)\n tf.summary.scalar('loss', self.reduced_loss, step=step)\n tf.summary.scalar('target', self.target, step=step)","def write_output(self):","def _write_stats(self, stat_type, user=None, summ_type=None):\n if stat_type == \"full collection\":\n self.summary_file.write(\"\\n\\nDataset: {c}\\n\".format(c=self.dataset_name))\n self.summary_file.write(\"Number of unique urls: {u}\\nNumber of unique sites: {s}\\n\".format(u=len(set(self.stat_dict['urls'])), s=len(set(self.stat_dict['sites'])))\n )\n site_cnts = Counter(self.stat_dict['sites']).most_common()\n for site in site_cnts:\n self.summary_file.write(\"{s}: {n}\\n\".format(s=site[0], n=site[1]))\n\n if stat_type == \"token_counts\":\n self.summary_file.write(\"\\n\\nDataset: {c}\\n\".format(c=self.dataset_name))\n for doc_type in self.stat_dict:\n if user is not None:\n self.summary_file.write(\"\\n{0}, {1}\\n\".format(user, summ_type))\n\n self.summary_file.write(\n \"\\nNumber of {d}s: {p}\\nAverage tokens/{d}: {t}\\nAverage sentences/{d}: {s}\\n\".format(\n d=doc_type, p=len(self.stat_dict[doc_type][0]), t=sum(self.stat_dict[doc_type][1])/len(self.stat_dict[doc_type][1]), s=sum(self.stat_dict[doc_type][0])/len(self.stat_dict[doc_type][0])\n )\n )\n\n self.summary_file.write(\n \"Median tokens/{d}: {p}\\nStandard deviation tokens/{d}: {t}\\n\".format(\n d=doc_type, p=np.median(self.stat_dict[doc_type][1]), t=np.std(self.stat_dict[doc_type][1])\n )\n )\n\n self.summary_file.write(\n \"Median sentences/{d}: {p}\\nStandard deviation sentences/{d}: {t}\\n\".format(\n d=doc_type, p=np.median(self.stat_dict[doc_type][0]), t=np.std(self.stat_dict[doc_type][0])\n )\n )","def print_summary(metrics_list, labels_list):\n for metric, name in zip(metrics_list, labels_list):\n print('*' * 108)\n print(name)\n mean_inc_acc = []\n for i in range(metric.shape[0]):\n print('\\t', end='')\n for j in range(metric.shape[1]):\n print('{:5.2f}% '.format(100 * metric[i, j]), end='')\n if np.trace(metric) == 0.0:\n if i > 0:\n avg = 100 * metric[i, :i].mean()\n mean_inc_acc += [avg]\n print('\\tAvg.:{:5.2f}% '.format(avg), end='')\n else:\n avg = 100 * metric[i, :i + 1].mean()\n mean_inc_acc += [avg]\n print('\\tAvg.:{:5.2f}% '.format(avg), end='')\n print()\n print()\n\n # Computing AIA across all incremental states (thus excluding the first non-incremental state)\n print('\\tMean Incremental Acc.: {:5.2f}%'.format(np.mean(mean_inc_acc[1:])))\n print('*' * 108)","def print_results(self, final_table=None):\n\n assert self.info\n\n if not final_table:\n final_table = [\"\\n\\n{:-^80}\\n\".format(\"ANALYSIS OF RESULTS\")]\n\n if not self.info.categories[\"integrated\"]:\n final_table.append(\"NO IMAGES INTEGRATED!\")\n else:\n label_lens = [len(v[\"label\"]) for k, v in self.info.stats.items()]\n max_label = int(5 * round(float(np.max(label_lens)) / 5)) + 5\n for k, v in self.info.stats.items():\n if k in (\"lres\", \"res\", \"beamX\", \"beamY\"):\n continue\n line = (\n \"{: <{l}}: max = {:<6.2f} min = {:<6.2f} \"\n \"avg = {:<6.2f} ({:<6.2f})\"\n \"\".format(\n v[\"label\"], v[\"max\"], v[\"min\"], v[\"mean\"], v[\"std\"], l=max_label\n )\n )\n final_table.append(line)\n\n # TODO: Figure out what to do with summary charts\n # # If more than one integrated image, plot various summary graphs\n # if len(self.info.categories['integrated']) > 1:\n # plot = Plotter(self.params, self.info)\n # if self.params.analysis.summary_graphs:\n # if ( self.params.advanced.processing_backend == 'ha14' and\n # self.params.cctbx_ha14.grid_search.type is not None\n # ):\n # plot.plot_spotfinding_heatmap(write_files=True)\n # plot.plot_res_histogram(write_files=True)\n # med_beamX, med_beamY, pixel_size = plot.plot_beam_xy(write_files=True,\n # return_values=True)\n # else:\n # with warnings.catch_warnings():\n # # To catch any 'mean of empty slice' runtime warnings\n # warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n # beamXY_info = plot.calculate_beam_xy()\n # beamX, beamY = beamXY_info[:2]\n # med_beamX = np.median(beamX)\n # med_beamY = np.median(beamY)\n # pixel_size = beamXY_info[-1]\n\n final_table.append(\n \"{: <{l}}: X = {:<4.2f}, Y = {:<4.2f}\"\n \"\".format(\n \"Median Beam Center\",\n self.info.stats[\"beamX\"][\"mean\"],\n self.info.stats[\"beamY\"][\"mean\"],\n l=max_label,\n )\n )\n\n # Special entry for resolution last\n v = self.info.stats[\"res\"]\n final_table.append(\n \"{: <{l}}: low = {:<6.2f} high = {:<6.2f} \"\n \"avg = {:<6.2f} ({:<6.2f})\"\n \"\".format(\n v[\"label\"], v[\"max\"], v[\"min\"], v[\"mean\"], v[\"std\"], l=max_label\n )\n )\n\n for item in final_table:\n util.main_log(self.info.logfile, item, False)\n self.info.update(final_table=final_table)","def main(sc):\n\n # Load data set and parse out statistical counters\n delays = sc.textFile(DATASET).map(counters)\n\n # Perform summary aggregation by key\n delays = delays.reduceByKey(aggregation)\n delays = delays.map(summary)\n\n # Write the results out to disk\n delays.saveAsTextFile(\"delays-summary\")","def output(results):\n\n text_file = open(\"problem_1_B_output.txt\", \"w\")\n\n out = \"\"\n\n for i, line in enumerate(results):\n\n string = \"Sample {}: {}, posterior probability of {:.4f}\".format(i + 1,\n line[0],\n line[1])\n\n out += (string + \"\\n\")\n\n text_file.write(out)\n\n text_file.close()","def write_output():\n f = open(OUTPUT_FILE, 'w')\n for case_index, words in get_output():\n f.write('Case #%d: %s\\n' % (case_index, ' '.join(words)))\n f.close()","def print_statistics(self):\n print 'Ran %s iterations in %0.3f seconds\\n' % (\n self.iterations, self.elapsed_time)\n\n print 'Overall Equity'\n for index in range(len(self.holdem_ranges)):\n range_short_form = '%r' % self.holdem_ranges[index]\n print 'P%s) %-15s %0.3f' % (\n index,\n range_short_form,\n float(self.win_stats.get(index, 0))/self.iterations)\n print '\\n'\n print 'Hand distribution for each player'\n for stats in self.player_stats:\n stats.print_report()","def output_summary_stats(self):\n total_return = self.equity_curve['equity_curve'][-1]\n returns = self.equity_curve['returns']\n pnl = self.equity_curve['equity_curve']\n\n sharpe_ratio = create_sharpe_ratio(returns)\n drawdown, max_dd, dd_duration = create_drawdowns(pnl)\n self.equity_curve['drawdown'] = drawdown\n if len(dd_duration) == 1:\n dd_duration = dd_duration[0]\n\n stats = [(\"Total Return\", \"%0.2f%%\" % ((total_return - 1.0) * 100.0)),\n (\"Sharpe Ratio\", \"%0.2f\" % sharpe_ratio),\n (\"Max Drawdown\", \"%0.2f%%\" % (max_dd * 100.0)),\n (\"Drawdown Duration\", \"%s\" % dd_duration)]\n\n self.equity_curve.to_csv('equity.csv')\n self.positions.to_csv('positions.csv')\n self.prices.to_csv('prices.csv')\n\n return stats","def printMachineStatOut():\n print(\"---------------MACHINES STATS --------------------------\\n\", file=out_file)\n for machine in machines_list:\n cur_job_list = machine.retrieveJobsList()\n print(\"machine number \", machine.number, \"assigned jobs [number,length,type]:\", file=out_file)\n l = []\n for job_number, job in cur_job_list.items():\n l.append(job)\n print(\"\".join(str(l)), file=out_file)\n\n print(\"Assigned types: \", machine.getTypes(), file=out_file)\n print(\"Types histogram: \", machine.types, \"Sum of each type: \", machine.types_sums, \"Makespan : \", machine.span,\n file=out_file)\n print(\"\\n\", file=out_file)\n print(\"Max makespan is : \", makeSpan(), file=out_file)","def main():\n data_visualisation()\n write_hyper_params()\n write_result_tables()\n write_box_plots()","def summarize(self, nthday=None):\n assert self.validate()\n D = self._data\n if nthday is None:\n daysel = slice(None)\n else:\n daysel = D['MJD'] < np.min(D['MJD']) + nthday\n D = D[daysel]\n tsched = 24 * D['tsched'].sum()\n topen = 24 * D['topen'].sum()\n tscience = 24 * D['tscience'].sum()\n print('Scheduled {:.3f} hr Open {:.3f}% Live {:.3f}%'.format(\n tsched, 100 * topen / max(1e-6, tsched), 100 * tscience / max(1e-6, topen)))\n print('=' * 82)\n print('PROG TILES NEXP SETUP ABT SPLIT ABT TEXP TSETUP TSPLIT TOPEN TDEAD')\n print('=' * 82)\n # Summarize by program.\n for program in self.tiles.programs:\n progidx = self.tiles.program_index[program]\n ntiles_p, ndone_p, nexp_p, nsetup_p, nsplit_p, nsetup_abort_p, nsplit_abort_p = [0] * 7\n tscience_p, tsetup_p, tsplit_p = [0.] * 3\n ntiles_all = 0\n sel = progidx\n ntiles = np.sum(self.tiles.program_mask[program])\n ndone = D['completed'][:, sel].sum()\n nexp = D['nexp'][:, sel].sum()\n nsetup = D['nsetup'][:, sel].sum()\n nsplit = D['nsplit'][:, sel].sum()\n nsetup_abort = D['nsetup_abort'][:, sel].sum()\n nsplit_abort = D['nsplit_abort'][:, sel].sum()\n tscience = 86400 * D['tscience'][:, sel].sum() / max(1, ndone)\n tsetup = 86400 * D['tsetup'][:, sel].sum() / max(1, ndone)\n tsplit = 86400 * D['tsplit'][:, sel].sum() / max(1, ndone)\n line = '{:6s} {} {:4d}/{:4d} {:5d} {:5d} {:3d} {:5d} {:3d} {:6.1f}s {:5.1f}s {:5.1f}s'.format(\n program, ' ', ndone, ntiles, nexp, nsetup, nsetup_abort, nsplit, nsplit_abort, tscience, tsetup, tsplit)\n print(line)","def print_results(self) -> None:\n print(\"=\" * 70, file=sys.stderr)\n total = 0.0\n max_points = 0.0\n for problem in self.problems:\n total += problem.run_tests()\n max_points += problem.max_grade\n print(f\"Total Grade: {total}/{max_points}\", file=sys.stderr)","def print_output(self):\n print(\"Reference score: \" + str(self.PotTax_reference.sum().TFI))\n print(\"Intervention score: \" + str(self.PotTax_intervention.sum().TFI))\n return","def main():\n run_test_summary1a()\n run_test_summary1c()\n run_test_summary1c()","def print_output():\n print(\"count: [primary: \"+str(primary_shards)+\", replica: \"+str(secondary_shards)+\"]\")\n print(\"size: [primary: \"+pretty_print_storage(total_size_primary)+\", replica: \"+pretty_print_storage(total_size_secondary)+\"]\")\n print(\"disk-max-node: \"+max_size_node_name)\n print(\"watermark-breached: \"+str(watermark_breached))","def validation_summaries(self, step):\n settings = self.settings\n dnn_summary_writer = self.dnn_summary_writer\n gan_summary_writer = self.gan_summary_writer\n DNN = self.DNN\n D = self.D\n G = self.G\n train_dataset = self.train_dataset\n validation_dataset = self.validation_dataset\n unlabeled_dataset = self.unlabeled_dataset\n dnn_predicted_train_labels = DNN(torch.tensor(\n train_dataset.examples.astype(np.float32)).to(gpu))[0].to('cpu').detach().numpy()\n dnn_train_label_errors = np.mean(np.abs(dnn_predicted_train_labels - train_dataset.labels))\n dnn_summary_writer.add_scalar('2 Train Error/MAE', dnn_train_label_errors, )\n dnn_predicted_validation_labels = DNN(torch.tensor(\n validation_dataset.examples.astype(np.float32)).to(gpu))[0].to('cpu').detach().numpy()\n dnn_validation_label_errors = np.mean(np.abs(dnn_predicted_validation_labels - validation_dataset.labels))\n dnn_summary_writer.add_scalar('1 Validation Error/MAE', dnn_validation_label_errors, )\n predicted_train_labels = D(torch.tensor(\n train_dataset.examples.astype(np.float32)).to(gpu))[0].to('cpu').detach().numpy()\n gan_train_label_errors = np.mean(np.abs(predicted_train_labels - train_dataset.labels))\n gan_summary_writer.add_scalar('2 Train Error/MAE', gan_train_label_errors, )\n predicted_validation_labels = D(torch.tensor(\n validation_dataset.examples.astype(np.float32)).to(gpu))[0].to('cpu').detach().numpy()\n gan_validation_label_errors = np.mean(np.abs(predicted_validation_labels - validation_dataset.labels))\n gan_summary_writer.add_scalar('1 Validation Error/MAE', gan_validation_label_errors, )\n gan_summary_writer.add_scalar('1 Validation Error/Ratio MAE GAN DNN',\n gan_validation_label_errors / dnn_validation_label_errors, )\n z = torch.tensor(MixtureModel([norm(-settings.mean_offset, 1), norm(settings.mean_offset, 1)]).rvs(\n size=[settings.batch_size, G.input_size]).astype(np.float32)).to(gpu)\n fake_examples = G(z, add_noise=False)\n fake_examples_array = fake_examples.to('cpu').detach().numpy()\n fake_predicted_labels = D(fake_examples)[0]\n fake_predicted_labels_array = fake_predicted_labels.to('cpu').detach().numpy()\n unlabeled_labels_array = unlabeled_dataset.labels[:settings.validation_dataset_size]\n label_wasserstein_distance = wasserstein_distance(fake_predicted_labels_array, unlabeled_labels_array)\n gan_summary_writer.add_scalar('Generator/Predicted Label Wasserstein', label_wasserstein_distance, )\n unlabeled_examples_array = unlabeled_dataset.examples[:settings.validation_dataset_size]\n unlabeled_examples = torch.tensor(unlabeled_examples_array.astype(np.float32)).to(gpu)\n unlabeled_predictions = D(unlabeled_examples)[0]\n if dnn_summary_writer.step % settings.summary_step_period == 0:\n unlabeled_predictions_array = unlabeled_predictions.to('cpu').detach().numpy()\n validation_predictions_array = predicted_validation_labels\n train_predictions_array = predicted_train_labels\n dnn_validation_predictions_array = dnn_predicted_validation_labels\n dnn_train_predictions_array = dnn_predicted_train_labels\n distribution_image = generate_display_frame(fake_examples_array, unlabeled_predictions_array,\n validation_predictions_array, dnn_validation_predictions_array,\n train_predictions_array, dnn_train_predictions_array, step)\n distribution_image = standard_image_format_to_tensorboard_image_format(distribution_image)\n gan_summary_writer.add_image('Distributions', distribution_image)","def log_output_data(self):\r\n with tf.name_scope('model_output'):\r\n for i in range(self.action_handler.get_number_actions()):\r\n variable_name = str(self.action_handler.action_list_names[i])\r\n tf.summary.histogram(variable_name + '_output', self.actor_last_row_layer[i])","def print_results(self):\n pass","def output_summary_stats(self, filename):\r\n\r\n total_return = self.equity_curve['equity_curve'][-1]\r\n returns = self.equity_curve['returns']\r\n pnl = self.equity_curve['equity_curve']\r\n\r\n sharpe_ratio = create_sharpe_ratio(returns, periods=252)\r\n drawdown, max_dd, dd_duration = create_drawdowns(pnl)\r\n self.equity_curve['drawdown'] = drawdown\r\n\r\n stats = [(\"Total Return\", \"%0.2f%%\" % \\\r\n ((total_return - 1.0) * 100.0)),\r\n (\"Sharpe Ratio\", \"%0.2f%%\" % sharpe_ratio),\r\n (\"Max Drawdown\", \"%0.2f%%\" % (max_dd * 100.0)),\r\n (\"Drawdown Duration\", \"%f\" % dd_duration)]\r\n self.equity_curve.to_csv(filename)\r\n return stats","def print_results(self, out_file):\n extra_results = [\n # Total test methods processed, excluding reruns.\n [\"Test Methods\", len(self.result_events)],\n [\"Reruns\", self.test_method_rerun_count]]\n\n # Output each of the test result entries.\n categories = [\n # result id, printed name, print matching tests?, detail label\n [EventBuilder.STATUS_SUCCESS,\n \"Success\", False, None],\n [EventBuilder.STATUS_EXPECTED_FAILURE,\n \"Expected Failure\", False, None],\n [EventBuilder.STATUS_FAILURE,\n \"Failure\", True, \"FAIL\"],\n [EventBuilder.STATUS_ERROR,\n \"Error\", True, \"ERROR\"],\n [EventBuilder.STATUS_EXCEPTIONAL_EXIT,\n \"Exceptional Exit\", True, \"ERROR\"],\n [EventBuilder.STATUS_UNEXPECTED_SUCCESS,\n \"Unexpected Success\", True, \"UNEXPECTED SUCCESS\"],\n [EventBuilder.STATUS_SKIP, \"Skip\", False, None],\n [EventBuilder.STATUS_TIMEOUT,\n \"Timeout\", True, \"TIMEOUT\"],\n [EventBuilder.STATUS_EXPECTED_TIMEOUT,\n # Intentionally using the unusual hyphenation in TIME-OUT to\n # prevent buildbots from thinking it is an issue when scanning\n # for TIMEOUT.\n \"Expected Timeout\", True, \"EXPECTED TIME-OUT\"]\n ]\n\n # Partition all the events by test result status\n result_events_by_status = self._partition_results_by_status(\n categories)\n\n # Print the details\n have_details = self._has_printable_details(\n categories, result_events_by_status)\n if have_details:\n self._print_banner(out_file, \"Issue Details\")\n for category in categories:\n self._report_category_details(\n out_file, category, result_events_by_status)\n\n # Print the summary\n self._print_summary_counts(\n out_file, categories, result_events_by_status, extra_results)\n\n if self.options.dump_results:\n # Debug dump of the key/result info for all categories.\n self._print_banner(out_file, \"Results Dump\")\n for status, events_by_key in result_events_by_status.items():\n out_file.write(\"\\nSTATUS: {}\\n\".format(status))\n for key, event in events_by_key:\n out_file.write(\"key: {}\\n\".format(key))\n out_file.write(\"event: {}\\n\".format(event))","def report(self, results):\n self.notice(\"Test Report\\n\")\n\n for count, group in enumerate(results, 1):\n results = (self._format_test(test, res) for test, res in group)\n results = (', ').join(results)\n self.notice(\"Test group %s:\\t%s\" % (count, results))\n\n self.divider()","def printResults(self):\n for key in self.mDict.keys():\n print ('for {:d}, entries = {:d} and exits = {:d}'.format (key, self.mDict.get(key).get ('entries'), self.mDict.get(key).get ('exits')))","def print_stats_to_file(file, cnt_insts, cnt_vars):\n\n for arg in sys.argv:\n if arg == \"--insts\":\n file.write(str(cnt_insts) + \"\\n\")\n elif arg == \"--vars\":\n file.write(str(cnt_vars) + \"\\n\")","def write_error_report(self):\n\n with open('runReport.txt', 'a') as report:\n report.write(\"Number of Hits: \" + str(self.num_hits) + '\\n')\n report.write(\"Number of Requests: \" + str(self.num_requests) + '\\n')\n report.write(\"Hit Rate: \" + str((self.num_hits / self.num_requests)))\n report.write(\"Datafiles downloaded: \" + str(self.num_datafiles))\n now = datetime.now()\n dt_string = now.strftime(\"%H:%M %m/%d/%Y\")\n report.write(\"Run finished \" + dt_string)","def add_summary(self):\n self.merged = tf.compat.v1.summary.merge_all()\n self.file_writer = tf.compat.v1.summary.FileWriter(self.config.dir_output,\n self.sess.graph)","def outputTiming():\r\n print ('N\\tSum \\tSet\\t String\\t Loop')\r\n for trial in [2**_ for _ in range(1,11)]:\r\n numbers = f'[random.randint(0, 2 ** 24) for _ in range({trial})]'\r\n \r\n methods = ['sumValues', 'uniqueCheckSet', 'uniqueCheckString', 'uniqueCheckLoop' ]\r\n counts = {}\r\n for meth in methods:\r\n counts[meth] = timeit.timeit(stmt=f'{meth}(numbers)', number=1000,\r\n setup=f'import random\\nfrom __main__ import {meth}\\nrandom.seed({trial})\\nnumbers = {numbers}')\r\n\r\n results = '\\t'.join(f'{counts[meth]:f}' for meth in methods)\r\n print (f'{trial}\\t{results}')","def und_generate_metrics(udb_file):\n log.info(f\"Running Analysis for commit: {udb_file} ...\")\n # stdout=subprocess.DEVNULL makes silent the stdout ,\n subprocess.call(f\"und analyze -db {udb_file}\", stdout=subprocess.DEVNULL)\n log.info(\"Calculating metrics and creating csv\")\n subprocess.call(f\"und metrics {udb_file}\")","def report(self):\n #i need to figure out how to pass all these in a list or something, woof.\n self.report_generator_module.run(\\\n self.total,\\\n self.unique,\\\n self.top_10,\\\n self.top_10_base,\\\n self.lengths,\\\n self.counts,\\\n self.one_to_six,\\\n self.trailing_number,\\\n self.last_1digit,\\\n self.last_2digit,\\\n self.last_3digit,\\\n self.last_4digit,\\\n self.last_5digit,\\\n self.charset)","def summary(self, verbosity=0, file=None):\n\n if type(file) == type(\"\"):\n f=open(file, \"w\")\n else: f= sys.stdout\n\n f.write(_(\"The number of vertices is %d. \") % self.number_of_vertices)\n f.write(_(\"The largest %s is %d.\\n\") % (self.degree_type, self.max_deg))\n f.write(\"\\nDegree distribution:\\n\")\n f.write(_(\" 0:%7.4f%%\\n\") % \\\n (self.n_0/self.number_of_vertices*100))\n\n column=1\n for degree, probability in self.dd:\n f.write(\" %5d:%7.4f%%\" % (degree, probability*100))\n if column == 5:\n f.write(\"\\n\")\n column=1\n else: column += 1\n f.write(\"\\n\")","def add_summary(self):\r\n self.merged = tf.summary.merge_all()\r\n self.file_writer = tf.summary.FileWriter(self.config.dir_output,\r\n self.sess.graph)","def output_data_stats(self, dictionary):\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Running: output_data_stats\"\n\t\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_ip_stats.csv', 'w')\n\t\tf.write('ip_pair, numTrue, numFalse, overallVote\\n')\n\t\tfor ip in IP_Pair.objects.all():\n\t\t\t#print len(dictionary[ip])\n\t\t\tnumTrue = sum(1 for vote in dictionary[ip] if vote)\n\t\t\tnumFalse = len(dictionary[ip])- numTrue\n\t\t\toverallVote = (numTrue > numFalse)\n\t\t\tf.write(str(ip) + ', ' + str(numTrue) + ', ' + str(numFalse)\n\t\t\t\t+ ', ' + str(overallVote) + '\\n')\n\t\tf.close()\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Wrote File: \" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_ip_stats.csv'","def summary(self):\n\n print(\n \"\\nModel trained with dataset %s that has maxlen=%d and charset=%s for %d epochs.\"\n % (self.dataset_name, self.maxlen, self.charset, self.epochs)\n )\n\n print(\n \"noise_std: %.6f, lstm_dim: %d, dec_layers: %d, td_dense_dim: %d, batch_size: %d, codelayer_dim: %d, lr: %.6f.\"\n % (\n self.noise_std,\n self.lstm_dim,\n self.dec_layers,\n self.td_dense_dim,\n self.batch_size,\n self.codelayer_dim,\n self.lr,\n )\n )","def printMdStatus(self, segment, MD_run_count, MD_skip_count):\n sys.stdout.write(self.writeMdStatus(segment, MD_run_count, MD_skip_count))\n sys.stdout.flush()","def printReport(self):\n\t\tself.app.printflush('Fetched: ' + str(self.fetched_count), self.app.IGNORE_EXIT_FLAG)\n\t\tself.app.printflush('Processes: ' + str(self.processes), self.app.IGNORE_EXIT_FLAG)\n\t\tself.app.printflush('Updated: ' + str(self.updated_count), self.app.IGNORE_EXIT_FLAG)\n\t\tself.app.printflush('Average page load time: ' + str(self.average_time), self.app.IGNORE_EXIT_FLAG)\n\t\tself.app.printflush('Returned with code: ' + repr(self.code_statistics), self.app.IGNORE_EXIT_FLAG)\n\t\tself.app.printflush('Closing Processes... ', self.app.IGNORE_EXIT_FLAG)","def print_summary_stats(self) -> None:\n print(\"Number of Users: {}\".format(len(self.all_users)))\n print(\"Number of Utterances: {}\".format(len(self.utterances)))\n print(\"Number of Conversations: {}\".format(len(self.conversations)))","def main():\n rows = []\n for path in DATA.glob(\"*.tsv\"):\n with path.open() as file:\n _header = next(file)\n for line in file:\n dead_id, when, alt_id = line.strip(\"\\n\").split(\"\\t\")\n rows.append((path.stem, dead_id, when, alt_id))\n\n rows = sorted(rows)\n\n with OUTPUT_PATH.open(\"w\") as file:\n print(*HEADER, sep=\"\\t\", file=file)\n for row in rows:\n print(*row, sep=\"\\t\", file=file)\n\n df = pd.DataFrame(rows, columns=[\"prefix\", \"dead_id\", \"date\", \"alternative_id\"])\n fig, ax = plt.subplots(figsize=(6, 3))\n sns.histplot(data=df, y=\"prefix\", ax=ax)\n ax.set_ylabel(\"\")\n ax.set_xscale(\"log\")\n ax.set_xlabel(\"Dead Identifiers\")\n fig.tight_layout()\n fig.savefig(SUMMARY_SVG_PATH)","def main():\n file_txt = open('results.txt','w+')\n positions = [1,10,100,1000]\n num_trials = 10000\n \n # Simulate the investment and plot histogram for different positions\n for position in positions:\n daily_ret = simulation(position, num_trials)\n plt.figure()\n plt.hist(daily_ret, 100, range=[-1,1])\n plt.title('The histogram of daily return for position ={}'.format(position))\n plt.xlabel('Daily return')\n plt.ylabel('The number of trials')\n plt.savefig('histogram_{}_pos.pdf'.format(str(position).zfill(4)))\n \n # Save the results of the simulation into a txt file \n file_txt.write('Position: {}\\n'.format(position))\n file_txt.write('Mean: {}; Std: {}\\n'.format(np.mean(daily_ret),np.std(daily_ret)))\n file_txt.write('\\n')\n file_txt.close()","def summary(self):\n\n print(\"input label:\", self.__input_label)\n print(\"target label:\", self.__target_label)\n print(\"denoising label:\", self.denoising_label)\n print(\"contains a successful DE:\", self.is_successful())","def add_summary(self):\n self.merged = tf.summary.merge_all()\n print(self.merged)\n self.file_writer = tf.summary.FileWriter(self.config.graph_output, self.sess.graph)","def output_summary_stats(self):\n total_return = self.equity_curve['equity_curve'][-1]\n returns = self.equity_curve['returns']\n pnl = self.equity_curve['equity_curve']\n \n sharpe_ratio = create_sharpe_ratio(returns, periods=252*6.5*60)\n drawdown, max_dd, dd_duration = create_drawdowns(pnl)\n self.equity_curve['drawdown'] = drawdown\n \n stats = [(\"Total Return\", \"%0.2f%%\" % ((total_return - 1.0) * 100.0)), \n (\"Sharpe Ratio\", \"%0.2f\" % sharpe_ratio), \n (\"Max Drawdown\", \"%0.2f%%\" % (max_dd * 100.0)), \n (\"Drawdown Duration\", \"%d\" % dd_duration)]\n \n self.equity_curve.to_csv('equity.csv')\n \n return stats","def outputs(self):\n pass","def show_runs(self,start=0,end=99999999,csv=False):\n if csv:\n print '{:>7}, {:>10}, {:>8}, {:>10}, {:3}, {:2}'.format('Run', \n 'Day', 'Time', 'Length', 'xtc', 'h5') \n \n else:\n print '='*72\n print 'Experiment {:}'.format(self.exp)\n print ' xtc dir {:}'.format(self.xtc_dir)\n print ' hdf5 dir {:}'.format(self.h5_dir)\n print '-'*72\n print '{:>7} {:>10} {:>8} {:>10} {:3} {:2}'.format('Run', 'Day', 'Time', \n 'Length', 'xtc', 'h5') \n print '-'*72\n \n for item in self.runs:\n run = item['num']\n if run >= start and run <= end:\n datestr = time.strftime('%Y-%m-%d',\n time.localtime(item['begin_time_unix']))\n timestr = time.strftime('%H:%M:%S',\n time.localtime(item['begin_time_unix']))\n if len(item['xtc_files']) > 0:\n xtc = 'xtc'\n else:\n xtc = ''\n \n if len(item['h5_files']) > 0:\n h5 = 'h5'\n else:\n h5 = ''\n \n begin_time = item['begin_time_unix']\n end_time = item['end_time_unix'] \n if end_time:\n dtime = end_time - begin_time\n flag = ' '\n else:\n dtime = time.time() - begin_time\n flag = '*'\n\n dmin = int(dtime/60)\n dsec = int(dtime % 60)\n if dmin > 0:\n dtstr = '{:4}m {:02}s'.format(dmin,dsec)\n else:\n dtstr = '{:02}s'.format(dsec)\n\n if csv:\n print '{:7}, {:10}, {:8}, {:>10}, {:3}, {:2}'.format(run,\n datestr, timestr, dtstr, xtc, h5)\n else:\n print '{:7} {:10} {:8} {:>10} {:3} {:2}'.format(run,\n datestr, timestr, dtstr, xtc, h5)\n\n if flag in '*':\n print '* Currently Acquiring Data for Run {:}'.format(run)","def debug(self):\n \n #path\n print('Path information:')\n for k, v in self.__path.items():\n print(k, v)\n \n #sample count\n print('Sample statistic of each phase')\n for k, v in self.__phase_sample_count.items():\n print(k, v)\n \n print('Sample statistic of each class')\n for k, v in self.__area_sample_count.items():\n print(k, v)\n \n print('Sample statistic of each train')\n for k, v in self.__train_sample_count.items():\n print(k, v)","def output_summary_stats(self):\n total_return = self.equity_curve['equity_curve'][-1]\n returns = self.equity_curve['returns']\n pnl = self.equity_curve['equity_curve']\n \n sharpe_ratio = create_sharpe_ratio(returns) #, periods=252*6.5*60) ??? \n drawdown, max_dd, dd_duration = create_drawdowns(pnl)\n self.equity_curve['drawdown'] = drawdown\n \n stats = [(\"Total Return\", \"%0.2f%%\" % ((total_return - 1.0) * 100.0)), \n (\"Sharpe Ratio\", \"%0.2f\" % sharpe_ratio), \n (\"Max Drawdown\", \"%0.2f%%\" % (max_dd * 100.0)), \n (\"Drawdown Duration\", \"%d\" % dd_duration)]\n \n self.equity_curve.to_csv('equity.csv')\n \n return stats","def log_evaluation(tester, name, description):\r\n\tfor dataset, output in tester.preds.items():\r\n\t\tresults = pandas.DataFrame.from_dict(output)\r\n\t\tpath = os.path.join(\r\n\t\t\tEXPERIMENT_PATH, tester.config[\"name\"] + '-' + dataset)\r\n\t\twith open(path + \".csv\", \"w\") as f:\r\n\t\t\tresults.to_csv(f, sep=\"\\t\", encoding='utf-8',\r\n\t\t\t\tfloat_format='%.3f', index=False)","def dataStats(self):\n print (\"Performing statistical analysis of the data\")\n # stuff to do","def test_summary(args, path):\n log = os.path.join(path, \"kstest.log.json\")\n with open(log) as f:\n data = json.load(f)\n scenario = data[0].get(\"scenario\", None)\n if not scenario:\n raise RuntimeError(\"No scenario found in %s\" % log)\n\n # The json log filename needs to be in the form of <scenario>-<YYYY-MM-DD>.json\n datename = f\"{scenario}-1990-01-01\"\n shutil.copy(log, datename+\".json\")\n datenames = [datename]\n all_logs = {datename: path}\n\n report = summary(args, (d+\".json\" for d in datenames), all_logs)\n if args.output:\n with open(args.output, \"w\") as f:\n f.write(report)\n else:\n print(report)","def print_test_details(scenario, days, test_name, buf):\n for d in days:\n if scenario not in days[d]:\n continue\n\n for n in days[d][scenario][test_name]:\n print(f\"\\n{n}:\", file=buf)\n for test in days[d][scenario][test_name][n]:\n if \"start_time\" not in test:\n start_time = \"\"\n else:\n start_time = datetime.fromtimestamp(test[\"start_time\"]).strftime(\"%m/%d/%Y %H:%M:%S\")\n\n if \"elapsed_time\" not in test:\n elapsed_time = 0\n else:\n elapsed_time = test[\"elapsed_time\"]\n\n # Get the result message\n msg = test[\"result\"].rsplit(\"FAILED:\")[-1]\n print(f' {start_time} ({elapsed_time}s): {msg}', file=buf)","def output_running_tasks(self):\r\n results_dirname = get_param(\"results_dir\")\r\n for user_id in range(get_param(\"num_users\")):\r\n filename = os.path.join(results_dirname, \"%s_running_tasks_%d\" %\r\n (get_param(\"file_prefix\"), user_id))\r\n running_tasks_file = open(filename, \"w\")\r\n self.write_running_tasks(running_tasks_file,\r\n self.running_tasks[user_id])\r\n running_tasks_file.close()\r\n \r\n # Output aggregate running tasks.\r\n filename = os.path.join(results_dirname, \"%s_running_tasks\" %\r\n get_param(\"file_prefix\"))\r\n running_tasks_file = open(filename, \"w\")\r\n self.write_running_tasks(running_tasks_file, self.total_running_tasks)\r\n running_tasks_file.close()","def write_report(self):\n\n def report_array(f, label, array):\n f.write(label)\n for val in array:\n f.write('{:.4f},\\t'.format(val))\n f.write('\\n')\n\n report_file = FLAGS.report_file\n\n with open(report_file, 'w') as f:\n f.write('Mean Error 2D: {}\\n'.format(\n safe_divide(self._error_2d, self._matched)))\n f.write('Mean 3D IoU: {}\\n'.format(\n safe_divide(self._iou_3d, self._matched)))\n f.write('Mean Azimuth Error: {}\\n'.format(\n safe_divide(self._azimuth_error, self._matched)))\n f.write('Mean Polar Error: {}\\n'.format(\n safe_divide(self._polar_error, self._matched)))\n\n f.write('\\n')\n f.write('IoU Thresholds: ')\n for threshold in self._iou_thresholds:\n f.write('{:.4f},\\t'.format(threshold))\n f.write('\\n')\n report_array(f, 'AP @3D IoU : ', self._iou_ap.aps)\n\n f.write('\\n')\n f.write('2D Thresholds : ')\n for threshold in self._pixel_thresholds:\n f.write('{:.4f},\\t'.format(threshold * 0.1))\n f.write('\\n')\n report_array(f, 'AP @2D Pixel : ', self._pixel_ap.aps)\n f.write('\\n')\n\n f.write('Azimuth Thresh: ')\n for threshold in self._azimuth_thresholds:\n f.write('{:.4f},\\t'.format(threshold * 0.1))\n f.write('\\n')\n report_array(f, 'AP @Azimuth : ', self._azimuth_ap.aps)\n f.write('\\n')\n\n f.write('Polar Thresh : ')\n for threshold in self._polar_thresholds:\n f.write('{:.4f},\\t'.format(threshold * 0.1))\n f.write('\\n')\n report_array(f, 'AP @Polar : ', self._polar_ap.aps)","def generate_summary(final_dictionary):\n otpt = open('multifind_summary.txt', 'w')\n for cat in final_dictionary:\n category_name = cat[0] + ': ' + str(len(cat[1])) + '\\n'\n otpt.write(category_name)\n for entry in cat[1]:\n otpt.write('\\t' + str(entry[0]) + '\\n')\n otpt.write('\\t\\tTotal Entries: %s\\n' % str(entry[1]))\n otpt.write('\\t\\tUnique Species: %s\\n' % str(entry[2]))\n count = 0\n for sp in entry[3]:\n if count < entry[2]-1:\n if count == 0:\n otpt.write('\\t\\tSpecies: ' + sp + ', ')\n else:\n otpt.write(sp + ', ')\n else:\n otpt.write(sp + '\\n')\n count += 1\n otpt.close()"],"string":"[\n \"def _output_summary(self, run_id):\\n time = self._summary.get_time_taken()\\n time_delta = None\\n num_tests_run_delta = None\\n num_failures_delta = None\\n values = [(\\\"id\\\", run_id, None)]\\n failures = self._summary.get_num_failures()\\n previous_summary = self._get_previous_summary()\\n if failures:\\n if previous_summary:\\n num_failures_delta = failures - previous_summary.get_num_failures()\\n values.append((\\\"failures\\\", failures, num_failures_delta))\\n if previous_summary:\\n num_tests_run_delta = self._summary.testsRun - previous_summary.testsRun\\n if time:\\n previous_time_taken = previous_summary.get_time_taken()\\n if previous_time_taken:\\n time_delta = time - previous_time_taken\\n skips = len(self._summary.skipped)\\n if skips:\\n values.append((\\\"skips\\\", skips, None))\\n output.output_summary(\\n not bool(failures),\\n self._summary.testsRun,\\n num_tests_run_delta,\\n time,\\n time_delta,\\n values,\\n output=self.stream,\\n )\",\n \"def printResults(self):\\n if self.statiFile and len(self.printOrder) > 0:\\n try:\\n file = open(abspath(self.statiFile), \\\"w\\\")\\n except Exception as e:\\n raise ErrorOutput(e)\\n else:\\n for stat in self.printOrder:\\n if stat == Stati.INST:\\n file.write(str(self.instCount)+\\\"\\\\n\\\")\\n elif stat == Stati.VAR:\\n var_count = self.countVars()\\n file.write(str(var_count) + \\\"\\\\n\\\")\\n file.close()\",\n \"def log_summary(self, no_run_list):\\n self.log_message('Entries not run' ,step='summary',status='start',name='config_file_reader')\\n for name in no_run_list.keys():\\n self.log_message('Did not run: '+name+', '+no_run_list[name],status='running')\\n \\n ret_total = 0\\n for x in xrange(2):\\n for ent in self.entries[x]:\\n ret_total = ret_total + 0 if ent.return_val == None else ent.return_val\\n self.log_message('Summary Complete, Run Time = ('+str(self.total_time)+')',status='complete')\\n return ret_total\",\n \"def write_summaries(self, summary_outputs, iteration_number):\\r\\n for _, summary in summary_outputs.items():\\r\\n self._writer.add_summary(summary, global_step=iteration_number)\",\n \"def summarize(self):\\n self.smalltalk += \\\"\\\\n Data IDs in this bundle: \\\\n\\\"\\n self._files = {}\\n inv_dict = {}\\n # sort IDs to make sure pdfs are printed in same oder as they were\\n # taken\\n for k, v in self.stage_summaries.items():\\n for qc_id in flatten_list(v):\\n inv_dict[qc_id] = k\\n sorted_ids = list(flatten_list(self.stage_summaries.values()))\\n sorted_ids.sort(key=int)\\n # for stage, value in self.stage_summaries.items():\\n for qc_run_id in sorted_ids:\\n # stage = inv_dict[qc_run_id]\\n # if stage[0:7] == 'failed_':\\n # stage = stage[7:]\\n # try:\\n # s = self.comments[qc_run_id]\\n # except KeyError:\\n # s = ''\\n # self.comments[qc_run_id] = 'Classified as poor result.\\\\n' + s\\n ds = Dataset(qc_run_id, self.db_name)\\n device_name = ds.device_name\\n f_folder = os.path.join(self.db_folder, \\\"tuning_results\\\", device_name)\\n # for qc_run_id in flatten_list(value):\\n self.smalltalk += str(qc_run_id) + \\\", \\\"\\n\\n # filename = stage + '_fit_ds'\\n # filename += str(qc_run_id) + '.png'\\n filename = os.path.join(f_folder, str(ds.ds.guid) + \\\".png\\\")\\n\\n self._files[str(qc_run_id)] = filename\",\n \"def printResults(self, stream=sys.stdout):\\n # Only master writes.\\n if MPICommons.isMaster():\\n stream.write(\\\"%15s %15s %15s %12s\\\\n\\\"%(\\\" time (t)\\\", \\\" count (n)\\\", \\\"(dn/dt) \\\", \\\"stdErr\\\"))\\n n_tot = 0\\n\\t actualTot = 0\\n t = 0.0\\n for i,n in enumerate(self.__data):\\n # Calculate the values to present.\\n t = i * self.__time_interval\\n actualTot += n\\n dt = self.__time_interval\\n n_tot += n\\n dn = n\\n rateEst = self.__floatAnalInterval*dn/dt\\n stdErr = self.__floatAnalInterval*math.sqrt(dn)/dt\\n # Only for times != zero.\\n if (i > 0):\\n stream.write(\\\"%15.5f %15i\\\"%(t, n_tot) +\\\" \\\"+ \\\"{:.6E}\\\".format(rateEst) +\\\" \\\"+\\\"{:.3E}\\\".format(stdErr) +\\\"\\\\n\\\")\\n eqTime = self.__finalTime - self.__initialTime\\n stream.write(\\\"\\\\nOverall we counted the following number of counts in the following amount of time: \\\" + \\\"%6i\\\"%(actualTot) + \\\" \\\" + \\\"{:.6E}\\\".format(eqTime))\",\n \"def run_all(self):\\n self.formatter.section_start('Scratch Memory Info')\\n self.formatter.section_start('Per priority')\\n self.analyse_per_priority()\\n self.formatter.section_end()\\n self.formatter.section_start('Per task')\\n self.analyse_per_task()\\n self.formatter.section_end()\\n self.formatter.section_end()\",\n \"def __printSummary(self, queryTargetId, rD, atomMap):\\n logger.info(\\\"\\\\n---------------------------- %s -----------------------\\\", queryTargetId)\\n outN = [\\\"bond_outliers\\\", \\\"angle_outliers\\\", \\\"torsion_outliers\\\", \\\"ring_outliers\\\"]\\n for ind in outN:\\n logger.info(\\\"Type: %-20s Outlier count: %4d\\\", ind, rD[ind])\\n #\\n outL = [\\\"bond_list\\\", \\\"angle_list\\\", \\\"torsion_list\\\", \\\"ring_list\\\"]\\n for ind in outL:\\n ll = rD[ind]\\n logger.info(\\\"Feature: %-20s total count: %4d\\\", ind, len(ll))\\n for dD in ll:\\n if dD[\\\"unusual\\\"]:\\n mappedAtomL = self.__mapAtomNames(dD[\\\"atom_labels\\\"], atomMap) if atomMap else dD[\\\"atom_labels\\\"]\\n if dD[\\\"type\\\"] in [\\\"bond\\\", \\\"angle\\\"]:\\n logger.info(\\\"%20s %20s %.4f %.4f %.4f %.4f\\\", dD[\\\"atom_labels\\\"], mappedAtomL, dD[\\\"value\\\"], dD[\\\"mean\\\"], dD[\\\"standard_deviation\\\"], dD[\\\"z_score\\\"])\\n else:\\n logger.info(\\\"%20s %20s %.4f %.4f %.4f %.4f\\\", dD[\\\"atom_labels\\\"], mappedAtomL, dD[\\\"value\\\"], dD[\\\"mean\\\"], dD[\\\"standard_deviation\\\"], dD[\\\"local_density\\\"])\",\n \"def complete_run(self) -> None:\\n super().complete_run()\\n\\n # Inspired by \\\"nox\\\"\\n prefix = 'doit> '\\n self.write(f'\\\\n{prefix}Summary:\\\\n')\\n not_run_kwargs = {'exit_code': _TaskExitCode.NOT_RUN}\\n for task_name in self._all_tasks:\\n task_summary = self._task_summaries.get(task_name, _TaskSummary(name=task_name, **not_run_kwargs))\\n self.write(prefix + _format_task_summary(task_summary) + '\\\\n')\",\n \"def summarize(self):\\n \\n print self._num_tests, \\\"tests ran with\\\", len(self._failed_tests), \\\"failures:\\\", sorted(list(self._failed_tests))\\n\\n self._num_tests = 0\\n self._failed_tests = set()\",\n \"def write_output_summary(outfile, read_scores, args):\\n\\theader = ['sim_info_file', 'sim_sam_file', 'analysis_info_file', 'results_file', 'junc_type', 'score_type', \\n\\t\\t\\t 'true_positives', 'true_negatives', 'false_positives', 'false_negatives']\\n\\t\\t\\t \\n\\tfilenames = [args.sim_info, args.sim_sam, args.analysis_info, args.output]\\n\\ttypes = ['tp', 'tn', 'fp', 'fn']\\n\\t\\t\\t \\n\\twith open(args.output_summary, \\\"w\\\") as outfile:\\n\\t\\toutfile.write(\\\"\\\\t\\\".join(header) + \\\"\\\\n\\\")\\n\\t\\t\\n\\t\\tfor score_type in read_scores:\\n\\t\\t\\tfor junc_type in read_scores[score_type]:\\n\\t\\t\\t\\tif junc_type == 'discord':\\n\\t\\t\\t\\t\\tscores = [str(read_scores[score_type][junc_type][type]/2) for type in types]\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tscores = [str(read_scores[score_type][junc_type][type]) for type in types]\\n\\t\\t\\t\\tline = filenames + [junc_type, score_type] + scores\\n\\t\\t\\t\\toutfile.write(\\\"\\\\t\\\".join(line) + \\\"\\\\n\\\")\",\n \"def final_output_analysis(samples_dict, dir_results_path):\\n with open(path.join(dir_results_path, 'corrupted_processes.txt'), 'w', encoding='utf-8', errors='replace') as c_out:\\n with open(path.join(dir_results_path, 'analysis.txt'), 'w', encoding='utf-8', errors='replace') as i_out:\\n with open(path.join(dir_results_path, 'syscalls.txt'), 'w', encoding='utf-8', errors='replace') as s_out:\\n for uuid in sorted(samples_dict.keys()):\\n reduced_sample = samples_dict[uuid]\\n\\n i_out.write('{} {}\\\\n'.format(string_utils.filename, uuid))\\n s_out.write('{} {}\\\\n'.format(string_utils.filename, uuid))\\n c_out.write('{} {}\\\\n'.format(string_utils.filename, uuid))\\n\\n # corrupted processes section\\n process_repr = '\\\\t\\\\t{:15s}\\\\t{:10d}\\\\t{:15s}\\\\tby:\\\\t{:15s}\\\\t{:10d}\\\\n'\\n for process in reduced_sample.corrupted_processes:\\n c_out.write(process_repr.format(process[0],\\n process[1],\\n process[2],\\n process[3],\\n process[4]))\\n\\n # instruction count section\\n i_out.write(string_utils.out_final + '\\\\t' + str(reduced_sample.total_instruction) + '\\\\n')\\n i_out.write(string_utils.out_terminating + '\\\\t' + str(reduced_sample.terminate_all) + '\\\\t')\\n i_out.write(string_utils.out_sleeping + '\\\\t' + str(reduced_sample.sleep_all) + '\\\\t')\\n i_out.write(string_utils.out_crashing + '\\\\t' + str(reduced_sample.crash_all) + '\\\\t')\\n i_out.write(string_utils.out_raising_error + '\\\\t' + str(reduced_sample.error_all) + '\\\\t')\\n i_out.write(string_utils.out_writes_file + '\\\\t' + str(reduced_sample.write_file) + '\\\\n')\\n\\n # system calls count section\\n s_out.write(string_utils.syscall_final + '\\\\t' + str(reduced_sample.total_syscalls) + '\\\\n')\\n\\n i_out.write('\\\\n')\\n s_out.write('\\\\n')\\n c_out.write('\\\\n')\",\n \"def _generate_run_end_text(self) -> str:\\n # Write the run summary:\\n text = \\\"\\\\n####Run final summary - epoch {}:\\\".format(self._epochs)\\n for property_name, property_value in self._extract_epoch_results().items():\\n text += \\\"\\\\n * **{}**: {}\\\".format(\\n property_name.capitalize(),\\n self._markdown_print(value=property_value, tabs=2),\\n )\\n\\n # Add the context final state:\\n if self._context is not None:\\n text += \\\"\\\\n####Context final state: ({})\\\".format(\\n self._generate_context_link(context=self._context)\\n )\\n for property_name, property_value in self._extract_properties_from_context(\\n context=self._context\\n ).items():\\n text += \\\"\\\\n * **{}**: {}\\\".format(\\n property_name.capitalize(),\\n self._markdown_print(value=property_value, tabs=2),\\n )\\n return text\",\n \"def write_final_summary_text(self):\\n # Log the run's final summary:\\n self._write_text_to_tensorboard(\\n tag=\\\"MLRun\\\",\\n text=self._generate_run_end_text(),\\n step=(\\n self._validation_iterations\\n if self._training_iterations == 0\\n else self._training_iterations\\n ),\\n )\",\n \"def print_summary(self):\\n #outcomes = self.get_outcomes()\\n #passes = 'Passes: %i' % sum(1 for outcome in outcomes if outcome == Result.PASS)\\n #untested = 'Untested: %i' % sum(1 for outcome in outcomes if outcome == Result.UNTESTED)\\n #errors = 'Errors: %i' % sum(1 for outcome in outcomes if outcome == Result.ERROR)\\n #fails = 'Fails: %i' % sum(1 for outcome in outcomes if outcome == Result.FAIL)\\n print('')\\n print ('Passes: %i' % self.get_pass_count())\\n print ('Fails: %i' % self.get_fail_count())\\n print ('Errors: %i' % self.get_error_count())\\n print ('Untested: %i' % self.get_untested_count())\\n print ('Skipped: %i' % self.get_skipped_count())\",\n \"def print_summary(self, write_files=True):\\n\\n assert self.info\\n\\n if not self.info.categories[\\\"integrated\\\"]:\\n util.main_log(\\n self.info.logfile,\\n \\\"NO IMAGES SUCCESSFULLY PROCESSSED!\\\",\\n (not self.gui_mode),\\n )\\n return\\n\\n summary = []\\n summary.append(\\\"\\\\n\\\\n{:-^80}\\\\n\\\".format(\\\"SUMMARY\\\"))\\n categories = [\\n \\\"total\\\",\\n \\\"failed_triage\\\",\\n \\\"have_diffraction\\\",\\n \\\"failed_spotfinding\\\",\\n \\\"failed_indexing\\\",\\n \\\"failed_grid_search\\\",\\n \\\"failed_integration\\\",\\n \\\"failed_filter\\\",\\n \\\"integrated\\\",\\n ]\\n for cat in categories:\\n lst, fail, fn, _ = self.info.categories[cat]\\n path = os.path.join(self.info.int_base, fn)\\n if len(lst) > 0 or cat in (\\\"integrated\\\", \\\"diffraction\\\"):\\n summary.append(\\\"{: <20}: {}\\\".format(\\\"{} \\\".format(fail), len(lst)))\\n with open(path, \\\"w\\\") as cf:\\n for item in lst:\\n if isinstance(item, tuple) or isinstance(item, list):\\n item = \\\", \\\".join([str(i) for i in item])\\n cf.write(\\\"{}\\\\n\\\".format(item))\\n if cat == \\\"integrated\\\" and write_files:\\n if not hasattr(self, \\\"prime_data_path\\\"):\\n self.prime_data_path = path\\n\\n summary.append(\\\"\\\\n\\\\nIOTA version {0}\\\".format(iota_version))\\n summary.append(\\\"{}\\\\n\\\".format(now))\\n\\n for item in summary:\\n util.main_log(self.info.logfile, \\\"{}\\\".format(item), False)\\n self.info.update(summary=summary)\",\n \"def _show_summary(self):\\n print 'Summary:'\\n print ' Reports downloaded successfully: %d' % self.counts\\n print ' Reports not downloaded: %d\\\\n' % self.failed\",\n \"def write_stats(self, filestream):\\n if not self.summary:\\n self.summarize()\\n\\n print(self.scores, file=filestream)\",\n \"def _write_ir_summaries(run_dir: str,\\n timing: sample_summary_pb2.SampleTimingProto,\\n summary_path: str):\\n args = []\\n\\n unoptimized_path = os.path.join(run_dir, 'sample.ir')\\n if os.path.exists(unoptimized_path):\\n args.append('--unoptimized_ir=' + unoptimized_path)\\n\\n optimized_path = os.path.join(run_dir, 'sample.opt.ir')\\n if os.path.exists(optimized_path):\\n args.append('--optimized_ir=' + optimized_path)\\n if not args:\\n return\\n\\n subprocess.run(\\n [\\n SUMMARIZE_IR_MAIN_PATH,\\n '--logtostderr',\\n '--minloglevel=2',\\n '--summary_file=' + summary_path,\\n '--timing=' + str(timing),\\n ] + args,\\n check=False)\",\n \"def _write_ir_summaries(run_dir: str,\\n timing: sample_summary_pb2.SampleTimingProto,\\n summary_path: str):\\n args = []\\n\\n unoptimized_path = os.path.join(run_dir, 'sample.ir')\\n if os.path.exists(unoptimized_path):\\n args.append('--unoptimized_ir=' + unoptimized_path)\\n\\n optimized_path = os.path.join(run_dir, 'sample.opt.ir')\\n if os.path.exists(optimized_path):\\n args.append('--optimized_ir=' + optimized_path)\\n if not args:\\n return\\n\\n subprocess.run(\\n [\\n SUMMARIZE_IR_MAIN_PATH,\\n '--logtostderr',\\n '--minloglevel=2',\\n '--summary_file=' + summary_path,\\n '--timing=' + str(timing),\\n ] + args,\\n check=False)\",\n \"def write_run(run):\\n r=Run(run)\\n r.write_all()\",\n \"def _print_summary(case, summary):\\n for dof, data in summary.items():\\n b4b = data[\\\"Bit for Bit\\\"]\\n conf = data[\\\"Configurations\\\"]\\n stdout = data[\\\"Std. Out Files\\\"]\\n print(\\\" \\\" + case + \\\" \\\" + str(dof))\\n print(\\\" --------------------\\\")\\n print(\\\" Bit for bit matches : \\\" + str(b4b[0]) + \\\" of \\\" + str(b4b[1]))\\n print(\\\" Configuration matches : \\\" + str(conf[0]) + \\\" of \\\" + str(conf[1]))\\n print(\\\" Std. Out files parsed : \\\" + str(stdout))\\n print(\\\"\\\")\",\n \"def summarize(self):\\n info(\\\"Running \\\" + self.title + \\\" generator\\\")\",\n \"def _printSummary(self):\\n\\t\\t### COP OUT\\n\\t\\tif self.params['background'] is True:\\n\\t\\t\\tself.stats['count'] += 1\\n\\t\\t\\treturn\\n\\n\\t\\t### THIS NEEDS TO BECOME MUCH MORE GENERAL, e.g. Peaks\\n\\t\\ttdiff = time.time()-self.stats['startseries']\\n\\t\\tif not self.params['continue'] or tdiff > 0.1:\\n\\t\\t\\tcount = self.stats['count']\\n\\t\\t\\t#if(count != self.stats['lastcount']):\\n\\t\\t\\tsys.stderr.write(\\\"\\\\n\\\\tSUMMARY: \\\"+self.functionname+\\\"\\\\n\\\")\\n\\t\\t\\tself._printLine()\\n\\t\\t\\tsys.stderr.write(\\\"\\\\tTIME: \\\\t\\\"+apDisplay.timeString(tdiff)+\\\"\\\\n\\\")\\n\\t\\t\\tself.stats['timesum'] = self.stats['timesum'] + tdiff\\n\\t\\t\\tself.stats['timesumsq'] = self.stats['timesumsq'] + (tdiff**2)\\n\\t\\t\\ttimesum = self.stats['timesum']\\n\\t\\t\\ttimesumsq = self.stats['timesumsq']\\n\\t\\t\\tif(count > 1):\\n\\t\\t\\t\\ttimeavg = float(timesum)/float(count)\\n\\t\\t\\t\\ttimestdev = math.sqrt(float(count*timesumsq - timesum**2) / float(count*(count-1)))\\n\\t\\t\\t\\ttimeremain = (float(timeavg)+float(timestdev))*self.stats['seriesleft']\\n\\t\\t\\t\\tsys.stderr.write(\\\"\\\\tAVG TIME: \\\\t\\\"+apDisplay.timeString(timeavg,timestdev)+\\\"\\\\n\\\")\\n\\t\\t\\t\\t#print \\\"\\\\t(- TOTAL:\\\",apDisplay.timeString(timesum),\\\" -)\\\"\\n\\t\\t\\t\\tif(self.stats['seriesleft'] > 0):\\n\\t\\t\\t\\t\\tsys.stderr.write(\\\"\\\\t(- REMAINING TIME: \\\"+apDisplay.timeString(timeremain)+\\\" for \\\"\\n\\t\\t\\t\\t\\t\\t+str(self.stats['seriesleft'])+\\\" series -)\\\\n\\\")\\n\\t\\t\\t#print \\\"\\\\tMEM: \\\",(mem.active()-startmem)/1024,\\\"M (\\\",(mem.active()-startmem)/(1024*count),\\\"M)\\\"\\n\\t\\t\\tself.stats['count'] += 1\\n\\t\\t\\tself._printLine()\",\n \"def output_run(run_data, name):\\n\\n print(json.dumps(run_data, indent=4))\\n ret = run_data.get('return', {})\\n display_output(\\n {name: ret}, \\n\\tout=run_data.get('out', 'nested'),\\n\\topts = salt.config.minion_config('/dev/null'))\",\n \"def pytest_terminal_summary(self, terminalreporter, exitstatus):\\n # pylint: disable=unused-argument\\n terminalreporter.section(\\\"Test Information\\\")\\n for test, info in self._info.items():\\n for datum in info:\\n terminalreporter.write(\\\"{}: {}\\\\n\\\".format(test, datum))\",\n \"def do_write(self, args):\\n\\t\\tasplit = args.split(\\\" \\\")\\n\\t\\tfname = asplit[0]\\n\\t\\twhat = asplit[1]\\n\\n\\t\\tif what == \\\"summary\\\" or what == \\\"oldsummary\\\":\\n\\t\\t\\twith open(fname, 'w') as f:\\n\\t\\t\\t\\tform = DresherInterface.summary_format if what == \\\"summary\\\" else DresherInterface.oldsummary_format\\n\\t\\t\\t\\tfor i, x in enumerate(form):\\n\\t\\t\\t\\t\\tf.write(x)\\n\\t\\t\\t\\t\\tif i == len(form)-1:\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\n\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t#for lang in sorted(self.languages, key = lambda l: len(l._phones.keys())):\\n\\t\\t\\t\\t#\\tdw.writerow(dict(zip(form, [self.get_language_info(lang, x) for x in form])))\\n\\t\\t\\t\\tfor lang in sorted(self.languages, key = lambda l: len(l._phones.keys())):\\n\\t\\t\\t\\t\\tfor i, x in enumerate(form):\\n\\t\\t\\t\\t\\t\\tf.write(str(self.get_language_info(lang, x)))\\n\\t\\t\\t\\t\\t\\tif i == len(form)-1:\\n\\t\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\n\\\")\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\tif what == \\\"hierarchies\\\":\\n\\t\\t\\t# format: #vowels, langname, hierarchy, len(hier), #of marks, lfeats, inv, freq, \\n\\t\\t\\t# how many times each feat marked, the actual marks, vowel:feature set, unused features\\n\\t\\t\\t# take fname to be name of directory to write outfiles to\\n\\t\\t\\tif not os.path.exists(fname):\\n\\t\\t\\t\\tos.mkdir(fname)\\n\\t\\t\\tfor lang in self.languages:\\n\\t\\t\\t\\tnum_vowels = self.get_language_info(lang, \\\"linv\\\")\\n\\t\\t\\t\\tname = lang.name\\n\\t\\t\\t\\tnum_feats = self.get_language_info(lang, \\\"lfeats\\\")\\n\\t\\t\\t\\tinv = self.get_language_info(lang, \\\"inv\\\")\\n\\t\\t\\t\\tfreq = self.get_language_info(lang, \\\"freq\\\")\\n\\t\\t\\t\\tinv_feats = lang.phone_feat_dict\\n\\t\\t\\t\\twith open(os.path.join(fname,name.replace(\\\" \\\",\\\"\\\")+\\\".txt\\\"), 'w') as f:\\n\\t\\t\\t\\t\\tf.write(\\\"num_vowels\\\\tname\\\\thierarchy\\\\tlen_hier\\\\tnum_marks\\\\tnumfeats\\\\tinv\\\\tfreq\\\\tfeat_marks\\\\tinv_marks\\\\tinv_feats\\\\tunused_feats\\\\n\\\")\\n\\t\\t\\t\\t\\tfor h in lang.hierarchies:\\n\\t\\t\\t\\t\\t\\tf.write(str(num_vowels))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(name)\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(h))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(len(h)))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tspec = SDA(lang._phones, lang._features, h)\\n\\t\\t\\t\\t\\t\\tmarkedness = sum([x for phone in spec.keys() for x in spec[phone] if x == 1])\\n\\t\\t\\t\\t\\t\\tf.write(str(markedness))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(num_feats))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(inv))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(freq))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tfeat_counts = {f:sum([spec[phone][i] for phone in spec.keys() if spec[phone][i] == 1]) for i, f in enumerate(h)}\\n\\t\\t\\t\\t\\t\\tf.write(str(feat_counts))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(spec))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(inv_feats))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(list(set(lang._features)-set(h))))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\n\\\")\\n\\t\\t# make sure all the threads that need to be finished have finished\\n\\t\\t# using .join() on the appropriate groups of threads\",\n \"def printSummary(self):\\n pass\",\n \"def basic ( ) :\\n \\n die_file_paths = _sort_all_apropriate_files(options.input)\\n \\n for die_file_path in die_file_paths :\\n \\n print\\n #print (\\\"loading die information from file: \\\" + die_file_path)\\n die_description, die_roll_dict = _read_die_file (die_file_path)\\n \\n print (\\\"data for die with description: \\\" + die_description.strip())\\n \\n print \\n \\n print (\\\"raw roll data:\\\")\\n for roll_value in sorted(die_roll_dict.keys()) :\\n print (\\\"rolled \\\\t\\\" + str(roll_value) + \\\"\\\\t on the die \\\\t\\\"\\n + str(die_roll_dict[roll_value]) + \\\"\\\\t time(s)\\\")\\n \\n print \\n \\n print (\\\"simple roll histogram:\\\")\\n for roll_value in sorted(die_roll_dict.keys()) :\\n bar_text = \\\"*\\\" * die_roll_dict[roll_value]\\n print (str(roll_value) + \\\"\\\\t\\\" + bar_text)\\n \\n print \\n \\n side_val = numpy.array(die_roll_dict.keys( ), dtype=numpy.float)\\n rolls = numpy.array(die_roll_dict.values( ), dtype=numpy.float)\\n num_rolls = float(numpy.sum(rolls))\\n avg_result = numpy.sum(rolls * side_val) / num_rolls\\n \\n print (\\\"average roll: \\\" + str(avg_result))\\n \\n print (\\\"------------\\\")\",\n \"def dump_total_results(statistic_entries):\\n individual_tests = sum([entry['correct answers'] + entry['wrong answers']\\n for entry in statistic_entries])\\n average_per_test = sum([entry['total time (s)'] for entry in statistic_entries]) \\\\\\n / float(individual_tests)\\n average_per_run = sum([entry['total time (s)'] for entry in statistic_entries]) \\\\\\n / float(len(statistic_entries))\\n\\n best_time = min([entry['best time (s)'] for entry in statistic_entries])\\n worst_time = max([entry['worst time (s)'] for entry in statistic_entries])\\n\\n print(\\\"\\\\nSummary for all done tests:\\\")\\n print(\\\" %5d total test runs\\\" % len(statistic_entries))\\n print(\\\" %5d individual tests\\\" % individual_tests)\\n print(\\\" %5.1f individual tests per run\\\" % (individual_tests / float(len(statistic_entries))))\\n print(\\\" %5.2f seconds per answer (average)\\\" % average_per_test)\\n print(\\\" %5.2f seconds per run (average)\\\" % average_per_run)\\n print(\\\" %5.2f seconds was best time.\\\" % best_time)\\n print(\\\" %5.2f seconds was worst time.\\\" % worst_time)\",\n \"def write_training_summaries(self):\\n for metric, epochs in self._training_summaries.items():\\n self._write_scalar_to_tensorboard(\\n name=f\\\"{self._Sections.SUMMARY}/training_{metric}\\\",\\n value=epochs[-1],\\n step=self._epochs,\\n )\",\n \"def print_tests_results(self):\\n\\n for test in self.test_report:\\n for detail in test:\\n print detail + ': ', test[detail]\",\n \"def write_background_stats(self, out_dir, all_output_lines):\\r\\n out_file = os.path.join(out_dir, \\\"simulations_stats.csv\\\")\\r\\n with open(out_file, \\\"w\\\") as file:\\r\\n col_names = \\\"sim_id,round,best_score,avg_score,solutions,elitist_candidates,elitism_rate,discard_rate,\\\" \\\\\\r\\n \\\"mutation_rate,colors\\\\n\\\"\\r\\n file.write(col_names)\\r\\n for lines_of_one_simulation in all_output_lines:\\r\\n for line in lines_of_one_simulation:\\r\\n file.write(line)\",\n \"def summary(args, json_logs, all_logs):\\n all_data = process_logs(json_logs)\\n if args.debug:\\n print(json.dumps(all_data))\\n\\n buf = io.StringIO()\\n\\n start = args.start.strftime(\\\"%m/%d/%Y %H:%M:%S\\\")\\n end = args.end.strftime(\\\"%m/%d/%Y %H:%M:%S\\\")\\n print(f\\\"Test Summary Report: {start} -> {end}\\\\n\\\", file=buf)\\n\\n # Calculate test failures per day/scenario\\n all_days = {} # dict of per-scenario counts\\n days = {} # dict of per-day -> per-scenario counts and test names\\n top_failed = {} # dict of per-test failure counts\\n top_flakes = {} # dict of per-test flake counts\\n for day in sorted(all_data.keys()):\\n days[day] = {}\\n for scenario in sorted(all_data[day].keys()):\\n if scenario not in all_days:\\n all_days[scenario] = {\\\"success\\\": 0, \\\"missing\\\": 0, \\\"failed\\\": 0, \\\"flakes\\\": 0}\\n\\n # Figure out how many were successful, failed, or were flakes\\n success, missing, failed, flakes = check_tests(all_data[day][scenario])\\n\\n days[day][scenario] = {\\n \\\"success\\\": len(success),\\n \\\"missing\\\": len(missing),\\n \\\"failed\\\": len(failed),\\n \\\"flakes\\\": len(flakes),\\n \\\"missing-tests\\\": missing,\\n \\\"failed-tests\\\": failed,\\n \\\"flaky-tests\\\": flakes}\\n all_days[scenario][\\\"success\\\"] += len(success)\\n all_days[scenario][\\\"missing\\\"] += len(missing)\\n all_days[scenario][\\\"failed\\\"] += len(failed)\\n all_days[scenario][\\\"flakes\\\"] += len(flakes)\\n\\n for n in failed:\\n top_failed[n] = top_failed.get(n, 0) + 1\\n\\n for n in flakes:\\n top_flakes[n] = top_flakes.get(n, 0) + 1\\n\\n\\n # Summary of tests per scenario\\n print(\\\"Weekly summary\\\", file=buf)\\n print(\\\"==============\\\", file=buf)\\n for scenario in sorted(all_days.keys()):\\n success = all_days[scenario][\\\"success\\\"]\\n missing = all_days[scenario][\\\"missing\\\"]\\n failed = all_days[scenario][\\\"failed\\\"]\\n flakes = all_days[scenario][\\\"flakes\\\"]\\n\\n print(f\\\"{scenario}: Ran {success+failed+missing} tests. {success} passed, {failed} failed, {missing} missing, {flakes} flakes.\\\", file=buf)\\n print(\\\"\\\\n\\\", file=buf)\\n\\n print(\\\"Top 5 failed tests for the week\\\", file=buf)\\n for n in sorted((n for n in top_failed), key=lambda x: top_failed[x], reverse=True)[:5]:\\n print(f\\\" {n} - {top_failed[n]}\\\", file=buf)\\n print(\\\"\\\\n\\\", file=buf)\\n\\n print(\\\"Top 5 flaky tests for the week\\\", file=buf)\\n for n in sorted((n for n in top_flakes), key=lambda x: top_flakes[x], reverse=True)[:5]:\\n print(f\\\" {n} - {top_flakes[n]}\\\", file=buf)\\n print(\\\"\\\\n\\\", file=buf)\\n\\n # Print daily stats\\n for day in sorted(days.keys()):\\n print(datetime.strptime(day, \\\"%Y%m%d\\\").strftime(\\\"%m/%d/%Y\\\"), file=buf)\\n for scenario in sorted(days[day].keys()):\\n s = days[day][scenario]\\n success = s[\\\"success\\\"]\\n missing = s[\\\"missing\\\"]\\n failed = s[\\\"failed\\\"]\\n total = success + failed + missing\\n flakes = s[\\\"flakes\\\"]\\n print(f\\\" {scenario} (Ran {total}, {success} passed, {failed} failed, {missing} missing. {flakes} flakes) :\\\", file=buf)\\n if s[\\\"missing-tests\\\"]:\\n print(\\\" Missing:\\\", file=buf)\\n for n in s[\\\"missing-tests\\\"]:\\n print(f\\\" {n}\\\", file=buf)\\n if s[\\\"failed-tests\\\"]:\\n print(\\\" Failed:\\\", file=buf)\\n for n in sorted(s[\\\"failed-tests\\\"].keys()):\\n print(f\\\" {n}\\\", file=buf)\\n if s[\\\"flaky-tests\\\"]:\\n print(\\\" Flakes:\\\", file=buf)\\n for n in sorted(s[\\\"flaky-tests\\\"].keys()):\\n print(f\\\" {n}\\\", file=buf)\\n print(\\\"\\\\n\\\", file=buf)\\n\\n # Print the failure details for each scenario, on each day.\\n for scenario in sorted(all_days.keys()):\\n success = all_days[scenario][\\\"success\\\"]\\n failed = all_days[scenario][\\\"failed\\\"]\\n flakes = all_days[scenario][\\\"flakes\\\"]\\n\\n msg = f\\\"{scenario}: Ran {success+failed} tests. {success} passed, {failed} failed, {flakes} flakes.\\\"\\n print(\\\"=\\\" * len(msg), file=buf)\\n print(msg, file=buf)\\n print(\\\"=\\\" * len(msg), file=buf)\\n\\n if args.flake_details:\\n print(\\\"Failed test details\\\", file=buf)\\n print(\\\"-------------------\\\", file=buf)\\n print_test_details(scenario, days, \\\"failed-tests\\\", buf)\\n\\n if args.flake_details:\\n print(\\\"\\\\nFlake test details\\\", file=buf)\\n print(\\\"-------------------\\\", file=buf)\\n print_test_details(scenario, days, \\\"flaky-tests\\\", buf)\\n\\n print(\\\"\\\\n\\\", file=buf)\\n\\n\\n # Save the logs for the failures and flakes if a path is specified\\n try:\\n if args.archive_logs:\\n archive_test_logs(days, args.archive_logs, all_logs)\\n except RuntimeError as e:\\n print(f\\\"\\\\nERROR: Problem archiving test logs - {e}\\\", file=buf)\\n\\n return buf.getvalue()\",\n \"def print_acts_summary(master_results_data,\\n master_results_pass,\\n master_results_fail,\\n master_results_unknown,\\n pass_counter,\\n fail_counter,\\n unknown_counter,\\n split_results=False,\\n ):\\n widths = [max(map(len, col)) for col in zip(*master_results_data)]\\n if not split_results:\\n for row in master_results_data:\\n print(' '.join((val.ljust(width) for val, width in zip(row,\\n widths))))\\n print('')\\n print('Pass: %s '\\n 'Fail: %s '\\n 'Unknown: %s '\\n 'Total: %s' % (pass_counter,\\n fail_counter,\\n unknown_counter,\\n pass_counter+fail_counter+unknown_counter))\\n else:\\n print('')\\n for row in master_results_pass:\\n print(' '.join((val.ljust(width) for val, width in zip(row,\\n widths))))\\n print('Pass: %s' % pass_counter)\\n\\n print('')\\n for row in master_results_fail:\\n print(' '.join((val.ljust(width) for val, width in zip(row,\\n widths))))\\n print('Fail: %s' % fail_counter)\\n if unknown_counter is not 0:\\n print('')\\n for row in master_results_unknown:\\n print(' '.join((val.ljust(width)\\n for val, width in zip(row, widths))))\\n print('Unknown: %s' % unknown_counter)\",\n \"def makereport(reslist, file=sys.stdout, hasTOI=False, hasRuns=False):\\n\\n if not hasRuns: reslist=[reslist]\\n \\n for irun, resrun in enumerate(reslist):\\n file.write(\\\"Run: %d\\\\n\\\" % irun)\\n for det, res in resrun.items():\\n file.write(\\\"%d\\\" % det)\\n\\n try:\\n if not hasTOI: \\n val = res[1][0]\\n sig = res[1][1]\\n else:\\n val = res[-1][1][0]\\n sig = res[-1][1][1]\\n \\n for (v, s) in zip(val, sig):\\n file.write(\\\" %f +- %f\\\" % (v, s))\\n except:\\n print(\\\"\\\\n... when running \\\", irun, det, end=' ')\\n print(\\\"Unexpected error:\\\", sys.exc_info()[0])\\n \\n file.write(\\\"\\\\n\\\")\",\n \"def create_summary_statistics(forward_accuracy, backward_accuracy, merged_accuracy):\\n summary_statistics = open(f'summary_statistics.txt', 'a')\\n summary_statistics.write(f'The forward model has an accuracy of: {forward_accuracy}\\\\n')\\n summary_statistics.write(f'The backward model has an accuracy of: {backward_accuracy}\\\\n')\\n summary_statistics.write(f'The merged model has an accuracy of: {merged_accuracy}\\\\n')\\n summary_statistics.close()\",\n \"def write_epoch_summary_text(self):\\n self._write_text_to_tensorboard(\\n tag=\\\"MLRun\\\",\\n text=self._generate_epoch_text(),\\n step=self._training_iterations,\\n )\",\n \"def print_analysis(self,version,results,tests,test_details,test_order,\\n output_dir,diffs_only):\\n def format_result(r):\\n return '%s %s' % (r.outcome,r.get_cause())\\n\\n main_template = makolookup.get_template(\\\"main.mako\\\")\\n detail_template = makolookup.get_template(\\\"detail.mako\\\")\\n\\n f = open(os.path.join(output_dir,'index.html'),'w')\\n try:\\n f.write(main_template.render(version=version,results=results,tests=tests,\\n test_details=test_details,test_order=test_order,\\n time2datetime=time2datetime))\\n finally:\\n f.close()\\n\\n for test_id,test_detail in test_details.items():\\n #print ('Detail: %s' % test_id)\\n f = open(os.path.join(output_dir,test_id+'.html'),'w')\\n try:\\n f.write(detail_template.render(version=version,test_id=test_id,\\n test_detail=test_detail,diffs_only=diffs_only))\\n except:\\n f.write(\\\"Error while processing output.\\\")\\n finally:\\n f.close()\",\n \"def main() -> int:\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--dir-metadata',\\n type=pathlib.Path, required=True)\\n\\n args = parser.parse_args()\\n\\n with LockedMetadata(args.dir_metadata, __file__) as md:\\n summary_dict = {}\\n passing_tests = []\\n failing_tests = []\\n for f in md.tests_pickle_files:\\n try:\\n trr = TestRunResult.construct_from_pickle(f)\\n summary_dict[f\\\"{trr.testname}.{trr.seed}\\\"] = \\\\\\n ('PASS' if trr.passed else\\n 'FAILED' + (\\\" {T}\\\" if (trr.failure_mode == Failure_Modes.TIMEOUT) else \\\"\\\"))\\n if trr.passed:\\n passing_tests.append(trr)\\n else:\\n failing_tests.append(trr)\\n except RuntimeError as e:\\n failing_tests.append(\\n TestRunResult(\\n name='broken_test',\\n failure_message=str(e)\\n ))\\n\\n md.regr_log = md.dir_run/'regr.log'\\n md.regr_log_junit = md.dir_run/'regr_junit.xml'\\n md.regr_log_junit_merged = md.dir_run/'regr_junit_merged.xml'\\n\\n # Write results as junit_xml\\n with open(md.regr_log_junit,\\n 'w',\\n encoding='UTF-8') as junit_xml,\\\\\\n open(md.regr_log_junit_merged,\\n 'w',\\n encoding='UTF-8') as junit_merged_xml:\\n output_run_results_junit_xml(passing_tests, failing_tests,\\n junit_xml,\\n junit_merged_xml)\\n\\n with open(md.regr_log, 'w', encoding='UTF-8') as outfile:\\n # Write results as regr.log (custom logfile format)\\n output_results_text(passing_tests, failing_tests, summary_dict,\\n outfile)\\n\\n test_summary_dict = create_test_summary_dict(passing_tests +\\n failing_tests)\\n\\n cov_summary_dict = {}\\n if md.simulator == \\\"xlm\\\":\\n cov_summary_dict = create_cov_summary_dict(md)\\n else:\\n print(\\\"Warning: Not generating coverage summary, unsupported \\\" \\\\\\n f\\\"simulator {md.simulator}\\\")\\n\\n html_report_filename = md.dir_run/'report.html'\\n with open(html_report_filename, 'w') as outfile:\\n output_results_html(md, passing_tests + failing_tests,\\n test_summary_dict, cov_summary_dict, outfile)\\n\\n json_report_filename = md.dir_run/'report.json'\\n with open(json_report_filename, 'w') as json_report_file:\\n output_results_dvsim_json(md, test_summary_dict, cov_summary_dict,\\n json_report_file)\\n\\n svg_summary_filename = md.dir_run/'summary.svg'\\n with open(svg_summary_filename, 'w') as svg_summary_file:\\n output_results_svg(test_summary_dict, cov_summary_dict,\\n svg_summary_file)\\n\\n # Print a summary line to the terminal\\n print(gen_summary_line(passing_tests, failing_tests))\\n\\n # Succeed if no tests failed\\n return 1 if failing_tests else 0\",\n \"def print_activity_run_details(activity_run):\\n print(\\\"\\\\n\\\\tActivity run details\\\\n\\\")\\n print(\\\"\\\\tActivity run status: {}\\\".format(activity_run.status))\\n if activity_run.status == 'Succeeded':\\n print(\\\"\\\\tNumber of bytes read: {}\\\".format(activity_run.output['dataRead']))\\n print(\\\"\\\\tNumber of bytes written: {}\\\".format(activity_run.output['dataWritten']))\\n print(\\\"\\\\tCopy duration: {}\\\".format(activity_run.output['copyDuration']))\\n else:\\n print(\\\"\\\\tErrors: {}\\\".format(activity_run.error['message']))\",\n \"def display_results(summary):\\n print ('Total running time %.2f secs (includes DB checks)'\\n % summary.total_time)\\n\\n print 'OK:', summary.ok\\n print 'Errors:', summary.errors\\n\\n # Display stats\\n print 'Changes stats:'\\n for var, s in summary.stats.iteritems():\\n print '\\\\t%s:' % var,\\n for x in s.iteritems():\\n print '%s=%.2f' % x,\\n print\\n\\n # Display profiling data\\n print 'Profiling data:'\\n for name, data in summary.profile.iteritems():\\n print '\\\\t%s: %d calls, %.2fms' % (name, data['callcount'],\\n data['time'] * 1000)\",\n \"def write_results_dat(self, output_path):\\n\\n def fstr(nb):\\n data = '%E' % nb\\n if data == 'NAN':\\n nb, power = 0,0\\n else:\\n nb, power = data.split('E')\\n nb = float(nb) /10\\n power = int(power) + 1\\n return '%.5fE%+03i' %(nb,power)\\n\\n line = '%s %s %s %i %i %i %i %s %s %s %s %s %i\\\\n' % (fstr(self.axsec), fstr(self.xerru), \\n fstr(self.xerrc), self.nevents, self.nw, self.maxit, self.nunwgt,\\n fstr(self.luminosity), fstr(self.wgt), fstr(self.xsec), fstr(self.maxwgt),\\n fstr(self.th_maxwgt), self.th_nunwgt) \\n fsock = open(output_path,'w') \\n fsock.writelines(line)\\n for i in range(len(self.ysec_iter)):\\n line = '%s %s %s %s %s %s\\\\n' % (i+1, self.ysec_iter[i], self.yerr_iter[i], \\n self.eff_iter[i], self.maxwgt_iter[i], self.yasec_iter[i]) \\n fsock.writelines(line)\",\n \"def _publish_results(self):\\n\\n doc = Document()\\n date = get_stamp()\\n\\n labels = ExperimentTemplateBase.parameters_to_string(self._topology_parameters_list)\\n\\n title = 'Mutual Information labels vs ' + self._experiment_name\\n self.plot_save(title,\\n self._mutual_info,\\n self._baseline_mutual_info,\\n 'Norm. mutual information',\\n labels, date, self._docs_folder, doc)\\n\\n title = 'Weak classifier accuracy labels vs ' + self._experiment_name\\n self.plot_save(title,\\n self._classifier_accuracy,\\n self._baseline_classifier_accuracy,\\n 'Classifier accuracy',\\n labels, date, self._docs_folder, doc) #, smoothing_size=3)\\n\\n title = 'average delta'\\n f = plot_multiple_runs(\\n self._different_steps[0], # here the X axes are identical\\n self._average_delta,\\n title=title,\\n ylabel='log(delta)',\\n xlabel='steps',\\n labels=labels\\n )\\n add_fig_to_doc(f, path.join(self._docs_folder, title), doc)\\n\\n title = 'average boosting duration'\\n f = plot_multiple_runs(\\n self._different_steps[0],\\n self._average_boosting_dur,\\n title=title,\\n ylabel='duration',\\n xlabel='steps',\\n labels=labels\\n )\\n add_fig_to_doc(f, path.join(self._docs_folder, title), doc)\\n\\n doc.write_file(path.join(self._docs_folder, to_safe_name(self._complete_name() + date + \\\".html\\\")))\\n\\n print('done')\",\n \"def summarise(thislog):\\n\\n # Logfile name\\n print(\\\"Summary for \\\" + thislog.filename() + \\\"\\\\n\\\")\\n # Was it from CCP4i?\\n if thislog.isccp4i():\\n print(\\\"This is a CCP4i logfile\\\\n\\\")\\n # Number of programs or pseudo-programs\\n print(str(thislog.nfragments()) + \\\" logfile fragments\\\\n\\\")\\n print(\\\"Fragments:\\\")\\n for i in range(0, thislog.nfragments()):\\n fragment = thislog.fragment(i)\\n if fragment.isprogram():\\n if fragment.has_attribute(\\\"name\\\"):\\n print(\\\"\\\\tProgram: \\\" + str(fragment.name))\\n else:\\n print(\\\"\\\\tProgram: <no name>\\\")\\n else:\\n if fragment.isccp4i_info():\\n print(\\\"\\\\tCCP4i info\\\")\\n elif fragment.isfragment():\\n print(\\\"\\\\tFragment\\\")\\n if fragment.ntables():\\n print(\\\"\\\\t\\\\t\\\" + str(fragment.ntables()) + \\\" tables\\\")\\n if fragment.nkeytexts():\\n print(\\\"\\\\t\\\\t\\\" + str(fragment.nkeytexts()) + \\\" keytexts\\\")\\n\\n print(\\\"\\\")\\n # Summarise program logfile fragments\\n if thislog.nprograms() > 0:\\n print(str(thislog.nprograms()) + \\\" program logfiles\\\\n\\\")\\n print(\\\"Programs:\\\")\\n for i in range(0, thislog.nprograms()):\\n prog = thislog.program(i)\\n # Is it a CCP4 program?\\n if prog.isccp4():\\n # Print name, version (and CCP4 version)\\n print(\\n \\\"\\\\t\\\"\\n + prog.name\\n + \\\"\\\\tv\\\"\\n + prog.version\\n + \\\"\\\\t(CCP4 \\\"\\n + prog.ccp4version\\n + \\\")\\\"\\n )\\n else:\\n # Print name and version\\n if prog.has_attribute(\\\"name\\\") and prog.has_attribute(\\\"version\\\"):\\n print(\\\"\\\\t\\\" + prog.name + \\\"\\\\t\\\" + prog.version)\\n else:\\n print(\\\"\\\\t<No name and/or version>\\\")\\n if prog.termination():\\n print(\\\"\\\\tTerminated with: \\\" + prog.termination_message)\\n else:\\n print(\\\"\\\\tNo termination message found\\\")\\n # Keytexts\\n if prog.nkeytexts():\\n print(\\\"\\\\n\\\\t\\\\tKeytext messages:\\\")\\n for j in range(0, prog.nkeytexts()):\\n print(\\n \\\"\\\\t\\\\t\\\"\\n + str(prog.keytext(j).name())\\n + ': \\\"'\\n + str(prog.keytext(j).message())\\n + '\\\"'\\n )\\n # Tables\\n if prog.ntables():\\n print(\\\"\\\\n\\\\t\\\\tTables:\\\")\\n for table in prog.tables():\\n print('\\\\t\\\\tTable: \\\"' + table.title() + '\\\"')\\n print(\\\"\\\")\\n else:\\n print(\\\"No program logfiles found\\\")\\n print(\\\"\\\")\\n # Total set of CCP4i information messages in the file\\n print(\\\"CCP4i messages in file:\\\")\\n if thislog.nccp4i_info():\\n for i in range(0, thislog.nccp4i_info()):\\n print('\\\\tCCP4i info: \\\"' + thislog.ccp4i_info(i).message + '\\\"')\\n else:\\n print(\\\"\\\\tNo messages found\\\")\\n print(\\\"\\\")\\n # Total set of tables in the file\\n print(\\\"Tables in file:\\\")\\n if thislog.ntables():\\n for table in thislog.tables():\\n print('\\\\tTable: \\\"' + table.title() + '\\\" (' + str(table.nrows()) + \\\" rows)\\\")\\n else:\\n print(\\\"\\\\tNo tables found\\\")\\n print(\\\"\\\")\\n # Total set of keytexts in the file\\n print(\\\"Keytext messages in file:\\\")\\n if thislog.nkeytexts():\\n for i in range(0, thislog.nkeytexts()):\\n print(\\n \\\"\\\\t\\\"\\n + str(thislog.keytext(i).name())\\n + ': \\\"'\\n + thislog.keytext(i).message()\\n + '\\\"'\\n )\\n else:\\n print(\\\"\\\\tNo keytext messages found\\\")\\n print(\\\"\\\")\",\n \"def write_validation_summaries(self):\\n for metric, epochs in self._validation_summaries.items():\\n self._write_scalar_to_tensorboard(\\n name=f\\\"{self._Sections.SUMMARY}/validation_{metric}\\\",\\n value=epochs[-1],\\n step=self._epochs,\\n )\",\n \"def debug_file(self, pkt_count, attack_count, data_list, ds_calc_time, ds_vals, metric_means, distances):\\n # Current frame no. //\\n # Current frame metric data //\\n # Current sliding window data\\n # Distances for each metric\\n # DS probabilities, BPA's, time to calculate\\n # Fusion results for each metric\\n # Averages for each metric\\n # Final result for frame\\n # Current number of malicious frames detected\\n metric_list = ['RSSI', 'Rate', 'NAV', 'Seq', 'TTL']\\n x = [1, 2, 3, 4, 5]\\n with open('debug.txt', 'a') as debug_file:\\n debug_file.write('\\\\nFrame number: %d\\\\n' % pkt_count)\\n debug_file.write('Current frame data. \\\\n')\\n debug_file.writelines('%s : %d \\\\n ' % (metric, value) for metric, value in zip(self._features_to_analyse,\\n data_list))\\n debug_file.write('\\\\nCurrent sliding window data: \\\\n')\\n debug_file.writelines('\\\\n%s:\\\\n %s \\\\nMean value = %f \\\\n' % (str(metric_array[0]), str(metric_array[1]), mean) for metric_array, mean in zip(self._sw_dict.items(), metric_means))\\n debug_file.write('\\\\nDempster Shafer calculation times: \\\\n')\\n\\n if self._ds_timer is True:\\n debug_file.writelines('Iteration %d time (s) = %f\\\\n' % (count, ds_time) for count, ds_time in zip(x, ds_calc_time))\\n debug_file.write('Total time to calculate DS = %f (s)\\\\n' % sum(ds_calc_time))\\n\\n debug_file.write('Number of malicious frames detected: %d \\\\n' % attack_count)\\n\\n\\n debug_file.close()\",\n \"def _print_results_header(self):\\n print(\\\"\\\\033[94m\\\"+\\\"Summary\\\\n\\\"+\\\"-\\\"*32+\\\"\\\\033[0m\\\")\\n print(\\\"Subroutine: {}\\\".format(self.mc_sample.__name__))\\n print(\\\"Num Runs: {:2.1e}\\\".format(self.num_runs))\\n print(\\\"-\\\"*32+'\\\\n')\",\n \"def execute_summary(self, step):\\n with self.summary_writer.as_default():\\n tf.summary.scalar('bias', self.core.fmlayer.b, step=step)\\n tf.summary.scalar('regularization_penalty', self.regularization, step=step)\\n tf.summary.scalar('loss', self.reduced_loss, step=step)\\n tf.summary.scalar('target', self.target, step=step)\",\n \"def write_output(self):\",\n \"def _write_stats(self, stat_type, user=None, summ_type=None):\\n if stat_type == \\\"full collection\\\":\\n self.summary_file.write(\\\"\\\\n\\\\nDataset: {c}\\\\n\\\".format(c=self.dataset_name))\\n self.summary_file.write(\\\"Number of unique urls: {u}\\\\nNumber of unique sites: {s}\\\\n\\\".format(u=len(set(self.stat_dict['urls'])), s=len(set(self.stat_dict['sites'])))\\n )\\n site_cnts = Counter(self.stat_dict['sites']).most_common()\\n for site in site_cnts:\\n self.summary_file.write(\\\"{s}: {n}\\\\n\\\".format(s=site[0], n=site[1]))\\n\\n if stat_type == \\\"token_counts\\\":\\n self.summary_file.write(\\\"\\\\n\\\\nDataset: {c}\\\\n\\\".format(c=self.dataset_name))\\n for doc_type in self.stat_dict:\\n if user is not None:\\n self.summary_file.write(\\\"\\\\n{0}, {1}\\\\n\\\".format(user, summ_type))\\n\\n self.summary_file.write(\\n \\\"\\\\nNumber of {d}s: {p}\\\\nAverage tokens/{d}: {t}\\\\nAverage sentences/{d}: {s}\\\\n\\\".format(\\n d=doc_type, p=len(self.stat_dict[doc_type][0]), t=sum(self.stat_dict[doc_type][1])/len(self.stat_dict[doc_type][1]), s=sum(self.stat_dict[doc_type][0])/len(self.stat_dict[doc_type][0])\\n )\\n )\\n\\n self.summary_file.write(\\n \\\"Median tokens/{d}: {p}\\\\nStandard deviation tokens/{d}: {t}\\\\n\\\".format(\\n d=doc_type, p=np.median(self.stat_dict[doc_type][1]), t=np.std(self.stat_dict[doc_type][1])\\n )\\n )\\n\\n self.summary_file.write(\\n \\\"Median sentences/{d}: {p}\\\\nStandard deviation sentences/{d}: {t}\\\\n\\\".format(\\n d=doc_type, p=np.median(self.stat_dict[doc_type][0]), t=np.std(self.stat_dict[doc_type][0])\\n )\\n )\",\n \"def print_summary(metrics_list, labels_list):\\n for metric, name in zip(metrics_list, labels_list):\\n print('*' * 108)\\n print(name)\\n mean_inc_acc = []\\n for i in range(metric.shape[0]):\\n print('\\\\t', end='')\\n for j in range(metric.shape[1]):\\n print('{:5.2f}% '.format(100 * metric[i, j]), end='')\\n if np.trace(metric) == 0.0:\\n if i > 0:\\n avg = 100 * metric[i, :i].mean()\\n mean_inc_acc += [avg]\\n print('\\\\tAvg.:{:5.2f}% '.format(avg), end='')\\n else:\\n avg = 100 * metric[i, :i + 1].mean()\\n mean_inc_acc += [avg]\\n print('\\\\tAvg.:{:5.2f}% '.format(avg), end='')\\n print()\\n print()\\n\\n # Computing AIA across all incremental states (thus excluding the first non-incremental state)\\n print('\\\\tMean Incremental Acc.: {:5.2f}%'.format(np.mean(mean_inc_acc[1:])))\\n print('*' * 108)\",\n \"def print_results(self, final_table=None):\\n\\n assert self.info\\n\\n if not final_table:\\n final_table = [\\\"\\\\n\\\\n{:-^80}\\\\n\\\".format(\\\"ANALYSIS OF RESULTS\\\")]\\n\\n if not self.info.categories[\\\"integrated\\\"]:\\n final_table.append(\\\"NO IMAGES INTEGRATED!\\\")\\n else:\\n label_lens = [len(v[\\\"label\\\"]) for k, v in self.info.stats.items()]\\n max_label = int(5 * round(float(np.max(label_lens)) / 5)) + 5\\n for k, v in self.info.stats.items():\\n if k in (\\\"lres\\\", \\\"res\\\", \\\"beamX\\\", \\\"beamY\\\"):\\n continue\\n line = (\\n \\\"{: <{l}}: max = {:<6.2f} min = {:<6.2f} \\\"\\n \\\"avg = {:<6.2f} ({:<6.2f})\\\"\\n \\\"\\\".format(\\n v[\\\"label\\\"], v[\\\"max\\\"], v[\\\"min\\\"], v[\\\"mean\\\"], v[\\\"std\\\"], l=max_label\\n )\\n )\\n final_table.append(line)\\n\\n # TODO: Figure out what to do with summary charts\\n # # If more than one integrated image, plot various summary graphs\\n # if len(self.info.categories['integrated']) > 1:\\n # plot = Plotter(self.params, self.info)\\n # if self.params.analysis.summary_graphs:\\n # if ( self.params.advanced.processing_backend == 'ha14' and\\n # self.params.cctbx_ha14.grid_search.type is not None\\n # ):\\n # plot.plot_spotfinding_heatmap(write_files=True)\\n # plot.plot_res_histogram(write_files=True)\\n # med_beamX, med_beamY, pixel_size = plot.plot_beam_xy(write_files=True,\\n # return_values=True)\\n # else:\\n # with warnings.catch_warnings():\\n # # To catch any 'mean of empty slice' runtime warnings\\n # warnings.simplefilter(\\\"ignore\\\", category=RuntimeWarning)\\n # beamXY_info = plot.calculate_beam_xy()\\n # beamX, beamY = beamXY_info[:2]\\n # med_beamX = np.median(beamX)\\n # med_beamY = np.median(beamY)\\n # pixel_size = beamXY_info[-1]\\n\\n final_table.append(\\n \\\"{: <{l}}: X = {:<4.2f}, Y = {:<4.2f}\\\"\\n \\\"\\\".format(\\n \\\"Median Beam Center\\\",\\n self.info.stats[\\\"beamX\\\"][\\\"mean\\\"],\\n self.info.stats[\\\"beamY\\\"][\\\"mean\\\"],\\n l=max_label,\\n )\\n )\\n\\n # Special entry for resolution last\\n v = self.info.stats[\\\"res\\\"]\\n final_table.append(\\n \\\"{: <{l}}: low = {:<6.2f} high = {:<6.2f} \\\"\\n \\\"avg = {:<6.2f} ({:<6.2f})\\\"\\n \\\"\\\".format(\\n v[\\\"label\\\"], v[\\\"max\\\"], v[\\\"min\\\"], v[\\\"mean\\\"], v[\\\"std\\\"], l=max_label\\n )\\n )\\n\\n for item in final_table:\\n util.main_log(self.info.logfile, item, False)\\n self.info.update(final_table=final_table)\",\n \"def main(sc):\\n\\n # Load data set and parse out statistical counters\\n delays = sc.textFile(DATASET).map(counters)\\n\\n # Perform summary aggregation by key\\n delays = delays.reduceByKey(aggregation)\\n delays = delays.map(summary)\\n\\n # Write the results out to disk\\n delays.saveAsTextFile(\\\"delays-summary\\\")\",\n \"def output(results):\\n\\n text_file = open(\\\"problem_1_B_output.txt\\\", \\\"w\\\")\\n\\n out = \\\"\\\"\\n\\n for i, line in enumerate(results):\\n\\n string = \\\"Sample {}: {}, posterior probability of {:.4f}\\\".format(i + 1,\\n line[0],\\n line[1])\\n\\n out += (string + \\\"\\\\n\\\")\\n\\n text_file.write(out)\\n\\n text_file.close()\",\n \"def write_output():\\n f = open(OUTPUT_FILE, 'w')\\n for case_index, words in get_output():\\n f.write('Case #%d: %s\\\\n' % (case_index, ' '.join(words)))\\n f.close()\",\n \"def print_statistics(self):\\n print 'Ran %s iterations in %0.3f seconds\\\\n' % (\\n self.iterations, self.elapsed_time)\\n\\n print 'Overall Equity'\\n for index in range(len(self.holdem_ranges)):\\n range_short_form = '%r' % self.holdem_ranges[index]\\n print 'P%s) %-15s %0.3f' % (\\n index,\\n range_short_form,\\n float(self.win_stats.get(index, 0))/self.iterations)\\n print '\\\\n'\\n print 'Hand distribution for each player'\\n for stats in self.player_stats:\\n stats.print_report()\",\n \"def output_summary_stats(self):\\n total_return = self.equity_curve['equity_curve'][-1]\\n returns = self.equity_curve['returns']\\n pnl = self.equity_curve['equity_curve']\\n\\n sharpe_ratio = create_sharpe_ratio(returns)\\n drawdown, max_dd, dd_duration = create_drawdowns(pnl)\\n self.equity_curve['drawdown'] = drawdown\\n if len(dd_duration) == 1:\\n dd_duration = dd_duration[0]\\n\\n stats = [(\\\"Total Return\\\", \\\"%0.2f%%\\\" % ((total_return - 1.0) * 100.0)),\\n (\\\"Sharpe Ratio\\\", \\\"%0.2f\\\" % sharpe_ratio),\\n (\\\"Max Drawdown\\\", \\\"%0.2f%%\\\" % (max_dd * 100.0)),\\n (\\\"Drawdown Duration\\\", \\\"%s\\\" % dd_duration)]\\n\\n self.equity_curve.to_csv('equity.csv')\\n self.positions.to_csv('positions.csv')\\n self.prices.to_csv('prices.csv')\\n\\n return stats\",\n \"def printMachineStatOut():\\n print(\\\"---------------MACHINES STATS --------------------------\\\\n\\\", file=out_file)\\n for machine in machines_list:\\n cur_job_list = machine.retrieveJobsList()\\n print(\\\"machine number \\\", machine.number, \\\"assigned jobs [number,length,type]:\\\", file=out_file)\\n l = []\\n for job_number, job in cur_job_list.items():\\n l.append(job)\\n print(\\\"\\\".join(str(l)), file=out_file)\\n\\n print(\\\"Assigned types: \\\", machine.getTypes(), file=out_file)\\n print(\\\"Types histogram: \\\", machine.types, \\\"Sum of each type: \\\", machine.types_sums, \\\"Makespan : \\\", machine.span,\\n file=out_file)\\n print(\\\"\\\\n\\\", file=out_file)\\n print(\\\"Max makespan is : \\\", makeSpan(), file=out_file)\",\n \"def main():\\n data_visualisation()\\n write_hyper_params()\\n write_result_tables()\\n write_box_plots()\",\n \"def summarize(self, nthday=None):\\n assert self.validate()\\n D = self._data\\n if nthday is None:\\n daysel = slice(None)\\n else:\\n daysel = D['MJD'] < np.min(D['MJD']) + nthday\\n D = D[daysel]\\n tsched = 24 * D['tsched'].sum()\\n topen = 24 * D['topen'].sum()\\n tscience = 24 * D['tscience'].sum()\\n print('Scheduled {:.3f} hr Open {:.3f}% Live {:.3f}%'.format(\\n tsched, 100 * topen / max(1e-6, tsched), 100 * tscience / max(1e-6, topen)))\\n print('=' * 82)\\n print('PROG TILES NEXP SETUP ABT SPLIT ABT TEXP TSETUP TSPLIT TOPEN TDEAD')\\n print('=' * 82)\\n # Summarize by program.\\n for program in self.tiles.programs:\\n progidx = self.tiles.program_index[program]\\n ntiles_p, ndone_p, nexp_p, nsetup_p, nsplit_p, nsetup_abort_p, nsplit_abort_p = [0] * 7\\n tscience_p, tsetup_p, tsplit_p = [0.] * 3\\n ntiles_all = 0\\n sel = progidx\\n ntiles = np.sum(self.tiles.program_mask[program])\\n ndone = D['completed'][:, sel].sum()\\n nexp = D['nexp'][:, sel].sum()\\n nsetup = D['nsetup'][:, sel].sum()\\n nsplit = D['nsplit'][:, sel].sum()\\n nsetup_abort = D['nsetup_abort'][:, sel].sum()\\n nsplit_abort = D['nsplit_abort'][:, sel].sum()\\n tscience = 86400 * D['tscience'][:, sel].sum() / max(1, ndone)\\n tsetup = 86400 * D['tsetup'][:, sel].sum() / max(1, ndone)\\n tsplit = 86400 * D['tsplit'][:, sel].sum() / max(1, ndone)\\n line = '{:6s} {} {:4d}/{:4d} {:5d} {:5d} {:3d} {:5d} {:3d} {:6.1f}s {:5.1f}s {:5.1f}s'.format(\\n program, ' ', ndone, ntiles, nexp, nsetup, nsetup_abort, nsplit, nsplit_abort, tscience, tsetup, tsplit)\\n print(line)\",\n \"def print_results(self) -> None:\\n print(\\\"=\\\" * 70, file=sys.stderr)\\n total = 0.0\\n max_points = 0.0\\n for problem in self.problems:\\n total += problem.run_tests()\\n max_points += problem.max_grade\\n print(f\\\"Total Grade: {total}/{max_points}\\\", file=sys.stderr)\",\n \"def print_output(self):\\n print(\\\"Reference score: \\\" + str(self.PotTax_reference.sum().TFI))\\n print(\\\"Intervention score: \\\" + str(self.PotTax_intervention.sum().TFI))\\n return\",\n \"def main():\\n run_test_summary1a()\\n run_test_summary1c()\\n run_test_summary1c()\",\n \"def print_output():\\n print(\\\"count: [primary: \\\"+str(primary_shards)+\\\", replica: \\\"+str(secondary_shards)+\\\"]\\\")\\n print(\\\"size: [primary: \\\"+pretty_print_storage(total_size_primary)+\\\", replica: \\\"+pretty_print_storage(total_size_secondary)+\\\"]\\\")\\n print(\\\"disk-max-node: \\\"+max_size_node_name)\\n print(\\\"watermark-breached: \\\"+str(watermark_breached))\",\n \"def validation_summaries(self, step):\\n settings = self.settings\\n dnn_summary_writer = self.dnn_summary_writer\\n gan_summary_writer = self.gan_summary_writer\\n DNN = self.DNN\\n D = self.D\\n G = self.G\\n train_dataset = self.train_dataset\\n validation_dataset = self.validation_dataset\\n unlabeled_dataset = self.unlabeled_dataset\\n dnn_predicted_train_labels = DNN(torch.tensor(\\n train_dataset.examples.astype(np.float32)).to(gpu))[0].to('cpu').detach().numpy()\\n dnn_train_label_errors = np.mean(np.abs(dnn_predicted_train_labels - train_dataset.labels))\\n dnn_summary_writer.add_scalar('2 Train Error/MAE', dnn_train_label_errors, )\\n dnn_predicted_validation_labels = DNN(torch.tensor(\\n validation_dataset.examples.astype(np.float32)).to(gpu))[0].to('cpu').detach().numpy()\\n dnn_validation_label_errors = np.mean(np.abs(dnn_predicted_validation_labels - validation_dataset.labels))\\n dnn_summary_writer.add_scalar('1 Validation Error/MAE', dnn_validation_label_errors, )\\n predicted_train_labels = D(torch.tensor(\\n train_dataset.examples.astype(np.float32)).to(gpu))[0].to('cpu').detach().numpy()\\n gan_train_label_errors = np.mean(np.abs(predicted_train_labels - train_dataset.labels))\\n gan_summary_writer.add_scalar('2 Train Error/MAE', gan_train_label_errors, )\\n predicted_validation_labels = D(torch.tensor(\\n validation_dataset.examples.astype(np.float32)).to(gpu))[0].to('cpu').detach().numpy()\\n gan_validation_label_errors = np.mean(np.abs(predicted_validation_labels - validation_dataset.labels))\\n gan_summary_writer.add_scalar('1 Validation Error/MAE', gan_validation_label_errors, )\\n gan_summary_writer.add_scalar('1 Validation Error/Ratio MAE GAN DNN',\\n gan_validation_label_errors / dnn_validation_label_errors, )\\n z = torch.tensor(MixtureModel([norm(-settings.mean_offset, 1), norm(settings.mean_offset, 1)]).rvs(\\n size=[settings.batch_size, G.input_size]).astype(np.float32)).to(gpu)\\n fake_examples = G(z, add_noise=False)\\n fake_examples_array = fake_examples.to('cpu').detach().numpy()\\n fake_predicted_labels = D(fake_examples)[0]\\n fake_predicted_labels_array = fake_predicted_labels.to('cpu').detach().numpy()\\n unlabeled_labels_array = unlabeled_dataset.labels[:settings.validation_dataset_size]\\n label_wasserstein_distance = wasserstein_distance(fake_predicted_labels_array, unlabeled_labels_array)\\n gan_summary_writer.add_scalar('Generator/Predicted Label Wasserstein', label_wasserstein_distance, )\\n unlabeled_examples_array = unlabeled_dataset.examples[:settings.validation_dataset_size]\\n unlabeled_examples = torch.tensor(unlabeled_examples_array.astype(np.float32)).to(gpu)\\n unlabeled_predictions = D(unlabeled_examples)[0]\\n if dnn_summary_writer.step % settings.summary_step_period == 0:\\n unlabeled_predictions_array = unlabeled_predictions.to('cpu').detach().numpy()\\n validation_predictions_array = predicted_validation_labels\\n train_predictions_array = predicted_train_labels\\n dnn_validation_predictions_array = dnn_predicted_validation_labels\\n dnn_train_predictions_array = dnn_predicted_train_labels\\n distribution_image = generate_display_frame(fake_examples_array, unlabeled_predictions_array,\\n validation_predictions_array, dnn_validation_predictions_array,\\n train_predictions_array, dnn_train_predictions_array, step)\\n distribution_image = standard_image_format_to_tensorboard_image_format(distribution_image)\\n gan_summary_writer.add_image('Distributions', distribution_image)\",\n \"def log_output_data(self):\\r\\n with tf.name_scope('model_output'):\\r\\n for i in range(self.action_handler.get_number_actions()):\\r\\n variable_name = str(self.action_handler.action_list_names[i])\\r\\n tf.summary.histogram(variable_name + '_output', self.actor_last_row_layer[i])\",\n \"def print_results(self):\\n pass\",\n \"def output_summary_stats(self, filename):\\r\\n\\r\\n total_return = self.equity_curve['equity_curve'][-1]\\r\\n returns = self.equity_curve['returns']\\r\\n pnl = self.equity_curve['equity_curve']\\r\\n\\r\\n sharpe_ratio = create_sharpe_ratio(returns, periods=252)\\r\\n drawdown, max_dd, dd_duration = create_drawdowns(pnl)\\r\\n self.equity_curve['drawdown'] = drawdown\\r\\n\\r\\n stats = [(\\\"Total Return\\\", \\\"%0.2f%%\\\" % \\\\\\r\\n ((total_return - 1.0) * 100.0)),\\r\\n (\\\"Sharpe Ratio\\\", \\\"%0.2f%%\\\" % sharpe_ratio),\\r\\n (\\\"Max Drawdown\\\", \\\"%0.2f%%\\\" % (max_dd * 100.0)),\\r\\n (\\\"Drawdown Duration\\\", \\\"%f\\\" % dd_duration)]\\r\\n self.equity_curve.to_csv(filename)\\r\\n return stats\",\n \"def print_results(self, out_file):\\n extra_results = [\\n # Total test methods processed, excluding reruns.\\n [\\\"Test Methods\\\", len(self.result_events)],\\n [\\\"Reruns\\\", self.test_method_rerun_count]]\\n\\n # Output each of the test result entries.\\n categories = [\\n # result id, printed name, print matching tests?, detail label\\n [EventBuilder.STATUS_SUCCESS,\\n \\\"Success\\\", False, None],\\n [EventBuilder.STATUS_EXPECTED_FAILURE,\\n \\\"Expected Failure\\\", False, None],\\n [EventBuilder.STATUS_FAILURE,\\n \\\"Failure\\\", True, \\\"FAIL\\\"],\\n [EventBuilder.STATUS_ERROR,\\n \\\"Error\\\", True, \\\"ERROR\\\"],\\n [EventBuilder.STATUS_EXCEPTIONAL_EXIT,\\n \\\"Exceptional Exit\\\", True, \\\"ERROR\\\"],\\n [EventBuilder.STATUS_UNEXPECTED_SUCCESS,\\n \\\"Unexpected Success\\\", True, \\\"UNEXPECTED SUCCESS\\\"],\\n [EventBuilder.STATUS_SKIP, \\\"Skip\\\", False, None],\\n [EventBuilder.STATUS_TIMEOUT,\\n \\\"Timeout\\\", True, \\\"TIMEOUT\\\"],\\n [EventBuilder.STATUS_EXPECTED_TIMEOUT,\\n # Intentionally using the unusual hyphenation in TIME-OUT to\\n # prevent buildbots from thinking it is an issue when scanning\\n # for TIMEOUT.\\n \\\"Expected Timeout\\\", True, \\\"EXPECTED TIME-OUT\\\"]\\n ]\\n\\n # Partition all the events by test result status\\n result_events_by_status = self._partition_results_by_status(\\n categories)\\n\\n # Print the details\\n have_details = self._has_printable_details(\\n categories, result_events_by_status)\\n if have_details:\\n self._print_banner(out_file, \\\"Issue Details\\\")\\n for category in categories:\\n self._report_category_details(\\n out_file, category, result_events_by_status)\\n\\n # Print the summary\\n self._print_summary_counts(\\n out_file, categories, result_events_by_status, extra_results)\\n\\n if self.options.dump_results:\\n # Debug dump of the key/result info for all categories.\\n self._print_banner(out_file, \\\"Results Dump\\\")\\n for status, events_by_key in result_events_by_status.items():\\n out_file.write(\\\"\\\\nSTATUS: {}\\\\n\\\".format(status))\\n for key, event in events_by_key:\\n out_file.write(\\\"key: {}\\\\n\\\".format(key))\\n out_file.write(\\\"event: {}\\\\n\\\".format(event))\",\n \"def report(self, results):\\n self.notice(\\\"Test Report\\\\n\\\")\\n\\n for count, group in enumerate(results, 1):\\n results = (self._format_test(test, res) for test, res in group)\\n results = (', ').join(results)\\n self.notice(\\\"Test group %s:\\\\t%s\\\" % (count, results))\\n\\n self.divider()\",\n \"def printResults(self):\\n for key in self.mDict.keys():\\n print ('for {:d}, entries = {:d} and exits = {:d}'.format (key, self.mDict.get(key).get ('entries'), self.mDict.get(key).get ('exits')))\",\n \"def print_stats_to_file(file, cnt_insts, cnt_vars):\\n\\n for arg in sys.argv:\\n if arg == \\\"--insts\\\":\\n file.write(str(cnt_insts) + \\\"\\\\n\\\")\\n elif arg == \\\"--vars\\\":\\n file.write(str(cnt_vars) + \\\"\\\\n\\\")\",\n \"def write_error_report(self):\\n\\n with open('runReport.txt', 'a') as report:\\n report.write(\\\"Number of Hits: \\\" + str(self.num_hits) + '\\\\n')\\n report.write(\\\"Number of Requests: \\\" + str(self.num_requests) + '\\\\n')\\n report.write(\\\"Hit Rate: \\\" + str((self.num_hits / self.num_requests)))\\n report.write(\\\"Datafiles downloaded: \\\" + str(self.num_datafiles))\\n now = datetime.now()\\n dt_string = now.strftime(\\\"%H:%M %m/%d/%Y\\\")\\n report.write(\\\"Run finished \\\" + dt_string)\",\n \"def add_summary(self):\\n self.merged = tf.compat.v1.summary.merge_all()\\n self.file_writer = tf.compat.v1.summary.FileWriter(self.config.dir_output,\\n self.sess.graph)\",\n \"def outputTiming():\\r\\n print ('N\\\\tSum \\\\tSet\\\\t String\\\\t Loop')\\r\\n for trial in [2**_ for _ in range(1,11)]:\\r\\n numbers = f'[random.randint(0, 2 ** 24) for _ in range({trial})]'\\r\\n \\r\\n methods = ['sumValues', 'uniqueCheckSet', 'uniqueCheckString', 'uniqueCheckLoop' ]\\r\\n counts = {}\\r\\n for meth in methods:\\r\\n counts[meth] = timeit.timeit(stmt=f'{meth}(numbers)', number=1000,\\r\\n setup=f'import random\\\\nfrom __main__ import {meth}\\\\nrandom.seed({trial})\\\\nnumbers = {numbers}')\\r\\n\\r\\n results = '\\\\t'.join(f'{counts[meth]:f}' for meth in methods)\\r\\n print (f'{trial}\\\\t{results}')\",\n \"def und_generate_metrics(udb_file):\\n log.info(f\\\"Running Analysis for commit: {udb_file} ...\\\")\\n # stdout=subprocess.DEVNULL makes silent the stdout ,\\n subprocess.call(f\\\"und analyze -db {udb_file}\\\", stdout=subprocess.DEVNULL)\\n log.info(\\\"Calculating metrics and creating csv\\\")\\n subprocess.call(f\\\"und metrics {udb_file}\\\")\",\n \"def report(self):\\n #i need to figure out how to pass all these in a list or something, woof.\\n self.report_generator_module.run(\\\\\\n self.total,\\\\\\n self.unique,\\\\\\n self.top_10,\\\\\\n self.top_10_base,\\\\\\n self.lengths,\\\\\\n self.counts,\\\\\\n self.one_to_six,\\\\\\n self.trailing_number,\\\\\\n self.last_1digit,\\\\\\n self.last_2digit,\\\\\\n self.last_3digit,\\\\\\n self.last_4digit,\\\\\\n self.last_5digit,\\\\\\n self.charset)\",\n \"def summary(self, verbosity=0, file=None):\\n\\n if type(file) == type(\\\"\\\"):\\n f=open(file, \\\"w\\\")\\n else: f= sys.stdout\\n\\n f.write(_(\\\"The number of vertices is %d. \\\") % self.number_of_vertices)\\n f.write(_(\\\"The largest %s is %d.\\\\n\\\") % (self.degree_type, self.max_deg))\\n f.write(\\\"\\\\nDegree distribution:\\\\n\\\")\\n f.write(_(\\\" 0:%7.4f%%\\\\n\\\") % \\\\\\n (self.n_0/self.number_of_vertices*100))\\n\\n column=1\\n for degree, probability in self.dd:\\n f.write(\\\" %5d:%7.4f%%\\\" % (degree, probability*100))\\n if column == 5:\\n f.write(\\\"\\\\n\\\")\\n column=1\\n else: column += 1\\n f.write(\\\"\\\\n\\\")\",\n \"def add_summary(self):\\r\\n self.merged = tf.summary.merge_all()\\r\\n self.file_writer = tf.summary.FileWriter(self.config.dir_output,\\r\\n self.sess.graph)\",\n \"def output_data_stats(self, dictionary):\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Running: output_data_stats\\\"\\n\\t\\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_ip_stats.csv', 'w')\\n\\t\\tf.write('ip_pair, numTrue, numFalse, overallVote\\\\n')\\n\\t\\tfor ip in IP_Pair.objects.all():\\n\\t\\t\\t#print len(dictionary[ip])\\n\\t\\t\\tnumTrue = sum(1 for vote in dictionary[ip] if vote)\\n\\t\\t\\tnumFalse = len(dictionary[ip])- numTrue\\n\\t\\t\\toverallVote = (numTrue > numFalse)\\n\\t\\t\\tf.write(str(ip) + ', ' + str(numTrue) + ', ' + str(numFalse)\\n\\t\\t\\t\\t+ ', ' + str(overallVote) + '\\\\n')\\n\\t\\tf.close()\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Wrote File: \\\" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_ip_stats.csv'\",\n \"def summary(self):\\n\\n print(\\n \\\"\\\\nModel trained with dataset %s that has maxlen=%d and charset=%s for %d epochs.\\\"\\n % (self.dataset_name, self.maxlen, self.charset, self.epochs)\\n )\\n\\n print(\\n \\\"noise_std: %.6f, lstm_dim: %d, dec_layers: %d, td_dense_dim: %d, batch_size: %d, codelayer_dim: %d, lr: %.6f.\\\"\\n % (\\n self.noise_std,\\n self.lstm_dim,\\n self.dec_layers,\\n self.td_dense_dim,\\n self.batch_size,\\n self.codelayer_dim,\\n self.lr,\\n )\\n )\",\n \"def printMdStatus(self, segment, MD_run_count, MD_skip_count):\\n sys.stdout.write(self.writeMdStatus(segment, MD_run_count, MD_skip_count))\\n sys.stdout.flush()\",\n \"def printReport(self):\\n\\t\\tself.app.printflush('Fetched: ' + str(self.fetched_count), self.app.IGNORE_EXIT_FLAG)\\n\\t\\tself.app.printflush('Processes: ' + str(self.processes), self.app.IGNORE_EXIT_FLAG)\\n\\t\\tself.app.printflush('Updated: ' + str(self.updated_count), self.app.IGNORE_EXIT_FLAG)\\n\\t\\tself.app.printflush('Average page load time: ' + str(self.average_time), self.app.IGNORE_EXIT_FLAG)\\n\\t\\tself.app.printflush('Returned with code: ' + repr(self.code_statistics), self.app.IGNORE_EXIT_FLAG)\\n\\t\\tself.app.printflush('Closing Processes... ', self.app.IGNORE_EXIT_FLAG)\",\n \"def print_summary_stats(self) -> None:\\n print(\\\"Number of Users: {}\\\".format(len(self.all_users)))\\n print(\\\"Number of Utterances: {}\\\".format(len(self.utterances)))\\n print(\\\"Number of Conversations: {}\\\".format(len(self.conversations)))\",\n \"def main():\\n rows = []\\n for path in DATA.glob(\\\"*.tsv\\\"):\\n with path.open() as file:\\n _header = next(file)\\n for line in file:\\n dead_id, when, alt_id = line.strip(\\\"\\\\n\\\").split(\\\"\\\\t\\\")\\n rows.append((path.stem, dead_id, when, alt_id))\\n\\n rows = sorted(rows)\\n\\n with OUTPUT_PATH.open(\\\"w\\\") as file:\\n print(*HEADER, sep=\\\"\\\\t\\\", file=file)\\n for row in rows:\\n print(*row, sep=\\\"\\\\t\\\", file=file)\\n\\n df = pd.DataFrame(rows, columns=[\\\"prefix\\\", \\\"dead_id\\\", \\\"date\\\", \\\"alternative_id\\\"])\\n fig, ax = plt.subplots(figsize=(6, 3))\\n sns.histplot(data=df, y=\\\"prefix\\\", ax=ax)\\n ax.set_ylabel(\\\"\\\")\\n ax.set_xscale(\\\"log\\\")\\n ax.set_xlabel(\\\"Dead Identifiers\\\")\\n fig.tight_layout()\\n fig.savefig(SUMMARY_SVG_PATH)\",\n \"def main():\\n file_txt = open('results.txt','w+')\\n positions = [1,10,100,1000]\\n num_trials = 10000\\n \\n # Simulate the investment and plot histogram for different positions\\n for position in positions:\\n daily_ret = simulation(position, num_trials)\\n plt.figure()\\n plt.hist(daily_ret, 100, range=[-1,1])\\n plt.title('The histogram of daily return for position ={}'.format(position))\\n plt.xlabel('Daily return')\\n plt.ylabel('The number of trials')\\n plt.savefig('histogram_{}_pos.pdf'.format(str(position).zfill(4)))\\n \\n # Save the results of the simulation into a txt file \\n file_txt.write('Position: {}\\\\n'.format(position))\\n file_txt.write('Mean: {}; Std: {}\\\\n'.format(np.mean(daily_ret),np.std(daily_ret)))\\n file_txt.write('\\\\n')\\n file_txt.close()\",\n \"def summary(self):\\n\\n print(\\\"input label:\\\", self.__input_label)\\n print(\\\"target label:\\\", self.__target_label)\\n print(\\\"denoising label:\\\", self.denoising_label)\\n print(\\\"contains a successful DE:\\\", self.is_successful())\",\n \"def add_summary(self):\\n self.merged = tf.summary.merge_all()\\n print(self.merged)\\n self.file_writer = tf.summary.FileWriter(self.config.graph_output, self.sess.graph)\",\n \"def output_summary_stats(self):\\n total_return = self.equity_curve['equity_curve'][-1]\\n returns = self.equity_curve['returns']\\n pnl = self.equity_curve['equity_curve']\\n \\n sharpe_ratio = create_sharpe_ratio(returns, periods=252*6.5*60)\\n drawdown, max_dd, dd_duration = create_drawdowns(pnl)\\n self.equity_curve['drawdown'] = drawdown\\n \\n stats = [(\\\"Total Return\\\", \\\"%0.2f%%\\\" % ((total_return - 1.0) * 100.0)), \\n (\\\"Sharpe Ratio\\\", \\\"%0.2f\\\" % sharpe_ratio), \\n (\\\"Max Drawdown\\\", \\\"%0.2f%%\\\" % (max_dd * 100.0)), \\n (\\\"Drawdown Duration\\\", \\\"%d\\\" % dd_duration)]\\n \\n self.equity_curve.to_csv('equity.csv')\\n \\n return stats\",\n \"def outputs(self):\\n pass\",\n \"def show_runs(self,start=0,end=99999999,csv=False):\\n if csv:\\n print '{:>7}, {:>10}, {:>8}, {:>10}, {:3}, {:2}'.format('Run', \\n 'Day', 'Time', 'Length', 'xtc', 'h5') \\n \\n else:\\n print '='*72\\n print 'Experiment {:}'.format(self.exp)\\n print ' xtc dir {:}'.format(self.xtc_dir)\\n print ' hdf5 dir {:}'.format(self.h5_dir)\\n print '-'*72\\n print '{:>7} {:>10} {:>8} {:>10} {:3} {:2}'.format('Run', 'Day', 'Time', \\n 'Length', 'xtc', 'h5') \\n print '-'*72\\n \\n for item in self.runs:\\n run = item['num']\\n if run >= start and run <= end:\\n datestr = time.strftime('%Y-%m-%d',\\n time.localtime(item['begin_time_unix']))\\n timestr = time.strftime('%H:%M:%S',\\n time.localtime(item['begin_time_unix']))\\n if len(item['xtc_files']) > 0:\\n xtc = 'xtc'\\n else:\\n xtc = ''\\n \\n if len(item['h5_files']) > 0:\\n h5 = 'h5'\\n else:\\n h5 = ''\\n \\n begin_time = item['begin_time_unix']\\n end_time = item['end_time_unix'] \\n if end_time:\\n dtime = end_time - begin_time\\n flag = ' '\\n else:\\n dtime = time.time() - begin_time\\n flag = '*'\\n\\n dmin = int(dtime/60)\\n dsec = int(dtime % 60)\\n if dmin > 0:\\n dtstr = '{:4}m {:02}s'.format(dmin,dsec)\\n else:\\n dtstr = '{:02}s'.format(dsec)\\n\\n if csv:\\n print '{:7}, {:10}, {:8}, {:>10}, {:3}, {:2}'.format(run,\\n datestr, timestr, dtstr, xtc, h5)\\n else:\\n print '{:7} {:10} {:8} {:>10} {:3} {:2}'.format(run,\\n datestr, timestr, dtstr, xtc, h5)\\n\\n if flag in '*':\\n print '* Currently Acquiring Data for Run {:}'.format(run)\",\n \"def debug(self):\\n \\n #path\\n print('Path information:')\\n for k, v in self.__path.items():\\n print(k, v)\\n \\n #sample count\\n print('Sample statistic of each phase')\\n for k, v in self.__phase_sample_count.items():\\n print(k, v)\\n \\n print('Sample statistic of each class')\\n for k, v in self.__area_sample_count.items():\\n print(k, v)\\n \\n print('Sample statistic of each train')\\n for k, v in self.__train_sample_count.items():\\n print(k, v)\",\n \"def output_summary_stats(self):\\n total_return = self.equity_curve['equity_curve'][-1]\\n returns = self.equity_curve['returns']\\n pnl = self.equity_curve['equity_curve']\\n \\n sharpe_ratio = create_sharpe_ratio(returns) #, periods=252*6.5*60) ??? \\n drawdown, max_dd, dd_duration = create_drawdowns(pnl)\\n self.equity_curve['drawdown'] = drawdown\\n \\n stats = [(\\\"Total Return\\\", \\\"%0.2f%%\\\" % ((total_return - 1.0) * 100.0)), \\n (\\\"Sharpe Ratio\\\", \\\"%0.2f\\\" % sharpe_ratio), \\n (\\\"Max Drawdown\\\", \\\"%0.2f%%\\\" % (max_dd * 100.0)), \\n (\\\"Drawdown Duration\\\", \\\"%d\\\" % dd_duration)]\\n \\n self.equity_curve.to_csv('equity.csv')\\n \\n return stats\",\n \"def log_evaluation(tester, name, description):\\r\\n\\tfor dataset, output in tester.preds.items():\\r\\n\\t\\tresults = pandas.DataFrame.from_dict(output)\\r\\n\\t\\tpath = os.path.join(\\r\\n\\t\\t\\tEXPERIMENT_PATH, tester.config[\\\"name\\\"] + '-' + dataset)\\r\\n\\t\\twith open(path + \\\".csv\\\", \\\"w\\\") as f:\\r\\n\\t\\t\\tresults.to_csv(f, sep=\\\"\\\\t\\\", encoding='utf-8',\\r\\n\\t\\t\\t\\tfloat_format='%.3f', index=False)\",\n \"def dataStats(self):\\n print (\\\"Performing statistical analysis of the data\\\")\\n # stuff to do\",\n \"def test_summary(args, path):\\n log = os.path.join(path, \\\"kstest.log.json\\\")\\n with open(log) as f:\\n data = json.load(f)\\n scenario = data[0].get(\\\"scenario\\\", None)\\n if not scenario:\\n raise RuntimeError(\\\"No scenario found in %s\\\" % log)\\n\\n # The json log filename needs to be in the form of <scenario>-<YYYY-MM-DD>.json\\n datename = f\\\"{scenario}-1990-01-01\\\"\\n shutil.copy(log, datename+\\\".json\\\")\\n datenames = [datename]\\n all_logs = {datename: path}\\n\\n report = summary(args, (d+\\\".json\\\" for d in datenames), all_logs)\\n if args.output:\\n with open(args.output, \\\"w\\\") as f:\\n f.write(report)\\n else:\\n print(report)\",\n \"def print_test_details(scenario, days, test_name, buf):\\n for d in days:\\n if scenario not in days[d]:\\n continue\\n\\n for n in days[d][scenario][test_name]:\\n print(f\\\"\\\\n{n}:\\\", file=buf)\\n for test in days[d][scenario][test_name][n]:\\n if \\\"start_time\\\" not in test:\\n start_time = \\\"\\\"\\n else:\\n start_time = datetime.fromtimestamp(test[\\\"start_time\\\"]).strftime(\\\"%m/%d/%Y %H:%M:%S\\\")\\n\\n if \\\"elapsed_time\\\" not in test:\\n elapsed_time = 0\\n else:\\n elapsed_time = test[\\\"elapsed_time\\\"]\\n\\n # Get the result message\\n msg = test[\\\"result\\\"].rsplit(\\\"FAILED:\\\")[-1]\\n print(f' {start_time} ({elapsed_time}s): {msg}', file=buf)\",\n \"def output_running_tasks(self):\\r\\n results_dirname = get_param(\\\"results_dir\\\")\\r\\n for user_id in range(get_param(\\\"num_users\\\")):\\r\\n filename = os.path.join(results_dirname, \\\"%s_running_tasks_%d\\\" %\\r\\n (get_param(\\\"file_prefix\\\"), user_id))\\r\\n running_tasks_file = open(filename, \\\"w\\\")\\r\\n self.write_running_tasks(running_tasks_file,\\r\\n self.running_tasks[user_id])\\r\\n running_tasks_file.close()\\r\\n \\r\\n # Output aggregate running tasks.\\r\\n filename = os.path.join(results_dirname, \\\"%s_running_tasks\\\" %\\r\\n get_param(\\\"file_prefix\\\"))\\r\\n running_tasks_file = open(filename, \\\"w\\\")\\r\\n self.write_running_tasks(running_tasks_file, self.total_running_tasks)\\r\\n running_tasks_file.close()\",\n \"def write_report(self):\\n\\n def report_array(f, label, array):\\n f.write(label)\\n for val in array:\\n f.write('{:.4f},\\\\t'.format(val))\\n f.write('\\\\n')\\n\\n report_file = FLAGS.report_file\\n\\n with open(report_file, 'w') as f:\\n f.write('Mean Error 2D: {}\\\\n'.format(\\n safe_divide(self._error_2d, self._matched)))\\n f.write('Mean 3D IoU: {}\\\\n'.format(\\n safe_divide(self._iou_3d, self._matched)))\\n f.write('Mean Azimuth Error: {}\\\\n'.format(\\n safe_divide(self._azimuth_error, self._matched)))\\n f.write('Mean Polar Error: {}\\\\n'.format(\\n safe_divide(self._polar_error, self._matched)))\\n\\n f.write('\\\\n')\\n f.write('IoU Thresholds: ')\\n for threshold in self._iou_thresholds:\\n f.write('{:.4f},\\\\t'.format(threshold))\\n f.write('\\\\n')\\n report_array(f, 'AP @3D IoU : ', self._iou_ap.aps)\\n\\n f.write('\\\\n')\\n f.write('2D Thresholds : ')\\n for threshold in self._pixel_thresholds:\\n f.write('{:.4f},\\\\t'.format(threshold * 0.1))\\n f.write('\\\\n')\\n report_array(f, 'AP @2D Pixel : ', self._pixel_ap.aps)\\n f.write('\\\\n')\\n\\n f.write('Azimuth Thresh: ')\\n for threshold in self._azimuth_thresholds:\\n f.write('{:.4f},\\\\t'.format(threshold * 0.1))\\n f.write('\\\\n')\\n report_array(f, 'AP @Azimuth : ', self._azimuth_ap.aps)\\n f.write('\\\\n')\\n\\n f.write('Polar Thresh : ')\\n for threshold in self._polar_thresholds:\\n f.write('{:.4f},\\\\t'.format(threshold * 0.1))\\n f.write('\\\\n')\\n report_array(f, 'AP @Polar : ', self._polar_ap.aps)\",\n \"def generate_summary(final_dictionary):\\n otpt = open('multifind_summary.txt', 'w')\\n for cat in final_dictionary:\\n category_name = cat[0] + ': ' + str(len(cat[1])) + '\\\\n'\\n otpt.write(category_name)\\n for entry in cat[1]:\\n otpt.write('\\\\t' + str(entry[0]) + '\\\\n')\\n otpt.write('\\\\t\\\\tTotal Entries: %s\\\\n' % str(entry[1]))\\n otpt.write('\\\\t\\\\tUnique Species: %s\\\\n' % str(entry[2]))\\n count = 0\\n for sp in entry[3]:\\n if count < entry[2]-1:\\n if count == 0:\\n otpt.write('\\\\t\\\\tSpecies: ' + sp + ', ')\\n else:\\n otpt.write(sp + ', ')\\n else:\\n otpt.write(sp + '\\\\n')\\n count += 1\\n otpt.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.706741","0.6504042","0.64469904","0.6359","0.6317233","0.62217075","0.62181455","0.62145364","0.6196254","0.61518073","0.61190933","0.61190766","0.61024827","0.60801","0.6074785","0.6020409","0.6015638","0.6012356","0.59702814","0.59702814","0.5955046","0.5953532","0.5950683","0.5946566","0.5942603","0.5941369","0.58944094","0.58873546","0.5857361","0.5843959","0.5804332","0.5786467","0.57849574","0.575996","0.5757898","0.575757","0.5747579","0.5738374","0.5727684","0.5726638","0.57202053","0.5718427","0.57063645","0.56831944","0.567712","0.56755173","0.5670093","0.56694835","0.56521344","0.56506884","0.56505895","0.5642972","0.5639958","0.5636025","0.56262845","0.5625267","0.5624588","0.5622254","0.5621434","0.562024","0.5617719","0.56101596","0.5606036","0.5598565","0.5596376","0.55962026","0.5595152","0.5591249","0.55897886","0.5585459","0.55785507","0.55773926","0.5574478","0.556963","0.55685955","0.55667114","0.55665314","0.5566516","0.5563755","0.5562515","0.5549337","0.5545496","0.5544344","0.554336","0.5540503","0.5534358","0.5527666","0.55205625","0.55130005","0.5510024","0.55072504","0.55012375","0.5491982","0.5487795","0.5486335","0.54824173","0.547499","0.54731137","0.5469278","0.546517","0.54642504"],"string":"[\n \"0.706741\",\n \"0.6504042\",\n \"0.64469904\",\n \"0.6359\",\n \"0.6317233\",\n \"0.62217075\",\n \"0.62181455\",\n \"0.62145364\",\n \"0.6196254\",\n \"0.61518073\",\n \"0.61190933\",\n \"0.61190766\",\n \"0.61024827\",\n \"0.60801\",\n \"0.6074785\",\n \"0.6020409\",\n \"0.6015638\",\n \"0.6012356\",\n \"0.59702814\",\n \"0.59702814\",\n \"0.5955046\",\n \"0.5953532\",\n \"0.5950683\",\n \"0.5946566\",\n \"0.5942603\",\n \"0.5941369\",\n \"0.58944094\",\n \"0.58873546\",\n \"0.5857361\",\n \"0.5843959\",\n \"0.5804332\",\n \"0.5786467\",\n \"0.57849574\",\n \"0.575996\",\n \"0.5757898\",\n \"0.575757\",\n \"0.5747579\",\n \"0.5738374\",\n \"0.5727684\",\n \"0.5726638\",\n \"0.57202053\",\n \"0.5718427\",\n \"0.57063645\",\n \"0.56831944\",\n \"0.567712\",\n \"0.56755173\",\n \"0.5670093\",\n \"0.56694835\",\n \"0.56521344\",\n \"0.56506884\",\n \"0.56505895\",\n \"0.5642972\",\n \"0.5639958\",\n \"0.5636025\",\n \"0.56262845\",\n \"0.5625267\",\n \"0.5624588\",\n \"0.5622254\",\n \"0.5621434\",\n \"0.562024\",\n \"0.5617719\",\n \"0.56101596\",\n \"0.5606036\",\n \"0.5598565\",\n \"0.5596376\",\n \"0.55962026\",\n \"0.5595152\",\n \"0.5591249\",\n \"0.55897886\",\n \"0.5585459\",\n \"0.55785507\",\n \"0.55773926\",\n \"0.5574478\",\n \"0.556963\",\n \"0.55685955\",\n \"0.55667114\",\n \"0.55665314\",\n \"0.5566516\",\n \"0.5563755\",\n \"0.5562515\",\n \"0.5549337\",\n \"0.5545496\",\n \"0.5544344\",\n \"0.554336\",\n \"0.5540503\",\n \"0.5534358\",\n \"0.5527666\",\n \"0.55205625\",\n \"0.55130005\",\n \"0.5510024\",\n \"0.55072504\",\n \"0.55012375\",\n \"0.5491982\",\n \"0.5487795\",\n \"0.5486335\",\n \"0.54824173\",\n \"0.547499\",\n \"0.54731137\",\n \"0.5469278\",\n \"0.546517\",\n \"0.54642504\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6380,"cells":{"query":{"kind":"string","value":"Plot the comparison between the data and the chosen model. This is a copypaste with some modification from the dadi.Plotting.plot_2d_comp_Poisson function."},"document":{"kind":"string","value":"def plot(self, vmin, vmax, resid_range=None,\n pop_ids=None, residual='Anscombe'):\n # Scale the model SFS to the data SFS\n sc_mod = dadi.Inference.optimally_scaled_sfs(self.model_sfs, self.sfs)\n # Start a new figure, and clear it\n f = pylab.gcf()\n pylab.clf()\n\n ax = pylab.subplot(2,2,1)\n dadi.Plotting.plot_single_2d_sfs(self.sfs, vmin=vmin, vmax=vmax,\n pop_ids=self.popnames, colorbar=False)\n ax.set_title('Data')\n\n ax2 = pylab.subplot(2,2,2, sharex=ax, sharey=ax)\n dadi.Plotting.plot_single_2d_sfs(sc_mod, vmin=vmin, vmax=vmax,\n pop_ids=self.popnames, extend='neither')\n ax2.set_title('Model')\n\n resid = dadi.Inference.Anscombe_Poisson_residual(sc_mod, self.sfs,\n mask=vmin)\n if resid_range is None:\n resid_range = max((abs(resid.max()), abs(resid.min())))\n\n ax3 = pylab.subplot(2,2,3, sharex=ax, sharey=ax)\n dadi.Plotting.plot_2d_resid(resid, resid_range, pop_ids=self.popnames,\n extend='neither')\n ax3.set_title('Residuals')\n\n ax = pylab.subplot(2,2,4)\n flatresid = numpy.compress(numpy.logical_not(resid.mask.ravel()), \n resid.ravel())\n ax.hist(flatresid, bins=20, normed=True)\n ax.set_title('Residuals')\n ax.set_yticks([])\n pylab.tight_layout()\n f.savefig(self.figout, bbox_inches='tight')\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def display_comparison(self, X_val, y_val):\n import matplotlib.pyplot as plt\n x = []\n y = []\n for model_tuple in self.model_list:\n x.append(model_tuple[1])\n y.append(model_tuple[0].score(X_val, y_val))\n plt.scatter(x, y)\n plt.show()","def plot_compare(self, model, u_model, obs, u_obs, bprop, ax=None, title=False,\n display=True, xlabel=False, legend=False):\n # TODO: move to mcmc_plot?\n fontsize = 12\n markersize = 6\n capsize = 3\n n_sigma = 3\n dx = 0.13 # horizontal offset of plot points\n yscale = {'dt': 1.0, 'rate': 1.0,\n 'fluence': 1e-6, 'peak': 1e-8, 'fper': 1e-9}.get(bprop)\n ylabel = {'dt': r'$\\Delta t$',\n 'rate': 'Burst rate',\n 'fluence': r'$E_b$',\n 'peak': r'$F_{peak}$',\n 'fper': r'$F_p$'}.get(bprop, bprop)\n y_units = {'dt': 'hr',\n 'rate': 'day$^{-1}$',\n 'fluence': r'$10^{-6}$ erg cm$^{-2}$',\n 'peak': r'$10^{-8}$ erg cm$^{-2}$ s$^{-1}$',\n 'fper': r'$10^{-9}$ erg cm$^{-2}$ s$^{-1}$'}.get(bprop)\n if ax is None:\n fig, ax = plt.subplots(figsize=(5, 4))\n\n epochs = np.array(self.obs.epoch)\n x = epochs\n\n ax.errorbar(x=x - dx, y=model/yscale, yerr=n_sigma*u_model/yscale, ls='none', marker='o',\n capsize=capsize, color='C3', label='Model', markersize=markersize)\n ax.errorbar(x=x + dx, y=obs/yscale, yerr=n_sigma*u_obs/yscale, ls='none',\n marker='o', capsize=capsize, color='C0', label='Observed',\n markersize=markersize)\n\n ax.set_ylabel(f'{ylabel} ({y_units})', fontsize=fontsize)\n ax.set_xticks(epochs)\n\n if xlabel:\n ax.set_xticklabels([f'{year}' for year in epochs])\n ax.set_xlabel('Epoch year', fontsize=fontsize)\n else:\n ax.set_xticklabels([])\n\n if title:\n ax.set_title(ylabel, fontsize=fontsize)\n if legend:\n ax.legend()\n plt.tight_layout()\n if display:\n plt.show(block=False)","def model_visualization(model,X,y,classifier):\n sns.set_context(context='notebook',font_scale=2)\n plt.figure(figsize=(16,9))\n from matplotlib.colors import ListedColormap\n X_set, y_set = X, y\n X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\n plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha = 0.6, cmap = ListedColormap(('green', 'blue')))\n plt.xlim(X1.min(), X1.max())\n plt.ylim(X2.min(), X2.max())\n for i, j in enumerate(np.unique(y_set)):\n plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\n color = ListedColormap(('turquoise', 'blue'))(i), label = j)\n plt.title(\"%s Model Set\" %(model))\n plt.xlabel('PC 1')\n plt.ylabel('PC 2')\n plt.legend()\n plt.savefig('images/{0}.png'.format(model))","def plot(model, samples):\n # compute responsiblity values\n resp = model.predict_proba(samples)\n\n # plot\n plt.axis('equal')\n plt.scatter(samples[:,0], samples[:,1], c=resp)\n plt.show()","def make_comparison_plot(\n nu,\n y_comp,\n y_ref,\n comp_label,\n ref_label,\n fig_title,\n fig_path,\n plot_type,\n y_range=None,\n comparison_range=None\n):\n if plot_type == \"sed\":\n # set the axes labels for an SED plot\n x_label = SED_X_LABEL\n y_label = SED_Y_LABEL\n deviation_label = SED_DEVIATION_LABEL\n elif plot_type == \"tau\":\n # set the axes labels for a tau plot\n x_label = TAU_X_LABEL\n y_label = TAU_Y_LABEL\n deviation_label = TAU_DEVIATION_LABEL\n else:\n # set a custom y label, keep the x-axis in frequency\n x_label = SED_X_LABEL\n y_label = plot_type\n deviation_label = f\"({plot_type} agnpy / {plot_type} ref.) - 1\"\n # make the plot\n fig, ax = plt.subplots(\n 2,\n sharex=True,\n gridspec_kw={\"height_ratios\": [2, 1], \"hspace\": 0.05},\n figsize=(8, 6),\n )\n\n # plot the SEDs or TAUs in the upper panel\n # plot the reference sed with a continuous line and agnpy sed with a dashed one\n ax[0].loglog(nu, y_ref, marker=\".\", ls=\"-\", color=\"k\", lw=1.5, label=ref_label)\n ax[0].loglog(\n nu, y_comp, marker=\".\", ls=\"--\", color=\"crimson\", lw=1.5, label=comp_label\n )\n ax[0].set_ylabel(y_label)\n ax[0].set_title(fig_title)\n ax[0].legend(loc=\"best\")\n if y_range is not None:\n ax[0].set_ylim(y_range)\n if comparison_range is not None:\n ax[0].axvline(comparison_range[0], ls=\"--\", color=\"dodgerblue\")\n ax[0].axvline(comparison_range[1], ls=\"--\", color=\"dodgerblue\")\n ax[0].grid(ls=\":\")\n\n # plot the deviation in the bottom panel\n deviation = y_comp / y_ref - 1\n ax[1].axhline(0, ls=\"-\", color=\"darkgray\")\n ax[1].axhline(0.2, ls=\"--\", color=\"darkgray\")\n ax[1].axhline(-0.2, ls=\"--\", color=\"darkgray\")\n ax[1].axhline(0.3, ls=\":\", color=\"darkgray\")\n ax[1].axhline(-0.3, ls=\":\", color=\"darkgray\")\n ax[1].set_ylim([-0.5, 0.5])\n ax[1].semilogx(\n nu,\n deviation,\n marker=\".\",\n ls=\"--\",\n color=\"crimson\",\n lw=1.5,\n label=deviation_label,\n )\n ax[1].set_xlabel(x_label)\n ax[1].legend(loc=\"best\")\n if comparison_range is not None:\n ax[1].axvline(comparison_range[0], ls=\"--\", color=\"dodgerblue\")\n ax[1].axvline(comparison_range[1], ls=\"--\", color=\"dodgerblue\")\n\n fig.savefig(f\"{fig_path}\")\n # avoid RuntimeWarning: More than 20 figures have been opened.\n plt.close(fig)","def plot_dif_eq(self):\n try:\n self.canvas.get_tk_widget().pack_forget()\n self.toolbar.pack_forget()\n except AttributeError:\n pass\n\n f = Figure(figsize=(8, 8), dpi=100)\n p = f.add_subplot(111)\n\n p.plot(self.model.ex.x_coord_plot, self.model.ex.y_coord_plot, c = 'C6')\n p.scatter(self.model.ex.x_coord, self.model.ex.y_coord, c = 'C6')\n p.plot(self.model.eu.x_coord, self.model.eu.y_coord, marker='o')\n p.plot(self.model.ieu.x_coord, self.model.ieu.y_coord, marker='o')\n p.plot(self.model.rk.x_coord, self.model.rk.y_coord, marker='o')\n\n p.set_ylabel('y')\n p.set_xlabel('x')\n\n p.legend(['Exact', 'EU', \"IEU\", \"RK\"])\n p.set_title(\"Solutions\")\n if max(self.model.ex.y_coord_plot) >= 1e5 or max(self.model.eu.y_coord) >= 1e5 \\\n or max(self.model.ieu.y_coord) >= 1e5 or max(self.model.rk.y_coord) >= 1e5:\n p.set_ylim([-100, 100])\n\n if min(self.model.ex.y_coord_plot) <= -1e5 or min(self.model.eu.y_coord) <= -1e5 \\\n or min(self.model.ieu.y_coord) <= -1e5 or min(self.model.rk.y_coord) <= -1e5:\n p.set_ylim([-100, 100])\n\n self.canvas = FigureCanvasTkAgg(f, self.f_left)\n self.canvas.draw()\n self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=False)\n\n self.toolbar = NavigationToolbar2Tk(self.canvas, self.f_left)\n self.toolbar.update()\n\n self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=False)","def model_comp_plot(id_model_list, filename):\n\taxes = plt.gca()\n\taxes.set_ylim(0, 10 * np.median([k['mse'] for i, k in enumerate(id_model_list)]))\n\tplt.plot([k['id'] for i, k in enumerate(id_model_list)], [k['mse'] for i, k in enumerate(id_model_list)], 'bo')\n\tplt.ylabel('Validation MSE')\n\tplt.xlabel('Model ID')\n\tplt.savefig(filename)\n\tplt.close()","def plot_comparison(*, dates, vo, vo_denoised, position, model_data,\n fig_size=(15, 5), font_size=12, label_size=14,\n save_fig=False, write_path=None, deriv=1):\n # Choose labels for plots (either for MF or SV)\n if deriv == 0:\n components = ['X_', 'Y_', 'Z_']\n labels = [r'X (nT)', r'Y (nT)', r'Z (nT)']\n elif deriv == 1:\n components = ['dx_', 'dy_', 'dz_']\n labels = [r'dX/dt (nT/yr)', r'dY/dt (nT/yr)', r'dZ/dt (nT/yr)']\n colors = ['red', 'green', 'blue']\n fig, ax = plt.subplots(1, 3, sharex=True, figsize=fig_size)\n\n for i in range(0, len(components)):\n plt.subplot(1, 3, i+1)\n plt.plot(dates, vo.filter(regex=components[i]+str(position).zfill(3)),\n color='grey', linestyle='--', linewidth=2)\n plt.plot(dates, vo_denoised.filter(\n regex=components[i]+str(position).zfill(3)), color=colors[i],\n linewidth=2)\n plt.plot(dates, model_data.filter(\n regex=components[i]+str(position).zfill(3)), color='black',\n linewidth=2)\n plt.ylabel(labels[i])\n plt.xticks(fontsize=font_size)\n plt.yticks(fontsize=font_size)\n fig.text(0.5, 0.01, 'Date', ha='center', fontsize=label_size)\n fig.text(0.05, 0.5, 'GVO ' + str(position), fontsize=label_size,\n rotation='vertical')\n if save_fig is True:\n # Create the output directory if it does not exist\n if not os.path.exists(write_path):\n os.makedirs(write_path)\n fpath = os.path.join(write_path, 'GVO_'+str(position).zfill(3) +\\\n '.png')\n plt.savefig(fpath, bbox_inches='tight')\n plt.close()","def compare(self, plot=False):\n oldConditionData, newConditionData = self.runSimulations()\n \n #For now make print statements about each none matching data\n conditionsBroken=[]\n variablesFailed=[]\n for i in range(len(oldConditionData)):\n timeOld, dataListOld = oldConditionData[i]\n timeNew, dataListNew = newConditionData[i]\n\n for variableOld, variableNew in zip(dataListOld, dataListNew):\n if not curvesSimilar(timeOld.data, variableOld.data, timeNew.data, variableNew.data, 0.05):\n if i not in conditionsBroken: conditionsBroken.append(i)\n\n if variableOld.species:\n label = variableOld.species.molecule[0].toSMILES()\n print \"Species profile for {0} does not match between the old model ({1}) and \\\n the new model ({2}) in condition {3:d}.\".format(variableOld.species.molecule[0].toSMILES(),\n variableOld.label, \n variableNew.label,\n i+1)\n else:\n label = variableOld.label\n print \"{0} does not match between the old model and \\\n the new model in condition {1:d}.\".format(variableOld.label, i+1)\n\n variablesFailed.append((self.conditions[i], label, variableOld, variableNew))\n print ''\n print 'The following reaction conditions were broken:'\n print ''\n for index in conditionsBroken:\n print \"Condition {0:d}:\"\n print str(self.conditions[index])\n print ''\n\n if plot:\n # Ignore Inerts\n inertList = ['[Ar]','[He]','[N#N]','[Ne]']\n for i in range(len(oldConditionData)):\n time, dataList = oldConditionData[i]\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\n oldSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\n\n time, dataList = newConditionData[i]\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\n newSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\n\n # Name after the index of the condition\n # though it may be better to name it after the actual conditions in T, P, etc\n oldSpeciesPlot.comparePlot(newSpeciesPlot,filename='simulation_condition_{0}.png'.format(i+1))\n\n return variablesFailed","def plot_model(self):\n \n plt.figure(figsize=[10,5])\n \n plt.scatter(self.receivers['recxs'],self.receivers['reczs'],marker='v')\n if self.source['src_type']==4:\n from obspy.imaging.beachball import beach\n beach = beach(self.source['mt'], xy=(self.source['srcx'],self.source['srcz']), width=self.model_parameters['xmax']*0.05)\n ax = plt.gca()\n \n ax.add_collection(beach) \n ax.set_aspect(\"equal\")\n \n else:\n plt.scatter(self.source['srcx'],self.source['srcz'],marker='*',color='r',s=200)\n \n plt.axhline(y=0,c='0.5')\n plt.xlim(0,self.model_parameters['xmax'])\n plt.ylim(self.model_parameters['zmax'],-0.1*self.model_parameters['zmax'])\n \n plt.xlabel('Distance (km)')\n plt.ylabel('Depth (km)')\n plt.grid()\n plt.show()","def generatePlot (self, Xdata_exp, Xdata_model, Ydata_exp, Ydata_model, Component_name):\n \n #self.clear_results_directory(results_dir)\n \n XaxisLabel = 'TCD Conversion [%]'\n YaxisLabel = 'Product Yield [wt %]'\n \n self.drawplot(XaxisLabel, YaxisLabel, Xdata_exp, Xdata_model, Ydata_exp, Ydata_model, Component_name)","def plot_and_compare(xs,ys, m,b):\n\n plt.scatter(xs, ys, color = 'blue')\n\n plt.plot(xs, (xs * m) + b, color = 'red')","def test_plot_compare_no_ic(models):\n model_compare = compare({\"Model 1\": models.model_1, \"Model 2\": models.model_2})\n\n # Drop column needed for plotting\n model_compare = model_compare.drop(\"elpd_loo\", axis=1)\n with pytest.raises(ValueError) as err:\n plot_compare(model_compare)\n\n assert \"comp_df must contain one of the following\" in str(err.value)\n assert \"['elpd_loo', 'elpd_waic']\" in str(err.value)","def plotComparison2(x, nt, nx, c, phi, phiExact, methodName): \n plt.plot(x, phiExact)\n\n plt.plot(x, phi, label=methodName)\n plt.ylim([-0.2, 1.4])","def plot(self):\n h = .02\n i=1\n bags_X = self.bags_X\n bags_y = self.bags_y\n fig1 = plt.figure(figsize=(45, 9))\n\n \n cm = plt.cm.RdBu\n cm_bright = ListedColormap(['#FF0000', '#0000FF'])\n \n for model in self.models:\n ax = plt.subplot(1, len(self.models) , i)\n X = pd.DataFrame(bags_X[i-1])\n y = pd.Series(bags_y[i-1])\n x_min, x_max = X[X.columns[0]].min() - .5, X[X.columns[0]].max() + .5\n y_min, y_max = X[X.columns[1]].min() - .5, X[X.columns[1]].max() + .5\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n Z = np.array(model.predict(pd.DataFrame(np.c_[xx.ravel(), yy.ravel()], columns=X.columns)))\n # print(Z[12])\n Z = Z.reshape(xx.shape)\n ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)\n ax.scatter(X[X.columns[0]], X[X.columns[1]], c=y, cmap=cm_bright, edgecolors='k')\n # size=[1000*w for w in self.weights[i-1]]\n ax.set_xlim(xx.min(), xx.max())\n ax.set_ylim(yy.min(), yy.max())\n ax.set_xlabel(str(X.columns[0]))\n ax.set_ylabel(str(X.columns[1]))\n plt.title(\"Estimator \"+str(i))\n i+=1\n \n fig2 = plt.figure(figsize=(9,9))\n X = self.X\n y = self.y\n ax2 = plt.subplot(1,1,1)\n x_min, x_max = X[X.columns[0]].min() - .5, X[X.columns[0]].max() + .5\n y_min, y_max = X[X.columns[1]].min() - .5, X[X.columns[1]].max() + .5\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n Z = np.array(self.predict(pd.DataFrame(np.c_[xx.ravel(), yy.ravel()], columns=X.columns)))\n Z = Z.reshape(xx.shape)\n ax2.contourf(xx, yy, Z, cmap=cm, alpha=.8)\n # size=[1000*w for w in self.weights[i-2]]\n ax2.scatter(X[X.columns[0]], X[X.columns[1]], c=y, cmap=cm_bright, edgecolors='k')\n ax2.set_xlim(xx.min(), xx.max())\n ax2.set_ylim(yy.min(), yy.max())\n plt.title(\"Combined Decision Surface\")\n \n plt.tight_layout()\n plt.show()\n\n return [fig1,fig2]","def plot_volcano(self, labels=None):\n cond1, cond2 = \"cond1\", \"cond2\"\n if labels is None:\n labels = [cond1, cond2]\n\n A = self.r1.df.loc[self.r1.gene_lists[\"all\"]]\n B = self.r2.df.loc[self.r2.gene_lists[\"all\"]]\n\n if cond1 == cond2:\n cond1 += \"(1)\"\n cond2 += \"(2)\"\n\n pylab.clf()\n pylab.plot(\n A.log2FoldChange,\n -np.log10(A.padj),\n marker=\"o\",\n alpha=0.5,\n color=\"r\",\n lw=0,\n label=labels[0],\n pickradius=4,\n picker=True,\n )\n pylab.plot(\n B.log2FoldChange,\n -np.log10(B.padj),\n marker=\"x\",\n alpha=0.5,\n color=\"k\",\n lw=0,\n label=labels[1],\n pickradius=4,\n picker=True,\n )\n\n genes = list(A.index) + list(B.index)\n pylab.grid(True)\n pylab.xlabel(\"fold change\")\n pylab.ylabel(\"log10 adjusted p-value\")\n pylab.legend(loc=\"lower right\")\n ax = pylab.gca()\n\n def onpick(event):\n thisline = event.artist\n self.event = event\n label = thisline.get_label()\n if label == cond1:\n gene_name = A.index[event.ind[0]]\n x1 = round(A.loc[gene_name].log2FoldChange, 1)\n y1 = round(-np.log10(A.loc[gene_name].padj), 1)\n try:\n x2 = round(B.loc[gene_name].log2FoldChange, 1)\n y2 = round(-np.log10(B.loc[gene_name].padj), 1)\n except:\n x2, y2 = None, None\n else:\n gene_name = B.index[event.ind[0]]\n x1 = round(B.loc[gene_name].log2FoldChange, 1)\n y1 = round(-np.log10(B.loc[gene_name].padj), 1)\n try:\n x2 = round(A.loc[gene_name].log2FoldChange, 1)\n y2 = round(-np.log10(A.loc[gene_name].padj), 1)\n except:\n x2, y2 = None, None\n\n try:\n if x2 is None:\n ax.title.set_text(\"{} at pos [{},{}]\".format(gene_name, x1, y1))\n else:\n ax.title.set_text(\"{} at pos [{},{}] and [{},{}]\".format(gene_name, x1, y1, x2, y2))\n except:\n print(\"exception\")\n ax.title.set_text(\"\")\n pylab.draw()\n\n fig = pylab.gcf()\n fig.canvas.mpl_connect(\"pick_event\", onpick)","def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\n\n\t#path_tsne = path_results + \"/Visualization/train/\" + str(args.step) + \"_2d.csv\"\n\t#data_frame = pd.read_csv(path_tsne)\n\t\n\tpath_maping = path_results + \"/Maping/\" + str(args.subject).split(\".txt\")[0] + \"/\"\n\tfilename = path_maping + \"maping_\" + str(args.step) + \"_\" + str(args.subject).split(\".txt\")[0] + \"_stick\" + str(args.stick) + \".png\"\n\n\tprint(\"path_save maping\", path_maping)\n\n\tif not os.path.exists(path_maping):\n\t\tos.makedirs(path_maping)\n\n\t#print(\"path_tsne\", path_tsne)\n\n\tlabel_maping = np.array([10])\n\n\tx_data = np.concatenate((x_data,signal_test),axis=0)\n\ty_data = np.concatenate((y_data,label_maping),axis=0)\n\n\tprint(\"x_data concatenate\",x_data.shape)\n\tprint(\"y_data concatenate\",y_data.shape)\n\n\tdata_frame = tsne_2d(x_data, y_data)\n\n\t\n\t\n\tgroups = data_frame.groupby('label')\n\n\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\n\n\tfig = plt.figure(figsize=(20, 10))\n\tax = fig.add_subplot(111)\n\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\n\tfor name, group in groups:\n\t\t\n\t\tif cluster_names[name] == str(args.subject):\n\t\t\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\n\t\telse:\n\t\t\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\n\n\tax.legend(numpoints=1) #show legend with only 1 point\n\tplt.savefig(filename) #save the plot","def plotComparison(x, nt, nx, c, phi, phiExact, methodName):\n \n plt.figure()\n plt.plot(x, phiExact)\n\n plt.plot(x, phi)\n plt.ylim([-0.2, 1.4])\n plt.title(str(methodName)+\" scheme\\nExact vs Numerical solution \"\\\n \"nt=\"+str(nt)+\", nx=\"+str(nx)+\"\\n\"\n \"Courant number: \"+str(c))\n plt.show()","def plot_decision_boundary(model, X, y):\r\n \r\n x1_array, x2_array = np.meshgrid(np.arange(-4, 4, 0.01), np.arange(-4, 4, 0.01))\r\n grid_coordinates = np.c_[x1_array.ravel(), x2_array.ravel()]\r\n Z = model.predict(grid_coordinates)\r\n Z = Z.reshape(x1_array.shape)\r\n plt.contourf(x1_array, x2_array, Z, cmap=plt.cm.bwr)\r\n plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.bwr)\r\n plt.show()","def plot_ppplot(obj1,sheet1,variable1,obj2,sheet2,variable2,title,opath):\n p1 = np.percentile(obj1.me[sheet1][variable1],range(0,101,1))\n p2 = np.percentile(obj2.me[sheet2][variable2],range(0,101,1))\n p1c = np.cumsum(np.array(p1))/np.cumsum(np.array(p1)).max()\n p2c = np.cumsum(np.array(p2))/np.cumsum(np.array(p2)).max()\n fig = plt.figure(figsize=(8,8),dpi=120)\n plt.scatter(p1c,p2c,color='#566c73',s=30)\n plt.plot([0,1],[0,1],color='red',alpha=0.3)\n plt.xlim(0,1)\n plt.ylim(0,1)\n plt.grid()\n plt.xlabel(sheet1+'_'+variable1)\n plt.ylabel(sheet2+'_'+variable2)\n plt.title(title)\n plt.savefig(opath+'.png')\n plt.close()","def main():\n\n if not os.path.exists( os.path.join(os.getcwd(), 'Plots') ):\n os.mkdir('Plots')\n\n # Initialise the canvas and set aesthetics\n canv = TCanvas(\"canv\", \"canv\", 800, 600)\n canv.SetLogy()\n gStyle.SetOptStat(0)\n gStyle.SetOptTitle(0)\n\n # Initialise legend and set colours\n leg_height = len(models) * 0.06 # make y-length of legend dependent on n_models\n myLeg = TLegend(0.6, 0.9 - leg_height, 0.9, 0.9)\n myLeg.SetTextSize(0.02)\n\n # Initialise histogram arrays\n nJetHist = [None] * len(models)\n jetPtHist = [None] * len(models)\n leadJetPtHist = [None] * len(models)\n metPtHist = [None] * len(models)\n dPhiJJHist = [None] * len(models)\n\n # x-axis labels for plots\n nJetLabel = \"#it{n}_{jet}\"\n jetPtLabel = \"#it{p}_{T}^{jet}\"\n leadJetPtLabel = \"#it{p}_{T}^{j_{1}}\"\n metPtLabel = \"#it{E}_{T}^{miss}\"\n dPhiJJLabel = \"#Delta#it{#phi}_{j_{1} j_{2}}\"\n\n # Initialise histograms here so I can use them later\n for i, model in enumerate(models):\n nJetHist[i] = TH1F(\"nJet\"+model, \"nJet dist \"+model, 30, 0, 29)\n jetPtHist[i] = TH1F(\"jetPt\"+model, \"Jet pT dist \"+model, 30, 0, 3000)\n leadJetPtHist[i] = TH1F(\"leadJetPt\"+model, \"Lead jet pT dist \"+model, 30, 0, 3000)\n metPtHist[i] = TH1F(\"met\"+model, \"MET dist \"+model, 30, 0, 3000)\n dPhiJJHist[i] = TH1F(\"dPhijj\"+model, \"DPhi dist \"+model, 20, -1*(pi+0.1), pi+0.1)\n \n\n # Open root files, then draw individual histograms\n for i, model in enumerate(models):\n print Fore.MAGENTA + \"Running over model {0}/{1}.\".format(i+1, len(models))\n openFile = TFile(files[i])\n tree = openFile.Get(\"Events\")\n nEntries = tree.GetEntries()\n\n # Initialise progress bar\n widgets = [Percentage(), Bar('>'), ETA()]\n pbar = ProgressBar(widgets = widgets, maxval = nEntries).start() \n\n for entry in xrange(nEntries):\n treeEntry = tree.GetEntry(entry)\n nJetHist[i].Fill(tree.nJet)\n \n for jet in xrange( len(tree.Jet_pt) ):\n jetPtHist[i].Fill(tree.Jet_pt[jet])\n\n if len(tree.Jet_pt) > 0: leadJetPtHist[i].Fill(tree.Jet_pt[0])\n metPtHist[i].Fill(tree.MET_pt)\n\n if len(tree.Jet_phi) >= 2:\n deltaPhi = tree.Jet_phi[0] - tree.Jet_phi[1]\n dPhiJJHist[i].Fill(deltaPhi) \n\n pbar.update(entry+1)\n \n pbar.finish()\n\n # Normalise histograms\n nJetHist[i].Scale(1./nEntries)\n jetPtHist[i].Scale(1./nEntries)\n leadJetPtHist[i].Scale(1./nEntries)\n metPtHist[i].Scale(1./nEntries)\n dPhiJJHist[i].Scale(1./nEntries)\n\n # Draw individual histograms and save\n drawIndivHistos(model, nJetHist[i], canv, myLeg, nJetLabel, \"nJet\", index=i)\n drawIndivHistos(model, jetPtHist[i], canv, myLeg, jetPtLabel, \"jetPT\", index=i)\n drawIndivHistos(model, leadJetPtHist[i], canv, myLeg, leadJetPtLabel, \"leadJetPT\", index=i)\n drawIndivHistos(model, metPtHist[i], canv, myLeg, metPtLabel, \"MET\", index=i)\n drawIndivHistos(model, dPhiJJHist[i], canv, myLeg, dPhiJJLabel, \"dPhi\", index=i)\n \n\n # Draw histograms for different models overlaid\n drawMultipleHistos(nJetHist, canv, myLeg, nJetLabel, \"nJet\")\n drawMultipleHistos(jetPtHist, canv, myLeg, jetPtLabel, \"jetPT\")\n drawMultipleHistos(leadJetPtHist, canv, myLeg, leadJetPtLabel, \"leadJetPT\")\n drawMultipleHistos(metPtHist, canv, myLeg, metPtLabel, \"MET\")\n drawMultipleHistos(dPhiJJHist, canv, myLeg, dPhiJJLabel, \"dPhi\")","def plotting_data1(fitspath, dataset, combine_flux_file, bin_info_file):\n\n pdf_file = join(fitspath, 'line_ratio_plots.pdf')\n pp = PdfPages(pdf_file)\n\n print(\"### combine_flux_file : \" + combine_flux_file)\n fitted_data = asc.read(combine_flux_file)\n\n print(\"### bin_info_file : \" + bin_info_file)\n bin_info_tab = asc.read(bin_info_file)\n OII = fitted_data['OII_3727_Flux_Observed']\n OIII5007 = fitted_data['OIII_5007_Flux_Observed']\n H_BETA = fitted_data['HBETA_Flux_Observed']\n binnum = fitted_data['N_stack']\n ID = fitted_data['bin_ID']\n print('binnum:', binnum, len(binnum))\n\n R23_composite = np.zeros(binnum.shape[0])\n O32_composite = np.zeros(binnum.shape[0]) \n for ii in range(len(binnum)):\n R23_comp = np.log10((OII[ii] + (1.33 * OIII5007[ii]))/H_BETA[ii])\n O32_comp = np.log10((1.33 * OIII5007[ii])/OII[ii])\n print(R23_comp, O32_comp)\n R23_composite[ii] = R23_comp\n O32_composite[ii] = O32_comp\n \n R23_raw = bin_info_tab['logR23_avg']\n O32_raw = bin_info_tab['logO32_avg']\n binnum_raw = bin_info_tab['N_stack']\n\n if dataset != 'Grid':\n for rr in range(len(binnum)):\n if binnum[rr] == binnum_raw[rr]:\n print('equal', binnum[rr], binnum_raw[rr])\n\n fig, ax_arr = plt.subplots()\n ax_arr.scatter(R23_raw, R23_composite, marker='o', facecolor='none',\n edgecolor='b', label='R23 Ratio: Voronoi Raw vs. Composite')\n ax_arr.legend(loc=0)\n ax_arr.set_title(dataset + ' Raw vs. Composite for R23')\n for rr in range(len(ID)):\n ax_arr.annotate(ID[rr], (R23_raw[rr], R23_composite[rr]))\n ax_arr.set_xlabel(r'Raw log($R_{23}$)')\n ax_arr.set_ylabel(r'Composite log($R_{23}$)')\n ax_arr.plot([0.0, 1.3], [0.0, 1.3], 'k-')\n \n fig.savefig(pp, format='pdf')\n\n fig, ax_arr = plt.subplots()\n ax_arr.scatter(O32_raw, O32_composite, marker='o', facecolor='none',\n edgecolor='b', label='O32 Ratio: Voronoi Raw vs. Composite')\n ax_arr.legend(loc=0)\n ax_arr.set_title(dataset + 'Raw vs. Composite for O32')\n for oo in range(len(ID)):\n ax_arr.annotate(ID[oo], (O32_raw[oo], O32_composite[oo]))\n ax_arr.set_xlabel(r'Raw log($O_{32}$)')\n ax_arr.set_ylabel(r'Composite log($O_{32}$)')\n\n ax_arr.plot([-1, 1.2], [-1, 1.2], 'k-')\n fig.savefig(pp, format='pdf')\n\n pp.close()\n\n fig.clear()","def plot_coefs(results):\n coefs_noisy = pd.concat([\n arr_to_df(results['obj_noisy'], n_arr, 'obj'),\n vec_to_df(results['dist_obj'], n_arr, 'obj'),\n arr_to_df(results['pos_noisy'], n_arr, 'pos'),\n vec_to_df(results['dist_pos'], n_arr, 'pos'),\n arr_to_df(results['neg_noisy'], n_arr, 'neg'),\n vec_to_df(results['dist_neg'], n_arr, 'neg')\n ])\n\n xlim = (min(n_arr), max(n_arr))\n ylim = (-1.1, 1.1)\n\n g = sns.FacetGrid(coefs_noisy, row = 'id', col = 'component', xlim = xlim,\n ylim = ylim)\n g.map(sns.pointplot, 'n', 'value', order = n_arr)\n g.set_xticklabels(rotation = 45)\n\n for i, val in enumerate(results['obj_true']):\n ax = g.axes[0, i]\n ax.hlines(val, *ax.get_xlim())\n for i, val in enumerate(results['pos_true']):\n ax = g.axes[1, i]\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\n ax.hlines(val, *ax.get_xlim())\n for i, val in enumerate(results['neg_true']):\n ax = g.axes[2, i]\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\n ax.hlines(val, *ax.get_xlim())","def _plot_comparison(xs, pan, other_program_name, **kw):\n\n pans = ['Bmax', 'Emax']\n units = ['(mG)', '(kV/m)']\n title_app = [', Max Magnetic Field', ', Max Electric Field']\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\n '-%s-comparison-Emax' % other_program_name]\n\n for p,u,t,s in zip(pans, units, title_app, save_suf):\n #figure object and axes\n fig = plt.figure()\n ax_abs = fig.add_subplot(2,1,1)\n ax_per = ax_abs.twinx()\n ax_mag = fig.add_subplot(2,1,2)\n #Bmax\n #init handles and labels lists for legend\n kw['H'], kw['L'] = [], []\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\n other_program_name, **kw)\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\n _check_und_conds([xs], [ax_mag], **kw)\n ax_abs.set_title('Absolute and Percent Difference' + t)\n ax_mag.set_ylabel(p + ' ' + u)\n ax_mag.set_title('Model Results' + t)\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\n #_format_twin_axes(ax_abs, ax_per)\n _save_fig(xs.sheet + s, fig, **kw)","def plot_results(model):\n\n # Is is a system of equation\n is_system = max(model.n_input, model.n_output) > 1\n\n # Choose the plotting function depending on the type of training data\n if model.dimension == 1 and not (is_system):\n plot_1d_results(model)\n\n elif model.dimension == 1 and is_system:\n plot_1d_systems(model)\n\n elif model.dimension > 1 and not (is_system):\n plot_2d_results(model)\n\n else:\n # Plot and save slices of the Green's matrix\n for i in range(1, 5):\n plot_2d_systems(model, Green_slice=i)","def comp(a,b,av=None,bv=None,domatch=True,out=None) :\n if domatch :\n i1,i2=match.match(a['APOGEE_ID'],b['APOGEE_ID'])\n gd = np.where(a['NVISITS'][i1] == b['NVISITS'][i2])[0]\n a=a[i1[gd]]\n b=b[i2[gd]]\n\n fig = vscat(a)\n vscat(b,fig=fig,ls=':')\n if out is not None : \n fig[0].savefig(out+'_1.png')\n plt.close()\n\n if domatch :\n fig,ax=plots.multi(1,2)\n #plots.plotp(ax[0,0],a['SNR'],a['VHELIO_AVG']-b['VHELIO_AVG'],yr=[-3,3],yt=r'$\\Delta$ VHELIO_AVG')\n #plots.plotp(ax[0,1],a['SNR'],a['VHELIO_AVG']-b['VHELIO_AVG'],yr=[-50,50],yt=r'$\\Delta$ VHELIO_AVG')\n #plots.plotp(ax[1,0],a['SNR'],a['VSCATTER']-b['VSCATTER'],yr=[-0.5,0.5],yt=r'$\\Delta$ VSCATTER')\n #plots.plotp(ax[1,1],a['SNR'],a['VSCATTER']-b['VSCATTER'],yr=[-5,5],yt=r'$\\Delta$ VSCATTER')\n ax[0].hist(a['VHELIO_AVG']-b['VHELIO_AVG'],bins=np.arange(-0.5,0.5,0.02),histtype='step')\n ax[0].set_xlabel(r'$\\Delta$ VHELIO_AVG')\n ax[1].hist(a['VSCATTER']-b['VSCATTER'],bins=np.arange(-0.5,0.5,0.02),histtype='step')\n ax[1].set_xlabel(r'$\\Delta$ VSCATTER')\n if out is not None : \n fig.savefig(out+'_2.png')\n plt.close()\n\n return a,b","def _plot_model_pred_vs_obs(self, ax):\n\n res = self._model.fit()\n\n ax.plot(self._model.endog, res.fittedvalues, '.', label='Observation')\n\n x_lim = ax.get_xlim()\n\n ax.plot(x_lim, x_lim, 'k:', label='1:1 line')\n\n x_label = 'Observed ' + self._model.endog_names\n y_label = 'Predicted ' + self._model.endog_names\n\n ax.set_xlabel(x_label)\n ax.set_ylabel(y_label)\n\n ax.legend(loc='best', numpoints=1)","def compare_CII_w_models(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n if not p.xlim: p.xlim = [-4,2]\n if not p.ylim: p.ylim = [4,10]\n\n fig,ax = plt.subplots(figsize=(8,6))\n ax.set_ylim(p.ylim)\n ax.set_xlim(p.xlim)\n\n # SIGAME Simba-100 ext ON (default run)\n GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[1])\n L_line = getattr(GR,'L_[CII]158_sun')\n SFR = getattr(GR,'SFR')\n # Phantom points to close contour lines...\n L_line = np.append(L_line,np.array([1e8,10**9.3]))\n SFR = np.append(SFR,np.array([0.1,10**0.85]))\n lL_line = np.log10(L_line)\n lSFR = np.log10(SFR)\n lSFR = lSFR[L_line > 0]\n lL_line = lL_line[L_line > 0]\n # ax.plot(np.log10(SFR),np.log10(L_line),'o',ms=4,color='midnightblue',\\\n # alpha=0.7,label='SIGAME with Simba-100',zorder=10)\n # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents\n nbins = 100\n k = kde.gaussian_kde(np.column_stack([lSFR,lL_line]).T)\n x, y = np.mgrid[lSFR.min():lSFR.max():nbins*1j,4:lL_line.max():nbins*1j]\n z = k(np.vstack([x.flatten(), y.flatten()]))\n CS = ax.contour(x, y, z.reshape(x.shape),colors='forestgreen',levels=6,zorder=10)\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF')\n\n # Select only MS galaxies\n L_line = getattr(GR,'L_[CII]158_sun')\n indices = aux.select_salim18(GR.M_star[L_line > 0],GR.SFR[L_line > 0])\n print('With MS selection criteria: only %i galaxies' % (len(L_line)))\n lSFR = lSFR[indices]\n lL_line = lL_line[indices]\n lSFR = np.append(lSFR,np.array([-1,0.85,1.5]))\n lL_line = np.append(lL_line,np.array([8,9.3,8.4]))\n nbins = 100\n k = kde.gaussian_kde(np.column_stack([lSFR,lL_line]).T)\n x, y = np.mgrid[lSFR.min():lSFR.max():nbins*1j,4:lL_line.max():nbins*1j]\n z = k(np.vstack([x.flatten(), y.flatten()]))\n CS = ax.contour(x, y, z.reshape(x.shape),colors='purple',linestyles='dashed',levels=6,zorder=10)\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF (MS)')\n\n\n # SIGAME Simba-100 ext OFF\n # GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[0])\n # L_line = getattr(GR,'L_[CII]158_sun')\n # SFR = getattr(GR,'SFR')\n # # Phantom points to close contour lines...\n # L_line = np.append(L_line,np.array([10.**9.2,1e8]))\n # SFR = np.append(SFR,np.array([0.9,0.1]))\n # lL_line = np.log10(L_line)\n # lSFR = np.log10(SFR)\n # lSFR = lSFR[L_line > 0]\n # lL_line = lL_line[L_line > 0]\n # # ax.plot(np.log10(SFR),np.log10(L_line),'o',ms=4,color='midnightblue',\\\n # # alpha=0.7,label='SIGAME with Simba-100',zorder=10)\n # # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents\n # nbins = 100\n # k = kde.gaussian_kde(np.column_stack([lSFR,\\\n # lL_line]).T)\n\n # x, y = np.mgrid[lSFR.min():lSFR.max():nbins*1j, \\\n # 4:lL_line.max():nbins*1j]\n # z = k(np.vstack([x.flatten(), y.flatten()]))\n # CS = ax.contour(x, y, z.reshape(x.shape),colors='brown',levels=6,linestyles='dotted')\n # CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF_no_ext')\n\n # SIGAME Simba-25\n # GR = glo.global_results(sim_run=p.sim_runs[0],nGal=p.nGals[0])\n # L_line = getattr(GR,'L_[CII]158_sun')\n # SFR = getattr(GR,'SFR')\n # ax.plot(np.log10(SFR),np.log10(L_line),'^',ms=6,color='darkorchid',alpha=0.7,label='SIGAME with Simba-25')\n\n # Observations in background\n add_line_SFR_obs('[CII]158',L_line,ax,plot_fit=False)\n\n # Popping 2019\n G19 = pd.read_csv(p.d_data + 'models/Popping2019.csv',skiprows=1,sep=' ',\\\n names=['logSFR', 'logLCII', 'log LCII 14th percentile', 'log LCII 86th percentile'])\n ax.plot(G19.logSFR,G19.logLCII,'k-',label='Popping 2019',alpha=0.8)\n ax.fill_between(G19.logSFR,G19['log LCII 14th percentile'].values,\\\n G19['log LCII 86th percentile'].values,color='grey',alpha=0.4)\n\n\n # Padilla 2020\n P20 = pd.read_csv(p.d_data + 'models/DataFig6.csv',skiprows=1,sep=',',\\\n names=['IDSim','GalID','SFR','LCIITotal'])\n P20['logLCII'] = np.log10(P20['LCIITotal'])\n P20['logSFR'] = np.log10(P20['SFR'])\n\n\n colors = ['cyan','orange','midnightblue']\n nbins = 100\n IDSims = ['Ref25','Recal25','Ref100']\n for i,IDSim in enumerate(IDSims):\n # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents\n k = kde.gaussian_kde(np.column_stack([P20.logSFR.values[P20.IDSim == IDSim],\\\n P20.logLCII.values[P20.IDSim == IDSim]]).T)\n\n xP20, yP20 = np.mgrid[P20.logSFR.min():P20.logSFR.max():nbins*1j, \\\n 4:P20.logLCII.max():nbins*1j]\n zP20 = k(np.vstack([xP20.flatten(), yP20.flatten()]))\n # To remove weird contour line:\n zP20.reshape(xP20.shape)[(xP20 > -1) & (yP20 < 5.5)] = 1e-5\n zP20.reshape(xP20.shape)[(xP20 < -3)] = 1e-5\n zP20.reshape(xP20.shape)[(xP20 < -2) & (yP20 > 8)] = 1e-5\n zP20.reshape(xP20.shape)[(xP20 > 1) & (yP20 < 7)] = 1e-5\n CS = ax.contour(xP20, yP20, zP20.reshape(xP20.shape),colors=colors[i],levels=5)\n CS.collections[0].set_label('Ramos Padilla 2020 '+IDSim)\n\n\n ax.set_xlabel('log '+getlabel('SFR'))\n ax.set_ylabel('log '+getlabel('[CII]158'))\n handles,labels = ax.get_legend_handles_labels()\n handles = [handles[_] for _ in [8,9,10,11,12,7,0,1,2,3,4,5,6]]\n labels = [labels[_] for _ in [8,9,10,11,12,7,0,1,2,3,4,5,6]]\n plt.legend(handles,labels,fontsize=9,loc='upper left')\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/CII_SFR_w_models.png', format='png', dpi=300)","def compare_plots(data_list, title_list, perp_list = [5, 30, 100], step_list = [10, 50, 1000], \\\n perp_plot = True, step_plot_perp = 30, verbose = False, plot_3d = False, \\\n cdict = {1: 'red', 2: 'mediumspringgreen', 3: 'royalblue'}, df = 1):\n \n # Determine dimensions of plot grid\n nrows = len(perp_list) + 1\n ncols = len(data_list)\n \n # Configure axes\n axes = []\n fig = plt.figure(figsize = (16, 3 * nrows))\n \n # Generate plots of starting points (first two columns for high-dimensional)\n for index, dat in enumerate(data_list):\n X, labs = dat\n \n # Check whether original data should be plotted in 3D, and adjust axes accordingly\n if plot_3d:\n axes.append(fig.add_subplot(nrows, ncols, 1 + index, projection = '3d'))\n axes[-1].scatter(xs = X[:, 0], ys = X[:, 1], zs = X[:, 2], edgecolor = None, alpha = 0.8, \\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_axis_off()\n else:\n axes.append(fig.add_subplot(nrows, ncols, 1 + index))\n plt.scatter(x = X[:, 0], y = X[:, 1], edgecolor = None, alpha = 0.8, \\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')\n axes[-1].set_title(\"\\n\".join(wrap(title_list[index], 35))) \n \n # Based on function input, generate either perplexity plots of interim iteration plots\n if perp_plot:\n # Generate plots of t-SNE output for different perplexities\n for perp in range(len(perp_list)):\n low_d = tsne(X = X, perplexity = perp_list[perp], verbose = verbose, optim = \"fastest\", df = df)\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (perp + 1) * ncols))\n axes[-1].set_title(\"Perplexity = \" + str(perp_list[perp]))\n plt.scatter(x = low_d[-1, :, 0], y = low_d[-1, :, 1], edgecolor = None, alpha = 0.8, \\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')\n else:\n # Generate plots of t-SNE output for different iterations\n low_d = tsne(X = X, perplexity = step_plot_perp, niter = np.max(step_list), verbose = verbose, optim = \"fastest\", \\\n df = df)\n for step in range(len(step_list)):\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (step + 1) * ncols))\n axes[-1].set_title(\"Perplexity = \" + str(step_plot_perp) + \", Step = \" + str(step_list[step]))\n plt.scatter(x = low_d[step_list[step], :, 0], y = low_d[step_list[step], :, 1], \\\n edgecolor = None, alpha = 0.8,\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')","def plot_comparison(step_test_data, model, inputs, outputs, start_time, end_time, plt_input=False, scale_plt=False):\n \n val_data = step_test_data.loc[start_time:end_time]\n val_data.columns = [col[0] for col in val_data.columns]\n \n Time = val_data.index\n u = val_data[inputs].to_numpy().T\n y = val_data[outputs].to_numpy().T\n\n\n # Use the model to predict the output-signals.\n mdl = np.load(model)\n \n # The output of the model\n xid, yid = fsetSIM.SS_lsim_innovation_form(A=mdl['A'], B=mdl['B'], C=mdl['C'], D=mdl['D'], K=mdl['K'], y=y, u=u, x0=mdl['X0'])\n \n # Make the plotting-canvas bigger.\n plt.rcParams['figure.figsize'] = [25, 5]\n # For each output-signal.\n for idx in range(0,len(outputs)):\n plt.figure(idx)\n plt.xticks(rotation=15)\n plt.plot(Time, y[idx],color='r')\n plt.plot(Time, yid[idx],color='b')\n plt.ylabel(outputs[idx])\n plt.grid()\n plt.xlabel(\"Time\")\n plt.title('output_'+ str(idx+1))\n plt.legend(['measurment', 'prediction'])\n ax=plt.gca()\n xfmt = md.DateFormatter('%m-%d-%yy %H:%M')\n ax.xaxis.set_major_formatter(xfmt) \n if scale_plt==True:\n plt.ylim(np.amin(y[idx])*.99, np.amax(y[idx])*1.01)\n \n if plt_input == True:\n for idx in range(len(outputs), len(outputs) + len(inputs)):\n plt.figure(idx)\n plt.xticks(rotation=15)\n plt.plot(Time, u[idx-len(outputs)], color='r')\n plt.ylabel(inputs[idx-len(outputs)])\n plt.grid()\n plt.xlabel(\"Time\")\n plt.title('input_'+ str(idx-len(outputs)+1))\n ax=plt.gca()\n xfmt = md.DateFormatter('%m-%d-%yy %H:%M')\n ax.xaxis.set_major_formatter(xfmt) \n plt.show()","def plotCompData(xdat, ydat, proteins, title=None, xlabel='dat1', ylabel='dat2', xMax=1.5, yMax=1.5, figSize=(10,10), saveFile=None):\r\n x = [numpy.median(xdat[i]) for i in proteins]\r\n y = [numpy.median(ydat[i]) for i in proteins] \r\n scat = pylab.figure(figsize=figSize)\r\n scatAx = scat.add_subplot(111) \r\n scatAx.scatter(x,y, c='b', s=150)\r\n scatAx.set_title(title)\r\n scatAx.set_xlabel(xlabel)\r\n scatAx.set_ylabel(ylabel)\r\n scatAx.set_xlim([-0.1,xMax])\r\n scatAx.set_ylim([-0.1,yMax])\r\n scatAx.set_xticks([0,xMax/5,xMax/5*2,xMax/5*3,xMax/5*4,xMax])\r\n scatAx.set_yticks([0,yMax/5,yMax/5*2,yMax/5*3,yMax/5*4,yMax])\r\n scatAx.yaxis.tick_left()\r\n scatAx.xaxis.tick_bottom()\r\n for prot, xl, yl in zip(proteins, x, y):\r\n scatAx.annotate(str(prot[4:]), xy = (float(xl), float(yl)), xytext = (15,15), textcoords = 'offset points', arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0'))\r\n pylab.tight_layout()\r\n scatAx.plot(numpy.linspace(0, 10), numpy.linspace(0,10))\r\n return scatAx","def plot_comparison(data, data1, data2, algorithm):\n # Loads the different datasets\n runs = data[data.columns[0]]\n distance = data[data.columns[1]]\n\n runs1 = data1[data1.columns[0]]\n distance1 = data1[data1.columns[1]]\n\n runs2 = data2[data2.columns[0]]\n distance2 = data2[data2.columns[1]]\n\n # Forms the histogram\n plt.plot(runs, distance, label=\"Wijk 1\")\n plt.plot(runs1, distance1, color = 'orange', label=\"Wijk 2\")\n plt.plot(runs2, distance2, color = 'red', label=\"Wijk 3\")\n plt.legend(loc='upper right')\n\n # Plots the legend\n plt.legend(loc='upper right')\n\n # Adds the title and axis names\n plt.title(f\"{algorithm} Algorithm\", fontweight='bold')\n plt.xlabel('Iterations')\n plt.ylabel('Total Distance')\n\n # Actually shows the histogram\n plt.show()","def scatter(original, updated, main=\"\", save=None): \n #Remove hits with no improvement and calcate the number of hits with no\n #improvement(udated == original), positive imporvent (updated > original), \n #and negative improvment (updated < original)\n print len(original)\n positiveImprovement = []\n negativeImprovement = []\n noImprovement = 0\n for o, u in izip(original, updated):\n if int(o) == int(u):\n noImprovement +=1\n elif u > o:\n positiveImprovement.append((o,u))\n elif u < o:\n negativeImprovement.append((o,u))\n else:\n noImprovement +=1\n\n if not positiveImprovement:\n positiveImprovement = [()]\n if not negativeImprovement:\n negativeImprovement = [()]\n\n print positiveImprovement\n print negativeImprovement\n print noImprovement\n\n #Set deimensions\n x, y = zip(*positiveImprovement+negativeImprovement)\n xMax = int(round(sorted(x)[-1]/500.0)*500.0)\n yMax = int(round(sorted(y)[-1]/500.0)*500.0)\n sep = 500\n xticks = range(0, xMax, sep)\n yticks = range(0,yMax,sep)\n color_cycle = brewer2mpl.get_map('Set2', 'qualitative', 8).mpl_colors\n\n fig, ax = plt.subplots()\n ax.set_title(main)\n ax.set_xlabel(\"Original Bitscores\")\n ax.set_ylabel(\"Updated Bitscores\")\n\n \n #Plot postive improvement (green, automatically by prettyplotlib)\n if positiveImprovement:\n ppl.scatter(ax, *zip(*positiveImprovement), \n label=\"Positive Improvement ({} seqs)\".format(len(positiveImprovement)),\n color=color_cycle[0])\n\n #Draw no improvement line\n ppl.plot(ax, (0,xMax), (0,xMax), color='k', linestyle='-', linewidth=2,\n label=\"No Improvement ({} seqs)\".format(noImprovement))\n\n #Plot negative improvement (red, automatically by prettyplotlib)\n if negativeImprovement:\n ppl.scatter(ax, *zip(*negativeImprovement),\n label=\"Negative Improvement ({} seqs)\".format(len(negativeImprovement)),\n color=color_cycle[1])\n\n #Draw labels\n ppl.legend(ax)\n\n #Set axis\n ax.set_ylim([0,yMax])\n ax.set_xlim([0,xMax])\n\n if save is None:\n plt.show()\n else:\n pp = PdfPages(save)\n pp.savefig(fig)\n pp.close()","def plot_bit_for_bit(case, var_name, model_data, bench_data, diff_data):\n plot_title = \"\"\n plot_name = case + \"_\" + var_name + \".png\"\n plot_path = os.path.join(os.path.join(livvkit.output_dir, \"verification\", \"imgs\"))\n functions.mkdir_p(plot_path)\n m_ndim = np.ndim(model_data)\n b_ndim = np.ndim(bench_data)\n if m_ndim != b_ndim:\n return \"Dataset dimensions didn't match!\"\n if m_ndim == 3:\n model_data = model_data[-1]\n bench_data = bench_data[-1]\n diff_data = diff_data[-1]\n plot_title = \"Showing \"+var_name+\"[-1,:,:]\"\n elif m_ndim == 4:\n model_data = model_data[-1][0]\n bench_data = bench_data[-1][0]\n diff_data = diff_data[-1][0]\n plot_title = \"Showing \"+var_name+\"[-1,0,:,:]\"\n plt.figure(figsize=(12, 3), dpi=80)\n plt.clf()\n\n # Calculate min and max to scale the colorbars\n _max = np.amax([np.amax(model_data), np.amax(bench_data)])\n _min = np.amin([np.amin(model_data), np.amin(bench_data)])\n\n # Plot the model output\n plt.subplot(1, 3, 1)\n plt.xlabel(\"Model Data\")\n plt.ylabel(var_name)\n plt.xticks([])\n plt.yticks([])\n plt.imshow(model_data, vmin=_min, vmax=_max, interpolation='nearest', cmap=colormaps.viridis)\n plt.colorbar()\n\n # Plot the benchmark data\n plt.subplot(1, 3, 2)\n plt.xlabel(\"Benchmark Data\")\n plt.xticks([])\n plt.yticks([])\n plt.imshow(bench_data, vmin=_min, vmax=_max, interpolation='nearest', cmap=colormaps.viridis)\n plt.colorbar()\n\n # Plot the difference\n plt.subplot(1, 3, 3)\n plt.xlabel(\"Difference\")\n plt.xticks([])\n plt.yticks([])\n plt.imshow(diff_data, interpolation='nearest', cmap=colormaps.viridis)\n plt.colorbar()\n\n plt.tight_layout(rect=(0, 0, 0.95, 0.9))\n plt.suptitle(plot_title)\n\n plot_file = os.path.sep.join([plot_path, plot_name])\n if livvkit.publish:\n plt.savefig(os.path.splitext(plot_file)[0]+'.eps', dpi=600)\n plt.savefig(plot_file)\n plt.close()\n return os.path.join(os.path.relpath(plot_path,\n os.path.join(livvkit.output_dir, \"verification\")),\n plot_name)","def plot_decision_boundary(data, x, y, labels, model, **kwargs):\n xx, yy, Z = setup_contours(data=data, x=x, y=y, model=model)\n\n x0, x1 = data[x].values, data[y].values\n x0lim = x0.min(), x0.max()\n x1lim = x1.min(), x1.max()\n\n col = data[labels].values\n plt.figure(figsize=(10, 10))\n\n plt.scatter(x0, x1, c=col, **kwargs)\n CS = plt.contourf(xx, yy, Z, **kwargs)\n CS2 = plt.contour(CS, CS.levels[::2], **kwargs)\n cbar = plt.colorbar(CS, **kwargs)\n cbar.ax.set_ylabel('Fitted Probability')\n # Add the contour line levels to the colorbar\n cbar.add_lines(CS2)\n\n plt.xlim(x0lim)\n plt.ylim(x1lim)\n plt.xlabel(x)\n plt.ylabel(y)\n plt.legend()","def plot_1d_systems(model):\n\n # Construct grid to evaluate the Green's function\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\n x_G_star = X_G.flatten()[:, None]\n y_G_star = Y_G.flatten()[:, None]\n\n # Create the figure\n n_plots = max(model.n_input + 1, model.n_output)\n scaling = n_plots / 2\n fig, ax = newfig(1.0 * scaling, 1.5)\n ax.axis('off')\n gs = gridspec.GridSpec(n_plots, n_plots)\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9,\n wspace=0.6 * scaling, hspace=0.6 * scaling)\n\n # Plot the Green's functions\n for i in range(model.n_output):\n for j in range(model.n_input):\n input_data = np.concatenate((x_G_star, y_G_star), 1)\n G_pred_identifier = model.sess.run(\n model.G_network[i][j].evaluate(input_data))\n G_pred = G_pred_identifier.reshape(X_G.shape)\n ax = plt.subplot(gs[i, j])\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\n extent=[np.min(model.x_G), np.max(model.x_G), np.min(\n model.y_G), np.max(model.y_G)],\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\n ax.set_title('$G_{%d,%d}$' % (i + 1, j + 1), fontsize=10)\n\n # Plot the homogeneous solutions\n for i in range(model.n_output):\n N_pred = model.sess.run(model.idn_N_pred[i].evaluate(model.x))\n ax = plt.subplot(gs[i, model.n_input])\n ax.plot(model.x, model.U_hom[:, i], label='Exact')\n ax.plot(model.x, N_pred, dashes=[2, 2], label='Learned')\n divider = make_axes_locatable(ax)\n ymin = min([np.min(N_pred), np.min(model.U_hom[:, i])])\n ymax = max([np.max(N_pred), np.max(model.U_hom[:, i])])\n ax.set_xlim(np.min(model.x), np.max(model.x))\n ax.set_ylim(ymin, ymax)\n if ymax - ymin < 1e-2:\n ax.yaxis.set_major_formatter(MathTextSciFormatter(\"%1.1e\"))\n ax.set_xlabel('$x$')\n ax.set_title('Hom$_{%d}$' % (i + 1), fontsize=10)\n ax.legend()\n\n # Save the figure\n savefig(\"%s/%s_%s\" % (model.path_result, model.example_name,\n model.activation_name), crop=False)","def plot_corr_normalized(models,data,fit,**kwargs):\n _fnNMod = len(models)\n _fnIdx = [0] ## -- index of plotted function, in array so it can be modified in functions\n ## -- objects to hold all plot data\n ## - Dat/Fit refers to the correlator data or the fit function\n ## - Central/Error are the central value and errors\n _fnDatCentral = []\n _fnDatError = []\n _fnFitOnes = []\n _fnFitError = []\n #\n ## -- other objects\n _fnTDataNonZero = []\n _fnTFitNonZero = []\n _fnTData = []\n _fnTFit = []\n _fnTRem = [] # number of previous timeslices removed\n fig,ax = plt.subplots(1)\n #\n ## -- setup plot function\n def do_plot_normalized(idx,fig=fig):\n fig.clear()\n ax = fig.add_subplot(111)\n key = models[idx[0]].datatag\n\n ax.set_xlim([-1,len(_fnTData[idx[0]])])\n ax.set_ylim(utp.get_option(\"y_limit\",[0.2,1.8],**kwargs[key]))\n #\n ## -- plot fit\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitOnes[idx[0]],\n color=utp.get_option(\"color2\",'b',**kwargs[key]))\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][0],\n color=utp.get_option(\"color2\",'g',**kwargs[key]),\n ls=utp.get_option(\"linestyle2\",'--',**kwargs[key]))\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][1],\n color=utp.get_option(\"color2\",'g',**kwargs[key]),\n ls=utp.get_option(\"linestyle2\",'--',**kwargs[key]))\n ## -- plot correlator data\n ax.errorbar(_fnTDataNonZero[idx[0]],_fnDatCentral[idx[0]],yerr=_fnDatError[idx[0]],\n mfc=utp.get_option(\"markerfacecolor1\",'None',**kwargs[key]),\n mec=utp.get_option(\"markeredgecolor1\",'k',**kwargs[key]),\n color=utp.get_option(\"markeredgecolor1\",'k',**kwargs[key]),\n ls=utp.get_option(\"linestyle1\",'None',**kwargs[key]),\n marker=utp.get_option(\"marker1\",'o',**kwargs[key]),\n ms=utp.get_option(\"markersize\",6,**kwargs[key]))\n ax.scatter(_fnTFitNonZero[idx[0]],\n [ _fnDatCentral[idx[0]][t] for t in\n list(np.array(_fnTFitNonZero[idx[0]])-np.array(_fnTRem[idx[0]])) ],\n color=utp.get_option(\"color1\",'r',**kwargs[key]),\n marker=utp.get_option(\"marker\",'o',**kwargs[key]),\n s=utp.get_option(\"markersize\",36,**kwargs[key]))\n fig.suptitle(utp.get_option(\"plottitlefn\",str(idx[0])+\" default title \"+str(key),**kwargs[key]),\n fontsize=utp.get_option(\"titlesize\",20,**kwargs[key]))\n ## -- modify some options \n ax.set_xlabel(r'$t$')\n ax.set_ylabel(utp.get_option(\"yaxistitle\",r\"$C(t)/C_{fit}(t)$\",**kwargs[key]))\n for item in ([ax.xaxis.label,ax.yaxis.label]):\n # must be after setting label content (LaTeX ruins it)\n item.set_fontsize(fontsize=utp.get_option(\"fontsize\",20,**kwargs[key]))\n rect =fig.patch\n rect.set_facecolor('white')\n if utp.get_option(\"to_file\",False,**kwargs[key]):\n save_dir = utp.get_option(\"fn_save_dir\",\"./plotdump\",**kwargs[key])\n save_name = utp.get_option(\"fn_save_name\",\"fnplot-\"+key+\".pdf\",**kwargs[key])\n plt.savefig(save_dir+'/'+save_name)\n if utp.get_option(\"to_terminal\",True,**kwargs[key]):\n plt.draw()\n pass\n #\n ## -- setup button press action function\n def press_normalized(event,idx=_fnIdx):\n #print('press_normalized', event.key)\n try:\n ## -- manually indicate index\n idx[0] = int(event.key) + (idx[0])*10\n except ValueError:\n if event.key==' ': ## -- space\n ## -- allows for replotting when changing index by typing number keys\n idx[0] = idx[0] % _fnNMod\n do_plot_normalized(idx)\n elif event.key=='left':\n idx[0] = (idx[0] - 1) % _fnNMod\n do_plot_normalized(idx)\n elif event.key=='right':\n idx[0] = (idx[0] + 1) % _fnNMod\n do_plot_normalized(idx)\n elif event.key=='backspace':\n ## -- reset index so can manually flip through using number keys\n idx[0] = 0\n elif event.key=='d':\n ## -- dump plots into ./plotdump directory\n for ix,model in zip(range(len(models)),models):\n key = model.datatag\n save_dir = utp.get_option(\"fn_save_dir\",\"./plotdump\",**kwargs[key])\n save_name = utp.get_option(\"fn_save_name\",\"fnplot-\"+key+\".png\",**kwargs[key])\n do_plot_normalized([ix])\n plt.savefig(save_dir+'/'+save_name)\n do_plot_normalized(idx)\n #\n ## -- \n fig.canvas.mpl_connect('key_press_event',press_normalized)\n ## -- save plot data\n for idx,model in zip(range(len(models)),models):\n key = model.datatag\n _fnTData.append(model.tdata)\n _fnTFit.append(model.tfit)\n _fnTFit[-1] = np.append(_fnTFit[-1],list(sorted([len(_fnTData[-1]) - t for t in _fnTFit[-1]])))\n ## -- fit\n _fnFitFunc = utp.create_fit_func(model,fit)\n _fnFitMean = gv.mean(_fnFitFunc(_fnTData[-1]))\n _fnTDataNonZero.append([t for t in _fnTData[-1] if np.abs(_fnFitMean[t]) > 1e-20])\n _fnTFitNonZero.append([t for t in _fnTFit[-1] if np.abs(_fnFitMean[t]) > 1e-20])\n _fnTRem.append([(0 if np.abs(_fnFitMean[t]) > 1e-20 else 1) for t in model.tdata])\n _fnTRem[-1] = \\\n [sum(_fnTRem[-1][:i+1]) for i in range(len(_fnTRem[-1])) if i in _fnTFitNonZero[-1]]\n _fnFitMean = gv.mean(_fnFitFunc(_fnTDataNonZero[-1]))\n _fnFitSdev = list(np.array(gv.sdev(_fnFitFunc(_fnTDataNonZero[-1])))/np.array(_fnFitMean))\n _fnFitOnes.append(list(np.ones(len(_fnTDataNonZero[-1]))))\n _fnFitError.append([ list(np.array(_fnFitOnes[-1])-np.array(_fnFitSdev)),\n list(np.array(_fnFitOnes[-1])+np.array(_fnFitSdev)) ])\n ## -- data\n _fnDatCentral.append( list(np.array([gv.mean(data[key])[t] for t in _fnTDataNonZero[-1]])/\n np.array(_fnFitMean)) )\n _fnDatSdev = ( np.array([gv.sdev(data[key])[t] for t in _fnTDataNonZero[-1]])/\n np.array(_fnFitMean) )\n _fnDatError.append([ list(_fnDatSdev), list(_fnDatSdev) ])\n ## -- done saving data\n \n if not(utp.get_option(\"to_terminal\",True,**kwargs[key])) and\\\n utp.get_option(\"to_file\",False,**kwargs[key]):\n for ix in range(len(models)):\n ## -- loops and saves all without creating window\n do_plot_normalized([ix])\n else:\n do_plot_normalized(_fnIdx)","def plot_cnn_results(file_data_model=None):\n \n if file_data_model is None:\n print(\"ERROR - PLOT_CNN_RESULTS - Argument is None\", file_data_model)\n return\n\n data_model = np.load(os.path.join(CNN.STR_DIR_RUN, file_data_model)).item()\n y_prob = data_model['y_est']\n valid_labels = data_model['y_cgt']\n acc_train = data_model['acc_train_tot'] \n acc_valid = data_model['acc_valid_tot'] \n n_iter = data_model['n_iter']\n loss = data_model['loss'] \n \n \n if len(valid_labels.shape) == 1:\n c_label = CNN.convert_to_one_hot(valid_labels, 3)\n else:\n c_label = valid_labels\n \n # Create base for Normal, MCI and AD\n angle = np.array([0, 2*np.pi/3, 4*np.pi/3])\n factors = np.array([np.exp(1j*angle)])\n # Linear combinaison with results\n prob_polar = y_prob.dot(factors.T).flatten()\n\n # Get ids of estimated classification\n ids = np.argmax(c_label, axis=1)\n ids_normal = np.nonzero(ids == 0)[0]\n ids_mci = np.nonzero(ids == 1)[0]\n ids_ad = np.nonzero(ids == 2)[0]\n \n fig = plt.figure(figsize=(16,4))\n # Polar plot\n ax = plt.subplot(1, 2, 1, projection='polar')\n plt.title('Validation - Prob. class.', fontsize=18); \n ax.scatter(np.angle(prob_polar[ids_normal]), np.abs(prob_polar[ids_normal]), s = 50, c='b', \n alpha=0.6, linewidths=0, label='Normal')\n ax.scatter(np.angle(prob_polar[ids_mci]), np.abs(prob_polar[ids_mci]), s = 50, c='g', \n alpha=0.6, linewidths=0, label='MCI')\n ax.scatter(np.angle(prob_polar[ids_ad]), np.abs(prob_polar[ids_ad]), s = 50, c='r', \n alpha=0.6, linewidths=0, label='AD')\n ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., scatterpoints=1)\n\n # Set limits of radius\n ax.set_rmax(1.0)\n # Set delimiters\n ax.xaxis.set_major_locator(ticker.MultipleLocator(np.pi/3))\n ax.xaxis.set_minor_locator(ticker.MultipleLocator(np.pi/6))\n \n # Turn off major tick labels\n ax.xaxis.set_major_formatter(ticker.NullFormatter())\n # Set the minor tick width to 0 so you don't see them\n for tick in ax.xaxis.get_minor_ticks():\n tick.tick1line.set_markersize(0)\n tick.tick2line.set_markersize(0)\n tick.label1.set_horizontalalignment('center')\n\n # Set the names of your ticks, with blank spaces for the major ticks\n ax.set_xticklabels(['','Nor','','','','MCI','','','','AD'],minor=True)\n\n # Creat second plot to see evolution of accuracy over iteration\n ax2 = plt.subplot(1, 2, 2)\n plt.title('Accuracy/Loss over iteration', fontsize=18); plt.xlabel('Iteration'); plt.ylabel('Accuracy')\n lns1 = ax2.plot(np.linspace(0,n_iter,len(acc_train)), acc_train, '-*', label = 'Train'); # Accuracy train\n lns2 = ax2.plot(np.linspace(0,n_iter,len(acc_valid)), acc_valid, '-*', label = 'Valid'); # Accuracy validation \n ax2.grid(); plt.ylim([0, 1]); \n # Lodd grid \n ax3 = ax2.twinx()\n lns3 = ax3.plot(np.linspace(0,n_iter,len(loss)), loss, '-+r', label = 'Loss'); # Accuracy validation\n plt.ylim([0, 1]); plt.ylabel('Loss') \n \n # added these three lines\n lns = lns1+lns2+lns3\n labs = [l.get_label() for l in lns]\n ax2.legend(lns, labs, loc=5)\n plt.show()\n \n # Save as PDF file if wanted\n if DataLoader.SAVE_FIGURE:\n DataLoader.save_plot(fig, 'plot_polar_prob.pdf')","def plot_2d_results(model):\n\n # Create the figure\n fig, ax = newfig(1.5, 1.5)\n ax.axis('off')\n gs = gridspec.GridSpec(3, 3)\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9, wspace=0.7, hspace=0.7)\n\n # Loop to plot different slices of the Green's function\n for i in range(2):\n for j in range(2):\n # Evaluate the Green's function network\n input_data, shape_Green, axis_limit, axis_labels = input_data_slice(\n model, Green_slice=2 * i + j + 1)\n G_pred_identifier = model.sess.run(\n model.G_network[0][0].evaluate(input_data))\n G_pred = G_pred_identifier.reshape(shape_Green)\n ax = plt.subplot(gs[i, j])\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\n extent=axis_limit,\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel(axis_labels[0])\n ax.set_ylabel(axis_labels[1], rotation=0, labelpad=12)\n ax.set_title('$G$%s' % (axis_labels[2]), fontsize=10)\n\n # Get axis limit\n x1min = np.min(model.x_G)\n x1max = np.max(model.x_G)\n x2min = np.min(model.y_G)\n x2max = np.max(model.y_G)\n\n # Exact Homogeneous solution\n ax = plt.subplot(gs[0, 2])\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\n x1 = X_G.flatten()[:, None]\n x2 = Y_G.flatten()[:, None]\n U_hom = np.transpose(model.U_hom.reshape(\n (model.y_G.shape[0], model.x_G.shape[0])))\n h = ax.imshow(U_hom, interpolation='lanczos', cmap='jet',\n extent=[x1min, x1max, x2min, x2max],\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\n ax.set_title('Exact Hom', fontsize=10)\n\n # Learned Homogeneous solution\n ax = plt.subplot(gs[1, 2])\n input_data = np.concatenate((x1, x2), 1).astype(dtype=config.real(np))\n N_pred_identifier = model.sess.run(\n model.idn_N_pred[0].evaluate(input_data))\n N_pred = N_pred_identifier.reshape(X_G.shape)\n h = ax.imshow(N_pred, interpolation='lanczos', cmap='jet',\n extent=[x1min, x1max, x2min, x2max],\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\n ax.set_title('Learned Hom', fontsize=10)\n\n # Save the figure\n savefig(\"%s/%s_%s\" % (model.path_result, model.example_name,\n model.activation_name), crop=False)","def plot_discrepancy(self, axes=None, **kwargs):\n return vis.plot_discrepancy(self.target_model,\n self.target_model.parameter_names,\n axes=axes,\n **kwargs)","def plot_comparaison_filter(fig_name):\n dir = \"log/peps mini\"\n pattern = r'(internal|access|lock)\\\\\\d{1,2}.csv$'\n pattern_valid = r'(3|6|9|12).csv$'\n df_report = pd.DataFrame()\n utils.construct_set(dir, pattern, pattern_valid, filter=0)\n X_train, X_valid, y_train, y_valid = utils.load_train_valid()\n cm, report_temp, classes = utils.train(X_train, X_valid, y_train, y_valid, method='RF',\n param={\"max_features\": 2, \"n_estimators\": 100})\n df_report = df_report.append(report_temp, ignore_index=True)\n utils.construct_set(dir, pattern, pattern_valid, filter=1)\n X_train, X_valid, y_train, y_valid = utils.load_train_valid()\n cm, report_temp, classes = utils.train(X_train, X_valid, y_train, y_valid, method='RF',\n param={\"max_features\": 2, \"n_estimators\": 100})\n df_report = df_report.append(report_temp, ignore_index=True)\n df_report.index = ['Original', 'Corrected']\n df_report.plot(kind='bar', rot=0, ylim=(0.6, 1))\n plt.title(fig_name)\n if not os.path.exists(dir_fig):\n os.makedirs(dir_fig)\n plt.savefig(dir_fig + '/' + fig_name + '.png')","def plotMerged(self, matrix, expcol, expdata=None,\n title='', showtable=True, ax=None, name=None,\n stats=True):\n if expdata==None:\n expdata = self.parent.tablemodel.simpleCopy(include=['Mutations'])\n merged = self.mergeMatrix(matrix, expdata)\n x,y,names,muts = merged.getColumns(['Total',expcol,'name','Mutations'],allowempty=False)\n from Correlation import CorrelationAnalyser\n C = CorrelationAnalyser()\n muts = ['mutation: '+i for i in muts]\n labels = zip(names, muts)\n ax,frame,mh = C.plotCorrelation(x,y,labels,title=title,ylabel=expcol,\n ax=ax,plotname=name,stats=stats,err=4)\n x=[round(float(i),2) for i in x]\n y=[round(float(i),2) for i in y] \n if showtable == True:\n table = self.showTable(frame, merged)\n mh.table = table\n \n return ax,mh,x,y","def test_plot_lm(models, kwargs):\n idata = models.model_1\n if \"constant_data\" not in idata.groups():\n y = idata.observed_data[\"y\"]\n x1data = y.coords[y.dims[0]]\n idata.add_groups({\"constant_data\": {\"_\": x1data}})\n idata.constant_data[\"x1\"] = x1data\n idata.constant_data[\"x2\"] = x1data\n\n axes = plot_lm(idata=idata, y=\"y\", y_model=\"eta\", xjitter=True, **kwargs)\n assert np.all(axes)","def plot_model(model, inputs, outputs, tss=90):\n mdl = np.load(model)\n sys = ss(mdl['A'], mdl['B'], mdl['C'], mdl['D'],1)\n gain_matrix = dcgain(sys).T\n num_i = len(inputs)\n num_o = len(outputs)\n fig, axs = plt.subplots(num_i,num_o, figsize=(3*len(outputs), 2*len(inputs)), facecolor='w', edgecolor='k')\n fig.suptitle('Step responce: '+model)\n T = np.arange(tss)\n for idx_i in range(num_i):\n for idx_o in range(num_o):\n ax = axs[idx_i][idx_o]\n t,y_step = step_response(sys,T, input=idx_i, output=idx_o)\n gain = round(gain_matrix[idx_i][idx_o],4)\n ax.plot(t, y_step,color='r')\n if idx_i == 0:\n ax.set_title(outputs[idx_o], rotation='horizontal', ha='center', fontsize=10)\n if idx_o == 0:\n ax.set_ylabel(inputs[idx_i], rotation=90, fontsize=10)\n ax.grid(color='k', linestyle='--', linewidth=0.5)\n ax.tick_params(axis='x', colors='red',size=0,labelsize=4)\n ax.tick_params(axis='y', colors='red',size=0,labelsize=4)\n ax.annotate(str(gain),xy=(.72,.8),xycoords='axes fraction')\n # fig.tight_layout()\n plt.show()","def plot_observed_predictions(self):\n \n # Plot of X vs Y\n fig = plt.figure(figsize=(15,5))\n plt.subplot(1,3,1) \n for k in self.phd_filter['estimated_positions'].keys():\n plt.plot(self.phd_filter['estimated_positions'][k][0], self.phd_filter['estimated_positions'][k][1], 'bx')\n plt.xlabel(\"X\",fontsize=20)\n plt.ylabel(\"Y\",fontsize=20)\n \n # Plot of time vs X\n plt.subplot(1,3,2)\n for k in self.phd_filter['estimated_positions'].keys(): \n plt.plot(k*np.ones(self.phd_filter['estimated_positions'][k].shape[1]), self.phd_filter['estimated_positions'][k][0], 'bx')\n plt.xlabel(\"time\",fontsize=20)\n plt.ylabel(\"X\",fontsize=20)\n plt.xlim(0,self.n_time_steps+1)\n\n # Plot of time vs Y\n plt.subplot(1,3,3)\n for k in self.phd_filter['estimated_positions'].keys():\n plt.plot(k*np.ones(self.phd_filter['estimated_positions'][k].shape[1]), self.phd_filter['estimated_positions'][k][1], 'bx')\n plt.xlabel(\"time\",fontsize=20)\n plt.ylabel(\"Y\",fontsize=20)\n plt.xlim(0,self.n_time_steps+1)\n plt.show();","def review_model(model): \n \n diagnose_model(model)\n \n plot_param_coef(model)\n \n plot_p_values(model)\n \n return","def Diagnostic_plot2(self):\n\n probs = pd.read_csv(self.probfile)\n\n fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n plt.scatter(probs['f0'], probs['Pdet_Kepler'], label='Kepler - 4yrs')\n plt.scatter(probs['f0'], probs['Pdet_TESS365'], label='TESS - 1 yr')\n plt.scatter(probs['f0'], probs['Pdet_TESS27'], label='TESS - 27 days')\n plt.legend(loc='lower right')\n plt.ylim([0,1])\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot2_Pdet' + self.ds.epic + '.pdf')\n\n fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'SNR')\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs')\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr')\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days')\n plt.legend(loc='lower right')\n #plt.ylim([0,1])\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot2_SNR' + self.ds.epic + '.pdf')","def plotChanges(data, na, nb, ra, rb, pcut, output, xlim=None, ylim=None):\n sa = data[f\"{na}_ES\"]\n sb = data[f\"{nb}_ES\"]\n\n #plot the raw dots\n fig, ax = pylab.subplots(figsize=(3.2, 2.2))\n ax.scatter(sa,\n sb,\n s=0.5,\n color=\"gray\",\n alpha=0.6,\n label=\"total %s domains\" % data.shape[0])\n #plot the changes\n ax.scatter(sa[ra],\n sb[ra],\n s=2,\n color=colors[0],\n alpha=0.8,\n label=\"%s domains\" % len(ra))\n ax.scatter(sa[rb],\n sb[rb],\n s=2,\n color=colors[1],\n alpha=0.8,\n label=\"%s domains\" % len(rb))\n leg = ax.legend(bbox_to_anchor=(1.05, 1.0),\n loc='upper left',\n labelcolor=[\"gray\", colors[0], colors[1]])\n for h in leg.legendHandles:\n h._sizes = [10]\n ax.set_xlabel(f\"{na} domain ES\")\n ax.set_ylabel(f\"{nb} domain ES\")\n ax.set_title(f\"ES comparsion\\nMahalanobis distance P-value < {pcut}\")\n s = np.min([np.min(sa), np.min(sb)])\n e = np.max([np.max(sa), np.max(sb)])\n ax.plot([s, e], [s, e], color=\"gray\", linestyle=\"--\")\n if xlim is not None:\n xlim = list(map(float, xlim.split(\",\")))\n xlim.sort()\n ax.set_xlim(xlim)\n if ylim is not None:\n ylim = list(map(float, ylim.split(\",\")))\n ylim.sort()\n ax.set_ylim(ylim)\n pylab.savefig(f\"{output}_domainChanges.pdf\")","def plot_decision_boundary(model: torch.nn.Module, X: torch.Tensor, y: torch.Tensor):\n # Put everything to CPU (works better with NumPy + Matplotlib)\n model.to(\"cpu\")\n X, y = X.to(\"cpu\"), y.to(\"cpu\")\n\n # Setup prediction boundaries and grid\n x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1\n y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1\n xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101), np.linspace(y_min, y_max, 101))\n\n # Make features\n X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()\n\n # Make predictions\n model.eval()\n with torch.inference_mode():\n y_logits = model(X_to_pred_on)\n\n # Test for multi-class or binary and adjust logits to prediction labels\n if len(torch.unique(y)) > 2:\n y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1) # mutli-class\n else:\n y_pred = torch.round(torch.sigmoid(y_logits)) # binary\n\n # Reshape preds and plot\n y_pred = y_pred.reshape(xx.shape).detach().numpy()\n plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)\n plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n plt.xlim(xx.min(), xx.max())\n plt.ylim(yy.min(), yy.max())","def plot_comparison(original, filtered, filter_name):\n fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4), sharex=True,\n sharey=True)\n ax1.imshow(original, cmap=plt.cm.gray)\n ax1.set_title('original')\n ax1.axis('off')\n ax2.imshow(filtered, cmap=plt.cm.gray)\n ax2.set_title(filter_name)\n ax2.axis('off')","def plot_comparison(original, filtered, filter_name):\n fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4), sharex=True,\n sharey=True)\n ax1.imshow(original, cmap=plt.cm.gray)\n ax1.set_title('original')\n ax1.axis('off')\n ax2.imshow(filtered, cmap=plt.cm.gray)\n ax2.set_title(filter_name)\n ax2.axis('off')","def plot_1d_results(model):\n\n # Construct grid to evaluate the Green's function\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\n x_G_star = X_G.flatten()[:, None]\n y_G_star = Y_G.flatten()[:, None]\n input_data = np.concatenate((x_G_star, y_G_star), 1)\n\n # Evaluate the Green's function\n G_pred_identifier = model.sess.run(\n model.G_network[0][0].evaluate(input_data))\n G_pred = G_pred_identifier.reshape(X_G.shape)\n\n # Evaluate the homogeneous solution\n N_pred = model.sess.run(model.idn_N_pred[0].evaluate(model.x))\n\n # Evaluate exact Green's function\n try:\n def G_expression(x, y):\n return eval(model.ExactGreen + '+ 0*x + 0*y')\n Exact_idn = G_expression(X_G, Y_G)\n except Exception:\n warnings.warn(\n 'Error in expression for the exact Green\\'s function, assuming it is unknown.')\n Exact_idn = 0 * X_G + 0 * Y_G\n\n # Compute and print relative error\n Mean_Exact_Green = np.square(Exact_idn).mean()\n L2_norm_Green = np.mean(np.square(Exact_idn - G_pred))\n if Mean_Exact_Green == 0:\n output_function = np.sqrt(L2_norm_Green)\n print('Exact Green\\'s function unknown, L2 norm = %g\"' % output_function)\n else:\n output_function = np.sqrt(L2_norm_Green / Mean_Exact_Green)\n print('Relative error = %g' % output_function)\n\n # Create the figure\n fig, ax = newfig(1.0, 1.5)\n ax.axis('off')\n gs = gridspec.GridSpec(2, 2)\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9, wspace=0.6, hspace=0.6)\n\n # Plot exact Green's function if known\n ax = plt.subplot(gs[0, 0])\n if Mean_Exact_Green == 0:\n ax.text(0.5, 0.5, \"Unknown\", horizontalalignment='center',\n verticalalignment='center', transform=ax.transAxes)\n ax.set_xlim(np.min(model.x_G), np.max(model.x_G))\n ax.set_ylim(np.min(model.y_G), np.max(model.y_G))\n else:\n h = ax.imshow(Exact_idn, interpolation='lanczos', cmap='jet',\n extent=[np.min(model.x_G), np.max(model.x_G), np.min(\n model.y_G), np.max(model.y_G)],\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\n ax.set_title('Exact Green\\'s function', fontsize=10)\n\n # Plot the learned Green's function\n ax = plt.subplot(gs[0, 1])\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\n extent=[np.min(model.x_G), np.max(model.x_G),\n np.min(model.y_G), np.max(model.y_G)],\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\n ax.set_title('Learned Green\\'s function', fontsize=10)\n\n # Plot training solutions u\n ax = plt.subplot(gs[1, 0])\n for i in range(model.u.shape[1]):\n ax.plot(model.x, model.u[:, i])\n divider = make_axes_locatable(ax)\n ax.set_xlim(np.min(model.x), np.max(model.x))\n ax.set_ylim(np.min(model.u), np.max(model.u))\n ax.set_xlabel('$x$')\n ax.set_title('Training solutions', fontsize=10)\n\n # Plot the homogeneous solution\n ax = plt.subplot(gs[1, 1])\n ax.plot(model.x, model.U_hom, label='Exact')\n ax.plot(model.x, N_pred, dashes=[2, 2], label='Learned')\n divider = make_axes_locatable(ax)\n ax.set_xlim(np.min(model.x), np.max(model.x))\n # Determine the axis limit\n ymin = min([np.min(N_pred), np.min(model.U_hom)])\n ymax = max([np.max(N_pred), np.max(model.U_hom)])\n ax.set_ylim(ymin, ymax)\n if ymax - ymin < 1e-2:\n ax.yaxis.set_major_formatter(MathTextSciFormatter(\"%1.1e\"))\n ax.set_xlabel('$x$')\n ax.set_title('Homogeneous solution', fontsize=10)\n ax.legend()\n\n # Save the figure\n savefig(\"%s/%s_%s\" % (model.path_result, model.example_name,\n model.activation_name), crop=False)","def plot_model_fits(self, x_test, plot_opts=dict()):\n \n cmodel_color = plot_opts.get('cmodel_color', 'black')\n dmodel_pre_color = plot_opts.get('dmodel_pre_color', '#cc7d21')\n dmodel_post_color = plot_opts.get('dmodel_post_color', '#0e2b4d')\n color_data = plot_opts.get('color_data', '#334431')\n marker_pre = plot_opts.get('marker_pre', 'x')\n marker_post = plot_opts.get('marker_post', 'o')\n marker_size = plot_opts.get('marker_size', 5)\n marker_alpha = plot_opts.get('marker_alpha', 1.0)\n plot_effect_size = plot_opts.get('plot_effect_size', True) \n plot_title = plot_opts.get('plot_title', 'Model fits') \n plot_samewindow = plot_opts.get('plot_same_window', False)\n axes = plot_opts.get('axes', None)\n plot_full_range = plot_opts.get('plot_full_range', \n self.labelFunc is None) \n plot_xlim = plot_opts.get('plot_xlim', \n [np.min(self.x), np.max(self.x)])\n plot_ylim = plot_opts.get('plot_ylim', \n [np.min(self.y), np.max(self.y)])\n \n if not plot_samewindow:\n if axes is None:\n fig, axes = plt.subplots(nrows=self.K, ncols=2, sharex=True, \n sharey=True, figsize=(12, 6*self.K))\n else:\n fig = plt.gcf()\n \n for i, kernel_name in enumerate(self.kernel_dict.keys()):\n self.results[kernel_name].CModel.plot(x_test, axes[i, 0], \n plotOptions={'color': cmodel_color})\n self.results[kernel_name].DModel.plot(x_test, axes[i, 1], \n b=self.b, \n plotOptions=({'color': dmodel_pre_color}, \n {'color': dmodel_post_color}), \n plotEffectSize=plot_effect_size,\n plotFullRange=plot_full_range)\n axes[i, 0].set_ylabel(kernel_name)\n summary = self.results[kernel_name].summary(b=self.b) \n pmc, pmd = summary['pmp']['pmc'], summary['pmp']['pmd']\n axes[i, 0].set_title('p(M_C | x, y) = {:0.3f}'.format(pmc))\n axes[i, 1].set_title('p(M_D | x, y) = {:0.3f}'.format(pmd))\n else:\n if axes is None:\n fig, axes = plt.subplots(nrows=self.K, ncols=1, sharex=True, \n sharey=True, figsize=(6, 6*self.K))\n else:\n fig = plt.gcf()\n \n for i, kernel_name in enumerate(self.kernel_dict.keys()):\n self.results[kernel_name].CModel.plot(x_test, axes[i], \n plotOptions={'color': cmodel_color})\n self.results[kernel_name].DModel.plot(x_test, axes[i], \n b=self.b, \n plotOptions=({'color': dmodel_pre_color}, \n {'color': dmodel_post_color}), \n plotEffectSize=plot_effect_size,\n plotFullRange=plot_full_range)\n axes[i].set_ylabel(kernel_name)\n summary = self.results[kernel_name].summary(b=self.b) \n pmc, pmd = summary['pmp']['pmc'], summary['pmp']['pmd']\n axes[i].set_title('p(M_C | x, y) = {:0.3f}, p(M_D | x, y) = {:0.3f}'.format(pmc, pmd))\n \n for ax in axes.flatten():\n ax.axvline(x=self.b, color='black', linestyle='--')\n if self.labelFunc is None:\n lab1 = self.labelLUT==0\n else:\n lab1 = self.labelFunc(self.x)\n lab2 = np.logical_not(lab1)\n ax.plot(self.x[lab1], self.y[lab1], linestyle='None', \n marker=marker_pre, color=color_data, alpha=marker_alpha, \n ms=marker_size)\n ax.plot(self.x[lab2], self.y[lab2], linestyle='None', \n marker=marker_post, color=color_data, alpha=marker_alpha, \n ms=marker_size)\n ax.set_xlim(plot_xlim)\n ax.set_ylim(plot_ylim)\n plt.suptitle(plot_title)\n return fig, axes","def plot_for_scaling_check(bolo_name):\n\n\n pop_path = \"../Analyse_\" + bolo_name + \"/Populations/Pop_for_scaling/\"\n\n #Load the estimator\n d_est = BDT_fh.open_estimator_file(bolo_name)\n\n #Best estimator for heat: coefficients\n coeff_EC1, coeff_EC2 = float(d_est[\"HEAT\"][:5]), 1 - float(d_est[\"HEAT\"][:5])\n coeff_EIB, coeff_EID = float(d_est[\"FID\"][:5]), 1-float(d_est[\"FID\"][:5])\n\n #Open event files\n data_types = {\"names\": (\"EC1\", \"EC2\", \"EIA\", \"EIB\", \"EIC\", \"EID\"), \"formats\": (\"f\", \"f\", \"f\", \"f\", \"f\", \"f\")}\n\n arr_heatonly = np.loadtxt(pop_path + bolo_name + \"_heatonly_KTH_cut_full_info.txt\", delimiter=\",\", dtype=data_types)\n arr_all = np.loadtxt(pop_path + bolo_name + \"_all_KTH_cut_full_info.txt\", delimiter=\",\", dtype=data_types)\n arr_FidGamma = np.loadtxt(pop_path + bolo_name + \"_FidGamma_KTH_cut_full_info.txt\", delimiter=\",\", dtype=data_types)\n arr_S1Gamma = np.loadtxt(pop_path + bolo_name + \"_S1Gamma_KTH_cut_full_info.txt\", delimiter=\",\", dtype=data_types)\n arr_S2Gamma = np.loadtxt(pop_path + bolo_name + \"_S2Gamma_KTH_cut_full_info.txt\", delimiter=\",\", dtype=data_types)\n arr_S1Beta = np.loadtxt(pop_path + bolo_name + \"_S1Beta_KTH_cut_full_info.txt\", delimiter=\",\", dtype=data_types)\n arr_S2Beta = np.loadtxt(pop_path + bolo_name + \"_S2Beta_KTH_cut_full_info.txt\", delimiter=\",\", dtype=data_types)\n arr_S1Pb = np.loadtxt(pop_path + bolo_name + \"_S1Pb_KTH_cut_full_info.txt\", delimiter=\",\", dtype=data_types)\n arr_S2Pb = np.loadtxt(pop_path + bolo_name + \"_S2Pb_KTH_cut_full_info.txt\", delimiter=\",\", dtype=data_types)\n\n arr_EI_heatonly, arr_EI_all = coeff_EIB*arr_heatonly[\"EIB\"] + coeff_EID*arr_heatonly[\"EID\"], coeff_EIB*arr_all[\"EIB\"] + coeff_EID*arr_all[\"EID\"]\n arr_EC_heatonly, arr_EC_all = coeff_EC1*arr_heatonly[\"EC1\"] + coeff_EC2*arr_heatonly[\"EC2\"], coeff_EC1*arr_all[\"EC1\"] + coeff_EC2*arr_all[\"EC2\"]\n arr_EI_FidGamma, arr_EC_FidGamma = coeff_EIB*arr_FidGamma[\"EIB\"] + coeff_EID*arr_FidGamma[\"EID\"], coeff_EC1*arr_FidGamma[\"EC1\"] + coeff_EC2*arr_FidGamma[\"EC2\"]\n arr_EI_S1Gamma, arr_EI_S2Gamma = coeff_EIB*arr_S1Gamma[\"EIB\"] + coeff_EID*arr_S1Gamma[\"EID\"], coeff_EIB*arr_S2Gamma[\"EIB\"] + coeff_EID*arr_S2Gamma[\"EID\"]\n arr_EC_S1Gamma, arr_EC_S2Gamma = coeff_EC1*arr_S1Gamma[\"EC1\"] + coeff_EC2*arr_S1Gamma[\"EC2\"], coeff_EC1*arr_S2Gamma[\"EC1\"] + coeff_EC2*arr_S2Gamma[\"EC2\"]\n arr_EI_S1Beta, arr_EI_S2Beta = coeff_EIB*arr_S1Beta[\"EIB\"] + coeff_EID*arr_S1Beta[\"EID\"], coeff_EIB*arr_S2Beta[\"EIB\"] + coeff_EID*arr_S2Beta[\"EID\"]\n arr_EC_S1Beta, arr_EC_S2Beta = coeff_EC1*arr_S1Beta[\"EC1\"] + coeff_EC2*arr_S1Beta[\"EC2\"], coeff_EC1*arr_S2Beta[\"EC1\"] + coeff_EC2*arr_S2Beta[\"EC2\"]\n arr_EI_S1Pb, arr_EI_S2Pb = coeff_EIB*arr_S1Pb[\"EIB\"] + coeff_EID*arr_S1Pb[\"EID\"], coeff_EIB*arr_S2Pb[\"EIB\"] + coeff_EID*arr_S2Pb[\"EID\"]\n arr_EC_S1Pb, arr_EC_S2Pb = coeff_EC1*arr_S1Pb[\"EC1\"] + coeff_EC2*arr_S1Pb[\"EC2\"], coeff_EC1*arr_S2Pb[\"EC1\"] + coeff_EC2*arr_S2Pb[\"EC2\"]\n\n lS1Beta, lS2Beta, lS1Pb, lS2Pb = np.where(arr_EC_S1Beta<15), np.where(arr_EC_S2Beta<15), np.where(arr_EC_S1Pb<15), np.where(arr_EC_S2Pb<15)\n lS1Gamma, lS2Gamma, lFidGamma = np.where(arr_EC_S1Gamma<15), np.where(arr_EC_S2Gamma<15), np.where(arr_EC_FidGamma<15)\n lheatonly, lall = np.where(arr_EC_heatonly<15), np.where(arr_EC_all<15)\n\n arr_EI_heatonly, arr_EC_heatonly = arr_EI_heatonly[lheatonly], arr_EC_heatonly[lheatonly]\n arr_EI_all, arr_EC_all = arr_EI_all[lall], arr_EC_all[lall]\n arr_EI_FidGamma, arr_EC_FidGamma = arr_EI_FidGamma[lFidGamma], arr_EC_FidGamma[lFidGamma]\n arr_EI_S1Gamma, arr_EC_S1Gamma = arr_EI_S1Gamma[lS1Gamma], arr_EC_S1Gamma[lS1Gamma]\n arr_EI_S2Gamma, arr_EC_S2Gamma = arr_EI_S2Gamma[lS2Gamma], arr_EC_S2Gamma[lS2Gamma]\n arr_EI_S1Beta, arr_EC_S1Beta = arr_EI_S1Beta[lS1Beta], arr_EC_S1Beta[lS1Beta]\n arr_EI_S2Beta, arr_EC_S2Beta = arr_EI_S2Beta[lS2Beta], arr_EC_S2Beta[lS2Beta]\n arr_EI_S1Pb, arr_EC_S1Pb = arr_EI_S1Pb[lS1Pb], arr_EC_S1Pb[lS1Pb]\n arr_EI_S2Pb, arr_EC_S2Pb = arr_EI_S2Pb[lS2Pb], arr_EC_S2Pb[lS2Pb]\n\n arr_EI_all, arr_EC_all = np.array(arr_EI_all).astype(float), np.array(arr_EC_all).astype(float)\n arr_EI_heatonly, arr_EC_heatonly = np.array(arr_EI_heatonly).astype(float), np.array(arr_EC_heatonly).astype(float)\n arr_EI_FidGamma, arr_EC_FidGamma = np.array(arr_EI_FidGamma).astype(float), np.array(arr_EC_FidGamma).astype(float)\n arr_EI_S1Gamma, arr_EC_S1Gamma = np.array(arr_EI_S1Gamma).astype(float), np.array(arr_EC_S1Gamma).astype(float)\n arr_EI_S2Gamma, arr_EC_S2Gamma = np.array(arr_EI_S2Gamma).astype(float), np.array(arr_EC_S2Gamma).astype(float) \n arr_EI_S1Beta, arr_EC_S1Beta = np.array(arr_EI_S1Beta).astype(float), np.array(arr_EC_S1Beta).astype(float)\n arr_EI_S2Beta, arr_EC_S2Beta = np.array(arr_EI_S2Beta).astype(float), np.array(arr_EC_S2Beta).astype(float)\n arr_EI_S1Pb, arr_EC_S1Pb = np.array(arr_EI_S1Pb).astype(float), np.array(arr_EC_S1Pb).astype(float)\n arr_EI_S2Pb, arr_EC_S2Pb = np.array(arr_EI_S2Pb).astype(float), np.array(arr_EC_S2Pb).astype(float)\n\n\n gr_heatonly = TGraph(len(arr_EI_heatonly), arr_EC_heatonly, arr_EI_heatonly)\n gr_FidGamma, gr_all = TGraph(len(arr_EI_FidGamma), arr_EC_FidGamma, arr_EI_FidGamma), TGraph(len(arr_EI_all), arr_EC_all, arr_EI_all)\n gr_S1Gamma, gr_S2Gamma = TGraph(len(arr_EI_S1Gamma), arr_EC_S1Gamma, arr_EI_S1Gamma), TGraph(len(arr_EI_S2Gamma), arr_EC_S2Gamma, arr_EI_S2Gamma)\n gr_S1Beta, gr_S2Beta = TGraph(len(arr_EI_S1Beta), arr_EC_S1Beta, arr_EI_S1Beta), TGraph(len(arr_EI_S2Beta), arr_EC_S2Beta, arr_EI_S2Beta)\n gr_S1Pb, gr_S2Pb = TGraph(len(arr_EI_S1Pb), arr_EC_S1Pb, arr_EI_S1Pb), TGraph(len(arr_EI_S2Pb), arr_EC_S2Pb, arr_EI_S2Pb)\n\n PyRPl.process_TGraph(gr_all, X_title = \"Heat\", Y_title = \"Ion\", color=kRed, marker_style = 20, marker_size = 0.1)\n PyRPl.process_TGraph(gr_FidGamma, X_title = \"Heat\", Y_title = \"Ion\", color=kBlack), PyRPl.process_TGraph(gr_heatonly, X_title = \"Heat\", Y_title = \"Ion\", color=kBlack)\n PyRPl.process_TGraph(gr_S1Gamma, X_title = \"Heat\", Y_title = \"Ion\", color=kBlack), PyRPl.process_TGraph(gr_S2Gamma, X_title = \"Heat\", Y_title = \"Ion\", color=kBlack)\n PyRPl.process_TGraph(gr_S1Beta, X_title = \"Heat\", Y_title = \"Ion\", color=kBlack), PyRPl.process_TGraph(gr_S2Beta, X_title = \"Heat\", Y_title = \"Ion\", color=kBlack)\n PyRPl.process_TGraph(gr_S1Pb, X_title = \"Heat\", Y_title = \"Ion\", color=kRed), PyRPl.process_TGraph(gr_S2Pb, X_title = \"Heat\", Y_title = \"Ion\", color=kBlack)\n\n list_gr = [gr_all, gr_FidGamma, gr_S1Gamma, gr_S2Gamma, gr_S1Beta, gr_S2Beta, gr_S1Pb, gr_S2Pb, gr_heatonly]\n list_pts = [gr.GetN() for gr in list_gr[1:]]\n print gr_all.GetN(), sum(list_pts)\n h = TH2F(\"h\", \"h\", 100, -5, 15, 100, -5, 15)\n PyRPl.process_TH2(h, X_title = \"Heat\", Y_title = \"Ion\")\n h.Draw()\n for gr in list_gr:\n gr.Draw(\"*same\")\n\n raw_input()\n\n # arr_Q_S1Beta = arr_EI_S1Beta/((1+8./3)*arr_EC_S1Beta - arr_EI_S1Beta*5.5/3)\n # arr_Q_S2Beta = arr_EI_S1Beta/((1+8./3)*arr_EC_S1Beta - arr_EI_S1Beta*5.5/3)\n # arr_Q_S1Pb = arr_EI_S1Pb/((1+8./3)*arr_EC_S1Pb - arr_EI_S1Pb*5.5/3)\n # arr_Q_S2Pb = arr_EI_S2Pb/((1+8./3)*arr_EC_S2Pb - arr_EI_S2Pb*5.5/3)\n \n # gr_QS1Beta, gr_QS2Beta = TGraph(len(arr_Q_S1Beta), arr_EC_S1Beta, arr_Q_S1Beta), TGraph(len(arr_Q_S2Beta), arr_EC_S2Beta, arr_Q_S2Beta)\n # gr_QS1Pb, gr_QS2Pb = TGraph(len(arr_Q_S1Pb), arr_EC_S1Pb, arr_Q_S1Pb), TGraph(len(arr_Q_S2Pb), arr_EC_S2Pb, arr_Q_S2Pb)\n\n\n # PyRPl.process_TGraph(gr_QS1Beta, X_title = \"Heat\", Y_title = \"Q\", color=kOrange-3), PyRPl.process_TGraph(gr_QS2Beta, X_title = \"Heat\", Y_title = \"Q\", color=kBlue)\n # PyRPl.process_TGraph(gr_QS1Pb, X_title = \"Heat\", Y_title = \"Q\", color=kRed), PyRPl.process_TGraph(gr_QS2Pb, X_title = \"Heat\", Y_title = \"Q\", color=kGreen+2)","def plot(model, center, extent, outname):\n # define model grid\n xg = np.linspace(-extent, extent, model.shape[0])\n yg = xg.copy()\n interp_func = RectBivariateSpline(xg, yg, model)\n\n x = np.array([-2, -1, 0, 1, 2]) + center[0]\n y = np.array([-2, -1, 0, 1, 2]) + center[1]\n psf = interp_func(x, y)\n\n x, y = np.meshgrid(x, y)\n f = pl.figure(figsize=(10, 5))\n\n pl.gray()\n ax1 = pl.subplot(121)\n ax1.imshow(model, interpolation='nearest', origin='lower',\n extent=(-extent, extent, -extent, extent),\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\n ax1.plot(x, y, 's', mec='r', mfc='none', mew=2)\n\n pl.xlim(-2.5, 2.5)\n pl.ylim(-2.5, 2.5)\n ax2 = pl.subplot(122)\n ax2.imshow(psf, interpolation='nearest', origin='lower',\n extent=(-extent, extent, -extent, extent),\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\n\n ax2.set_xticks([-2, -1, 0, 1, 2])\n ax2.set_yticks([-2, -1, 0, 1, 2])\n ax2.set_xticklabels(['%0.3f' % v for v in x[0]])\n ax2.set_yticklabels(['%0.3f' % v for v in y[:, 0]])\n\n coordsA, coordsB = \"data\", \"data\"\n pixels = np.array([[0.0, 0.0], [2., 2.], [-1., -1.]])\n locs = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, -0.5]])\n rads = [0.15, 0.25, -0.25]\n for i, p in enumerate(pixels):\n xy1 = p + center\n xy2 = p + locs[i]\n con = ConnectionPatch(xyA=xy2, xyB=xy1, coordsA=coordsA,\n coordsB=coordsB, axesA=ax2, axesB=ax1,\n arrowstyle=\"<-, head_length=1.2, head_width=0.8\", \n shrinkB=5,\n connectionstyle='arc3, rad=%s' % rads[i],\n color='r', lw=2)\n ax2.add_artist(con)\n ax2.plot(p[0], p[1], 's', mfc='none', mec='r', mew=2, ms=50)\n\n #pl.xlim(-2.5, 2.5)\n #pl.ylim(-2.5, 2.5)\n f.savefig(outname)","def plot_distmodel(objective, refl_mode='rq4', maxd=1000):\n fig, [ax1, ax2, ax3] = plt.subplots(1, 3, figsize=(10, 3), dpi=150)\n\n q = objective.data.x\n r = objective.data.y\n r_err = objective.data.y_err\n\n if refl_mode == 'rq4':\n q4 = q**4\n txt_loc2 = 'bottom'\n else:\n q4 = 1\n txt_loc2 = 'top'\n\n if type(objective.model) == MetaModel:\n distmodel = objective.model.models[0]\n distscale = objective.model.scales[0]\n h2omodel = objective.model.models[1]\n h2oscale = objective.model.scales[1]\n\n ax1.plot(*h2omodel.structure.sld_profile(), color='b', alpha=1, lw=1)\n ax2.plot(q, h2omodel(q)*q4*h2oscale, color='b', alpha=1, lw=1)\n ax2.plot(q, distmodel(q)*q4*distscale, color='red', alpha=1, lw=1)\n\n scales = objective.model.scales\n ax2.text(0.95, 0.23, 'mScales: %0.3f, %0.3f' % (scales[0].value, scales[1].value),\n ha='right', va=txt_loc2, size='small',\n transform=ax2.transAxes)\n\n else:\n distmodel = objective.model\n distscale = 1\n\n maxscale = np.max(distmodel.scales)\n\n # Need to call the model to refresh parameters\n objective.model(q)\n\n d = np.linspace(0, maxd, 5000)\n pdf = distmodel.pdf(d, **distmodel.pdf_kwargs)\n ax3.plot(d, pdf)\n\n for struct, scale in zip(distmodel.structures, distmodel.scales):\n normscale = np.min([1, np.max([scale/maxscale, 0.001])])\n\n ax1.plot(*struct.sld_profile(), color='xkcd:crimson',\n alpha=normscale, lw=1)\n\n dummy_model = ReflectModel(struct, bkg=objective.model.bkg.value)\n\n ax2.plot(q, dummy_model.model(q)*q4*normscale*distscale,\n alpha=normscale*0.5, color='xkcd:crimson', lw=1)\n\n thick = struct[2].thick.value\n\n ax3.scatter(thick, np.interp(thick, d, pdf), marker='.', color='k',\n alpha=normscale)\n\n ax2.plot(q, objective.model(q)*q4, color='k', alpha=1)\n ax2.errorbar(q, r*q4, yerr=r_err*q4, color='b', alpha=0.5)\n ax2.set_yscale('log')\n\n ax1.set_xlabel('Thickness, $\\mathrm{\\AA}$')\n ax1.set_ylabel('SLD, $\\mathrm{\\AA}^{-2}$')\n ax2.set_xlabel('$Q$, $\\mathrm{\\AA}^{-1}$')\n ax2.set_ylabel('$R$')\n ax3.set_xlabel('Thickness, $\\mathrm{\\AA}$')\n\n kwargs = distmodel.pdf_kwargs\n for i, key in enumerate(kwargs):\n ax3.text(0.95, 0.95-0.06*i, '%s: %0.4f' % (key, kwargs[key]),\n ha='right', va='top', size='small',\n transform=ax3.transAxes)\n\n i = 0\n for p in distmodel.master_structure.parameters.flattened():\n if p.vary is True:\n ax1.text(0.95, 0.05+0.06*i, '%s: %0.3f' % (p.name, p.value),\n ha='right', va='bottom', size='small',\n transform=ax1.transAxes)\n i += 1\n\n ax2.text(0.95, 0.17, 'background: %d' % objective.model.bkg.value,\n ha='right', va=txt_loc2, size='small',\n transform=ax2.transAxes)\n# ax2.text(0.95, 0.05, 'lnprob: %d' % (objective.logpost()),\n# ha='right', va=txt_loc2, size='small',\n# transform=ax2.transAxes)\n ax2.text(0.95, 0.11, 'chisqr: %d' % (objective.chisqr()),\n ha='right', va=txt_loc2, size='small',\n transform=ax2.transAxes)\n\n ax1.set_xbound(-50, maxd)\n fig.tight_layout()","def models_comparison_plot(self, roc_curves, precision_recall_curves, det_curves, target_proportion):\n new_tps = [assess_models_names(tp) for tp in [roc_curves, precision_recall_curves, det_curves]]\n roc_curves, precision_recall_curves, det_curves = new_tps\n\n # ROC\n roc_plot = Panel(\n child=self._roc_plot(roc_curves),\n title=self._roc_plot_name\n )\n # Precision-Recall\n precision_recall_plot = Panel(\n child=self._precision_recall_plot(precision_recall_curves, target_proportion),\n title=self._precision_recall_plot_name\n )\n # DET\n det_plot = Panel(\n child=self._det_plot(det_curves),\n title=self._det_plot_name\n )\n\n # Final Plot\n main_plot = Tabs(tabs=[roc_plot, precision_recall_plot, det_plot])\n\n return main_plot","def plot_components(component1, component2, df, name):\n\n # Create figure and plot input data onto first two components\n plt.figure()\n colors = sns.color_palette('hls', len(np.unique(df['y'])))\n sns.scatterplot(x=component1, y=component2, hue='y', palette=colors, data=df, legend='full', alpha=0.3)\n\n # Annotate standard deviation arrows for the two components\n plt.annotate('', xy=(np.std(df[component1]), 0), xytext=(0, 0), arrowprops=dict(arrowstyle='->', color='orange', lw=3))\n plt.annotate('', xy=(0, np.std(df[component2])), xytext=(0, 0), arrowprops=dict(arrowstyle='->', color='orange', lw=3))\n\n # Set title and axes limits\n plt.title('{} Transformation with first 2 components and true labels'.format(name.upper()))\n xlim = 1.1 * np.max(np.abs(df[component1]))\n ylim = 1.1 * np.max(np.abs(df[component2]))\n plt.xlim(-xlim, xlim)\n plt.ylim(-ylim, ylim)","def comparison_plot(X, Y, title):\n linreg = scipy.stats.linregress(X, Y)\n\n x_txt = rel_pos(X, 0.95)\n y_txt = rel_pos(Y, 0)\n\n plt.scatter(X, Y)\n plt.xlabel('B-S')\n plt.ylabel('S-B')\n if title == 'RouteScore':\n plt.xscale('log')\n plt.yscale('log')\n if len(set(X)) > 1 or len(set(Y)) > 1:\n plt.text(x_txt, y_txt,\n f'slope = {round(linreg.slope, 2)}\\n$R^{2}$ = {round(linreg.rvalue,2)}',\n horizontalalignment='right',\n verticalalignment='bottom')\n plt.xlim(0.95 * min(X), 1.05 * max(X))\n plt.ylim(0.95 * min(Y), 1.05 * max(Y))\n plt.savefig(os.path.join(FIG_DIR, f'BSvsSB {title}.png'))\n plt.show()","def plot_scatter(self):\n if Trainer.y_pred is None or Trainer.y_true is None:\n messagebox.showerror(\"Information\", \"Please train the model first before plotting\")\n return\n\n fig = plt.figure(figsize=(8, 4))\n plt.xlabel(\"Prediction\")\n plt.ylabel(\"Target\")\n plt.figtext(0, 0, f\"RMSE: {self.test_rmse}\", fontsize=13)\n plt.grid()\n plt.scatter(x=Trainer.y_true, y=Trainer.y_pred, c='b', s=1)\n\n win = tk.Toplevel()\n win.wm_title(\"Window\")\n win.geometry(\"1000x500\")\n\n # specify the window as master\n canvas = FigureCanvasTkAgg(fig, master=win)\n canvas.draw()\n canvas.get_tk_widget().grid(row=0, column=0, sticky=tk.W)\n\n # navigation toolbar\n toolbarFrame = tk.Frame(master=win)\n toolbarFrame.grid(row=1, column=0)\n toolbar = NavigationToolbar2Tk(canvas, toolbarFrame)","def plot_results(self):\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))","def plotCoefficients(model):\n\n coefs = pd.DataFrame(model.coef_, X_train.columns)\n coefs.columns = [\"coef\"]\n coefs[\"abs\"] = coefs.coef.apply(np.abs)\n coefs = coefs.sort_values(by=\"abs\", ascending=False).drop([\"abs\"], axis=1)\n\n plt.figure(figsize=(15, 7))\n plt.title('sorted coefficient values of the model')\n coefs.coef.plot(kind='bar')\n plt.grid(True, axis='y')\n plt.hlines(y=0, xmin=0, xmax=len(coefs), linestyles='dashed');\n plt.draw()","def plot_MCMC_results(xdata, ydata, trace, colors='k'):\n fig, ax = plt.subplots(1, 1, figsize=(8, 5))\n plt.title(' 68 and 95 percent joint confidence intervals on b and m')\n plot_MCMC_trace(ax, xdata, ydata, trace, True, colors=colors)\n # plot_MCMC_model(ax[1], xdata, ydata, trace)","def plot_interaction_map(model, name, matrix, output_name, first_variable, second_variable, x_coord, y_coord, output_path): \n import matplotlib\n import matplotlib.cm as cm\n import matplotlib.pyplot as plt\n\n font = {'size' : 14}\n\n matplotlib.rc('font', **font)\n fig = plt.figure(figsize=(5,5))\n ax = plt.subplot()\n\n maxValue = np.max(np.abs(matrix))\n img = ax.imshow((matrix), cmap = cm.bwr, origin='lower', vmin = -min(maxValue, 6), vmax = min(maxValue, 6), interpolation='spline16')\n\n first_variable = '{}'.format(first_variable)\n second_variable = '{}'.format(second_variable)\n ax.set_ylabel(r'$x_i$ = ' + first_variable)\n ax.set_xlabel(r'$y_i$ = ' + second_variable)\n ax.axes.set_xticks([0, 50, 99])\n ax.axes.set_yticks([0, 50, 99])\n xticks = np.linspace(np.array(model.feature_limits[first_variable]).min(), np.array(model.feature_limits[first_variable]).max(), 3)\n yticks = np.linspace(np.array(model.feature_limits[second_variable]).min(), np.array(model.feature_limits[second_variable]).max(), 3)\n ax.scatter([x_coord], [y_coord], marker='o', color='white', s = 250, edgecolors='black', linewidth=3)\n\n ax.set_yticklabels([xticks[tind] for tind in range(3)])\n ax.set_xticklabels([yticks[tind] for tind in range(3)])\n ax.axis([0, (100) - 1, 0, (100) - 1])\n\n # ax.scatter([x_coord_linear], [y_coord_linear], marker='o', color='blue', s = 250, edgecolors='black', linewidth=3)\n t = ax.set_title(r'$\\mathregular{\\frac{\\delta ^2 F(\\bar{x})}{\\delta x_i \\delta x_j}}$')\n # t = ax.set_title('{} and {} - '.format(first_variable, second_variable) + r'$\\mathregular{\\frac{\\delta ^2 F(\\bar{x})}{\\delta x_i \\delta x_j}}$')\n t.set_position([.5, 1.025])\n from mpl_toolkits.axes_grid1 import make_axes_locatable\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n cb = plt.colorbar(img, cax=cax)\n cb.set_label(\"Nomralized mixed derivative\", rotation=90)\n plt.savefig('{}/{}_{}_{}_{}_nonlinear_map.pdf'.format(output_path, name, output_name, first_variable, second_variable), transparent=True, bbox_inches='tight', format='pdf', dpi=600)\n # plt.close('all')","def plot_bv_join(df, xcolname, ycolname, kindname='hist', xlogflag=False, ylogflag=False, icol=4):\n # set plot size\n fig, ax = plt.subplots(figsize=(8,6))\n \n # plotting... jointplot\n sns.jointplot(ax = ax, data = df\n , x = str(xcolname)\n , y = str(ycolname)\n , kind = kindname\n , color = sns.color_palette()[icol]);\n \n\n # log scale or not\n if (ylogflag): plt.yscale('log')\n \n \n # title and labels\n plt.title(xcolname+' Vs '+ycolname, fontsize=20)\n plt.xlabel(xcolname+ ' (units)', fontsize=16)\n plt.ylabel(ycolname+ ' (units)', fontsize=16)\n \n return plt.show()","def makeComparsionChart(columns, data):\n fig = plt.figure(figsize=(16, 10))\n gs = gridspec.GridSpec(2, 3, wspace = 0.2, hspace=0.2, right=0.96, left=0.04)\n ax1 = plt.subplot(gs[0, 0:1], label=\"\")\n ax2 = plt.subplot(gs[0, 1:2], label=\"\" )\n ax3 = plt.subplot(gs[0, 2:3], label=\"\" )\n ax4 = plt.subplot(gs[1, 0:1], label=\"\" )\n ax5 = plt.subplot(gs[1, 1:2], label=\"\" )\n ax1.set_title('Before Scaling')\n ax2.set_title('After Standard Scaler')\n ax3.set_title('After Min-Max Scaler')\n ax4.set_title('After Roboust Scaler')\n ax5.set_title('After Normalization')\n\n for column in columns:\n sns.kdeplot(data[0][column], ax=ax1, legend=False)\n sns.kdeplot(data[1][column], ax=ax2, legend=False)\n sns.kdeplot(data[2][column], ax=ax3, legend=False)\n sns.kdeplot(data[3][column], ax=ax4, legend=False)\n sns.kdeplot(data[4][column], ax=ax5, legend=False)\n\n plt.show()","def test_2d_plot(self):\n db = pd.HDFStore('test.h5')\n df_iv = db['iv']\n dates = df_iv[df_iv['dte'] == 30]['date']\n impl_vols = df_iv[df_iv['dte'] == 30]['impl_vol']\n db.close()\n\n print df_iv.sort_values('impl_vol').head()\n\n plt.plot(dates, impl_vols)\n plt.xlabel('date')\n plt.ylabel('impl_vols')\n plt.show()","def plot_comparaison_filter2():\n dir = \"log/NY/peps mini\"\n pattern = r'(internal|access|lock)\\\\\\d{1,2}.csv$'\n pattern_valid = r'(3|6|9|12).csv$'\n df_report = pd.DataFrame()\n filters = ['Raw', 'ULimiter', 'BLimiter', 'TA:n=5', 'TA:n=10', 'LSA:n=5', 'LSA:n=10']\n for index, name in enumerate(filters):\n print('Filter: ' + name)\n utils.construct_set(dir, pattern, pattern_valid, filter=index)\n X_train, X_valid, y_train, y_valid = utils.load_train_valid()\n cm, report_temp, classes = utils.train(X_train, X_valid, y_train, y_valid, method='RF',\n param={\"max_features\": 2, \"n_estimators\": 100})\n df_report = df_report.append(report_temp, ignore_index=True)\n df_report.index = filters\n df_report.plot(kind='bar', rot=0, ylim=(0.8, 0.95))\n df_report.to_csv('data/comparaison_filter.csv', sep=';')","def plot_result(data, gt_y, pred_y):\n assert data.shape[0] == gt_y.shape[0]\n assert data.shape[0] == pred_y.shape[0]\n\n plt.figure()\n\n plt.subplot(1, 2, 1)\n plt.title('Ground Truth', fontsize=18)\n\n for idx in range(data.shape[0]):\n if gt_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.subplot(1, 2, 2)\n plt.title('Prediction', fontsize=18)\n\n for idx in range(data.shape[0]):\n if pred_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.show()","def plot_result(data, gt_y, pred_y):\n assert data.shape[0] == gt_y.shape[0]\n assert data.shape[0] == pred_y.shape[0]\n\n plt.figure()\n\n plt.subplot(1, 2, 1)\n plt.title('Ground Truth', fontsize=18)\n\n for idx in range(data.shape[0]):\n if gt_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.subplot(1, 2, 2)\n plt.title('Prediction', fontsize=18)\n\n for idx in range(data.shape[0]):\n if pred_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.show()","def onselect(xmin, xmax): \n # convert matplotlib float dates to a datetime format\n date_min = mdates.num2date(xmin)\n date_max = mdates.num2date(xmax) \n \n # put the xmin and xmax in datetime format to compare\n date_min = datetime.datetime(date_min.year, date_min.month, date_min.day, date_min.hour, date_min.minute) \n date_max = datetime.datetime(date_max.year, date_max.month, date_max.day, date_max.hour, date_max.minute)\n \n # find the indices that were selected \n indices = np.where((comp_data['dates'] >= date_min) & (comp_data['dates'] <= date_max))\n indices = indices[0]\n \n # set the data in ax2 plot\n plot2a.set_data(comp_data['dates'][indices], comp_data['observed_parameter'][indices])\n plot2b.set_data(comp_data['dates'][indices], comp_data['modeled_parameter'][indices])\n \n # calculate updated stats \n updated_r_squared_coeff = statistics.r_squared(modeled = comp_data['modeled_parameter'][indices], observed = comp_data['observed_parameter'][indices])\n updated_nash_sutcliffe_coeff = statistics.nash_sutcliffe(modeled = comp_data['modeled_parameter'][indices], observed = comp_data['observed_parameter'][indices])\n \n ax2.set_xlim(comp_data['dates'][indices][0], comp_data['dates'][indices][-1])\n param_max = np.max((comp_data['observed_parameter'][indices], comp_data['modeled_parameter'][indices]))\n param_min = np.min((comp_data['observed_parameter'][indices], comp_data['modeled_parameter'][indices]))\n ax2.set_ylim(param_min, param_max)\n \n # show text of mean, max, min values on graph; use matplotlib.patch.Patch properies and bbox\n text2 = 'R_squared = %.2f\\nNash sutcliffe = %.2f' % (updated_r_squared_coeff, updated_nash_sutcliffe_coeff)\n \n ax2_text.set_text(text2)\n \n # set the data in ax4 plot\n plot4a.set_data(comp_data['dates'][indices], comp_data['stats']['relative_error'][indices])\n plot4b.set_data(comp_data['dates'][indices], comp_data['stats']['relative_error'][indices])\n \n # calculate updated mean, max, min for stats data\n stat_mean = np.mean(comp_data['stats']['relative_error'][indices])\n stat_max = np.max(comp_data['stats']['relative_error'][indices])\n stat_min = np.min(comp_data['stats']['relative_error'][indices])\n \n ax4.set_xlim(comp_data['dates'][indices][0], comp_data['dates'][indices][-1])\n ax4.set_ylim(stat_min, stat_max)\n \n # show text of mean, max, min values on graph; use matplotlib.patch.Patch properies and bbox\n text4 = 'Mean = %.2f\\nMax = %.2f\\nMin = %.2f' % (stat_mean, stat_max, stat_min)\n \n ax4_text.set_text(text4) \n \n fig.canvas.draw()","def figures_2d(\r\n self,\r\n data: bool = False,\r\n noise_map: bool = False,\r\n signal_to_noise_map: bool = False,\r\n model_image: bool = False,\r\n residual_map: bool = False,\r\n normalized_residual_map: bool = False,\r\n chi_squared_map: bool = False,\r\n use_source_vmax : bool = False,\r\n suffix: str = \"\",\r\n ):\r\n\r\n visuals_2d = self.get_visuals_2d()\r\n\r\n visuals_2d_no_critical_caustic = self.get_visuals_2d()\r\n visuals_2d_no_critical_caustic.tangential_critical_curves = None\r\n visuals_2d_no_critical_caustic.radial_critical_curves = None\r\n visuals_2d_no_critical_caustic.tangential_caustics = None\r\n visuals_2d_no_critical_caustic.radial_caustics = None\r\n visuals_2d_no_critical_caustic.origin = None\r\n visuals_2d_no_critical_caustic.light_profile_centres = None\r\n visuals_2d_no_critical_caustic.mass_profile_centres = None\r\n\r\n if data:\r\n\r\n if use_source_vmax:\r\n self.mat_plot_2d.cmap.kwargs[\"vmax\"] = np.max(self.fit.model_images_of_planes_list[-1])\r\n\r\n self.mat_plot_2d.plot_array(\r\n array=self.fit.data,\r\n visuals_2d=visuals_2d_no_critical_caustic,\r\n auto_labels=AutoLabels(title=\"Data\", filename=f\"data{suffix}\"),\r\n )\r\n\r\n if use_source_vmax:\r\n self.mat_plot_2d.cmap.kwargs.pop(\"vmax\")\r\n\r\n if noise_map:\r\n\r\n self.mat_plot_2d.plot_array(\r\n array=self.fit.noise_map,\r\n visuals_2d=visuals_2d_no_critical_caustic,\r\n auto_labels=AutoLabels(\r\n title=\"Noise-Map\", filename=f\"noise_map{suffix}\"\r\n ),\r\n )\r\n\r\n if signal_to_noise_map:\r\n\r\n self.mat_plot_2d.plot_array(\r\n array=self.fit.signal_to_noise_map,\r\n visuals_2d=visuals_2d_no_critical_caustic,\r\n auto_labels=AutoLabels(\r\n title=\"Signal-To-Noise Map\", cb_unit=\" S/N\", filename=f\"signal_to_noise_map{suffix}\"\r\n ),\r\n )\r\n\r\n if model_image:\r\n\r\n if use_source_vmax:\r\n self.mat_plot_2d.cmap.kwargs[\"vmax\"] = np.max(self.fit.model_images_of_planes_list[-1])\r\n\r\n self.mat_plot_2d.plot_array(\r\n array=self.fit.model_data,\r\n visuals_2d=visuals_2d,\r\n auto_labels=AutoLabels(\r\n title=\"Model Image\", filename=f\"model_image{suffix}\"\r\n ),\r\n )\r\n\r\n if use_source_vmax:\r\n self.mat_plot_2d.cmap.kwargs.pop(\"vmax\")\r\n\r\n cmap_original = self.mat_plot_2d.cmap\r\n\r\n if self.residuals_symmetric_cmap:\r\n\r\n self.mat_plot_2d.cmap = self.mat_plot_2d.cmap.symmetric_cmap_from()\r\n\r\n if residual_map:\r\n\r\n self.mat_plot_2d.plot_array(\r\n array=self.fit.residual_map,\r\n visuals_2d=visuals_2d_no_critical_caustic,\r\n auto_labels=AutoLabels(\r\n title=\"Residual Map\", filename=f\"residual_map{suffix}\"\r\n ),\r\n )\r\n\r\n if normalized_residual_map:\r\n\r\n self.mat_plot_2d.plot_array(\r\n array=self.fit.normalized_residual_map,\r\n visuals_2d=visuals_2d_no_critical_caustic,\r\n auto_labels=AutoLabels(\r\n title=\"Normalized Residual Map\",\r\n cb_unit=r\" $\\sigma$\",\r\n filename=f\"normalized_residual_map{suffix}\",\r\n ),\r\n )\r\n\r\n self.mat_plot_2d.cmap = cmap_original\r\n\r\n if chi_squared_map:\r\n\r\n self.mat_plot_2d.plot_array(\r\n array=self.fit.chi_squared_map,\r\n visuals_2d=visuals_2d_no_critical_caustic,\r\n auto_labels=AutoLabels(\r\n title=\"Chi-Squared Map\", cb_unit=r\" $\\chi^2$\", filename=f\"chi_squared_map{suffix}\"\r\n ),\r\n )","def plot(model, results, filename):\n\n # c = model.compartments.get_one(id='c')\n #\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\n #\n pops = results.get('populations')\n time = pops.index\n pop_rna_1 = pops['rna_1[c]']\n pop_rna_2 = pops['rna_2[c]']\n pop_rna_3 = pops['rna_3[c]']\n\n pop_atp = pops['atp[c]']\n pop_gtp = pops['gtp[c]']\n pop_utp = pops['ctp[c]']\n pop_ctp = pops['utp[c]']\n\n pop_amp = pops['amp[c]']\n pop_gmp = pops['gmp[c]']\n pop_ump = pops['cmp[c]']\n pop_cmp = pops['ump[c]']\n\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\n\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\n\n axes1[0].plot(time / 3600, pop_rna_1)\n axes1[0].plot(time / 3600, pop_rna_2)\n axes1[0].plot(time / 3600, pop_rna_3)\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\n axes1[0].set_ylim((0., 10.0))\n axes1[0].legend(loc='upper right')\n\n axes1[1].plot(time / 3600, pop_atp)\n axes1[1].plot(time / 3600, pop_gtp)\n axes1[1].plot(time / 3600, pop_utp)\n axes1[1].plot(time / 3600, pop_ctp)\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[1].set_ylim((0., 10.0))\n axes1[1].legend(loc='upper right')\n\n axes1[2].plot(time / 3600, pop_amp)\n axes1[2].plot(time / 3600, pop_gmp)\n axes1[2].plot(time / 3600, pop_ump)\n axes1[2].plot(time / 3600, pop_cmp)\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[2].set_ylim((0., 10.0))\n axes1[2].legend(loc='upper right')\n\n fig1.savefig(filename.format('species'))\n pyplot.close(fig1)","def visualize(self):\n\t\tplt.figure(1)\n\t\tax1 = plt.add_suplot(1,2,1)\n\t\t# Plot free energy error\n\t\tax1.plot(self.FE_errors_GMM_CV_, linewidth=4, label='GMM with cross-validation')\n\t\tax1.plot(self.FE_errors_GMM_mix_models_, linewidth=4, label='GMM with mixture of models')\n\t\tplt.legend()\n\n\t\t# Plot density error\n\n\t\t# Plot log-likelihood of test set\n\n\t\t# Plot clustering score\n\n\t\tplt.show()\n\n\t\treturn","def plot_observed(self):\n \n fig = plt.figure(figsize=(15,5))\n plt.subplot(1,3,1)\n for k in self.observed_data.keys():\n plt.plot(self.observed_data[k][0], self.observed_data[k][1], 'bx')\n plt.xlabel(\"X\",fontsize=20)\n plt.ylabel(\"Y\",fontsize=20)\n\n fig = plt.figure(figsize=(16,4))\n \n # Plot of time vs X\n plt.subplot(1,3,2)\n for k in self.observed_data.keys(): \n plt.plot(k*np.ones(self.observed_data[k].shape[1]), self.observed_data[k][0], 'bx')\n plt.xlabel(\"time\",fontsize=20)\n plt.ylabel(\"X\",fontsize=20)\n plt.xlim(0,self.n_time_steps+1)\n\n # Plot of time vs Y\n plt.subplot(1,3,3)\n for k in self.observed_data.keys():\n plt.plot(k*np.ones(self.observed_data[k].shape[1]), self.observed_data[k][1], 'bx')\n plt.xlabel(\"time\",fontsize=20)\n plt.ylabel(\"Y\",fontsize=20)\n plt.xlim(0,self.n_time_steps+1)\n plt.show();","def plot_lineratios(modeldata,modeldata2='None',line1='CIV1551',line2='CIII1908',line3='CIV1551',line4='HeII1640',\n plotname='./TESTPLOT.pdf',Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\n logx=True,logy=True,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\n showobs=None,noobserr=False,verbose=True):\n NFalse = 0\n freeparam = []\n inforstr = \"\"\n # - - - - - - - - - - - - - - - - - - - - - - - -\n legenddic = {}\n legenddic['Zgas'] = r'Z$_\\textrm{gas}$'\n legenddic['logUs'] = r'log$_\\textrm{10}$(U)'\n legenddic['xid'] = r'$\\xi_\\textrm{d}$'\n legenddic['nh'] = r'n$_\\textrm{H}$ / [cm$^3$]'\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\textrm{sun}$'\n legenddic['mup'] = r'M$_\\textrm{cut IMF}$ / [M$_\\textrm{sun}]$'\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Zgas:\n Zgasrange = [0.0,1.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Zgas:vary, '\n freeparam.append('Zgas')\n else:\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not logU:\n logUrange = [-5.0,0.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' logU:vary, '\n freeparam.append('logUs')\n else:\n logUrange = [logU-0.1,logU+0.1]\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not xid:\n xidrange = [0.0,0.6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' xid:vary, '\n freeparam.append('xid')\n else:\n xidrange = [xid-0.01,xid+0.01]\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not nh:\n nhrange = [0.0,1.0e6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' nH:vary, '\n freeparam.append('nh')\n else:\n nhrange = [nh-1.0,nh+1.0]\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not COratio:\n COratiorange = [0.0,2.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' C/O:vary, '\n freeparam.append('COCOsol')\n else:\n COratiorange = [COratio-0.001,COratio+0.001]\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Mcutoff:\n Mcutoffrange = [0.0,400.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Mcutoff:vary, '\n freeparam.append('mup')\n else:\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n\n if NFalse != 2:\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\n ' parameters where not set')\n\n # - - - - - - - - - - - - - - - - - - - - - - - -\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\n\n Ngoodent = len(goodent[0])\n\n if Ngoodent > 1:\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying (SFR)model selection ')\n param1_1 = modeldata[freeparam[0]][goodent]\n if logp1:\n param1_1 = np.log10(param1_1)\n\n param1_2 = modeldata[freeparam[1]][goodent]\n if logp2:\n param1_2 = np.log10(param1_2)\n\n ratio1_1 = modeldata[line1][goodent]/modeldata[line2][goodent]\n ratio1_2 = modeldata[line3][goodent]/modeldata[line4][goodent]\n else:\n if verbose: print(' WARNING: Less than 2 (SFR)model grid points to plot; no output generated')\n return\n\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if modeldata2 != 'None':\n goodent2 = np.where( (modeldata2['Zgas'] > Zgasrange[0]) & (modeldata2['Zgas'] < Zgasrange[1]) &\n (modeldata2['logUs'] > logUrange[0]) & (modeldata2['logUs'] < logUrange[1]) &\n (modeldata2['xid'] > xidrange[0]) & (modeldata2['xid'] < xidrange[1]) &\n (modeldata2['nh'] > nhrange[0]) & (modeldata2['nh'] < nhrange[1]) )\n\n Ngoodent2 = len(goodent2[0])\n\n if Ngoodent > 1:\n if verbose: print(' - Getting data for '+str(Ngoodent2)+' data points satisfying (AGN)model selection ')\n param2_1 = modeldata2[freeparam[0]][goodent2]\n if logp1:\n param2_1 = np.log10(param2_1)\n\n param2_2 = modeldata2[freeparam[1]][goodent2]\n if logp2:\n param2_2 = np.log10(param2_2)\n\n l2s = ['x','x','x','x'] # line names to use for Feltre+16 file\n for ll, linestr in enumerate([line1,line2,line3,line4]):\n if '1908' in linestr:\n l2 = linestr.replace('1908','1907')\n else:\n l2 = linestr\n\n l2s[ll] = l2\n\n ratio2_1 = modeldata2[l2s[0]][goodent2]/modeldata2[l2s[1]][goodent2]\n ratio2_2 = modeldata2[l2s[2]][goodent2]/modeldata2[l2s[3]][goodent2]\n else:\n if verbose: print(' WARNING: Less than 2 (AGN)model grid points to plot; no output generated')\n return\n\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\n if verbose: print(' - Setting up and generating plot')\n plotname = plotname\n fig = plt.figure(figsize=(9, 5))\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\n Fsize = 10\n lthick = 1\n marksize = 3\n plt.rc('text', usetex=True)\n plt.rc('font', family='serif',size=Fsize)\n plt.rc('xtick', labelsize=Fsize)\n plt.rc('ytick', labelsize=Fsize)\n plt.clf()\n plt.ioff()\n plt.title(inforstr[:-2],fontsize=Fsize)\n\n margin = 0.1\n dx = np.abs(np.max(ratio1_1)-np.min(ratio1_1))\n dy = np.abs(np.max(ratio1_2)-np.min(ratio1_2))\n\n\n if fixxrange:\n xrange = fixxrange\n else:\n if logx:\n xrange = [np.min(ratio1_1)-np.min(ratio1_1)/2.,np.max(ratio1_1)+np.max(ratio1_1)/2.]\n else:\n xrange = [np.min(ratio1_1)-dx*margin,np.max(ratio1_1)+dx*margin]\n\n if fixyrange:\n yrange = fixyrange\n else:\n if logy:\n yrange = [np.min(ratio1_2)-np.min(ratio1_2)/2.,np.max(ratio1_2)+np.max(ratio1_2)/2.]\n else:\n yrange = [np.min(ratio1_2)-dy*margin,np.max(ratio1_2)+dy*margin]\n\n # ------------ PARAM1 ------------\n cmap = plt.cm.get_cmap('winter')\n cmin = np.min(param1_1)\n cmax = np.max(param1_1)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb1 = plt.colorbar(mm)#shrink=0.25\n\n pstr1 = legenddic[freeparam[0]]\n if logp1:\n pstr1 = r'log$_\\textrm{10}$('+pstr1+')'\n\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\n\n for p1 in np.unique(param1_1):\n p1col = cmap(colnorm(p1))\n p1ent = np.where(param1_1 == p1)\n\n plt.plot(ratio1_1[p1ent],ratio1_2[p1ent],'-',lw=lthick, color='k',zorder=1)\n\n plt.errorbar(ratio1_1[p1ent],ratio1_2[p1ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*3,\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\n\n if modeldata2 is not 'None':\n p1ent = np.where(param2_1 == p1)\n\n plt.plot(ratio2_1[p1ent],ratio2_2[p1ent],'-',lw=lthick, color='k',zorder=1)\n\n plt.errorbar(ratio2_1[p1ent],ratio2_2[p1ent],xerr=None,yerr=None,\n marker='D',lw=0, markersize=marksize*3,\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\n\n\n # ------------ PARAM2 ------------\n cmap = plt.cm.get_cmap('spring')\n cmin = np.min(param1_2)\n cmax = np.max(param1_2)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb2 = plt.colorbar(mm)#shrink=0.25\n\n pstr2 = legenddic[freeparam[1]]\n if logp2:\n pstr2 = 'log10('+pstr2+')'\n\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\n\n for p2 in np.unique(param1_2):\n p2col = cmap(colnorm(p2))\n p2ent = np.where(param1_2 == p2)\n\n plt.plot(ratio1_1[p2ent],ratio1_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\n\n plt.errorbar(ratio1_1[p2ent],ratio1_2[p2ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*1.5,\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\n\n if modeldata2 is not 'None':\n p2ent = np.where(param2_2 == p2)\n\n plt.plot(ratio2_1[p2ent],ratio2_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\n\n plt.errorbar(ratio2_1[p2ent],ratio2_2[p2ent],xerr=None,yerr=None,\n marker='D',lw=0, markersize=marksize*1.5,\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\n\n\n if showobs != None:\n for ii, objid in enumerate(showobs[:,0]):\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\n\n if noobserr:\n obsxerr = None\n obsyerr = None\n else:\n obsxerr = showobs[:,8][ii]\n obsyerr = showobs[:,10][ii]\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\n marker='*',lw=lthick, markersize=marksize*2,\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\n\n plt.xlabel(line1+'/'+line2)\n plt.ylabel(line3+'/'+line4)\n\n plt.xlim(xrange)\n plt.ylim(yrange)\n\n if logx:\n plt.xscale('log')\n if logy:\n plt.yscale('log')\n\n #--------- LEGEND ---------\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\n #\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\n # leg.get_frame().set_alpha(0.7)\n #--------------------------\n\n if verbose: print(' Saving plot to'+plotname)\n plt.savefig(plotname)\n plt.clf()\n plt.close('all')","def showPlot2():\n interested_in = list(range(1,10))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on number of robots')\n xlabel('number of robots (tiles)')\n ylabel('mean time (clocks)')\n show()","def xx_plot(epoch, model, features, filters, figname, fgal=0.5):\n # fetch Stripe 82 data\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\n filters, use_single=False)\n N = 20000\n X = X[:N]\n Xcov = Xcov[:N]\n Xcoadd = Xcoadd[:N]\n Xcoaddcov = Xcoaddcov[:N]\n\n # unpickle the XD model\n if type(model) == str: \n f = open(model, 'rb')\n model = cPickle.load(f)\n f.close()\n\n # Calculate the posteriors, draw samples\n a, m, v = model.posterior(X, Xcov)\n posts = np.zeros_like(X)\n for i in range(X.shape[0]):\n posts[i] = model.sample(a[i], m[i], v[i], size=1)\n\n lo = [0.01, 0.02, 0.06]\n hi = [0.99, 0.96, 0.98]\n idx = [0, 1, 4]\n bins = [100, 100, 300]\n label = ['psfmag $r$', 'modelmag $u-g$', 'modelmag $i-z$']\n N = len(idx)\n fs = 5\n lsize = 20\n f = pl.figure(figsize=(N * fs, 2 * fs))\n pl.subplots_adjust(wspace=0.3)\n for i in range(N):\n x = X[:, idx[i]]\n y = Xcoadd[:, idx[i]]\n p = posts[:, idx[i]]\n ind = (y > -999) & (Xcoaddcov[:, idx[i]][:, idx[i]] < 10.)\n x = x[ind]\n y = y[ind]\n p = p[ind]\n ax = pl.subplot(2, N, i + 1)\n v = np.sort(x)\n mn, mx = v[np.int(lo[i] * x.shape[0])], v[np.int(hi[i] * x.shape[0])]\n hist2d(x, y, ax=ax, bins=bins[i], plot_contours=True,\n plot_datapoints=True)\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\n pl.xlabel('Single Epoch ' + label[i], fontsize=lsize)\n pl.xlim(mn, mx)\n pl.ylim(mn, mx)\n ax = pl.subplot(2, N, i + 4)\n hist2d(p, y, ax=ax, bins=bins[i], plot_contours=True,\n plot_datapoints=True)\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\n pl.xlim(mn, mx)\n pl.ylim(mn, mx)\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\n pl.xlabel('XD Posterior ' + label[i], fontsize=lsize)\n f.savefig(figname, bbox_inches='tight')","def conf_matrix_plotter(model, X_t_vec, y_t):\n fig, ax = plt.subplots()\n\n fig.suptitle(str(model))\n\n plot_confusion_matrix(model, X_t_vec, y_t, ax=ax, cmap=\"plasma\");","def plot_orig(self, conf, nn_in_trn, nn_out_trn, y_pred, a, vert_coef):\n plot_win=tk.Toplevel()\n plot_win.title(\"Predict data plot\")\n fig = Figure(figsize=(5, 4), dpi=80)\n ax=fig.add_subplot(111)\n ax.plot(nn_in_trn[:, 0], nn_out_trn[:, 0], label=\"Train data\")\n ax.plot(nn_in_trn[:, 0], y_pred[:, 0], label=\"Prediction data\")\n ax.set_xlabel('IN[1]')\n ax.set_ylabel('OUT[1]')\n fig.legend()\n canvas = FigureCanvasTkAgg(fig, master=plot_win)\n canvas.draw()\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)\n\n toolbar = NavigationToolbar2Tk(canvas, plot_win)\n toolbar.update()\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)\n lab1=tk.Label(plot_win,width=35, text=\"Model configuration\"+str(conf))\n lab1.pack()\n lab2=tk.Label(plot_win,width=35, text=\"Loss= \" + str(round(a,4))+ \" %\")\n lab2.pack()\n plot_win.geometry(f'+{self.winfo_x()+self.winfo_width()+20}+{self.winfo_y() + vert_coef}')","def plot_results(self):\n [m, s] = self.run_model()\n barM = m.x[2:8]\n barS = s.x[2:8]\n T1vec = self.T1_extraction(self.subj)\n for i in T1vec:\n T1vec[T1vec == i] = int(i)\n T1vec = T1vec[2:8]\n barWidth = 25\n r2 = [x + barWidth for x in T1vec]\n plt.grid(b=True, linewidth=0.2)\n plt.bar(\n T1vec, barM, color=\"b\", width=barWidth, edgecolor=\"white\", label=\"Motor\"\n )\n plt.bar(r2, barS, color=\"r\", width=barWidth, edgecolor=\"white\", label=\"Sensory\")\n plt.xlabel(\"T1\", fontweight=\"bold\")\n plt.ylabel(\"Partial contribution\", fontweight=\"bold\")\n plt.legend()\n plt.title(\n \"Partial contribution of cortical layers to motor and sensory operations\"\n )\n plt.show()\n return barM, barS, T1vec","def diff_plot(targets, predictions, filename, remove_outliers=False):\n\tif remove_outliers:\n\t\tindices = np.where(np.logical_not(np.logical_or(np.abs(predictions) > 10 * np.abs(targets), np.abs(predictions) < np.abs(targets) / 10.0)))\n\t\ttargets = targets[indices]\n\t\tpredictions = predictions[indices]\n\n\tif targets.shape[0] != 0:\n\t\tfig, ax = plt.subplots()\n\t\tfig.suptitle(str(targets.shape[0]) + ' samples, R2: ' + str(r2(targets, predictions)), fontsize=12)\n\t\taxes = plt.gca()\n\t\taxes.set_ylim(np.min(predictions), np.max(predictions))\n\t\taxes.set_xlim(np.min(targets), np.max(targets))\n\t\tax.scatter(targets, predictions, edgecolors=(0, 0, 0))\n\t\tax.set_xlabel('Targets')\n\t\tax.set_ylabel('Predictions')\n\t\tax.plot([targets.min(), targets.max()], [targets.min(), targets.max()], 'k--', lw=4)\n\t\tplt.savefig(filename)\n\t\tplt.close()","def convergence_plot(self, varying, savename = False):\n assert(varying == \"Mx\" or varying == \"My\" or varying == \"Both\") \n self._colors = [\"red\", \"green\", \"black\", \"orange\"]\n self._powers = [2] # Power used in the convergence plot. \n\n # Assert that the savename variable is of the correct format.\n if (varying == \"Mx\" or varying == \"My\") and savename:\n assert(type(savename) is list and len(savename) == 4)\n elif savename:\n assert(isinstance(savename, str))\n\n if varying == \"Mx\":\n self._constant_list = [10, 100, pow(10, 3), pow(10, 4)] # Constant values in plots. \n maximum = 2**7 # Maximum limit of Mx.\n elif varying == \"My\":\n self._constant_list = [10, 100, pow(10, 3), pow(10, 4)] # Constant values in plots. \n maximum = 2**7 # Maximum limit of My.\n elif varying == \"Both\":\n maximum = 2**10 # Maximum limit of My and Mx. \n self._powers = [1] # Power used in the convergence plot. \n\n varying_list = 2 ** np.arange(1, np.log(maximum)/np.log(2)+1, dtype = int)\n if varying == \"Both\":\n self._discrete_error = np.zeros(len(varying_list))\n for i, m in enumerate(varying_list):\n Usol, xv, yv = self.num_solution_Mx_My(Mx = m, My = m)\n analsol = self.analytic_solution(xv, yv)\n self._discrete_error[i] = e_l(Usol, analsol)\n if savename:\n self.plot_plots(varying_list, varying_list, savename=savename)\n else: \n self.plot_plots(varying_list, varying_list)\n elif varying:\n for j, constant in enumerate(self._constant_list):\n self._discrete_error = np.zeros(len(varying_list))\n for i, m in enumerate(varying_list):\n if varying == \"Mx\":\n Usol, xv, yv = self.num_solution_Mx_My(Mx = m, My = constant)\n elif varying == \"My\":\n Usol, xv, yv = self.num_solution_Mx_My(Mx = constant, My = m)\n\n analsol = self.analytic_solution(xv, yv)\n self._discrete_error[i] = e_l(Usol, analsol)\n if savename:\n self.plot_plots(varying_list, constant, savename=savename[j])\n else: \n self.plot_plots(varying_list, constant)","def plot(self):\n y = self.projection\n mpl.scatter(y[:, 0], y[:, 1], c=self.data_class)\n mpl.show()","def plot(self) -> None:\n cw_l2_data_list = list(); cw_linf_data_list = list()\n\n for model in self.model_list:\n cw_l2_data_list.append(joblib.load(model + \"/stat/mse-rmse-si-mae-cw_l2_1.pkl\"))\n\n cw_l2_attack = list(zip(self.model_list, cw_l2_data_list))\n\n for model in self.model_list:\n cw_linf_data_list.append(joblib.load(model + \"/stat/mse-rmse-si-mae-cw_inf_1.pkl\"))\n\n cw_linf_attack = list(zip(self.model_list, cw_linf_data_list))\n\n # RMSE v.s. MAE over change budget\n # There will be one graph for each manipulation\n # CW_L2 ATTACK\n for datum in cw_l2_attack:\n ran_color_list = self._random_color_picker(2)\n fig, axis_1 = plt.subplots()\n\n # Generate x_axis\n x_axis = list()\n for key in datum[1]:\n if float(key) not in x_axis:\n x_axis.append(float(key))\n\n x_axis.sort()\n\n # Sort data in datum[1]\n data_dict = self._sort_dict(x_axis, datum[1])\n\n # PLOT RMSE ON AXIS 1\n # Generate y_axis ticks for RMSE\n rmse_values = list()\n for key in data_dict:\n rmse_values.append(data_dict[key][\"rmse\"])\n\n # Generate 10 ticks for the y_axis\n y_axis_ticks = np.linspace(0.0, 0.6, num=10, endpoint=True)\n\n # Plot RMSE\n axis_1.plot(x_axis, rmse_values, color=ran_color_list[0], linestyle=\"solid\")\n axis_1.set_xlabel(\"Perturbation Budget\")\n axis_1.set_ylabel(\"Root Mean Squared Error (RMSE)\", color=ran_color_list[0])\n axis_1.set_yticks(y_axis_ticks)\n \n for tick_label, tick_line in zip(axis_1.get_yticklabels(), axis_1.get_yticklines()):\n tick_label.set_color(ran_color_list[0])\n tick_line.set_color(ran_color_list[0])\n\n # PLOT MAE ON AXIS 2\n axis_2 = axis_1.twinx()\n\n # Generate y-axis ticks for MAE\n mae_values = list()\n for key in data_dict:\n mae_values.append(data_dict[key][\"mae\"])\n\n\n # Plot MAE\n axis_2.plot(x_axis, mae_values, color=ran_color_list[1], linestyle=\"solid\")\n axis_2.set_ylabel(\"Mean Absolute Error (MAE)\", color=ran_color_list[1])\n axis_2.set_yticks(y_axis_ticks)\n \n for tick_label, tick_line in zip(axis_2.get_yticklabels(), axis_2.get_yticklines()):\n tick_label.set_color(ran_color_list[1])\n tick_line.set_color(ran_color_list[1])\n\n model_tag = datum[0].split(\"/\"); model_tag = model_tag[-1]\n plt.savefig(self.save_path + \"/{}_rmse-and-mae-as-perturbation-budget-increases-for-cw_l2-attack-on-model-{}.png\".format(self.plot_name, model_tag), \n bbox_inches=\"tight\")\n plt.close()\n\n # CW_Linf ATTACK\n for datum in cw_linf_attack:\n ran_color_list = self._random_color_picker(2)\n fig, axis_1 = plt.subplots()\n\n # Generate x_axis\n x_axis = list()\n for key in datum[1]:\n if float(key) not in x_axis:\n x_axis.append(float(key))\n\n x_axis.sort()\n\n # Sort data in datum[1]\n data_dict = self._sort_dict(x_axis, datum[1])\n\n # PLOT RMSE ON AXIS 1\n # Generate y_axis ticks for RMSE\n rmse_values = list()\n for key in data_dict:\n rmse_values.append(data_dict[key][\"rmse\"])\n\n # Plot RMSE\n axis_1.plot(x_axis, rmse_values, color=ran_color_list[0], linestyle=\"solid\")\n axis_1.set_xlabel(\"Perturbation Budget\")\n axis_1.set_ylabel(\"Root Mean Squared Error (RMSE)\", color=ran_color_list[0])\n axis_1.set_yticks(y_axis_ticks)\n\n for tick_label, tick_line in zip(axis_1.get_yticklabels(), axis_1.get_yticklines()):\n tick_label.set_color(ran_color_list[0])\n tick_line.set_color(ran_color_list[0])\n\n # PLOT MAE ON AXIS 2\n axis_2 = axis_1.twinx()\n\n # Generate y-axis ticks for MAE\n mae_values = list()\n for key in data_dict:\n mae_values.append(data_dict[key][\"mae\"])\n\n # Plot MAE\n axis_2.plot(x_axis, mae_values, color=ran_color_list[1], linestyle=\"solid\")\n axis_2.set_ylabel(\"Mean Absolute Error (MAE)\", color=ran_color_list[1])\n axis_2.set_yticks(y_axis_ticks)\n \n for tick_label, tick_line in zip(axis_2.get_yticklabels(), axis_2.get_yticklines()):\n tick_label.set_color(ran_color_list[1])\n tick_line.set_color(ran_color_list[1])\n \n model_tag = datum[0].split(\"/\"); model_tag = model_tag[-1]\n plt.savefig(self.save_path + \"/{}_rmse-and-mae-as-perturbation-budget-increases-for-cw_linf-attack-on-model-{}.png\".format(self.plot_name, model_tag),\n bbox_inches=\"tight\")\n plt.close()\n \"RMSE and MAE as Perturbation Budget increases for CW_Linf attack on model {}\".format(model_tag)\n \n # Scattter Index over the change budget\n # All the manipulations will be put on the same graph.\n # CW_L2 ATTACK\n plt.figure()\n plt.xlabel(\"Perturbation Budget\"); plt.ylabel(\"Scatter Index\")\n ran_color_list = self._random_color_picker(len(cw_l2_attack)); i = 0\n\n # Find maximum scatter index value\n scatter_values = list()\n for datum in cw_l2_attack:\n for key in datum[1]:\n scatter_values.append(datum[1][key][\"scatter_index\"])\n\n # Generate y_axis ticks; generate 10 ticks\n y_axis_ticks = np.linspace(0.0, float(Decimal(str(max(scatter_values))) + Decimal(\"0.1\")), num=10, endpoint=True)\n plt.yticks(y_axis_ticks)\n\n # Generate x_axis\n x_axis = list()\n for datum in cw_l2_attack:\n for key in datum[1]:\n if float(key) not in x_axis:\n x_axis.append(float(key))\n\n x_axis.sort()\n\n formal_names = FormalNameMap()\n for datum in cw_l2_attack:\n values = list()\n data_dict = self._sort_dict(x_axis, datum[1])\n for key in data_dict:\n values.append(data_dict[key][\"scatter_index\"])\n\n # Append values to the plot\n line_name = datum[0].split(\"/\"); line_name = line_name[-1]\n formal_name = formal_names.getformalname(line_name) if formal_names.hasname(line_name) else line_name\n if \"vanilla\" in line_name:\n plt.plot(x_axis, values, color=ran_color_list[i], linewidth=3, linestyle=self._random_linestyle(), label=formal_name)\n\n else:\n plt.plot(x_axis, values, color=ran_color_list[i], linestyle=self._random_linestyle(), label=formal_name)\n \n i += 1\n\n plt.legend()\n plt.savefig(self.save_path + \"/{}_scatter-index-as-perturbation-budget-increases-for-cw_l2-attack.png\".format(self.plot_name),\n bbox_inches=\"tight\")\n plt.close()\n\n # CW_Linf ATTACK\n plt.figure()\n plt.xlabel(\"Perturbation Budget\"); plt.ylabel(\"Scatter Index\")\n ran_color_list = self._random_color_picker(len(cw_linf_attack)); i = 0\n\n # Find maximum scatter index value\n scatter_values = list()\n for datum in cw_linf_attack:\n for key in datum[1]:\n scatter_values.append(datum[1][key][\"scatter_index\"])\n\n # Generate y_axis ticks; generate 10 ticks\n y_axis_ticks = np.linspace(0.0, float(Decimal(str(max(scatter_values))) + Decimal(\"0.1\")), num=10, endpoint=True)\n plt.yticks(y_axis_ticks)\n\n # Generate x_axis\n x_axis = list()\n for datum in cw_l2_attack:\n for key in datum[1]:\n if float(key) not in x_axis:\n x_axis.append(float(key))\n\n x_axis.sort()\n\n formal_names = FormalNameMap()\n for datum in cw_linf_attack:\n values = list()\n data_dict = self._sort_dict(x_axis, datum[1])\n for key in data_dict:\n values.append(data_dict[key][\"scatter_index\"])\n\n # Append values to the plot\n line_name = datum[0].split(\"/\"); line_name = line_name[-1]\n formal_name = formal_names.getformalname(line_name) if formal_names.hasname(line_name) else line_name\n if \"vanilla\" in line_name:\n plt.plot(x_axis, values, color=ran_color_list[i], linewidth=3, linestyle=self._random_linestyle(), label=formal_name)\n\n else: \n plt.plot(x_axis, values, color=ran_color_list[i], linestyle=self._random_linestyle(), label=formal_name)\n \n i += 1\n\n plt.legend()\n plt.savefig(self.save_path + \"/{}_scatter-index-as-perturbation-budget-increases-for-cw_linf-attack.png\".format(self.plot_name),\n bbox_inches=\"tight\")\n plt.close()","def plot_compare(benchmark_portvals,\n manual_strategy_portvals,\n strategy_learner_portval):\n final_df = pd.concat([benchmark_portvals, manual_strategy_portvals, strategy_learner_portval], axis=1)\n final_df.columns = ['Normalized Benchmark Portfolio Value',\n 'Normalized Manual Strategy Portfolio Value',\n 'Normalized Strategy Learner Portfolio Value']\n # print(final_df)\n # Plot final dataframe\n title = \"Strategy Learner vs Manual Strategy\"\n xlabel = \"Date\"\n ylabel = \"Portfolio Value\"\n \"\"\"Plot stock prices with a custom title and meaningful axis labels.\"\"\"\n ax = final_df.plot(title=title, fontsize=12, color=['g', 'r', 'b'], figsize=(10, 6))\n ax.set_xlabel(xlabel)\n ax.set_ylabel(ylabel)\n plt.axhline(y=1., color='m', linestyle=':')\n plt.show()\n return None","def problemTwo(self):\n # Initialize plot figure\n plot_2 = plt.figure(figsize=(18, 20 ))\n plot_2.subplots_adjust(left=.08, right=.97, top=.97, bottom=.07)\n mv = plot_2.add_subplot(1, 1, 1)\n plt.tick_params(labelsize=20)\n mv.set_xlabel('$\\\\frac{(y-y_o)}{D}$', fontsize=36)\n mv.set_ylabel('$\\\\frac{u(y)}{U_{\\infty}}$', fontsize=36)\n mv.grid(linewidth=1, color='gray', linestyle='--')\n # Get plot data from each file\n for file_loc in self.filenames:\n file = os.path.basename(file_loc).replace('.csv', '')\n index = self.filenames.index(file_loc)\n if 'calibration' not in file:\n self.hot_vel = self.data[file]['hot vel'].tolist()\n self.pitot_vel = self.data[file]['pitot vel'].tolist()\n self.y_pos = self.data[file]['y pos'].tolist()\n # Calc the v_inf for the hotwire and pitot velocity profiles\n v_inf_hot = statistics.mean([sum(self.hot_vel[:6])/len(self.hot_vel[:6]), sum(self.hot_vel[-6:])/len(self.hot_vel[-6:])])\n v_inf_pitot = statistics.mean([sum(self.pitot_vel[:6])/len(self.pitot_vel[:6]), sum(self.pitot_vel[-6:])/len(self.pitot_vel[-6:])])\n # Normalize velocity to the freestream velocity\n hot_nondim = [i/v_inf_hot for i in self.hot_vel]\n pitot_nondim = [i/v_inf_pitot for i in self.pitot_vel]\n # Normalize the y position with cylinder diameter\n y0_hot = self.y_pos[hot_nondim.index(min(hot_nondim))]\n y0_pitot = self.y_pos[pitot_nondim.index(min(pitot_nondim))]\n y_pos_nondim_hot = [(i-y0_hot)/self.cylinder_diam for i in self.y_pos]\n y_pos_nondim_pitot = [(i - y0_pitot) / self.cylinder_diam for i in self.y_pos]\n # Plot the mean velocity\n mv.plot(y_pos_nondim_hot, hot_nondim, color=self.plot_color[index], label=f'Hotwire @ {file}mm', linewidth=3)\n mv.plot(y_pos_nondim_pitot, pitot_nondim, color=self.plot_color[index], label=f'Pitot @ {file}mm', linestyle='--', linewidth=2)\n mv.legend(loc='lower right', fontsize=22)\n plot_2.savefig(os.path.join(os.getcwd(), r'plots\\prob2'))\n plt.draw()","def compare(self, model, u_model, obs, u_obs, bprop, label='', plot=False):\n self.debug.start_function('compare')\n pyprint.check_same_length(model, obs, 'model and obs arrays')\n pyprint.check_same_length(u_model, u_obs, 'u_model and u_obs arrays')\n\n weight = self.mcmc_version.weights[bprop]\n inv_sigma2 = 1 / (u_model ** 2 + u_obs ** 2)\n lh = -0.5 * weight * ((model - obs) ** 2 * inv_sigma2\n + np.log(2 * np.pi / inv_sigma2))\n self.debug.print_(f'lhood breakdown: {label} {lh}')\n\n if plot:\n self.plot_compare(model=model, u_model=u_model, obs=obs,\n u_obs=u_obs, bprop=label)\n self.debug.end_function()\n return lh.sum()","def psfminusmodel_plot(epoch, model, features, filters, figname, fgal=0.5,\n idx=-1):\n # fetch Stripe 82 data\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\n filters, use_single=False)\n\n # unpickle the XD model\n if type(model) == str: \n f = open(model, 'rb')\n model = cPickle.load(f)\n f.close()\n\n fs = 5\n Nbins = [50, 50, 50]\n lsize = 20\n mags = [19.5, 20.5, 21.5]\n dlt = [0.15, 0.15, 0.15]\n f = pl.figure(figsize=(3 * fs, fs))\n pl.subplots_adjust(wspace=0.3)\n for i in range(len(mags)):\n ind = (Xcoadd[:, idx] < 0.03) & (Xcoadd[:, 0] > mags[i] - dlt[i])\n ind = ind & (Xcoadd[:, 0] <= mags[i] + dlt[i])\n\n x = X[ind]\n xc = Xcov[ind]\n\n a, m, v = model.posterior(x, xc)\n posts = np.zeros_like(x)\n for j in range(x.shape[0]):\n posts[j] = np.median(model.sample(a[j], m[j], v[j], size=1000),\n axis=0)\n\n ax = pl.subplot(1, 3, i + 1)\n h, b = np.histogram(x[:, idx], Nbins[i])\n d = (b[1] - b[0]) / 2.\n b = np.append([b[0] - d], b[:-1] + d)\n h = np.append([1.0], h)\n pl.plot(b, h, drawstyle='steps-mid', linestyle='dotted',\n color='k', lw=2)\n h, b = np.histogram(posts[:, idx], Nbins[i])\n d = (b[1] - b[0]) / 2.\n b = np.append([b[0] - d], b[:-1] + d)\n h = np.append([1.0], h)\n pl.plot(b, h, drawstyle='steps-mid', color='k', lw=2)\n pl.xlabel('psfmag - modelmag $r$', fontsize=lsize)\n pl.ylabel('counts', fontsize=lsize)\n ax.text(0.95, 0.95, '$r=%0.1f$' % mags[i], fontsize=lsize, ha='right',\n va='top', transform=ax.transAxes)\n pl.xlim(-0.1, 0.2)\n f.savefig(figname, bbox_inches='tight')","def plot(self):\n pass","def plot(self):\n\t\tself.plotOfSpect().plot()","def simPlots_comb(loadFile, axes, drug1, drug2):\n # Read model\n M = drugInteractionModel(loadFile, drug1=drug1, drug2=drug2, fit=False)\n\n drug1 += r\" ($\\mu$M)\"\n drug2 += r\" ($\\mu$M)\"\n\n dfplot = pd.DataFrame()\n dfplot[\"confl\"] = M.phase.flatten()\n dfplot[\"death\"] = M.green.flatten()\n dfplot[\"time\"] = np.tile(M.timeV, M.X1.size)\n dfplot[drug1] = np.round(np.repeat(M.X1, M.timeV.size), decimals=1)\n dfplot[drug2] = np.round(np.repeat(M.X2, M.timeV.size), decimals=1)\n\n ddd = dfplot.loc[dfplot[\"time\"] == 72.0, :]\n ddd = ddd.groupby([drug1, drug2, \"time\"]).mean().reset_index()\n confldf = ddd.pivot(drug1, drug2, \"confl\")\n\n sns.heatmap(confldf, ax=axes[0], vmin=0.0, square=True, xticklabels=1)\n axes[0].set_title(\"Phase\")\n sns.heatmap(ddd.pivot(drug1, drug2, \"death\"), ax=axes[3], vmin=0.0, square=True, xticklabels=1)\n axes[3].set_title(\"Annexin V\")\n\n confl = confldf.to_numpy()\n confl /= confl[0, 0]\n confl = 1.0 - confl\n\n assert np.all(confl <= 1.0)\n\n additive = (confl[:, 0][:, None] + confl[0, :][None, :]) - np.outer(confl[:, 0], confl[0, :])\n\n assert np.all(additive <= 1.0)\n\n confldf.iloc[:, :] = confl - additive\n\n sns.heatmap(confldf, ax=axes[1], cmap=\"PiYG\", vmin=-0.5, vmax=0.5, square=True, xticklabels=1)\n axes[1].set_title(\"Just Viability\")\n\n return confldf","def inner_PlotDistrifun():\r\n \r\n font = {'family': 'serif',\r\n 'color': 'darkred',\r\n 'weight': 'normal',\r\n 'size': 16}\r\n\r\n Nmax = 100\r\n bins = np.linspace(0, Nmax, Nmax+1)\r\n nList = np.linspace(0, Nmax, Nmax+1, dtype = int)\r\n\r\n y_location = self.spinBox_PixelY.value()\r\n x_location = self.spinBox_PixelX.value()\r\n\r\n # get pixel intensity data\r\n Array1 = self.APP_dataprocess.PixelData(y_location, x_location)\r\n Array2 = Array1\r\n g2 = G2(Array1, Array2)\r\n print(\"g2 is:\", g2)\r\n\r\n arr = []\r\n rv = poisson(self.firstOrdImaging[y_location, x_location])\r\n for num in range(0,40):\r\n arr.append(rv.pmf(num))\r\n\r\n ax = fig.add_subplot(111)\r\n\r\n try:\r\n ax.cla()\r\n #print(\"clear self.cbar !\")\r\n except:\r\n pass\r\n #print(\"fail to clear self.cbar !\")\r\n \r\n ax.hist(Array1 , bins, normed=True, label = \"Data distribution\") \r\n ax.plot(nList, BoseEinstein(self.firstOrdImaging[y_location, x_location], Nmax), label =\"BoseEinstein distribution\")\r\n ax.plot(arr, linewidth=2.0, label =\"Possion distribution\")\r\n ax.set_title(\"Pixel Position({},{}); <$I$>:{}\".format(x_location , y_location, self.firstOrdImaging[y_location, x_location]), fontdict=font)\r\n \r\n ax.text(22, .08, r\"g2:{}\".format(g2), fontdict=font)\r\n ax.legend() \r\n \r\n fig.savefig('PixelPosition({},{})PhotDist.eps'.format(x_location , y_location), format='eps', dpi=300)\r\n plt.close()","def plot(self):\n if self.tabWidget.count() == 0:\n return\n\n # Error if not enough slabs\n plotType = str(self.plotOptions.getPlotType()) \n if len(self.selectedVars) < 2 and self.requiresTwoSlabs(plotType):\n self.showError('Error Message to User', 'Vector, Scatter, Meshfill or XvsY plots \\nmust have two data variables. The data \\nvariables must be selected in the \\n\"Defined Variables\" window.')\n return\n\n # Create & Update the graphics method / CDATCell vistrails modules\n # *** IMPORTANT ***\n # Everytime plot is pressed, this will create a new Graphics Method and\n # CDATCell Module. Instead it should ONLY create a new graphics method\n # and CDATCell module if the variable isn't already connected to an\n # existing Graphics Method / CDATCell module. This results in plots \n # being plotted multiple times.\n axisList = self.tabWidget.currentWidget()\n self.emit(QtCore.SIGNAL('createModule'), gm_name)\n self.emit(QtCore.SIGNAL('createModule'), cdatcell_name) \n self.setVistrailsGraphicsMethod() \n self.setVistrailsCDATCell()\n\n # Get the names of the 2 slabs so we can connect their modules in vistrails\n if self.requiresTwoSlabs(plotType):\n var1 = self.selectedVars[-1].id\n var2 = self.selectedVars[-2].id\n else:\n var1 = self.currentTabName()\n var2 = None\n\n # Emit signal to GuiController to connect ports and plot\n self.emit(QtCore.SIGNAL('plot'), var1, var2)\n\n # If a quickplot is plotted, define current variable under 'quickplot'\n if (self.currentTabName() == 'quickplot'):\n var = self.getUpdatedVar()\n self.emit(QtCore.SIGNAL('plotPressed'), axisList.getFile(), var)\n\n # Record plot teaching commands\n self.recordPlotTeachingCommand()","def visualize_data(data):\n\n # Instantiate a PCA object for the sake of easy visualisation\n pca = PCA(n_components=2)\n\n # Fit and transform x to visualise inside a 2D feature space\n x_vis = pca.fit_transform(data[data.columns[:-1]])\n y = data['Tumor'].as_matrix()\n\n # Plot the original data\n # Plot the two classes\n palette = sns.color_palette()\n\n plt.scatter(x_vis[y == 0, 0], x_vis[y == 0, 1], label=\"Normal\", alpha=0.5,\n edgecolor=ALMOST_BLACK, facecolor=palette[0], linewidth=0.15)\n plt.scatter(x_vis[y == 1, 0], x_vis[y == 1, 1], label=\"Tumor\", alpha=0.5,\n edgecolor=ALMOST_BLACK, facecolor=palette[2], linewidth=0.15)\n\n plt.legend()\n plt.show()","def plot_results(\n data,\n xparam,\n yparam,\n pxrange=None,\n pyrange=None,\n data_comp=None,\n data_bohlin=None,\n figsize=None,\n alpha=0.25,\n):\n # set the plotting defaults\n set_params(lw=2, fontsize=22)\n\n fig, ax = plt.subplots(figsize=figsize)\n\n if data_bohlin is not None:\n if (xparam in data_bohlin.colnames) and (yparam in data_bohlin.colnames):\n xcol = data_bohlin[xparam]\n xcol_unc = get_unc(xparam, data_bohlin)\n ycol = data_bohlin[yparam]\n ycol_unc = get_unc(yparam, data_bohlin)\n ax.errorbar(\n xcol,\n ycol,\n xerr=xcol_unc,\n yerr=ycol_unc,\n fmt=\"ro\",\n label=\"Bohlin (1978)\",\n alpha=alpha,\n )\n if data_comp is not None:\n xcol = data_comp[xparam]\n xcol_unc = get_unc(xparam, data_comp)\n ycol = data_comp[yparam]\n ycol_unc = get_unc(yparam, data_comp)\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\n # fmt='go', label='FUSE Comparisons', alpha=0.25)\n ax.plot(xcol, ycol, \"go\")\n # plot the error bars as ellipses illustrating the covariance\n corrs = get_corr(\n xparam,\n yparam,\n xcol,\n ycol,\n xcol_unc,\n ycol_unc,\n cterm=data_comp[\"AV\"].data,\n cterm_unc=data_comp[\"AV_unc\"].data,\n )\n plot_errorbar_corr(\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\"g\"\n )\n\n xcol = data[xparam].data\n xcol_unc = get_unc(xparam, data)\n ycol = data[yparam].data\n ycol_unc = get_unc(yparam, data)\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\n # fmt='bo', label='FUSE Reddened', alpha=0.25)\n ax.plot(xcol, ycol, \"bo\")\n\n # plot the error bars as ellipses illustrating the covariance\n if yparam[0:3] == \"CAV\":\n cparam = \"AV\"\n elif yparam[0:1] == \"C\":\n cparam = \"EBV\"\n else:\n cparam = \"AV\"\n\n corrs = get_corr(\n xparam,\n yparam,\n xcol,\n ycol,\n xcol_unc,\n ycol_unc,\n cterm=data[cparam].data,\n cterm_unc=data[cparam + \"_unc\"].data,\n )\n plot_errorbar_corr(\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\"b\", pellipse=True\n )\n\n ax.set_xlabel(format_colname(xparam))\n ax.set_ylabel(format_colname(yparam))\n\n # fit a line\n # params = np.polyfit(xcol, ycol, 1) # , w=1.0/ycol_unc)\n # line_init = models.Polynomial1D(1)\n line_init = models.Linear1D()\n fit = fitting.LinearLSQFitter()\n # fitter with outlier rejection\n or_fit = fitting.FittingWithOutlierRemoval(fit, sigma_clip, niter=3, sigma=3.0)\n\n # fit the data w/o weights\n fitted_model = fit(line_init, xcol, ycol)\n print(fitted_model)\n\n # fit the data using the uncertainties as weights\n fitted_model_weights = fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\n\n # fit the data using the uncertainties as weights\n fitted_model_weights_sc, mask_sc = or_fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\n data_sc = np.ma.masked_array(ycol, mask=mask_sc)\n\n # print(\"linear fit params [slope, y-intercept]\")\n # print(params)\n xlim = ax.get_xlim()\n x_mod = np.linspace(xlim[0], xlim[1])\n # y_mod = params[1] + x_mod * params[0]\n # ax.plot(x_mod, y_mod, \"k--\")\n\n ax.plot(x_mod, fitted_model(x_mod), \"k-\")\n ax.plot(x_mod, fitted_model_weights(x_mod), \"k--\")\n ax.plot(x_mod, fitted_model_weights_sc(x_mod), \"k.\")\n\n ax.plot(xcol, data_sc, 'ko')\n print(data_sc)\n\n if pxrange is not None:\n ax.set_xlim(pxrange)\n if pyrange is not None:\n ax.set_ylim(pyrange)\n\n return fig","def visualisation(self):\n plt.plot(self.x, self.y, 'o', label = 'Example data')\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\n plt.xlim([-1,1])\n plt.ylim([-1,1])","def showPlot2():\n raise NotImplementedError","def plotCompareScatterMatrix(scatterMatrix1, scatterMatrix2, fName=None):\n from matplotlib import pyplot\n\n diff = scatterMatrix1 - scatterMatrix2\n\n pyplot.imshow(diff.todense(), interpolation=\"nearest\")\n pyplot.grid(color=\"0.70\")\n pyplot.xlabel(\"From group\")\n pyplot.ylabel(\"To group\")\n pyplot.title(\"scattering XS difference \", fontsize=6)\n pyplot.colorbar()\n if fName:\n pyplot.savefig(fName)\n else:\n pyplot.show()\n\n pyplot.close()","def plot_in_outliers(data, mask, output):\n\n oc = 'lightskyblue'\n ic = 'navy'\n plt.figure(figsize=(15, 18))\n sns.set_style('white')\n x_all = pd.DataFrame({'PC1': data[:, 0], 'PC2': data[:, 1]})\n x_inliers = pd.DataFrame({'PC1': data[mask == 0, 0], 'PC2': data[mask == 0, 1]})\n x_outliers = pd.DataFrame({'PC1': data[mask == 1, 0], 'PC2': data[mask == 1, 1]})\n # Plot everything first\n g = sns.JointGrid(x='PC1', y='PC2', data=x_all, space=0)\n # Plot points\n sns.scatterplot(x_outliers.PC1, x_outliers.PC2, color=oc, ax=g.ax_joint,\n s=10, linewidth=0, label='Abnormal morphology')\n sns.scatterplot(x_inliers.PC1, x_inliers.PC2, color=ic, ax=g.ax_joint,\n s=10, linewidth=0, label='Normal morphology')\n # Plot kernel density estimates\n sns.distplot(x_outliers.PC1, kde=True, hist=False, color=oc, ax=g.ax_marg_x, axlabel=False)\n sns.distplot(x_inliers.PC1, kde=True, hist=False, color=ic, ax=g.ax_marg_x, axlabel=False)\n sns.distplot(x_outliers.PC2, kde=True, hist=False, color=oc, ax=g.ax_marg_y,\n vertical=True, axlabel=False)\n sns.distplot(x_inliers.PC2, kde=True, hist=False, color=ic, ax=g.ax_marg_y,\n vertical=True, axlabel=False)\n fig = plt.gcf()\n fig.savefig(output, dpi=150, bbox_inches='tight')\n fig.clf()\n plt.close(fig)","def fiducial_comparison():\n \n # observed gd1\n g = Table(fits.getdata('/home/ana/projects/GD1-DR2/output/gd1_members.fits'))\n \n # fiducial model\n wangle = 180*u.deg\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\n xi, eta = pk['xi'], pk['eta']\n \n plt.close()\n fig, ax = plt.subplots(2,1,figsize=(7,6), sharex=True)\n \n plt.sca(ax[0])\n plt.scatter(g['phi1']+40, g['phi2'], s=g['pmem']*2, c=g['pmem'], cmap=mpl.cm.binary, vmin=0.5, vmax=1.1, rasterized=True)\n \n plt.ylabel('$\\phi_2$ [deg]')\n plt.text(0.05, 0.9, 'Most likely GD-1 members', transform=plt.gca().transAxes, va='top', fontsize=17)\n plt.xlim(-20,20)\n plt.ylim(-10,10)\n plt.gca().set_aspect('equal')\n \n plt.sca(ax[1])\n plt.plot(xi.wrap_at(wangle), eta, 'o', mec='none', color=mpl.cm.Blues(0.9), ms=5)\n \n plt.xlabel('$\\phi_1$ [deg]')\n plt.ylabel('$\\phi_2$ [deg]')\n plt.text(0.05, 0.9, 'Simulated GD-1\\n0.5 Gyr after subhalo flyby', transform=plt.gca().transAxes, va='top', fontsize=17)\n plt.ylim(-10,10)\n plt.gca().set_aspect('equal')\n \n plt.tight_layout()\n plt.savefig('../plots/fiducial_comparison.pdf')"],"string":"[\n \"def display_comparison(self, X_val, y_val):\\n import matplotlib.pyplot as plt\\n x = []\\n y = []\\n for model_tuple in self.model_list:\\n x.append(model_tuple[1])\\n y.append(model_tuple[0].score(X_val, y_val))\\n plt.scatter(x, y)\\n plt.show()\",\n \"def plot_compare(self, model, u_model, obs, u_obs, bprop, ax=None, title=False,\\n display=True, xlabel=False, legend=False):\\n # TODO: move to mcmc_plot?\\n fontsize = 12\\n markersize = 6\\n capsize = 3\\n n_sigma = 3\\n dx = 0.13 # horizontal offset of plot points\\n yscale = {'dt': 1.0, 'rate': 1.0,\\n 'fluence': 1e-6, 'peak': 1e-8, 'fper': 1e-9}.get(bprop)\\n ylabel = {'dt': r'$\\\\Delta t$',\\n 'rate': 'Burst rate',\\n 'fluence': r'$E_b$',\\n 'peak': r'$F_{peak}$',\\n 'fper': r'$F_p$'}.get(bprop, bprop)\\n y_units = {'dt': 'hr',\\n 'rate': 'day$^{-1}$',\\n 'fluence': r'$10^{-6}$ erg cm$^{-2}$',\\n 'peak': r'$10^{-8}$ erg cm$^{-2}$ s$^{-1}$',\\n 'fper': r'$10^{-9}$ erg cm$^{-2}$ s$^{-1}$'}.get(bprop)\\n if ax is None:\\n fig, ax = plt.subplots(figsize=(5, 4))\\n\\n epochs = np.array(self.obs.epoch)\\n x = epochs\\n\\n ax.errorbar(x=x - dx, y=model/yscale, yerr=n_sigma*u_model/yscale, ls='none', marker='o',\\n capsize=capsize, color='C3', label='Model', markersize=markersize)\\n ax.errorbar(x=x + dx, y=obs/yscale, yerr=n_sigma*u_obs/yscale, ls='none',\\n marker='o', capsize=capsize, color='C0', label='Observed',\\n markersize=markersize)\\n\\n ax.set_ylabel(f'{ylabel} ({y_units})', fontsize=fontsize)\\n ax.set_xticks(epochs)\\n\\n if xlabel:\\n ax.set_xticklabels([f'{year}' for year in epochs])\\n ax.set_xlabel('Epoch year', fontsize=fontsize)\\n else:\\n ax.set_xticklabels([])\\n\\n if title:\\n ax.set_title(ylabel, fontsize=fontsize)\\n if legend:\\n ax.legend()\\n plt.tight_layout()\\n if display:\\n plt.show(block=False)\",\n \"def model_visualization(model,X,y,classifier):\\n sns.set_context(context='notebook',font_scale=2)\\n plt.figure(figsize=(16,9))\\n from matplotlib.colors import ListedColormap\\n X_set, y_set = X, y\\n X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\\n plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha = 0.6, cmap = ListedColormap(('green', 'blue')))\\n plt.xlim(X1.min(), X1.max())\\n plt.ylim(X2.min(), X2.max())\\n for i, j in enumerate(np.unique(y_set)):\\n plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\\n color = ListedColormap(('turquoise', 'blue'))(i), label = j)\\n plt.title(\\\"%s Model Set\\\" %(model))\\n plt.xlabel('PC 1')\\n plt.ylabel('PC 2')\\n plt.legend()\\n plt.savefig('images/{0}.png'.format(model))\",\n \"def plot(model, samples):\\n # compute responsiblity values\\n resp = model.predict_proba(samples)\\n\\n # plot\\n plt.axis('equal')\\n plt.scatter(samples[:,0], samples[:,1], c=resp)\\n plt.show()\",\n \"def make_comparison_plot(\\n nu,\\n y_comp,\\n y_ref,\\n comp_label,\\n ref_label,\\n fig_title,\\n fig_path,\\n plot_type,\\n y_range=None,\\n comparison_range=None\\n):\\n if plot_type == \\\"sed\\\":\\n # set the axes labels for an SED plot\\n x_label = SED_X_LABEL\\n y_label = SED_Y_LABEL\\n deviation_label = SED_DEVIATION_LABEL\\n elif plot_type == \\\"tau\\\":\\n # set the axes labels for a tau plot\\n x_label = TAU_X_LABEL\\n y_label = TAU_Y_LABEL\\n deviation_label = TAU_DEVIATION_LABEL\\n else:\\n # set a custom y label, keep the x-axis in frequency\\n x_label = SED_X_LABEL\\n y_label = plot_type\\n deviation_label = f\\\"({plot_type} agnpy / {plot_type} ref.) - 1\\\"\\n # make the plot\\n fig, ax = plt.subplots(\\n 2,\\n sharex=True,\\n gridspec_kw={\\\"height_ratios\\\": [2, 1], \\\"hspace\\\": 0.05},\\n figsize=(8, 6),\\n )\\n\\n # plot the SEDs or TAUs in the upper panel\\n # plot the reference sed with a continuous line and agnpy sed with a dashed one\\n ax[0].loglog(nu, y_ref, marker=\\\".\\\", ls=\\\"-\\\", color=\\\"k\\\", lw=1.5, label=ref_label)\\n ax[0].loglog(\\n nu, y_comp, marker=\\\".\\\", ls=\\\"--\\\", color=\\\"crimson\\\", lw=1.5, label=comp_label\\n )\\n ax[0].set_ylabel(y_label)\\n ax[0].set_title(fig_title)\\n ax[0].legend(loc=\\\"best\\\")\\n if y_range is not None:\\n ax[0].set_ylim(y_range)\\n if comparison_range is not None:\\n ax[0].axvline(comparison_range[0], ls=\\\"--\\\", color=\\\"dodgerblue\\\")\\n ax[0].axvline(comparison_range[1], ls=\\\"--\\\", color=\\\"dodgerblue\\\")\\n ax[0].grid(ls=\\\":\\\")\\n\\n # plot the deviation in the bottom panel\\n deviation = y_comp / y_ref - 1\\n ax[1].axhline(0, ls=\\\"-\\\", color=\\\"darkgray\\\")\\n ax[1].axhline(0.2, ls=\\\"--\\\", color=\\\"darkgray\\\")\\n ax[1].axhline(-0.2, ls=\\\"--\\\", color=\\\"darkgray\\\")\\n ax[1].axhline(0.3, ls=\\\":\\\", color=\\\"darkgray\\\")\\n ax[1].axhline(-0.3, ls=\\\":\\\", color=\\\"darkgray\\\")\\n ax[1].set_ylim([-0.5, 0.5])\\n ax[1].semilogx(\\n nu,\\n deviation,\\n marker=\\\".\\\",\\n ls=\\\"--\\\",\\n color=\\\"crimson\\\",\\n lw=1.5,\\n label=deviation_label,\\n )\\n ax[1].set_xlabel(x_label)\\n ax[1].legend(loc=\\\"best\\\")\\n if comparison_range is not None:\\n ax[1].axvline(comparison_range[0], ls=\\\"--\\\", color=\\\"dodgerblue\\\")\\n ax[1].axvline(comparison_range[1], ls=\\\"--\\\", color=\\\"dodgerblue\\\")\\n\\n fig.savefig(f\\\"{fig_path}\\\")\\n # avoid RuntimeWarning: More than 20 figures have been opened.\\n plt.close(fig)\",\n \"def plot_dif_eq(self):\\n try:\\n self.canvas.get_tk_widget().pack_forget()\\n self.toolbar.pack_forget()\\n except AttributeError:\\n pass\\n\\n f = Figure(figsize=(8, 8), dpi=100)\\n p = f.add_subplot(111)\\n\\n p.plot(self.model.ex.x_coord_plot, self.model.ex.y_coord_plot, c = 'C6')\\n p.scatter(self.model.ex.x_coord, self.model.ex.y_coord, c = 'C6')\\n p.plot(self.model.eu.x_coord, self.model.eu.y_coord, marker='o')\\n p.plot(self.model.ieu.x_coord, self.model.ieu.y_coord, marker='o')\\n p.plot(self.model.rk.x_coord, self.model.rk.y_coord, marker='o')\\n\\n p.set_ylabel('y')\\n p.set_xlabel('x')\\n\\n p.legend(['Exact', 'EU', \\\"IEU\\\", \\\"RK\\\"])\\n p.set_title(\\\"Solutions\\\")\\n if max(self.model.ex.y_coord_plot) >= 1e5 or max(self.model.eu.y_coord) >= 1e5 \\\\\\n or max(self.model.ieu.y_coord) >= 1e5 or max(self.model.rk.y_coord) >= 1e5:\\n p.set_ylim([-100, 100])\\n\\n if min(self.model.ex.y_coord_plot) <= -1e5 or min(self.model.eu.y_coord) <= -1e5 \\\\\\n or min(self.model.ieu.y_coord) <= -1e5 or min(self.model.rk.y_coord) <= -1e5:\\n p.set_ylim([-100, 100])\\n\\n self.canvas = FigureCanvasTkAgg(f, self.f_left)\\n self.canvas.draw()\\n self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=False)\\n\\n self.toolbar = NavigationToolbar2Tk(self.canvas, self.f_left)\\n self.toolbar.update()\\n\\n self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=False)\",\n \"def model_comp_plot(id_model_list, filename):\\n\\taxes = plt.gca()\\n\\taxes.set_ylim(0, 10 * np.median([k['mse'] for i, k in enumerate(id_model_list)]))\\n\\tplt.plot([k['id'] for i, k in enumerate(id_model_list)], [k['mse'] for i, k in enumerate(id_model_list)], 'bo')\\n\\tplt.ylabel('Validation MSE')\\n\\tplt.xlabel('Model ID')\\n\\tplt.savefig(filename)\\n\\tplt.close()\",\n \"def plot_comparison(*, dates, vo, vo_denoised, position, model_data,\\n fig_size=(15, 5), font_size=12, label_size=14,\\n save_fig=False, write_path=None, deriv=1):\\n # Choose labels for plots (either for MF or SV)\\n if deriv == 0:\\n components = ['X_', 'Y_', 'Z_']\\n labels = [r'X (nT)', r'Y (nT)', r'Z (nT)']\\n elif deriv == 1:\\n components = ['dx_', 'dy_', 'dz_']\\n labels = [r'dX/dt (nT/yr)', r'dY/dt (nT/yr)', r'dZ/dt (nT/yr)']\\n colors = ['red', 'green', 'blue']\\n fig, ax = plt.subplots(1, 3, sharex=True, figsize=fig_size)\\n\\n for i in range(0, len(components)):\\n plt.subplot(1, 3, i+1)\\n plt.plot(dates, vo.filter(regex=components[i]+str(position).zfill(3)),\\n color='grey', linestyle='--', linewidth=2)\\n plt.plot(dates, vo_denoised.filter(\\n regex=components[i]+str(position).zfill(3)), color=colors[i],\\n linewidth=2)\\n plt.plot(dates, model_data.filter(\\n regex=components[i]+str(position).zfill(3)), color='black',\\n linewidth=2)\\n plt.ylabel(labels[i])\\n plt.xticks(fontsize=font_size)\\n plt.yticks(fontsize=font_size)\\n fig.text(0.5, 0.01, 'Date', ha='center', fontsize=label_size)\\n fig.text(0.05, 0.5, 'GVO ' + str(position), fontsize=label_size,\\n rotation='vertical')\\n if save_fig is True:\\n # Create the output directory if it does not exist\\n if not os.path.exists(write_path):\\n os.makedirs(write_path)\\n fpath = os.path.join(write_path, 'GVO_'+str(position).zfill(3) +\\\\\\n '.png')\\n plt.savefig(fpath, bbox_inches='tight')\\n plt.close()\",\n \"def compare(self, plot=False):\\n oldConditionData, newConditionData = self.runSimulations()\\n \\n #For now make print statements about each none matching data\\n conditionsBroken=[]\\n variablesFailed=[]\\n for i in range(len(oldConditionData)):\\n timeOld, dataListOld = oldConditionData[i]\\n timeNew, dataListNew = newConditionData[i]\\n\\n for variableOld, variableNew in zip(dataListOld, dataListNew):\\n if not curvesSimilar(timeOld.data, variableOld.data, timeNew.data, variableNew.data, 0.05):\\n if i not in conditionsBroken: conditionsBroken.append(i)\\n\\n if variableOld.species:\\n label = variableOld.species.molecule[0].toSMILES()\\n print \\\"Species profile for {0} does not match between the old model ({1}) and \\\\\\n the new model ({2}) in condition {3:d}.\\\".format(variableOld.species.molecule[0].toSMILES(),\\n variableOld.label, \\n variableNew.label,\\n i+1)\\n else:\\n label = variableOld.label\\n print \\\"{0} does not match between the old model and \\\\\\n the new model in condition {1:d}.\\\".format(variableOld.label, i+1)\\n\\n variablesFailed.append((self.conditions[i], label, variableOld, variableNew))\\n print ''\\n print 'The following reaction conditions were broken:'\\n print ''\\n for index in conditionsBroken:\\n print \\\"Condition {0:d}:\\\"\\n print str(self.conditions[index])\\n print ''\\n\\n if plot:\\n # Ignore Inerts\\n inertList = ['[Ar]','[He]','[N#N]','[Ne]']\\n for i in range(len(oldConditionData)):\\n time, dataList = oldConditionData[i]\\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\\n oldSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\\n\\n time, dataList = newConditionData[i]\\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\\n newSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\\n\\n # Name after the index of the condition\\n # though it may be better to name it after the actual conditions in T, P, etc\\n oldSpeciesPlot.comparePlot(newSpeciesPlot,filename='simulation_condition_{0}.png'.format(i+1))\\n\\n return variablesFailed\",\n \"def plot_model(self):\\n \\n plt.figure(figsize=[10,5])\\n \\n plt.scatter(self.receivers['recxs'],self.receivers['reczs'],marker='v')\\n if self.source['src_type']==4:\\n from obspy.imaging.beachball import beach\\n beach = beach(self.source['mt'], xy=(self.source['srcx'],self.source['srcz']), width=self.model_parameters['xmax']*0.05)\\n ax = plt.gca()\\n \\n ax.add_collection(beach) \\n ax.set_aspect(\\\"equal\\\")\\n \\n else:\\n plt.scatter(self.source['srcx'],self.source['srcz'],marker='*',color='r',s=200)\\n \\n plt.axhline(y=0,c='0.5')\\n plt.xlim(0,self.model_parameters['xmax'])\\n plt.ylim(self.model_parameters['zmax'],-0.1*self.model_parameters['zmax'])\\n \\n plt.xlabel('Distance (km)')\\n plt.ylabel('Depth (km)')\\n plt.grid()\\n plt.show()\",\n \"def generatePlot (self, Xdata_exp, Xdata_model, Ydata_exp, Ydata_model, Component_name):\\n \\n #self.clear_results_directory(results_dir)\\n \\n XaxisLabel = 'TCD Conversion [%]'\\n YaxisLabel = 'Product Yield [wt %]'\\n \\n self.drawplot(XaxisLabel, YaxisLabel, Xdata_exp, Xdata_model, Ydata_exp, Ydata_model, Component_name)\",\n \"def plot_and_compare(xs,ys, m,b):\\n\\n plt.scatter(xs, ys, color = 'blue')\\n\\n plt.plot(xs, (xs * m) + b, color = 'red')\",\n \"def test_plot_compare_no_ic(models):\\n model_compare = compare({\\\"Model 1\\\": models.model_1, \\\"Model 2\\\": models.model_2})\\n\\n # Drop column needed for plotting\\n model_compare = model_compare.drop(\\\"elpd_loo\\\", axis=1)\\n with pytest.raises(ValueError) as err:\\n plot_compare(model_compare)\\n\\n assert \\\"comp_df must contain one of the following\\\" in str(err.value)\\n assert \\\"['elpd_loo', 'elpd_waic']\\\" in str(err.value)\",\n \"def plotComparison2(x, nt, nx, c, phi, phiExact, methodName): \\n plt.plot(x, phiExact)\\n\\n plt.plot(x, phi, label=methodName)\\n plt.ylim([-0.2, 1.4])\",\n \"def plot(self):\\n h = .02\\n i=1\\n bags_X = self.bags_X\\n bags_y = self.bags_y\\n fig1 = plt.figure(figsize=(45, 9))\\n\\n \\n cm = plt.cm.RdBu\\n cm_bright = ListedColormap(['#FF0000', '#0000FF'])\\n \\n for model in self.models:\\n ax = plt.subplot(1, len(self.models) , i)\\n X = pd.DataFrame(bags_X[i-1])\\n y = pd.Series(bags_y[i-1])\\n x_min, x_max = X[X.columns[0]].min() - .5, X[X.columns[0]].max() + .5\\n y_min, y_max = X[X.columns[1]].min() - .5, X[X.columns[1]].max() + .5\\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\\n Z = np.array(model.predict(pd.DataFrame(np.c_[xx.ravel(), yy.ravel()], columns=X.columns)))\\n # print(Z[12])\\n Z = Z.reshape(xx.shape)\\n ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)\\n ax.scatter(X[X.columns[0]], X[X.columns[1]], c=y, cmap=cm_bright, edgecolors='k')\\n # size=[1000*w for w in self.weights[i-1]]\\n ax.set_xlim(xx.min(), xx.max())\\n ax.set_ylim(yy.min(), yy.max())\\n ax.set_xlabel(str(X.columns[0]))\\n ax.set_ylabel(str(X.columns[1]))\\n plt.title(\\\"Estimator \\\"+str(i))\\n i+=1\\n \\n fig2 = plt.figure(figsize=(9,9))\\n X = self.X\\n y = self.y\\n ax2 = plt.subplot(1,1,1)\\n x_min, x_max = X[X.columns[0]].min() - .5, X[X.columns[0]].max() + .5\\n y_min, y_max = X[X.columns[1]].min() - .5, X[X.columns[1]].max() + .5\\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\\n Z = np.array(self.predict(pd.DataFrame(np.c_[xx.ravel(), yy.ravel()], columns=X.columns)))\\n Z = Z.reshape(xx.shape)\\n ax2.contourf(xx, yy, Z, cmap=cm, alpha=.8)\\n # size=[1000*w for w in self.weights[i-2]]\\n ax2.scatter(X[X.columns[0]], X[X.columns[1]], c=y, cmap=cm_bright, edgecolors='k')\\n ax2.set_xlim(xx.min(), xx.max())\\n ax2.set_ylim(yy.min(), yy.max())\\n plt.title(\\\"Combined Decision Surface\\\")\\n \\n plt.tight_layout()\\n plt.show()\\n\\n return [fig1,fig2]\",\n \"def plot_volcano(self, labels=None):\\n cond1, cond2 = \\\"cond1\\\", \\\"cond2\\\"\\n if labels is None:\\n labels = [cond1, cond2]\\n\\n A = self.r1.df.loc[self.r1.gene_lists[\\\"all\\\"]]\\n B = self.r2.df.loc[self.r2.gene_lists[\\\"all\\\"]]\\n\\n if cond1 == cond2:\\n cond1 += \\\"(1)\\\"\\n cond2 += \\\"(2)\\\"\\n\\n pylab.clf()\\n pylab.plot(\\n A.log2FoldChange,\\n -np.log10(A.padj),\\n marker=\\\"o\\\",\\n alpha=0.5,\\n color=\\\"r\\\",\\n lw=0,\\n label=labels[0],\\n pickradius=4,\\n picker=True,\\n )\\n pylab.plot(\\n B.log2FoldChange,\\n -np.log10(B.padj),\\n marker=\\\"x\\\",\\n alpha=0.5,\\n color=\\\"k\\\",\\n lw=0,\\n label=labels[1],\\n pickradius=4,\\n picker=True,\\n )\\n\\n genes = list(A.index) + list(B.index)\\n pylab.grid(True)\\n pylab.xlabel(\\\"fold change\\\")\\n pylab.ylabel(\\\"log10 adjusted p-value\\\")\\n pylab.legend(loc=\\\"lower right\\\")\\n ax = pylab.gca()\\n\\n def onpick(event):\\n thisline = event.artist\\n self.event = event\\n label = thisline.get_label()\\n if label == cond1:\\n gene_name = A.index[event.ind[0]]\\n x1 = round(A.loc[gene_name].log2FoldChange, 1)\\n y1 = round(-np.log10(A.loc[gene_name].padj), 1)\\n try:\\n x2 = round(B.loc[gene_name].log2FoldChange, 1)\\n y2 = round(-np.log10(B.loc[gene_name].padj), 1)\\n except:\\n x2, y2 = None, None\\n else:\\n gene_name = B.index[event.ind[0]]\\n x1 = round(B.loc[gene_name].log2FoldChange, 1)\\n y1 = round(-np.log10(B.loc[gene_name].padj), 1)\\n try:\\n x2 = round(A.loc[gene_name].log2FoldChange, 1)\\n y2 = round(-np.log10(A.loc[gene_name].padj), 1)\\n except:\\n x2, y2 = None, None\\n\\n try:\\n if x2 is None:\\n ax.title.set_text(\\\"{} at pos [{},{}]\\\".format(gene_name, x1, y1))\\n else:\\n ax.title.set_text(\\\"{} at pos [{},{}] and [{},{}]\\\".format(gene_name, x1, y1, x2, y2))\\n except:\\n print(\\\"exception\\\")\\n ax.title.set_text(\\\"\\\")\\n pylab.draw()\\n\\n fig = pylab.gcf()\\n fig.canvas.mpl_connect(\\\"pick_event\\\", onpick)\",\n \"def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\\n\\n\\t#path_tsne = path_results + \\\"/Visualization/train/\\\" + str(args.step) + \\\"_2d.csv\\\"\\n\\t#data_frame = pd.read_csv(path_tsne)\\n\\t\\n\\tpath_maping = path_results + \\\"/Maping/\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"/\\\"\\n\\tfilename = path_maping + \\\"maping_\\\" + str(args.step) + \\\"_\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"_stick\\\" + str(args.stick) + \\\".png\\\"\\n\\n\\tprint(\\\"path_save maping\\\", path_maping)\\n\\n\\tif not os.path.exists(path_maping):\\n\\t\\tos.makedirs(path_maping)\\n\\n\\t#print(\\\"path_tsne\\\", path_tsne)\\n\\n\\tlabel_maping = np.array([10])\\n\\n\\tx_data = np.concatenate((x_data,signal_test),axis=0)\\n\\ty_data = np.concatenate((y_data,label_maping),axis=0)\\n\\n\\tprint(\\\"x_data concatenate\\\",x_data.shape)\\n\\tprint(\\\"y_data concatenate\\\",y_data.shape)\\n\\n\\tdata_frame = tsne_2d(x_data, y_data)\\n\\n\\t\\n\\t\\n\\tgroups = data_frame.groupby('label')\\n\\n\\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\\n\\n\\tfig = plt.figure(figsize=(20, 10))\\n\\tax = fig.add_subplot(111)\\n\\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\\n\\tfor name, group in groups:\\n\\t\\t\\n\\t\\tif cluster_names[name] == str(args.subject):\\n\\t\\t\\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\\n\\t\\telse:\\n\\t\\t\\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\\n\\n\\tax.legend(numpoints=1) #show legend with only 1 point\\n\\tplt.savefig(filename) #save the plot\",\n \"def plotComparison(x, nt, nx, c, phi, phiExact, methodName):\\n \\n plt.figure()\\n plt.plot(x, phiExact)\\n\\n plt.plot(x, phi)\\n plt.ylim([-0.2, 1.4])\\n plt.title(str(methodName)+\\\" scheme\\\\nExact vs Numerical solution \\\"\\\\\\n \\\"nt=\\\"+str(nt)+\\\", nx=\\\"+str(nx)+\\\"\\\\n\\\"\\n \\\"Courant number: \\\"+str(c))\\n plt.show()\",\n \"def plot_decision_boundary(model, X, y):\\r\\n \\r\\n x1_array, x2_array = np.meshgrid(np.arange(-4, 4, 0.01), np.arange(-4, 4, 0.01))\\r\\n grid_coordinates = np.c_[x1_array.ravel(), x2_array.ravel()]\\r\\n Z = model.predict(grid_coordinates)\\r\\n Z = Z.reshape(x1_array.shape)\\r\\n plt.contourf(x1_array, x2_array, Z, cmap=plt.cm.bwr)\\r\\n plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.bwr)\\r\\n plt.show()\",\n \"def plot_ppplot(obj1,sheet1,variable1,obj2,sheet2,variable2,title,opath):\\n p1 = np.percentile(obj1.me[sheet1][variable1],range(0,101,1))\\n p2 = np.percentile(obj2.me[sheet2][variable2],range(0,101,1))\\n p1c = np.cumsum(np.array(p1))/np.cumsum(np.array(p1)).max()\\n p2c = np.cumsum(np.array(p2))/np.cumsum(np.array(p2)).max()\\n fig = plt.figure(figsize=(8,8),dpi=120)\\n plt.scatter(p1c,p2c,color='#566c73',s=30)\\n plt.plot([0,1],[0,1],color='red',alpha=0.3)\\n plt.xlim(0,1)\\n plt.ylim(0,1)\\n plt.grid()\\n plt.xlabel(sheet1+'_'+variable1)\\n plt.ylabel(sheet2+'_'+variable2)\\n plt.title(title)\\n plt.savefig(opath+'.png')\\n plt.close()\",\n \"def main():\\n\\n if not os.path.exists( os.path.join(os.getcwd(), 'Plots') ):\\n os.mkdir('Plots')\\n\\n # Initialise the canvas and set aesthetics\\n canv = TCanvas(\\\"canv\\\", \\\"canv\\\", 800, 600)\\n canv.SetLogy()\\n gStyle.SetOptStat(0)\\n gStyle.SetOptTitle(0)\\n\\n # Initialise legend and set colours\\n leg_height = len(models) * 0.06 # make y-length of legend dependent on n_models\\n myLeg = TLegend(0.6, 0.9 - leg_height, 0.9, 0.9)\\n myLeg.SetTextSize(0.02)\\n\\n # Initialise histogram arrays\\n nJetHist = [None] * len(models)\\n jetPtHist = [None] * len(models)\\n leadJetPtHist = [None] * len(models)\\n metPtHist = [None] * len(models)\\n dPhiJJHist = [None] * len(models)\\n\\n # x-axis labels for plots\\n nJetLabel = \\\"#it{n}_{jet}\\\"\\n jetPtLabel = \\\"#it{p}_{T}^{jet}\\\"\\n leadJetPtLabel = \\\"#it{p}_{T}^{j_{1}}\\\"\\n metPtLabel = \\\"#it{E}_{T}^{miss}\\\"\\n dPhiJJLabel = \\\"#Delta#it{#phi}_{j_{1} j_{2}}\\\"\\n\\n # Initialise histograms here so I can use them later\\n for i, model in enumerate(models):\\n nJetHist[i] = TH1F(\\\"nJet\\\"+model, \\\"nJet dist \\\"+model, 30, 0, 29)\\n jetPtHist[i] = TH1F(\\\"jetPt\\\"+model, \\\"Jet pT dist \\\"+model, 30, 0, 3000)\\n leadJetPtHist[i] = TH1F(\\\"leadJetPt\\\"+model, \\\"Lead jet pT dist \\\"+model, 30, 0, 3000)\\n metPtHist[i] = TH1F(\\\"met\\\"+model, \\\"MET dist \\\"+model, 30, 0, 3000)\\n dPhiJJHist[i] = TH1F(\\\"dPhijj\\\"+model, \\\"DPhi dist \\\"+model, 20, -1*(pi+0.1), pi+0.1)\\n \\n\\n # Open root files, then draw individual histograms\\n for i, model in enumerate(models):\\n print Fore.MAGENTA + \\\"Running over model {0}/{1}.\\\".format(i+1, len(models))\\n openFile = TFile(files[i])\\n tree = openFile.Get(\\\"Events\\\")\\n nEntries = tree.GetEntries()\\n\\n # Initialise progress bar\\n widgets = [Percentage(), Bar('>'), ETA()]\\n pbar = ProgressBar(widgets = widgets, maxval = nEntries).start() \\n\\n for entry in xrange(nEntries):\\n treeEntry = tree.GetEntry(entry)\\n nJetHist[i].Fill(tree.nJet)\\n \\n for jet in xrange( len(tree.Jet_pt) ):\\n jetPtHist[i].Fill(tree.Jet_pt[jet])\\n\\n if len(tree.Jet_pt) > 0: leadJetPtHist[i].Fill(tree.Jet_pt[0])\\n metPtHist[i].Fill(tree.MET_pt)\\n\\n if len(tree.Jet_phi) >= 2:\\n deltaPhi = tree.Jet_phi[0] - tree.Jet_phi[1]\\n dPhiJJHist[i].Fill(deltaPhi) \\n\\n pbar.update(entry+1)\\n \\n pbar.finish()\\n\\n # Normalise histograms\\n nJetHist[i].Scale(1./nEntries)\\n jetPtHist[i].Scale(1./nEntries)\\n leadJetPtHist[i].Scale(1./nEntries)\\n metPtHist[i].Scale(1./nEntries)\\n dPhiJJHist[i].Scale(1./nEntries)\\n\\n # Draw individual histograms and save\\n drawIndivHistos(model, nJetHist[i], canv, myLeg, nJetLabel, \\\"nJet\\\", index=i)\\n drawIndivHistos(model, jetPtHist[i], canv, myLeg, jetPtLabel, \\\"jetPT\\\", index=i)\\n drawIndivHistos(model, leadJetPtHist[i], canv, myLeg, leadJetPtLabel, \\\"leadJetPT\\\", index=i)\\n drawIndivHistos(model, metPtHist[i], canv, myLeg, metPtLabel, \\\"MET\\\", index=i)\\n drawIndivHistos(model, dPhiJJHist[i], canv, myLeg, dPhiJJLabel, \\\"dPhi\\\", index=i)\\n \\n\\n # Draw histograms for different models overlaid\\n drawMultipleHistos(nJetHist, canv, myLeg, nJetLabel, \\\"nJet\\\")\\n drawMultipleHistos(jetPtHist, canv, myLeg, jetPtLabel, \\\"jetPT\\\")\\n drawMultipleHistos(leadJetPtHist, canv, myLeg, leadJetPtLabel, \\\"leadJetPT\\\")\\n drawMultipleHistos(metPtHist, canv, myLeg, metPtLabel, \\\"MET\\\")\\n drawMultipleHistos(dPhiJJHist, canv, myLeg, dPhiJJLabel, \\\"dPhi\\\")\",\n \"def plotting_data1(fitspath, dataset, combine_flux_file, bin_info_file):\\n\\n pdf_file = join(fitspath, 'line_ratio_plots.pdf')\\n pp = PdfPages(pdf_file)\\n\\n print(\\\"### combine_flux_file : \\\" + combine_flux_file)\\n fitted_data = asc.read(combine_flux_file)\\n\\n print(\\\"### bin_info_file : \\\" + bin_info_file)\\n bin_info_tab = asc.read(bin_info_file)\\n OII = fitted_data['OII_3727_Flux_Observed']\\n OIII5007 = fitted_data['OIII_5007_Flux_Observed']\\n H_BETA = fitted_data['HBETA_Flux_Observed']\\n binnum = fitted_data['N_stack']\\n ID = fitted_data['bin_ID']\\n print('binnum:', binnum, len(binnum))\\n\\n R23_composite = np.zeros(binnum.shape[0])\\n O32_composite = np.zeros(binnum.shape[0]) \\n for ii in range(len(binnum)):\\n R23_comp = np.log10((OII[ii] + (1.33 * OIII5007[ii]))/H_BETA[ii])\\n O32_comp = np.log10((1.33 * OIII5007[ii])/OII[ii])\\n print(R23_comp, O32_comp)\\n R23_composite[ii] = R23_comp\\n O32_composite[ii] = O32_comp\\n \\n R23_raw = bin_info_tab['logR23_avg']\\n O32_raw = bin_info_tab['logO32_avg']\\n binnum_raw = bin_info_tab['N_stack']\\n\\n if dataset != 'Grid':\\n for rr in range(len(binnum)):\\n if binnum[rr] == binnum_raw[rr]:\\n print('equal', binnum[rr], binnum_raw[rr])\\n\\n fig, ax_arr = plt.subplots()\\n ax_arr.scatter(R23_raw, R23_composite, marker='o', facecolor='none',\\n edgecolor='b', label='R23 Ratio: Voronoi Raw vs. Composite')\\n ax_arr.legend(loc=0)\\n ax_arr.set_title(dataset + ' Raw vs. Composite for R23')\\n for rr in range(len(ID)):\\n ax_arr.annotate(ID[rr], (R23_raw[rr], R23_composite[rr]))\\n ax_arr.set_xlabel(r'Raw log($R_{23}$)')\\n ax_arr.set_ylabel(r'Composite log($R_{23}$)')\\n ax_arr.plot([0.0, 1.3], [0.0, 1.3], 'k-')\\n \\n fig.savefig(pp, format='pdf')\\n\\n fig, ax_arr = plt.subplots()\\n ax_arr.scatter(O32_raw, O32_composite, marker='o', facecolor='none',\\n edgecolor='b', label='O32 Ratio: Voronoi Raw vs. Composite')\\n ax_arr.legend(loc=0)\\n ax_arr.set_title(dataset + 'Raw vs. Composite for O32')\\n for oo in range(len(ID)):\\n ax_arr.annotate(ID[oo], (O32_raw[oo], O32_composite[oo]))\\n ax_arr.set_xlabel(r'Raw log($O_{32}$)')\\n ax_arr.set_ylabel(r'Composite log($O_{32}$)')\\n\\n ax_arr.plot([-1, 1.2], [-1, 1.2], 'k-')\\n fig.savefig(pp, format='pdf')\\n\\n pp.close()\\n\\n fig.clear()\",\n \"def plot_coefs(results):\\n coefs_noisy = pd.concat([\\n arr_to_df(results['obj_noisy'], n_arr, 'obj'),\\n vec_to_df(results['dist_obj'], n_arr, 'obj'),\\n arr_to_df(results['pos_noisy'], n_arr, 'pos'),\\n vec_to_df(results['dist_pos'], n_arr, 'pos'),\\n arr_to_df(results['neg_noisy'], n_arr, 'neg'),\\n vec_to_df(results['dist_neg'], n_arr, 'neg')\\n ])\\n\\n xlim = (min(n_arr), max(n_arr))\\n ylim = (-1.1, 1.1)\\n\\n g = sns.FacetGrid(coefs_noisy, row = 'id', col = 'component', xlim = xlim,\\n ylim = ylim)\\n g.map(sns.pointplot, 'n', 'value', order = n_arr)\\n g.set_xticklabels(rotation = 45)\\n\\n for i, val in enumerate(results['obj_true']):\\n ax = g.axes[0, i]\\n ax.hlines(val, *ax.get_xlim())\\n for i, val in enumerate(results['pos_true']):\\n ax = g.axes[1, i]\\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\\n ax.hlines(val, *ax.get_xlim())\\n for i, val in enumerate(results['neg_true']):\\n ax = g.axes[2, i]\\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\\n ax.hlines(val, *ax.get_xlim())\",\n \"def _plot_comparison(xs, pan, other_program_name, **kw):\\n\\n pans = ['Bmax', 'Emax']\\n units = ['(mG)', '(kV/m)']\\n title_app = [', Max Magnetic Field', ', Max Electric Field']\\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\\n '-%s-comparison-Emax' % other_program_name]\\n\\n for p,u,t,s in zip(pans, units, title_app, save_suf):\\n #figure object and axes\\n fig = plt.figure()\\n ax_abs = fig.add_subplot(2,1,1)\\n ax_per = ax_abs.twinx()\\n ax_mag = fig.add_subplot(2,1,2)\\n #Bmax\\n #init handles and labels lists for legend\\n kw['H'], kw['L'] = [], []\\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\\n other_program_name, **kw)\\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\\n _check_und_conds([xs], [ax_mag], **kw)\\n ax_abs.set_title('Absolute and Percent Difference' + t)\\n ax_mag.set_ylabel(p + ' ' + u)\\n ax_mag.set_title('Model Results' + t)\\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\\n #_format_twin_axes(ax_abs, ax_per)\\n _save_fig(xs.sheet + s, fig, **kw)\",\n \"def plot_results(model):\\n\\n # Is is a system of equation\\n is_system = max(model.n_input, model.n_output) > 1\\n\\n # Choose the plotting function depending on the type of training data\\n if model.dimension == 1 and not (is_system):\\n plot_1d_results(model)\\n\\n elif model.dimension == 1 and is_system:\\n plot_1d_systems(model)\\n\\n elif model.dimension > 1 and not (is_system):\\n plot_2d_results(model)\\n\\n else:\\n # Plot and save slices of the Green's matrix\\n for i in range(1, 5):\\n plot_2d_systems(model, Green_slice=i)\",\n \"def comp(a,b,av=None,bv=None,domatch=True,out=None) :\\n if domatch :\\n i1,i2=match.match(a['APOGEE_ID'],b['APOGEE_ID'])\\n gd = np.where(a['NVISITS'][i1] == b['NVISITS'][i2])[0]\\n a=a[i1[gd]]\\n b=b[i2[gd]]\\n\\n fig = vscat(a)\\n vscat(b,fig=fig,ls=':')\\n if out is not None : \\n fig[0].savefig(out+'_1.png')\\n plt.close()\\n\\n if domatch :\\n fig,ax=plots.multi(1,2)\\n #plots.plotp(ax[0,0],a['SNR'],a['VHELIO_AVG']-b['VHELIO_AVG'],yr=[-3,3],yt=r'$\\\\Delta$ VHELIO_AVG')\\n #plots.plotp(ax[0,1],a['SNR'],a['VHELIO_AVG']-b['VHELIO_AVG'],yr=[-50,50],yt=r'$\\\\Delta$ VHELIO_AVG')\\n #plots.plotp(ax[1,0],a['SNR'],a['VSCATTER']-b['VSCATTER'],yr=[-0.5,0.5],yt=r'$\\\\Delta$ VSCATTER')\\n #plots.plotp(ax[1,1],a['SNR'],a['VSCATTER']-b['VSCATTER'],yr=[-5,5],yt=r'$\\\\Delta$ VSCATTER')\\n ax[0].hist(a['VHELIO_AVG']-b['VHELIO_AVG'],bins=np.arange(-0.5,0.5,0.02),histtype='step')\\n ax[0].set_xlabel(r'$\\\\Delta$ VHELIO_AVG')\\n ax[1].hist(a['VSCATTER']-b['VSCATTER'],bins=np.arange(-0.5,0.5,0.02),histtype='step')\\n ax[1].set_xlabel(r'$\\\\Delta$ VSCATTER')\\n if out is not None : \\n fig.savefig(out+'_2.png')\\n plt.close()\\n\\n return a,b\",\n \"def _plot_model_pred_vs_obs(self, ax):\\n\\n res = self._model.fit()\\n\\n ax.plot(self._model.endog, res.fittedvalues, '.', label='Observation')\\n\\n x_lim = ax.get_xlim()\\n\\n ax.plot(x_lim, x_lim, 'k:', label='1:1 line')\\n\\n x_label = 'Observed ' + self._model.endog_names\\n y_label = 'Predicted ' + self._model.endog_names\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n\\n ax.legend(loc='best', numpoints=1)\",\n \"def compare_CII_w_models(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n if not p.xlim: p.xlim = [-4,2]\\n if not p.ylim: p.ylim = [4,10]\\n\\n fig,ax = plt.subplots(figsize=(8,6))\\n ax.set_ylim(p.ylim)\\n ax.set_xlim(p.xlim)\\n\\n # SIGAME Simba-100 ext ON (default run)\\n GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[1])\\n L_line = getattr(GR,'L_[CII]158_sun')\\n SFR = getattr(GR,'SFR')\\n # Phantom points to close contour lines...\\n L_line = np.append(L_line,np.array([1e8,10**9.3]))\\n SFR = np.append(SFR,np.array([0.1,10**0.85]))\\n lL_line = np.log10(L_line)\\n lSFR = np.log10(SFR)\\n lSFR = lSFR[L_line > 0]\\n lL_line = lL_line[L_line > 0]\\n # ax.plot(np.log10(SFR),np.log10(L_line),'o',ms=4,color='midnightblue',\\\\\\n # alpha=0.7,label='SIGAME with Simba-100',zorder=10)\\n # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents\\n nbins = 100\\n k = kde.gaussian_kde(np.column_stack([lSFR,lL_line]).T)\\n x, y = np.mgrid[lSFR.min():lSFR.max():nbins*1j,4:lL_line.max():nbins*1j]\\n z = k(np.vstack([x.flatten(), y.flatten()]))\\n CS = ax.contour(x, y, z.reshape(x.shape),colors='forestgreen',levels=6,zorder=10)\\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF')\\n\\n # Select only MS galaxies\\n L_line = getattr(GR,'L_[CII]158_sun')\\n indices = aux.select_salim18(GR.M_star[L_line > 0],GR.SFR[L_line > 0])\\n print('With MS selection criteria: only %i galaxies' % (len(L_line)))\\n lSFR = lSFR[indices]\\n lL_line = lL_line[indices]\\n lSFR = np.append(lSFR,np.array([-1,0.85,1.5]))\\n lL_line = np.append(lL_line,np.array([8,9.3,8.4]))\\n nbins = 100\\n k = kde.gaussian_kde(np.column_stack([lSFR,lL_line]).T)\\n x, y = np.mgrid[lSFR.min():lSFR.max():nbins*1j,4:lL_line.max():nbins*1j]\\n z = k(np.vstack([x.flatten(), y.flatten()]))\\n CS = ax.contour(x, y, z.reshape(x.shape),colors='purple',linestyles='dashed',levels=6,zorder=10)\\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF (MS)')\\n\\n\\n # SIGAME Simba-100 ext OFF\\n # GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[0])\\n # L_line = getattr(GR,'L_[CII]158_sun')\\n # SFR = getattr(GR,'SFR')\\n # # Phantom points to close contour lines...\\n # L_line = np.append(L_line,np.array([10.**9.2,1e8]))\\n # SFR = np.append(SFR,np.array([0.9,0.1]))\\n # lL_line = np.log10(L_line)\\n # lSFR = np.log10(SFR)\\n # lSFR = lSFR[L_line > 0]\\n # lL_line = lL_line[L_line > 0]\\n # # ax.plot(np.log10(SFR),np.log10(L_line),'o',ms=4,color='midnightblue',\\\\\\n # # alpha=0.7,label='SIGAME with Simba-100',zorder=10)\\n # # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents\\n # nbins = 100\\n # k = kde.gaussian_kde(np.column_stack([lSFR,\\\\\\n # lL_line]).T)\\n\\n # x, y = np.mgrid[lSFR.min():lSFR.max():nbins*1j, \\\\\\n # 4:lL_line.max():nbins*1j]\\n # z = k(np.vstack([x.flatten(), y.flatten()]))\\n # CS = ax.contour(x, y, z.reshape(x.shape),colors='brown',levels=6,linestyles='dotted')\\n # CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF_no_ext')\\n\\n # SIGAME Simba-25\\n # GR = glo.global_results(sim_run=p.sim_runs[0],nGal=p.nGals[0])\\n # L_line = getattr(GR,'L_[CII]158_sun')\\n # SFR = getattr(GR,'SFR')\\n # ax.plot(np.log10(SFR),np.log10(L_line),'^',ms=6,color='darkorchid',alpha=0.7,label='SIGAME with Simba-25')\\n\\n # Observations in background\\n add_line_SFR_obs('[CII]158',L_line,ax,plot_fit=False)\\n\\n # Popping 2019\\n G19 = pd.read_csv(p.d_data + 'models/Popping2019.csv',skiprows=1,sep=' ',\\\\\\n names=['logSFR', 'logLCII', 'log LCII 14th percentile', 'log LCII 86th percentile'])\\n ax.plot(G19.logSFR,G19.logLCII,'k-',label='Popping 2019',alpha=0.8)\\n ax.fill_between(G19.logSFR,G19['log LCII 14th percentile'].values,\\\\\\n G19['log LCII 86th percentile'].values,color='grey',alpha=0.4)\\n\\n\\n # Padilla 2020\\n P20 = pd.read_csv(p.d_data + 'models/DataFig6.csv',skiprows=1,sep=',',\\\\\\n names=['IDSim','GalID','SFR','LCIITotal'])\\n P20['logLCII'] = np.log10(P20['LCIITotal'])\\n P20['logSFR'] = np.log10(P20['SFR'])\\n\\n\\n colors = ['cyan','orange','midnightblue']\\n nbins = 100\\n IDSims = ['Ref25','Recal25','Ref100']\\n for i,IDSim in enumerate(IDSims):\\n # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents\\n k = kde.gaussian_kde(np.column_stack([P20.logSFR.values[P20.IDSim == IDSim],\\\\\\n P20.logLCII.values[P20.IDSim == IDSim]]).T)\\n\\n xP20, yP20 = np.mgrid[P20.logSFR.min():P20.logSFR.max():nbins*1j, \\\\\\n 4:P20.logLCII.max():nbins*1j]\\n zP20 = k(np.vstack([xP20.flatten(), yP20.flatten()]))\\n # To remove weird contour line:\\n zP20.reshape(xP20.shape)[(xP20 > -1) & (yP20 < 5.5)] = 1e-5\\n zP20.reshape(xP20.shape)[(xP20 < -3)] = 1e-5\\n zP20.reshape(xP20.shape)[(xP20 < -2) & (yP20 > 8)] = 1e-5\\n zP20.reshape(xP20.shape)[(xP20 > 1) & (yP20 < 7)] = 1e-5\\n CS = ax.contour(xP20, yP20, zP20.reshape(xP20.shape),colors=colors[i],levels=5)\\n CS.collections[0].set_label('Ramos Padilla 2020 '+IDSim)\\n\\n\\n ax.set_xlabel('log '+getlabel('SFR'))\\n ax.set_ylabel('log '+getlabel('[CII]158'))\\n handles,labels = ax.get_legend_handles_labels()\\n handles = [handles[_] for _ in [8,9,10,11,12,7,0,1,2,3,4,5,6]]\\n labels = [labels[_] for _ in [8,9,10,11,12,7,0,1,2,3,4,5,6]]\\n plt.legend(handles,labels,fontsize=9,loc='upper left')\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/CII_SFR_w_models.png', format='png', dpi=300)\",\n \"def compare_plots(data_list, title_list, perp_list = [5, 30, 100], step_list = [10, 50, 1000], \\\\\\n perp_plot = True, step_plot_perp = 30, verbose = False, plot_3d = False, \\\\\\n cdict = {1: 'red', 2: 'mediumspringgreen', 3: 'royalblue'}, df = 1):\\n \\n # Determine dimensions of plot grid\\n nrows = len(perp_list) + 1\\n ncols = len(data_list)\\n \\n # Configure axes\\n axes = []\\n fig = plt.figure(figsize = (16, 3 * nrows))\\n \\n # Generate plots of starting points (first two columns for high-dimensional)\\n for index, dat in enumerate(data_list):\\n X, labs = dat\\n \\n # Check whether original data should be plotted in 3D, and adjust axes accordingly\\n if plot_3d:\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index, projection = '3d'))\\n axes[-1].scatter(xs = X[:, 0], ys = X[:, 1], zs = X[:, 2], edgecolor = None, alpha = 0.8, \\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_axis_off()\\n else:\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index))\\n plt.scatter(x = X[:, 0], y = X[:, 1], edgecolor = None, alpha = 0.8, \\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_xticklabels([])\\n axes[-1].set_yticklabels([])\\n axes[-1].xaxis.set_ticks_position('none')\\n axes[-1].yaxis.set_ticks_position('none')\\n axes[-1].set_title(\\\"\\\\n\\\".join(wrap(title_list[index], 35))) \\n \\n # Based on function input, generate either perplexity plots of interim iteration plots\\n if perp_plot:\\n # Generate plots of t-SNE output for different perplexities\\n for perp in range(len(perp_list)):\\n low_d = tsne(X = X, perplexity = perp_list[perp], verbose = verbose, optim = \\\"fastest\\\", df = df)\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (perp + 1) * ncols))\\n axes[-1].set_title(\\\"Perplexity = \\\" + str(perp_list[perp]))\\n plt.scatter(x = low_d[-1, :, 0], y = low_d[-1, :, 1], edgecolor = None, alpha = 0.8, \\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_xticklabels([])\\n axes[-1].set_yticklabels([])\\n axes[-1].xaxis.set_ticks_position('none')\\n axes[-1].yaxis.set_ticks_position('none')\\n else:\\n # Generate plots of t-SNE output for different iterations\\n low_d = tsne(X = X, perplexity = step_plot_perp, niter = np.max(step_list), verbose = verbose, optim = \\\"fastest\\\", \\\\\\n df = df)\\n for step in range(len(step_list)):\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (step + 1) * ncols))\\n axes[-1].set_title(\\\"Perplexity = \\\" + str(step_plot_perp) + \\\", Step = \\\" + str(step_list[step]))\\n plt.scatter(x = low_d[step_list[step], :, 0], y = low_d[step_list[step], :, 1], \\\\\\n edgecolor = None, alpha = 0.8,\\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_xticklabels([])\\n axes[-1].set_yticklabels([])\\n axes[-1].xaxis.set_ticks_position('none')\\n axes[-1].yaxis.set_ticks_position('none')\",\n \"def plot_comparison(step_test_data, model, inputs, outputs, start_time, end_time, plt_input=False, scale_plt=False):\\n \\n val_data = step_test_data.loc[start_time:end_time]\\n val_data.columns = [col[0] for col in val_data.columns]\\n \\n Time = val_data.index\\n u = val_data[inputs].to_numpy().T\\n y = val_data[outputs].to_numpy().T\\n\\n\\n # Use the model to predict the output-signals.\\n mdl = np.load(model)\\n \\n # The output of the model\\n xid, yid = fsetSIM.SS_lsim_innovation_form(A=mdl['A'], B=mdl['B'], C=mdl['C'], D=mdl['D'], K=mdl['K'], y=y, u=u, x0=mdl['X0'])\\n \\n # Make the plotting-canvas bigger.\\n plt.rcParams['figure.figsize'] = [25, 5]\\n # For each output-signal.\\n for idx in range(0,len(outputs)):\\n plt.figure(idx)\\n plt.xticks(rotation=15)\\n plt.plot(Time, y[idx],color='r')\\n plt.plot(Time, yid[idx],color='b')\\n plt.ylabel(outputs[idx])\\n plt.grid()\\n plt.xlabel(\\\"Time\\\")\\n plt.title('output_'+ str(idx+1))\\n plt.legend(['measurment', 'prediction'])\\n ax=plt.gca()\\n xfmt = md.DateFormatter('%m-%d-%yy %H:%M')\\n ax.xaxis.set_major_formatter(xfmt) \\n if scale_plt==True:\\n plt.ylim(np.amin(y[idx])*.99, np.amax(y[idx])*1.01)\\n \\n if plt_input == True:\\n for idx in range(len(outputs), len(outputs) + len(inputs)):\\n plt.figure(idx)\\n plt.xticks(rotation=15)\\n plt.plot(Time, u[idx-len(outputs)], color='r')\\n plt.ylabel(inputs[idx-len(outputs)])\\n plt.grid()\\n plt.xlabel(\\\"Time\\\")\\n plt.title('input_'+ str(idx-len(outputs)+1))\\n ax=plt.gca()\\n xfmt = md.DateFormatter('%m-%d-%yy %H:%M')\\n ax.xaxis.set_major_formatter(xfmt) \\n plt.show()\",\n \"def plotCompData(xdat, ydat, proteins, title=None, xlabel='dat1', ylabel='dat2', xMax=1.5, yMax=1.5, figSize=(10,10), saveFile=None):\\r\\n x = [numpy.median(xdat[i]) for i in proteins]\\r\\n y = [numpy.median(ydat[i]) for i in proteins] \\r\\n scat = pylab.figure(figsize=figSize)\\r\\n scatAx = scat.add_subplot(111) \\r\\n scatAx.scatter(x,y, c='b', s=150)\\r\\n scatAx.set_title(title)\\r\\n scatAx.set_xlabel(xlabel)\\r\\n scatAx.set_ylabel(ylabel)\\r\\n scatAx.set_xlim([-0.1,xMax])\\r\\n scatAx.set_ylim([-0.1,yMax])\\r\\n scatAx.set_xticks([0,xMax/5,xMax/5*2,xMax/5*3,xMax/5*4,xMax])\\r\\n scatAx.set_yticks([0,yMax/5,yMax/5*2,yMax/5*3,yMax/5*4,yMax])\\r\\n scatAx.yaxis.tick_left()\\r\\n scatAx.xaxis.tick_bottom()\\r\\n for prot, xl, yl in zip(proteins, x, y):\\r\\n scatAx.annotate(str(prot[4:]), xy = (float(xl), float(yl)), xytext = (15,15), textcoords = 'offset points', arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0'))\\r\\n pylab.tight_layout()\\r\\n scatAx.plot(numpy.linspace(0, 10), numpy.linspace(0,10))\\r\\n return scatAx\",\n \"def plot_comparison(data, data1, data2, algorithm):\\n # Loads the different datasets\\n runs = data[data.columns[0]]\\n distance = data[data.columns[1]]\\n\\n runs1 = data1[data1.columns[0]]\\n distance1 = data1[data1.columns[1]]\\n\\n runs2 = data2[data2.columns[0]]\\n distance2 = data2[data2.columns[1]]\\n\\n # Forms the histogram\\n plt.plot(runs, distance, label=\\\"Wijk 1\\\")\\n plt.plot(runs1, distance1, color = 'orange', label=\\\"Wijk 2\\\")\\n plt.plot(runs2, distance2, color = 'red', label=\\\"Wijk 3\\\")\\n plt.legend(loc='upper right')\\n\\n # Plots the legend\\n plt.legend(loc='upper right')\\n\\n # Adds the title and axis names\\n plt.title(f\\\"{algorithm} Algorithm\\\", fontweight='bold')\\n plt.xlabel('Iterations')\\n plt.ylabel('Total Distance')\\n\\n # Actually shows the histogram\\n plt.show()\",\n \"def scatter(original, updated, main=\\\"\\\", save=None): \\n #Remove hits with no improvement and calcate the number of hits with no\\n #improvement(udated == original), positive imporvent (updated > original), \\n #and negative improvment (updated < original)\\n print len(original)\\n positiveImprovement = []\\n negativeImprovement = []\\n noImprovement = 0\\n for o, u in izip(original, updated):\\n if int(o) == int(u):\\n noImprovement +=1\\n elif u > o:\\n positiveImprovement.append((o,u))\\n elif u < o:\\n negativeImprovement.append((o,u))\\n else:\\n noImprovement +=1\\n\\n if not positiveImprovement:\\n positiveImprovement = [()]\\n if not negativeImprovement:\\n negativeImprovement = [()]\\n\\n print positiveImprovement\\n print negativeImprovement\\n print noImprovement\\n\\n #Set deimensions\\n x, y = zip(*positiveImprovement+negativeImprovement)\\n xMax = int(round(sorted(x)[-1]/500.0)*500.0)\\n yMax = int(round(sorted(y)[-1]/500.0)*500.0)\\n sep = 500\\n xticks = range(0, xMax, sep)\\n yticks = range(0,yMax,sep)\\n color_cycle = brewer2mpl.get_map('Set2', 'qualitative', 8).mpl_colors\\n\\n fig, ax = plt.subplots()\\n ax.set_title(main)\\n ax.set_xlabel(\\\"Original Bitscores\\\")\\n ax.set_ylabel(\\\"Updated Bitscores\\\")\\n\\n \\n #Plot postive improvement (green, automatically by prettyplotlib)\\n if positiveImprovement:\\n ppl.scatter(ax, *zip(*positiveImprovement), \\n label=\\\"Positive Improvement ({} seqs)\\\".format(len(positiveImprovement)),\\n color=color_cycle[0])\\n\\n #Draw no improvement line\\n ppl.plot(ax, (0,xMax), (0,xMax), color='k', linestyle='-', linewidth=2,\\n label=\\\"No Improvement ({} seqs)\\\".format(noImprovement))\\n\\n #Plot negative improvement (red, automatically by prettyplotlib)\\n if negativeImprovement:\\n ppl.scatter(ax, *zip(*negativeImprovement),\\n label=\\\"Negative Improvement ({} seqs)\\\".format(len(negativeImprovement)),\\n color=color_cycle[1])\\n\\n #Draw labels\\n ppl.legend(ax)\\n\\n #Set axis\\n ax.set_ylim([0,yMax])\\n ax.set_xlim([0,xMax])\\n\\n if save is None:\\n plt.show()\\n else:\\n pp = PdfPages(save)\\n pp.savefig(fig)\\n pp.close()\",\n \"def plot_bit_for_bit(case, var_name, model_data, bench_data, diff_data):\\n plot_title = \\\"\\\"\\n plot_name = case + \\\"_\\\" + var_name + \\\".png\\\"\\n plot_path = os.path.join(os.path.join(livvkit.output_dir, \\\"verification\\\", \\\"imgs\\\"))\\n functions.mkdir_p(plot_path)\\n m_ndim = np.ndim(model_data)\\n b_ndim = np.ndim(bench_data)\\n if m_ndim != b_ndim:\\n return \\\"Dataset dimensions didn't match!\\\"\\n if m_ndim == 3:\\n model_data = model_data[-1]\\n bench_data = bench_data[-1]\\n diff_data = diff_data[-1]\\n plot_title = \\\"Showing \\\"+var_name+\\\"[-1,:,:]\\\"\\n elif m_ndim == 4:\\n model_data = model_data[-1][0]\\n bench_data = bench_data[-1][0]\\n diff_data = diff_data[-1][0]\\n plot_title = \\\"Showing \\\"+var_name+\\\"[-1,0,:,:]\\\"\\n plt.figure(figsize=(12, 3), dpi=80)\\n plt.clf()\\n\\n # Calculate min and max to scale the colorbars\\n _max = np.amax([np.amax(model_data), np.amax(bench_data)])\\n _min = np.amin([np.amin(model_data), np.amin(bench_data)])\\n\\n # Plot the model output\\n plt.subplot(1, 3, 1)\\n plt.xlabel(\\\"Model Data\\\")\\n plt.ylabel(var_name)\\n plt.xticks([])\\n plt.yticks([])\\n plt.imshow(model_data, vmin=_min, vmax=_max, interpolation='nearest', cmap=colormaps.viridis)\\n plt.colorbar()\\n\\n # Plot the benchmark data\\n plt.subplot(1, 3, 2)\\n plt.xlabel(\\\"Benchmark Data\\\")\\n plt.xticks([])\\n plt.yticks([])\\n plt.imshow(bench_data, vmin=_min, vmax=_max, interpolation='nearest', cmap=colormaps.viridis)\\n plt.colorbar()\\n\\n # Plot the difference\\n plt.subplot(1, 3, 3)\\n plt.xlabel(\\\"Difference\\\")\\n plt.xticks([])\\n plt.yticks([])\\n plt.imshow(diff_data, interpolation='nearest', cmap=colormaps.viridis)\\n plt.colorbar()\\n\\n plt.tight_layout(rect=(0, 0, 0.95, 0.9))\\n plt.suptitle(plot_title)\\n\\n plot_file = os.path.sep.join([plot_path, plot_name])\\n if livvkit.publish:\\n plt.savefig(os.path.splitext(plot_file)[0]+'.eps', dpi=600)\\n plt.savefig(plot_file)\\n plt.close()\\n return os.path.join(os.path.relpath(plot_path,\\n os.path.join(livvkit.output_dir, \\\"verification\\\")),\\n plot_name)\",\n \"def plot_decision_boundary(data, x, y, labels, model, **kwargs):\\n xx, yy, Z = setup_contours(data=data, x=x, y=y, model=model)\\n\\n x0, x1 = data[x].values, data[y].values\\n x0lim = x0.min(), x0.max()\\n x1lim = x1.min(), x1.max()\\n\\n col = data[labels].values\\n plt.figure(figsize=(10, 10))\\n\\n plt.scatter(x0, x1, c=col, **kwargs)\\n CS = plt.contourf(xx, yy, Z, **kwargs)\\n CS2 = plt.contour(CS, CS.levels[::2], **kwargs)\\n cbar = plt.colorbar(CS, **kwargs)\\n cbar.ax.set_ylabel('Fitted Probability')\\n # Add the contour line levels to the colorbar\\n cbar.add_lines(CS2)\\n\\n plt.xlim(x0lim)\\n plt.ylim(x1lim)\\n plt.xlabel(x)\\n plt.ylabel(y)\\n plt.legend()\",\n \"def plot_1d_systems(model):\\n\\n # Construct grid to evaluate the Green's function\\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\\n x_G_star = X_G.flatten()[:, None]\\n y_G_star = Y_G.flatten()[:, None]\\n\\n # Create the figure\\n n_plots = max(model.n_input + 1, model.n_output)\\n scaling = n_plots / 2\\n fig, ax = newfig(1.0 * scaling, 1.5)\\n ax.axis('off')\\n gs = gridspec.GridSpec(n_plots, n_plots)\\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9,\\n wspace=0.6 * scaling, hspace=0.6 * scaling)\\n\\n # Plot the Green's functions\\n for i in range(model.n_output):\\n for j in range(model.n_input):\\n input_data = np.concatenate((x_G_star, y_G_star), 1)\\n G_pred_identifier = model.sess.run(\\n model.G_network[i][j].evaluate(input_data))\\n G_pred = G_pred_identifier.reshape(X_G.shape)\\n ax = plt.subplot(gs[i, j])\\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\\n extent=[np.min(model.x_G), np.max(model.x_G), np.min(\\n model.y_G), np.max(model.y_G)],\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel('$x$')\\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\\n ax.set_title('$G_{%d,%d}$' % (i + 1, j + 1), fontsize=10)\\n\\n # Plot the homogeneous solutions\\n for i in range(model.n_output):\\n N_pred = model.sess.run(model.idn_N_pred[i].evaluate(model.x))\\n ax = plt.subplot(gs[i, model.n_input])\\n ax.plot(model.x, model.U_hom[:, i], label='Exact')\\n ax.plot(model.x, N_pred, dashes=[2, 2], label='Learned')\\n divider = make_axes_locatable(ax)\\n ymin = min([np.min(N_pred), np.min(model.U_hom[:, i])])\\n ymax = max([np.max(N_pred), np.max(model.U_hom[:, i])])\\n ax.set_xlim(np.min(model.x), np.max(model.x))\\n ax.set_ylim(ymin, ymax)\\n if ymax - ymin < 1e-2:\\n ax.yaxis.set_major_formatter(MathTextSciFormatter(\\\"%1.1e\\\"))\\n ax.set_xlabel('$x$')\\n ax.set_title('Hom$_{%d}$' % (i + 1), fontsize=10)\\n ax.legend()\\n\\n # Save the figure\\n savefig(\\\"%s/%s_%s\\\" % (model.path_result, model.example_name,\\n model.activation_name), crop=False)\",\n \"def plot_corr_normalized(models,data,fit,**kwargs):\\n _fnNMod = len(models)\\n _fnIdx = [0] ## -- index of plotted function, in array so it can be modified in functions\\n ## -- objects to hold all plot data\\n ## - Dat/Fit refers to the correlator data or the fit function\\n ## - Central/Error are the central value and errors\\n _fnDatCentral = []\\n _fnDatError = []\\n _fnFitOnes = []\\n _fnFitError = []\\n #\\n ## -- other objects\\n _fnTDataNonZero = []\\n _fnTFitNonZero = []\\n _fnTData = []\\n _fnTFit = []\\n _fnTRem = [] # number of previous timeslices removed\\n fig,ax = plt.subplots(1)\\n #\\n ## -- setup plot function\\n def do_plot_normalized(idx,fig=fig):\\n fig.clear()\\n ax = fig.add_subplot(111)\\n key = models[idx[0]].datatag\\n\\n ax.set_xlim([-1,len(_fnTData[idx[0]])])\\n ax.set_ylim(utp.get_option(\\\"y_limit\\\",[0.2,1.8],**kwargs[key]))\\n #\\n ## -- plot fit\\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitOnes[idx[0]],\\n color=utp.get_option(\\\"color2\\\",'b',**kwargs[key]))\\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][0],\\n color=utp.get_option(\\\"color2\\\",'g',**kwargs[key]),\\n ls=utp.get_option(\\\"linestyle2\\\",'--',**kwargs[key]))\\n ax.plot(_fnTDataNonZero[idx[0]],_fnFitError[idx[0]][1],\\n color=utp.get_option(\\\"color2\\\",'g',**kwargs[key]),\\n ls=utp.get_option(\\\"linestyle2\\\",'--',**kwargs[key]))\\n ## -- plot correlator data\\n ax.errorbar(_fnTDataNonZero[idx[0]],_fnDatCentral[idx[0]],yerr=_fnDatError[idx[0]],\\n mfc=utp.get_option(\\\"markerfacecolor1\\\",'None',**kwargs[key]),\\n mec=utp.get_option(\\\"markeredgecolor1\\\",'k',**kwargs[key]),\\n color=utp.get_option(\\\"markeredgecolor1\\\",'k',**kwargs[key]),\\n ls=utp.get_option(\\\"linestyle1\\\",'None',**kwargs[key]),\\n marker=utp.get_option(\\\"marker1\\\",'o',**kwargs[key]),\\n ms=utp.get_option(\\\"markersize\\\",6,**kwargs[key]))\\n ax.scatter(_fnTFitNonZero[idx[0]],\\n [ _fnDatCentral[idx[0]][t] for t in\\n list(np.array(_fnTFitNonZero[idx[0]])-np.array(_fnTRem[idx[0]])) ],\\n color=utp.get_option(\\\"color1\\\",'r',**kwargs[key]),\\n marker=utp.get_option(\\\"marker\\\",'o',**kwargs[key]),\\n s=utp.get_option(\\\"markersize\\\",36,**kwargs[key]))\\n fig.suptitle(utp.get_option(\\\"plottitlefn\\\",str(idx[0])+\\\" default title \\\"+str(key),**kwargs[key]),\\n fontsize=utp.get_option(\\\"titlesize\\\",20,**kwargs[key]))\\n ## -- modify some options \\n ax.set_xlabel(r'$t$')\\n ax.set_ylabel(utp.get_option(\\\"yaxistitle\\\",r\\\"$C(t)/C_{fit}(t)$\\\",**kwargs[key]))\\n for item in ([ax.xaxis.label,ax.yaxis.label]):\\n # must be after setting label content (LaTeX ruins it)\\n item.set_fontsize(fontsize=utp.get_option(\\\"fontsize\\\",20,**kwargs[key]))\\n rect =fig.patch\\n rect.set_facecolor('white')\\n if utp.get_option(\\\"to_file\\\",False,**kwargs[key]):\\n save_dir = utp.get_option(\\\"fn_save_dir\\\",\\\"./plotdump\\\",**kwargs[key])\\n save_name = utp.get_option(\\\"fn_save_name\\\",\\\"fnplot-\\\"+key+\\\".pdf\\\",**kwargs[key])\\n plt.savefig(save_dir+'/'+save_name)\\n if utp.get_option(\\\"to_terminal\\\",True,**kwargs[key]):\\n plt.draw()\\n pass\\n #\\n ## -- setup button press action function\\n def press_normalized(event,idx=_fnIdx):\\n #print('press_normalized', event.key)\\n try:\\n ## -- manually indicate index\\n idx[0] = int(event.key) + (idx[0])*10\\n except ValueError:\\n if event.key==' ': ## -- space\\n ## -- allows for replotting when changing index by typing number keys\\n idx[0] = idx[0] % _fnNMod\\n do_plot_normalized(idx)\\n elif event.key=='left':\\n idx[0] = (idx[0] - 1) % _fnNMod\\n do_plot_normalized(idx)\\n elif event.key=='right':\\n idx[0] = (idx[0] + 1) % _fnNMod\\n do_plot_normalized(idx)\\n elif event.key=='backspace':\\n ## -- reset index so can manually flip through using number keys\\n idx[0] = 0\\n elif event.key=='d':\\n ## -- dump plots into ./plotdump directory\\n for ix,model in zip(range(len(models)),models):\\n key = model.datatag\\n save_dir = utp.get_option(\\\"fn_save_dir\\\",\\\"./plotdump\\\",**kwargs[key])\\n save_name = utp.get_option(\\\"fn_save_name\\\",\\\"fnplot-\\\"+key+\\\".png\\\",**kwargs[key])\\n do_plot_normalized([ix])\\n plt.savefig(save_dir+'/'+save_name)\\n do_plot_normalized(idx)\\n #\\n ## -- \\n fig.canvas.mpl_connect('key_press_event',press_normalized)\\n ## -- save plot data\\n for idx,model in zip(range(len(models)),models):\\n key = model.datatag\\n _fnTData.append(model.tdata)\\n _fnTFit.append(model.tfit)\\n _fnTFit[-1] = np.append(_fnTFit[-1],list(sorted([len(_fnTData[-1]) - t for t in _fnTFit[-1]])))\\n ## -- fit\\n _fnFitFunc = utp.create_fit_func(model,fit)\\n _fnFitMean = gv.mean(_fnFitFunc(_fnTData[-1]))\\n _fnTDataNonZero.append([t for t in _fnTData[-1] if np.abs(_fnFitMean[t]) > 1e-20])\\n _fnTFitNonZero.append([t for t in _fnTFit[-1] if np.abs(_fnFitMean[t]) > 1e-20])\\n _fnTRem.append([(0 if np.abs(_fnFitMean[t]) > 1e-20 else 1) for t in model.tdata])\\n _fnTRem[-1] = \\\\\\n [sum(_fnTRem[-1][:i+1]) for i in range(len(_fnTRem[-1])) if i in _fnTFitNonZero[-1]]\\n _fnFitMean = gv.mean(_fnFitFunc(_fnTDataNonZero[-1]))\\n _fnFitSdev = list(np.array(gv.sdev(_fnFitFunc(_fnTDataNonZero[-1])))/np.array(_fnFitMean))\\n _fnFitOnes.append(list(np.ones(len(_fnTDataNonZero[-1]))))\\n _fnFitError.append([ list(np.array(_fnFitOnes[-1])-np.array(_fnFitSdev)),\\n list(np.array(_fnFitOnes[-1])+np.array(_fnFitSdev)) ])\\n ## -- data\\n _fnDatCentral.append( list(np.array([gv.mean(data[key])[t] for t in _fnTDataNonZero[-1]])/\\n np.array(_fnFitMean)) )\\n _fnDatSdev = ( np.array([gv.sdev(data[key])[t] for t in _fnTDataNonZero[-1]])/\\n np.array(_fnFitMean) )\\n _fnDatError.append([ list(_fnDatSdev), list(_fnDatSdev) ])\\n ## -- done saving data\\n \\n if not(utp.get_option(\\\"to_terminal\\\",True,**kwargs[key])) and\\\\\\n utp.get_option(\\\"to_file\\\",False,**kwargs[key]):\\n for ix in range(len(models)):\\n ## -- loops and saves all without creating window\\n do_plot_normalized([ix])\\n else:\\n do_plot_normalized(_fnIdx)\",\n \"def plot_cnn_results(file_data_model=None):\\n \\n if file_data_model is None:\\n print(\\\"ERROR - PLOT_CNN_RESULTS - Argument is None\\\", file_data_model)\\n return\\n\\n data_model = np.load(os.path.join(CNN.STR_DIR_RUN, file_data_model)).item()\\n y_prob = data_model['y_est']\\n valid_labels = data_model['y_cgt']\\n acc_train = data_model['acc_train_tot'] \\n acc_valid = data_model['acc_valid_tot'] \\n n_iter = data_model['n_iter']\\n loss = data_model['loss'] \\n \\n \\n if len(valid_labels.shape) == 1:\\n c_label = CNN.convert_to_one_hot(valid_labels, 3)\\n else:\\n c_label = valid_labels\\n \\n # Create base for Normal, MCI and AD\\n angle = np.array([0, 2*np.pi/3, 4*np.pi/3])\\n factors = np.array([np.exp(1j*angle)])\\n # Linear combinaison with results\\n prob_polar = y_prob.dot(factors.T).flatten()\\n\\n # Get ids of estimated classification\\n ids = np.argmax(c_label, axis=1)\\n ids_normal = np.nonzero(ids == 0)[0]\\n ids_mci = np.nonzero(ids == 1)[0]\\n ids_ad = np.nonzero(ids == 2)[0]\\n \\n fig = plt.figure(figsize=(16,4))\\n # Polar plot\\n ax = plt.subplot(1, 2, 1, projection='polar')\\n plt.title('Validation - Prob. class.', fontsize=18); \\n ax.scatter(np.angle(prob_polar[ids_normal]), np.abs(prob_polar[ids_normal]), s = 50, c='b', \\n alpha=0.6, linewidths=0, label='Normal')\\n ax.scatter(np.angle(prob_polar[ids_mci]), np.abs(prob_polar[ids_mci]), s = 50, c='g', \\n alpha=0.6, linewidths=0, label='MCI')\\n ax.scatter(np.angle(prob_polar[ids_ad]), np.abs(prob_polar[ids_ad]), s = 50, c='r', \\n alpha=0.6, linewidths=0, label='AD')\\n ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., scatterpoints=1)\\n\\n # Set limits of radius\\n ax.set_rmax(1.0)\\n # Set delimiters\\n ax.xaxis.set_major_locator(ticker.MultipleLocator(np.pi/3))\\n ax.xaxis.set_minor_locator(ticker.MultipleLocator(np.pi/6))\\n \\n # Turn off major tick labels\\n ax.xaxis.set_major_formatter(ticker.NullFormatter())\\n # Set the minor tick width to 0 so you don't see them\\n for tick in ax.xaxis.get_minor_ticks():\\n tick.tick1line.set_markersize(0)\\n tick.tick2line.set_markersize(0)\\n tick.label1.set_horizontalalignment('center')\\n\\n # Set the names of your ticks, with blank spaces for the major ticks\\n ax.set_xticklabels(['','Nor','','','','MCI','','','','AD'],minor=True)\\n\\n # Creat second plot to see evolution of accuracy over iteration\\n ax2 = plt.subplot(1, 2, 2)\\n plt.title('Accuracy/Loss over iteration', fontsize=18); plt.xlabel('Iteration'); plt.ylabel('Accuracy')\\n lns1 = ax2.plot(np.linspace(0,n_iter,len(acc_train)), acc_train, '-*', label = 'Train'); # Accuracy train\\n lns2 = ax2.plot(np.linspace(0,n_iter,len(acc_valid)), acc_valid, '-*', label = 'Valid'); # Accuracy validation \\n ax2.grid(); plt.ylim([0, 1]); \\n # Lodd grid \\n ax3 = ax2.twinx()\\n lns3 = ax3.plot(np.linspace(0,n_iter,len(loss)), loss, '-+r', label = 'Loss'); # Accuracy validation\\n plt.ylim([0, 1]); plt.ylabel('Loss') \\n \\n # added these three lines\\n lns = lns1+lns2+lns3\\n labs = [l.get_label() for l in lns]\\n ax2.legend(lns, labs, loc=5)\\n plt.show()\\n \\n # Save as PDF file if wanted\\n if DataLoader.SAVE_FIGURE:\\n DataLoader.save_plot(fig, 'plot_polar_prob.pdf')\",\n \"def plot_2d_results(model):\\n\\n # Create the figure\\n fig, ax = newfig(1.5, 1.5)\\n ax.axis('off')\\n gs = gridspec.GridSpec(3, 3)\\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9, wspace=0.7, hspace=0.7)\\n\\n # Loop to plot different slices of the Green's function\\n for i in range(2):\\n for j in range(2):\\n # Evaluate the Green's function network\\n input_data, shape_Green, axis_limit, axis_labels = input_data_slice(\\n model, Green_slice=2 * i + j + 1)\\n G_pred_identifier = model.sess.run(\\n model.G_network[0][0].evaluate(input_data))\\n G_pred = G_pred_identifier.reshape(shape_Green)\\n ax = plt.subplot(gs[i, j])\\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\\n extent=axis_limit,\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel(axis_labels[0])\\n ax.set_ylabel(axis_labels[1], rotation=0, labelpad=12)\\n ax.set_title('$G$%s' % (axis_labels[2]), fontsize=10)\\n\\n # Get axis limit\\n x1min = np.min(model.x_G)\\n x1max = np.max(model.x_G)\\n x2min = np.min(model.y_G)\\n x2max = np.max(model.y_G)\\n\\n # Exact Homogeneous solution\\n ax = plt.subplot(gs[0, 2])\\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\\n x1 = X_G.flatten()[:, None]\\n x2 = Y_G.flatten()[:, None]\\n U_hom = np.transpose(model.U_hom.reshape(\\n (model.y_G.shape[0], model.x_G.shape[0])))\\n h = ax.imshow(U_hom, interpolation='lanczos', cmap='jet',\\n extent=[x1min, x1max, x2min, x2max],\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel('$x$')\\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\\n ax.set_title('Exact Hom', fontsize=10)\\n\\n # Learned Homogeneous solution\\n ax = plt.subplot(gs[1, 2])\\n input_data = np.concatenate((x1, x2), 1).astype(dtype=config.real(np))\\n N_pred_identifier = model.sess.run(\\n model.idn_N_pred[0].evaluate(input_data))\\n N_pred = N_pred_identifier.reshape(X_G.shape)\\n h = ax.imshow(N_pred, interpolation='lanczos', cmap='jet',\\n extent=[x1min, x1max, x2min, x2max],\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel('$x$')\\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\\n ax.set_title('Learned Hom', fontsize=10)\\n\\n # Save the figure\\n savefig(\\\"%s/%s_%s\\\" % (model.path_result, model.example_name,\\n model.activation_name), crop=False)\",\n \"def plot_discrepancy(self, axes=None, **kwargs):\\n return vis.plot_discrepancy(self.target_model,\\n self.target_model.parameter_names,\\n axes=axes,\\n **kwargs)\",\n \"def plot_comparaison_filter(fig_name):\\n dir = \\\"log/peps mini\\\"\\n pattern = r'(internal|access|lock)\\\\\\\\\\\\d{1,2}.csv$'\\n pattern_valid = r'(3|6|9|12).csv$'\\n df_report = pd.DataFrame()\\n utils.construct_set(dir, pattern, pattern_valid, filter=0)\\n X_train, X_valid, y_train, y_valid = utils.load_train_valid()\\n cm, report_temp, classes = utils.train(X_train, X_valid, y_train, y_valid, method='RF',\\n param={\\\"max_features\\\": 2, \\\"n_estimators\\\": 100})\\n df_report = df_report.append(report_temp, ignore_index=True)\\n utils.construct_set(dir, pattern, pattern_valid, filter=1)\\n X_train, X_valid, y_train, y_valid = utils.load_train_valid()\\n cm, report_temp, classes = utils.train(X_train, X_valid, y_train, y_valid, method='RF',\\n param={\\\"max_features\\\": 2, \\\"n_estimators\\\": 100})\\n df_report = df_report.append(report_temp, ignore_index=True)\\n df_report.index = ['Original', 'Corrected']\\n df_report.plot(kind='bar', rot=0, ylim=(0.6, 1))\\n plt.title(fig_name)\\n if not os.path.exists(dir_fig):\\n os.makedirs(dir_fig)\\n plt.savefig(dir_fig + '/' + fig_name + '.png')\",\n \"def plotMerged(self, matrix, expcol, expdata=None,\\n title='', showtable=True, ax=None, name=None,\\n stats=True):\\n if expdata==None:\\n expdata = self.parent.tablemodel.simpleCopy(include=['Mutations'])\\n merged = self.mergeMatrix(matrix, expdata)\\n x,y,names,muts = merged.getColumns(['Total',expcol,'name','Mutations'],allowempty=False)\\n from Correlation import CorrelationAnalyser\\n C = CorrelationAnalyser()\\n muts = ['mutation: '+i for i in muts]\\n labels = zip(names, muts)\\n ax,frame,mh = C.plotCorrelation(x,y,labels,title=title,ylabel=expcol,\\n ax=ax,plotname=name,stats=stats,err=4)\\n x=[round(float(i),2) for i in x]\\n y=[round(float(i),2) for i in y] \\n if showtable == True:\\n table = self.showTable(frame, merged)\\n mh.table = table\\n \\n return ax,mh,x,y\",\n \"def test_plot_lm(models, kwargs):\\n idata = models.model_1\\n if \\\"constant_data\\\" not in idata.groups():\\n y = idata.observed_data[\\\"y\\\"]\\n x1data = y.coords[y.dims[0]]\\n idata.add_groups({\\\"constant_data\\\": {\\\"_\\\": x1data}})\\n idata.constant_data[\\\"x1\\\"] = x1data\\n idata.constant_data[\\\"x2\\\"] = x1data\\n\\n axes = plot_lm(idata=idata, y=\\\"y\\\", y_model=\\\"eta\\\", xjitter=True, **kwargs)\\n assert np.all(axes)\",\n \"def plot_model(model, inputs, outputs, tss=90):\\n mdl = np.load(model)\\n sys = ss(mdl['A'], mdl['B'], mdl['C'], mdl['D'],1)\\n gain_matrix = dcgain(sys).T\\n num_i = len(inputs)\\n num_o = len(outputs)\\n fig, axs = plt.subplots(num_i,num_o, figsize=(3*len(outputs), 2*len(inputs)), facecolor='w', edgecolor='k')\\n fig.suptitle('Step responce: '+model)\\n T = np.arange(tss)\\n for idx_i in range(num_i):\\n for idx_o in range(num_o):\\n ax = axs[idx_i][idx_o]\\n t,y_step = step_response(sys,T, input=idx_i, output=idx_o)\\n gain = round(gain_matrix[idx_i][idx_o],4)\\n ax.plot(t, y_step,color='r')\\n if idx_i == 0:\\n ax.set_title(outputs[idx_o], rotation='horizontal', ha='center', fontsize=10)\\n if idx_o == 0:\\n ax.set_ylabel(inputs[idx_i], rotation=90, fontsize=10)\\n ax.grid(color='k', linestyle='--', linewidth=0.5)\\n ax.tick_params(axis='x', colors='red',size=0,labelsize=4)\\n ax.tick_params(axis='y', colors='red',size=0,labelsize=4)\\n ax.annotate(str(gain),xy=(.72,.8),xycoords='axes fraction')\\n # fig.tight_layout()\\n plt.show()\",\n \"def plot_observed_predictions(self):\\n \\n # Plot of X vs Y\\n fig = plt.figure(figsize=(15,5))\\n plt.subplot(1,3,1) \\n for k in self.phd_filter['estimated_positions'].keys():\\n plt.plot(self.phd_filter['estimated_positions'][k][0], self.phd_filter['estimated_positions'][k][1], 'bx')\\n plt.xlabel(\\\"X\\\",fontsize=20)\\n plt.ylabel(\\\"Y\\\",fontsize=20)\\n \\n # Plot of time vs X\\n plt.subplot(1,3,2)\\n for k in self.phd_filter['estimated_positions'].keys(): \\n plt.plot(k*np.ones(self.phd_filter['estimated_positions'][k].shape[1]), self.phd_filter['estimated_positions'][k][0], 'bx')\\n plt.xlabel(\\\"time\\\",fontsize=20)\\n plt.ylabel(\\\"X\\\",fontsize=20)\\n plt.xlim(0,self.n_time_steps+1)\\n\\n # Plot of time vs Y\\n plt.subplot(1,3,3)\\n for k in self.phd_filter['estimated_positions'].keys():\\n plt.plot(k*np.ones(self.phd_filter['estimated_positions'][k].shape[1]), self.phd_filter['estimated_positions'][k][1], 'bx')\\n plt.xlabel(\\\"time\\\",fontsize=20)\\n plt.ylabel(\\\"Y\\\",fontsize=20)\\n plt.xlim(0,self.n_time_steps+1)\\n plt.show();\",\n \"def review_model(model): \\n \\n diagnose_model(model)\\n \\n plot_param_coef(model)\\n \\n plot_p_values(model)\\n \\n return\",\n \"def Diagnostic_plot2(self):\\n\\n probs = pd.read_csv(self.probfile)\\n\\n fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n plt.scatter(probs['f0'], probs['Pdet_Kepler'], label='Kepler - 4yrs')\\n plt.scatter(probs['f0'], probs['Pdet_TESS365'], label='TESS - 1 yr')\\n plt.scatter(probs['f0'], probs['Pdet_TESS27'], label='TESS - 27 days')\\n plt.legend(loc='lower right')\\n plt.ylim([0,1])\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot2_Pdet' + self.ds.epic + '.pdf')\\n\\n fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'SNR')\\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs')\\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr')\\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days')\\n plt.legend(loc='lower right')\\n #plt.ylim([0,1])\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot2_SNR' + self.ds.epic + '.pdf')\",\n \"def plotChanges(data, na, nb, ra, rb, pcut, output, xlim=None, ylim=None):\\n sa = data[f\\\"{na}_ES\\\"]\\n sb = data[f\\\"{nb}_ES\\\"]\\n\\n #plot the raw dots\\n fig, ax = pylab.subplots(figsize=(3.2, 2.2))\\n ax.scatter(sa,\\n sb,\\n s=0.5,\\n color=\\\"gray\\\",\\n alpha=0.6,\\n label=\\\"total %s domains\\\" % data.shape[0])\\n #plot the changes\\n ax.scatter(sa[ra],\\n sb[ra],\\n s=2,\\n color=colors[0],\\n alpha=0.8,\\n label=\\\"%s domains\\\" % len(ra))\\n ax.scatter(sa[rb],\\n sb[rb],\\n s=2,\\n color=colors[1],\\n alpha=0.8,\\n label=\\\"%s domains\\\" % len(rb))\\n leg = ax.legend(bbox_to_anchor=(1.05, 1.0),\\n loc='upper left',\\n labelcolor=[\\\"gray\\\", colors[0], colors[1]])\\n for h in leg.legendHandles:\\n h._sizes = [10]\\n ax.set_xlabel(f\\\"{na} domain ES\\\")\\n ax.set_ylabel(f\\\"{nb} domain ES\\\")\\n ax.set_title(f\\\"ES comparsion\\\\nMahalanobis distance P-value < {pcut}\\\")\\n s = np.min([np.min(sa), np.min(sb)])\\n e = np.max([np.max(sa), np.max(sb)])\\n ax.plot([s, e], [s, e], color=\\\"gray\\\", linestyle=\\\"--\\\")\\n if xlim is not None:\\n xlim = list(map(float, xlim.split(\\\",\\\")))\\n xlim.sort()\\n ax.set_xlim(xlim)\\n if ylim is not None:\\n ylim = list(map(float, ylim.split(\\\",\\\")))\\n ylim.sort()\\n ax.set_ylim(ylim)\\n pylab.savefig(f\\\"{output}_domainChanges.pdf\\\")\",\n \"def plot_decision_boundary(model: torch.nn.Module, X: torch.Tensor, y: torch.Tensor):\\n # Put everything to CPU (works better with NumPy + Matplotlib)\\n model.to(\\\"cpu\\\")\\n X, y = X.to(\\\"cpu\\\"), y.to(\\\"cpu\\\")\\n\\n # Setup prediction boundaries and grid\\n x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1\\n y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1\\n xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101), np.linspace(y_min, y_max, 101))\\n\\n # Make features\\n X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()\\n\\n # Make predictions\\n model.eval()\\n with torch.inference_mode():\\n y_logits = model(X_to_pred_on)\\n\\n # Test for multi-class or binary and adjust logits to prediction labels\\n if len(torch.unique(y)) > 2:\\n y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1) # mutli-class\\n else:\\n y_pred = torch.round(torch.sigmoid(y_logits)) # binary\\n\\n # Reshape preds and plot\\n y_pred = y_pred.reshape(xx.shape).detach().numpy()\\n plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)\\n plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\\n plt.xlim(xx.min(), xx.max())\\n plt.ylim(yy.min(), yy.max())\",\n \"def plot_comparison(original, filtered, filter_name):\\n fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4), sharex=True,\\n sharey=True)\\n ax1.imshow(original, cmap=plt.cm.gray)\\n ax1.set_title('original')\\n ax1.axis('off')\\n ax2.imshow(filtered, cmap=plt.cm.gray)\\n ax2.set_title(filter_name)\\n ax2.axis('off')\",\n \"def plot_comparison(original, filtered, filter_name):\\n fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4), sharex=True,\\n sharey=True)\\n ax1.imshow(original, cmap=plt.cm.gray)\\n ax1.set_title('original')\\n ax1.axis('off')\\n ax2.imshow(filtered, cmap=plt.cm.gray)\\n ax2.set_title(filter_name)\\n ax2.axis('off')\",\n \"def plot_1d_results(model):\\n\\n # Construct grid to evaluate the Green's function\\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\\n x_G_star = X_G.flatten()[:, None]\\n y_G_star = Y_G.flatten()[:, None]\\n input_data = np.concatenate((x_G_star, y_G_star), 1)\\n\\n # Evaluate the Green's function\\n G_pred_identifier = model.sess.run(\\n model.G_network[0][0].evaluate(input_data))\\n G_pred = G_pred_identifier.reshape(X_G.shape)\\n\\n # Evaluate the homogeneous solution\\n N_pred = model.sess.run(model.idn_N_pred[0].evaluate(model.x))\\n\\n # Evaluate exact Green's function\\n try:\\n def G_expression(x, y):\\n return eval(model.ExactGreen + '+ 0*x + 0*y')\\n Exact_idn = G_expression(X_G, Y_G)\\n except Exception:\\n warnings.warn(\\n 'Error in expression for the exact Green\\\\'s function, assuming it is unknown.')\\n Exact_idn = 0 * X_G + 0 * Y_G\\n\\n # Compute and print relative error\\n Mean_Exact_Green = np.square(Exact_idn).mean()\\n L2_norm_Green = np.mean(np.square(Exact_idn - G_pred))\\n if Mean_Exact_Green == 0:\\n output_function = np.sqrt(L2_norm_Green)\\n print('Exact Green\\\\'s function unknown, L2 norm = %g\\\"' % output_function)\\n else:\\n output_function = np.sqrt(L2_norm_Green / Mean_Exact_Green)\\n print('Relative error = %g' % output_function)\\n\\n # Create the figure\\n fig, ax = newfig(1.0, 1.5)\\n ax.axis('off')\\n gs = gridspec.GridSpec(2, 2)\\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9, wspace=0.6, hspace=0.6)\\n\\n # Plot exact Green's function if known\\n ax = plt.subplot(gs[0, 0])\\n if Mean_Exact_Green == 0:\\n ax.text(0.5, 0.5, \\\"Unknown\\\", horizontalalignment='center',\\n verticalalignment='center', transform=ax.transAxes)\\n ax.set_xlim(np.min(model.x_G), np.max(model.x_G))\\n ax.set_ylim(np.min(model.y_G), np.max(model.y_G))\\n else:\\n h = ax.imshow(Exact_idn, interpolation='lanczos', cmap='jet',\\n extent=[np.min(model.x_G), np.max(model.x_G), np.min(\\n model.y_G), np.max(model.y_G)],\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel('$x$')\\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\\n ax.set_title('Exact Green\\\\'s function', fontsize=10)\\n\\n # Plot the learned Green's function\\n ax = plt.subplot(gs[0, 1])\\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\\n extent=[np.min(model.x_G), np.max(model.x_G),\\n np.min(model.y_G), np.max(model.y_G)],\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel('$x$')\\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\\n ax.set_title('Learned Green\\\\'s function', fontsize=10)\\n\\n # Plot training solutions u\\n ax = plt.subplot(gs[1, 0])\\n for i in range(model.u.shape[1]):\\n ax.plot(model.x, model.u[:, i])\\n divider = make_axes_locatable(ax)\\n ax.set_xlim(np.min(model.x), np.max(model.x))\\n ax.set_ylim(np.min(model.u), np.max(model.u))\\n ax.set_xlabel('$x$')\\n ax.set_title('Training solutions', fontsize=10)\\n\\n # Plot the homogeneous solution\\n ax = plt.subplot(gs[1, 1])\\n ax.plot(model.x, model.U_hom, label='Exact')\\n ax.plot(model.x, N_pred, dashes=[2, 2], label='Learned')\\n divider = make_axes_locatable(ax)\\n ax.set_xlim(np.min(model.x), np.max(model.x))\\n # Determine the axis limit\\n ymin = min([np.min(N_pred), np.min(model.U_hom)])\\n ymax = max([np.max(N_pred), np.max(model.U_hom)])\\n ax.set_ylim(ymin, ymax)\\n if ymax - ymin < 1e-2:\\n ax.yaxis.set_major_formatter(MathTextSciFormatter(\\\"%1.1e\\\"))\\n ax.set_xlabel('$x$')\\n ax.set_title('Homogeneous solution', fontsize=10)\\n ax.legend()\\n\\n # Save the figure\\n savefig(\\\"%s/%s_%s\\\" % (model.path_result, model.example_name,\\n model.activation_name), crop=False)\",\n \"def plot_model_fits(self, x_test, plot_opts=dict()):\\n \\n cmodel_color = plot_opts.get('cmodel_color', 'black')\\n dmodel_pre_color = plot_opts.get('dmodel_pre_color', '#cc7d21')\\n dmodel_post_color = plot_opts.get('dmodel_post_color', '#0e2b4d')\\n color_data = plot_opts.get('color_data', '#334431')\\n marker_pre = plot_opts.get('marker_pre', 'x')\\n marker_post = plot_opts.get('marker_post', 'o')\\n marker_size = plot_opts.get('marker_size', 5)\\n marker_alpha = plot_opts.get('marker_alpha', 1.0)\\n plot_effect_size = plot_opts.get('plot_effect_size', True) \\n plot_title = plot_opts.get('plot_title', 'Model fits') \\n plot_samewindow = plot_opts.get('plot_same_window', False)\\n axes = plot_opts.get('axes', None)\\n plot_full_range = plot_opts.get('plot_full_range', \\n self.labelFunc is None) \\n plot_xlim = plot_opts.get('plot_xlim', \\n [np.min(self.x), np.max(self.x)])\\n plot_ylim = plot_opts.get('plot_ylim', \\n [np.min(self.y), np.max(self.y)])\\n \\n if not plot_samewindow:\\n if axes is None:\\n fig, axes = plt.subplots(nrows=self.K, ncols=2, sharex=True, \\n sharey=True, figsize=(12, 6*self.K))\\n else:\\n fig = plt.gcf()\\n \\n for i, kernel_name in enumerate(self.kernel_dict.keys()):\\n self.results[kernel_name].CModel.plot(x_test, axes[i, 0], \\n plotOptions={'color': cmodel_color})\\n self.results[kernel_name].DModel.plot(x_test, axes[i, 1], \\n b=self.b, \\n plotOptions=({'color': dmodel_pre_color}, \\n {'color': dmodel_post_color}), \\n plotEffectSize=plot_effect_size,\\n plotFullRange=plot_full_range)\\n axes[i, 0].set_ylabel(kernel_name)\\n summary = self.results[kernel_name].summary(b=self.b) \\n pmc, pmd = summary['pmp']['pmc'], summary['pmp']['pmd']\\n axes[i, 0].set_title('p(M_C | x, y) = {:0.3f}'.format(pmc))\\n axes[i, 1].set_title('p(M_D | x, y) = {:0.3f}'.format(pmd))\\n else:\\n if axes is None:\\n fig, axes = plt.subplots(nrows=self.K, ncols=1, sharex=True, \\n sharey=True, figsize=(6, 6*self.K))\\n else:\\n fig = plt.gcf()\\n \\n for i, kernel_name in enumerate(self.kernel_dict.keys()):\\n self.results[kernel_name].CModel.plot(x_test, axes[i], \\n plotOptions={'color': cmodel_color})\\n self.results[kernel_name].DModel.plot(x_test, axes[i], \\n b=self.b, \\n plotOptions=({'color': dmodel_pre_color}, \\n {'color': dmodel_post_color}), \\n plotEffectSize=plot_effect_size,\\n plotFullRange=plot_full_range)\\n axes[i].set_ylabel(kernel_name)\\n summary = self.results[kernel_name].summary(b=self.b) \\n pmc, pmd = summary['pmp']['pmc'], summary['pmp']['pmd']\\n axes[i].set_title('p(M_C | x, y) = {:0.3f}, p(M_D | x, y) = {:0.3f}'.format(pmc, pmd))\\n \\n for ax in axes.flatten():\\n ax.axvline(x=self.b, color='black', linestyle='--')\\n if self.labelFunc is None:\\n lab1 = self.labelLUT==0\\n else:\\n lab1 = self.labelFunc(self.x)\\n lab2 = np.logical_not(lab1)\\n ax.plot(self.x[lab1], self.y[lab1], linestyle='None', \\n marker=marker_pre, color=color_data, alpha=marker_alpha, \\n ms=marker_size)\\n ax.plot(self.x[lab2], self.y[lab2], linestyle='None', \\n marker=marker_post, color=color_data, alpha=marker_alpha, \\n ms=marker_size)\\n ax.set_xlim(plot_xlim)\\n ax.set_ylim(plot_ylim)\\n plt.suptitle(plot_title)\\n return fig, axes\",\n \"def plot_for_scaling_check(bolo_name):\\n\\n\\n pop_path = \\\"../Analyse_\\\" + bolo_name + \\\"/Populations/Pop_for_scaling/\\\"\\n\\n #Load the estimator\\n d_est = BDT_fh.open_estimator_file(bolo_name)\\n\\n #Best estimator for heat: coefficients\\n coeff_EC1, coeff_EC2 = float(d_est[\\\"HEAT\\\"][:5]), 1 - float(d_est[\\\"HEAT\\\"][:5])\\n coeff_EIB, coeff_EID = float(d_est[\\\"FID\\\"][:5]), 1-float(d_est[\\\"FID\\\"][:5])\\n\\n #Open event files\\n data_types = {\\\"names\\\": (\\\"EC1\\\", \\\"EC2\\\", \\\"EIA\\\", \\\"EIB\\\", \\\"EIC\\\", \\\"EID\\\"), \\\"formats\\\": (\\\"f\\\", \\\"f\\\", \\\"f\\\", \\\"f\\\", \\\"f\\\", \\\"f\\\")}\\n\\n arr_heatonly = np.loadtxt(pop_path + bolo_name + \\\"_heatonly_KTH_cut_full_info.txt\\\", delimiter=\\\",\\\", dtype=data_types)\\n arr_all = np.loadtxt(pop_path + bolo_name + \\\"_all_KTH_cut_full_info.txt\\\", delimiter=\\\",\\\", dtype=data_types)\\n arr_FidGamma = np.loadtxt(pop_path + bolo_name + \\\"_FidGamma_KTH_cut_full_info.txt\\\", delimiter=\\\",\\\", dtype=data_types)\\n arr_S1Gamma = np.loadtxt(pop_path + bolo_name + \\\"_S1Gamma_KTH_cut_full_info.txt\\\", delimiter=\\\",\\\", dtype=data_types)\\n arr_S2Gamma = np.loadtxt(pop_path + bolo_name + \\\"_S2Gamma_KTH_cut_full_info.txt\\\", delimiter=\\\",\\\", dtype=data_types)\\n arr_S1Beta = np.loadtxt(pop_path + bolo_name + \\\"_S1Beta_KTH_cut_full_info.txt\\\", delimiter=\\\",\\\", dtype=data_types)\\n arr_S2Beta = np.loadtxt(pop_path + bolo_name + \\\"_S2Beta_KTH_cut_full_info.txt\\\", delimiter=\\\",\\\", dtype=data_types)\\n arr_S1Pb = np.loadtxt(pop_path + bolo_name + \\\"_S1Pb_KTH_cut_full_info.txt\\\", delimiter=\\\",\\\", dtype=data_types)\\n arr_S2Pb = np.loadtxt(pop_path + bolo_name + \\\"_S2Pb_KTH_cut_full_info.txt\\\", delimiter=\\\",\\\", dtype=data_types)\\n\\n arr_EI_heatonly, arr_EI_all = coeff_EIB*arr_heatonly[\\\"EIB\\\"] + coeff_EID*arr_heatonly[\\\"EID\\\"], coeff_EIB*arr_all[\\\"EIB\\\"] + coeff_EID*arr_all[\\\"EID\\\"]\\n arr_EC_heatonly, arr_EC_all = coeff_EC1*arr_heatonly[\\\"EC1\\\"] + coeff_EC2*arr_heatonly[\\\"EC2\\\"], coeff_EC1*arr_all[\\\"EC1\\\"] + coeff_EC2*arr_all[\\\"EC2\\\"]\\n arr_EI_FidGamma, arr_EC_FidGamma = coeff_EIB*arr_FidGamma[\\\"EIB\\\"] + coeff_EID*arr_FidGamma[\\\"EID\\\"], coeff_EC1*arr_FidGamma[\\\"EC1\\\"] + coeff_EC2*arr_FidGamma[\\\"EC2\\\"]\\n arr_EI_S1Gamma, arr_EI_S2Gamma = coeff_EIB*arr_S1Gamma[\\\"EIB\\\"] + coeff_EID*arr_S1Gamma[\\\"EID\\\"], coeff_EIB*arr_S2Gamma[\\\"EIB\\\"] + coeff_EID*arr_S2Gamma[\\\"EID\\\"]\\n arr_EC_S1Gamma, arr_EC_S2Gamma = coeff_EC1*arr_S1Gamma[\\\"EC1\\\"] + coeff_EC2*arr_S1Gamma[\\\"EC2\\\"], coeff_EC1*arr_S2Gamma[\\\"EC1\\\"] + coeff_EC2*arr_S2Gamma[\\\"EC2\\\"]\\n arr_EI_S1Beta, arr_EI_S2Beta = coeff_EIB*arr_S1Beta[\\\"EIB\\\"] + coeff_EID*arr_S1Beta[\\\"EID\\\"], coeff_EIB*arr_S2Beta[\\\"EIB\\\"] + coeff_EID*arr_S2Beta[\\\"EID\\\"]\\n arr_EC_S1Beta, arr_EC_S2Beta = coeff_EC1*arr_S1Beta[\\\"EC1\\\"] + coeff_EC2*arr_S1Beta[\\\"EC2\\\"], coeff_EC1*arr_S2Beta[\\\"EC1\\\"] + coeff_EC2*arr_S2Beta[\\\"EC2\\\"]\\n arr_EI_S1Pb, arr_EI_S2Pb = coeff_EIB*arr_S1Pb[\\\"EIB\\\"] + coeff_EID*arr_S1Pb[\\\"EID\\\"], coeff_EIB*arr_S2Pb[\\\"EIB\\\"] + coeff_EID*arr_S2Pb[\\\"EID\\\"]\\n arr_EC_S1Pb, arr_EC_S2Pb = coeff_EC1*arr_S1Pb[\\\"EC1\\\"] + coeff_EC2*arr_S1Pb[\\\"EC2\\\"], coeff_EC1*arr_S2Pb[\\\"EC1\\\"] + coeff_EC2*arr_S2Pb[\\\"EC2\\\"]\\n\\n lS1Beta, lS2Beta, lS1Pb, lS2Pb = np.where(arr_EC_S1Beta<15), np.where(arr_EC_S2Beta<15), np.where(arr_EC_S1Pb<15), np.where(arr_EC_S2Pb<15)\\n lS1Gamma, lS2Gamma, lFidGamma = np.where(arr_EC_S1Gamma<15), np.where(arr_EC_S2Gamma<15), np.where(arr_EC_FidGamma<15)\\n lheatonly, lall = np.where(arr_EC_heatonly<15), np.where(arr_EC_all<15)\\n\\n arr_EI_heatonly, arr_EC_heatonly = arr_EI_heatonly[lheatonly], arr_EC_heatonly[lheatonly]\\n arr_EI_all, arr_EC_all = arr_EI_all[lall], arr_EC_all[lall]\\n arr_EI_FidGamma, arr_EC_FidGamma = arr_EI_FidGamma[lFidGamma], arr_EC_FidGamma[lFidGamma]\\n arr_EI_S1Gamma, arr_EC_S1Gamma = arr_EI_S1Gamma[lS1Gamma], arr_EC_S1Gamma[lS1Gamma]\\n arr_EI_S2Gamma, arr_EC_S2Gamma = arr_EI_S2Gamma[lS2Gamma], arr_EC_S2Gamma[lS2Gamma]\\n arr_EI_S1Beta, arr_EC_S1Beta = arr_EI_S1Beta[lS1Beta], arr_EC_S1Beta[lS1Beta]\\n arr_EI_S2Beta, arr_EC_S2Beta = arr_EI_S2Beta[lS2Beta], arr_EC_S2Beta[lS2Beta]\\n arr_EI_S1Pb, arr_EC_S1Pb = arr_EI_S1Pb[lS1Pb], arr_EC_S1Pb[lS1Pb]\\n arr_EI_S2Pb, arr_EC_S2Pb = arr_EI_S2Pb[lS2Pb], arr_EC_S2Pb[lS2Pb]\\n\\n arr_EI_all, arr_EC_all = np.array(arr_EI_all).astype(float), np.array(arr_EC_all).astype(float)\\n arr_EI_heatonly, arr_EC_heatonly = np.array(arr_EI_heatonly).astype(float), np.array(arr_EC_heatonly).astype(float)\\n arr_EI_FidGamma, arr_EC_FidGamma = np.array(arr_EI_FidGamma).astype(float), np.array(arr_EC_FidGamma).astype(float)\\n arr_EI_S1Gamma, arr_EC_S1Gamma = np.array(arr_EI_S1Gamma).astype(float), np.array(arr_EC_S1Gamma).astype(float)\\n arr_EI_S2Gamma, arr_EC_S2Gamma = np.array(arr_EI_S2Gamma).astype(float), np.array(arr_EC_S2Gamma).astype(float) \\n arr_EI_S1Beta, arr_EC_S1Beta = np.array(arr_EI_S1Beta).astype(float), np.array(arr_EC_S1Beta).astype(float)\\n arr_EI_S2Beta, arr_EC_S2Beta = np.array(arr_EI_S2Beta).astype(float), np.array(arr_EC_S2Beta).astype(float)\\n arr_EI_S1Pb, arr_EC_S1Pb = np.array(arr_EI_S1Pb).astype(float), np.array(arr_EC_S1Pb).astype(float)\\n arr_EI_S2Pb, arr_EC_S2Pb = np.array(arr_EI_S2Pb).astype(float), np.array(arr_EC_S2Pb).astype(float)\\n\\n\\n gr_heatonly = TGraph(len(arr_EI_heatonly), arr_EC_heatonly, arr_EI_heatonly)\\n gr_FidGamma, gr_all = TGraph(len(arr_EI_FidGamma), arr_EC_FidGamma, arr_EI_FidGamma), TGraph(len(arr_EI_all), arr_EC_all, arr_EI_all)\\n gr_S1Gamma, gr_S2Gamma = TGraph(len(arr_EI_S1Gamma), arr_EC_S1Gamma, arr_EI_S1Gamma), TGraph(len(arr_EI_S2Gamma), arr_EC_S2Gamma, arr_EI_S2Gamma)\\n gr_S1Beta, gr_S2Beta = TGraph(len(arr_EI_S1Beta), arr_EC_S1Beta, arr_EI_S1Beta), TGraph(len(arr_EI_S2Beta), arr_EC_S2Beta, arr_EI_S2Beta)\\n gr_S1Pb, gr_S2Pb = TGraph(len(arr_EI_S1Pb), arr_EC_S1Pb, arr_EI_S1Pb), TGraph(len(arr_EI_S2Pb), arr_EC_S2Pb, arr_EI_S2Pb)\\n\\n PyRPl.process_TGraph(gr_all, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\", color=kRed, marker_style = 20, marker_size = 0.1)\\n PyRPl.process_TGraph(gr_FidGamma, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\", color=kBlack), PyRPl.process_TGraph(gr_heatonly, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\", color=kBlack)\\n PyRPl.process_TGraph(gr_S1Gamma, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\", color=kBlack), PyRPl.process_TGraph(gr_S2Gamma, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\", color=kBlack)\\n PyRPl.process_TGraph(gr_S1Beta, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\", color=kBlack), PyRPl.process_TGraph(gr_S2Beta, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\", color=kBlack)\\n PyRPl.process_TGraph(gr_S1Pb, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\", color=kRed), PyRPl.process_TGraph(gr_S2Pb, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\", color=kBlack)\\n\\n list_gr = [gr_all, gr_FidGamma, gr_S1Gamma, gr_S2Gamma, gr_S1Beta, gr_S2Beta, gr_S1Pb, gr_S2Pb, gr_heatonly]\\n list_pts = [gr.GetN() for gr in list_gr[1:]]\\n print gr_all.GetN(), sum(list_pts)\\n h = TH2F(\\\"h\\\", \\\"h\\\", 100, -5, 15, 100, -5, 15)\\n PyRPl.process_TH2(h, X_title = \\\"Heat\\\", Y_title = \\\"Ion\\\")\\n h.Draw()\\n for gr in list_gr:\\n gr.Draw(\\\"*same\\\")\\n\\n raw_input()\\n\\n # arr_Q_S1Beta = arr_EI_S1Beta/((1+8./3)*arr_EC_S1Beta - arr_EI_S1Beta*5.5/3)\\n # arr_Q_S2Beta = arr_EI_S1Beta/((1+8./3)*arr_EC_S1Beta - arr_EI_S1Beta*5.5/3)\\n # arr_Q_S1Pb = arr_EI_S1Pb/((1+8./3)*arr_EC_S1Pb - arr_EI_S1Pb*5.5/3)\\n # arr_Q_S2Pb = arr_EI_S2Pb/((1+8./3)*arr_EC_S2Pb - arr_EI_S2Pb*5.5/3)\\n \\n # gr_QS1Beta, gr_QS2Beta = TGraph(len(arr_Q_S1Beta), arr_EC_S1Beta, arr_Q_S1Beta), TGraph(len(arr_Q_S2Beta), arr_EC_S2Beta, arr_Q_S2Beta)\\n # gr_QS1Pb, gr_QS2Pb = TGraph(len(arr_Q_S1Pb), arr_EC_S1Pb, arr_Q_S1Pb), TGraph(len(arr_Q_S2Pb), arr_EC_S2Pb, arr_Q_S2Pb)\\n\\n\\n # PyRPl.process_TGraph(gr_QS1Beta, X_title = \\\"Heat\\\", Y_title = \\\"Q\\\", color=kOrange-3), PyRPl.process_TGraph(gr_QS2Beta, X_title = \\\"Heat\\\", Y_title = \\\"Q\\\", color=kBlue)\\n # PyRPl.process_TGraph(gr_QS1Pb, X_title = \\\"Heat\\\", Y_title = \\\"Q\\\", color=kRed), PyRPl.process_TGraph(gr_QS2Pb, X_title = \\\"Heat\\\", Y_title = \\\"Q\\\", color=kGreen+2)\",\n \"def plot(model, center, extent, outname):\\n # define model grid\\n xg = np.linspace(-extent, extent, model.shape[0])\\n yg = xg.copy()\\n interp_func = RectBivariateSpline(xg, yg, model)\\n\\n x = np.array([-2, -1, 0, 1, 2]) + center[0]\\n y = np.array([-2, -1, 0, 1, 2]) + center[1]\\n psf = interp_func(x, y)\\n\\n x, y = np.meshgrid(x, y)\\n f = pl.figure(figsize=(10, 5))\\n\\n pl.gray()\\n ax1 = pl.subplot(121)\\n ax1.imshow(model, interpolation='nearest', origin='lower',\\n extent=(-extent, extent, -extent, extent),\\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\\n ax1.plot(x, y, 's', mec='r', mfc='none', mew=2)\\n\\n pl.xlim(-2.5, 2.5)\\n pl.ylim(-2.5, 2.5)\\n ax2 = pl.subplot(122)\\n ax2.imshow(psf, interpolation='nearest', origin='lower',\\n extent=(-extent, extent, -extent, extent),\\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\\n\\n ax2.set_xticks([-2, -1, 0, 1, 2])\\n ax2.set_yticks([-2, -1, 0, 1, 2])\\n ax2.set_xticklabels(['%0.3f' % v for v in x[0]])\\n ax2.set_yticklabels(['%0.3f' % v for v in y[:, 0]])\\n\\n coordsA, coordsB = \\\"data\\\", \\\"data\\\"\\n pixels = np.array([[0.0, 0.0], [2., 2.], [-1., -1.]])\\n locs = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, -0.5]])\\n rads = [0.15, 0.25, -0.25]\\n for i, p in enumerate(pixels):\\n xy1 = p + center\\n xy2 = p + locs[i]\\n con = ConnectionPatch(xyA=xy2, xyB=xy1, coordsA=coordsA,\\n coordsB=coordsB, axesA=ax2, axesB=ax1,\\n arrowstyle=\\\"<-, head_length=1.2, head_width=0.8\\\", \\n shrinkB=5,\\n connectionstyle='arc3, rad=%s' % rads[i],\\n color='r', lw=2)\\n ax2.add_artist(con)\\n ax2.plot(p[0], p[1], 's', mfc='none', mec='r', mew=2, ms=50)\\n\\n #pl.xlim(-2.5, 2.5)\\n #pl.ylim(-2.5, 2.5)\\n f.savefig(outname)\",\n \"def plot_distmodel(objective, refl_mode='rq4', maxd=1000):\\n fig, [ax1, ax2, ax3] = plt.subplots(1, 3, figsize=(10, 3), dpi=150)\\n\\n q = objective.data.x\\n r = objective.data.y\\n r_err = objective.data.y_err\\n\\n if refl_mode == 'rq4':\\n q4 = q**4\\n txt_loc2 = 'bottom'\\n else:\\n q4 = 1\\n txt_loc2 = 'top'\\n\\n if type(objective.model) == MetaModel:\\n distmodel = objective.model.models[0]\\n distscale = objective.model.scales[0]\\n h2omodel = objective.model.models[1]\\n h2oscale = objective.model.scales[1]\\n\\n ax1.plot(*h2omodel.structure.sld_profile(), color='b', alpha=1, lw=1)\\n ax2.plot(q, h2omodel(q)*q4*h2oscale, color='b', alpha=1, lw=1)\\n ax2.plot(q, distmodel(q)*q4*distscale, color='red', alpha=1, lw=1)\\n\\n scales = objective.model.scales\\n ax2.text(0.95, 0.23, 'mScales: %0.3f, %0.3f' % (scales[0].value, scales[1].value),\\n ha='right', va=txt_loc2, size='small',\\n transform=ax2.transAxes)\\n\\n else:\\n distmodel = objective.model\\n distscale = 1\\n\\n maxscale = np.max(distmodel.scales)\\n\\n # Need to call the model to refresh parameters\\n objective.model(q)\\n\\n d = np.linspace(0, maxd, 5000)\\n pdf = distmodel.pdf(d, **distmodel.pdf_kwargs)\\n ax3.plot(d, pdf)\\n\\n for struct, scale in zip(distmodel.structures, distmodel.scales):\\n normscale = np.min([1, np.max([scale/maxscale, 0.001])])\\n\\n ax1.plot(*struct.sld_profile(), color='xkcd:crimson',\\n alpha=normscale, lw=1)\\n\\n dummy_model = ReflectModel(struct, bkg=objective.model.bkg.value)\\n\\n ax2.plot(q, dummy_model.model(q)*q4*normscale*distscale,\\n alpha=normscale*0.5, color='xkcd:crimson', lw=1)\\n\\n thick = struct[2].thick.value\\n\\n ax3.scatter(thick, np.interp(thick, d, pdf), marker='.', color='k',\\n alpha=normscale)\\n\\n ax2.plot(q, objective.model(q)*q4, color='k', alpha=1)\\n ax2.errorbar(q, r*q4, yerr=r_err*q4, color='b', alpha=0.5)\\n ax2.set_yscale('log')\\n\\n ax1.set_xlabel('Thickness, $\\\\mathrm{\\\\AA}$')\\n ax1.set_ylabel('SLD, $\\\\mathrm{\\\\AA}^{-2}$')\\n ax2.set_xlabel('$Q$, $\\\\mathrm{\\\\AA}^{-1}$')\\n ax2.set_ylabel('$R$')\\n ax3.set_xlabel('Thickness, $\\\\mathrm{\\\\AA}$')\\n\\n kwargs = distmodel.pdf_kwargs\\n for i, key in enumerate(kwargs):\\n ax3.text(0.95, 0.95-0.06*i, '%s: %0.4f' % (key, kwargs[key]),\\n ha='right', va='top', size='small',\\n transform=ax3.transAxes)\\n\\n i = 0\\n for p in distmodel.master_structure.parameters.flattened():\\n if p.vary is True:\\n ax1.text(0.95, 0.05+0.06*i, '%s: %0.3f' % (p.name, p.value),\\n ha='right', va='bottom', size='small',\\n transform=ax1.transAxes)\\n i += 1\\n\\n ax2.text(0.95, 0.17, 'background: %d' % objective.model.bkg.value,\\n ha='right', va=txt_loc2, size='small',\\n transform=ax2.transAxes)\\n# ax2.text(0.95, 0.05, 'lnprob: %d' % (objective.logpost()),\\n# ha='right', va=txt_loc2, size='small',\\n# transform=ax2.transAxes)\\n ax2.text(0.95, 0.11, 'chisqr: %d' % (objective.chisqr()),\\n ha='right', va=txt_loc2, size='small',\\n transform=ax2.transAxes)\\n\\n ax1.set_xbound(-50, maxd)\\n fig.tight_layout()\",\n \"def models_comparison_plot(self, roc_curves, precision_recall_curves, det_curves, target_proportion):\\n new_tps = [assess_models_names(tp) for tp in [roc_curves, precision_recall_curves, det_curves]]\\n roc_curves, precision_recall_curves, det_curves = new_tps\\n\\n # ROC\\n roc_plot = Panel(\\n child=self._roc_plot(roc_curves),\\n title=self._roc_plot_name\\n )\\n # Precision-Recall\\n precision_recall_plot = Panel(\\n child=self._precision_recall_plot(precision_recall_curves, target_proportion),\\n title=self._precision_recall_plot_name\\n )\\n # DET\\n det_plot = Panel(\\n child=self._det_plot(det_curves),\\n title=self._det_plot_name\\n )\\n\\n # Final Plot\\n main_plot = Tabs(tabs=[roc_plot, precision_recall_plot, det_plot])\\n\\n return main_plot\",\n \"def plot_components(component1, component2, df, name):\\n\\n # Create figure and plot input data onto first two components\\n plt.figure()\\n colors = sns.color_palette('hls', len(np.unique(df['y'])))\\n sns.scatterplot(x=component1, y=component2, hue='y', palette=colors, data=df, legend='full', alpha=0.3)\\n\\n # Annotate standard deviation arrows for the two components\\n plt.annotate('', xy=(np.std(df[component1]), 0), xytext=(0, 0), arrowprops=dict(arrowstyle='->', color='orange', lw=3))\\n plt.annotate('', xy=(0, np.std(df[component2])), xytext=(0, 0), arrowprops=dict(arrowstyle='->', color='orange', lw=3))\\n\\n # Set title and axes limits\\n plt.title('{} Transformation with first 2 components and true labels'.format(name.upper()))\\n xlim = 1.1 * np.max(np.abs(df[component1]))\\n ylim = 1.1 * np.max(np.abs(df[component2]))\\n plt.xlim(-xlim, xlim)\\n plt.ylim(-ylim, ylim)\",\n \"def comparison_plot(X, Y, title):\\n linreg = scipy.stats.linregress(X, Y)\\n\\n x_txt = rel_pos(X, 0.95)\\n y_txt = rel_pos(Y, 0)\\n\\n plt.scatter(X, Y)\\n plt.xlabel('B-S')\\n plt.ylabel('S-B')\\n if title == 'RouteScore':\\n plt.xscale('log')\\n plt.yscale('log')\\n if len(set(X)) > 1 or len(set(Y)) > 1:\\n plt.text(x_txt, y_txt,\\n f'slope = {round(linreg.slope, 2)}\\\\n$R^{2}$ = {round(linreg.rvalue,2)}',\\n horizontalalignment='right',\\n verticalalignment='bottom')\\n plt.xlim(0.95 * min(X), 1.05 * max(X))\\n plt.ylim(0.95 * min(Y), 1.05 * max(Y))\\n plt.savefig(os.path.join(FIG_DIR, f'BSvsSB {title}.png'))\\n plt.show()\",\n \"def plot_scatter(self):\\n if Trainer.y_pred is None or Trainer.y_true is None:\\n messagebox.showerror(\\\"Information\\\", \\\"Please train the model first before plotting\\\")\\n return\\n\\n fig = plt.figure(figsize=(8, 4))\\n plt.xlabel(\\\"Prediction\\\")\\n plt.ylabel(\\\"Target\\\")\\n plt.figtext(0, 0, f\\\"RMSE: {self.test_rmse}\\\", fontsize=13)\\n plt.grid()\\n plt.scatter(x=Trainer.y_true, y=Trainer.y_pred, c='b', s=1)\\n\\n win = tk.Toplevel()\\n win.wm_title(\\\"Window\\\")\\n win.geometry(\\\"1000x500\\\")\\n\\n # specify the window as master\\n canvas = FigureCanvasTkAgg(fig, master=win)\\n canvas.draw()\\n canvas.get_tk_widget().grid(row=0, column=0, sticky=tk.W)\\n\\n # navigation toolbar\\n toolbarFrame = tk.Frame(master=win)\\n toolbarFrame.grid(row=1, column=0)\\n toolbar = NavigationToolbar2Tk(canvas, toolbarFrame)\",\n \"def plot_results(self):\\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))\",\n \"def plotCoefficients(model):\\n\\n coefs = pd.DataFrame(model.coef_, X_train.columns)\\n coefs.columns = [\\\"coef\\\"]\\n coefs[\\\"abs\\\"] = coefs.coef.apply(np.abs)\\n coefs = coefs.sort_values(by=\\\"abs\\\", ascending=False).drop([\\\"abs\\\"], axis=1)\\n\\n plt.figure(figsize=(15, 7))\\n plt.title('sorted coefficient values of the model')\\n coefs.coef.plot(kind='bar')\\n plt.grid(True, axis='y')\\n plt.hlines(y=0, xmin=0, xmax=len(coefs), linestyles='dashed');\\n plt.draw()\",\n \"def plot_MCMC_results(xdata, ydata, trace, colors='k'):\\n fig, ax = plt.subplots(1, 1, figsize=(8, 5))\\n plt.title(' 68 and 95 percent joint confidence intervals on b and m')\\n plot_MCMC_trace(ax, xdata, ydata, trace, True, colors=colors)\\n # plot_MCMC_model(ax[1], xdata, ydata, trace)\",\n \"def plot_interaction_map(model, name, matrix, output_name, first_variable, second_variable, x_coord, y_coord, output_path): \\n import matplotlib\\n import matplotlib.cm as cm\\n import matplotlib.pyplot as plt\\n\\n font = {'size' : 14}\\n\\n matplotlib.rc('font', **font)\\n fig = plt.figure(figsize=(5,5))\\n ax = plt.subplot()\\n\\n maxValue = np.max(np.abs(matrix))\\n img = ax.imshow((matrix), cmap = cm.bwr, origin='lower', vmin = -min(maxValue, 6), vmax = min(maxValue, 6), interpolation='spline16')\\n\\n first_variable = '{}'.format(first_variable)\\n second_variable = '{}'.format(second_variable)\\n ax.set_ylabel(r'$x_i$ = ' + first_variable)\\n ax.set_xlabel(r'$y_i$ = ' + second_variable)\\n ax.axes.set_xticks([0, 50, 99])\\n ax.axes.set_yticks([0, 50, 99])\\n xticks = np.linspace(np.array(model.feature_limits[first_variable]).min(), np.array(model.feature_limits[first_variable]).max(), 3)\\n yticks = np.linspace(np.array(model.feature_limits[second_variable]).min(), np.array(model.feature_limits[second_variable]).max(), 3)\\n ax.scatter([x_coord], [y_coord], marker='o', color='white', s = 250, edgecolors='black', linewidth=3)\\n\\n ax.set_yticklabels([xticks[tind] for tind in range(3)])\\n ax.set_xticklabels([yticks[tind] for tind in range(3)])\\n ax.axis([0, (100) - 1, 0, (100) - 1])\\n\\n # ax.scatter([x_coord_linear], [y_coord_linear], marker='o', color='blue', s = 250, edgecolors='black', linewidth=3)\\n t = ax.set_title(r'$\\\\mathregular{\\\\frac{\\\\delta ^2 F(\\\\bar{x})}{\\\\delta x_i \\\\delta x_j}}$')\\n # t = ax.set_title('{} and {} - '.format(first_variable, second_variable) + r'$\\\\mathregular{\\\\frac{\\\\delta ^2 F(\\\\bar{x})}{\\\\delta x_i \\\\delta x_j}}$')\\n t.set_position([.5, 1.025])\\n from mpl_toolkits.axes_grid1 import make_axes_locatable\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n cb = plt.colorbar(img, cax=cax)\\n cb.set_label(\\\"Nomralized mixed derivative\\\", rotation=90)\\n plt.savefig('{}/{}_{}_{}_{}_nonlinear_map.pdf'.format(output_path, name, output_name, first_variable, second_variable), transparent=True, bbox_inches='tight', format='pdf', dpi=600)\\n # plt.close('all')\",\n \"def plot_bv_join(df, xcolname, ycolname, kindname='hist', xlogflag=False, ylogflag=False, icol=4):\\n # set plot size\\n fig, ax = plt.subplots(figsize=(8,6))\\n \\n # plotting... jointplot\\n sns.jointplot(ax = ax, data = df\\n , x = str(xcolname)\\n , y = str(ycolname)\\n , kind = kindname\\n , color = sns.color_palette()[icol]);\\n \\n\\n # log scale or not\\n if (ylogflag): plt.yscale('log')\\n \\n \\n # title and labels\\n plt.title(xcolname+' Vs '+ycolname, fontsize=20)\\n plt.xlabel(xcolname+ ' (units)', fontsize=16)\\n plt.ylabel(ycolname+ ' (units)', fontsize=16)\\n \\n return plt.show()\",\n \"def makeComparsionChart(columns, data):\\n fig = plt.figure(figsize=(16, 10))\\n gs = gridspec.GridSpec(2, 3, wspace = 0.2, hspace=0.2, right=0.96, left=0.04)\\n ax1 = plt.subplot(gs[0, 0:1], label=\\\"\\\")\\n ax2 = plt.subplot(gs[0, 1:2], label=\\\"\\\" )\\n ax3 = plt.subplot(gs[0, 2:3], label=\\\"\\\" )\\n ax4 = plt.subplot(gs[1, 0:1], label=\\\"\\\" )\\n ax5 = plt.subplot(gs[1, 1:2], label=\\\"\\\" )\\n ax1.set_title('Before Scaling')\\n ax2.set_title('After Standard Scaler')\\n ax3.set_title('After Min-Max Scaler')\\n ax4.set_title('After Roboust Scaler')\\n ax5.set_title('After Normalization')\\n\\n for column in columns:\\n sns.kdeplot(data[0][column], ax=ax1, legend=False)\\n sns.kdeplot(data[1][column], ax=ax2, legend=False)\\n sns.kdeplot(data[2][column], ax=ax3, legend=False)\\n sns.kdeplot(data[3][column], ax=ax4, legend=False)\\n sns.kdeplot(data[4][column], ax=ax5, legend=False)\\n\\n plt.show()\",\n \"def test_2d_plot(self):\\n db = pd.HDFStore('test.h5')\\n df_iv = db['iv']\\n dates = df_iv[df_iv['dte'] == 30]['date']\\n impl_vols = df_iv[df_iv['dte'] == 30]['impl_vol']\\n db.close()\\n\\n print df_iv.sort_values('impl_vol').head()\\n\\n plt.plot(dates, impl_vols)\\n plt.xlabel('date')\\n plt.ylabel('impl_vols')\\n plt.show()\",\n \"def plot_comparaison_filter2():\\n dir = \\\"log/NY/peps mini\\\"\\n pattern = r'(internal|access|lock)\\\\\\\\\\\\d{1,2}.csv$'\\n pattern_valid = r'(3|6|9|12).csv$'\\n df_report = pd.DataFrame()\\n filters = ['Raw', 'ULimiter', 'BLimiter', 'TA:n=5', 'TA:n=10', 'LSA:n=5', 'LSA:n=10']\\n for index, name in enumerate(filters):\\n print('Filter: ' + name)\\n utils.construct_set(dir, pattern, pattern_valid, filter=index)\\n X_train, X_valid, y_train, y_valid = utils.load_train_valid()\\n cm, report_temp, classes = utils.train(X_train, X_valid, y_train, y_valid, method='RF',\\n param={\\\"max_features\\\": 2, \\\"n_estimators\\\": 100})\\n df_report = df_report.append(report_temp, ignore_index=True)\\n df_report.index = filters\\n df_report.plot(kind='bar', rot=0, ylim=(0.8, 0.95))\\n df_report.to_csv('data/comparaison_filter.csv', sep=';')\",\n \"def plot_result(data, gt_y, pred_y):\\n assert data.shape[0] == gt_y.shape[0]\\n assert data.shape[0] == pred_y.shape[0]\\n\\n plt.figure()\\n\\n plt.subplot(1, 2, 1)\\n plt.title('Ground Truth', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if gt_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.subplot(1, 2, 2)\\n plt.title('Prediction', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if pred_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.show()\",\n \"def plot_result(data, gt_y, pred_y):\\n assert data.shape[0] == gt_y.shape[0]\\n assert data.shape[0] == pred_y.shape[0]\\n\\n plt.figure()\\n\\n plt.subplot(1, 2, 1)\\n plt.title('Ground Truth', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if gt_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.subplot(1, 2, 2)\\n plt.title('Prediction', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if pred_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.show()\",\n \"def onselect(xmin, xmax): \\n # convert matplotlib float dates to a datetime format\\n date_min = mdates.num2date(xmin)\\n date_max = mdates.num2date(xmax) \\n \\n # put the xmin and xmax in datetime format to compare\\n date_min = datetime.datetime(date_min.year, date_min.month, date_min.day, date_min.hour, date_min.minute) \\n date_max = datetime.datetime(date_max.year, date_max.month, date_max.day, date_max.hour, date_max.minute)\\n \\n # find the indices that were selected \\n indices = np.where((comp_data['dates'] >= date_min) & (comp_data['dates'] <= date_max))\\n indices = indices[0]\\n \\n # set the data in ax2 plot\\n plot2a.set_data(comp_data['dates'][indices], comp_data['observed_parameter'][indices])\\n plot2b.set_data(comp_data['dates'][indices], comp_data['modeled_parameter'][indices])\\n \\n # calculate updated stats \\n updated_r_squared_coeff = statistics.r_squared(modeled = comp_data['modeled_parameter'][indices], observed = comp_data['observed_parameter'][indices])\\n updated_nash_sutcliffe_coeff = statistics.nash_sutcliffe(modeled = comp_data['modeled_parameter'][indices], observed = comp_data['observed_parameter'][indices])\\n \\n ax2.set_xlim(comp_data['dates'][indices][0], comp_data['dates'][indices][-1])\\n param_max = np.max((comp_data['observed_parameter'][indices], comp_data['modeled_parameter'][indices]))\\n param_min = np.min((comp_data['observed_parameter'][indices], comp_data['modeled_parameter'][indices]))\\n ax2.set_ylim(param_min, param_max)\\n \\n # show text of mean, max, min values on graph; use matplotlib.patch.Patch properies and bbox\\n text2 = 'R_squared = %.2f\\\\nNash sutcliffe = %.2f' % (updated_r_squared_coeff, updated_nash_sutcliffe_coeff)\\n \\n ax2_text.set_text(text2)\\n \\n # set the data in ax4 plot\\n plot4a.set_data(comp_data['dates'][indices], comp_data['stats']['relative_error'][indices])\\n plot4b.set_data(comp_data['dates'][indices], comp_data['stats']['relative_error'][indices])\\n \\n # calculate updated mean, max, min for stats data\\n stat_mean = np.mean(comp_data['stats']['relative_error'][indices])\\n stat_max = np.max(comp_data['stats']['relative_error'][indices])\\n stat_min = np.min(comp_data['stats']['relative_error'][indices])\\n \\n ax4.set_xlim(comp_data['dates'][indices][0], comp_data['dates'][indices][-1])\\n ax4.set_ylim(stat_min, stat_max)\\n \\n # show text of mean, max, min values on graph; use matplotlib.patch.Patch properies and bbox\\n text4 = 'Mean = %.2f\\\\nMax = %.2f\\\\nMin = %.2f' % (stat_mean, stat_max, stat_min)\\n \\n ax4_text.set_text(text4) \\n \\n fig.canvas.draw()\",\n \"def figures_2d(\\r\\n self,\\r\\n data: bool = False,\\r\\n noise_map: bool = False,\\r\\n signal_to_noise_map: bool = False,\\r\\n model_image: bool = False,\\r\\n residual_map: bool = False,\\r\\n normalized_residual_map: bool = False,\\r\\n chi_squared_map: bool = False,\\r\\n use_source_vmax : bool = False,\\r\\n suffix: str = \\\"\\\",\\r\\n ):\\r\\n\\r\\n visuals_2d = self.get_visuals_2d()\\r\\n\\r\\n visuals_2d_no_critical_caustic = self.get_visuals_2d()\\r\\n visuals_2d_no_critical_caustic.tangential_critical_curves = None\\r\\n visuals_2d_no_critical_caustic.radial_critical_curves = None\\r\\n visuals_2d_no_critical_caustic.tangential_caustics = None\\r\\n visuals_2d_no_critical_caustic.radial_caustics = None\\r\\n visuals_2d_no_critical_caustic.origin = None\\r\\n visuals_2d_no_critical_caustic.light_profile_centres = None\\r\\n visuals_2d_no_critical_caustic.mass_profile_centres = None\\r\\n\\r\\n if data:\\r\\n\\r\\n if use_source_vmax:\\r\\n self.mat_plot_2d.cmap.kwargs[\\\"vmax\\\"] = np.max(self.fit.model_images_of_planes_list[-1])\\r\\n\\r\\n self.mat_plot_2d.plot_array(\\r\\n array=self.fit.data,\\r\\n visuals_2d=visuals_2d_no_critical_caustic,\\r\\n auto_labels=AutoLabels(title=\\\"Data\\\", filename=f\\\"data{suffix}\\\"),\\r\\n )\\r\\n\\r\\n if use_source_vmax:\\r\\n self.mat_plot_2d.cmap.kwargs.pop(\\\"vmax\\\")\\r\\n\\r\\n if noise_map:\\r\\n\\r\\n self.mat_plot_2d.plot_array(\\r\\n array=self.fit.noise_map,\\r\\n visuals_2d=visuals_2d_no_critical_caustic,\\r\\n auto_labels=AutoLabels(\\r\\n title=\\\"Noise-Map\\\", filename=f\\\"noise_map{suffix}\\\"\\r\\n ),\\r\\n )\\r\\n\\r\\n if signal_to_noise_map:\\r\\n\\r\\n self.mat_plot_2d.plot_array(\\r\\n array=self.fit.signal_to_noise_map,\\r\\n visuals_2d=visuals_2d_no_critical_caustic,\\r\\n auto_labels=AutoLabels(\\r\\n title=\\\"Signal-To-Noise Map\\\", cb_unit=\\\" S/N\\\", filename=f\\\"signal_to_noise_map{suffix}\\\"\\r\\n ),\\r\\n )\\r\\n\\r\\n if model_image:\\r\\n\\r\\n if use_source_vmax:\\r\\n self.mat_plot_2d.cmap.kwargs[\\\"vmax\\\"] = np.max(self.fit.model_images_of_planes_list[-1])\\r\\n\\r\\n self.mat_plot_2d.plot_array(\\r\\n array=self.fit.model_data,\\r\\n visuals_2d=visuals_2d,\\r\\n auto_labels=AutoLabels(\\r\\n title=\\\"Model Image\\\", filename=f\\\"model_image{suffix}\\\"\\r\\n ),\\r\\n )\\r\\n\\r\\n if use_source_vmax:\\r\\n self.mat_plot_2d.cmap.kwargs.pop(\\\"vmax\\\")\\r\\n\\r\\n cmap_original = self.mat_plot_2d.cmap\\r\\n\\r\\n if self.residuals_symmetric_cmap:\\r\\n\\r\\n self.mat_plot_2d.cmap = self.mat_plot_2d.cmap.symmetric_cmap_from()\\r\\n\\r\\n if residual_map:\\r\\n\\r\\n self.mat_plot_2d.plot_array(\\r\\n array=self.fit.residual_map,\\r\\n visuals_2d=visuals_2d_no_critical_caustic,\\r\\n auto_labels=AutoLabels(\\r\\n title=\\\"Residual Map\\\", filename=f\\\"residual_map{suffix}\\\"\\r\\n ),\\r\\n )\\r\\n\\r\\n if normalized_residual_map:\\r\\n\\r\\n self.mat_plot_2d.plot_array(\\r\\n array=self.fit.normalized_residual_map,\\r\\n visuals_2d=visuals_2d_no_critical_caustic,\\r\\n auto_labels=AutoLabels(\\r\\n title=\\\"Normalized Residual Map\\\",\\r\\n cb_unit=r\\\" $\\\\sigma$\\\",\\r\\n filename=f\\\"normalized_residual_map{suffix}\\\",\\r\\n ),\\r\\n )\\r\\n\\r\\n self.mat_plot_2d.cmap = cmap_original\\r\\n\\r\\n if chi_squared_map:\\r\\n\\r\\n self.mat_plot_2d.plot_array(\\r\\n array=self.fit.chi_squared_map,\\r\\n visuals_2d=visuals_2d_no_critical_caustic,\\r\\n auto_labels=AutoLabels(\\r\\n title=\\\"Chi-Squared Map\\\", cb_unit=r\\\" $\\\\chi^2$\\\", filename=f\\\"chi_squared_map{suffix}\\\"\\r\\n ),\\r\\n )\",\n \"def plot(model, results, filename):\\n\\n # c = model.compartments.get_one(id='c')\\n #\\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\\n #\\n pops = results.get('populations')\\n time = pops.index\\n pop_rna_1 = pops['rna_1[c]']\\n pop_rna_2 = pops['rna_2[c]']\\n pop_rna_3 = pops['rna_3[c]']\\n\\n pop_atp = pops['atp[c]']\\n pop_gtp = pops['gtp[c]']\\n pop_utp = pops['ctp[c]']\\n pop_ctp = pops['utp[c]']\\n\\n pop_amp = pops['amp[c]']\\n pop_gmp = pops['gmp[c]']\\n pop_ump = pops['cmp[c]']\\n pop_cmp = pops['ump[c]']\\n\\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\\n\\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\\n\\n axes1[0].plot(time / 3600, pop_rna_1)\\n axes1[0].plot(time / 3600, pop_rna_2)\\n axes1[0].plot(time / 3600, pop_rna_3)\\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\\n axes1[0].set_ylim((0., 10.0))\\n axes1[0].legend(loc='upper right')\\n\\n axes1[1].plot(time / 3600, pop_atp)\\n axes1[1].plot(time / 3600, pop_gtp)\\n axes1[1].plot(time / 3600, pop_utp)\\n axes1[1].plot(time / 3600, pop_ctp)\\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[1].set_ylim((0., 10.0))\\n axes1[1].legend(loc='upper right')\\n\\n axes1[2].plot(time / 3600, pop_amp)\\n axes1[2].plot(time / 3600, pop_gmp)\\n axes1[2].plot(time / 3600, pop_ump)\\n axes1[2].plot(time / 3600, pop_cmp)\\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[2].set_ylim((0., 10.0))\\n axes1[2].legend(loc='upper right')\\n\\n fig1.savefig(filename.format('species'))\\n pyplot.close(fig1)\",\n \"def visualize(self):\\n\\t\\tplt.figure(1)\\n\\t\\tax1 = plt.add_suplot(1,2,1)\\n\\t\\t# Plot free energy error\\n\\t\\tax1.plot(self.FE_errors_GMM_CV_, linewidth=4, label='GMM with cross-validation')\\n\\t\\tax1.plot(self.FE_errors_GMM_mix_models_, linewidth=4, label='GMM with mixture of models')\\n\\t\\tplt.legend()\\n\\n\\t\\t# Plot density error\\n\\n\\t\\t# Plot log-likelihood of test set\\n\\n\\t\\t# Plot clustering score\\n\\n\\t\\tplt.show()\\n\\n\\t\\treturn\",\n \"def plot_observed(self):\\n \\n fig = plt.figure(figsize=(15,5))\\n plt.subplot(1,3,1)\\n for k in self.observed_data.keys():\\n plt.plot(self.observed_data[k][0], self.observed_data[k][1], 'bx')\\n plt.xlabel(\\\"X\\\",fontsize=20)\\n plt.ylabel(\\\"Y\\\",fontsize=20)\\n\\n fig = plt.figure(figsize=(16,4))\\n \\n # Plot of time vs X\\n plt.subplot(1,3,2)\\n for k in self.observed_data.keys(): \\n plt.plot(k*np.ones(self.observed_data[k].shape[1]), self.observed_data[k][0], 'bx')\\n plt.xlabel(\\\"time\\\",fontsize=20)\\n plt.ylabel(\\\"X\\\",fontsize=20)\\n plt.xlim(0,self.n_time_steps+1)\\n\\n # Plot of time vs Y\\n plt.subplot(1,3,3)\\n for k in self.observed_data.keys():\\n plt.plot(k*np.ones(self.observed_data[k].shape[1]), self.observed_data[k][1], 'bx')\\n plt.xlabel(\\\"time\\\",fontsize=20)\\n plt.ylabel(\\\"Y\\\",fontsize=20)\\n plt.xlim(0,self.n_time_steps+1)\\n plt.show();\",\n \"def plot_lineratios(modeldata,modeldata2='None',line1='CIV1551',line2='CIII1908',line3='CIV1551',line4='HeII1640',\\n plotname='./TESTPLOT.pdf',Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\\n logx=True,logy=True,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\\n showobs=None,noobserr=False,verbose=True):\\n NFalse = 0\\n freeparam = []\\n inforstr = \\\"\\\"\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n legenddic = {}\\n legenddic['Zgas'] = r'Z$_\\\\textrm{gas}$'\\n legenddic['logUs'] = r'log$_\\\\textrm{10}$(U)'\\n legenddic['xid'] = r'$\\\\xi_\\\\textrm{d}$'\\n legenddic['nh'] = r'n$_\\\\textrm{H}$ / [cm$^3$]'\\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\\\textrm{sun}$'\\n legenddic['mup'] = r'M$_\\\\textrm{cut IMF}$ / [M$_\\\\textrm{sun}]$'\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Zgas:\\n Zgasrange = [0.0,1.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Zgas:vary, '\\n freeparam.append('Zgas')\\n else:\\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not logU:\\n logUrange = [-5.0,0.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' logU:vary, '\\n freeparam.append('logUs')\\n else:\\n logUrange = [logU-0.1,logU+0.1]\\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not xid:\\n xidrange = [0.0,0.6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' xid:vary, '\\n freeparam.append('xid')\\n else:\\n xidrange = [xid-0.01,xid+0.01]\\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not nh:\\n nhrange = [0.0,1.0e6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' nH:vary, '\\n freeparam.append('nh')\\n else:\\n nhrange = [nh-1.0,nh+1.0]\\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not COratio:\\n COratiorange = [0.0,2.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' C/O:vary, '\\n freeparam.append('COCOsol')\\n else:\\n COratiorange = [COratio-0.001,COratio+0.001]\\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Mcutoff:\\n Mcutoffrange = [0.0,400.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Mcutoff:vary, '\\n freeparam.append('mup')\\n else:\\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n\\n if NFalse != 2:\\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\\n ' parameters where not set')\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\\n\\n Ngoodent = len(goodent[0])\\n\\n if Ngoodent > 1:\\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying (SFR)model selection ')\\n param1_1 = modeldata[freeparam[0]][goodent]\\n if logp1:\\n param1_1 = np.log10(param1_1)\\n\\n param1_2 = modeldata[freeparam[1]][goodent]\\n if logp2:\\n param1_2 = np.log10(param1_2)\\n\\n ratio1_1 = modeldata[line1][goodent]/modeldata[line2][goodent]\\n ratio1_2 = modeldata[line3][goodent]/modeldata[line4][goodent]\\n else:\\n if verbose: print(' WARNING: Less than 2 (SFR)model grid points to plot; no output generated')\\n return\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if modeldata2 != 'None':\\n goodent2 = np.where( (modeldata2['Zgas'] > Zgasrange[0]) & (modeldata2['Zgas'] < Zgasrange[1]) &\\n (modeldata2['logUs'] > logUrange[0]) & (modeldata2['logUs'] < logUrange[1]) &\\n (modeldata2['xid'] > xidrange[0]) & (modeldata2['xid'] < xidrange[1]) &\\n (modeldata2['nh'] > nhrange[0]) & (modeldata2['nh'] < nhrange[1]) )\\n\\n Ngoodent2 = len(goodent2[0])\\n\\n if Ngoodent > 1:\\n if verbose: print(' - Getting data for '+str(Ngoodent2)+' data points satisfying (AGN)model selection ')\\n param2_1 = modeldata2[freeparam[0]][goodent2]\\n if logp1:\\n param2_1 = np.log10(param2_1)\\n\\n param2_2 = modeldata2[freeparam[1]][goodent2]\\n if logp2:\\n param2_2 = np.log10(param2_2)\\n\\n l2s = ['x','x','x','x'] # line names to use for Feltre+16 file\\n for ll, linestr in enumerate([line1,line2,line3,line4]):\\n if '1908' in linestr:\\n l2 = linestr.replace('1908','1907')\\n else:\\n l2 = linestr\\n\\n l2s[ll] = l2\\n\\n ratio2_1 = modeldata2[l2s[0]][goodent2]/modeldata2[l2s[1]][goodent2]\\n ratio2_2 = modeldata2[l2s[2]][goodent2]/modeldata2[l2s[3]][goodent2]\\n else:\\n if verbose: print(' WARNING: Less than 2 (AGN)model grid points to plot; no output generated')\\n return\\n\\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\\n if verbose: print(' - Setting up and generating plot')\\n plotname = plotname\\n fig = plt.figure(figsize=(9, 5))\\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\\n Fsize = 10\\n lthick = 1\\n marksize = 3\\n plt.rc('text', usetex=True)\\n plt.rc('font', family='serif',size=Fsize)\\n plt.rc('xtick', labelsize=Fsize)\\n plt.rc('ytick', labelsize=Fsize)\\n plt.clf()\\n plt.ioff()\\n plt.title(inforstr[:-2],fontsize=Fsize)\\n\\n margin = 0.1\\n dx = np.abs(np.max(ratio1_1)-np.min(ratio1_1))\\n dy = np.abs(np.max(ratio1_2)-np.min(ratio1_2))\\n\\n\\n if fixxrange:\\n xrange = fixxrange\\n else:\\n if logx:\\n xrange = [np.min(ratio1_1)-np.min(ratio1_1)/2.,np.max(ratio1_1)+np.max(ratio1_1)/2.]\\n else:\\n xrange = [np.min(ratio1_1)-dx*margin,np.max(ratio1_1)+dx*margin]\\n\\n if fixyrange:\\n yrange = fixyrange\\n else:\\n if logy:\\n yrange = [np.min(ratio1_2)-np.min(ratio1_2)/2.,np.max(ratio1_2)+np.max(ratio1_2)/2.]\\n else:\\n yrange = [np.min(ratio1_2)-dy*margin,np.max(ratio1_2)+dy*margin]\\n\\n # ------------ PARAM1 ------------\\n cmap = plt.cm.get_cmap('winter')\\n cmin = np.min(param1_1)\\n cmax = np.max(param1_1)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb1 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr1 = legenddic[freeparam[0]]\\n if logp1:\\n pstr1 = r'log$_\\\\textrm{10}$('+pstr1+')'\\n\\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\\n\\n for p1 in np.unique(param1_1):\\n p1col = cmap(colnorm(p1))\\n p1ent = np.where(param1_1 == p1)\\n\\n plt.plot(ratio1_1[p1ent],ratio1_2[p1ent],'-',lw=lthick, color='k',zorder=1)\\n\\n plt.errorbar(ratio1_1[p1ent],ratio1_2[p1ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*3,\\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\\n\\n if modeldata2 is not 'None':\\n p1ent = np.where(param2_1 == p1)\\n\\n plt.plot(ratio2_1[p1ent],ratio2_2[p1ent],'-',lw=lthick, color='k',zorder=1)\\n\\n plt.errorbar(ratio2_1[p1ent],ratio2_2[p1ent],xerr=None,yerr=None,\\n marker='D',lw=0, markersize=marksize*3,\\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\\n\\n\\n # ------------ PARAM2 ------------\\n cmap = plt.cm.get_cmap('spring')\\n cmin = np.min(param1_2)\\n cmax = np.max(param1_2)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb2 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr2 = legenddic[freeparam[1]]\\n if logp2:\\n pstr2 = 'log10('+pstr2+')'\\n\\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\\n\\n for p2 in np.unique(param1_2):\\n p2col = cmap(colnorm(p2))\\n p2ent = np.where(param1_2 == p2)\\n\\n plt.plot(ratio1_1[p2ent],ratio1_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\\n\\n plt.errorbar(ratio1_1[p2ent],ratio1_2[p2ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*1.5,\\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\\n\\n if modeldata2 is not 'None':\\n p2ent = np.where(param2_2 == p2)\\n\\n plt.plot(ratio2_1[p2ent],ratio2_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\\n\\n plt.errorbar(ratio2_1[p2ent],ratio2_2[p2ent],xerr=None,yerr=None,\\n marker='D',lw=0, markersize=marksize*1.5,\\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\\n\\n\\n if showobs != None:\\n for ii, objid in enumerate(showobs[:,0]):\\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\\\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\\n\\n if noobserr:\\n obsxerr = None\\n obsyerr = None\\n else:\\n obsxerr = showobs[:,8][ii]\\n obsyerr = showobs[:,10][ii]\\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\\n marker='*',lw=lthick, markersize=marksize*2,\\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\\n\\n plt.xlabel(line1+'/'+line2)\\n plt.ylabel(line3+'/'+line4)\\n\\n plt.xlim(xrange)\\n plt.ylim(yrange)\\n\\n if logx:\\n plt.xscale('log')\\n if logy:\\n plt.yscale('log')\\n\\n #--------- LEGEND ---------\\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\\n #\\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\\n # leg.get_frame().set_alpha(0.7)\\n #--------------------------\\n\\n if verbose: print(' Saving plot to'+plotname)\\n plt.savefig(plotname)\\n plt.clf()\\n plt.close('all')\",\n \"def showPlot2():\\n interested_in = list(range(1,10))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on number of robots')\\n xlabel('number of robots (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def xx_plot(epoch, model, features, filters, figname, fgal=0.5):\\n # fetch Stripe 82 data\\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\\n filters, use_single=False)\\n N = 20000\\n X = X[:N]\\n Xcov = Xcov[:N]\\n Xcoadd = Xcoadd[:N]\\n Xcoaddcov = Xcoaddcov[:N]\\n\\n # unpickle the XD model\\n if type(model) == str: \\n f = open(model, 'rb')\\n model = cPickle.load(f)\\n f.close()\\n\\n # Calculate the posteriors, draw samples\\n a, m, v = model.posterior(X, Xcov)\\n posts = np.zeros_like(X)\\n for i in range(X.shape[0]):\\n posts[i] = model.sample(a[i], m[i], v[i], size=1)\\n\\n lo = [0.01, 0.02, 0.06]\\n hi = [0.99, 0.96, 0.98]\\n idx = [0, 1, 4]\\n bins = [100, 100, 300]\\n label = ['psfmag $r$', 'modelmag $u-g$', 'modelmag $i-z$']\\n N = len(idx)\\n fs = 5\\n lsize = 20\\n f = pl.figure(figsize=(N * fs, 2 * fs))\\n pl.subplots_adjust(wspace=0.3)\\n for i in range(N):\\n x = X[:, idx[i]]\\n y = Xcoadd[:, idx[i]]\\n p = posts[:, idx[i]]\\n ind = (y > -999) & (Xcoaddcov[:, idx[i]][:, idx[i]] < 10.)\\n x = x[ind]\\n y = y[ind]\\n p = p[ind]\\n ax = pl.subplot(2, N, i + 1)\\n v = np.sort(x)\\n mn, mx = v[np.int(lo[i] * x.shape[0])], v[np.int(hi[i] * x.shape[0])]\\n hist2d(x, y, ax=ax, bins=bins[i], plot_contours=True,\\n plot_datapoints=True)\\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\\n pl.xlabel('Single Epoch ' + label[i], fontsize=lsize)\\n pl.xlim(mn, mx)\\n pl.ylim(mn, mx)\\n ax = pl.subplot(2, N, i + 4)\\n hist2d(p, y, ax=ax, bins=bins[i], plot_contours=True,\\n plot_datapoints=True)\\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\\n pl.xlim(mn, mx)\\n pl.ylim(mn, mx)\\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\\n pl.xlabel('XD Posterior ' + label[i], fontsize=lsize)\\n f.savefig(figname, bbox_inches='tight')\",\n \"def conf_matrix_plotter(model, X_t_vec, y_t):\\n fig, ax = plt.subplots()\\n\\n fig.suptitle(str(model))\\n\\n plot_confusion_matrix(model, X_t_vec, y_t, ax=ax, cmap=\\\"plasma\\\");\",\n \"def plot_orig(self, conf, nn_in_trn, nn_out_trn, y_pred, a, vert_coef):\\n plot_win=tk.Toplevel()\\n plot_win.title(\\\"Predict data plot\\\")\\n fig = Figure(figsize=(5, 4), dpi=80)\\n ax=fig.add_subplot(111)\\n ax.plot(nn_in_trn[:, 0], nn_out_trn[:, 0], label=\\\"Train data\\\")\\n ax.plot(nn_in_trn[:, 0], y_pred[:, 0], label=\\\"Prediction data\\\")\\n ax.set_xlabel('IN[1]')\\n ax.set_ylabel('OUT[1]')\\n fig.legend()\\n canvas = FigureCanvasTkAgg(fig, master=plot_win)\\n canvas.draw()\\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)\\n\\n toolbar = NavigationToolbar2Tk(canvas, plot_win)\\n toolbar.update()\\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)\\n lab1=tk.Label(plot_win,width=35, text=\\\"Model configuration\\\"+str(conf))\\n lab1.pack()\\n lab2=tk.Label(plot_win,width=35, text=\\\"Loss= \\\" + str(round(a,4))+ \\\" %\\\")\\n lab2.pack()\\n plot_win.geometry(f'+{self.winfo_x()+self.winfo_width()+20}+{self.winfo_y() + vert_coef}')\",\n \"def plot_results(self):\\n [m, s] = self.run_model()\\n barM = m.x[2:8]\\n barS = s.x[2:8]\\n T1vec = self.T1_extraction(self.subj)\\n for i in T1vec:\\n T1vec[T1vec == i] = int(i)\\n T1vec = T1vec[2:8]\\n barWidth = 25\\n r2 = [x + barWidth for x in T1vec]\\n plt.grid(b=True, linewidth=0.2)\\n plt.bar(\\n T1vec, barM, color=\\\"b\\\", width=barWidth, edgecolor=\\\"white\\\", label=\\\"Motor\\\"\\n )\\n plt.bar(r2, barS, color=\\\"r\\\", width=barWidth, edgecolor=\\\"white\\\", label=\\\"Sensory\\\")\\n plt.xlabel(\\\"T1\\\", fontweight=\\\"bold\\\")\\n plt.ylabel(\\\"Partial contribution\\\", fontweight=\\\"bold\\\")\\n plt.legend()\\n plt.title(\\n \\\"Partial contribution of cortical layers to motor and sensory operations\\\"\\n )\\n plt.show()\\n return barM, barS, T1vec\",\n \"def diff_plot(targets, predictions, filename, remove_outliers=False):\\n\\tif remove_outliers:\\n\\t\\tindices = np.where(np.logical_not(np.logical_or(np.abs(predictions) > 10 * np.abs(targets), np.abs(predictions) < np.abs(targets) / 10.0)))\\n\\t\\ttargets = targets[indices]\\n\\t\\tpredictions = predictions[indices]\\n\\n\\tif targets.shape[0] != 0:\\n\\t\\tfig, ax = plt.subplots()\\n\\t\\tfig.suptitle(str(targets.shape[0]) + ' samples, R2: ' + str(r2(targets, predictions)), fontsize=12)\\n\\t\\taxes = plt.gca()\\n\\t\\taxes.set_ylim(np.min(predictions), np.max(predictions))\\n\\t\\taxes.set_xlim(np.min(targets), np.max(targets))\\n\\t\\tax.scatter(targets, predictions, edgecolors=(0, 0, 0))\\n\\t\\tax.set_xlabel('Targets')\\n\\t\\tax.set_ylabel('Predictions')\\n\\t\\tax.plot([targets.min(), targets.max()], [targets.min(), targets.max()], 'k--', lw=4)\\n\\t\\tplt.savefig(filename)\\n\\t\\tplt.close()\",\n \"def convergence_plot(self, varying, savename = False):\\n assert(varying == \\\"Mx\\\" or varying == \\\"My\\\" or varying == \\\"Both\\\") \\n self._colors = [\\\"red\\\", \\\"green\\\", \\\"black\\\", \\\"orange\\\"]\\n self._powers = [2] # Power used in the convergence plot. \\n\\n # Assert that the savename variable is of the correct format.\\n if (varying == \\\"Mx\\\" or varying == \\\"My\\\") and savename:\\n assert(type(savename) is list and len(savename) == 4)\\n elif savename:\\n assert(isinstance(savename, str))\\n\\n if varying == \\\"Mx\\\":\\n self._constant_list = [10, 100, pow(10, 3), pow(10, 4)] # Constant values in plots. \\n maximum = 2**7 # Maximum limit of Mx.\\n elif varying == \\\"My\\\":\\n self._constant_list = [10, 100, pow(10, 3), pow(10, 4)] # Constant values in plots. \\n maximum = 2**7 # Maximum limit of My.\\n elif varying == \\\"Both\\\":\\n maximum = 2**10 # Maximum limit of My and Mx. \\n self._powers = [1] # Power used in the convergence plot. \\n\\n varying_list = 2 ** np.arange(1, np.log(maximum)/np.log(2)+1, dtype = int)\\n if varying == \\\"Both\\\":\\n self._discrete_error = np.zeros(len(varying_list))\\n for i, m in enumerate(varying_list):\\n Usol, xv, yv = self.num_solution_Mx_My(Mx = m, My = m)\\n analsol = self.analytic_solution(xv, yv)\\n self._discrete_error[i] = e_l(Usol, analsol)\\n if savename:\\n self.plot_plots(varying_list, varying_list, savename=savename)\\n else: \\n self.plot_plots(varying_list, varying_list)\\n elif varying:\\n for j, constant in enumerate(self._constant_list):\\n self._discrete_error = np.zeros(len(varying_list))\\n for i, m in enumerate(varying_list):\\n if varying == \\\"Mx\\\":\\n Usol, xv, yv = self.num_solution_Mx_My(Mx = m, My = constant)\\n elif varying == \\\"My\\\":\\n Usol, xv, yv = self.num_solution_Mx_My(Mx = constant, My = m)\\n\\n analsol = self.analytic_solution(xv, yv)\\n self._discrete_error[i] = e_l(Usol, analsol)\\n if savename:\\n self.plot_plots(varying_list, constant, savename=savename[j])\\n else: \\n self.plot_plots(varying_list, constant)\",\n \"def plot(self):\\n y = self.projection\\n mpl.scatter(y[:, 0], y[:, 1], c=self.data_class)\\n mpl.show()\",\n \"def plot(self) -> None:\\n cw_l2_data_list = list(); cw_linf_data_list = list()\\n\\n for model in self.model_list:\\n cw_l2_data_list.append(joblib.load(model + \\\"/stat/mse-rmse-si-mae-cw_l2_1.pkl\\\"))\\n\\n cw_l2_attack = list(zip(self.model_list, cw_l2_data_list))\\n\\n for model in self.model_list:\\n cw_linf_data_list.append(joblib.load(model + \\\"/stat/mse-rmse-si-mae-cw_inf_1.pkl\\\"))\\n\\n cw_linf_attack = list(zip(self.model_list, cw_linf_data_list))\\n\\n # RMSE v.s. MAE over change budget\\n # There will be one graph for each manipulation\\n # CW_L2 ATTACK\\n for datum in cw_l2_attack:\\n ran_color_list = self._random_color_picker(2)\\n fig, axis_1 = plt.subplots()\\n\\n # Generate x_axis\\n x_axis = list()\\n for key in datum[1]:\\n if float(key) not in x_axis:\\n x_axis.append(float(key))\\n\\n x_axis.sort()\\n\\n # Sort data in datum[1]\\n data_dict = self._sort_dict(x_axis, datum[1])\\n\\n # PLOT RMSE ON AXIS 1\\n # Generate y_axis ticks for RMSE\\n rmse_values = list()\\n for key in data_dict:\\n rmse_values.append(data_dict[key][\\\"rmse\\\"])\\n\\n # Generate 10 ticks for the y_axis\\n y_axis_ticks = np.linspace(0.0, 0.6, num=10, endpoint=True)\\n\\n # Plot RMSE\\n axis_1.plot(x_axis, rmse_values, color=ran_color_list[0], linestyle=\\\"solid\\\")\\n axis_1.set_xlabel(\\\"Perturbation Budget\\\")\\n axis_1.set_ylabel(\\\"Root Mean Squared Error (RMSE)\\\", color=ran_color_list[0])\\n axis_1.set_yticks(y_axis_ticks)\\n \\n for tick_label, tick_line in zip(axis_1.get_yticklabels(), axis_1.get_yticklines()):\\n tick_label.set_color(ran_color_list[0])\\n tick_line.set_color(ran_color_list[0])\\n\\n # PLOT MAE ON AXIS 2\\n axis_2 = axis_1.twinx()\\n\\n # Generate y-axis ticks for MAE\\n mae_values = list()\\n for key in data_dict:\\n mae_values.append(data_dict[key][\\\"mae\\\"])\\n\\n\\n # Plot MAE\\n axis_2.plot(x_axis, mae_values, color=ran_color_list[1], linestyle=\\\"solid\\\")\\n axis_2.set_ylabel(\\\"Mean Absolute Error (MAE)\\\", color=ran_color_list[1])\\n axis_2.set_yticks(y_axis_ticks)\\n \\n for tick_label, tick_line in zip(axis_2.get_yticklabels(), axis_2.get_yticklines()):\\n tick_label.set_color(ran_color_list[1])\\n tick_line.set_color(ran_color_list[1])\\n\\n model_tag = datum[0].split(\\\"/\\\"); model_tag = model_tag[-1]\\n plt.savefig(self.save_path + \\\"/{}_rmse-and-mae-as-perturbation-budget-increases-for-cw_l2-attack-on-model-{}.png\\\".format(self.plot_name, model_tag), \\n bbox_inches=\\\"tight\\\")\\n plt.close()\\n\\n # CW_Linf ATTACK\\n for datum in cw_linf_attack:\\n ran_color_list = self._random_color_picker(2)\\n fig, axis_1 = plt.subplots()\\n\\n # Generate x_axis\\n x_axis = list()\\n for key in datum[1]:\\n if float(key) not in x_axis:\\n x_axis.append(float(key))\\n\\n x_axis.sort()\\n\\n # Sort data in datum[1]\\n data_dict = self._sort_dict(x_axis, datum[1])\\n\\n # PLOT RMSE ON AXIS 1\\n # Generate y_axis ticks for RMSE\\n rmse_values = list()\\n for key in data_dict:\\n rmse_values.append(data_dict[key][\\\"rmse\\\"])\\n\\n # Plot RMSE\\n axis_1.plot(x_axis, rmse_values, color=ran_color_list[0], linestyle=\\\"solid\\\")\\n axis_1.set_xlabel(\\\"Perturbation Budget\\\")\\n axis_1.set_ylabel(\\\"Root Mean Squared Error (RMSE)\\\", color=ran_color_list[0])\\n axis_1.set_yticks(y_axis_ticks)\\n\\n for tick_label, tick_line in zip(axis_1.get_yticklabels(), axis_1.get_yticklines()):\\n tick_label.set_color(ran_color_list[0])\\n tick_line.set_color(ran_color_list[0])\\n\\n # PLOT MAE ON AXIS 2\\n axis_2 = axis_1.twinx()\\n\\n # Generate y-axis ticks for MAE\\n mae_values = list()\\n for key in data_dict:\\n mae_values.append(data_dict[key][\\\"mae\\\"])\\n\\n # Plot MAE\\n axis_2.plot(x_axis, mae_values, color=ran_color_list[1], linestyle=\\\"solid\\\")\\n axis_2.set_ylabel(\\\"Mean Absolute Error (MAE)\\\", color=ran_color_list[1])\\n axis_2.set_yticks(y_axis_ticks)\\n \\n for tick_label, tick_line in zip(axis_2.get_yticklabels(), axis_2.get_yticklines()):\\n tick_label.set_color(ran_color_list[1])\\n tick_line.set_color(ran_color_list[1])\\n \\n model_tag = datum[0].split(\\\"/\\\"); model_tag = model_tag[-1]\\n plt.savefig(self.save_path + \\\"/{}_rmse-and-mae-as-perturbation-budget-increases-for-cw_linf-attack-on-model-{}.png\\\".format(self.plot_name, model_tag),\\n bbox_inches=\\\"tight\\\")\\n plt.close()\\n \\\"RMSE and MAE as Perturbation Budget increases for CW_Linf attack on model {}\\\".format(model_tag)\\n \\n # Scattter Index over the change budget\\n # All the manipulations will be put on the same graph.\\n # CW_L2 ATTACK\\n plt.figure()\\n plt.xlabel(\\\"Perturbation Budget\\\"); plt.ylabel(\\\"Scatter Index\\\")\\n ran_color_list = self._random_color_picker(len(cw_l2_attack)); i = 0\\n\\n # Find maximum scatter index value\\n scatter_values = list()\\n for datum in cw_l2_attack:\\n for key in datum[1]:\\n scatter_values.append(datum[1][key][\\\"scatter_index\\\"])\\n\\n # Generate y_axis ticks; generate 10 ticks\\n y_axis_ticks = np.linspace(0.0, float(Decimal(str(max(scatter_values))) + Decimal(\\\"0.1\\\")), num=10, endpoint=True)\\n plt.yticks(y_axis_ticks)\\n\\n # Generate x_axis\\n x_axis = list()\\n for datum in cw_l2_attack:\\n for key in datum[1]:\\n if float(key) not in x_axis:\\n x_axis.append(float(key))\\n\\n x_axis.sort()\\n\\n formal_names = FormalNameMap()\\n for datum in cw_l2_attack:\\n values = list()\\n data_dict = self._sort_dict(x_axis, datum[1])\\n for key in data_dict:\\n values.append(data_dict[key][\\\"scatter_index\\\"])\\n\\n # Append values to the plot\\n line_name = datum[0].split(\\\"/\\\"); line_name = line_name[-1]\\n formal_name = formal_names.getformalname(line_name) if formal_names.hasname(line_name) else line_name\\n if \\\"vanilla\\\" in line_name:\\n plt.plot(x_axis, values, color=ran_color_list[i], linewidth=3, linestyle=self._random_linestyle(), label=formal_name)\\n\\n else:\\n plt.plot(x_axis, values, color=ran_color_list[i], linestyle=self._random_linestyle(), label=formal_name)\\n \\n i += 1\\n\\n plt.legend()\\n plt.savefig(self.save_path + \\\"/{}_scatter-index-as-perturbation-budget-increases-for-cw_l2-attack.png\\\".format(self.plot_name),\\n bbox_inches=\\\"tight\\\")\\n plt.close()\\n\\n # CW_Linf ATTACK\\n plt.figure()\\n plt.xlabel(\\\"Perturbation Budget\\\"); plt.ylabel(\\\"Scatter Index\\\")\\n ran_color_list = self._random_color_picker(len(cw_linf_attack)); i = 0\\n\\n # Find maximum scatter index value\\n scatter_values = list()\\n for datum in cw_linf_attack:\\n for key in datum[1]:\\n scatter_values.append(datum[1][key][\\\"scatter_index\\\"])\\n\\n # Generate y_axis ticks; generate 10 ticks\\n y_axis_ticks = np.linspace(0.0, float(Decimal(str(max(scatter_values))) + Decimal(\\\"0.1\\\")), num=10, endpoint=True)\\n plt.yticks(y_axis_ticks)\\n\\n # Generate x_axis\\n x_axis = list()\\n for datum in cw_l2_attack:\\n for key in datum[1]:\\n if float(key) not in x_axis:\\n x_axis.append(float(key))\\n\\n x_axis.sort()\\n\\n formal_names = FormalNameMap()\\n for datum in cw_linf_attack:\\n values = list()\\n data_dict = self._sort_dict(x_axis, datum[1])\\n for key in data_dict:\\n values.append(data_dict[key][\\\"scatter_index\\\"])\\n\\n # Append values to the plot\\n line_name = datum[0].split(\\\"/\\\"); line_name = line_name[-1]\\n formal_name = formal_names.getformalname(line_name) if formal_names.hasname(line_name) else line_name\\n if \\\"vanilla\\\" in line_name:\\n plt.plot(x_axis, values, color=ran_color_list[i], linewidth=3, linestyle=self._random_linestyle(), label=formal_name)\\n\\n else: \\n plt.plot(x_axis, values, color=ran_color_list[i], linestyle=self._random_linestyle(), label=formal_name)\\n \\n i += 1\\n\\n plt.legend()\\n plt.savefig(self.save_path + \\\"/{}_scatter-index-as-perturbation-budget-increases-for-cw_linf-attack.png\\\".format(self.plot_name),\\n bbox_inches=\\\"tight\\\")\\n plt.close()\",\n \"def plot_compare(benchmark_portvals,\\n manual_strategy_portvals,\\n strategy_learner_portval):\\n final_df = pd.concat([benchmark_portvals, manual_strategy_portvals, strategy_learner_portval], axis=1)\\n final_df.columns = ['Normalized Benchmark Portfolio Value',\\n 'Normalized Manual Strategy Portfolio Value',\\n 'Normalized Strategy Learner Portfolio Value']\\n # print(final_df)\\n # Plot final dataframe\\n title = \\\"Strategy Learner vs Manual Strategy\\\"\\n xlabel = \\\"Date\\\"\\n ylabel = \\\"Portfolio Value\\\"\\n \\\"\\\"\\\"Plot stock prices with a custom title and meaningful axis labels.\\\"\\\"\\\"\\n ax = final_df.plot(title=title, fontsize=12, color=['g', 'r', 'b'], figsize=(10, 6))\\n ax.set_xlabel(xlabel)\\n ax.set_ylabel(ylabel)\\n plt.axhline(y=1., color='m', linestyle=':')\\n plt.show()\\n return None\",\n \"def problemTwo(self):\\n # Initialize plot figure\\n plot_2 = plt.figure(figsize=(18, 20 ))\\n plot_2.subplots_adjust(left=.08, right=.97, top=.97, bottom=.07)\\n mv = plot_2.add_subplot(1, 1, 1)\\n plt.tick_params(labelsize=20)\\n mv.set_xlabel('$\\\\\\\\frac{(y-y_o)}{D}$', fontsize=36)\\n mv.set_ylabel('$\\\\\\\\frac{u(y)}{U_{\\\\infty}}$', fontsize=36)\\n mv.grid(linewidth=1, color='gray', linestyle='--')\\n # Get plot data from each file\\n for file_loc in self.filenames:\\n file = os.path.basename(file_loc).replace('.csv', '')\\n index = self.filenames.index(file_loc)\\n if 'calibration' not in file:\\n self.hot_vel = self.data[file]['hot vel'].tolist()\\n self.pitot_vel = self.data[file]['pitot vel'].tolist()\\n self.y_pos = self.data[file]['y pos'].tolist()\\n # Calc the v_inf for the hotwire and pitot velocity profiles\\n v_inf_hot = statistics.mean([sum(self.hot_vel[:6])/len(self.hot_vel[:6]), sum(self.hot_vel[-6:])/len(self.hot_vel[-6:])])\\n v_inf_pitot = statistics.mean([sum(self.pitot_vel[:6])/len(self.pitot_vel[:6]), sum(self.pitot_vel[-6:])/len(self.pitot_vel[-6:])])\\n # Normalize velocity to the freestream velocity\\n hot_nondim = [i/v_inf_hot for i in self.hot_vel]\\n pitot_nondim = [i/v_inf_pitot for i in self.pitot_vel]\\n # Normalize the y position with cylinder diameter\\n y0_hot = self.y_pos[hot_nondim.index(min(hot_nondim))]\\n y0_pitot = self.y_pos[pitot_nondim.index(min(pitot_nondim))]\\n y_pos_nondim_hot = [(i-y0_hot)/self.cylinder_diam for i in self.y_pos]\\n y_pos_nondim_pitot = [(i - y0_pitot) / self.cylinder_diam for i in self.y_pos]\\n # Plot the mean velocity\\n mv.plot(y_pos_nondim_hot, hot_nondim, color=self.plot_color[index], label=f'Hotwire @ {file}mm', linewidth=3)\\n mv.plot(y_pos_nondim_pitot, pitot_nondim, color=self.plot_color[index], label=f'Pitot @ {file}mm', linestyle='--', linewidth=2)\\n mv.legend(loc='lower right', fontsize=22)\\n plot_2.savefig(os.path.join(os.getcwd(), r'plots\\\\prob2'))\\n plt.draw()\",\n \"def compare(self, model, u_model, obs, u_obs, bprop, label='', plot=False):\\n self.debug.start_function('compare')\\n pyprint.check_same_length(model, obs, 'model and obs arrays')\\n pyprint.check_same_length(u_model, u_obs, 'u_model and u_obs arrays')\\n\\n weight = self.mcmc_version.weights[bprop]\\n inv_sigma2 = 1 / (u_model ** 2 + u_obs ** 2)\\n lh = -0.5 * weight * ((model - obs) ** 2 * inv_sigma2\\n + np.log(2 * np.pi / inv_sigma2))\\n self.debug.print_(f'lhood breakdown: {label} {lh}')\\n\\n if plot:\\n self.plot_compare(model=model, u_model=u_model, obs=obs,\\n u_obs=u_obs, bprop=label)\\n self.debug.end_function()\\n return lh.sum()\",\n \"def psfminusmodel_plot(epoch, model, features, filters, figname, fgal=0.5,\\n idx=-1):\\n # fetch Stripe 82 data\\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\\n filters, use_single=False)\\n\\n # unpickle the XD model\\n if type(model) == str: \\n f = open(model, 'rb')\\n model = cPickle.load(f)\\n f.close()\\n\\n fs = 5\\n Nbins = [50, 50, 50]\\n lsize = 20\\n mags = [19.5, 20.5, 21.5]\\n dlt = [0.15, 0.15, 0.15]\\n f = pl.figure(figsize=(3 * fs, fs))\\n pl.subplots_adjust(wspace=0.3)\\n for i in range(len(mags)):\\n ind = (Xcoadd[:, idx] < 0.03) & (Xcoadd[:, 0] > mags[i] - dlt[i])\\n ind = ind & (Xcoadd[:, 0] <= mags[i] + dlt[i])\\n\\n x = X[ind]\\n xc = Xcov[ind]\\n\\n a, m, v = model.posterior(x, xc)\\n posts = np.zeros_like(x)\\n for j in range(x.shape[0]):\\n posts[j] = np.median(model.sample(a[j], m[j], v[j], size=1000),\\n axis=0)\\n\\n ax = pl.subplot(1, 3, i + 1)\\n h, b = np.histogram(x[:, idx], Nbins[i])\\n d = (b[1] - b[0]) / 2.\\n b = np.append([b[0] - d], b[:-1] + d)\\n h = np.append([1.0], h)\\n pl.plot(b, h, drawstyle='steps-mid', linestyle='dotted',\\n color='k', lw=2)\\n h, b = np.histogram(posts[:, idx], Nbins[i])\\n d = (b[1] - b[0]) / 2.\\n b = np.append([b[0] - d], b[:-1] + d)\\n h = np.append([1.0], h)\\n pl.plot(b, h, drawstyle='steps-mid', color='k', lw=2)\\n pl.xlabel('psfmag - modelmag $r$', fontsize=lsize)\\n pl.ylabel('counts', fontsize=lsize)\\n ax.text(0.95, 0.95, '$r=%0.1f$' % mags[i], fontsize=lsize, ha='right',\\n va='top', transform=ax.transAxes)\\n pl.xlim(-0.1, 0.2)\\n f.savefig(figname, bbox_inches='tight')\",\n \"def plot(self):\\n pass\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect().plot()\",\n \"def simPlots_comb(loadFile, axes, drug1, drug2):\\n # Read model\\n M = drugInteractionModel(loadFile, drug1=drug1, drug2=drug2, fit=False)\\n\\n drug1 += r\\\" ($\\\\mu$M)\\\"\\n drug2 += r\\\" ($\\\\mu$M)\\\"\\n\\n dfplot = pd.DataFrame()\\n dfplot[\\\"confl\\\"] = M.phase.flatten()\\n dfplot[\\\"death\\\"] = M.green.flatten()\\n dfplot[\\\"time\\\"] = np.tile(M.timeV, M.X1.size)\\n dfplot[drug1] = np.round(np.repeat(M.X1, M.timeV.size), decimals=1)\\n dfplot[drug2] = np.round(np.repeat(M.X2, M.timeV.size), decimals=1)\\n\\n ddd = dfplot.loc[dfplot[\\\"time\\\"] == 72.0, :]\\n ddd = ddd.groupby([drug1, drug2, \\\"time\\\"]).mean().reset_index()\\n confldf = ddd.pivot(drug1, drug2, \\\"confl\\\")\\n\\n sns.heatmap(confldf, ax=axes[0], vmin=0.0, square=True, xticklabels=1)\\n axes[0].set_title(\\\"Phase\\\")\\n sns.heatmap(ddd.pivot(drug1, drug2, \\\"death\\\"), ax=axes[3], vmin=0.0, square=True, xticklabels=1)\\n axes[3].set_title(\\\"Annexin V\\\")\\n\\n confl = confldf.to_numpy()\\n confl /= confl[0, 0]\\n confl = 1.0 - confl\\n\\n assert np.all(confl <= 1.0)\\n\\n additive = (confl[:, 0][:, None] + confl[0, :][None, :]) - np.outer(confl[:, 0], confl[0, :])\\n\\n assert np.all(additive <= 1.0)\\n\\n confldf.iloc[:, :] = confl - additive\\n\\n sns.heatmap(confldf, ax=axes[1], cmap=\\\"PiYG\\\", vmin=-0.5, vmax=0.5, square=True, xticklabels=1)\\n axes[1].set_title(\\\"Just Viability\\\")\\n\\n return confldf\",\n \"def inner_PlotDistrifun():\\r\\n \\r\\n font = {'family': 'serif',\\r\\n 'color': 'darkred',\\r\\n 'weight': 'normal',\\r\\n 'size': 16}\\r\\n\\r\\n Nmax = 100\\r\\n bins = np.linspace(0, Nmax, Nmax+1)\\r\\n nList = np.linspace(0, Nmax, Nmax+1, dtype = int)\\r\\n\\r\\n y_location = self.spinBox_PixelY.value()\\r\\n x_location = self.spinBox_PixelX.value()\\r\\n\\r\\n # get pixel intensity data\\r\\n Array1 = self.APP_dataprocess.PixelData(y_location, x_location)\\r\\n Array2 = Array1\\r\\n g2 = G2(Array1, Array2)\\r\\n print(\\\"g2 is:\\\", g2)\\r\\n\\r\\n arr = []\\r\\n rv = poisson(self.firstOrdImaging[y_location, x_location])\\r\\n for num in range(0,40):\\r\\n arr.append(rv.pmf(num))\\r\\n\\r\\n ax = fig.add_subplot(111)\\r\\n\\r\\n try:\\r\\n ax.cla()\\r\\n #print(\\\"clear self.cbar !\\\")\\r\\n except:\\r\\n pass\\r\\n #print(\\\"fail to clear self.cbar !\\\")\\r\\n \\r\\n ax.hist(Array1 , bins, normed=True, label = \\\"Data distribution\\\") \\r\\n ax.plot(nList, BoseEinstein(self.firstOrdImaging[y_location, x_location], Nmax), label =\\\"BoseEinstein distribution\\\")\\r\\n ax.plot(arr, linewidth=2.0, label =\\\"Possion distribution\\\")\\r\\n ax.set_title(\\\"Pixel Position({},{}); <$I$>:{}\\\".format(x_location , y_location, self.firstOrdImaging[y_location, x_location]), fontdict=font)\\r\\n \\r\\n ax.text(22, .08, r\\\"g2:{}\\\".format(g2), fontdict=font)\\r\\n ax.legend() \\r\\n \\r\\n fig.savefig('PixelPosition({},{})PhotDist.eps'.format(x_location , y_location), format='eps', dpi=300)\\r\\n plt.close()\",\n \"def plot(self):\\n if self.tabWidget.count() == 0:\\n return\\n\\n # Error if not enough slabs\\n plotType = str(self.plotOptions.getPlotType()) \\n if len(self.selectedVars) < 2 and self.requiresTwoSlabs(plotType):\\n self.showError('Error Message to User', 'Vector, Scatter, Meshfill or XvsY plots \\\\nmust have two data variables. The data \\\\nvariables must be selected in the \\\\n\\\"Defined Variables\\\" window.')\\n return\\n\\n # Create & Update the graphics method / CDATCell vistrails modules\\n # *** IMPORTANT ***\\n # Everytime plot is pressed, this will create a new Graphics Method and\\n # CDATCell Module. Instead it should ONLY create a new graphics method\\n # and CDATCell module if the variable isn't already connected to an\\n # existing Graphics Method / CDATCell module. This results in plots \\n # being plotted multiple times.\\n axisList = self.tabWidget.currentWidget()\\n self.emit(QtCore.SIGNAL('createModule'), gm_name)\\n self.emit(QtCore.SIGNAL('createModule'), cdatcell_name) \\n self.setVistrailsGraphicsMethod() \\n self.setVistrailsCDATCell()\\n\\n # Get the names of the 2 slabs so we can connect their modules in vistrails\\n if self.requiresTwoSlabs(plotType):\\n var1 = self.selectedVars[-1].id\\n var2 = self.selectedVars[-2].id\\n else:\\n var1 = self.currentTabName()\\n var2 = None\\n\\n # Emit signal to GuiController to connect ports and plot\\n self.emit(QtCore.SIGNAL('plot'), var1, var2)\\n\\n # If a quickplot is plotted, define current variable under 'quickplot'\\n if (self.currentTabName() == 'quickplot'):\\n var = self.getUpdatedVar()\\n self.emit(QtCore.SIGNAL('plotPressed'), axisList.getFile(), var)\\n\\n # Record plot teaching commands\\n self.recordPlotTeachingCommand()\",\n \"def visualize_data(data):\\n\\n # Instantiate a PCA object for the sake of easy visualisation\\n pca = PCA(n_components=2)\\n\\n # Fit and transform x to visualise inside a 2D feature space\\n x_vis = pca.fit_transform(data[data.columns[:-1]])\\n y = data['Tumor'].as_matrix()\\n\\n # Plot the original data\\n # Plot the two classes\\n palette = sns.color_palette()\\n\\n plt.scatter(x_vis[y == 0, 0], x_vis[y == 0, 1], label=\\\"Normal\\\", alpha=0.5,\\n edgecolor=ALMOST_BLACK, facecolor=palette[0], linewidth=0.15)\\n plt.scatter(x_vis[y == 1, 0], x_vis[y == 1, 1], label=\\\"Tumor\\\", alpha=0.5,\\n edgecolor=ALMOST_BLACK, facecolor=palette[2], linewidth=0.15)\\n\\n plt.legend()\\n plt.show()\",\n \"def plot_results(\\n data,\\n xparam,\\n yparam,\\n pxrange=None,\\n pyrange=None,\\n data_comp=None,\\n data_bohlin=None,\\n figsize=None,\\n alpha=0.25,\\n):\\n # set the plotting defaults\\n set_params(lw=2, fontsize=22)\\n\\n fig, ax = plt.subplots(figsize=figsize)\\n\\n if data_bohlin is not None:\\n if (xparam in data_bohlin.colnames) and (yparam in data_bohlin.colnames):\\n xcol = data_bohlin[xparam]\\n xcol_unc = get_unc(xparam, data_bohlin)\\n ycol = data_bohlin[yparam]\\n ycol_unc = get_unc(yparam, data_bohlin)\\n ax.errorbar(\\n xcol,\\n ycol,\\n xerr=xcol_unc,\\n yerr=ycol_unc,\\n fmt=\\\"ro\\\",\\n label=\\\"Bohlin (1978)\\\",\\n alpha=alpha,\\n )\\n if data_comp is not None:\\n xcol = data_comp[xparam]\\n xcol_unc = get_unc(xparam, data_comp)\\n ycol = data_comp[yparam]\\n ycol_unc = get_unc(yparam, data_comp)\\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\\n # fmt='go', label='FUSE Comparisons', alpha=0.25)\\n ax.plot(xcol, ycol, \\\"go\\\")\\n # plot the error bars as ellipses illustrating the covariance\\n corrs = get_corr(\\n xparam,\\n yparam,\\n xcol,\\n ycol,\\n xcol_unc,\\n ycol_unc,\\n cterm=data_comp[\\\"AV\\\"].data,\\n cterm_unc=data_comp[\\\"AV_unc\\\"].data,\\n )\\n plot_errorbar_corr(\\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\\\"g\\\"\\n )\\n\\n xcol = data[xparam].data\\n xcol_unc = get_unc(xparam, data)\\n ycol = data[yparam].data\\n ycol_unc = get_unc(yparam, data)\\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\\n # fmt='bo', label='FUSE Reddened', alpha=0.25)\\n ax.plot(xcol, ycol, \\\"bo\\\")\\n\\n # plot the error bars as ellipses illustrating the covariance\\n if yparam[0:3] == \\\"CAV\\\":\\n cparam = \\\"AV\\\"\\n elif yparam[0:1] == \\\"C\\\":\\n cparam = \\\"EBV\\\"\\n else:\\n cparam = \\\"AV\\\"\\n\\n corrs = get_corr(\\n xparam,\\n yparam,\\n xcol,\\n ycol,\\n xcol_unc,\\n ycol_unc,\\n cterm=data[cparam].data,\\n cterm_unc=data[cparam + \\\"_unc\\\"].data,\\n )\\n plot_errorbar_corr(\\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\\\"b\\\", pellipse=True\\n )\\n\\n ax.set_xlabel(format_colname(xparam))\\n ax.set_ylabel(format_colname(yparam))\\n\\n # fit a line\\n # params = np.polyfit(xcol, ycol, 1) # , w=1.0/ycol_unc)\\n # line_init = models.Polynomial1D(1)\\n line_init = models.Linear1D()\\n fit = fitting.LinearLSQFitter()\\n # fitter with outlier rejection\\n or_fit = fitting.FittingWithOutlierRemoval(fit, sigma_clip, niter=3, sigma=3.0)\\n\\n # fit the data w/o weights\\n fitted_model = fit(line_init, xcol, ycol)\\n print(fitted_model)\\n\\n # fit the data using the uncertainties as weights\\n fitted_model_weights = fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\\n\\n # fit the data using the uncertainties as weights\\n fitted_model_weights_sc, mask_sc = or_fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\\n data_sc = np.ma.masked_array(ycol, mask=mask_sc)\\n\\n # print(\\\"linear fit params [slope, y-intercept]\\\")\\n # print(params)\\n xlim = ax.get_xlim()\\n x_mod = np.linspace(xlim[0], xlim[1])\\n # y_mod = params[1] + x_mod * params[0]\\n # ax.plot(x_mod, y_mod, \\\"k--\\\")\\n\\n ax.plot(x_mod, fitted_model(x_mod), \\\"k-\\\")\\n ax.plot(x_mod, fitted_model_weights(x_mod), \\\"k--\\\")\\n ax.plot(x_mod, fitted_model_weights_sc(x_mod), \\\"k.\\\")\\n\\n ax.plot(xcol, data_sc, 'ko')\\n print(data_sc)\\n\\n if pxrange is not None:\\n ax.set_xlim(pxrange)\\n if pyrange is not None:\\n ax.set_ylim(pyrange)\\n\\n return fig\",\n \"def visualisation(self):\\n plt.plot(self.x, self.y, 'o', label = 'Example data')\\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\\n plt.xlim([-1,1])\\n plt.ylim([-1,1])\",\n \"def showPlot2():\\n raise NotImplementedError\",\n \"def plotCompareScatterMatrix(scatterMatrix1, scatterMatrix2, fName=None):\\n from matplotlib import pyplot\\n\\n diff = scatterMatrix1 - scatterMatrix2\\n\\n pyplot.imshow(diff.todense(), interpolation=\\\"nearest\\\")\\n pyplot.grid(color=\\\"0.70\\\")\\n pyplot.xlabel(\\\"From group\\\")\\n pyplot.ylabel(\\\"To group\\\")\\n pyplot.title(\\\"scattering XS difference \\\", fontsize=6)\\n pyplot.colorbar()\\n if fName:\\n pyplot.savefig(fName)\\n else:\\n pyplot.show()\\n\\n pyplot.close()\",\n \"def plot_in_outliers(data, mask, output):\\n\\n oc = 'lightskyblue'\\n ic = 'navy'\\n plt.figure(figsize=(15, 18))\\n sns.set_style('white')\\n x_all = pd.DataFrame({'PC1': data[:, 0], 'PC2': data[:, 1]})\\n x_inliers = pd.DataFrame({'PC1': data[mask == 0, 0], 'PC2': data[mask == 0, 1]})\\n x_outliers = pd.DataFrame({'PC1': data[mask == 1, 0], 'PC2': data[mask == 1, 1]})\\n # Plot everything first\\n g = sns.JointGrid(x='PC1', y='PC2', data=x_all, space=0)\\n # Plot points\\n sns.scatterplot(x_outliers.PC1, x_outliers.PC2, color=oc, ax=g.ax_joint,\\n s=10, linewidth=0, label='Abnormal morphology')\\n sns.scatterplot(x_inliers.PC1, x_inliers.PC2, color=ic, ax=g.ax_joint,\\n s=10, linewidth=0, label='Normal morphology')\\n # Plot kernel density estimates\\n sns.distplot(x_outliers.PC1, kde=True, hist=False, color=oc, ax=g.ax_marg_x, axlabel=False)\\n sns.distplot(x_inliers.PC1, kde=True, hist=False, color=ic, ax=g.ax_marg_x, axlabel=False)\\n sns.distplot(x_outliers.PC2, kde=True, hist=False, color=oc, ax=g.ax_marg_y,\\n vertical=True, axlabel=False)\\n sns.distplot(x_inliers.PC2, kde=True, hist=False, color=ic, ax=g.ax_marg_y,\\n vertical=True, axlabel=False)\\n fig = plt.gcf()\\n fig.savefig(output, dpi=150, bbox_inches='tight')\\n fig.clf()\\n plt.close(fig)\",\n \"def fiducial_comparison():\\n \\n # observed gd1\\n g = Table(fits.getdata('/home/ana/projects/GD1-DR2/output/gd1_members.fits'))\\n \\n # fiducial model\\n wangle = 180*u.deg\\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\\n xi, eta = pk['xi'], pk['eta']\\n \\n plt.close()\\n fig, ax = plt.subplots(2,1,figsize=(7,6), sharex=True)\\n \\n plt.sca(ax[0])\\n plt.scatter(g['phi1']+40, g['phi2'], s=g['pmem']*2, c=g['pmem'], cmap=mpl.cm.binary, vmin=0.5, vmax=1.1, rasterized=True)\\n \\n plt.ylabel('$\\\\phi_2$ [deg]')\\n plt.text(0.05, 0.9, 'Most likely GD-1 members', transform=plt.gca().transAxes, va='top', fontsize=17)\\n plt.xlim(-20,20)\\n plt.ylim(-10,10)\\n plt.gca().set_aspect('equal')\\n \\n plt.sca(ax[1])\\n plt.plot(xi.wrap_at(wangle), eta, 'o', mec='none', color=mpl.cm.Blues(0.9), ms=5)\\n \\n plt.xlabel('$\\\\phi_1$ [deg]')\\n plt.ylabel('$\\\\phi_2$ [deg]')\\n plt.text(0.05, 0.9, 'Simulated GD-1\\\\n0.5 Gyr after subhalo flyby', transform=plt.gca().transAxes, va='top', fontsize=17)\\n plt.ylim(-10,10)\\n plt.gca().set_aspect('equal')\\n \\n plt.tight_layout()\\n plt.savefig('../plots/fiducial_comparison.pdf')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6889876","0.6815983","0.6491328","0.6326441","0.630209","0.6259812","0.62159556","0.6189489","0.60769445","0.60425025","0.6001705","0.59992814","0.59848875","0.5948288","0.592511","0.589603","0.5892012","0.5887439","0.58789676","0.5858394","0.5851891","0.5829441","0.5824557","0.5823291","0.58223736","0.5787535","0.57777894","0.5770898","0.57547176","0.57460713","0.57353437","0.5720691","0.5703079","0.5688315","0.5680977","0.5672115","0.5670482","0.5664656","0.56615627","0.5660444","0.5653138","0.5643707","0.5636519","0.5634619","0.56219316","0.5618674","0.5616942","0.5615008","0.56149167","0.5608081","0.5608081","0.56026316","0.5600537","0.55998033","0.5596158","0.55958647","0.5595494","0.55949974","0.55945605","0.55692357","0.556015","0.5559919","0.5554822","0.55447966","0.55437756","0.55429727","0.553936","0.55371815","0.5535848","0.5535848","0.5533262","0.5530422","0.55280596","0.5526696","0.551411","0.55086553","0.5506803","0.54992634","0.54971033","0.54899126","0.5488038","0.5486654","0.54844296","0.5474991","0.54681104","0.5465294","0.5464084","0.5463944","0.54589295","0.5455518","0.54541117","0.54535437","0.54528874","0.54507405","0.54471886","0.54471207","0.5446722","0.5446177","0.54459774","0.54421747","0.54409087"],"string":"[\n \"0.6889876\",\n \"0.6815983\",\n \"0.6491328\",\n \"0.6326441\",\n \"0.630209\",\n \"0.6259812\",\n \"0.62159556\",\n \"0.6189489\",\n \"0.60769445\",\n \"0.60425025\",\n \"0.6001705\",\n \"0.59992814\",\n \"0.59848875\",\n \"0.5948288\",\n \"0.592511\",\n \"0.589603\",\n \"0.5892012\",\n \"0.5887439\",\n \"0.58789676\",\n \"0.5858394\",\n \"0.5851891\",\n \"0.5829441\",\n \"0.5824557\",\n \"0.5823291\",\n \"0.58223736\",\n \"0.5787535\",\n \"0.57777894\",\n \"0.5770898\",\n \"0.57547176\",\n \"0.57460713\",\n \"0.57353437\",\n \"0.5720691\",\n \"0.5703079\",\n \"0.5688315\",\n \"0.5680977\",\n \"0.5672115\",\n \"0.5670482\",\n \"0.5664656\",\n \"0.56615627\",\n \"0.5660444\",\n \"0.5653138\",\n \"0.5643707\",\n \"0.5636519\",\n \"0.5634619\",\n \"0.56219316\",\n \"0.5618674\",\n \"0.5616942\",\n \"0.5615008\",\n \"0.56149167\",\n \"0.5608081\",\n \"0.5608081\",\n \"0.56026316\",\n \"0.5600537\",\n \"0.55998033\",\n \"0.5596158\",\n \"0.55958647\",\n \"0.5595494\",\n \"0.55949974\",\n \"0.55945605\",\n \"0.55692357\",\n \"0.556015\",\n \"0.5559919\",\n \"0.5554822\",\n \"0.55447966\",\n \"0.55437756\",\n \"0.55429727\",\n \"0.553936\",\n \"0.55371815\",\n \"0.5535848\",\n \"0.5535848\",\n \"0.5533262\",\n \"0.5530422\",\n \"0.55280596\",\n \"0.5526696\",\n \"0.551411\",\n \"0.55086553\",\n \"0.5506803\",\n \"0.54992634\",\n \"0.54971033\",\n \"0.54899126\",\n \"0.5488038\",\n \"0.5486654\",\n \"0.54844296\",\n \"0.5474991\",\n \"0.54681104\",\n \"0.5465294\",\n \"0.5464084\",\n \"0.5463944\",\n \"0.54589295\",\n \"0.5455518\",\n \"0.54541117\",\n \"0.54535437\",\n \"0.54528874\",\n \"0.54507405\",\n \"0.54471886\",\n \"0.54471207\",\n \"0.5446722\",\n \"0.5446177\",\n \"0.54459774\",\n \"0.54421747\",\n \"0.54409087\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6381,"cells":{"query":{"kind":"string","value":"Drive the combination process. This entails generating code for use in the casa interpreter and then running it. If the 'generate' commandline option is invoked, the code will be printed to a file instead of run in the interpreter."},"document":{"kind":"string","value":"def drive(param_dict, clargs):\n output_basename = _gen_basename(param_dict, clargs)\n\n if not clargs.overwrite:\n i = 1\n while glob.glob('*{}*'.format(output_basename)):\n output_basename = '{}.{}'.format(\n _gen_basename(param_dict, clargs), i)\n i += 1\n\n casa_instance = None\n if not clargs.generate:\n casa_instance = drivecasa.Casapy()\n\n if param_dict['produce_uv']:\n _drive_uv(param_dict, clargs, output_basename, casa_instance)\n\n if param_dict['produce_feather']:\n _drive_feather(param_dict, clargs, output_basename, casa_instance)"},"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 main():\n\n BASIC.run(PROGRAM)","def generate(options):\n interactive = options['i']\n if interactive:\n generate_interactive(options)\n else:\n generate_rcfile(vars(options['c']), options['rcfile'])","def run():\n names=[i.__name__ for i in modList]\n res,action=kcs_ui.string_select('fake vitesse generator',\n 'Please select the module you want to generate fake vitesse py.',\n 'Press option to generate for all modules.',\n names)\n if res==kcs_util.ok():\n mod=modList[action-1]\n des=kcs_ui.string_req('Where do you want to place the file?',r'C:\\temp')\n if des[0]==kcs_util.ok():\n# des = os.path.join(os.path.join(os.getcwd(), \"FakeVitesse\"))\n fname = des[1] + \"\\\\\" + mod.__name__ + \".py\"\n GenPy(mod, fname)\n elif res==kcs_util.options():\n des=kcs_ui.string_req('Where do you want to place the file?',r'C:\\temp')\n if des[0]==kcs_util.ok():\n for mod in modList:\n fname = des[1] + \"\\\\\" + mod.__name__ + \".py\"\n GenPy(mod, fname)","def main():\n\n\tparser = OptionParser()\n\tparser.add_option(\"-p\", dest=\"pdbfile\", help=\"pdbfile\")\n\tparser.add_option(\"-o\", dest=\"outfile\", help=\"outfile\")\n\tparser.add_option(\"-r\", dest=\"replace\", help=\"replace\", action=\"store_true\")\n\tparser.set_description(main.__doc__)\n\t(options, args) = parser.parse_args()\n\n\texe = \"makeSelection.py\" \n\tsele = ' -s \"CEN\"'\n\n\tif options.pdbfile:\n\t\texe += \" -p \" + options.pdbfile\n\telse:\n\t\tparser.print_help()\n\t\tsys.exit()\n\n\tif options.outfile:\n\t\texe += \" -o \" + options.outfile\n\telif options.replace:\n\t\texe += \" -r \"\n\telse:\n\t\tparser.print_help()\n\t\tsys.exit()\n\n\texe += sele\n\n\tos.system(exe)","def main():\n parser = create_argument_parser(\n \"generate a wheel spinning loose on an axle\",\n default_gravity=[0, -9.81, 0])\n parser.add_argument(\"--num-links\",\n type=int,\n default=11,\n help=\"number of links in the chain\")\n args = parser.parse_args()\n\n if args.out_path is None:\n directory = pathlib.Path(__file__).resolve().parents[1] / \"fixtures\"\n args.out_path = directory / \"chain-cross-section.json\"\n args.out_path.parent.mkdir(parents=True, exist_ok=True)\n\n print_args(args)\n\n fixture = generate_fixture(args)\n\n save_fixture(fixture, args.out_path)","def script_generator(self):\n py = self.global_setting.get('python', sys.executable)\n ex_options = self.global_setting.get('evaluate_options', str())\n train_py = \"/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py\"\n if os.access(py, os.X_OK):\n content = \"set -e \\n\"\n content += \"export CUDA_VISIBLE_DEVICES=\" + \\\n \",\".join(self.selected_gpus)+ \" \\n\"\n content += \"cd %s \\n\"%(self.run_dir)\n \n content += \"%s %s %s --work_dir %s --validate %s &> train.log \\n\"%(py, \n train_py,\n self.setting['config_file'],\n self.run_dir,\n ex_options)\n content += \"touch evaluate.done \\n\"\n\n self.script_content = content\n else:\n print(\"Error: %s is not executable.\"%py)\n sys.exit(0)","def generate():\n PackCommandExecutor().pack()\n GenerateCommandExecutor().generate()","def main(binary_name, code_directory, verbose, clase):\n print(\"Start of binaries generation\")\n #Directory to iterate\n directory = '../../results/'+code_directory + '/' + clase + '/application_signature/'\n #Directory to store the binaries to generate\n bin_directory = './bin/'\n #Task to performed on the new script\n make_clean = 'make clean\\n'\n for dirs in os.listdir(directory):\n print('Generating binary for path', dirs)\n if os.path.exists(directory+dirs+'/bin/'+dirs):\n os.remove(directory+dirs+'/bin/'+dirs)\n #Creation of the script\n with open(directory+dirs+'/make_bin.sh', 'w') as bin_file:\n bin_file.write('#! /bin/bash\\n')\n bin_file.write(make_clean+'\\n')\n bin_file.write('make '+code_directory+' CLASS='+clase+'\\n')\n bin_file.write('mv '+bin_directory+binary_name+' '+bin_directory+binary_name+'_'+dirs+'\\n')\n bin_file.write(make_clean)\n bin_file.close()\n try:\n #Changing privileges so script can be executed automatically\n os.chmod(directory+dirs+'/make_bin.sh', 0o777)\n #Move to directory where script is to be executed\n cwd = os.getcwd()\n #Change cwd to execute script generating the binary\n os.chdir(directory+dirs)\n if verbose:\n subprocess.check_call('./make_bin.sh')\n else:\n subprocess.check_call('./make_bin.sh', stdout=subprocess.PIPE, shell=False)\n \n os.chdir(cwd)\n except FileNotFoundError as e:\n logger.error(e)\n raise\n print('End of binaries generation')","def execute(self):\n if self._cli_arguments.get('<samplename>') == 'cfn':\n generate_sample_cfn_module(self.env_root)\n elif self._cli_arguments.get('<samplename>') == 'static-angular':\n generate_sample_static_angular(self.env_root)\n elif self._cli_arguments.get('<samplename>') == 'static-react':\n generate_sample_static_react(self.env_root)\n elif self._cli_arguments.get('<samplename>') == 'sls-py':\n generate_sample_sls_module(self.env_root, 'sls-py')\n elif self._cli_arguments.get('<samplename>') == 'sls-tsc':\n generate_sample_sls_module(self.env_root, 'sls-tsc')\n elif self._cli_arguments.get('<samplename>') == 'stacker':\n generate_sample_stacker_module(self.env_root)\n elif self._cli_arguments.get('<samplename>') == 'tf':\n generate_sample_tf_module(self.env_root)\n elif self._cli_arguments.get('<samplename>') == 'k8s-cfn-repo':\n generate_sample_k8s_cfn_repo(self.env_root)\n elif self._cli_arguments.get('<samplename>') == 'k8s-tf-repo':\n generate_sample_k8s_tf_repo(self.env_root)\n elif self._cli_arguments.get('<samplename>') == 'cdk-tsc':\n generate_sample_cdk_tsc_module(self.env_root)\n elif self._cli_arguments.get('<samplename>') == 'cdk-py':\n generate_sample_cdk_py_module(self.env_root)\n elif self._cli_arguments.get('<samplename>') == 'cdk-csharp':\n generate_sample_cdk_cs_module(self.env_root)\n else:\n LOGGER.info(\"Available samples to generate:\")\n for i in ['cfn', 'static-angular', 'static-react', 'sls-tsc',\n 'sls-py', 'tf', 'k8s-cfn-repo', 'k8s-tf-repo',\n 'stacker', 'cdk-tsc', 'cdk-py', 'cdk-csharp']:\n print(i)","def main() -> None:\n # The first thing to do is get the lines of the PyFlex file we are given.\n parser = Parser(filename=sys.argv[1])\n parsed_data = parser.ParseFile()\n\n # Upon retrieving the Parsed Data, assign the parsed data to the\n # Symbol Table.\n SymbolTable.RULESET = parsed_data['ruleset']\n SymbolTable.INSTRUCTIONS = parsed_data['instructions']\n SymbolTable.CODE = parsed_data['code']\n # SymbolTable.PrintTable()\n\n # Using the Generator backend, we can build the generated script\n generator = Generator()\n generator.GenerateNewScript()\n\n autopep8.fix_file(filename=generator.file_main)\n\n print(\"Generated Script can be found in {}\".format(generator.file_main))","def script_generator(self):\n\n self._get_free_tcp_port()\n\n train_py = \"/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py\"\n py = self.global_setting.get('python', sys.executable)\n ex_options = self.global_setting.get('train_options', str())\n\n if not os.access(py, os.X_OK):\n py = \"/home/haihuam/anaconda3/envs/RepPoints/bin/python\"\n \n if os.access(py, os.X_OK):\n content = \"set -e \\n\"\n content += \"export CUDA_VISIBLE_DEVICES=\" + \\\n \",\".join(self.selected_gpus)+ \" \\n\"\n\n content += \"cd %s \\n\"%(self.run_dir)\n content += \"%s -m torch.distributed.launch \"%(py)\n content += \"--nproc_per_node=%s \"%(self.setting['train_num_gpu'])\n content += \"--master_port %s \"%(self.dist_train_port)\n content += \"%s %s --launcher pytorch \"%(train_py, self.setting['config_file'])\n content += \"--work_dir %s \"%(self.run_dir)\n content += \"--resume_from latest.pth \"\n content += \"--validate %s &> %s.log \\n\"%(ex_options, self.stage)\n content += \"touch train.done \\n\"\n # return content\n self.script_content = content\n else:\n print(\"Error: %s is not executable.\"%py)\n sys.exit(0)","def main():\n run_program()","def main():\n\t\n\tparser = argparse.ArgumentParser(description=\"This invokes a java program to place and/or route a design using Vivado tcl.\")\n\tparser.add_argument('input_dcp', nargs=1, help=\"Input design checkpoint (.dcp) file.\")\n\tparser.add_argument('output_dcp', nargs=1, help=\"Output dcp file.\")\n\tparser.add_argument('-p', '--place', dest='place', action='store_true', help=\"Place design.\")\n\tparser.add_argument('-r', '--route', dest='route', action='store_true', help=\"Route design.\")\n\tparser.add_argument('-b', '--both', dest='place_and_route', action='store_true', help=\"Place and route design. This option supercedes -p or -r.\")\n\tparser.add_argument('-q', '--quiet', dest='quiet', action='store_true', help=\"Suppress messages.\")\n\tparser.add_argument('-f', '--force', dest='force', action='store_true', help=\"Overwrite file at destination if it exists.\")\n\targs = parser.parse_args()\n\t\n\t\n\tif args.place or args.place_and_route:\n\t\tplace_flag = \"-p true\"\n\telse:\n\t\tplace_flag = \"-p false\"\n\t\t\n\tif args.route or args.place_and_route:\n\t\troute_flag = \"-r true\"\n\telse:\n\t\troute_flag = \"-r false\"\n\t\n\tif args.force:\n\t\tforce_flag = \"-f true\"\n\telse:\n\t\tforce_flag = \"-f false\"\n\tif args.quiet:\n\t\tquiet_flag = \"-q true\"\n\telse:\n\t\tquiet_flag = \"-q false\"\n\t\n\t\n\tplace_and_route_dir = \"~/Documents/2019_summer/AddILA/\"\n\tclass_path = \".:/nfs/ug/thesis/thesis0/pc2019/Software/RapidWright/RapidWright\"\n\t\n\tcd_cmd = \"cd {}\".format(place_and_route_dir)\n\tjava_compile_cmd = \"javac PlaceAndRoute.java\".format()\n\n\ttry:\n\t\tif not args.quiet:\n\t\t\tprint(\"pwd\")\n\t\tpwd = subprocess.check_output(\"pwd\").decode(sys.stdout.encoding).strip()\n\t\tif not args.quiet:\n\t\t\tprint(cd_cmd)\n\t\tos.system(cd_cmd)\n\texcept:\n\t\tprint(\"\\nERROR: Failed to execute '{}'.\".format(cd_cmd))\n\t\treturn 1\n\n\tif args.input_dcp[0][0] in {'~', '/'}:\n\t\tinput_dcp = args.input_dcp[0]\n\telse:\n\t\tinput_dcp = pwd + \"/\" + args.input_dcp[0]\n\tif args.output_dcp[0][0] in {'~', '/'}:\n\t\toutput_dcp = args.output_dcp[0]\n\telse:\n\t\toutput_dcp = pwd + \"/\" + args.output_dcp[0]\n\t\n\tjava_execute_cmd = \"java -cp {0} PlaceAndRoute {1} {2} {3} {4} {5} {6}\".format(class_path, input_dcp, output_dcp, place_flag, route_flag, force_flag, quiet_flag)\n\t\n\ttry:\n\t\tif not args.quiet:\n\t\t\tprint(java_compile_cmd)\n\t\tos.system(java_compile_cmd)\n\texcept:\n\t\tprint(\"\\nERROR: Failed to execute '{}'.\".format(java_compile_cmd))\n\t\treturn 1\n\n\ttry:\n\t\tif not args.quiet:\n\t\t\tprint(java_execute_cmd)\n\t\tos.system(java_execute_cmd)\n\texcept:\n\t\tprint(\"\\nERROR: Failed to execute '{}'.\".format(java_execute_cmd))\n\t\treturn 1","def main(argv=None):\n if not check_python_version():\n return 2\n\n if argv is None:\n argv = sys.argv[1:]\n ap = argparse.ArgumentParser(description=\"DistAlgo compiler.\",\n argument_default=argparse.SUPPRESS)\n _add_compiler_args(ap)\n ap.add_argument('-o', help=\"Output file name.\",\n dest=\"outfile\", default=None)\n ap.add_argument('-L', help=\"Logging output level.\",\n dest=\"debug\", default=None)\n ap.add_argument('-i',\n help=\"Generate interface code for plugging\"\n \" into incrementalizer.\",\n action='store_true', dest=\"geninc\", default=False)\n ap.add_argument(\"-m\", \"--inc-module-name\",\n help=\"name of the incrementalized interface module, \"\n \"defaults to source module name + '_inc'. \",\n dest=\"incfile\", default=None)\n ap.add_argument('-O', '--optimize', type=int, default=-1)\n ap.add_argument('-D', '--dump-ast', default=False, action='store_true')\n ap.add_argument('-C', '--write-bytecode', default=False, action='store_true')\n ap.add_argument('-I', '--interactive',\n help=\"Launch interactive shell.\",\n action='store_true', default=False)\n ap.add_argument('-B', '--benchmark',\n help=\"Print the elapsed wallclock time of the compile session.\",\n action='store_true', default=False)\n ap.add_argument('-p', help=\"Generate DistAlgo pseudo code.\",\n action='store_true', dest=\"genpsd\", default=False)\n ap.add_argument(\"-v\", \"--version\", action=\"version\", version=__version__)\n ap.add_argument('--psdfile', help=\"Name of DistAlgo pseudo code output file.\",\n dest=\"psdfile\", default=None)\n ap.add_argument('infile', metavar='SOURCEFILE', type=str,\n help=\"DistAlgo input source file.\")\n args = ap.parse_args(argv)\n\n if args.benchmark:\n global WallclockStart\n WallclockStart = time.perf_counter()\n\n if args.interactive:\n import code\n code.interact()\n return\n\n if args.debug is not None:\n try:\n level = int(args.debug)\n if is_valid_debug_level(level):\n set_debug_level(level)\n else:\n raise ValueError()\n except ValueError:\n stderr.write(\"Invalid debugging level %s.\\n\" % str(args.debug))\n\n if args.genpsd:\n res = dafile_to_pseudofile(args.infile, args.psdfile, args)\n elif args.geninc:\n res = dafile_to_incfiles(args)\n elif args.write_bytecode:\n res = dafile_to_pycfile(args.infile, args.outfile, args.optimize,\n args=args)\n else:\n res = dafile_to_pyfile(args.infile, args.outfile, args)\n\n if args.benchmark:\n import json\n walltime = time.perf_counter() - WallclockStart\n jsondata = {'Wallclock_time' : walltime,\n \"Input_size\" : InputSize,\n \"Output_size\" : OutputSize}\n print(\"###OUTPUT: \" + json.dumps(jsondata))\n\n return res","def main():\n # Initialize logging to the terminal and system log.\n coloredlogs.install(syslog=True)\n # Parse the command line arguments.\n context_opts = dict()\n program_opts = dict()\n dest_opts = dict()\n try:\n options, arguments = getopt.gnu_getopt(sys.argv[1:], 'bsrm:c:t:i:unx:fvqh', [\n 'backup', 'snapshot', 'rotate', 'mount=', 'crypto=', 'tunnel=',\n 'ionice=', 'no-sudo', 'dry-run', 'multi-fs', 'exclude=', 'force',\n 'disable-notifications', 'verbose', 'quiet', 'help',\n ])\n for option, value in options:\n if option in ('-b', '--backup'):\n enable_explicit_action(program_opts, 'backup_enabled')\n elif option in ('-s', '--snapshot'):\n enable_explicit_action(program_opts, 'snapshot_enabled')\n elif option in ('-r', '--rotate'):\n enable_explicit_action(program_opts, 'rotate_enabled')\n elif option in ('-m', '--mount'):\n program_opts['mount_point'] = value\n elif option in ('-c', '--crypto'):\n program_opts['crypto_device'] = value\n elif option in ('-t', '--tunnel'):\n ssh_user, _, value = value.rpartition('@')\n ssh_alias, _, port_number = value.partition(':')\n tunnel_opts = dict(\n ssh_alias=ssh_alias,\n ssh_user=ssh_user,\n # The port number of the rsync daemon.\n remote_port=RSYNCD_PORT,\n )\n if port_number:\n # The port number of the SSH server.\n tunnel_opts['port'] = int(port_number)\n dest_opts['ssh_tunnel'] = SecureTunnel(**tunnel_opts)\n elif option in ('-i', '--ionice'):\n value = value.lower().strip()\n validate_ionice_class(value)\n program_opts['ionice'] = value\n elif option in ('-u', '--no-sudo'):\n program_opts['sudo_enabled'] = False\n elif option in ('-n', '--dry-run'):\n logger.info(\"Performing a dry run (because of %s option) ..\", option)\n program_opts['dry_run'] = True\n elif option in ('-f', '--force'):\n program_opts['force'] = True\n elif option in ('-x', '--exclude'):\n program_opts.setdefault('exclude_list', [])\n program_opts['exclude_list'].append(value)\n elif option == '--multi-fs':\n program_opts['multi_fs'] = True\n elif option == '--disable-notifications':\n program_opts['notifications_enabled'] = False\n elif option in ('-v', '--verbose'):\n coloredlogs.increase_verbosity()\n elif option in ('-q', '--quiet'):\n coloredlogs.decrease_verbosity()\n elif option in ('-h', '--help'):\n usage(__doc__)\n return\n else:\n raise Exception(\"Unhandled option! (programming error)\")\n if len(arguments) > 2:\n msg = \"Expected one or two positional arguments! (got %i)\"\n raise Exception(msg % len(arguments))\n if len(arguments) == 2:\n # Get the source from the first of two arguments.\n program_opts['source'] = arguments.pop(0)\n if arguments:\n # Get the destination from the second (or only) argument.\n dest_opts['expression'] = arguments[0]\n program_opts['destination'] = Destination(**dest_opts)\n elif not os.environ.get('RSYNC_MODULE_PATH'):\n # Show a usage message when no destination is given.\n usage(__doc__)\n return\n except Exception as e:\n warning(\"Error: %s\", e)\n sys.exit(1)\n try:\n # Inject the source context into the program options.\n program_opts['source_context'] = create_context(**context_opts)\n # Initialize the program with the command line\n # options and execute the requested action(s).\n RsyncSystemBackup(**program_opts).execute()\n except Exception as e:\n if isinstance(e, RsyncSystemBackupError):\n # Special handling when the backup disk isn't available.\n if isinstance(e, MissingBackupDiskError):\n # Check if we're connected to a terminal to decide whether the\n # error should be propagated or silenced, the idea being that\n # rsync-system-backup should keep quiet when it's being run\n # from cron and the backup disk isn't available.\n if not connected_to_terminal():\n logger.info(\"Skipping backup: %s\", e)\n sys.exit(0)\n # Known problems shouldn't produce\n # an intimidating traceback to users.\n logger.error(\"Aborting due to error: %s\", e)\n else:\n # Unhandled exceptions do get a traceback,\n # because it may help fix programming errors.\n logger.exception(\"Aborting due to unhandled exception!\")\n sys.exit(1)","def main():\n print(sys.argv)\n parser = create_argument_parser(description=\"generate a tower of blocks\",\n default_restitution_coefficient=0)\n parser.add_argument(\"--num-blocks\",\n type=int,\n default=10,\n help=\"maximum number of blocks in the compactor\")\n args = parser.parse_args()\n\n if args.out_path is None:\n directory = pathlib.Path(__file__).resolve().parents[1] / \"fixtures\"\n args.out_path = directory / \"compactor.json\"\n args.out_path.parent.mkdir(parents=True, exist_ok=True)\n\n print_args(args)\n\n fixture = generate_fixture(args)\n\n save_fixture(fixture, args.out_path)","def main():\n\n\tparser = generate_parser()\n\targuments, unknown = parser.parse_known_args()\n\n\tif type(arguments.output) is list:\n\t\t arguments.output = arguments.output[0]\n\n\tif '-o' in arguments.other:\n\t\t# -o output can be in other due to ordering of command\n\t\t# move output into arguments.output\n\n\t\toutput_idx = arguments.other.index('-o') + 1\n\t\targuments.output = arguments.other[output_idx]\n\n\t\targuments.other.pop(output_idx)\n\t\targuments.other.remove('-o')\n\n\n\t# find C compiler\n\tcompilers = determine_compilers(arguments)\n\n\t# find ExaMPI library\n\tpaths = find_library(arguments)\n\n\t# user only executed with flags\n\tif unknown and not arguments.other:\n\t\t# flags of compiler\n\t\terror_code = assemble(compilers, paths, None, unknown)\n\n\t\tsys.exit(error_code)\n\n\t# require a command from user\n\tif not arguments.other and not unknown:\n\t\t# mpicc is being executed without commands\n\t\tparser.print_usage()\n\n\t\tsys.exit()\n\n\t# execute command\n\tif any((flag in unknown or flag in arguments.other) for flag in ['-E', '-S', '-c']):\n\t\t# user is requesting preprocessing, compiling or assembling only\n\t\terror_code = assemble(compilers, paths, arguments.output, unknown + arguments.other)\n\n\t\tsys.exit(error_code)\n\n\telse:\n\t\terror_code = link(compilers, paths, arguments.output, unknown + arguments.other)\n\n\t\tsys.exit(error_code)","def main(argv): \n if len(argv) < 2:\n print 'generate.py -k <k-value> -o <outputfile>'\n exit(1)\n argv = argv[1:]\n k = 0\n outputfile = ''\n try:\n opts, args = getopt.getopt(argv,\"hk:o:\",[\"k-value=\",\"ofile=\"])\n except getopt.GetoptError:\n print 'generate.py -k <k-value> -o <outputfile>'\n sys.exit(2)\n for opt, arg in opts:\n if opt == '-h':\n print 'generate.py -k <k-value> -o <outputfile>'\n sys.exit()\n elif opt in (\"-k\", \"--kval\"):\n k = int(arg)\n elif opt in (\"-o\", \"--ofile\"):\n outputfile = arg\n generate(k, outputfile)","def main():\n load()\n\n print(generate())","def run():\n print(\"clewsy CLEWs Model Building Script.\")\n print(\"When using clewsy please reference:\")\n print(\"T. Niet and A. Shivakumar (2020): clewsy: Script for building CLEWs models.\")\n main(sys.argv[1:])","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 makecmd(self, options):","def main():\n subcommands = {\n \"train\": train.train,\n \"tune\": train_tune.train,\n \"predict\": predict.cli_predict,\n \"evaluate\": evaluate.cli_evaluate,\n \"version\": version,\n }\n\n try:\n import xarray_behave.gui.app\n\n subcommands[\"gui\"] = xarray_behave.gui.app.main_das\n except (ImportError, ModuleNotFoundError):\n logging.exception(\"No GUI avalaible.\")\n # fall back to function that displays helpful instructions\n subcommands[\"gui\"] = no_xb_gui\n\n logging.basicConfig(level=logging.INFO, force=True)\n defopt.run(subcommands, show_defaults=False)","def main(args: List[Union[str, bytes]] = sys.argv,):\n\tprogram_name, *args = args\n\targs = decode_raw_args(args, str)\n\n\tgen = Generator(*args)\n\tgen.generate_data()\n\tgen.print_return_list()","def makeprg(setup, loop):\n return loop","def main():\n parser = optparse.OptionParser()\n parser.add_option(\"-c\", \"--clear\", action=\"store_true\", dest=\"clear\",\n help=\"clear out all generated reports\")\n parser.add_option(\"-n\", \"--num\", action=\"store\", type=\"int\", dest=\"num\",\n help=\"number of data points to generate\")\n parser.add_option(\"-m\", \"--min\", action=\"store\", type=\"float\", dest=\"min\",\n help=\"minimum of polynomial range\")\n parser.add_option(\"-f\", \"--fun\", action=\"store\", type=\"string\", dest=\"fun\",\n help=(\"Python expression (function of x)\"))\n (options, _) = parser.parse_args()\n if options.clear:\n clear_data()\n else:\n report_id = generate_id()\n if report_id is None:\n print \"Too many tests exist already\"\n else:\n gen = DataGen(options.min, options.fun, options.num)\n gen.generate_data()\n gen.write_ref(report_id)\n gen.write_rand(report_id)","def main(argv):\n parser = OptionParser()\n parser.add_option(\n \"--output-dir\",\n help=\"Output directory for generated files. Defaults to chromium root \"\n \"directory.\")\n parser.add_option(\n \"-v\", \"--verbose\", action=\"store_true\", help=\"Verbose logging output.\")\n parser.add_option(\n \"-c\", \"--check\", action=\"store_true\",\n help=\"Check if output files match generated files in chromium root \"\n \"directory. Use this in PRESUBMIT scripts with --output-dir.\")\n\n (options, _) = parser.parse_args(args=argv)\n\n # This script lives under src/gpu/command_buffer.\n script_dir = os.path.dirname(os.path.abspath(__file__))\n assert script_dir.endswith(os.path.normpath(\"src/gpu/command_buffer\"))\n # os.path.join doesn't do the right thing with relative paths.\n chromium_root_dir = os.path.abspath(script_dir + \"/../..\")\n\n # Support generating files under gen/ and for PRESUBMIT.\n if options.output_dir:\n output_dir = options.output_dir\n else:\n output_dir = chromium_root_dir\n os.chdir(output_dir)\n\n # This script lives under gpu/command_buffer, cd to base directory.\n build_cmd_buffer_lib.InitializePrefix(\"WebGPU\")\n gen = build_cmd_buffer_lib.GLGenerator(\n options.verbose, \"2018\", _FUNCTION_INFO, _NAMED_TYPE_INFO,\n chromium_root_dir)\n gen.ParseGLH(\"gpu/command_buffer/webgpu_cmd_buffer_functions.txt\")\n\n gen.WriteCommandIds(\"gpu/command_buffer/common/webgpu_cmd_ids_autogen.h\")\n gen.WriteFormat(\"gpu/command_buffer/common/webgpu_cmd_format_autogen.h\")\n gen.WriteFormatTest(\n \"gpu/command_buffer/common/webgpu_cmd_format_test_autogen.h\")\n gen.WriteGLES2InterfaceHeader(\n \"gpu/command_buffer/client/webgpu_interface_autogen.h\")\n gen.WriteGLES2ImplementationHeader(\n \"gpu/command_buffer/client/webgpu_implementation_autogen.h\")\n gen.WriteGLES2InterfaceStub(\n \"gpu/command_buffer/client/webgpu_interface_stub_autogen.h\")\n gen.WriteGLES2InterfaceStubImpl(\n \"gpu/command_buffer/client/webgpu_interface_stub_impl_autogen.h\")\n gen.WriteGLES2Implementation(\n \"gpu/command_buffer/client/webgpu_implementation_impl_autogen.h\")\n gen.WriteGLES2ImplementationUnitTests(\n \"gpu/command_buffer/client/webgpu_implementation_unittest_autogen.h\")\n gen.WriteCmdHelperHeader(\n \"gpu/command_buffer/client/webgpu_cmd_helper_autogen.h\")\n # Note: No gen.WriteServiceImplementation\n # Note: No gen.WriteServiceUnitTests\n gen.WriteServiceUtilsHeader(\n \"gpu/command_buffer/service/webgpu_cmd_validation_autogen.h\")\n gen.WriteServiceUtilsImplementation(\n \"gpu/command_buffer/service/\"\n \"webgpu_cmd_validation_implementation_autogen.h\")\n\n build_cmd_buffer_lib.Format(gen.generated_cpp_filenames, output_dir,\n chromium_root_dir)\n\n if gen.errors > 0:\n print(\"build_webgpu_cmd_buffer.py: Failed with %d errors\" % gen.errors)\n return 1\n\n check_failed_filenames = []\n if options.check:\n for filename in gen.generated_cpp_filenames:\n if not filecmp.cmp(os.path.join(output_dir, filename),\n os.path.join(chromium_root_dir, filename)):\n check_failed_filenames.append(filename)\n\n if len(check_failed_filenames) > 0:\n print('Please run gpu/command_buffer/build_webgpu_cmd_buffer.py')\n print('Failed check on autogenerated command buffer files:')\n for filename in check_failed_filenames:\n print(filename)\n return 1\n\n return 0","def main():\n parser = argparse.ArgumentParser(\"Generate custom wordlist\")\n\n parser.add_argument(\"iterations\", type=int, help=\"Maximum words to combine.\")\n parser.add_argument(\"--words\", default=\"words.txt\", type=str, help=\"Path to the words file. One word per line.\")\n parser.add_argument(\"--output\",default=\"output.txt\", type=str, help=\"Path to the output file.\")\n\n args = parser.parse_args()\n\n wordlist = open(args.words, 'r')\n wordlistlines = []\n for line in wordlist.readlines():\n wordlistlines.append(line)\n\n global iterations\n iterations = args.iterations\n\n output = open(args.output, 'w')\n\n combos(wordlistlines, iterations, output)","def __cmd_builder(self):\n self.cmd = 'python -m lizard \"%s\" ' % self.get_proj_path()\n args = \"\"\n if self.get_cyclo_args():\n args = self.get_cyclo_args()\n exclude = \",\".join(str(x) for x in self.get_cyclo_exclude() if x is not None)\n if exclude:\n exclude = ','.join(' -x \"{0}\"'.format(w) for w in exclude.rstrip().split(','))\n self.cmd = self.cmd + args + \" \" + exclude + \" --csv\"\n print(self.cmd) # pragma: no mutate","def run(compiler: str, language: str, prelude: str, coda: str, snippet: str):\n with tempfile.TemporaryDirectory() as tmp:\n\n src = Path(tmp) / f\"main.{language}\"\n src.write_text(f\"{prelude}{snippet}{coda}\")\n\n dst = Path(tmp) / \"a.out\"\n\n std = \"-std=c++20\" if language == \"c++\" else \"-std=c11\"\n subprocess.check_call(\n [compiler, std, \"-Wall\", \"-Wextra\", \"-x\", language, \"-o\", dst, src]\n )\n\n subprocess.check_call([dst])","def run(self, line):\r\n if os.name == 'nt':\r\n if not ctypes.windll.shell32.IsUserAnAdmin() != 0:\r\n self.app.typepath.adminpriv = False\r\n elif not os.getuid() == 0:\r\n self.app.typepath.adminpriv = False\r\n\r\n nargv = []\r\n curr = []\r\n argfound = False\r\n\r\n if \"--version\" in line or \"-V\" in line:\r\n sys.stdout.write(\"\"\"%(progname)s %(version)s\\n\"\"\" % \\\r\n {'progname': versioning.__longname__, 'version': \\\r\n versioning.__version__})\r\n sys.stdout.flush()\r\n sys.exit(self.retcode)\r\n\r\n else:\r\n for argument in enumerate(line):\r\n if not argfound and not argument[1].startswith('-'):\r\n nargv = line[argument[0]:]\r\n break\r\n else:\r\n argfound = False\r\n\r\n if argument[1] == \"-c\":\r\n argfound = True\r\n\r\n curr.append(argument[1])\r\n\r\n (self.opts, _) = self.parser.parse_args(curr)\r\n\r\n try:\r\n Encryption.encode_credentials('test')\r\n self.app.set_encode_funct(Encryption.encode_credentials)\r\n self.app.set_decode_funct(Encryption.decode_credentials)\r\n self.encoding = True\r\n except redfish.hpilo.risblobstore2.ChifDllMissingError:\r\n self.encoding = False\r\n\r\n if self.opts.config is not None and len(self.opts.config) > 0:\r\n if not os.path.isfile(self.opts.config):\r\n self.retcode = ReturnCodes.CONFIGURATION_FILE_ERROR\r\n sys.exit(self.retcode)\r\n\r\n self.app.config_file = self.opts.config\r\n\r\n self.app.config_from_file(self.app.config_file)\r\n if self.opts.logdir and self.opts.debug:\r\n logdir = self.opts.logdir\r\n else:\r\n logdir = self.app.config.get_logdir()\r\n\r\n if logdir and self.opts.debug:\r\n try:\r\n os.makedirs(logdir)\r\n except OSError as ex:\r\n if ex.errno == errno.EEXIST:\r\n pass\r\n else:\r\n raise\r\n\r\n if self.opts.debug:\r\n logfile = os.path.join(logdir, versioning.__shortname__+'.log')\r\n\r\n # Create a file logger since we got a logdir\r\n lfile = logging.FileHandler(filename=logfile)\r\n formatter = logging.Formatter(\"%(asctime)s %(levelname)s\\t: \" \\\r\n \"%(message)s\")\r\n\r\n lfile.setFormatter(formatter)\r\n lfile.setLevel(logging.DEBUG)\r\n LOGGER.addHandler(lfile)\r\n self.app.LOGGER = LOGGER\r\n\r\n cachedir = None\r\n if self.opts.nocache:\r\n self.app.config.set_cache(False)\r\n else:\r\n self.app.config.set_cachedir(os.path.join(self.opts.config_dir, \\\r\n 'cache'))\r\n cachedir = self.app.config.get_cachedir()\r\n\r\n if cachedir:\r\n try:\r\n os.makedirs(cachedir)\r\n except OSError as ex:\r\n if ex.errno == errno.EEXIST:\r\n pass\r\n else:\r\n raise\r\n\r\n if (\"login\" in line or any(x.startswith(\"--url\") for x in line) or not line)\\\r\n and not (any(x.startswith((\"-h\", \"--h\")) for x in nargv) or \"help\" in line):\r\n self.app.logout()\r\n else:\r\n self.app.restore()\r\n self.opts.is_redfish = self.app.updatedefinesflag(redfishflag=\\\r\n self.opts.is_redfish)\r\n\r\n if nargv:\r\n try:\r\n self.retcode = self._run_command(self.opts, nargv)\r\n if self.app.config.get_cache():\r\n if (\"logout\" not in line) and (\"--logout\" not in line):\r\n self.app.save()\r\n else:\r\n self.app.logout()\r\n except Exception as excp:\r\n self.handle_exceptions(excp)\r\n\r\n return self.retcode\r\n else:\r\n self.cmdloop(self.opts)\r\n\r\n if self.app.config.get_cache():\r\n self.app.save()\r\n else:\r\n self.app.logout()","def main():\n opt = parse_opts()\n run(opt)","def main():\n opt = parse_opts()\n run(opt)","def run_genie(platform, cc=None, cxx=None):\n\n cmd = PLATFORMS_GENIE[platform]\n\n subprocess.check_call(cmd)","def write_binana_sh(self, autodock_path, autodock_path_2, command_chain_A, command_chain_B):\n opened_sh = open(\"pdbqt_generator.sh\",\"w\")\n opened_sh.write(autodock_path)\n opened_sh.write(autodock_path_2)\n opened_sh.write(command_chain_A)\n opened_sh.write(command_chain_B)\n opened_sh.close()","def main():\n parsed_args = parse_args()\n dfg = DummyFileGenerator(parsed_args[0], **parsed_args[1])\n dfg.write_output_file(**parsed_args[2])","def main():\n parser = optparse.OptionParser()\n parser.add_option('-n', dest='length', default=LENGTH, type=int)\n opts, _ = parser.parse_args()\n\n print generate(opts.length)","def gen(\n file: str,\n infer: bool = typer.Option(\n True, help=\"Whether to run type inference on code examples.\"\n ),\n exec: bool = typer.Option(\n False, help=\"Whether to attempt to execute doctring code.\"\n ),\n experimental: bool = typer.Option(False, help=\"Use experimental Ts parsing\"),\n debug: bool = False,\n dummy_progress: bool = typer.Option(False, help=\"Disable rich progress bar\"),\n):\n _intro()\n from papyri.gen import gen_main\n\n gen_main(\n infer=infer,\n exec_=exec,\n target_file=file,\n experimental=experimental,\n debug=debug,\n dummy_progress=dummy_progress,\n )","def main():\n parser = create_argument_parser(\"generate a block falling onto a saw\")\n args = parser.parse_args()\n\n if args.out_path is None:\n directory = (pathlib.Path(__file__).resolve().parents[1] / \"fixtures\" /\n \"saw\")\n args.out_path = (directory /\n \"saw-cor={:g}.json\".format(args.restitution_coeff))\n args.out_path.parent.mkdir(parents=True, exist_ok=True)\n\n print_args(args)\n\n fixture = generate_fixture(args)\n\n save_fixture(fixture, args.out_path)","def main():\n sys.argv.pop(0)\n (cmd, var, args) = process_options(sys.argv[:])\n execute(cmd, var, args)","def generate():","def main():\n # Initialize logging to the terminal and system log.\n coloredlogs.install(syslog=True)\n # Parse the command line arguments.\n context_opts = dict()\n program_opts = dict()\n dest_opts = dict()\n try:\n options, arguments = getopt.gnu_getopt(sys.argv[1:], 'bsrm:c:t:i:unx:fvqhVQp', [\n 'backup', 'snapshot', 'rotate', 'mount=', 'crypto=', 'tunnel=',\n 'ionice=', 'no-sudo', 'dry-run', 'exclude=', 'force',\n 'disable-notifications', 'verbose', 'quiet', 'help', 'multi-fs',\n 'rsync-verbose', 'rsync-quiet', 'rsync-progress'\n ])\n for option, value in options:\n if option in ('-b', '--backup'):\n enable_explicit_action(program_opts, 'backup_enabled')\n elif option in ('-s', '--snapshot'):\n enable_explicit_action(program_opts, 'snapshot_enabled')\n elif option in ('-r', '--rotate'):\n enable_explicit_action(program_opts, 'rotate_enabled')\n elif option in ('-m', '--mount'):\n program_opts['mount_point'] = value\n elif option in ('-c', '--crypto'):\n program_opts['crypto_device'] = value\n elif option in ('-t', '--tunnel'):\n ssh_user, _, value = value.rpartition('@')\n ssh_alias, _, port_number = value.partition(':')\n tunnel_opts = dict(\n ssh_alias=ssh_alias,\n ssh_user=ssh_user,\n # The port number of the rsync daemon.\n remote_port=RSYNCD_PORT,\n )\n if port_number:\n # The port number of the SSH server.\n tunnel_opts['port'] = int(port_number)\n dest_opts['ssh_tunnel'] = SecureTunnel(**tunnel_opts)\n elif option in ('-i', '--ionice'):\n value = value.lower().strip()\n validate_ionice_class(value)\n program_opts['ionice'] = value\n elif option in ('-u', '--no-sudo'):\n program_opts['sudo_enabled'] = False\n elif option in ('-n', '--dry-run'):\n logger.info(\"Performing a dry run (because of %s option) ..\", option)\n program_opts['dry_run'] = True\n elif option in ('-f', '--force'):\n program_opts['force'] = True\n elif option in ('-x', '--exclude'):\n program_opts.setdefault('exclude_list', [])\n program_opts['exclude_list'].append(value)\n elif option == '--multi-fs':\n program_opts['multi_fs'] = True\n elif option == '--disable-notifications':\n program_opts['notifications_enabled'] = False\n elif option in ('-V', '--rsync-verbose'):\n if 'rsync_verbose_count' not in program_opts:\n program_opts['rsync_verbose_count'] = 1\n else:\n program_opts['rsync_verbose_count'] = program_opts['rsync_verbose_count'] + 1\n elif option in ('-Q', '--rsync-quiet'):\n if 'rsync_quiet_count' not in program_opts:\n program_opts['rsync_quiet_count'] = 1\n else:\n program_opts['rsync_quiet_count'] = program_opts['rsync_quiet_count'] + 1\n elif option in ('-v', '--verbose'):\n coloredlogs.increase_verbosity()\n elif option in ('-q', '--quiet'):\n coloredlogs.decrease_verbosity()\n elif option in ('-p', '--rsync-progress'):\n program_opts['rsync_show_progress'] = True\n elif option in ('-h', '--help'):\n usage(__doc__)\n return\n else:\n raise Exception(\"Unhandled option! (programming error)\")\n if len(arguments) > 2:\n msg = \"Expected one or two positional arguments! (got %i)\"\n raise Exception(msg % len(arguments))\n if len(arguments) == 2:\n # Get the source from the first of two arguments.\n program_opts['source'] = arguments.pop(0)\n if arguments:\n # Get the destination from the second (or only) argument.\n dest_opts['expression'] = arguments[0]\n program_opts['destination'] = Destination(**dest_opts)\n elif not os.environ.get('RSYNC_MODULE_PATH'):\n # Show a usage message when no destination is given.\n usage(__doc__)\n return\n except Exception as e:\n warning(\"Error: %s\", e)\n sys.exit(1)\n try:\n # Inject the source context into the program options.\n program_opts['source_context'] = create_context(**context_opts)\n # Initialize the program with the command line\n # options and execute the requested action(s).\n RsyncSystemBackup(**program_opts).execute()\n except Exception as e:\n if isinstance(e, RsyncSystemBackupError):\n # Special handling when the backup disk isn't available.\n if isinstance(e, MissingBackupDiskError):\n # Check if we're connected to a terminal to decide whether the\n # error should be propagated or silenced, the idea being that\n # rsync-system-backup should keep quiet when it's being run\n # from cron and the backup disk isn't available.\n if not connected_to_terminal():\n logger.info(\"Skipping backup: %s\", e)\n sys.exit(0)\n # Known problems shouldn't produce\n # an intimidating traceback to users.\n logger.error(\"Aborting due to error: %s\", e)\n else:\n # Unhandled exceptions do get a traceback,\n # because it may help fix programming errors.\n logger.exception(\"Aborting due to unhandled exception!\")\n sys.exit(1)","def main_execute(vars):\n\n # Unpack necessary variables\n # output_directory is the root output folder for the run\n output_directory = vars[\"output_directory\"]\n\n # This will run operations which will:\n # 1) generate new ligands\n # 2) optionally filter ligands\n # 3) optionally convert from 1D smiles to 3D (mol2/PDB)\n\n sys.stdout.flush()\n\n\n smile_file_new_gen, new_gen_ligands_list = operations.populate_generation(vars)\n sys.stdout.flush()\n\n if new_gen_ligands_list is None:\n raise ValueError(\"Population failed to make enough mutants... \\\n Errors could include not enough diversity, too few seeds to the generation, \\\n number_of_mutants is too high, \\\n or all of the seed lack functional groups for performing reactions.\")\n\n sys.stdout.flush()","async def generate(root: Root, shell: str) -> None:\n root.console.print(f\"Push the following line into your {CFG_FILE[shell]}\")\n root.console.print(\n ACTIVATION_TEMPLATE.format(cmd=SOURCE_CMD[shell], exe=sys.argv[0])\n )","def h(options, buildout, version, opts):\n cwd = os.getcwd()\n md = options['compile-directory']\n c = os.path.join(md, 'configure.py')\n os.chdir(md)\n p = buildout['p'][version]\n opts = ' '.join(opts.split())\n cmd = [p, c, opts]\n print \"Running: %s\" % ' '.join(cmd)\n ret = os.system(' '.join(cmd))\n if ret > 0: raise Exception,('Cannot confiure')\n os.chdir(cwd)","def execute_tool(description, *args):\n command_line = list(args) + files_and_directories\n click.echo(f\"{description}: {' '.join(command_line)}\")\n rv = call(command_line)\n if rv != 0:\n exit(rv)","def main():\n\n\toptions = parse_arguments()\n\tcodon_counts = parse.codon_freq_table(options.codon)\n\tgenetic_code = parse.genetic_code(options.codon_table, options.gene_code)\n\n\tdc = degenerate_codons(genetic_code=genetic_code,codon_counts=codon_counts)\n\tdc.compute_results()\n\tdc.output(options.output_format)","def main():\n produce()","def script_generator(self):\n analyze_tool = \"/home/haihuam/Projects/RepPoints/mmdetection/tools/analyze_logs.py\"\n ex_options = self.global_setting.get('analyze_options', str())\n py = self.global_setting.get('python', sys.executable)\n if os.access(py, os.X_OK):\n content = \"set -e \\n\" \n content += \"cd %s \\n\"%(self.run_dir)\n content += \"%s %s plot_curve *.log.json \"%(py, analyze_tool)\n content += \"--keys loss loss_cls loss_pts_init \"\n content += \"loss_pts_refine \"\n content += \"--out losses.pdf %s &> analyze.log \\n\"%(ex_options)\n\n content += \"touch analyze.done \\n\"\n self.script_content = content\n else:\n print(\"Error: %s is not executable.\"%py)\n sys.exit(0)","def main():\n challenge = Challenge()\n # Get the number of saved files on last execution\n last_saved = challenge.get_last_execution()\n # Get the total of products to save\n total_objects = len(challenge.get_products(\"product_groups.json\"))\n\n # While there are products to be saved\n while last_saved < total_objects:\n create_products()\n # Updates last_saved number\n last_saved = challenge.get_last_execution()\n\n logging.info(\"[INFO] Execution done with no errors!\")\n # Sends to runner a signal different from the crash signal\n # Indicates terminated execution\n os._exit(1)","def generate_base(params, out):\n\n os.makedirs(out)\n experiment_path = os.path.join(out, BASE)\n shutil.copy(\"evaluation/ablation/run_all.sh\", out)\n\n print(f\"Generating {out}/{BASE}\")\n subprocess.run(\n [\n \"racket\",\n \"src/example-gen.rkt\",\n \"-b\", \"mat-mul\",\n \"-p\", params,\n \"-o\", experiment_path\n ],\n check=True,\n stderr=subprocess.PIPE)\n\n # Add all required file for the harness.\n shutil.copy(\"evaluation/ablation/Makefile\", experiment_path)\n shutil.copy(\"evaluation/ablation/harness.c\", experiment_path)\n shutil.copy(\"evaluation/src/utils.h\", experiment_path)","def generate_custom_sequence(program, pass_space=DEFAULT_GENE_POOL,\n debug=False):\n global print_out\n print_out = debug\n return simulate_generations(pass_space, program)","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 generate(cfg, filename=None, wait=False):\n code = yield generate_submission(cfg, filename)\n print(code)","def build_step(self):\n run_cmd('./compile.sh', log_all=True, simple=True, log_ok=True)","def cli():\r\n pass","def generate(self):\n logger=self.logger\n outputter=self.OutputType()\n outputter.make_runner(parser=self.parser,dry_run=self.dry_run,\n setarith=self.setarith)\n con=fileless_context(\n scopes=[self.parse_result],verbose=self.verbose,logger=logger,\n run_mode=self.run_mode)\n self.make_more(self.parse_result,con)","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():\n pass","def setup():\n\n generators = {\"man\": gen_manpage, \"cpl\": gen_completions}\n\n prsr = argparse.ArgumentParser(\n description=\"xNVMe CLI Bash-completions and man page generator\",\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n )\n prsr.add_argument(\n \"generator\",\n help=\"Generator to run\",\n default=sorted(generators.keys())[0],\n choices=sorted(generators.keys()),\n )\n prsr.add_argument(\n \"--tools\",\n nargs=\"*\",\n help=\"Name of tools to generate bash-completions for\",\n )\n prsr.add_argument(\n \"--output\",\n help=\"Path to directory in which to emit completion scripts\",\n default=os.sep.join([\".\"]),\n )\n prsr.add_argument(\n \"--log-level\",\n help=\"log-devel\",\n default=\"INFO\",\n choices=[\"DEBUG\", \"INFO\", \"WARNING\", \"ERROR\", \"CRITICAL\"],\n )\n\n args = prsr.parse_args()\n args.output = expand_path(args.output)\n args.gen = generators[args.generator]\n\n if not args.tools:\n args.tools = find_binaries()\n\n logging.basicConfig(\n format=\"%(asctime)s %(message)s\",\n level=getattr(logging, args.log_level.upper(), None),\n )\n\n return args","def main():\n insert_gateway_values(\"hermes/bin/gateways.txt\")\n return","def main():\r\n db = connect_database()\r\n with db:\r\n if sys.argv[1] == \"-s\":\r\n select_all(db, sys.argv[2])\r\n elif sys.argv[1] == \"-i\":\r\n cus_data = []\r\n for i in range(2, len(sys.argv)):\r\n cus_data.append(sys.argv[i])\r\n insert_customer(db, cus_data)\r\n elif sys.argv[1] == \"-c\":\r\n create_tables()\r\n elif sys.argv[1] == \"-pw\":\r\n pop_waiting(db, sys.argv[2])\r\n elif sys.argv[1] == \"-ph\":\r\n pop_help(db, sys.argv[2])\r\n elif sys.argv[1] == \"-r\":\r\n refresh_tables(db)\r\n elif sys.argv[1] == \"-e\":\r\n export_helped_table(db)\r\n else:\r\n print errorArgument\r\n db.close()","def cmd_generate(argv):\n description = inspect.getdoc(cmd_generate)\n parser = ArgumentParser(description=description)\n parser.add_argument(\"-o\",\"--output\", action=\"store\", dest=\"output\",\n default=\"dhall_key\", help=\"outpuf filename\")\n args = parser.parse_args(argv)\n\n import dhall.util\n dhall.util.generate_keys(key=args.output)","def main(self):\n\n try:\n if os.getuid():\n print(\"**** Error: This script (%s) must be run as root!\" % sys.argv[0])\n raise RuntimeError\n\n exit_status = self.EXIT_STATUS_SUCCESS\n self._parse_options()\n self._init_logger()\n logger = self._logger\n\n # TODO: Switch to spts' shared onject API!\n if self._pexpect_available:\n self.tool_prompt='spt> \\? .*\\n'\n #self.tool_prompt='spt> ? .*\\r\\n'\n self.tool_start='enable=pipes'\n self.tool_prompt_index = TOOL_PROMPT_INDEX\n self.tool_unique_index = TOOL_UNIQUE_INDEX\n self.tool_status_index = TOOL_STATUS_INDEX\n self.start_tool(tool=self.tool, start_cmd=self.tool_start)\n\n self.get_devices()\n self.get_drive_information()\n self.get_enclosure_information()\n self.get_drive_enclosure_information()\n\n if self._number_drives:\n self.show_device_information()\n else:\n self._logger.warning(\"No SCSI disk drives found or none match your criteria!\")\n\n except KeyboardInterrupt:\n pass\n\n except IOError as e:\n if e.errno == errno.EPIPE:\n pass\n\n except RuntimeError:\n exit_status = self.EXIT_STATUS_RUNTIME_ERROR\n if self._debug:\n logger.debug(\"Exiting with status code {0}, RuntimeError\".format(exit_status))\n\n except TimeoutExpiredError:\n exit_status = self.EXIT_STATUS_TIMEOUT_EXPIRED\n if self._debug:\n logger.debug(\"Exiting with status code {0}, TimeoutExpiredError\".format(exit_status))\n\n if self.tc:\n self.tc.terminate()\n sys.exit(exit_status)","def local(ctx):\n _do_codegen_user(\"demo\")\n _do_codegen_user(\"errors\")\n _do_codegen_user(\"mpi\")\n _do_codegen_user(\"omp\")\n _do_codegen_user(\"python\")\n\n # Do codegen for libfake\n for so in LIB_FAKE_FILES:\n _do_codegen_file(so)\n\n # Run the WAMR codegen required by the tests\n codegen(ctx, \"demo\", \"echo\", wamr=True)\n codegen(ctx, \"demo\", \"chain\", wamr=True)\n\n # Run the SGX codegen required by the tests\n codegen(ctx, \"demo\", \"hello\", wamr=True, sgx=True)\n codegen(ctx, \"demo\", \"chain_named_a\", wamr=True, sgx=True)\n codegen(ctx, \"demo\", \"chain_named_b\", wamr=True, sgx=True)\n codegen(ctx, \"demo\", \"chain_named_c\", wamr=True, sgx=True)","def main():\r\n\r\n option_parser, opts, args = parse_command_line_parameters(**script_info)\r\n\r\n # additional option checks\r\n if opts.chimera_detection_method == 'blast_fragments':\r\n if not (opts.blast_db or opts.reference_seqs_fp):\r\n option_parser.error('Must provide either --blast_db or' +\r\n ' --reference_seqs_fp and --id_to_taxonomy_fp when' +\r\n ' method is blast_fragments.')\r\n if not opts.id_to_taxonomy_fp:\r\n option_parser.error('Must provide --id_to_taxonomy_fp when method' +\r\n ' is blast_fragments.')\r\n if opts.num_fragments < 2:\r\n option_parser.error('Invalid number of fragments (-n %d) Must be >= 2.'\r\n % opts.num_fragments)\r\n elif opts.chimera_detection_method == 'ChimeraSlayer':\r\n if not opts.aligned_reference_seqs_fp:\r\n option_parser.error(\"Must provide --aligned_reference_seqs_fp \"\r\n \"when using method ChimeraSlayer\")\r\n elif opts.chimera_detection_method == 'usearch61':\r\n if opts.suppress_usearch61_ref and opts.suppress_usearch61_denovo:\r\n option_parser.error(\"Supressing both de novo and reference \"\r\n \"chimera detection not allowed.\")\r\n if not opts.reference_seqs_fp and not opts.suppress_usearch61_ref:\r\n option_parser.error(\"--reference_seqs_fp required for reference \"\r\n \"based chimera detection, suppress reference based chimera \"\r\n \"detection with --suppress_usearch61_ref\")\r\n if opts.reference_seqs_fp:\r\n try:\r\n temp_f = open(opts.reference_seqs_fp, \"U\")\r\n temp_f.close()\r\n except IOError:\r\n raise IOError(\"Unable to open --reference_seqs_fp, please \"\r\n \"check filepath and permissions.\")\r\n if opts.non_chimeras_retention not in ['intersection', 'union']:\r\n option_parser.error(\"--non_chimeras_retention must be either \"\r\n \"'union' or 'intersection'\")\r\n if opts.usearch61_xn <= 1:\r\n option_parser.error(\"--usearch61_xn must be > 1\")\r\n if opts.usearch61_dn <= 0:\r\n option_parser.error(\"--usearch61_dn must be > 0\")\r\n if opts.usearch61_mindiffs <= 0:\r\n option_parser.error(\"--usearch61_mindiffs must be > 0\")\r\n if opts.usearch61_mindiv <= 0:\r\n option_parser.error(\"--usearch61_mindiv must be > 0\")\r\n if opts.usearch61_abundance_skew <= 0:\r\n option_parser.error(\"--usearch61_abundance_skew must be > 0\")\r\n\r\n verbose = opts.verbose # not used yet ...\r\n input_seqs_fp = opts.input_fasta_fp\r\n id_to_taxonomy_fp = opts.id_to_taxonomy_fp\r\n reference_seqs_fp = opts.reference_seqs_fp\r\n chimera_detection_method = opts.chimera_detection_method\r\n num_fragments = opts.num_fragments\r\n output_fp = opts.output_fp\r\n taxonomy_depth = opts.taxonomy_depth\r\n max_e_value = opts.max_e_value\r\n blast_db = opts.blast_db\r\n keep_intermediates = opts.keep_intermediates\r\n threads = opts.threads\r\n\r\n # calculate threads as 1 per CPU, or use float of input value\r\n if threads == 'one_per_cpu':\r\n threads = float(1 / cpu_count())\r\n else:\r\n # Make sure input is a float\r\n try:\r\n threads = float(threads)\r\n except ValueError:\r\n option_parser.error(\"--threads must be a float value if \"\r\n \"default 'one_per_cpu' value overridden.\")\r\n\r\n if not output_fp:\r\n if chimera_detection_method == \"usearch61\":\r\n output_dir = \"usearch61_chimeras/\"\r\n create_dir(output_dir, fail_on_exist=False)\r\n else:\r\n input_basename = splitext(split(input_seqs_fp)[1])[0]\r\n output_fp = '%s_chimeric.txt' % input_basename\r\n elif chimera_detection_method == \"usearch61\":\r\n output_dir = output_fp\r\n create_dir(output_dir, fail_on_exist=False)\r\n\r\n if chimera_detection_method == 'blast_fragments':\r\n blast_fragments_identify_chimeras(input_seqs_fp,\r\n id_to_taxonomy_fp,\r\n reference_seqs_fp, blast_db=blast_db,\r\n num_fragments=opts.num_fragments,\r\n max_e_value=max_e_value,\r\n output_fp=output_fp,\r\n taxonomy_depth=taxonomy_depth)\r\n elif chimera_detection_method == 'ChimeraSlayer':\r\n chimeraSlayer_identify_chimeras(input_seqs_fp,\r\n output_fp=output_fp,\r\n db_FASTA_fp=opts.reference_seqs_fp,\r\n db_NAST_fp=opts.aligned_reference_seqs_fp,\r\n min_div_ratio=opts.min_div_ratio,\r\n keep_intermediates=keep_intermediates)\r\n elif chimera_detection_method == 'usearch61':\r\n usearch61_chimera_check(input_seqs_fp,\r\n output_dir=output_dir,\r\n reference_seqs_fp=reference_seqs_fp,\r\n suppress_usearch61_intermediates=opts.suppress_usearch61_intermediates,\r\n suppress_usearch61_ref=opts.suppress_usearch61_ref,\r\n suppress_usearch61_denovo=opts.suppress_usearch61_denovo,\r\n split_by_sampleid=opts.split_by_sampleid,\r\n non_chimeras_retention=opts.non_chimeras_retention,\r\n usearch61_minh=opts.usearch61_minh,\r\n usearch61_xn=opts.usearch61_xn,\r\n usearch61_dn=opts.usearch61_dn,\r\n usearch61_mindiffs=opts.usearch61_mindiffs,\r\n usearch61_mindiv=opts.usearch61_mindiv,\r\n usearch61_abundance_skew=opts.usearch61_abundance_skew,\r\n percent_id_usearch61=opts.percent_id_usearch61,\r\n minlen=opts.minlen,\r\n word_length=opts.word_length,\r\n max_accepts=opts.max_accepts,\r\n max_rejects=opts.max_rejects,\r\n verbose=opts.verbose,\r\n threads=threads)","def start_compilation(self):\n if(not self.check_main_requirements()):\n exit(0)\n\n save_sysetting('last_action', self.COMPILE)\n\n self.add_board()\n if(not self.board_id):\n self.print(\"select_board_list\")\n return\n\n self.add_option('lib_extra_dirs')\n\n # check if there is a new speed to overwrite\n self.add_option('upload_speed')\n\n # add src_dir option if it's neccesary\n self.override_src()\n\n cmd = ['run', '-e ', self.board_id]\n self.run_command(cmd)\n\n self.after_complete()","def main():\n # if len(sys.argv) == 1:\n # TicTacToe().mainloop()\n # else:\n # needEval = ['-degree']\n # args = sys.argv[1:]\n # opts = {}\n # # parse the opts and args two at a time\n # for i in range(0, len(args), +2):\n # if args[i] in needEval:\n # opts[args[i][1:]] = eval(args[i+1])\n # else:\n # opts[args[i][1:]] = args[i+1]\n # trace(opts)\n # apply(TicTacToe, (), opts).mainloop()\n player1 = Player('X')\n player2 = Player('O')\n series = Series([player1, player2])\n series.run(100000)\n\n series2 = Series()\n series2.run(2, trace=True)\n # pa1 = PlayerSmart('smrt1', 'X')\n # pa2 = PlayerSmart('smrt2', 'O')\n # Game().play([pa1, pa2])","def main():\n is_program_working = True\n while is_program_working:\n display.print_program_menu(MAIN_MENU)\n try:\n choose_option()\n except ValueError as err:\n display.print_command_result(str(err))","def main():\n parser = argparse.ArgumentParser(description=DESCRIPTON, epilog=EXAMPLE)\n parser.add_argument(\n \"--version\", action=\"version\", version=\"%(prog)s {}\".format(VERSION)\n )\n parser.add_argument(\n \"-u\", \"--url\", metavar=\"<TARGET_URL>\",\n required=\"-F\" not in sys.argv and \"--file\" not in sys.argv,\n help=\"URL of the target GWT {name}.nocache.js bootstrap or {hex}.cache.js file\",\n type=url_mode_checks\n )\n parser.add_argument(\n \"-F\", \"--file\", metavar=\"<FILE>\", default=None,\n required=\"-u\" not in sys.argv and \"--url\" not in sys.argv,\n help=\"path to the local copy of a {hex}.cache.js GWT permutation file\",\n type=file_mode_checks\n )\n parser.add_argument(\n \"-b\", \"--base\", metavar=\"<BASE_URL>\", default=BASE_URL,\n help=\"specifies the base URL for a given permutation file in -F/--file mode\"\n )\n parser.add_argument(\n \"-p\", \"--proxy\", metavar=\"<PROXY>\", default=None,\n help=\"URL for an optional HTTP proxy (e.g. -p http://127.0.0.1:8080)\"\n )\n parser.add_argument(\n \"-c\", \"--cookies\", metavar=\"<COOKIES>\", default=None,\n help=\"any cookies required to access the remote resource in -u/--url mode \"\n + \"(e.g. 'JSESSIONID=ABCDEF; OTHER=XYZABC')\"\n )\n parser.add_argument(\n \"-f\", \"--filter\", metavar=\"<FILTER>\", default=\"\",\n help=\"case-sensitive method filter for output (e.g. -f AuthSvc.checkSession)\"\n )\n parser.add_argument(\n \"--basic\", action=\"store_true\", default=False,\n help=\"enables HTTP Basic authentication if require. Prompts for credentials\"\n )\n parser.add_argument(\n \"--rpc\", action=\"store_true\", default=False,\n required=\"--probe\" in sys.argv,\n help=\"attempts to generate a serialized RPC request for each method\"\n )\n parser.add_argument(\n \"--probe\", action=\"store_true\", default=False,\n help=\"sends an HTTP probe request to test each method returned in --rpc mode\"\n )\n parser.add_argument(\n \"--svc\", action=\"store_true\", default=False,\n help=\"displays enumerated service information, in addition to methods\"\n )\n parser.add_argument(\n \"--code\", action=\"store_true\", default=False,\n help=\"skips all and dumps the 're-formatted' state of the provided resource\"\n )\n parser.add_argument(\n \"--color\", action=\"store_true\", default=False,\n help=\"enables coloured console output\"\n )\n parser.add_argument(\n \"--backup\", metavar=\"DIR\", nargs='?', default=False,\n help=\"creates a local backup of retrieved code in -u/--url mode\"\n )\n parser.add_argument(\n \"-q\", \"--quiet\", action=\"store_true\", default=False,\n help=\"enables quiet mode (minimal output)\"\n )\n\n parser._optionals.title = \"Arguments\"\n args = parser.parse_args()\n\n global COLOR_MODE\n COLOR_MODE = args.color\n\n if not args.code and not args.quiet:\n present_banner()\n\n set_base_url(args.url if args.base is BASE_URL else args.base)\n\n set_http_params(args)\n\n if not args.code and not args.quiet:\n present_target(args.url if args.file is None else args.file)\n\n code, code_type = (\n read_file(args.file) if args.file is not None else\n fetch_code(args.url)\n )\n\n check_warnings(code_type, args)\n\n code = clean_code(code, code_type)\n\n if code_type.startswith(BOOTSTRAP) and args.file is None:\n code = get_permutation(code, code_type, args)\n\n set_globals(code, args)\n\n if is_fragmented(''.join(code), code_type) and args.file is None:\n code = append_fragments(code, code_type, args)\n\n backup_file = None\n if args.backup is not False and args.file is None:\n backup_file = save_code(code, code_type, args.backup)\n\n if args.code:\n present_code(code)\n sys.exit(0)\n\n if not args.quiet:\n present_module_info()\n\n service_objects = extract_service_info(code)\n if args.svc:\n present_services(service_objects, args.quiet)\n\n method_objects = extract_method_info(code, service_objects)\n count = present_methods(method_objects, args.quiet, args.probe)\n\n if not args.quiet:\n present_summary(service_objects, method_objects, count, backup_file)","def cli(ctx: click.Context, config_instance: str, config_path: str) -> None:\n ctx.obj = TurbiniaCli(\n config_instance=config_instance, config_path=config_path)\n\n # Set up the tool based on the configuration file parameters.\n ctx.obj.setup()\n\n # Build all the commands based on responses from the API server.\n request_commands = factory.CommandFactory.create_dynamic_objects(\n evidence_mapping=ctx.obj.evidence_mapping,\n request_options=ctx.obj.request_options)\n for command in request_commands:\n groups.submit_group.add_command(command)","def main():\n sys.exit(RBExt().run(sys.argv[1:]))","def main():\n\n\tparser = OptionParser()\n\tparser.add_option(\"-l\", dest=\"liglist\", help=\"list of ligands\")\n\tparser.add_option(\"-r\", dest=\"runfile\", help=\"run file\")\n\tparser.add_option(\"-o\", dest=\"logfile\", help=\"log file\")\n\tparser.add_option(\"-b\", dest=\"bkupfile\", help=\"backed up file\")\n\tparser.add_option(\"-g\", dest=\"go\", help=\"do the runs\",action=\"store_true\")\n\tparser.set_description(main.__doc__)\n\t(options,args) = parser.parse_args()\n\n\tif not options.liglist or not options.runfile:\n\t\tparser.print_help()\n\t\tsys.exit()\n\n\tif not options.logfile:\n\t\tparser.print_help()\n\t\tsys.exit()\n\n\t# --- create directories for each ligand --- #\t\n\tligands = files_from_list(options.liglist)\t\n\n\texe = \"basename $PWD\"\n\tcurrdir = commands.getoutput(exe)\n\n\tcwd = os.getcwd()\n\tls = os.listdir(cwd)\n\tprotein = currdir + \"_9.pdb\"\n\tif not protein in ls:\n\t\tprint \"cannot find protein file:\",protein\n\t\tsys.exit()\n\n\ttry:\n\t\tRUN = open(options.runfile)\n\texcept:\n\t\tprint \"unable to open run file\"\n\t\tsys.exit()\t\n\n\trunline = RUN.readline()\n\tre_het = re.compile(\"HETERO\")\n\tre_prt = re.compile(\"PROTEIN\")\n\n\tif not re_het.search(runline):\n\t\tprint \"run must contain HETERO\"\n\t\tsys.exit()\n\n\tif not re_prt.search(runline):\n\t\tprint \"run must contain PROTEIN\"\n\t\tsys.exit()\n\t\t\n\n\tfor lig in ligands:\n\t\trline = runline\n\t\tligbase = get_basefile(lig)\n\n\t\texe = \"mkdir \" + ligbase\n\t\tos.system(exe)\n\n\t\texe = \"cp \" + lig + \" \" + ligbase\n\t\tos.system(exe)\n\n\t\texe = \"cp \" + currdir + \"* \" + ligbase\n\t\tos.system(exe)\n\n\t\texe = \"cp paths.txt \" + ligbase\n\t\tos.system(exe)\n\n\t\texe = \"cp \" + options.bkupfile + \" \" + ligbase\n\t\tos.system(exe)\n\n\t\trline = rline.replace(\"HETERO\", lig)\n\t\trline = rline.replace(\"PROTEIN\", protein)\n\t\t\n\t\tnewrun = ligbase + \"/\" + options.runfile\n\t\ttry:\n\t\t\tOUTRUN = open(newrun, 'w')\n\t\texcept:\n\t\t\tprint \"cannot make new run\"\n\t\t\tsys.exit()\n\n\n\t\tOUTRUN.write(rline) \n\t\tOUTRUN.close()\n\t\tos.chmod(newrun, stat.S_IRWXU)\n\n\t\tif options.go:\n\t\t\tos.chdir(ligbase)\n\t\t\tprint \" in\",os.getcwd()\n\t\t\texe = \"nice ./\" + options.runfile + \" >& \" + options.logfile\n\t\t\tos.system(exe)\n\t\t\tos.chdir(\"..\")","def cli():\n\n pass"],"string":"[\n \"def main():\\n\\n BASIC.run(PROGRAM)\",\n \"def generate(options):\\n interactive = options['i']\\n if interactive:\\n generate_interactive(options)\\n else:\\n generate_rcfile(vars(options['c']), options['rcfile'])\",\n \"def run():\\n names=[i.__name__ for i in modList]\\n res,action=kcs_ui.string_select('fake vitesse generator',\\n 'Please select the module you want to generate fake vitesse py.',\\n 'Press option to generate for all modules.',\\n names)\\n if res==kcs_util.ok():\\n mod=modList[action-1]\\n des=kcs_ui.string_req('Where do you want to place the file?',r'C:\\\\temp')\\n if des[0]==kcs_util.ok():\\n# des = os.path.join(os.path.join(os.getcwd(), \\\"FakeVitesse\\\"))\\n fname = des[1] + \\\"\\\\\\\\\\\" + mod.__name__ + \\\".py\\\"\\n GenPy(mod, fname)\\n elif res==kcs_util.options():\\n des=kcs_ui.string_req('Where do you want to place the file?',r'C:\\\\temp')\\n if des[0]==kcs_util.ok():\\n for mod in modList:\\n fname = des[1] + \\\"\\\\\\\\\\\" + mod.__name__ + \\\".py\\\"\\n GenPy(mod, fname)\",\n \"def main():\\n\\n\\tparser = OptionParser()\\n\\tparser.add_option(\\\"-p\\\", dest=\\\"pdbfile\\\", help=\\\"pdbfile\\\")\\n\\tparser.add_option(\\\"-o\\\", dest=\\\"outfile\\\", help=\\\"outfile\\\")\\n\\tparser.add_option(\\\"-r\\\", dest=\\\"replace\\\", help=\\\"replace\\\", action=\\\"store_true\\\")\\n\\tparser.set_description(main.__doc__)\\n\\t(options, args) = parser.parse_args()\\n\\n\\texe = \\\"makeSelection.py\\\" \\n\\tsele = ' -s \\\"CEN\\\"'\\n\\n\\tif options.pdbfile:\\n\\t\\texe += \\\" -p \\\" + options.pdbfile\\n\\telse:\\n\\t\\tparser.print_help()\\n\\t\\tsys.exit()\\n\\n\\tif options.outfile:\\n\\t\\texe += \\\" -o \\\" + options.outfile\\n\\telif options.replace:\\n\\t\\texe += \\\" -r \\\"\\n\\telse:\\n\\t\\tparser.print_help()\\n\\t\\tsys.exit()\\n\\n\\texe += sele\\n\\n\\tos.system(exe)\",\n \"def main():\\n parser = create_argument_parser(\\n \\\"generate a wheel spinning loose on an axle\\\",\\n default_gravity=[0, -9.81, 0])\\n parser.add_argument(\\\"--num-links\\\",\\n type=int,\\n default=11,\\n help=\\\"number of links in the chain\\\")\\n args = parser.parse_args()\\n\\n if args.out_path is None:\\n directory = pathlib.Path(__file__).resolve().parents[1] / \\\"fixtures\\\"\\n args.out_path = directory / \\\"chain-cross-section.json\\\"\\n args.out_path.parent.mkdir(parents=True, exist_ok=True)\\n\\n print_args(args)\\n\\n fixture = generate_fixture(args)\\n\\n save_fixture(fixture, args.out_path)\",\n \"def script_generator(self):\\n py = self.global_setting.get('python', sys.executable)\\n ex_options = self.global_setting.get('evaluate_options', str())\\n train_py = \\\"/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py\\\"\\n if os.access(py, os.X_OK):\\n content = \\\"set -e \\\\n\\\"\\n content += \\\"export CUDA_VISIBLE_DEVICES=\\\" + \\\\\\n \\\",\\\".join(self.selected_gpus)+ \\\" \\\\n\\\"\\n content += \\\"cd %s \\\\n\\\"%(self.run_dir)\\n \\n content += \\\"%s %s %s --work_dir %s --validate %s &> train.log \\\\n\\\"%(py, \\n train_py,\\n self.setting['config_file'],\\n self.run_dir,\\n ex_options)\\n content += \\\"touch evaluate.done \\\\n\\\"\\n\\n self.script_content = content\\n else:\\n print(\\\"Error: %s is not executable.\\\"%py)\\n sys.exit(0)\",\n \"def generate():\\n PackCommandExecutor().pack()\\n GenerateCommandExecutor().generate()\",\n \"def main(binary_name, code_directory, verbose, clase):\\n print(\\\"Start of binaries generation\\\")\\n #Directory to iterate\\n directory = '../../results/'+code_directory + '/' + clase + '/application_signature/'\\n #Directory to store the binaries to generate\\n bin_directory = './bin/'\\n #Task to performed on the new script\\n make_clean = 'make clean\\\\n'\\n for dirs in os.listdir(directory):\\n print('Generating binary for path', dirs)\\n if os.path.exists(directory+dirs+'/bin/'+dirs):\\n os.remove(directory+dirs+'/bin/'+dirs)\\n #Creation of the script\\n with open(directory+dirs+'/make_bin.sh', 'w') as bin_file:\\n bin_file.write('#! /bin/bash\\\\n')\\n bin_file.write(make_clean+'\\\\n')\\n bin_file.write('make '+code_directory+' CLASS='+clase+'\\\\n')\\n bin_file.write('mv '+bin_directory+binary_name+' '+bin_directory+binary_name+'_'+dirs+'\\\\n')\\n bin_file.write(make_clean)\\n bin_file.close()\\n try:\\n #Changing privileges so script can be executed automatically\\n os.chmod(directory+dirs+'/make_bin.sh', 0o777)\\n #Move to directory where script is to be executed\\n cwd = os.getcwd()\\n #Change cwd to execute script generating the binary\\n os.chdir(directory+dirs)\\n if verbose:\\n subprocess.check_call('./make_bin.sh')\\n else:\\n subprocess.check_call('./make_bin.sh', stdout=subprocess.PIPE, shell=False)\\n \\n os.chdir(cwd)\\n except FileNotFoundError as e:\\n logger.error(e)\\n raise\\n print('End of binaries generation')\",\n \"def execute(self):\\n if self._cli_arguments.get('<samplename>') == 'cfn':\\n generate_sample_cfn_module(self.env_root)\\n elif self._cli_arguments.get('<samplename>') == 'static-angular':\\n generate_sample_static_angular(self.env_root)\\n elif self._cli_arguments.get('<samplename>') == 'static-react':\\n generate_sample_static_react(self.env_root)\\n elif self._cli_arguments.get('<samplename>') == 'sls-py':\\n generate_sample_sls_module(self.env_root, 'sls-py')\\n elif self._cli_arguments.get('<samplename>') == 'sls-tsc':\\n generate_sample_sls_module(self.env_root, 'sls-tsc')\\n elif self._cli_arguments.get('<samplename>') == 'stacker':\\n generate_sample_stacker_module(self.env_root)\\n elif self._cli_arguments.get('<samplename>') == 'tf':\\n generate_sample_tf_module(self.env_root)\\n elif self._cli_arguments.get('<samplename>') == 'k8s-cfn-repo':\\n generate_sample_k8s_cfn_repo(self.env_root)\\n elif self._cli_arguments.get('<samplename>') == 'k8s-tf-repo':\\n generate_sample_k8s_tf_repo(self.env_root)\\n elif self._cli_arguments.get('<samplename>') == 'cdk-tsc':\\n generate_sample_cdk_tsc_module(self.env_root)\\n elif self._cli_arguments.get('<samplename>') == 'cdk-py':\\n generate_sample_cdk_py_module(self.env_root)\\n elif self._cli_arguments.get('<samplename>') == 'cdk-csharp':\\n generate_sample_cdk_cs_module(self.env_root)\\n else:\\n LOGGER.info(\\\"Available samples to generate:\\\")\\n for i in ['cfn', 'static-angular', 'static-react', 'sls-tsc',\\n 'sls-py', 'tf', 'k8s-cfn-repo', 'k8s-tf-repo',\\n 'stacker', 'cdk-tsc', 'cdk-py', 'cdk-csharp']:\\n print(i)\",\n \"def main() -> None:\\n # The first thing to do is get the lines of the PyFlex file we are given.\\n parser = Parser(filename=sys.argv[1])\\n parsed_data = parser.ParseFile()\\n\\n # Upon retrieving the Parsed Data, assign the parsed data to the\\n # Symbol Table.\\n SymbolTable.RULESET = parsed_data['ruleset']\\n SymbolTable.INSTRUCTIONS = parsed_data['instructions']\\n SymbolTable.CODE = parsed_data['code']\\n # SymbolTable.PrintTable()\\n\\n # Using the Generator backend, we can build the generated script\\n generator = Generator()\\n generator.GenerateNewScript()\\n\\n autopep8.fix_file(filename=generator.file_main)\\n\\n print(\\\"Generated Script can be found in {}\\\".format(generator.file_main))\",\n \"def script_generator(self):\\n\\n self._get_free_tcp_port()\\n\\n train_py = \\\"/home/haihuam/Projects/RepPoints/mmdetection/tools/train.py\\\"\\n py = self.global_setting.get('python', sys.executable)\\n ex_options = self.global_setting.get('train_options', str())\\n\\n if not os.access(py, os.X_OK):\\n py = \\\"/home/haihuam/anaconda3/envs/RepPoints/bin/python\\\"\\n \\n if os.access(py, os.X_OK):\\n content = \\\"set -e \\\\n\\\"\\n content += \\\"export CUDA_VISIBLE_DEVICES=\\\" + \\\\\\n \\\",\\\".join(self.selected_gpus)+ \\\" \\\\n\\\"\\n\\n content += \\\"cd %s \\\\n\\\"%(self.run_dir)\\n content += \\\"%s -m torch.distributed.launch \\\"%(py)\\n content += \\\"--nproc_per_node=%s \\\"%(self.setting['train_num_gpu'])\\n content += \\\"--master_port %s \\\"%(self.dist_train_port)\\n content += \\\"%s %s --launcher pytorch \\\"%(train_py, self.setting['config_file'])\\n content += \\\"--work_dir %s \\\"%(self.run_dir)\\n content += \\\"--resume_from latest.pth \\\"\\n content += \\\"--validate %s &> %s.log \\\\n\\\"%(ex_options, self.stage)\\n content += \\\"touch train.done \\\\n\\\"\\n # return content\\n self.script_content = content\\n else:\\n print(\\\"Error: %s is not executable.\\\"%py)\\n sys.exit(0)\",\n \"def main():\\n run_program()\",\n \"def main():\\n\\t\\n\\tparser = argparse.ArgumentParser(description=\\\"This invokes a java program to place and/or route a design using Vivado tcl.\\\")\\n\\tparser.add_argument('input_dcp', nargs=1, help=\\\"Input design checkpoint (.dcp) file.\\\")\\n\\tparser.add_argument('output_dcp', nargs=1, help=\\\"Output dcp file.\\\")\\n\\tparser.add_argument('-p', '--place', dest='place', action='store_true', help=\\\"Place design.\\\")\\n\\tparser.add_argument('-r', '--route', dest='route', action='store_true', help=\\\"Route design.\\\")\\n\\tparser.add_argument('-b', '--both', dest='place_and_route', action='store_true', help=\\\"Place and route design. This option supercedes -p or -r.\\\")\\n\\tparser.add_argument('-q', '--quiet', dest='quiet', action='store_true', help=\\\"Suppress messages.\\\")\\n\\tparser.add_argument('-f', '--force', dest='force', action='store_true', help=\\\"Overwrite file at destination if it exists.\\\")\\n\\targs = parser.parse_args()\\n\\t\\n\\t\\n\\tif args.place or args.place_and_route:\\n\\t\\tplace_flag = \\\"-p true\\\"\\n\\telse:\\n\\t\\tplace_flag = \\\"-p false\\\"\\n\\t\\t\\n\\tif args.route or args.place_and_route:\\n\\t\\troute_flag = \\\"-r true\\\"\\n\\telse:\\n\\t\\troute_flag = \\\"-r false\\\"\\n\\t\\n\\tif args.force:\\n\\t\\tforce_flag = \\\"-f true\\\"\\n\\telse:\\n\\t\\tforce_flag = \\\"-f false\\\"\\n\\tif args.quiet:\\n\\t\\tquiet_flag = \\\"-q true\\\"\\n\\telse:\\n\\t\\tquiet_flag = \\\"-q false\\\"\\n\\t\\n\\t\\n\\tplace_and_route_dir = \\\"~/Documents/2019_summer/AddILA/\\\"\\n\\tclass_path = \\\".:/nfs/ug/thesis/thesis0/pc2019/Software/RapidWright/RapidWright\\\"\\n\\t\\n\\tcd_cmd = \\\"cd {}\\\".format(place_and_route_dir)\\n\\tjava_compile_cmd = \\\"javac PlaceAndRoute.java\\\".format()\\n\\n\\ttry:\\n\\t\\tif not args.quiet:\\n\\t\\t\\tprint(\\\"pwd\\\")\\n\\t\\tpwd = subprocess.check_output(\\\"pwd\\\").decode(sys.stdout.encoding).strip()\\n\\t\\tif not args.quiet:\\n\\t\\t\\tprint(cd_cmd)\\n\\t\\tos.system(cd_cmd)\\n\\texcept:\\n\\t\\tprint(\\\"\\\\nERROR: Failed to execute '{}'.\\\".format(cd_cmd))\\n\\t\\treturn 1\\n\\n\\tif args.input_dcp[0][0] in {'~', '/'}:\\n\\t\\tinput_dcp = args.input_dcp[0]\\n\\telse:\\n\\t\\tinput_dcp = pwd + \\\"/\\\" + args.input_dcp[0]\\n\\tif args.output_dcp[0][0] in {'~', '/'}:\\n\\t\\toutput_dcp = args.output_dcp[0]\\n\\telse:\\n\\t\\toutput_dcp = pwd + \\\"/\\\" + args.output_dcp[0]\\n\\t\\n\\tjava_execute_cmd = \\\"java -cp {0} PlaceAndRoute {1} {2} {3} {4} {5} {6}\\\".format(class_path, input_dcp, output_dcp, place_flag, route_flag, force_flag, quiet_flag)\\n\\t\\n\\ttry:\\n\\t\\tif not args.quiet:\\n\\t\\t\\tprint(java_compile_cmd)\\n\\t\\tos.system(java_compile_cmd)\\n\\texcept:\\n\\t\\tprint(\\\"\\\\nERROR: Failed to execute '{}'.\\\".format(java_compile_cmd))\\n\\t\\treturn 1\\n\\n\\ttry:\\n\\t\\tif not args.quiet:\\n\\t\\t\\tprint(java_execute_cmd)\\n\\t\\tos.system(java_execute_cmd)\\n\\texcept:\\n\\t\\tprint(\\\"\\\\nERROR: Failed to execute '{}'.\\\".format(java_execute_cmd))\\n\\t\\treturn 1\",\n \"def main(argv=None):\\n if not check_python_version():\\n return 2\\n\\n if argv is None:\\n argv = sys.argv[1:]\\n ap = argparse.ArgumentParser(description=\\\"DistAlgo compiler.\\\",\\n argument_default=argparse.SUPPRESS)\\n _add_compiler_args(ap)\\n ap.add_argument('-o', help=\\\"Output file name.\\\",\\n dest=\\\"outfile\\\", default=None)\\n ap.add_argument('-L', help=\\\"Logging output level.\\\",\\n dest=\\\"debug\\\", default=None)\\n ap.add_argument('-i',\\n help=\\\"Generate interface code for plugging\\\"\\n \\\" into incrementalizer.\\\",\\n action='store_true', dest=\\\"geninc\\\", default=False)\\n ap.add_argument(\\\"-m\\\", \\\"--inc-module-name\\\",\\n help=\\\"name of the incrementalized interface module, \\\"\\n \\\"defaults to source module name + '_inc'. \\\",\\n dest=\\\"incfile\\\", default=None)\\n ap.add_argument('-O', '--optimize', type=int, default=-1)\\n ap.add_argument('-D', '--dump-ast', default=False, action='store_true')\\n ap.add_argument('-C', '--write-bytecode', default=False, action='store_true')\\n ap.add_argument('-I', '--interactive',\\n help=\\\"Launch interactive shell.\\\",\\n action='store_true', default=False)\\n ap.add_argument('-B', '--benchmark',\\n help=\\\"Print the elapsed wallclock time of the compile session.\\\",\\n action='store_true', default=False)\\n ap.add_argument('-p', help=\\\"Generate DistAlgo pseudo code.\\\",\\n action='store_true', dest=\\\"genpsd\\\", default=False)\\n ap.add_argument(\\\"-v\\\", \\\"--version\\\", action=\\\"version\\\", version=__version__)\\n ap.add_argument('--psdfile', help=\\\"Name of DistAlgo pseudo code output file.\\\",\\n dest=\\\"psdfile\\\", default=None)\\n ap.add_argument('infile', metavar='SOURCEFILE', type=str,\\n help=\\\"DistAlgo input source file.\\\")\\n args = ap.parse_args(argv)\\n\\n if args.benchmark:\\n global WallclockStart\\n WallclockStart = time.perf_counter()\\n\\n if args.interactive:\\n import code\\n code.interact()\\n return\\n\\n if args.debug is not None:\\n try:\\n level = int(args.debug)\\n if is_valid_debug_level(level):\\n set_debug_level(level)\\n else:\\n raise ValueError()\\n except ValueError:\\n stderr.write(\\\"Invalid debugging level %s.\\\\n\\\" % str(args.debug))\\n\\n if args.genpsd:\\n res = dafile_to_pseudofile(args.infile, args.psdfile, args)\\n elif args.geninc:\\n res = dafile_to_incfiles(args)\\n elif args.write_bytecode:\\n res = dafile_to_pycfile(args.infile, args.outfile, args.optimize,\\n args=args)\\n else:\\n res = dafile_to_pyfile(args.infile, args.outfile, args)\\n\\n if args.benchmark:\\n import json\\n walltime = time.perf_counter() - WallclockStart\\n jsondata = {'Wallclock_time' : walltime,\\n \\\"Input_size\\\" : InputSize,\\n \\\"Output_size\\\" : OutputSize}\\n print(\\\"###OUTPUT: \\\" + json.dumps(jsondata))\\n\\n return res\",\n \"def main():\\n # Initialize logging to the terminal and system log.\\n coloredlogs.install(syslog=True)\\n # Parse the command line arguments.\\n context_opts = dict()\\n program_opts = dict()\\n dest_opts = dict()\\n try:\\n options, arguments = getopt.gnu_getopt(sys.argv[1:], 'bsrm:c:t:i:unx:fvqh', [\\n 'backup', 'snapshot', 'rotate', 'mount=', 'crypto=', 'tunnel=',\\n 'ionice=', 'no-sudo', 'dry-run', 'multi-fs', 'exclude=', 'force',\\n 'disable-notifications', 'verbose', 'quiet', 'help',\\n ])\\n for option, value in options:\\n if option in ('-b', '--backup'):\\n enable_explicit_action(program_opts, 'backup_enabled')\\n elif option in ('-s', '--snapshot'):\\n enable_explicit_action(program_opts, 'snapshot_enabled')\\n elif option in ('-r', '--rotate'):\\n enable_explicit_action(program_opts, 'rotate_enabled')\\n elif option in ('-m', '--mount'):\\n program_opts['mount_point'] = value\\n elif option in ('-c', '--crypto'):\\n program_opts['crypto_device'] = value\\n elif option in ('-t', '--tunnel'):\\n ssh_user, _, value = value.rpartition('@')\\n ssh_alias, _, port_number = value.partition(':')\\n tunnel_opts = dict(\\n ssh_alias=ssh_alias,\\n ssh_user=ssh_user,\\n # The port number of the rsync daemon.\\n remote_port=RSYNCD_PORT,\\n )\\n if port_number:\\n # The port number of the SSH server.\\n tunnel_opts['port'] = int(port_number)\\n dest_opts['ssh_tunnel'] = SecureTunnel(**tunnel_opts)\\n elif option in ('-i', '--ionice'):\\n value = value.lower().strip()\\n validate_ionice_class(value)\\n program_opts['ionice'] = value\\n elif option in ('-u', '--no-sudo'):\\n program_opts['sudo_enabled'] = False\\n elif option in ('-n', '--dry-run'):\\n logger.info(\\\"Performing a dry run (because of %s option) ..\\\", option)\\n program_opts['dry_run'] = True\\n elif option in ('-f', '--force'):\\n program_opts['force'] = True\\n elif option in ('-x', '--exclude'):\\n program_opts.setdefault('exclude_list', [])\\n program_opts['exclude_list'].append(value)\\n elif option == '--multi-fs':\\n program_opts['multi_fs'] = True\\n elif option == '--disable-notifications':\\n program_opts['notifications_enabled'] = False\\n elif option in ('-v', '--verbose'):\\n coloredlogs.increase_verbosity()\\n elif option in ('-q', '--quiet'):\\n coloredlogs.decrease_verbosity()\\n elif option in ('-h', '--help'):\\n usage(__doc__)\\n return\\n else:\\n raise Exception(\\\"Unhandled option! (programming error)\\\")\\n if len(arguments) > 2:\\n msg = \\\"Expected one or two positional arguments! (got %i)\\\"\\n raise Exception(msg % len(arguments))\\n if len(arguments) == 2:\\n # Get the source from the first of two arguments.\\n program_opts['source'] = arguments.pop(0)\\n if arguments:\\n # Get the destination from the second (or only) argument.\\n dest_opts['expression'] = arguments[0]\\n program_opts['destination'] = Destination(**dest_opts)\\n elif not os.environ.get('RSYNC_MODULE_PATH'):\\n # Show a usage message when no destination is given.\\n usage(__doc__)\\n return\\n except Exception as e:\\n warning(\\\"Error: %s\\\", e)\\n sys.exit(1)\\n try:\\n # Inject the source context into the program options.\\n program_opts['source_context'] = create_context(**context_opts)\\n # Initialize the program with the command line\\n # options and execute the requested action(s).\\n RsyncSystemBackup(**program_opts).execute()\\n except Exception as e:\\n if isinstance(e, RsyncSystemBackupError):\\n # Special handling when the backup disk isn't available.\\n if isinstance(e, MissingBackupDiskError):\\n # Check if we're connected to a terminal to decide whether the\\n # error should be propagated or silenced, the idea being that\\n # rsync-system-backup should keep quiet when it's being run\\n # from cron and the backup disk isn't available.\\n if not connected_to_terminal():\\n logger.info(\\\"Skipping backup: %s\\\", e)\\n sys.exit(0)\\n # Known problems shouldn't produce\\n # an intimidating traceback to users.\\n logger.error(\\\"Aborting due to error: %s\\\", e)\\n else:\\n # Unhandled exceptions do get a traceback,\\n # because it may help fix programming errors.\\n logger.exception(\\\"Aborting due to unhandled exception!\\\")\\n sys.exit(1)\",\n \"def main():\\n print(sys.argv)\\n parser = create_argument_parser(description=\\\"generate a tower of blocks\\\",\\n default_restitution_coefficient=0)\\n parser.add_argument(\\\"--num-blocks\\\",\\n type=int,\\n default=10,\\n help=\\\"maximum number of blocks in the compactor\\\")\\n args = parser.parse_args()\\n\\n if args.out_path is None:\\n directory = pathlib.Path(__file__).resolve().parents[1] / \\\"fixtures\\\"\\n args.out_path = directory / \\\"compactor.json\\\"\\n args.out_path.parent.mkdir(parents=True, exist_ok=True)\\n\\n print_args(args)\\n\\n fixture = generate_fixture(args)\\n\\n save_fixture(fixture, args.out_path)\",\n \"def main():\\n\\n\\tparser = generate_parser()\\n\\targuments, unknown = parser.parse_known_args()\\n\\n\\tif type(arguments.output) is list:\\n\\t\\t arguments.output = arguments.output[0]\\n\\n\\tif '-o' in arguments.other:\\n\\t\\t# -o output can be in other due to ordering of command\\n\\t\\t# move output into arguments.output\\n\\n\\t\\toutput_idx = arguments.other.index('-o') + 1\\n\\t\\targuments.output = arguments.other[output_idx]\\n\\n\\t\\targuments.other.pop(output_idx)\\n\\t\\targuments.other.remove('-o')\\n\\n\\n\\t# find C compiler\\n\\tcompilers = determine_compilers(arguments)\\n\\n\\t# find ExaMPI library\\n\\tpaths = find_library(arguments)\\n\\n\\t# user only executed with flags\\n\\tif unknown and not arguments.other:\\n\\t\\t# flags of compiler\\n\\t\\terror_code = assemble(compilers, paths, None, unknown)\\n\\n\\t\\tsys.exit(error_code)\\n\\n\\t# require a command from user\\n\\tif not arguments.other and not unknown:\\n\\t\\t# mpicc is being executed without commands\\n\\t\\tparser.print_usage()\\n\\n\\t\\tsys.exit()\\n\\n\\t# execute command\\n\\tif any((flag in unknown or flag in arguments.other) for flag in ['-E', '-S', '-c']):\\n\\t\\t# user is requesting preprocessing, compiling or assembling only\\n\\t\\terror_code = assemble(compilers, paths, arguments.output, unknown + arguments.other)\\n\\n\\t\\tsys.exit(error_code)\\n\\n\\telse:\\n\\t\\terror_code = link(compilers, paths, arguments.output, unknown + arguments.other)\\n\\n\\t\\tsys.exit(error_code)\",\n \"def main(argv): \\n if len(argv) < 2:\\n print 'generate.py -k <k-value> -o <outputfile>'\\n exit(1)\\n argv = argv[1:]\\n k = 0\\n outputfile = ''\\n try:\\n opts, args = getopt.getopt(argv,\\\"hk:o:\\\",[\\\"k-value=\\\",\\\"ofile=\\\"])\\n except getopt.GetoptError:\\n print 'generate.py -k <k-value> -o <outputfile>'\\n sys.exit(2)\\n for opt, arg in opts:\\n if opt == '-h':\\n print 'generate.py -k <k-value> -o <outputfile>'\\n sys.exit()\\n elif opt in (\\\"-k\\\", \\\"--kval\\\"):\\n k = int(arg)\\n elif opt in (\\\"-o\\\", \\\"--ofile\\\"):\\n outputfile = arg\\n generate(k, outputfile)\",\n \"def main():\\n load()\\n\\n print(generate())\",\n \"def run():\\n print(\\\"clewsy CLEWs Model Building Script.\\\")\\n print(\\\"When using clewsy please reference:\\\")\\n print(\\\"T. Niet and A. Shivakumar (2020): clewsy: Script for building CLEWs models.\\\")\\n main(sys.argv[1:])\",\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 makecmd(self, options):\",\n \"def main():\\n subcommands = {\\n \\\"train\\\": train.train,\\n \\\"tune\\\": train_tune.train,\\n \\\"predict\\\": predict.cli_predict,\\n \\\"evaluate\\\": evaluate.cli_evaluate,\\n \\\"version\\\": version,\\n }\\n\\n try:\\n import xarray_behave.gui.app\\n\\n subcommands[\\\"gui\\\"] = xarray_behave.gui.app.main_das\\n except (ImportError, ModuleNotFoundError):\\n logging.exception(\\\"No GUI avalaible.\\\")\\n # fall back to function that displays helpful instructions\\n subcommands[\\\"gui\\\"] = no_xb_gui\\n\\n logging.basicConfig(level=logging.INFO, force=True)\\n defopt.run(subcommands, show_defaults=False)\",\n \"def main(args: List[Union[str, bytes]] = sys.argv,):\\n\\tprogram_name, *args = args\\n\\targs = decode_raw_args(args, str)\\n\\n\\tgen = Generator(*args)\\n\\tgen.generate_data()\\n\\tgen.print_return_list()\",\n \"def makeprg(setup, loop):\\n return loop\",\n \"def main():\\n parser = optparse.OptionParser()\\n parser.add_option(\\\"-c\\\", \\\"--clear\\\", action=\\\"store_true\\\", dest=\\\"clear\\\",\\n help=\\\"clear out all generated reports\\\")\\n parser.add_option(\\\"-n\\\", \\\"--num\\\", action=\\\"store\\\", type=\\\"int\\\", dest=\\\"num\\\",\\n help=\\\"number of data points to generate\\\")\\n parser.add_option(\\\"-m\\\", \\\"--min\\\", action=\\\"store\\\", type=\\\"float\\\", dest=\\\"min\\\",\\n help=\\\"minimum of polynomial range\\\")\\n parser.add_option(\\\"-f\\\", \\\"--fun\\\", action=\\\"store\\\", type=\\\"string\\\", dest=\\\"fun\\\",\\n help=(\\\"Python expression (function of x)\\\"))\\n (options, _) = parser.parse_args()\\n if options.clear:\\n clear_data()\\n else:\\n report_id = generate_id()\\n if report_id is None:\\n print \\\"Too many tests exist already\\\"\\n else:\\n gen = DataGen(options.min, options.fun, options.num)\\n gen.generate_data()\\n gen.write_ref(report_id)\\n gen.write_rand(report_id)\",\n \"def main(argv):\\n parser = OptionParser()\\n parser.add_option(\\n \\\"--output-dir\\\",\\n help=\\\"Output directory for generated files. Defaults to chromium root \\\"\\n \\\"directory.\\\")\\n parser.add_option(\\n \\\"-v\\\", \\\"--verbose\\\", action=\\\"store_true\\\", help=\\\"Verbose logging output.\\\")\\n parser.add_option(\\n \\\"-c\\\", \\\"--check\\\", action=\\\"store_true\\\",\\n help=\\\"Check if output files match generated files in chromium root \\\"\\n \\\"directory. Use this in PRESUBMIT scripts with --output-dir.\\\")\\n\\n (options, _) = parser.parse_args(args=argv)\\n\\n # This script lives under src/gpu/command_buffer.\\n script_dir = os.path.dirname(os.path.abspath(__file__))\\n assert script_dir.endswith(os.path.normpath(\\\"src/gpu/command_buffer\\\"))\\n # os.path.join doesn't do the right thing with relative paths.\\n chromium_root_dir = os.path.abspath(script_dir + \\\"/../..\\\")\\n\\n # Support generating files under gen/ and for PRESUBMIT.\\n if options.output_dir:\\n output_dir = options.output_dir\\n else:\\n output_dir = chromium_root_dir\\n os.chdir(output_dir)\\n\\n # This script lives under gpu/command_buffer, cd to base directory.\\n build_cmd_buffer_lib.InitializePrefix(\\\"WebGPU\\\")\\n gen = build_cmd_buffer_lib.GLGenerator(\\n options.verbose, \\\"2018\\\", _FUNCTION_INFO, _NAMED_TYPE_INFO,\\n chromium_root_dir)\\n gen.ParseGLH(\\\"gpu/command_buffer/webgpu_cmd_buffer_functions.txt\\\")\\n\\n gen.WriteCommandIds(\\\"gpu/command_buffer/common/webgpu_cmd_ids_autogen.h\\\")\\n gen.WriteFormat(\\\"gpu/command_buffer/common/webgpu_cmd_format_autogen.h\\\")\\n gen.WriteFormatTest(\\n \\\"gpu/command_buffer/common/webgpu_cmd_format_test_autogen.h\\\")\\n gen.WriteGLES2InterfaceHeader(\\n \\\"gpu/command_buffer/client/webgpu_interface_autogen.h\\\")\\n gen.WriteGLES2ImplementationHeader(\\n \\\"gpu/command_buffer/client/webgpu_implementation_autogen.h\\\")\\n gen.WriteGLES2InterfaceStub(\\n \\\"gpu/command_buffer/client/webgpu_interface_stub_autogen.h\\\")\\n gen.WriteGLES2InterfaceStubImpl(\\n \\\"gpu/command_buffer/client/webgpu_interface_stub_impl_autogen.h\\\")\\n gen.WriteGLES2Implementation(\\n \\\"gpu/command_buffer/client/webgpu_implementation_impl_autogen.h\\\")\\n gen.WriteGLES2ImplementationUnitTests(\\n \\\"gpu/command_buffer/client/webgpu_implementation_unittest_autogen.h\\\")\\n gen.WriteCmdHelperHeader(\\n \\\"gpu/command_buffer/client/webgpu_cmd_helper_autogen.h\\\")\\n # Note: No gen.WriteServiceImplementation\\n # Note: No gen.WriteServiceUnitTests\\n gen.WriteServiceUtilsHeader(\\n \\\"gpu/command_buffer/service/webgpu_cmd_validation_autogen.h\\\")\\n gen.WriteServiceUtilsImplementation(\\n \\\"gpu/command_buffer/service/\\\"\\n \\\"webgpu_cmd_validation_implementation_autogen.h\\\")\\n\\n build_cmd_buffer_lib.Format(gen.generated_cpp_filenames, output_dir,\\n chromium_root_dir)\\n\\n if gen.errors > 0:\\n print(\\\"build_webgpu_cmd_buffer.py: Failed with %d errors\\\" % gen.errors)\\n return 1\\n\\n check_failed_filenames = []\\n if options.check:\\n for filename in gen.generated_cpp_filenames:\\n if not filecmp.cmp(os.path.join(output_dir, filename),\\n os.path.join(chromium_root_dir, filename)):\\n check_failed_filenames.append(filename)\\n\\n if len(check_failed_filenames) > 0:\\n print('Please run gpu/command_buffer/build_webgpu_cmd_buffer.py')\\n print('Failed check on autogenerated command buffer files:')\\n for filename in check_failed_filenames:\\n print(filename)\\n return 1\\n\\n return 0\",\n \"def main():\\n parser = argparse.ArgumentParser(\\\"Generate custom wordlist\\\")\\n\\n parser.add_argument(\\\"iterations\\\", type=int, help=\\\"Maximum words to combine.\\\")\\n parser.add_argument(\\\"--words\\\", default=\\\"words.txt\\\", type=str, help=\\\"Path to the words file. One word per line.\\\")\\n parser.add_argument(\\\"--output\\\",default=\\\"output.txt\\\", type=str, help=\\\"Path to the output file.\\\")\\n\\n args = parser.parse_args()\\n\\n wordlist = open(args.words, 'r')\\n wordlistlines = []\\n for line in wordlist.readlines():\\n wordlistlines.append(line)\\n\\n global iterations\\n iterations = args.iterations\\n\\n output = open(args.output, 'w')\\n\\n combos(wordlistlines, iterations, output)\",\n \"def __cmd_builder(self):\\n self.cmd = 'python -m lizard \\\"%s\\\" ' % self.get_proj_path()\\n args = \\\"\\\"\\n if self.get_cyclo_args():\\n args = self.get_cyclo_args()\\n exclude = \\\",\\\".join(str(x) for x in self.get_cyclo_exclude() if x is not None)\\n if exclude:\\n exclude = ','.join(' -x \\\"{0}\\\"'.format(w) for w in exclude.rstrip().split(','))\\n self.cmd = self.cmd + args + \\\" \\\" + exclude + \\\" --csv\\\"\\n print(self.cmd) # pragma: no mutate\",\n \"def run(compiler: str, language: str, prelude: str, coda: str, snippet: str):\\n with tempfile.TemporaryDirectory() as tmp:\\n\\n src = Path(tmp) / f\\\"main.{language}\\\"\\n src.write_text(f\\\"{prelude}{snippet}{coda}\\\")\\n\\n dst = Path(tmp) / \\\"a.out\\\"\\n\\n std = \\\"-std=c++20\\\" if language == \\\"c++\\\" else \\\"-std=c11\\\"\\n subprocess.check_call(\\n [compiler, std, \\\"-Wall\\\", \\\"-Wextra\\\", \\\"-x\\\", language, \\\"-o\\\", dst, src]\\n )\\n\\n subprocess.check_call([dst])\",\n \"def run(self, line):\\r\\n if os.name == 'nt':\\r\\n if not ctypes.windll.shell32.IsUserAnAdmin() != 0:\\r\\n self.app.typepath.adminpriv = False\\r\\n elif not os.getuid() == 0:\\r\\n self.app.typepath.adminpriv = False\\r\\n\\r\\n nargv = []\\r\\n curr = []\\r\\n argfound = False\\r\\n\\r\\n if \\\"--version\\\" in line or \\\"-V\\\" in line:\\r\\n sys.stdout.write(\\\"\\\"\\\"%(progname)s %(version)s\\\\n\\\"\\\"\\\" % \\\\\\r\\n {'progname': versioning.__longname__, 'version': \\\\\\r\\n versioning.__version__})\\r\\n sys.stdout.flush()\\r\\n sys.exit(self.retcode)\\r\\n\\r\\n else:\\r\\n for argument in enumerate(line):\\r\\n if not argfound and not argument[1].startswith('-'):\\r\\n nargv = line[argument[0]:]\\r\\n break\\r\\n else:\\r\\n argfound = False\\r\\n\\r\\n if argument[1] == \\\"-c\\\":\\r\\n argfound = True\\r\\n\\r\\n curr.append(argument[1])\\r\\n\\r\\n (self.opts, _) = self.parser.parse_args(curr)\\r\\n\\r\\n try:\\r\\n Encryption.encode_credentials('test')\\r\\n self.app.set_encode_funct(Encryption.encode_credentials)\\r\\n self.app.set_decode_funct(Encryption.decode_credentials)\\r\\n self.encoding = True\\r\\n except redfish.hpilo.risblobstore2.ChifDllMissingError:\\r\\n self.encoding = False\\r\\n\\r\\n if self.opts.config is not None and len(self.opts.config) > 0:\\r\\n if not os.path.isfile(self.opts.config):\\r\\n self.retcode = ReturnCodes.CONFIGURATION_FILE_ERROR\\r\\n sys.exit(self.retcode)\\r\\n\\r\\n self.app.config_file = self.opts.config\\r\\n\\r\\n self.app.config_from_file(self.app.config_file)\\r\\n if self.opts.logdir and self.opts.debug:\\r\\n logdir = self.opts.logdir\\r\\n else:\\r\\n logdir = self.app.config.get_logdir()\\r\\n\\r\\n if logdir and self.opts.debug:\\r\\n try:\\r\\n os.makedirs(logdir)\\r\\n except OSError as ex:\\r\\n if ex.errno == errno.EEXIST:\\r\\n pass\\r\\n else:\\r\\n raise\\r\\n\\r\\n if self.opts.debug:\\r\\n logfile = os.path.join(logdir, versioning.__shortname__+'.log')\\r\\n\\r\\n # Create a file logger since we got a logdir\\r\\n lfile = logging.FileHandler(filename=logfile)\\r\\n formatter = logging.Formatter(\\\"%(asctime)s %(levelname)s\\\\t: \\\" \\\\\\r\\n \\\"%(message)s\\\")\\r\\n\\r\\n lfile.setFormatter(formatter)\\r\\n lfile.setLevel(logging.DEBUG)\\r\\n LOGGER.addHandler(lfile)\\r\\n self.app.LOGGER = LOGGER\\r\\n\\r\\n cachedir = None\\r\\n if self.opts.nocache:\\r\\n self.app.config.set_cache(False)\\r\\n else:\\r\\n self.app.config.set_cachedir(os.path.join(self.opts.config_dir, \\\\\\r\\n 'cache'))\\r\\n cachedir = self.app.config.get_cachedir()\\r\\n\\r\\n if cachedir:\\r\\n try:\\r\\n os.makedirs(cachedir)\\r\\n except OSError as ex:\\r\\n if ex.errno == errno.EEXIST:\\r\\n pass\\r\\n else:\\r\\n raise\\r\\n\\r\\n if (\\\"login\\\" in line or any(x.startswith(\\\"--url\\\") for x in line) or not line)\\\\\\r\\n and not (any(x.startswith((\\\"-h\\\", \\\"--h\\\")) for x in nargv) or \\\"help\\\" in line):\\r\\n self.app.logout()\\r\\n else:\\r\\n self.app.restore()\\r\\n self.opts.is_redfish = self.app.updatedefinesflag(redfishflag=\\\\\\r\\n self.opts.is_redfish)\\r\\n\\r\\n if nargv:\\r\\n try:\\r\\n self.retcode = self._run_command(self.opts, nargv)\\r\\n if self.app.config.get_cache():\\r\\n if (\\\"logout\\\" not in line) and (\\\"--logout\\\" not in line):\\r\\n self.app.save()\\r\\n else:\\r\\n self.app.logout()\\r\\n except Exception as excp:\\r\\n self.handle_exceptions(excp)\\r\\n\\r\\n return self.retcode\\r\\n else:\\r\\n self.cmdloop(self.opts)\\r\\n\\r\\n if self.app.config.get_cache():\\r\\n self.app.save()\\r\\n else:\\r\\n self.app.logout()\",\n \"def main():\\n opt = parse_opts()\\n run(opt)\",\n \"def main():\\n opt = parse_opts()\\n run(opt)\",\n \"def run_genie(platform, cc=None, cxx=None):\\n\\n cmd = PLATFORMS_GENIE[platform]\\n\\n subprocess.check_call(cmd)\",\n \"def write_binana_sh(self, autodock_path, autodock_path_2, command_chain_A, command_chain_B):\\n opened_sh = open(\\\"pdbqt_generator.sh\\\",\\\"w\\\")\\n opened_sh.write(autodock_path)\\n opened_sh.write(autodock_path_2)\\n opened_sh.write(command_chain_A)\\n opened_sh.write(command_chain_B)\\n opened_sh.close()\",\n \"def main():\\n parsed_args = parse_args()\\n dfg = DummyFileGenerator(parsed_args[0], **parsed_args[1])\\n dfg.write_output_file(**parsed_args[2])\",\n \"def main():\\n parser = optparse.OptionParser()\\n parser.add_option('-n', dest='length', default=LENGTH, type=int)\\n opts, _ = parser.parse_args()\\n\\n print generate(opts.length)\",\n \"def gen(\\n file: str,\\n infer: bool = typer.Option(\\n True, help=\\\"Whether to run type inference on code examples.\\\"\\n ),\\n exec: bool = typer.Option(\\n False, help=\\\"Whether to attempt to execute doctring code.\\\"\\n ),\\n experimental: bool = typer.Option(False, help=\\\"Use experimental Ts parsing\\\"),\\n debug: bool = False,\\n dummy_progress: bool = typer.Option(False, help=\\\"Disable rich progress bar\\\"),\\n):\\n _intro()\\n from papyri.gen import gen_main\\n\\n gen_main(\\n infer=infer,\\n exec_=exec,\\n target_file=file,\\n experimental=experimental,\\n debug=debug,\\n dummy_progress=dummy_progress,\\n )\",\n \"def main():\\n parser = create_argument_parser(\\\"generate a block falling onto a saw\\\")\\n args = parser.parse_args()\\n\\n if args.out_path is None:\\n directory = (pathlib.Path(__file__).resolve().parents[1] / \\\"fixtures\\\" /\\n \\\"saw\\\")\\n args.out_path = (directory /\\n \\\"saw-cor={:g}.json\\\".format(args.restitution_coeff))\\n args.out_path.parent.mkdir(parents=True, exist_ok=True)\\n\\n print_args(args)\\n\\n fixture = generate_fixture(args)\\n\\n save_fixture(fixture, args.out_path)\",\n \"def main():\\n sys.argv.pop(0)\\n (cmd, var, args) = process_options(sys.argv[:])\\n execute(cmd, var, args)\",\n \"def generate():\",\n \"def main():\\n # Initialize logging to the terminal and system log.\\n coloredlogs.install(syslog=True)\\n # Parse the command line arguments.\\n context_opts = dict()\\n program_opts = dict()\\n dest_opts = dict()\\n try:\\n options, arguments = getopt.gnu_getopt(sys.argv[1:], 'bsrm:c:t:i:unx:fvqhVQp', [\\n 'backup', 'snapshot', 'rotate', 'mount=', 'crypto=', 'tunnel=',\\n 'ionice=', 'no-sudo', 'dry-run', 'exclude=', 'force',\\n 'disable-notifications', 'verbose', 'quiet', 'help', 'multi-fs',\\n 'rsync-verbose', 'rsync-quiet', 'rsync-progress'\\n ])\\n for option, value in options:\\n if option in ('-b', '--backup'):\\n enable_explicit_action(program_opts, 'backup_enabled')\\n elif option in ('-s', '--snapshot'):\\n enable_explicit_action(program_opts, 'snapshot_enabled')\\n elif option in ('-r', '--rotate'):\\n enable_explicit_action(program_opts, 'rotate_enabled')\\n elif option in ('-m', '--mount'):\\n program_opts['mount_point'] = value\\n elif option in ('-c', '--crypto'):\\n program_opts['crypto_device'] = value\\n elif option in ('-t', '--tunnel'):\\n ssh_user, _, value = value.rpartition('@')\\n ssh_alias, _, port_number = value.partition(':')\\n tunnel_opts = dict(\\n ssh_alias=ssh_alias,\\n ssh_user=ssh_user,\\n # The port number of the rsync daemon.\\n remote_port=RSYNCD_PORT,\\n )\\n if port_number:\\n # The port number of the SSH server.\\n tunnel_opts['port'] = int(port_number)\\n dest_opts['ssh_tunnel'] = SecureTunnel(**tunnel_opts)\\n elif option in ('-i', '--ionice'):\\n value = value.lower().strip()\\n validate_ionice_class(value)\\n program_opts['ionice'] = value\\n elif option in ('-u', '--no-sudo'):\\n program_opts['sudo_enabled'] = False\\n elif option in ('-n', '--dry-run'):\\n logger.info(\\\"Performing a dry run (because of %s option) ..\\\", option)\\n program_opts['dry_run'] = True\\n elif option in ('-f', '--force'):\\n program_opts['force'] = True\\n elif option in ('-x', '--exclude'):\\n program_opts.setdefault('exclude_list', [])\\n program_opts['exclude_list'].append(value)\\n elif option == '--multi-fs':\\n program_opts['multi_fs'] = True\\n elif option == '--disable-notifications':\\n program_opts['notifications_enabled'] = False\\n elif option in ('-V', '--rsync-verbose'):\\n if 'rsync_verbose_count' not in program_opts:\\n program_opts['rsync_verbose_count'] = 1\\n else:\\n program_opts['rsync_verbose_count'] = program_opts['rsync_verbose_count'] + 1\\n elif option in ('-Q', '--rsync-quiet'):\\n if 'rsync_quiet_count' not in program_opts:\\n program_opts['rsync_quiet_count'] = 1\\n else:\\n program_opts['rsync_quiet_count'] = program_opts['rsync_quiet_count'] + 1\\n elif option in ('-v', '--verbose'):\\n coloredlogs.increase_verbosity()\\n elif option in ('-q', '--quiet'):\\n coloredlogs.decrease_verbosity()\\n elif option in ('-p', '--rsync-progress'):\\n program_opts['rsync_show_progress'] = True\\n elif option in ('-h', '--help'):\\n usage(__doc__)\\n return\\n else:\\n raise Exception(\\\"Unhandled option! (programming error)\\\")\\n if len(arguments) > 2:\\n msg = \\\"Expected one or two positional arguments! (got %i)\\\"\\n raise Exception(msg % len(arguments))\\n if len(arguments) == 2:\\n # Get the source from the first of two arguments.\\n program_opts['source'] = arguments.pop(0)\\n if arguments:\\n # Get the destination from the second (or only) argument.\\n dest_opts['expression'] = arguments[0]\\n program_opts['destination'] = Destination(**dest_opts)\\n elif not os.environ.get('RSYNC_MODULE_PATH'):\\n # Show a usage message when no destination is given.\\n usage(__doc__)\\n return\\n except Exception as e:\\n warning(\\\"Error: %s\\\", e)\\n sys.exit(1)\\n try:\\n # Inject the source context into the program options.\\n program_opts['source_context'] = create_context(**context_opts)\\n # Initialize the program with the command line\\n # options and execute the requested action(s).\\n RsyncSystemBackup(**program_opts).execute()\\n except Exception as e:\\n if isinstance(e, RsyncSystemBackupError):\\n # Special handling when the backup disk isn't available.\\n if isinstance(e, MissingBackupDiskError):\\n # Check if we're connected to a terminal to decide whether the\\n # error should be propagated or silenced, the idea being that\\n # rsync-system-backup should keep quiet when it's being run\\n # from cron and the backup disk isn't available.\\n if not connected_to_terminal():\\n logger.info(\\\"Skipping backup: %s\\\", e)\\n sys.exit(0)\\n # Known problems shouldn't produce\\n # an intimidating traceback to users.\\n logger.error(\\\"Aborting due to error: %s\\\", e)\\n else:\\n # Unhandled exceptions do get a traceback,\\n # because it may help fix programming errors.\\n logger.exception(\\\"Aborting due to unhandled exception!\\\")\\n sys.exit(1)\",\n \"def main_execute(vars):\\n\\n # Unpack necessary variables\\n # output_directory is the root output folder for the run\\n output_directory = vars[\\\"output_directory\\\"]\\n\\n # This will run operations which will:\\n # 1) generate new ligands\\n # 2) optionally filter ligands\\n # 3) optionally convert from 1D smiles to 3D (mol2/PDB)\\n\\n sys.stdout.flush()\\n\\n\\n smile_file_new_gen, new_gen_ligands_list = operations.populate_generation(vars)\\n sys.stdout.flush()\\n\\n if new_gen_ligands_list is None:\\n raise ValueError(\\\"Population failed to make enough mutants... \\\\\\n Errors could include not enough diversity, too few seeds to the generation, \\\\\\n number_of_mutants is too high, \\\\\\n or all of the seed lack functional groups for performing reactions.\\\")\\n\\n sys.stdout.flush()\",\n \"async def generate(root: Root, shell: str) -> None:\\n root.console.print(f\\\"Push the following line into your {CFG_FILE[shell]}\\\")\\n root.console.print(\\n ACTIVATION_TEMPLATE.format(cmd=SOURCE_CMD[shell], exe=sys.argv[0])\\n )\",\n \"def h(options, buildout, version, opts):\\n cwd = os.getcwd()\\n md = options['compile-directory']\\n c = os.path.join(md, 'configure.py')\\n os.chdir(md)\\n p = buildout['p'][version]\\n opts = ' '.join(opts.split())\\n cmd = [p, c, opts]\\n print \\\"Running: %s\\\" % ' '.join(cmd)\\n ret = os.system(' '.join(cmd))\\n if ret > 0: raise Exception,('Cannot confiure')\\n os.chdir(cwd)\",\n \"def execute_tool(description, *args):\\n command_line = list(args) + files_and_directories\\n click.echo(f\\\"{description}: {' '.join(command_line)}\\\")\\n rv = call(command_line)\\n if rv != 0:\\n exit(rv)\",\n \"def main():\\n\\n\\toptions = parse_arguments()\\n\\tcodon_counts = parse.codon_freq_table(options.codon)\\n\\tgenetic_code = parse.genetic_code(options.codon_table, options.gene_code)\\n\\n\\tdc = degenerate_codons(genetic_code=genetic_code,codon_counts=codon_counts)\\n\\tdc.compute_results()\\n\\tdc.output(options.output_format)\",\n \"def main():\\n produce()\",\n \"def script_generator(self):\\n analyze_tool = \\\"/home/haihuam/Projects/RepPoints/mmdetection/tools/analyze_logs.py\\\"\\n ex_options = self.global_setting.get('analyze_options', str())\\n py = self.global_setting.get('python', sys.executable)\\n if os.access(py, os.X_OK):\\n content = \\\"set -e \\\\n\\\" \\n content += \\\"cd %s \\\\n\\\"%(self.run_dir)\\n content += \\\"%s %s plot_curve *.log.json \\\"%(py, analyze_tool)\\n content += \\\"--keys loss loss_cls loss_pts_init \\\"\\n content += \\\"loss_pts_refine \\\"\\n content += \\\"--out losses.pdf %s &> analyze.log \\\\n\\\"%(ex_options)\\n\\n content += \\\"touch analyze.done \\\\n\\\"\\n self.script_content = content\\n else:\\n print(\\\"Error: %s is not executable.\\\"%py)\\n sys.exit(0)\",\n \"def main():\\n challenge = Challenge()\\n # Get the number of saved files on last execution\\n last_saved = challenge.get_last_execution()\\n # Get the total of products to save\\n total_objects = len(challenge.get_products(\\\"product_groups.json\\\"))\\n\\n # While there are products to be saved\\n while last_saved < total_objects:\\n create_products()\\n # Updates last_saved number\\n last_saved = challenge.get_last_execution()\\n\\n logging.info(\\\"[INFO] Execution done with no errors!\\\")\\n # Sends to runner a signal different from the crash signal\\n # Indicates terminated execution\\n os._exit(1)\",\n \"def generate_base(params, out):\\n\\n os.makedirs(out)\\n experiment_path = os.path.join(out, BASE)\\n shutil.copy(\\\"evaluation/ablation/run_all.sh\\\", out)\\n\\n print(f\\\"Generating {out}/{BASE}\\\")\\n subprocess.run(\\n [\\n \\\"racket\\\",\\n \\\"src/example-gen.rkt\\\",\\n \\\"-b\\\", \\\"mat-mul\\\",\\n \\\"-p\\\", params,\\n \\\"-o\\\", experiment_path\\n ],\\n check=True,\\n stderr=subprocess.PIPE)\\n\\n # Add all required file for the harness.\\n shutil.copy(\\\"evaluation/ablation/Makefile\\\", experiment_path)\\n shutil.copy(\\\"evaluation/ablation/harness.c\\\", experiment_path)\\n shutil.copy(\\\"evaluation/src/utils.h\\\", experiment_path)\",\n \"def generate_custom_sequence(program, pass_space=DEFAULT_GENE_POOL,\\n debug=False):\\n global print_out\\n print_out = debug\\n return simulate_generations(pass_space, program)\",\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 generate(cfg, filename=None, wait=False):\\n code = yield generate_submission(cfg, filename)\\n print(code)\",\n \"def build_step(self):\\n run_cmd('./compile.sh', log_all=True, simple=True, log_ok=True)\",\n \"def cli():\\r\\n pass\",\n \"def generate(self):\\n logger=self.logger\\n outputter=self.OutputType()\\n outputter.make_runner(parser=self.parser,dry_run=self.dry_run,\\n setarith=self.setarith)\\n con=fileless_context(\\n scopes=[self.parse_result],verbose=self.verbose,logger=logger,\\n run_mode=self.run_mode)\\n self.make_more(self.parse_result,con)\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\\n pass\",\n \"def setup():\\n\\n generators = {\\\"man\\\": gen_manpage, \\\"cpl\\\": gen_completions}\\n\\n prsr = argparse.ArgumentParser(\\n description=\\\"xNVMe CLI Bash-completions and man page generator\\\",\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\\n )\\n prsr.add_argument(\\n \\\"generator\\\",\\n help=\\\"Generator to run\\\",\\n default=sorted(generators.keys())[0],\\n choices=sorted(generators.keys()),\\n )\\n prsr.add_argument(\\n \\\"--tools\\\",\\n nargs=\\\"*\\\",\\n help=\\\"Name of tools to generate bash-completions for\\\",\\n )\\n prsr.add_argument(\\n \\\"--output\\\",\\n help=\\\"Path to directory in which to emit completion scripts\\\",\\n default=os.sep.join([\\\".\\\"]),\\n )\\n prsr.add_argument(\\n \\\"--log-level\\\",\\n help=\\\"log-devel\\\",\\n default=\\\"INFO\\\",\\n choices=[\\\"DEBUG\\\", \\\"INFO\\\", \\\"WARNING\\\", \\\"ERROR\\\", \\\"CRITICAL\\\"],\\n )\\n\\n args = prsr.parse_args()\\n args.output = expand_path(args.output)\\n args.gen = generators[args.generator]\\n\\n if not args.tools:\\n args.tools = find_binaries()\\n\\n logging.basicConfig(\\n format=\\\"%(asctime)s %(message)s\\\",\\n level=getattr(logging, args.log_level.upper(), None),\\n )\\n\\n return args\",\n \"def main():\\n insert_gateway_values(\\\"hermes/bin/gateways.txt\\\")\\n return\",\n \"def main():\\r\\n db = connect_database()\\r\\n with db:\\r\\n if sys.argv[1] == \\\"-s\\\":\\r\\n select_all(db, sys.argv[2])\\r\\n elif sys.argv[1] == \\\"-i\\\":\\r\\n cus_data = []\\r\\n for i in range(2, len(sys.argv)):\\r\\n cus_data.append(sys.argv[i])\\r\\n insert_customer(db, cus_data)\\r\\n elif sys.argv[1] == \\\"-c\\\":\\r\\n create_tables()\\r\\n elif sys.argv[1] == \\\"-pw\\\":\\r\\n pop_waiting(db, sys.argv[2])\\r\\n elif sys.argv[1] == \\\"-ph\\\":\\r\\n pop_help(db, sys.argv[2])\\r\\n elif sys.argv[1] == \\\"-r\\\":\\r\\n refresh_tables(db)\\r\\n elif sys.argv[1] == \\\"-e\\\":\\r\\n export_helped_table(db)\\r\\n else:\\r\\n print errorArgument\\r\\n db.close()\",\n \"def cmd_generate(argv):\\n description = inspect.getdoc(cmd_generate)\\n parser = ArgumentParser(description=description)\\n parser.add_argument(\\\"-o\\\",\\\"--output\\\", action=\\\"store\\\", dest=\\\"output\\\",\\n default=\\\"dhall_key\\\", help=\\\"outpuf filename\\\")\\n args = parser.parse_args(argv)\\n\\n import dhall.util\\n dhall.util.generate_keys(key=args.output)\",\n \"def main(self):\\n\\n try:\\n if os.getuid():\\n print(\\\"**** Error: This script (%s) must be run as root!\\\" % sys.argv[0])\\n raise RuntimeError\\n\\n exit_status = self.EXIT_STATUS_SUCCESS\\n self._parse_options()\\n self._init_logger()\\n logger = self._logger\\n\\n # TODO: Switch to spts' shared onject API!\\n if self._pexpect_available:\\n self.tool_prompt='spt> \\\\? .*\\\\n'\\n #self.tool_prompt='spt> ? .*\\\\r\\\\n'\\n self.tool_start='enable=pipes'\\n self.tool_prompt_index = TOOL_PROMPT_INDEX\\n self.tool_unique_index = TOOL_UNIQUE_INDEX\\n self.tool_status_index = TOOL_STATUS_INDEX\\n self.start_tool(tool=self.tool, start_cmd=self.tool_start)\\n\\n self.get_devices()\\n self.get_drive_information()\\n self.get_enclosure_information()\\n self.get_drive_enclosure_information()\\n\\n if self._number_drives:\\n self.show_device_information()\\n else:\\n self._logger.warning(\\\"No SCSI disk drives found or none match your criteria!\\\")\\n\\n except KeyboardInterrupt:\\n pass\\n\\n except IOError as e:\\n if e.errno == errno.EPIPE:\\n pass\\n\\n except RuntimeError:\\n exit_status = self.EXIT_STATUS_RUNTIME_ERROR\\n if self._debug:\\n logger.debug(\\\"Exiting with status code {0}, RuntimeError\\\".format(exit_status))\\n\\n except TimeoutExpiredError:\\n exit_status = self.EXIT_STATUS_TIMEOUT_EXPIRED\\n if self._debug:\\n logger.debug(\\\"Exiting with status code {0}, TimeoutExpiredError\\\".format(exit_status))\\n\\n if self.tc:\\n self.tc.terminate()\\n sys.exit(exit_status)\",\n \"def local(ctx):\\n _do_codegen_user(\\\"demo\\\")\\n _do_codegen_user(\\\"errors\\\")\\n _do_codegen_user(\\\"mpi\\\")\\n _do_codegen_user(\\\"omp\\\")\\n _do_codegen_user(\\\"python\\\")\\n\\n # Do codegen for libfake\\n for so in LIB_FAKE_FILES:\\n _do_codegen_file(so)\\n\\n # Run the WAMR codegen required by the tests\\n codegen(ctx, \\\"demo\\\", \\\"echo\\\", wamr=True)\\n codegen(ctx, \\\"demo\\\", \\\"chain\\\", wamr=True)\\n\\n # Run the SGX codegen required by the tests\\n codegen(ctx, \\\"demo\\\", \\\"hello\\\", wamr=True, sgx=True)\\n codegen(ctx, \\\"demo\\\", \\\"chain_named_a\\\", wamr=True, sgx=True)\\n codegen(ctx, \\\"demo\\\", \\\"chain_named_b\\\", wamr=True, sgx=True)\\n codegen(ctx, \\\"demo\\\", \\\"chain_named_c\\\", wamr=True, sgx=True)\",\n \"def main():\\r\\n\\r\\n option_parser, opts, args = parse_command_line_parameters(**script_info)\\r\\n\\r\\n # additional option checks\\r\\n if opts.chimera_detection_method == 'blast_fragments':\\r\\n if not (opts.blast_db or opts.reference_seqs_fp):\\r\\n option_parser.error('Must provide either --blast_db or' +\\r\\n ' --reference_seqs_fp and --id_to_taxonomy_fp when' +\\r\\n ' method is blast_fragments.')\\r\\n if not opts.id_to_taxonomy_fp:\\r\\n option_parser.error('Must provide --id_to_taxonomy_fp when method' +\\r\\n ' is blast_fragments.')\\r\\n if opts.num_fragments < 2:\\r\\n option_parser.error('Invalid number of fragments (-n %d) Must be >= 2.'\\r\\n % opts.num_fragments)\\r\\n elif opts.chimera_detection_method == 'ChimeraSlayer':\\r\\n if not opts.aligned_reference_seqs_fp:\\r\\n option_parser.error(\\\"Must provide --aligned_reference_seqs_fp \\\"\\r\\n \\\"when using method ChimeraSlayer\\\")\\r\\n elif opts.chimera_detection_method == 'usearch61':\\r\\n if opts.suppress_usearch61_ref and opts.suppress_usearch61_denovo:\\r\\n option_parser.error(\\\"Supressing both de novo and reference \\\"\\r\\n \\\"chimera detection not allowed.\\\")\\r\\n if not opts.reference_seqs_fp and not opts.suppress_usearch61_ref:\\r\\n option_parser.error(\\\"--reference_seqs_fp required for reference \\\"\\r\\n \\\"based chimera detection, suppress reference based chimera \\\"\\r\\n \\\"detection with --suppress_usearch61_ref\\\")\\r\\n if opts.reference_seqs_fp:\\r\\n try:\\r\\n temp_f = open(opts.reference_seqs_fp, \\\"U\\\")\\r\\n temp_f.close()\\r\\n except IOError:\\r\\n raise IOError(\\\"Unable to open --reference_seqs_fp, please \\\"\\r\\n \\\"check filepath and permissions.\\\")\\r\\n if opts.non_chimeras_retention not in ['intersection', 'union']:\\r\\n option_parser.error(\\\"--non_chimeras_retention must be either \\\"\\r\\n \\\"'union' or 'intersection'\\\")\\r\\n if opts.usearch61_xn <= 1:\\r\\n option_parser.error(\\\"--usearch61_xn must be > 1\\\")\\r\\n if opts.usearch61_dn <= 0:\\r\\n option_parser.error(\\\"--usearch61_dn must be > 0\\\")\\r\\n if opts.usearch61_mindiffs <= 0:\\r\\n option_parser.error(\\\"--usearch61_mindiffs must be > 0\\\")\\r\\n if opts.usearch61_mindiv <= 0:\\r\\n option_parser.error(\\\"--usearch61_mindiv must be > 0\\\")\\r\\n if opts.usearch61_abundance_skew <= 0:\\r\\n option_parser.error(\\\"--usearch61_abundance_skew must be > 0\\\")\\r\\n\\r\\n verbose = opts.verbose # not used yet ...\\r\\n input_seqs_fp = opts.input_fasta_fp\\r\\n id_to_taxonomy_fp = opts.id_to_taxonomy_fp\\r\\n reference_seqs_fp = opts.reference_seqs_fp\\r\\n chimera_detection_method = opts.chimera_detection_method\\r\\n num_fragments = opts.num_fragments\\r\\n output_fp = opts.output_fp\\r\\n taxonomy_depth = opts.taxonomy_depth\\r\\n max_e_value = opts.max_e_value\\r\\n blast_db = opts.blast_db\\r\\n keep_intermediates = opts.keep_intermediates\\r\\n threads = opts.threads\\r\\n\\r\\n # calculate threads as 1 per CPU, or use float of input value\\r\\n if threads == 'one_per_cpu':\\r\\n threads = float(1 / cpu_count())\\r\\n else:\\r\\n # Make sure input is a float\\r\\n try:\\r\\n threads = float(threads)\\r\\n except ValueError:\\r\\n option_parser.error(\\\"--threads must be a float value if \\\"\\r\\n \\\"default 'one_per_cpu' value overridden.\\\")\\r\\n\\r\\n if not output_fp:\\r\\n if chimera_detection_method == \\\"usearch61\\\":\\r\\n output_dir = \\\"usearch61_chimeras/\\\"\\r\\n create_dir(output_dir, fail_on_exist=False)\\r\\n else:\\r\\n input_basename = splitext(split(input_seqs_fp)[1])[0]\\r\\n output_fp = '%s_chimeric.txt' % input_basename\\r\\n elif chimera_detection_method == \\\"usearch61\\\":\\r\\n output_dir = output_fp\\r\\n create_dir(output_dir, fail_on_exist=False)\\r\\n\\r\\n if chimera_detection_method == 'blast_fragments':\\r\\n blast_fragments_identify_chimeras(input_seqs_fp,\\r\\n id_to_taxonomy_fp,\\r\\n reference_seqs_fp, blast_db=blast_db,\\r\\n num_fragments=opts.num_fragments,\\r\\n max_e_value=max_e_value,\\r\\n output_fp=output_fp,\\r\\n taxonomy_depth=taxonomy_depth)\\r\\n elif chimera_detection_method == 'ChimeraSlayer':\\r\\n chimeraSlayer_identify_chimeras(input_seqs_fp,\\r\\n output_fp=output_fp,\\r\\n db_FASTA_fp=opts.reference_seqs_fp,\\r\\n db_NAST_fp=opts.aligned_reference_seqs_fp,\\r\\n min_div_ratio=opts.min_div_ratio,\\r\\n keep_intermediates=keep_intermediates)\\r\\n elif chimera_detection_method == 'usearch61':\\r\\n usearch61_chimera_check(input_seqs_fp,\\r\\n output_dir=output_dir,\\r\\n reference_seqs_fp=reference_seqs_fp,\\r\\n suppress_usearch61_intermediates=opts.suppress_usearch61_intermediates,\\r\\n suppress_usearch61_ref=opts.suppress_usearch61_ref,\\r\\n suppress_usearch61_denovo=opts.suppress_usearch61_denovo,\\r\\n split_by_sampleid=opts.split_by_sampleid,\\r\\n non_chimeras_retention=opts.non_chimeras_retention,\\r\\n usearch61_minh=opts.usearch61_minh,\\r\\n usearch61_xn=opts.usearch61_xn,\\r\\n usearch61_dn=opts.usearch61_dn,\\r\\n usearch61_mindiffs=opts.usearch61_mindiffs,\\r\\n usearch61_mindiv=opts.usearch61_mindiv,\\r\\n usearch61_abundance_skew=opts.usearch61_abundance_skew,\\r\\n percent_id_usearch61=opts.percent_id_usearch61,\\r\\n minlen=opts.minlen,\\r\\n word_length=opts.word_length,\\r\\n max_accepts=opts.max_accepts,\\r\\n max_rejects=opts.max_rejects,\\r\\n verbose=opts.verbose,\\r\\n threads=threads)\",\n \"def start_compilation(self):\\n if(not self.check_main_requirements()):\\n exit(0)\\n\\n save_sysetting('last_action', self.COMPILE)\\n\\n self.add_board()\\n if(not self.board_id):\\n self.print(\\\"select_board_list\\\")\\n return\\n\\n self.add_option('lib_extra_dirs')\\n\\n # check if there is a new speed to overwrite\\n self.add_option('upload_speed')\\n\\n # add src_dir option if it's neccesary\\n self.override_src()\\n\\n cmd = ['run', '-e ', self.board_id]\\n self.run_command(cmd)\\n\\n self.after_complete()\",\n \"def main():\\n # if len(sys.argv) == 1:\\n # TicTacToe().mainloop()\\n # else:\\n # needEval = ['-degree']\\n # args = sys.argv[1:]\\n # opts = {}\\n # # parse the opts and args two at a time\\n # for i in range(0, len(args), +2):\\n # if args[i] in needEval:\\n # opts[args[i][1:]] = eval(args[i+1])\\n # else:\\n # opts[args[i][1:]] = args[i+1]\\n # trace(opts)\\n # apply(TicTacToe, (), opts).mainloop()\\n player1 = Player('X')\\n player2 = Player('O')\\n series = Series([player1, player2])\\n series.run(100000)\\n\\n series2 = Series()\\n series2.run(2, trace=True)\\n # pa1 = PlayerSmart('smrt1', 'X')\\n # pa2 = PlayerSmart('smrt2', 'O')\\n # Game().play([pa1, pa2])\",\n \"def main():\\n is_program_working = True\\n while is_program_working:\\n display.print_program_menu(MAIN_MENU)\\n try:\\n choose_option()\\n except ValueError as err:\\n display.print_command_result(str(err))\",\n \"def main():\\n parser = argparse.ArgumentParser(description=DESCRIPTON, epilog=EXAMPLE)\\n parser.add_argument(\\n \\\"--version\\\", action=\\\"version\\\", version=\\\"%(prog)s {}\\\".format(VERSION)\\n )\\n parser.add_argument(\\n \\\"-u\\\", \\\"--url\\\", metavar=\\\"<TARGET_URL>\\\",\\n required=\\\"-F\\\" not in sys.argv and \\\"--file\\\" not in sys.argv,\\n help=\\\"URL of the target GWT {name}.nocache.js bootstrap or {hex}.cache.js file\\\",\\n type=url_mode_checks\\n )\\n parser.add_argument(\\n \\\"-F\\\", \\\"--file\\\", metavar=\\\"<FILE>\\\", default=None,\\n required=\\\"-u\\\" not in sys.argv and \\\"--url\\\" not in sys.argv,\\n help=\\\"path to the local copy of a {hex}.cache.js GWT permutation file\\\",\\n type=file_mode_checks\\n )\\n parser.add_argument(\\n \\\"-b\\\", \\\"--base\\\", metavar=\\\"<BASE_URL>\\\", default=BASE_URL,\\n help=\\\"specifies the base URL for a given permutation file in -F/--file mode\\\"\\n )\\n parser.add_argument(\\n \\\"-p\\\", \\\"--proxy\\\", metavar=\\\"<PROXY>\\\", default=None,\\n help=\\\"URL for an optional HTTP proxy (e.g. -p http://127.0.0.1:8080)\\\"\\n )\\n parser.add_argument(\\n \\\"-c\\\", \\\"--cookies\\\", metavar=\\\"<COOKIES>\\\", default=None,\\n help=\\\"any cookies required to access the remote resource in -u/--url mode \\\"\\n + \\\"(e.g. 'JSESSIONID=ABCDEF; OTHER=XYZABC')\\\"\\n )\\n parser.add_argument(\\n \\\"-f\\\", \\\"--filter\\\", metavar=\\\"<FILTER>\\\", default=\\\"\\\",\\n help=\\\"case-sensitive method filter for output (e.g. -f AuthSvc.checkSession)\\\"\\n )\\n parser.add_argument(\\n \\\"--basic\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"enables HTTP Basic authentication if require. Prompts for credentials\\\"\\n )\\n parser.add_argument(\\n \\\"--rpc\\\", action=\\\"store_true\\\", default=False,\\n required=\\\"--probe\\\" in sys.argv,\\n help=\\\"attempts to generate a serialized RPC request for each method\\\"\\n )\\n parser.add_argument(\\n \\\"--probe\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"sends an HTTP probe request to test each method returned in --rpc mode\\\"\\n )\\n parser.add_argument(\\n \\\"--svc\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"displays enumerated service information, in addition to methods\\\"\\n )\\n parser.add_argument(\\n \\\"--code\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"skips all and dumps the 're-formatted' state of the provided resource\\\"\\n )\\n parser.add_argument(\\n \\\"--color\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"enables coloured console output\\\"\\n )\\n parser.add_argument(\\n \\\"--backup\\\", metavar=\\\"DIR\\\", nargs='?', default=False,\\n help=\\\"creates a local backup of retrieved code in -u/--url mode\\\"\\n )\\n parser.add_argument(\\n \\\"-q\\\", \\\"--quiet\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"enables quiet mode (minimal output)\\\"\\n )\\n\\n parser._optionals.title = \\\"Arguments\\\"\\n args = parser.parse_args()\\n\\n global COLOR_MODE\\n COLOR_MODE = args.color\\n\\n if not args.code and not args.quiet:\\n present_banner()\\n\\n set_base_url(args.url if args.base is BASE_URL else args.base)\\n\\n set_http_params(args)\\n\\n if not args.code and not args.quiet:\\n present_target(args.url if args.file is None else args.file)\\n\\n code, code_type = (\\n read_file(args.file) if args.file is not None else\\n fetch_code(args.url)\\n )\\n\\n check_warnings(code_type, args)\\n\\n code = clean_code(code, code_type)\\n\\n if code_type.startswith(BOOTSTRAP) and args.file is None:\\n code = get_permutation(code, code_type, args)\\n\\n set_globals(code, args)\\n\\n if is_fragmented(''.join(code), code_type) and args.file is None:\\n code = append_fragments(code, code_type, args)\\n\\n backup_file = None\\n if args.backup is not False and args.file is None:\\n backup_file = save_code(code, code_type, args.backup)\\n\\n if args.code:\\n present_code(code)\\n sys.exit(0)\\n\\n if not args.quiet:\\n present_module_info()\\n\\n service_objects = extract_service_info(code)\\n if args.svc:\\n present_services(service_objects, args.quiet)\\n\\n method_objects = extract_method_info(code, service_objects)\\n count = present_methods(method_objects, args.quiet, args.probe)\\n\\n if not args.quiet:\\n present_summary(service_objects, method_objects, count, backup_file)\",\n \"def cli(ctx: click.Context, config_instance: str, config_path: str) -> None:\\n ctx.obj = TurbiniaCli(\\n config_instance=config_instance, config_path=config_path)\\n\\n # Set up the tool based on the configuration file parameters.\\n ctx.obj.setup()\\n\\n # Build all the commands based on responses from the API server.\\n request_commands = factory.CommandFactory.create_dynamic_objects(\\n evidence_mapping=ctx.obj.evidence_mapping,\\n request_options=ctx.obj.request_options)\\n for command in request_commands:\\n groups.submit_group.add_command(command)\",\n \"def main():\\n sys.exit(RBExt().run(sys.argv[1:]))\",\n \"def main():\\n\\n\\tparser = OptionParser()\\n\\tparser.add_option(\\\"-l\\\", dest=\\\"liglist\\\", help=\\\"list of ligands\\\")\\n\\tparser.add_option(\\\"-r\\\", dest=\\\"runfile\\\", help=\\\"run file\\\")\\n\\tparser.add_option(\\\"-o\\\", dest=\\\"logfile\\\", help=\\\"log file\\\")\\n\\tparser.add_option(\\\"-b\\\", dest=\\\"bkupfile\\\", help=\\\"backed up file\\\")\\n\\tparser.add_option(\\\"-g\\\", dest=\\\"go\\\", help=\\\"do the runs\\\",action=\\\"store_true\\\")\\n\\tparser.set_description(main.__doc__)\\n\\t(options,args) = parser.parse_args()\\n\\n\\tif not options.liglist or not options.runfile:\\n\\t\\tparser.print_help()\\n\\t\\tsys.exit()\\n\\n\\tif not options.logfile:\\n\\t\\tparser.print_help()\\n\\t\\tsys.exit()\\n\\n\\t# --- create directories for each ligand --- #\\t\\n\\tligands = files_from_list(options.liglist)\\t\\n\\n\\texe = \\\"basename $PWD\\\"\\n\\tcurrdir = commands.getoutput(exe)\\n\\n\\tcwd = os.getcwd()\\n\\tls = os.listdir(cwd)\\n\\tprotein = currdir + \\\"_9.pdb\\\"\\n\\tif not protein in ls:\\n\\t\\tprint \\\"cannot find protein file:\\\",protein\\n\\t\\tsys.exit()\\n\\n\\ttry:\\n\\t\\tRUN = open(options.runfile)\\n\\texcept:\\n\\t\\tprint \\\"unable to open run file\\\"\\n\\t\\tsys.exit()\\t\\n\\n\\trunline = RUN.readline()\\n\\tre_het = re.compile(\\\"HETERO\\\")\\n\\tre_prt = re.compile(\\\"PROTEIN\\\")\\n\\n\\tif not re_het.search(runline):\\n\\t\\tprint \\\"run must contain HETERO\\\"\\n\\t\\tsys.exit()\\n\\n\\tif not re_prt.search(runline):\\n\\t\\tprint \\\"run must contain PROTEIN\\\"\\n\\t\\tsys.exit()\\n\\t\\t\\n\\n\\tfor lig in ligands:\\n\\t\\trline = runline\\n\\t\\tligbase = get_basefile(lig)\\n\\n\\t\\texe = \\\"mkdir \\\" + ligbase\\n\\t\\tos.system(exe)\\n\\n\\t\\texe = \\\"cp \\\" + lig + \\\" \\\" + ligbase\\n\\t\\tos.system(exe)\\n\\n\\t\\texe = \\\"cp \\\" + currdir + \\\"* \\\" + ligbase\\n\\t\\tos.system(exe)\\n\\n\\t\\texe = \\\"cp paths.txt \\\" + ligbase\\n\\t\\tos.system(exe)\\n\\n\\t\\texe = \\\"cp \\\" + options.bkupfile + \\\" \\\" + ligbase\\n\\t\\tos.system(exe)\\n\\n\\t\\trline = rline.replace(\\\"HETERO\\\", lig)\\n\\t\\trline = rline.replace(\\\"PROTEIN\\\", protein)\\n\\t\\t\\n\\t\\tnewrun = ligbase + \\\"/\\\" + options.runfile\\n\\t\\ttry:\\n\\t\\t\\tOUTRUN = open(newrun, 'w')\\n\\t\\texcept:\\n\\t\\t\\tprint \\\"cannot make new run\\\"\\n\\t\\t\\tsys.exit()\\n\\n\\n\\t\\tOUTRUN.write(rline) \\n\\t\\tOUTRUN.close()\\n\\t\\tos.chmod(newrun, stat.S_IRWXU)\\n\\n\\t\\tif options.go:\\n\\t\\t\\tos.chdir(ligbase)\\n\\t\\t\\tprint \\\" in\\\",os.getcwd()\\n\\t\\t\\texe = \\\"nice ./\\\" + options.runfile + \\\" >& \\\" + options.logfile\\n\\t\\t\\tos.system(exe)\\n\\t\\t\\tos.chdir(\\\"..\\\")\",\n \"def cli():\\n\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6534681","0.6394365","0.6163484","0.61047703","0.60676014","0.60312563","0.60181093","0.5815423","0.57839054","0.57279795","0.57003903","0.5678264","0.5646332","0.5634394","0.56316435","0.562979","0.5626772","0.5618201","0.5612563","0.5597489","0.55842924","0.55564576","0.5555601","0.5515311","0.5514631","0.551268","0.5493332","0.54922366","0.54820806","0.54812676","0.5470746","0.5468599","0.5468599","0.54564965","0.5452494","0.54516083","0.54506594","0.5449433","0.5442771","0.54304934","0.54141307","0.54085374","0.5388","0.5380908","0.53808814","0.53606606","0.5352593","0.5346451","0.5345832","0.53239554","0.532043","0.5317752","0.53161496","0.5310522","0.53086793","0.53070927","0.5293908","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.5289581","0.52874756","0.5285492","0.5282261","0.5266196","0.52595264","0.5256867","0.5253383","0.5252542","0.5248004","0.52473366","0.52455467","0.5241078","0.5240836","0.5239147","0.5236855","0.5233088"],"string":"[\n \"0.6534681\",\n \"0.6394365\",\n \"0.6163484\",\n \"0.61047703\",\n \"0.60676014\",\n \"0.60312563\",\n \"0.60181093\",\n \"0.5815423\",\n \"0.57839054\",\n \"0.57279795\",\n \"0.57003903\",\n \"0.5678264\",\n \"0.5646332\",\n \"0.5634394\",\n \"0.56316435\",\n \"0.562979\",\n \"0.5626772\",\n \"0.5618201\",\n \"0.5612563\",\n \"0.5597489\",\n \"0.55842924\",\n \"0.55564576\",\n \"0.5555601\",\n \"0.5515311\",\n \"0.5514631\",\n \"0.551268\",\n \"0.5493332\",\n \"0.54922366\",\n \"0.54820806\",\n \"0.54812676\",\n \"0.5470746\",\n \"0.5468599\",\n \"0.5468599\",\n \"0.54564965\",\n \"0.5452494\",\n \"0.54516083\",\n \"0.54506594\",\n \"0.5449433\",\n \"0.5442771\",\n \"0.54304934\",\n \"0.54141307\",\n \"0.54085374\",\n \"0.5388\",\n \"0.5380908\",\n \"0.53808814\",\n \"0.53606606\",\n \"0.5352593\",\n \"0.5346451\",\n \"0.5345832\",\n \"0.53239554\",\n \"0.532043\",\n \"0.5317752\",\n \"0.53161496\",\n \"0.5310522\",\n \"0.53086793\",\n \"0.53070927\",\n \"0.5293908\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.5289581\",\n \"0.52874756\",\n \"0.5285492\",\n \"0.5282261\",\n \"0.5266196\",\n \"0.52595264\",\n \"0.5256867\",\n \"0.5253383\",\n \"0.5252542\",\n \"0.5248004\",\n \"0.52473366\",\n \"0.52455467\",\n \"0.5241078\",\n \"0.5240836\",\n \"0.5239147\",\n \"0.5236855\",\n \"0.5233088\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6382,"cells":{"query":{"kind":"string","value":"Drive the UV plane combination. Functionally, this means Performing concatenation Cleaning the concatenated MS in the UV plane Imaging the concatenated MS"},"document":{"kind":"string","value":"def _drive_uv(param_dict, clargs, output_basename, casa_instance):\n\n script = []\n\n if glob.glob('{}.concat.ms'.format(output_basename)) and clargs.overwrite:\n os.system('rm -rf {}.concat.ms'.format(output_basename))\n\n # casa_instance.run_script(script)\n # todo\n # write an extension of the drivecasa command for imstat, which will let\n # us do the imstat work to do the inference for clean params.\n\n # perform concatenation\n\n if not glob.glob('{}.concat.ms'):\n concat_vis = drivecasa.commands.reduction.concat(script,\n [\n param_dict[\n 'twelve_meter_filename'],\n param_dict[\n 'seven_meter_filename']\n ],\n out_path='./{}.concat.ms'.\n format(output_basename))\n\n # clean + image\n thresh, clean_args = utils.param_dict_to_clean_input(\n param_dict, seven_meter=False)\n\n clean_args.update(\n {'spw': str(param_dict['seven_meter_spw'] + ',' + param_dict['twelve_meter_spw'])})\n clean_image = drivecasa.commands.clean(\n script,\n concat_vis,\n niter=10000,\n threshold_in_jy=thresh,\n other_clean_args=clean_args)\n\n if param_dict['moments']:\n for moment in param_dict['moments']:\n _ = additional_casa_commands.immoments(\n script, clean_image.image, clean_image.image, moment)\n if clargs.verbose:\n utils.eprint(script)\n\n if not clargs.generate:\n _ = casa_instance.run_script(script, timeout=None)\n\n if clargs.generate:\n utils.output_to_file(script, output_basename)\n\n if clargs.verbose:\n utils.eprint(\"Data products present in {}\".format(clean_image))"},"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 apply_uvs(mesh, bsp_verts):\n\n mesh.uv_textures.new(\"UVs\")\n bm = bmesh.new()\n bm.from_mesh(mesh)\n\n if hasattr(bm.faces, \"ensure_lookup_table\"): \n bm.faces.ensure_lookup_table()\n\n uv_layer = bm.loops.layers.uv[0]\n\n for face_idx, current_face in enumerate(bm.faces):\n current_face.loops[0][uv_layer].uv = bsp_verts[current_face.loops[0].vert.index][1]\n current_face.loops[1][uv_layer].uv = bsp_verts[current_face.loops[1].vert.index][1]\n current_face.loops[2][uv_layer].uv = bsp_verts[current_face.loops[2].vert.index][1]\n \n bm.to_mesh(mesh)","def voxelize4(self, materials):\n\t\tlayers = list()\n\t\tlayersR = list()\n\t\tlayersG = list()\n\t\tlayersB = list()\n\t\t\n\t\tlayerMaterial = list()\n\t\tself.volumeComposition = list()\n\t\tfor l in range(len(materials)):\n\t\t\tlayerMaterial.append(list())\n\t\t\tself.volumeComposition.append(list())\n\n\t\tvolumeGeneral = list()\n\t\tm = 0\n\t\tfor i in self.slicePoints:\n\t\t\t#print self.boolResult[m].shape\n\t\t\ttupleResultR = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\n\t\t\ttupleResultG = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\n\t\t\ttupleResultB = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\n\t\t\ttupleMaterial = list()\n\t\t\tfor l in range(len(materials)):\n\t\t\t\ttupleMaterial.append(numpy.zeros(self.boolLayers[m].shape, dtype=float))\n\t\t\t\n\t\t\tj = numpy.nditer(self.boolLayers[m], flags=['multi_index'], op_flags=['readwrite'])\n\t\t\twhile not j.finished:\n\t\t\t\tif j[0] == True:\n\t\t\t\t#tupleResult[j.multi_index] = round((i[direction] - minValue) * ratio)\n\t\t\t\t#tupleResult[j.multi_index] = 78\n\t\t\t\t\tprint type(j.multi_index)\n\t\t\t\t\tprint j.multi_index\n\t\t\t\t\t#tupleResult[j.multi_index] = planeWeight * math.fabs((j.multi_index[1] - planeOrigin[0]) * planeNormal[0] + (j.multi_index[0] - planeOrigin[1]) * planeNormal[1] + (i[2] - planeOrigin[2]) * planeNormal[2]) + pointWeight * math.sqrt(math.pow((j.multi_index[1]- pointValue[0]),2) + math.pow((j.multi_index[0] - pointValue[1]), 2)+math.pow((i[2] - pointValue[2]),2))\n\t\t\t\t\t\n\t\t\t\t\tdistanceList = []\n\t\t\t\t\ttotalDistance = 0.0\n\t\t\t\t\tfor k in range(len(materials)):\n\t\t\t\t\t\tif materials[k].controlSourceType == \"Plane\":\n\t\t\t\t\t\t\tGplane = math.fabs((j.multi_index[1] - materials[k].origin[0]) * materials[k].normal[0] + (j.multi_index[0] - materials[k].origin[1]) * materials[k].normal[1] + (i[2] - materials[k].origin[2]) * materials[k].normal[2])\n\t\t\t\t\t\t\tdistanceList.append(Gplane)\n\t\t\t\t\t\t\ttotalDistance += Gplane\n\t\t\t\t\t\tif materials[k].controlSourceType == \"Point\":\n\t\t\t\t\t\t\tGpoint = (math.sqrt(math.pow((j.multi_index[1]- materials[k].point[0]),2) + math.pow((j.multi_index[0] - materials[k].point[1]), 2)+math.pow((i[2] - materials[k].point[2]),2)))\n\t\t\t\t\t\t\tdistanceList.append(Gpoint)\n\t\t\t\t\t\t\ttotalDistance += Gpoint\n\t\t\t\t\tfor k in range(len(distanceList)):\n\t\t\t\t\t\tdistanceList[k] = distanceList[k] / totalDistance\n\t\t\t\t\t\tdistanceList[k] = 1.0 - distanceList[k]\n\t\t\t\t\t\t\n\t\t\t\t\t\ttupleMaterial[k][j.multi_index] = distanceList[k]\n\t\t\t\t\t\t\n\t\t\t\t\t\ttupleResultR[j.multi_index] += materials[k].materialColor[0] * distanceList[k] * materials[k].weight\n\t\t\t\t\t\ttupleResultG[j.multi_index] += materials[k].materialColor[1] * distanceList[k] * materials[k].weight\n\t\t\t\t\t\ttupleResultB[j.multi_index] += materials[k].materialColor[2] * distanceList[k] * materials[k].weight\n\t\t\t\t\t#if(tupleResult[j.multi_index] > 0):\n\t\t\t\t\t#\ttupleResult[j.multi_index] = round(tupleResult[j.multi_index]) \n\t\t\t\t\t#if(tupleResult[j.multi_index] == 0):\n\t\t\t\t\t#\t\ttupleResult[j.multi_index] = 1\n\t\t\t\t\t#if(tupleResult[j.multi_index] < 0):\n\t\t\t\t\t#\ttupleResult[j.multi_index] = round(0 - tupleResult[j.multi_index]) \n\t\t\t\telse:\n\t\t\t\t\ttupleResultR[j.multi_index] = 0\n\t\t\t\t\ttupleResultG[j.multi_index] = 0\n\t\t\t\t\ttupleResultB[j.multi_index] = 0\n\t\t\t\t\tfor k in range(len(materials)):\n\t\t\t\t\t\ttupleMaterial[k][j.multi_index] = 0.0\n\t\t\t\tj.iternext()\n\t\t\tlayersR.append(tupleResultR)\n\t\t\tlayersG.append(tupleResultG)\n\t\t\tlayersB.append(tupleResultB)\n\t\t\tfor k in range(len(materials)):\n\t\t\t\tlayerMaterial[k].append(tupleMaterial[k])\n\t\t\t\t\n\t\t\tm = m + 1\n\t\tprint \"i got here\"\n\t\tvolumeR=numpy.array(layersR) # create the 3d volume\n\t\tvolumeG=numpy.array(layersG) \n\t\tvolumeB=numpy.array(layersB)\n\t\tfor k in range(len(materials)):\n\t\t\tself.volumeComposition[k] = numpy.array(layerMaterial[k])\n\t\t\n\t\tvolumeGeneral.append(volumeR)\n\t\tvolumeGeneral.append(volumeG)\n\t\tvolumeGeneral.append(volumeB)\n\t\treturn volumeGeneral","def edge_velocity(self):\n #reflext x values at x edges\n self.u[1,:,0] = -self.u[1,:,1]\n self.u[1,:,-1] = -self.u[1,:,-2]\n #mirror x values at y edges \n self.u[1,0,:] = self.u[1,1,:]\n self.u[1,-1,:] = self.u[1,-2,:]\n #mirror y values at x edges\n self.u[0,:,0] = self.u[0,:,1]\n self.u[0,:,-1] = self.u[0,:,-2]\n #mirror y values at y edges \n self.u[0,0,:] = -self.u[0,1,:]\n self.u[0,-1,:] = -self.u[0,-2,:]","def CreateBiPennate1():\r\n \r\n print('Opening Data...')\r\n # Load Surface Mesh Data and generate normals\r\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\r\n header, PointData, PolygonData = CreateMatrixVTK(VTKString)\r\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\r\n # Load full volume centroid\r\n NCF_Str = OpenData(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\",\"new_centroids_file.dat\")\r\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\r\n print('Loading Finished \\n Rotating Vectors...')\r\n \r\n # Rotate Vectors\r\n RotVectors1 = np.zeros((Vectors1.shape[0],3))\r\n\r\n idxpos = np.argwhere(Centroids1[:,1] >= 0)\r\n idxpos = idxpos.flatten()\r\n idxneg = np.argwhere(Centroids1[:,1] < 0)\r\n idxneg = idxneg.flatten()\r\n\r\n PosVectors = RotationTransform(Vectors1[idxpos,:],degZ = 30)\r\n NegVectors = RotationTransform(Vectors1[idxneg,:],degZ = -30)\r\n RotVectors1[idxpos,:] = PosVectors[:,:]\r\n RotVectors1[idxneg,:] = NegVectors[:,:]\r\n print('Vectors Rotated \\n Inserting Plane...')\r\n \r\n # Create Plane of vectors through centreline.\r\n PlaneCentroids,PlaneVectors = InsertPlane(Centroids1,RotVectors1,50,4)\r\n print('Plane Inserted \\n Interpolating Centroids...')\r\n \r\n # Interpolate Vectors\r\n Vectors2 = VectorInter(PlaneCentroids,PlaneVectors,Centroids2)\r\n # Make the data more sparse to display better.\r\n C1,V1 = SparseData(PlaneCentroids,PlaneVectors,1)\r\n C2,V2 = SparseData(Centroids2,Vectors2,1)\r\n print('Interpolation Finished \\n Plotting...')\r\n \r\n # Plot Data\r\n fig = plt.figure()\r\n\r\n ax1 = fig.add_subplot(121,projection = '3d')\r\n DisplaySliceVectors(C1,V1,ax1,5,10)\r\n\r\n ax2 = fig.add_subplot(122,projection = '3d')\r\n DisplaySliceVectors(C2,V2,ax2,5,10)\r\n\r\n plt.show()\r\n\r\n header = 'TITLE = \\\"New Centroid Vectors\\\"\\nVARIABLES = \\\"XV\\\", \\\"YV\\\", \\\"ZV\\\" \\nZONE T=\\\"Step 0 Incr 0\\\" \\nF = VECTORS'\r\n\r\n np.savetxt(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/BiPennateCentralPlaneFibres30.dat\",Vectors2,header = header,comments='')","def _prepare_plane(self):\n verticies = [\n # main plane - note that the mainplane is scaled so the mat_plane\n # matrix will it transform to the correct coordinates\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n\n # coord plane\n 0, 0,\n 0, -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], 0,\n 0, 0,\n\n # axes\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\n 0, 0, 0, -self.o_wh[1], #y\n ]\n\n colors = [\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n .9, .9, .9, 9.0, # plot box\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n 0.0, 0.0, 0.0, 1.0, #lines\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n ]\n\n self._fonts = []\n for u in range(1, self._unit_count[0]+1):\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]+0.02)\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]-0.02)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\n (-self.o_wh[1]+(self.i_border[3])*0.5)\n ])\n for u in range(0, self._unit_count[1]):\n verticies.append(0.02)\n verticies.append(-self._unit_w[1]*u)\n verticies.append(-0.02)\n verticies.append(-self._unit_w[1]*u)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\n (0.025)*self._scaling[0],\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\n ])\n\n self._draw_plane_indicies = (0, 12)\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\n\n # convert data into valid data format\n verticies = numpy.array(verticies, dtype=numpy.float32)\n colors = numpy.array(colors, dtype=numpy.float32)\n\n self._plane_vao = util.VAO()\n self._plane_vbo = util.VBO(2)\n\n with self._plane_vao:\n # plane verticies\n with self._plane_vbo.get(0):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(0)\n\n # place vertex colors\n with self._plane_vbo.get(1):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(1)","def CreateBiPennate2():\r\n \r\n print('Opening Data...')\r\n # Load Surface Mesh Data and generate normals\r\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\r\n header, PointData, PolygonData = CreateMatrixVTK(VTKString)\r\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\r\n Vectors1 = LongaxisOrtho(Vectors1)\r\n # Load full volume centroid\r\n NCF_Str = OpenData(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/Project_Gastro/workflows/Cesim/musc_mod_v2/OutputFiles\",\"new_centroids_file.dat\")\r\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\r\n print('Loading Finished \\n Rotating Vectors...')\r\n \r\n # Rotate Vectors\r\n RotVectors1 = np.zeros((np.shape(Vectors1)[0],3))\r\n\r\n idxpos = np.argwhere(Centroids1[:,1] >= 0)\r\n idxpos = idxpos.flatten()\r\n idxneg = np.argwhere(Centroids1[:,1] < 0)\r\n idxneg = idxneg.flatten()\r\n\r\n PosVectors = RotationTransform(Vectors1[idxpos,:],degZ = -30)\r\n NegVectors = RotationTransform(Vectors1[idxneg,:],degZ = 30)\r\n RotVectors1[idxpos,:] = PosVectors[:,:]\r\n RotVectors1[idxneg,:] = NegVectors[:,:]\r\n print('Vectors Rotated \\n Inserting Plane...')\r\n \r\n # Create Plane of vectors through centreline.\r\n PlaneCentroids,PlaneVectors = InsertPlane(Centroids1,RotVectors1,50,4)\r\n print('Plane Inserted \\n Interpolating Centroids...')\r\n \r\n # Interpolate Vectors\r\n Vectors2 = VectorInter(PlaneCentroids,PlaneVectors,Centroids2)\r\n # Make the data more sparse to display better.\r\n C1,V1 = SparseData(PlaneCentroids,PlaneVectors,0.1)\r\n C2,V2 = SparseData(Centroids2,Vectors2,0.1)\r\n print('Interpolation Finished \\n Plotting...')\r\n \r\n # Plot Data\r\n fig = plt.figure()\r\n\r\n ax1 = fig.add_subplot(211,projection = '3d')\r\n DisplaySliceVectors(C1,V1,ax1,1,1)\r\n\r\n ax2 = fig.add_subplot(212,projection = '3d')\r\n DisplaySliceVectors(C2,V2,ax2,1,1)\r\n\r\n plt.show()\r\n\r\n header = 'TITLE = \\\"New Centroid Vectors\\\"\\nVARIABLES = \\\"XV\\\", \\\"YV\\\", \\\"ZV\\\" \\nZONE T=\\\"Step 0 Incr 0\\\" \\nF = VECTORS'\r\n\r\n np.savetxt(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/BiPennateCentralPlaneFibres.dat\",Vectors2,header = header,comments='')","def InterpolateSurfaceVectorsWithPlane():\r\n # Load Surface Mesh Data and generate normals\r\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\r\n header, PointData, PolygonData = CreateMatrixVTK(VTKString)\r\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\r\n # Load full volume centroid\r\n NCF_Str = OpenData(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\",\"new_centroids_file.dat\")\r\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\r\n print('Loading Finished \\n Inserting Plane...')\r\n # Create Plane of vectors through centreline.\r\n PlaneCentroids,PlaneVectors = InsertPlane(Centroids1,Vectors1,50,8)\r\n print('Plane Inserted \\n Interpolating Centroids...')\r\n # Interpolate Vectors\r\n Vectors2 = VectorInter(PlaneCentroids,PlaneVectors,Centroids2)\r\n # Make the data more sparse to display better.\r\n C1,V1 = SparseData(PlaneCentroids,PlaneVectors,0.5)\r\n C2,V2 = SparseData(Centroids2,Vectors2,0.5)\r\n print('Interpolation Finished \\n Plotting...')\r\n # Plot Data\r\n fig = plt.figure()\r\n\r\n ax1 = fig.add_subplot(121,projection = '3d')\r\n DisplaySliceVectors(C1,V1,ax1,5,10)\r\n\r\n ax2 = fig.add_subplot(122,projection = '3d')\r\n DisplaySliceVectors(C2,V2,ax2,5,10)\r\n\r\n plt.show()\r\n\r\n header = 'TITLE = \\\"Normal Surface Vectors With Central axis Plane\\\"\\nVARIABLES = \\\"XV\\\", \\\"YV\\\", \\\"ZV\\\" \\nZONE T=\\\"Step 0 Incr 0\\\" \\nF = VECTORS'\r\n\r\n np.savetxt(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/SurfacePlaneVectorInterpolation.dat\",Vectors2,header = header,comments='')","def untangleUV(*args, mapBorder: AnyStr=\"\", maxRelaxIterations: int=0, pinBorder: bool=True,\n pinSelected: bool=True, pinUnselected: bool=True, relax: AnyStr=\"\",\n relaxTolerance: float=0.0, shapeDetail: float=0.0, **kwargs)->int:\n pass","def planeSliceTOAFig(uxmax, uymax, dso, dsl, f, dm, m, n, ax, ay, npoints, xax = True, yax = True):\n \n # Calculate coefficients\n rF2 = rFsqr(dso, dsl, f)\n uF2x, uF2y = rF2*np.array([1./ax**2, 1./ay**2])\n lc = lensc(dm, f)\n alp = rF2*lc\n coeff = alp*np.array([1./ax**2, 1./ay**2])\n tg0 = tg0coeff(dso, dsl)\n tdm0 = tdm0coeff(dm, f)\n\n # Calculate caustic intersections\n ucross = polishedRoots(causticEqSlice, uxmax, uymax, args=(alp, m, n, ax, ay))\n ncross = len(ucross)\n upcross = mapToUp(ucross.T, alp, ax, ay)\n p = np.argsort(upcross[0])\n upcross = upcross.T[p]\n ucross = ucross[p]\n # print(upcross)\n \n # Set up quantities for proper u' plane slicing\n ymin = -m*uxmax + n\n ymax = m*uxmax + n\n if ymin < -uymax:\n xmin = (-uymax - n)/m\n ymin = m*xmin + n\n else:\n xmin = -uxmax\n if ymax > uymax:\n xmax = (uymax - n)/m\n ymax = m*xmax + n\n else:\n xmax = uxmax\n \n cdist = uxmax/(np.abs(50*lc))\n \n bound = np.insert(upcross, 0, np.array([[xmin, ymin]]), axis = 0) # set up boundaries\n bound = np.append(bound, np.array([[xmax, ymax]]), axis = 0)\n midpoints = [(bound[i] + bound[i+1])/2. for i in range(len(bound) - 1)] # find middle point between boundaries\n nzones = len(midpoints)\n nreal = np.zeros(nzones, dtype = int)\n for i in range(nzones): # find number of roots at each midpoint\n mpoint = midpoints[i]\n nreal[i] = len(findRoots(lensEq, 2*uxmax, 2*uymax, args = (mpoint, coeff)))\n upxvecs = np.array([np.linspace(bound[i-1][0] + cdist, bound[i][0] - cdist, npoints) for i in range(1, ncross + 2)]) # generate upx vector\n segs = np.asarray([lineVert(upx, m, n) for upx in upxvecs]) # generate slice across plane\n ncomplex = np.zeros(nzones) # don't care about complex solutions in this case\n print(nreal)\n \n # Find roots\n allroots = rootFinder(segs, nreal, ncomplex, npoints, ucross, uxmax, uymax, coeff)\n \n # Calculate TOAs\n alltoas = []\n for i in range(nzones):\n toas = obsCalc(deltat, allroots[i], int(nreal[i]), npoints, 1, args = (tg0, tdm0, alp, ax, ay)).real\n alltoas.append(toas)\n \n # Plots\n fig, ax1 = plt.subplots(figsize=(10, 8), dpi = 100)\n # grid = gs.GridSpec(2, 2, width_ratios=[4, 1])\n # ax0 = plt.subplot(grid[1:, 1])\n # ax1 = plt.subplot(grid[0, 1])\n \n \n # ax2 = plt.subplot(grid[:, 0]) # Plot results\n colors = assignColor(allroots, nreal)\n l = []\n for i in range(len(upxvecs)):\n zone = alltoas[i]\n for j in range(len(zone)):\n line = ax1.plot(upxvecs[i], zone[j], color = colors[i][j], lw = 3.)\n l.append(line)\n for i in range(ncross):\n ax1.plot([upcross[i][0], upcross[i][0]], [-100, 100], color = 'black', ls = 'dashed', scaley = False, scalex = False, lw = 2.5)\n label = r'$\\nu = $' + str(f/GHz) + ' GHz'\n ax1.text(0.05, 0.9, label, transform=ax1.transAxes, fontsize = 28, bbox=dict(facecolor = 'white', alpha=1.))\n # ax1.set_ylim(min(alltoas.flatten() - 1), max(alltoas.flatten() + 1))\n if not xax:\n ax1.xaxis.set_ticklabels([])\n else:\n ax1.set_xlabel(r\"$u'_x$\", fontsize=28)\n if not yax:\n ax1.yaxis.set_ticklabels([])\n else:\n ax1.set_ylabel(r'$\\Delta t \\: (\\mu s)$', fontsize=28)\n if dm > 0:\n ax1.set_ylim(-0.5, 15.)\n else:\n ax1.set_ylim(-2.5, 10.)\n ax1.tick_params(labelsize = 22)\n ax1.grid()\n \n ax2 = inset_axes(ax1, width='18%', height='23%', loc=1)\n rx = np.linspace(-uxmax, uxmax, 1000) # Plot caustic surfaces\n ry = np.linspace(-uxmax, uxmax, 1000)\n uvec = np.meshgrid(rx, ry)\n ucaus = causCurve(uvec, coeff)\n cs = ax2.contour(rx, ry, ucaus, levels = [0, np.inf], linewidths = 0)\n paths = cs.collections[0].get_paths()\n uppaths = []\n for p in paths:\n cuvert = np.array(p.vertices).T\n upx, upy = mapToUp(cuvert, alp, ax, ay)\n ax2.plot(upx, upy, color = 'blue')\n ax2.plot(np.linspace(xmin, xmax, 10), np.linspace(ymin, ymax, 10), color = 'green')\n ax2.scatter(upcross.T[0], upcross.T[1], color = 'green')\n # ax2.set_xlabel(r\"$u'_x$\")\n # ax2.set_ylabel(r\"$u'_y$\")\n ax2.set_xlim(-uxmax, uxmax)\n ax2.tick_params(labelsize = 16)\n # ax1.set_title(\"Caustic curves\")\n # ax1.set_aspect('equal', anchor = 'N')\n ax2.grid()\n # ax2.tight_layout()\n \n plt.tight_layout()\n plt.show()\n return","def uvregister(self,v):\n return self.get('patchmesh.uvvertices').intern(v)","def uvmap(self, p):\n # bottom left corner of the plane\n p00 = self.position - (self.sx * self.n0) / 2 - (self.sy * self.n1) / 2\n dif_vector = p - p00\n u = np.dot(dif_vector, self.n0) / self.sx\n v = np.dot(dif_vector, self.n1) / self.sy\n return u, v","def add_subdivision(self):\n temp_sub_vertices = []\n for plane in (self.subdivision_list):\n current_mids = []\n mid_m_01 = Vec3d(0, 0, 0, 0)\n mid_m_12 = Vec3d(0, 0, 0, 0)\n mid_m_20 = Vec3d(0, 0, 0, 0)\n\n mid_m_01.x = (plane[0].x + plane[1].x) / 2\n mid_m_01.y = (plane[0].y + plane[1].y) / 2\n mid_m_01.z = (plane[0].z + plane[1].z) / 2\n mid_m_01.w = plane[0].w\n\n mid_m_12.x = (plane[1].x + plane[2].x) / 2\n mid_m_12.y = (plane[1].y + plane[2].y) / 2\n mid_m_12.z = (plane[1].z + plane[2].z) / 2\n mid_m_12.w = plane[1].w\n\n mid_m_20.x = (plane[2].x + plane[0].x) / 2\n mid_m_20.y = (plane[2].y + plane[0].y) / 2\n mid_m_20.z = (plane[2].z + plane[0].z) / 2\n mid_m_20.w = plane[2].w\n\n current_mids = [mid_m_01, mid_m_12, mid_m_20]\n temp_sub_vertices.append(current_mids)\n\n for index in range(len(current_mids)):\n v0 = Vec3d(0, 0, 0, 0)\n v1 = Vec3d(0, 0, 0, 0)\n v2 = Vec3d(0, 0, 0, 0)\n\n v0.x = plane[index].x\n v0.y = plane[index].y\n v0.z = plane[index].z\n\n v1.x = current_mids[index].x\n v1.y = current_mids[index].y\n v1.z = current_mids[index].z\n\n v2.x = current_mids[index - 1].x\n v2.y = current_mids[index - 1].y\n v2.z = current_mids[index - 1].z\n\n temp_sub_vertices.append([v0, v1, v2])\n\n self.subdivision_list = temp_sub_vertices","def test_set_vx_to_vx_plus_vy(self, cpu):\n for x in range(0x0, 0xF):\n for y in range(0x0, 0xF):\n if x != y:\n cpu.opcode = 0x8004 | (x << 8) | (y << 4)\n for v1 in range(0x0, 0xFF):\n for v2 in range(0x0, 0xFF):\n cpu.V_register[x] = v1\n cpu.V_register[y] = v2\n cpu.set_vx_to_vx_plus_vy()\n value = v1 + v2\n if value > 0xFF:\n assert(cpu.V_register[0xF] == 1)\n assert(cpu.V_register[x] == value & 0xFF)\n else:\n assert(cpu.V_register[0xF] == 0)\n assert(cpu.V_register[x] == value)","def blackbodyUV(temp):\n lam=lambda wl: planckian(temp, wl)\n xyz=spectrumToTristim(perfectrefl, lam)\n uvy=xyzTouvY(xyz)\n return [uvy[0], uvy[1]*2.0/3]","def extforce (u, v):\r\n\r\n for i in range (height):\r\n for j in range (width):\r\n u[i,j], v[i,j] = np.stack((u[i,j], v[i,j])) + dt * extacc\r\n\r\n return u, v","def levelsets_to_vector_field(levelsets, stepsize):\r\n vector_field_shape = levelsets[0][0].shape\r\n y_comp_combined = np.ndarray(vector_field_shape)\r\n x_comp_combined = np.ndarray(vector_field_shape)\r\n y_comp_combined.fill(np.nan)\r\n x_comp_combined.fill(np.nan)\r\n\r\n for source, target in levelsets:\r\n labels_present = set(np.array([source.flatten(),target.flatten()]).flatten())\r\n labels_present.remove(0)#relates to background\r\n\r\n #print(labels_present)\r\n for l in labels_present:\r\n\r\n source_cluster = source == l\r\n target_cluster = target == l\r\n\r\n\r\n \"\"\"plt.imshow(source_cluster.astype(np.int32)+target_cluster.astype(np.int32))\r\n plt.show()\r\n print(\"-----------\")\"\"\"\r\n\r\n #plot_gradient_field(source_cluster.astype(np.int32), target_cluster.astype(np.int32))\r\n\r\n y_comp, x_comp = array_to_vector_field(source_cluster, target_cluster, stepsize=stepsize)\r\n y_comp_combined[~np.isnan(y_comp)] = y_comp[~np.isnan(y_comp)]\r\n x_comp_combined[~np.isnan(x_comp)] = x_comp[~np.isnan(x_comp)]\r\n return y_comp_combined, x_comp_combined","def uvregister(self,v):\n return self.get('mesh.uvvertices').intern(v)","def vector_arrows(Out, x, y, z, plot_layer):\n\n x = sort_dim(x)\n y = sort_dim(y)\n z = sort_dim(z)\n\n # length of array in each dimension\n Ny = len(y)-1\n Nx = len(x)-1\n Nz = len(z)-1\n\n # coordinates of cell centres\n # (halfway between L and R edges)\n xm = 0.5 * (x[:-1] + x[1:])\n ym = 0.5 * (y[:-1] + y[1:])\n zm = 0.5 * (z[:-1] + z[1:])\n\n # create empty arrays for output\n U = np.zeros((len(Out.Qx[:,0,0,0]),len(Out.Qx[0,:,0,0]),len(Out.Qx[0,0,:,0]),len(Out.Qx[0,0,0,:])+1)) \n V = np.zeros((len(Out.Qy[:,0,0,0]),len(Out.Qy[0,:,0,0]),len(Out.Qy[0,0,:,0])+1,len(Out.Qy[0,0,0,:])))\n W = np.zeros((len(Out.Qz[:,0,0,0]),len(Out.Qz[0,:,0,0])+1,len(Out.Qz[0,0,:,0]),len(Out.Qz[0,0,0,:])))\n\n # create mesh\n X, Y, = np.meshgrid(xm, ym) # coordinates of cell centers\n Z = np.meshgrid(zm)\n\n # iterate through timesteps\n for t in range(len(Out.Qy[:,0,0,0])): # number of timesteps\n\n #grab relevant timestep from Out array\n Qx = Out.Qx[t,:,:,:]\n Qy = Out.Qy[t,:,:,:]\n Qz = Out.Qz[t,:,:,:]\n\n # Calculate flows at cell centers by interpolating between L and R faces\n Ut = np.concatenate((Qx[plot_layer, :, 0].reshape((1, Ny, 1)), \\\n 0.5 * (Qx[plot_layer, :, :-1].reshape((1, Ny, Nx-2)) +\\\n Qx[plot_layer, :, 1: ].reshape((1, Ny, Nx-2))), \\\n Qx[plot_layer, :, -1].reshape((1, Ny, 1))), axis=2).reshape((Ny,Nx))\n\n Vt = np.concatenate((Qy[plot_layer, 0, :].reshape((1, 1, Nx)), \\\n 0.5 * (Qy[plot_layer, :-1, :].reshape((1, Ny-2, Nx)) +\\\n Qy[plot_layer, 1:, :].reshape((1, Ny-2, Nx))), \\\n Qy[plot_layer, -1, :].reshape((1, 1, Nx))), axis=1).reshape((Ny,Nx))\n\n # average flow across vertical cell to get z flow at cell centre\n QzTop = Qz[0:-1,:,:]\n QzBot = Qz[1:,:,:]\n Wt = (QzTop+QzBot)/2\n \n # add results to output arrays\n U[t,:,:,:] = Ut\n V[t,:,:,:] = Vt\n W[t,1:-1,:,:] = Wt\n\n return X,Y,Z,U,V,W","def scale_uv(self):\n self.u = [i * self.scale * self.scaleratio for i in self.u]\n self.v = [i * self.scale for i in self.v]","def render(self, scene):\n if self.degenerate:\n return\n # The number of subdivisions around the hoop's radial direction.\n if self.thickness:\n band_coverage = scene.pixel_coverage(self.pos, self.thickness)\n else:\n band_coverage = scene.pixel_coverage(self.pos, self.radius * 0.1)\n if band_coverage < 0:\n band_coverage = 1000\n bands = sqrt(band_coverage * 4.0)\n bands = clamp(4, bands, 40)\n # The number of subdivisions around the hoop's tangential direction.\n ring_coverage = scene.pixel_coverage(self.pos, self.radius)\n if ring_coverage < 0:\n ring_coverage = 1000\n rings = sqrt(ring_coverage * 4.0)\n rings = clamp(4, rings, 80)\n slices = int(rings)\n inner_slices = int(bands)\n radius = self.radius\n inner_radius = self.thickness\n\n # Create the vertex and normal arrays.\n vertices = []\n normals = []\n\n outer_angle_step = 2 * pi / (slices - 1)\n inner_angle_step = 2 * pi / (inner_slices - 1)\n outer_angle = 0.\n for i in range(slices):\n cos_outer_angle = cos(outer_angle)\n sin_outer_angle = sin(outer_angle)\n inner_angle = 0.\n for j in range(inner_slices):\n cos_inner_angle = cos(inner_angle)\n sin_inner_angle = sin(inner_angle)\n\n diameter = (radius + inner_radius * cos_inner_angle)\n vertex_x = diameter * cos_outer_angle\n vertex_y = diameter * sin_outer_angle\n vertex_z = inner_radius * sin_inner_angle\n\n normal_x = cos_outer_angle * cos_inner_angle\n normal_y = sin_outer_angle * cos_inner_angle\n normal_z = sin_inner_angle\n\n vertices.extend([vertex_x, vertex_y, vertex_z])\n normals.extend([normal_x, normal_y, normal_z])\n inner_angle += inner_angle_step\n outer_angle += outer_angle_step\n\n # Create ctypes arrays of the lists\n vertices = (gl.GLfloat *len(vertices))(*vertices)\n normals = (gl.GLfloat * len(normals))(*normals)\n\n # Create a list of triangle indices.\n indices = []\n for i in range(slices - 1):\n for j in range(inner_slices - 1):\n pos = i * inner_slices + j\n indices.extend([pos, pos + inner_slices, pos + inner_slices +\n 1])\n indices.extend([pos, pos + inner_slices + 1, pos + 1])\n indices = (gl.GLuint * len(indices))(*indices)\n\n # Compile a display list\n self.list = gl.glGenLists(1)\n gl.glNewList(self.list, gl.GL_COMPILE)\n self.color.gl_set(self.opacity)\n\n gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)\n gl.glEnableClientState(gl.GL_VERTEX_ARRAY)\n gl.glEnableClientState(gl.GL_NORMAL_ARRAY)\n self.model_world_transform(scene.gcf,\n Vector([self.radius, self.radius,\n self.radius])).gl_mult()\n\n gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)\n gl.glNormalPointer(gl.GL_FLOAT, 0, normals)\n gl.glDrawElements(gl.GL_TRIANGLES, len(indices), gl.GL_UNSIGNED_INT,\n indices)\n gl.glPopClientAttrib()\n\n gl.glEndList()\n gl.glCallList(self.list)","def planeSliceGFig2(uxmax, uymax, rF2, lc, ax, ay, m, n, npoints = 3000, gsizex = 2048, gsizey = 2048, comp = True):\n\n # Calculate coefficients\n alp = rF2*lc\n coeff = alp*np.array([1./ax**2, 1./ay**2])\n uF2x, uF2y = rF2*np.array([1./ax**2, 1./ay**2])\n\n # Calculate caustic intersections\n ucross = polishedRoots(causticEqSlice, uxmax, uymax, args = (alp, m, n, ax, ay))\n ncross = len(ucross)\n upcross = mapToUp(ucross.T, alp, ax, ay)\n p = np.argsort(upcross[0])\n upcross = upcross.T[p]\n ucross = ucross[p]\n print(upcross)\n print(ucross)\n\n # Calculate sign of second derivative at caustics\n sigs = np.zeros(ncross)\n for i in range(ncross):\n sigs[i] = np.sign(ax**2/rF2 + lc*(lensh(*[ucross[i][0], ucross[i][1]])[0]))\n print(sigs)\n\n # Set up quantities for proper u' plane slicing\n ymin = -m*uxmax + n\n ymax = m*uxmax + n\n if ymin < -uymax:\n xmin = (-uymax - n)/m\n ymin = m*xmin + n\n else:\n xmin = -uxmax\n if ymax > uymax:\n xmax = (uymax - n)/m\n ymax = m*xmax + n\n else:\n xmax = uxmax\n xx = np.linspace(gridToPixel(xmin, uxmax, gsizex/2), gridToPixel(xmax, uxmax, gsizex/2) - 1, gsizex)\n yy = np.linspace(gridToPixel(ymin, uymax, gsizey/2), gridToPixel(ymax, uymax, gsizey/2) - 1, gsizey)\n\n cdist = uxmax/(np.abs(100*lc))\n print(cdist)\n\n bound = np.insert(upcross, 0, np.array([[xmin, ymin]]), axis = 0) # set up boundaries\n bound = np.append(bound, np.array([[xmax, ymax]]), axis = 0)\n midpoints = [(bound[i] + bound[i+1])/2. for i in range(len(bound) - 1)] # find middle point between boundaries\n nzones = len(midpoints)\n nreal = np.zeros(nzones, dtype = int)\n print(nzones)\n for i in range(nzones): # find number of roots at each midpoint\n mpoint = midpoints[i]\n nreal[i] = int(len(findRoots(lensEq, 2*uxmax, 2*uymax, args = (mpoint, coeff), N = 1000)))\n upxvecs = np.array([np.linspace(bound[i-1][0] + cdist, bound[i][0] - cdist, npoints) for i in range(1, ncross + 2)]) # generate upx vector\n segs = np.asarray([lineVert(upx, m, n) for upx in upxvecs]) # generate slice across plane\n if comp == True:\n diff = difference(nreal) # determine number of complex solutions\n ncomplex = np.ones(nzones)*100\n for i in range(nzones):\n if diff[i] == 0 or diff[i] == -2:\n ncomplex[i] = 1\n elif diff[i] == -4:\n ncomplex[i] = 2\n elif diff[i] == 4:\n ncomplex[i] = 0\n else:\n ncomplex = np.zeros(nzones)\n \n print(nreal)\n print(ncomplex)\n\n # Solve lens equation at each coordinate\n allroots = rootFinder(segs, nreal, ncomplex, npoints, ucross, uxmax, uymax, coeff)\n \n # Calculate fields\n allfields = []\n for i in range(nzones):\n fields = obsCalc(GOfield, allroots[i], len(allroots[i][0]), npoints, 1, args=(rF2, lc, ax, ay))\n allfields.append(fields)\n \n fogain = np.zeros([nzones, npoints])\n zogain = np.zeros([nzones, npoints])\n for i in range(nzones):\n nroots = nreal[i]\n if nroots == 1:\n fogain[i] = np.abs(allfields[i])**2\n zogain[i] = np.abs(allfields[i])**2\n else:\n fogain[i] = np.abs(np.sum(allfields[i], axis = 0))**2\n zog = 0\n for j in range(nroots):\n zog = zog + np.abs(allfields[i][j])**2\n zogain[i] = zog\n \n fogain = fogain.flatten()\n zogain = zogain.flatten()\n\n # Construct uniform asymptotics\n # asymp = uniAsymp(allroots, allfields, nreal, ncomplex, npoints, nzones, sigs)\n # interp = UnivariateSpline(upxvecs.flatten(), asymp, s = 0)\n # finx = np.linspace(xmin, xmax, 4*npoints)\n # asymG = interp(finx)\n\n # KDI\n rx = np.linspace(-2*uxmax, 2*uxmax, gsizex)\n ry = np.linspace(-2*uymax, 2*uymax, gsizey)\n dux = 4*uxmax/gsizex\n duy = 4*uymax/gsizey\n extent = (-uxmax, uxmax, -uymax, uymax)\n ux, uy = np.meshgrid(rx, ry)\n lens = lensPhase(ux, uy, lc)\n lensfft = fft2(lens)\n geo = geoPhase(ux, uy, uF2x, uF2y)\n geofft = fft2(geo)\n fieldfft = lensfft*geofft\n field = fftshift(ifft2(fieldfft))\n soln = np.abs((dux*duy*field)**2/(4*pi**2*uF2x*uF2y))\n soln = soln[int(0.25*gsizex):int(0.75*gsizex), int(0.25*gsizey):int(0.75*gsizey)]\n\n # Plots\n fig = plt.figure(figsize = (15, 6), dpi = 100)\n grid = gs.GridSpec(2, 2)\n # grid = gs.GridSpec(1, 2)\n # tableax = plt.subplot(grid[1, :])\n # tableax2 = plt.subplot(grid[2, :])\n ax0, ax1 = plt.subplot(grid[:, 0]), plt.subplot(grid[0, 1])\n # ax0, ax2 = plt.subplot(grid[0]), plt.subplot(grid[1])\n ax2 = plt.subplot(grid[1, 1], sharex=ax1)\n\n rx = np.linspace(-uxmax, uxmax, gsizex)\n ry = np.linspace(-uymax, uymax, gsizey)\n ux, uy = np.meshgrid(rx, ry)\n\n rx2 = np.linspace(xmin, xmax, gsizex)\n im0 = ax0.imshow(soln, origin = 'lower', extent = extent, aspect = 'auto') # Plot entire screen\n cbar = fig.colorbar(im0, ax = ax0)\n cbar.set_label('G', fontsize = 18)\n cbar.ax.tick_params(labelsize=14)\n ucaus = causCurve([ux, uy], lc*np.array([uF2x, uF2y]))\n cs = plt.contour(np.linspace(-uxmax, uxmax, gsizex), ry, ucaus, levels = [0, np.inf], linewidths = 0)\n paths = cs.collections[0].get_paths()\n uppaths = []\n for p in paths:\n cuvert = np.array(p.vertices).T\n upx, upy = mapToUp(cuvert, alp, ax, ay)\n ax0.plot(upx, upy, color = 'white') # Plot caustic curves\n ax0.scatter(upcross.T[0], upcross.T[1], color = 'white')\n ax0.plot(rx2, rx2*m + n, color = 'white') # Plot observer motion\n ax0.set_xlabel(r\"$u'_x$\", fontsize = 18)\n ax0.set_ylim([-uymax, uymax])\n ax0.set_xlim([-uxmax, uxmax])\n ax0.set_ylabel(r\"$u'_y$\", fontsize = 18)\n ax0.tick_params(labelsize = 14)\n # ax0.set_title(\"Gain in the u' plane\")\n\n G = map_coordinates(soln.T, np.vstack((xx, yy))) # Plot gain along observer motion\n G = G - G[-1] + 1\n ax1.plot(rx2, G, color = 'blue', label = \"FFT gain\", linewidth = 1.)\n for caus in upcross.T[0]:\n ax1.plot([caus, caus], [-10, 1000], ls = 'dashed', color = 'black')\n xaxis = upxvecs.flatten()\n ax1.plot(xaxis, zogain, color = 'red', label = r'$0^{th}$ order GO gain')\n ax1.set_ylim(-cdist, np.max(G) + 1.)\n ax1.set_xlim(np.min(rx2), np.max(rx2))\n # ax1.set_xlabel(r\"$u'_x$\")\n ax1.set_ylabel('G', fontsize = 18)\n ax1.legend(loc = 1, fontsize = 12)\n ax1.tick_params(labelsize = 14)\n # ax1.set_title(\"Slice Gain\")\n ax1.grid()\n \n # Plot gain along observer motion\n ax2.plot(rx2, G, color='blue', label=\"FFT gain\", linewidth=1.)\n for caus in upcross.T[0]:\n ax2.plot([caus, caus], [-10, 1000], ls='dashed', color='black')\n ax2.plot(xaxis, fogain, color='orange', label=r'$1^{st}$ order GO gain')\n ax2.set_ylim(-cdist, np.max(G) + 1.)\n ax2.set_xlim(np.min(rx2), np.max(rx2))\n ax2.set_xlabel(r\"$u'_x$\", fontsize = 18)\n ax2.set_ylabel('G', fontsize = 18)\n ax2.legend(loc = 1, fontsize = 12)\n # ax1.set_title(\"Slice Gain\")\n ax2.tick_params(labelsize = 14)\n ax2.grid()\n grid.tight_layout(fig)\n\n # col_labels = ['Parameter', 'Value'] # Create table with parameter values\n # if np.abs(dm/pctocm) < 1:\n # dmlabel = \"{:.2E}\".format(Decimal(dm/pctocm))\n # else:\n # dmlabel = str(dm/pctocm)\n # tablevals = [[r'$d_{so} \\: (kpc)$', np.around(dso/pctocm/kpc, 2)], [r'$d_{sl} \\: (kpc)$', np.around(dsl/pctocm/kpc, 3)], [r'$a_x \\: (AU)$', np.around(ax/autocm, 3)], [r'$a_y \\: (AU)$', np.around(ay/autocm, 3)], [r'$DM_l \\: (pc \\, cm^{-3})$', dmlabel], [r\"$\\nu$ (GHz)\", f/GHz], ['Slope', np.around(m, 2)], ['Offset', n]]\n # tableax.axis('tight')\n # tableax.axis('off')\n # table = tableax.table(cellText = np.asarray(tablevals).T, colWidths = np.ones(8)*0.045, rowLabels = col_labels, loc = 'center')\n # table.auto_set_font_size(False)\n # table.set_fontsize(11)\n # table.scale(2.5, 2.5)\n \n # row_label = ['Lens shape']\n # val = [['$%s$' % sym.latex(lensf)]]\n # tableax2.axis('tight')\n # tableax2.axis('off')\n # table2 = tableax2.table(cellText=val, colWidths=[0.0015*len(sym.latex(lensf))], rowLabels=row_label, loc='top')\n # table2.auto_set_font_size(False)\n # table2.set_fontsize(12)\n # table2.scale(2.5, 2.5)\n\n plt.show()\n return","def check_uv_border_crossing(progress_controller=None):\n if progress_controller is None:\n progress_controller = ProgressControllerBase()\n\n # skip if this is a representation\n v = staging.get(\"version\")\n if v and Representation.repr_separator in v.take_name:\n progress_controller.complete()\n return\n\n all_meshes = pm.ls(type=\"mesh\")\n mesh_count = len(all_meshes)\n progress_controller.maximum = mesh_count\n nodes_with_uvs_crossing_borders = []\n\n for node in all_meshes:\n all_uvs = node.getUVs()\n # before doing anything get all the uvs and skip if all of them are\n # in the same UV quadrant (which is the wrong name, sorry!)\n all_uvs_u = sorted(all_uvs[0])\n all_uvs_v = sorted(all_uvs[1])\n if int(all_uvs_u[0]) == int(all_uvs_u[-1]) and int(all_uvs_v[0]) == int(\n all_uvs_v[-1]\n ):\n # skip this mesh\n continue\n\n #\n # Group uvs according to their UV shells\n #\n # The following method is 20-25% faster than using getUvShellsIds()\n #\n num_uvs = node.numUVs()\n uv_ids = list(range(num_uvs))\n\n uv_shells_and_uv_ids = []\n uv_shells_and_uv_coords = []\n\n i = 0\n while len(uv_ids) and i < num_uvs + 1:\n current_uv_id = uv_ids[0]\n # the polyListComponentConversion takes 85% of the processing time\n # of getting the uvShells here\n shell_uv_group_ids = pm.polyListComponentConversion(\n \"%s.map[%s]\" % (node.name(), current_uv_id), toUV=1, uvShell=1\n )\n\n uv_shell_uv_ids = []\n uv_shell_uv_coords = [[], []]\n for uv_group_ids in shell_uv_group_ids:\n if \":\" in uv_group_ids:\n splits = uv_group_ids.split(\":\")\n start_uv_id = int(splits[0].split(\"[\")[1])\n end_uv_id = int(splits[1].split(\"]\")[0])\n else:\n splits = uv_group_ids.split(\"[\")\n start_uv_id = int(splits[1].split(\"]\")[0])\n end_uv_id = start_uv_id\n\n for j in range(start_uv_id, end_uv_id + 1):\n uv_ids.remove(j)\n uv_shell_uv_ids.append(j)\n uv_shell_uv_coords[0].append(all_uvs[0][j])\n uv_shell_uv_coords[1].append(all_uvs[1][j])\n\n # store the uv ids and uv coords in this shell\n uv_shells_and_uv_ids.append(uv_shell_uv_ids)\n uv_shells_and_uv_coords.append(uv_shell_uv_coords)\n\n # go to the next pseudo uv shell id\n i += 1\n\n # now check all uvs per shell\n try:\n for uv_shell_uv_coords in uv_shells_and_uv_coords:\n us = sorted(uv_shell_uv_coords[0])\n vs = sorted(uv_shell_uv_coords[1])\n\n # check first and last u and v values\n if int(us[0]) != int(us[-1]) or int(vs[0]) != int(vs[-1]):\n # they are not equal it is crossing spaces\n nodes_with_uvs_crossing_borders.append(node)\n break\n except (IndexError, RuntimeError) as e:\n print(\"%s\\nnode: %s\" % (e, node))\n raise RuntimeError()\n\n progress_controller.increment()\n\n progress_controller.complete()\n if len(nodes_with_uvs_crossing_borders):\n # get transform nodes\n tra_nodes = list(map(lambda x: x.getParent(), nodes_with_uvs_crossing_borders))\n pm.select(tra_nodes)\n raise RuntimeError(\n \"\"\"There are nodes with <b>UV-Shells</b> that are crossing\n <b>UV BORDERS</b>:<br><br>%s\"\"\"\n % \"<br>\".join(map(lambda x: x.name(), tra_nodes[:MAX_NODE_DISPLAY]))\n )","def clean_line_with_uvt_mask(cfg, spw, fullcube=False, parallel=True):\n log_post(':: Running clean with uv-taper ({0}, {1})'.format(targ.name, spw.name))\n imagename = cfg.get_basename(spw, ext='smask')\n maskname = cfg.get_basename(spw, ext='uvtaper') + '.image.smask'\n spw_id = cfg.get_spw_id(spw)\n # restart parameters\n if not fullcube and spw.line_win != -1:\n start = spw.nchan // 2 - spw.line_win\n nchan = spw.line_win * 2\n else:\n start = -1\n nchan = -1\n delete_all_extensions(imagename)\n tclean(\n vis=cfg.vis,\n imagename=imagename,\n field=targ.name,\n spw=spw_id,\n specmode='cube',\n outframe='lsrk',\n veltype='radio',\n restfreq=spw.restfreq,\n start=start,\n nchan=nchan,\n imsize=cfg.array_config.imsize,\n cell=cfg.array_config.cell,\n # gridder parameters\n gridder='standard',\n # deconvolver parameters\n deconvolver='multiscale',\n scales=[0, 5, 10], # point, 1, 2 beam hpbw's\n smallscalebias=0.6,\n restoringbeam='common',\n weighting='briggs',\n robust=2.0,\n niter=int(1e6),\n nsigma=2.0,\n interactive=False,\n parallel=parallel,\n # mask from smoothed uv-taper\n usemask='user',\n mask=maskname,\n verbose=True,\n )\n workdir = '{0}.workdirectory'.format(imagename)\n if os.path.exists(workdir):\n shutil.rmtree(workdir)","def CreateLandmask(Fieldset, test = False):\n \n \n \"\"\"\n This first set of lines creates a numpy array with u velocities and a numpy\n array with v velocities. First we get the U and V fields from the dataset. Then\n we compute a time chunk, which is needed because of the dataset. Then we only\n take the first slice of the U and V field (we do not need more for finding the land\n and ocean grids). As last we make an empty array which will be filled with zeros and \n ones.\n \"\"\"\n fU = Fieldset.U\n fV = Fieldset.V\n Fieldset.computeTimeChunk(fU.grid.time[0], 1) \n uvel_mask_c = fU.data[0,:,:] \n vvel_mask_c = fV.data[0,:,:]\n# vvel_mask_c = np.roll(vvel_mask_c, 1, axis = 0)\n landmask = np.zeros((uvel_mask_c.shape[0], uvel_mask_c.shape[1]))\n \n \"\"\"\n The first loop checks the value of the u and v velocitites. Notice that we get the\n values of two adjacent grid, since we're working with a C-grid.\n Visualizations of velocities in the C-grids(see below). So for a grid to be flagged identified\n as a land grid two U velocities and 2 V velocities need to be zero. The first loop makes all\n ocean grids 1 and land grids 0. \n ____ ____ ____ ____\n | V | V | \n | | | \n U T U T U\n | | | \n |____V____|_____V_____| \n \"\"\"\n \n for i in range (len(landmask[:,0])-1):\n for j in range (len(landmask[0,:])-1):\n u1 = uvel_mask_c[i,j]\n\n u2 = uvel_mask_c[i,j+1]\n\n v1 = vvel_mask_c[i,j]\n\n v2 = vvel_mask_c[i+1,j]\n\n if u1 != 0 or u2 != 0 or v1 != 0 or v2 != 0:\n landmask[i,j] = 1\n \n \n \"\"\"\n Change all zero to 1 and rest 0. since we want the land grids to be 1 and ocean\n grids to be 0. \n \"\"\"\n \n landmask = ChangeValues(landmask,0,1) \n \n \"\"\"\n The created landmask needs to be shifted upwards one grid. We will\n use the numpy roll function to do this.\n \"\"\"\n \n if test == True:\n plt.figure()\n plt.imshow(landmask)\n plt.colorbar()\n \n return landmask","def test_uv_degrid():\n\n layout = read_layout(layout_path=f\"{test_data}/test_mwa.txt\")\n xyz = enh_xyz(layout=layout, latitude=mwa_geo.latitude.radians)\n uvw = xyz_uvw(xyz=xyz, freq=freq, dec0=mwa_geo.latitude.radians, ha0=0)\n uv = uv_degrid(max_lambda=1400, nside=20, uvw=uvw, sigma=3, kersize=21, kernel=None)\n\n assert uv.shape == (20, 20)\n assert uv[0, 0] == 0.0","def set_vx_to_vx_or_vy(self, cpu):\n for x in range(0x0, 0xF):\n for y in range(0x0, 0xF):\n if x != y:\n cpu.opcode = 0x8001 | (x << 8) | (y << 4)\n for v1 in range(0x0, 0xFF):\n for v2 in range(0x0, 0xFF):\n cpu.V_register[x] = v1\n cpu.V_register[y] = v2\n cpu.set_vx_to_vx_or_vy()\n assert(cpu.V_register[x] == v1 | v2)","def test_set_vx_to_vx_or_vy(self, cpu):\n for x in range(0x0, 0xF):\n for y in range(0x0, 0xF):\n if x != y:\n cpu.opcode = 0x8003 | (x << 8) | (y << 4)\n for v1 in range(0x0, 0xFF):\n for v2 in range(0x0, 0xFF):\n cpu.V_register[x] = v1\n cpu.V_register[y] = v2\n cpu.set_vx_to_vx_or_vy()\n assert(cpu.V_register[x] == v1 | v2)","def draw_vectors(self):\r\n for v in self.vehicles:\r\n pg.draw.line(self.screen, (0, 255, 0), v.pos, v.pos + v.extent, 1)\r\n pg.draw.circle(self.screen, (0, 255, 0),\r\n (int(v.pos.x + v.extent.x),\r\n int(v.pos.y + v.extent.y)), 30, 1)\r\n start = v.pos + v.extent\r\n end = v.target\r\n d = end - start\r\n if d.length_squared() < 2000:\r\n pg.draw.line(self.screen, (0, 255, 0), start, end, 1)","def InterpolateSurfaceVectors():\r\n \r\n # Load Surface Mesh Data and generate normals\r\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\r\n header, PointData, PolygonData = CreateMatrixVTK(VTKString)\r\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\r\n # Load full volume centroid\r\n NCF_Str = OpenData(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\",\"new_centroids_file.dat\")\r\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\r\n \r\n # Interpolate Vectors\r\n Vectors2 = VectorInter(Centroids1,Vectors1,Centroids2)\r\n # Make the data sparser to display better.\r\n C1,V1 = SparseData(Centroids1,Vectors1,0.2)\r\n C2,V2 = SparseData(Centroids2,Vectors2,0.2)\r\n\r\n # Plot Data\r\n fig = plt.figure()\r\n\r\n ax1 = fig.add_subplot(121,projection = '3d')\r\n DisplaySliceVectors(C1,V1,ax1,1,10)\r\n\r\n ax2 = fig.add_subplot(122,projection = '3d')\r\n DisplaySliceVectors(C2,V2,ax2,1,10)\r\n\r\n plt.show()\r\n\r\n header = 'TITLE = \\\"Normal Surface Vectors\\\"\\nVARIABLES = \\\"XV\\\", \\\"YV\\\", \\\"ZV\\\" \\nZONE T=\\\"Step 0 Incr 0\\\" \\nF = VECTORS'\r\n\r\n np.savetxt(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/NormalVectorInterpolation.dat\",Vectors2,header = header,comments='')","def run():\n\n def assignToon(context):\n def instanciate_group(nodes, group_name):\n group = nodes.new(type='ShaderNodeGroup')\n group.node_tree = bpy.data.node_groups[group_name]\n return group\n\n def assignToonShader(material):\n '''To do Handle if the material output doesnt exist'''\n toonShader = instanciate_group(material.node_tree.nodes, \"ToonShader_2\")\n node2 = material.node_tree.nodes['Material Output']\n material.node_tree.links.new(toonShader.outputs[0], node2.inputs[0])\n\n objects = bpy.context.selected_objects\n for obj in objects:\n if len(obj.material_slots) < 1:\n\n bpy.ops.object.material_slot_add()\n\n if obj.name not in bpy.data.materials:\n\n mat = bpy.data.materials.new(obj.name)\n else:\n mat = bpy.data.materials[obj.name]\n\n obj.data.materials[0] = mat\n mat.use_nodes = True\n\n for mat in obj.data.materials:\n if mat.name == '':\n mat.name = obj.name\n\n matNodes = mat.node_tree.nodes\n\n assignToonShader(mat)\n if 'Principled BSDF' in matNodes:\n matNodes.remove(matNodes['Principled BSDF'])\n # else:\n # for n in matNodes:\n # if n != material.node_tree.nodes['Material Output']:\n # matNodes.remove(n)\n\n\n shaderPath = r'D:/COMPANIES/loneCoconut/render/MILVIO_CGL/assets/lib/TOONSCEENSETUP/shd/publish/001.000/high/lib_TOONSCEENSETUP_shd.blend'\n collection_name = 'ToonSceneSetup'\n # dict_ = {'company': 'loneCoconut',\n # 'context': 'render',\n # 'project': 'MILVIO',\n # 'scope': 'assets',\n # 'seq': 'lib',\n # 'shot': 'TOONSCEENSETUP',\n # 'task': 'shd',\n # 'user': 'publish',\n # 'resolution': 'high'}\n # shaderPath = lm.LumberObject(dict_)\n # print(shaderPath.latest_version().path_root)\n #\n # collection_name = shaderPath.shot\n\n if collection_name not in bpy.data.collections:\n\n # link all collections starting with 'MyCollection'\n with bpy.data.libraries.load(shaderPath, link=False) as (data_from, data_to):\n data_to.collections = [c for c in data_from.collections if c.startswith(collection_name)]\n\n # link collection to scene collection\n for coll in data_to.collections:\n if coll is not None:\n bpy.data.scenes['Scene'].collection.children.link(coll)\n\n else:\n print(\"Toon Shader Exist\")\n\n\n assignToon(bpy.context)","def test_set_vx_to_vx_and_vy(self, cpu):\n for x in range(0x0, 0xF):\n for y in range(0x0, 0xF):\n if x != y:\n cpu.opcode = 0x8002 | (x << 8) | (y << 4)\n for v1 in range(0x0, 0xFF):\n for v2 in range(0x0, 0xFF):\n cpu.V_register[x] = v1\n cpu.V_register[y] = v2\n cpu.set_vx_to_vx_and_vy()\n assert(cpu.V_register[x] == v1 & v2)","def makeVideo(self):\n \n #from morphforge.morphology.util import TriMeshBuilderVerySimple\n import sys\n sys.path.append('/usr/share/pyshared/')\n \n #import morphforge\n from morphforge.morphology.mesh import MeshBuilderRings\n MonkeyPatchMayaVi()\n #import enthought.mayavi.mlab as mlab\n from mayavi import mlab\n \n assert len(self.morphs)==1\n mesh = MeshBuilderRings().build(self.morphs[0])\n \n \n #mlab.options.offscreen = True\n \n \n @mlab.show\n @mlab.animate(delay=100 )#, ui=False) #(delay=500, ui=False)\n def _showSimpleCylinders():\n \n f = mlab.figure( bgcolor=None, fgcolor=None, engine=None, size=(1024, 768))\n #f = mlab.gcf() \n #c = TriMeshBuilderVerySimple(self.morphs[0])\n #mlab.triangular_mesh(c.x, c.y, c.z, c.triangles, colormap=self.colormap)\n mlab.triangular_mesh(mesh.vertices[:,0], mesh.vertices[:,1], mesh.vertices[:,2], mesh.triangles, colormap=self.colormap)\n \n for i in itertools.count():\n print i\n f.scene.camera.azimuth(0.1)\n mlab.savefig('/home/michael/Desktop/out/O%04d.png'%i)#, size=(1024,768))\n f.scene.render()\n if i> 3600:\n break\n yield\n \n _showSimpleCylinders()","def pov_render(self, camera_position = (0,0,-10), camera_target = (0,0,0)):\n\n \"\"\"\n f=pov.File(\"demo.pov\",\"colors.inc\",\"stones.inc\")\n \n cam = pov.Camera(location=camera_position, sky=(1,0,1),look_at=camera_target)\n light = pov.LightSource( camera_position, color=\"White\")\n \n povObjs = [cam, light]\n for obj in self.objects[1:]:\n # test coordinate transfroms\n # print M\n # vectors = np.array([[0,0,0,1], #origin\n # [1,0,0,1], # x\n # [0,1,0,1], # y\n # [0,0,1,1]]).transpose() # z\n # origin,x,y,z = (T*vectors).transpose()\n povObjs.append(povObj(obj))\n \n #print tuple(povObjs)\n f.write(*tuple(povObjs))\n f.close()\n #sphere1 = pov.Sphere( (1,1,2), 2, pov.Texture(pov.Pigment(color=\"Yellow\")))\n #sphere2 = pov.Sphere( (0,1,2), 2, pov.Texture(pov.Pigment(color=\"Yellow\")))\n # composite2 = None#pov.Difference(sphere1, sphere2)\n # \n \n \n \n \n \n # f.write( cam, composite2, light )\n # f.close()\n subprocess.call(\"povray +H2400 +W3200 demo.pov\", shell=True)\n os.system(\"open demo.png\")\n \"\"\"","def test_set_vx_to_vx_minus_vy(self, cpu):\n for x in range(0x0, 0xF):\n for y in range(0x0, 0xF):\n if x != y:\n cpu.opcode = 0x8005 | (x << 8) | (y << 4)\n for v1 in range(0x0, 0xFF):\n for v2 in range(0x0, 0xFF):\n cpu.V_register[x] = v1\n cpu.V_register[y] = v2\n cpu.set_vx_to_vx_minus_vy()\n value = v1 - v2\n if value > 0:\n assert(cpu.V_register[0xF] == 1)\n else:\n assert(cpu.V_register[0xF] == 0)\n if value >= 0:\n assert(cpu.V_register[x] == value)\n else:\n assert(cpu.V_register[x] == 0x100 + value)","def __concatenate_planes_to_444yuv_frame(self, y_plane, u_plane, v_plane):\n np.set_printoptions(formatter={'int': hex})\n\n y_plane.shape = (self.frame_height, self.frame_width, 1)\n u_plane.shape = (self.frame_height, self.frame_width, 1)\n v_plane.shape = (self.frame_height, self.frame_width, 1)\n\n yuv = np.concatenate((y_plane, u_plane, v_plane), axis=2)\n\n # Use OpenCV to convert color since the implementation is MUCH faster\n if self.__convert_to_bgr:\n yuv = cv.cvtColor(yuv, cv.COLOR_YUV2BGR)\n\n return yuv","def gen_dtu_mvs_path(dtu_data_folder, mode='training'):\n sample_list = []\n \n # parse camera pairs\n cluster_file_path = dtu_data_folder + '/Cameras/pair.txt'\n cluster_list = open(cluster_file_path).read().split()\n\n # 3 sets\n training_set = [2, 6, 7, 8, 14, 16, 18, 19, 20, 22, 30, 31, 36, 39, 41, 42, 44,\n 45, 46, 47, 50, 51, 52, 53, 55, 57, 58, 60, 61, 63, 64, 65, 68, 69, 70, 71, 72,\n 74, 76, 83, 84, 85, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,\n 101, 102, 103, 104, 105, 107, 108, 109, 111, 112, 113, 115, 116, 119, 120,\n 121, 122, 123, 124, 125, 126, 127, 128]\n validation_set = [3, 5, 17, 21, 28, 35, 37, 38, 40, 43, 56, 59, 66, 67, 82, 86, 106, 117]\n evaluation_set = [1, 4, 9, 10, 11, 12, 13, 15, 23, 24, 29, 32, 33, 34, 48, 49, 62, 75, 77, \n 110, 114, 118]\n\n # for each dataset\n data_set = []\n if mode == 'training':\n data_set = training_set\n elif mode == 'validation':\n data_set = validation_set\n elif mode == 'evaluation':\n data_set = evaluation_set\n\n # for each dataset\n for i in data_set:\n\n image_folder = os.path.join(dtu_data_folder, ('Rectified/scan%d' % i))\n cam_folder = os.path.join(dtu_data_folder, 'Cameras')\n depth_folder = os.path.join(dtu_data_folder, ('Depths/scan%d' % i))\n\n if mode == 'training':\n # for each lighting\n for j in range(0, 7):\n # for each reference image\n for p in range(0, int(cluster_list[0])):\n paths = []\n # ref image\n ref_index = int(cluster_list[22 * p + 1])\n ref_image_path = os.path.join(\n image_folder, ('rect_%03d_%d_r5000.png' % ((ref_index + 1), j)))\n ref_cam_path = os.path.join(cam_folder, ('%08d_cam.txt' % ref_index))\n paths.append(ref_image_path)\n paths.append(ref_cam_path)\n # view images\n for view in range(FLAGS.view_num - 1):\n view_index = int(cluster_list[22 * p + 2 * view + 3])\n view_image_path = os.path.join(\n image_folder, ('rect_%03d_%d_r5000.png' % ((view_index + 1), j)))\n view_cam_path = os.path.join(cam_folder, ('%08d_cam.txt' % view_index))\n paths.append(view_image_path)\n paths.append(view_cam_path)\n # depth path\n depth_image_path = os.path.join(depth_folder, ('depth_map_%04d.pfm' % ref_index))\n paths.append(depth_image_path)\n sample_list.append(paths)\n else:\n # for each reference image\n j = 5\n for p in range(0, int(cluster_list[0])):\n paths = []\n # ref image\n ref_index = int(cluster_list[22 * p + 1])\n ref_image_path = os.path.join(\n image_folder, ('rect_%03d_%d_r5000.png' % ((ref_index + 1), j)))\n ref_cam_path = os.path.join(cam_folder, ('%08d_cam.txt' % ref_index))\n paths.append(ref_image_path)\n paths.append(ref_cam_path)\n # view images\n for view in range(FLAGS.view_num - 1):\n view_index = int(cluster_list[22 * p + 2 * view + 3])\n view_image_path = os.path.join(\n image_folder, ('rect_%03d_%d_r5000.png' % ((view_index + 1), j)))\n view_cam_path = os.path.join(cam_folder, ('%08d_cam.txt' % view_index))\n paths.append(view_image_path)\n paths.append(view_cam_path)\n # depth path\n depth_image_path = os.path.join(depth_folder, ('depth_map_%04d.pfm' % ref_index))\n paths.append(depth_image_path)\n sample_list.append(paths)\n \n return sample_list","def stempot(self,xmax,ymax,nx,ny,atms,pixelshift,scalefactor):\n #zed=2 for rutherford scattering of the nucleus, less for screening\n zed = 1.7\n\n ix = numpy.arange(1.0,nx)\n iy = numpy.arange(1.0,ny)\n dx = xmax/nx\n dy = ymax/ny\n rx = numpy.arange(0,xmax-dx,dx)\n ry = numpy.arange(0,ymax-dy,dy)\n\n Zatom = atms.get_atomic_numbers()\n #translate atoms such that the center of mass is in the center of the computational cell\n com = atms.get_center_of_mass()\n #com = [ 44.40963074 , 44.65497562 , 44.90406073] #for AuNP\n #com = numpy.array(com)\n #print 'com',com -0.149836425, 0.29967285, 0\n #com += [0.41205016875, 0.6742639125, 0] #for rotated line profile \n #com += [-0.149836425, 0.29967285, 0] #for AuNP\n #com += pixelshift\n #print 'com+pixelshift',com\n cop = xmax/2.0\n trans = [cop-i for i in com]\n atms.translate(trans)\n positions=atms.get_positions()\n ax=[]\n ay=[]\n az=[]\n for o,t,h in positions:\n ax.append(o)\n ay.append(t)\n az.append(h)\n ax = numpy.array(ax)\n ay = numpy.array(ay)\n az = numpy.array(az)\n amax = len(Zatom)\n\n #find boundaries of slice\n axmin = min(ax)\n axmax = max(ax)\n aymin = min(ay)\n aymax = max(ay)\n\n V= numpy.zeros((nx,ny))\n\n #map x and y coords of the atoms to the nearest grid points\n #A fraction of the atom must be assigned to the closest gridpoints\n #to avoid sum and difference frequencies appearing in the image\n #grid point to the left of the atom\n ix = numpy.array([math.floor(axi/dx) for axi in ax])\n #apply periodic boundary conditions\n iax = numpy.array([math.fmod(iaxi,nx) for iaxi in ix])\n ibx = numpy.array([math.fmod(iaxi+1,nx) for iaxi in ix])\n #fraction of atom at iax\n fax = numpy.array([1-math.fmod((axi/dx),1 ) for axi in ax])\n #grid point above the atom\n iy = numpy.array([math.floor(ayi/dy) for ayi in ay])\n #apply periodic boundary conditions\n iay = numpy.array([math.fmod(iayi,ny) for iayi in iy])\n iby = numpy.array([math.fmod(iayi+1,ny) for iayi in iy])\n #fraction of atom at iay \n fay = numpy.array([1-math.fmod((ayi/dy),1 ) for ayi in ay])\n #Add each atom to the potential grid\n V1 = numpy.array([fax[i] * fay[i] * (Zatom[i]**zed) for i in range(len(fax))])\n V2 = numpy.array([(1-fax[i]) * fay[i] * (Zatom[i]**zed) for i in range(len(fax))])\n V3 = numpy.array([fax[i] * (1-fay[i]) * (Zatom[i]**zed) for i in range(len(fax))])\n V4 = numpy.array([(1-fax[i]) * (1-fay[i]) * (Zatom[i]**zed) for i in range(len(fax))])\n #V1 = numpy.array([fax[i] * fay[i] * scalefactor for i in range(len(fax))])\n #V2 = numpy.array([(1-fax[i]) * fay[i] * scalefactor for i in range(len(fax))])\n #V3 = numpy.array([fax[i] * (1-fay[i]) * scalefactor for i in range(len(fax))])\n #V4 = numpy.array([(1-fax[i]) * (1-fay[i]) * scalefactor for i in range(len(fax))])\n\n for j in range(amax):\n V[iax[j],iay[j]] += V1[j]\n V[ibx[j],iay[j]] += V2[j]\n V[iax[j],iby[j]] += V3[j]\n V[ibx[j],iby[j]] += V4[j]\n rev_trans = [-1.0*i for i in trans]\n atms.translate(rev_trans)\n return V","def test_set_vx_to_vy_minus_vx(self, cpu):\n for x in range(0x0, 0xF):\n for y in range(0x0, 0xF):\n if x != y:\n cpu.opcode = 0x8007 | (x << 8) | (y << 4)\n for v1 in range(0x0, 0xFF):\n for v2 in range(0x0, 0xFF):\n cpu.V_register[x] = v1\n cpu.V_register[y] = v2\n cpu.set_vx_to_vy_minus_vx()\n value = v2 - v1\n if value > 0:\n assert(cpu.V_register[0xF] == 1)\n else:\n assert(cpu.V_register[0xF] == 0)\n if value >= 0:\n assert(cpu.V_register[x] == value)\n else:\n assert(cpu.V_register[x] == 0x100 + value)","def main_proc(self, ds=5.0):\n\n # Preprocessing\n # downsampling edge pixels\n pcd_t_ds = self.pcd_t.voxel_down_sample(voxel_size=ds)\n pcd_t_ds, center_t = centering(pcd_t_ds)\n self.result_id = 0\n reg_trans = None\n\n self.pcd_registrated = list() # results of ICP\n for i in range(len(self.pcd_s)):\n self.pcd_s[i].paint_uniform_color([0.0, 0.0, 1.0])\n pcd_s_ds = self.pcd_s[i].voxel_down_sample(voxel_size=ds)\n\n pcd_s_ds, center_s = centering(pcd_s_ds)\n ts_c = np.identity(4)\n ts_c[:3, 3] = -center_s\n tt_c = np.identity(4)\n tt_c[:3, 3] = center_t\n\n # Registration by ICP algorithm\n reg = ICPRegistration(pcd_s_ds, pcd_t_ds)\n reg.set_distance_tolerance(ds * 0.5)\n mse, rt = reg.registration()\n if mse < self.mse:\n self.result_id = i\n print(\"Init:\", self.initial_angles[i], self.mse, \"==>\", mse)\n self.mse = mse\n reg_trans = rt\n TT = np.dot(reg_trans, ts_c)\n self.trans_final = np.dot(tt_c, TT)\n\n # check transformation progress\n \"\"\"\n hoge = copy.deepcopy(pcd_s_ds)\n hoge.paint_uniform_color([1,0,0])\n mesh_frame = o3d.geometry.TriangleMesh.create_coordinate_frame(size=100., origin=[0.0,0.0,0.0])\n o3d.visualization.draw_geometries( [mesh_frame,hoge, pcd_t_ds], width=640, height=500)\n hoge.transform( rt )\n o3d.visualization.draw_geometries( [mesh_frame,hoge, pcd_t_ds], width=640, height=500)\n \"\"\"\n\n self.pcds = reg.pcds\n self.d = reg.d\n # Get registration result\n # translation[x,y] and rotation\n _, _, rotate = mat2rpy(self.trans_final)\n print(\"Initial angle is:\", self.initial_angles[self.result_id])\n rotate = np.radians(self.initial_angles[self.result_id]) + rotate\n translation = self.trans_final[:2, 3]\n\n # Choose the direction that results in the smaller rotation\n if rotate > tau:\n rotate -= tau\n elif rotate < 0:\n rotate += tau\n\n self.rotate = rotate\n return self.rotate, translation, self.mse","def uvmap(self, p):\n pass","def planeSliceGFig3(uxmax, uymax, rF2, lc, ax, ay, m, n, npoints = 3000, gsizex = 2048, gsizey = 2048, comp = True):\n\n # Calculate coefficients\n alp = rF2*lc\n coeff = alp*np.array([1./ax**2, 1./ay**2])\n uF2x, uF2y = rF2*np.array([1./ax**2, 1./ay**2])\n\n # Calculate caustic intersections\n ucross = polishedRoots(causticEqSlice, uxmax, uymax, args = (alp, m, n, ax, ay))\n ncross = len(ucross)\n upcross = mapToUp(ucross.T, alp, ax, ay)\n p = np.argsort(upcross[0])\n upcross = upcross.T[p]\n ucross = ucross[p]\n print(upcross)\n print(ucross)\n\n # Calculate sign of second derivative at caustics\n sigs = np.zeros(ncross)\n for i in range(ncross):\n sigs[i] = np.sign(ax**2/rF2 + lc*(lensh(*[ucross[i][0], ucross[i][1]])[0]))\n print(sigs)\n\n # Set up quantities for proper u' plane slicing\n ymin = -m*uxmax + n\n ymax = m*uxmax + n\n if ymin < -uymax:\n xmin = (-uymax - n)/m\n ymin = m*xmin + n\n else:\n xmin = -uxmax\n if ymax > uymax:\n xmax = (uymax - n)/m\n ymax = m*xmax + n\n else:\n xmax = uxmax\n xx = np.linspace(gridToPixel(xmin, uxmax, gsizex/2), gridToPixel(xmax, uxmax, gsizex/2) - 1, gsizex)\n yy = np.linspace(gridToPixel(ymin, uymax, gsizey/2), gridToPixel(ymax, uymax, gsizey/2) - 1, gsizey)\n\n cdist = uxmax/(np.abs(100*lc))\n print(cdist)\n\n bound = np.insert(upcross, 0, np.array([[xmin, ymin]]), axis = 0) # set up boundaries\n bound = np.append(bound, np.array([[xmax, ymax]]), axis = 0)\n # print(bound)\n midpoints = [(bound[i] + bound[i+1])/2. for i in range(len(bound) - 1)] # find middle point between boundaries\n nzones = len(midpoints)\n nreal = np.zeros(nzones)\n print(nzones)\n for i in range(nzones): # find number of roots at each midpoint\n mpoint = midpoints[i]\n nreal[i] = len(findRoots(lensEq, 2*uxmax, 2*uymax, args = (mpoint, coeff), N = 1000))\n upxvecs = np.array([np.linspace(bound[i-1][0] + cdist, bound[i][0] - cdist, npoints) for i in range(1, ncross + 2)]) # generate upx vector\n # print(upxvecs)\n segs = np.asarray([lineVert(upx, m, n) for upx in upxvecs]) # generate slice across plane\n diff = difference(nreal) # determine number of complex solutions\n if comp == True:\n ncomplex = np.ones(nzones)*100\n for i in range(nzones):\n if diff[i] == 0 or diff[i] == -2:\n ncomplex[i] = 1\n elif diff[i] == -4:\n ncomplex[i] = 2\n elif diff[i] == 4:\n ncomplex[i] = 0\n else:\n ncomplex = np.zeros(nzones)\n \n print(nreal)\n print(ncomplex)\n\n # Solve lens equation at each coordinate\n allroots = rootFinder(segs, nreal, ncomplex, npoints, ucross, uxmax, uymax, coeff)\n \n # Calculate fields\n allfields = []\n for i in range(nzones):\n fields = obsCalc(GOfield, allroots[i], len(allroots[i][0]), npoints, 3, args=(rF2, lc, ax, ay))\n allfields.append(fields)\n\n # Construct uniform asymptotics\n asymp = uniAsymp(allroots, allfields, nreal, ncomplex, npoints, nzones, sigs)\n interp = UnivariateSpline(upxvecs.flatten(), asymp, s = 0)\n finx = np.linspace(xmin, xmax, 4*npoints)\n asymG = interp(finx)\n\n # KDI\n rx = np.linspace(-2*uxmax, 2*uxmax, gsizex)\n ry = np.linspace(-2*uymax, 2*uymax, gsizey)\n dux = 4*uxmax/gsizex\n duy = 4*uymax/gsizey\n extent = (-uxmax, uxmax, -uymax, uymax)\n ux, uy = np.meshgrid(rx, ry)\n lens = lensPhase(ux, uy, lc)\n lensfft = fft2(lens)\n geo = geoPhase(ux, uy, uF2x, uF2y)\n geofft = fft2(geo)\n fieldfft = lensfft*geofft\n field = fftshift(ifft2(fieldfft))\n soln = np.abs((dux*duy*field)**2/(4*pi**2*uF2x*uF2y))\n soln = soln[int(0.25*gsizex):int(0.75*gsizex), int(0.25*gsizey):int(0.75*gsizey)]\n\n # Plots\n fig = plt.figure(figsize = (15, 6), dpi = 100)\n grid = gs.GridSpec(1, 2)\n # tableax = plt.subplot(grid[1, :])\n # tableax2 = plt.subplot(grid[2, :])\n ax0, ax1 = plt.subplot(grid[0, 0]), plt.subplot(grid[0, 1])\n\n rx = np.linspace(-uxmax, uxmax, gsizex)\n ry = np.linspace(-uymax, uymax, gsizey)\n ux, uy = np.meshgrid(rx, ry)\n\n rx2 = np.linspace(xmin, xmax, gsizex)\n im0 = ax0.imshow(soln, origin = 'lower', extent = extent, aspect = 'auto') # Plot entire screen\n cbar = fig.colorbar(im0, ax = ax0)\n # cbar.set_label(r'$\\log{G}$', fontsize = 16)\n cbar.set_label('G', fontsize=18)\n cbar.ax.tick_params(labelsize=14)\n ucaus = causCurve([ux, uy], lc*np.array([uF2x, uF2y]))\n cs = plt.contour(np.linspace(-uxmax, uxmax, gsizex), ry, ucaus, levels = [0, np.inf], linewidths = 0)\n paths = cs.collections[0].get_paths()\n uppaths = []\n for p in paths:\n cuvert = np.array(p.vertices).T\n upx, upy = mapToUp(cuvert, alp, ax, ay)\n ax0.plot(upx, upy, color = 'white') # Plot caustic curves\n ax0.scatter(upcross.T[0], upcross.T[1], color = 'white')\n ax0.plot(rx2, rx2*m + n, color = 'white') # Plot observer motion\n ax0.set_xlabel(r\"$u'_x$\", fontsize = 18)\n ax0.set_ylim([-uymax, uymax])\n ax0.set_xlim([-uxmax, uxmax])\n ax0.set_ylabel(r\"$u'_y$\", fontsize = 18)\n ax0.tick_params(labelsize = 14)\n # ax0.set_title(\"Gain in the u' plane\")\n\n G = map_coordinates(soln.T, np.vstack((xx, yy))) # Plot gain along observer motion\n G = G - G[-1] + 1\n ax1.plot(rx2, G, color = 'blue', label = \"FFT gain\")\n for caus in upcross.T[0]:\n ax1.plot([caus, caus], [-10, 1000], ls = 'dashed', color = 'black')\n ax1.plot(finx, asymG, color = 'red', label = r\"$2^{nd}$ order GO gain\")\n ax1.set_ylim(-cdist, np.max(asymG) + 1.)\n ax1.set_xlim(np.min(rx2), np.max(rx2))\n ax1.set_xlabel(r\"$u'_x$\", fontsize = 18)\n ax1.set_ylabel('G', fontsize = 18)\n # ax1.set_title(\"Slice Gain\")\n ax1.tick_params(labelsize = 14)\n ax1.grid()\n ax1.legend(loc = 1, fontsize = 14)\n\n\n # col_labels = ['Parameter', 'Value'] # Create table with parameter values\n # if np.abs(dm/pctocm) < 1:\n # dmlabel = \"{:.2E}\".format(Decimal(dm/pctocm))\n # else:\n # dmlabel = str(dm/pctocm)\n # tablevals = [[r'$d_{so} \\: (kpc)$', np.around(dso/pctocm/kpc, 2)], [r'$d_{sl} \\: (kpc)$', np.around(dsl/pctocm/kpc, 3)], [r'$a_x \\: (AU)$', np.around(ax/autocm, 3)], [r'$a_y \\: (AU)$', np.around(ay/autocm, 3)], [r'$DM_l \\: (pc \\, cm^{-3})$', dmlabel], [r\"$\\nu$ (GHz)\", f/GHz], ['Slope', np.around(m, 2)], ['Offset', n]]\n # tableax.axis('tight')\n # tableax.axis('off')\n # table = tableax.table(cellText = np.asarray(tablevals).T, colWidths = np.ones(8)*0.045, rowLabels = col_labels, loc = 'center')\n # table.auto_set_font_size(False)\n # table.set_fontsize(11)\n # table.scale(2.5, 2.5)\n \n # row_label = ['Lens shape']\n # val = [['$%s$' % sym.latex(lensf)]]\n # tableax2.axis('tight')\n # tableax2.axis('off')\n # table2 = tableax2.table(cellText=val, colWidths=[0.0015*len(sym.latex(lensf))], rowLabels=row_label, loc='top')\n # table2.auto_set_font_size(False)\n # table2.set_fontsize(12)\n # table2.scale(2.5, 2.5)\n\n grid.tight_layout(fig, pad = 1.5)\n plt.show()\n return","def project (u, v):\r\n\r\n # Construct linear system Ap = d\r\n A = sps.lil_matrix ((width*height, width*height))\r\n d = np.zeros ((width*height))\r\n\r\n for i in range (1, height-1):\r\n for j in range (1, width-1):\r\n A[index(i,j), index(i,j)] = 4\r\n A[index(i,j), index(i-1,j)] = -1\r\n A[index(i,j), index(i+1,j)] = -1\r\n A[index(i,j), index(i,j-1)] = -1\r\n A[index(i,j), index(i,j+1)] = -1\r\n \r\n d[index(i,j)] = -1/h * (u[i,j] - u[i,j-1] + v[i,j] - v[i-1,j])\r\n\r\n # Unhandled boundary cases, we assume solid walls that don't move\r\n A[index(0,0), index(0,0)] = 2\r\n A[index(0,0), index(1,0)] = -1\r\n A[index(0,0), index(0,1)] = -1\r\n d[index(0,0)] = -1/h * (u[0,0] + v[0,0])\r\n\r\n A[index(height-1,0), index(0,0)] = 2\r\n A[index(height-1,0), index(height-1,1)] = -1\r\n A[index(height-1,0), index(height-2,0)] = -1\r\n d[index(height-1,0)] = -1/h * (u[height-1,0] - v[height-2,0])\r\n\r\n A[index(0,width-1), index(0,width-1)] = 2\r\n A[index(0,width-1), index(1,width-1)] = -1\r\n A[index(0,width-1), index(0,width-2)] = -1\r\n d[index(0,width-1)] = -1/h * (-u[0,width-2] + v[0,width-1])\r\n\r\n A[index(height-1,width-1), index(height-1,width-1)] = 2\r\n A[index(height-1,width-1), index(height-2,width-1)] = -1\r\n A[index(height-1,width-1), index(height-1,width-2)] = -1\r\n d[index(height-1,width-1)] = -1/h * (-u[height-1,width-2] - v[height-2,width-1])\r\n\r\n\r\n for i in range (1, height-1):\r\n A[index(i,0), index(i,0)] = 3\r\n A[index(i,0), index(i-1,0)] = -1\r\n A[index(i,0), index(i+1,0)] = -1\r\n A[index(i,0), index(i,1)] = -1\r\n d[index(i,0)] = -1/h * (u[i,0] + v[i,0] - v[i-1,0])\r\n\r\n for i in range (1, height-1):\r\n A[index(i,width-1), index(i,width-1)] = 3\r\n A[index(i,width-1), index(i-1,width-1)] = -1\r\n A[index(i,width-1), index(i+1,width-1)] = -1\r\n A[index(i,width-1), index(i,width-2)] = -1\r\n d[index(i,width-1)] = -1/h * (- u[i,width-2] + v[i, width-1] - v[i-1,width-1])\r\n\r\n for j in range (1, width-1):\r\n A[index(0,j), index(0,j)] = 3\r\n A[index(0,j), index(1,j)] = -1\r\n A[index(0,j), index(0,j-1)] = -1\r\n A[index(0,j), index(0,j+1)] = -1\r\n d[index(0,j)] = -1/h * (u[0,j] - u[0,j-1] + v[0,j])\r\n \r\n for j in range (1, width-1):\r\n A[index(height-1,j), index(height-1,j)] = 3\r\n A[index(height-1,j), index(height-2,j)] = -1\r\n A[index(height-1,j), index(height-1,j-1)] = -1\r\n A[index(height-1,j), index(height-1,j+1)] = -1\r\n d[index(height-1,j)] = -1/h * (u[height-1,j] - u[height-1,j-1] - v[height-2,j])\r\n\r\n\r\n A = A * dt / (density * h**2)\r\n\r\n A = sps.csr_matrix (A)\r\n p = np.reshape(spsolve (A, d), (height, width))\r\n\r\n # Calculate new velocity field based on this pressure field\r\n for i in range (height):\r\n for j in range (width):\r\n if (i == height-1 and j == width-1) or (i == height-1 and j == 0) or (i == 0 and j == width-1) or (i == 0 and j == 0):\r\n # Set vertical velocity to movement of solid wall 0\r\n u[i,j] = 0\r\n v[i,j] = 0\r\n elif i == height-1 or i == 0:\r\n u[i,j] = u[i,j] - dt / (density * h) * (p[i,j+1] - p[i,j])\r\n v[i,j] = 0\r\n elif j == width-1 or j == 0:\r\n u[i,j] = 0\r\n v[i,j] = v[i,j] - dt / (density * h) * (p[i+1,j] - p[i,j])\r\n else:\r\n u[i,j] = u[i,j] - dt / (density * h) * (p[i,j+1] - p[i,j])\r\n v[i,j] = v[i,j] - dt / (density * h) * (p[i+1,j] - p[i,j])\r\n\r\n # let's get some inflow\r\n u[4:12, 0] = 1\r\n\r\n return u, v, p","def prog(args):\r\n i_fname, o_fname, pedestal_params, split_list, Num_W = args\r\n mesh = stl.mesh.Mesh.from_file(i_fname)\r\n #rotate mesh since by default the rotation axis is along X\r\n mesh.rotate([0,1,0],np.pi/2)\r\n\r\n v_arr = np.round(np.vstack(mesh.vectors).astype(float), decimals=1)\r\n\r\n splt0_arr = np.array(split_list)\r\n splt1_arr = np.roll(splt0_arr,-1)\r\n\r\n pos = cf.cartesian2cylyndrical(v_arr, Num_W)\r\n\r\n #make splits\r\n pos_list=[]\r\n for splt0, splt1 in zip(splt0_arr[:-1], splt1_arr[:-1]):\r\n pos_idx = np.where((splt0<=pos[:,:,2]) & (splt1>pos[:,:,2]))[0]\r\n print(splt0, splt1)\r\n #pos = [r, th, z] sectionwise\r\n pos_list.append(pos[pos_idx])\r\n #add pedestal mesh\r\n\r\n for sect_num, pos in enumerate(pos_list):\r\n pos = cf.add_pedestal(pos, pedestal_params)\r\n profiles=np.zeros_like(pos)\r\n\r\n for i in np.arange(np.shape(pos)[0]):\r\n profiles[i] = cf.cylyndrical2cartesian(pos[i])\r\n\r\n strokes = np.flipud(np.rot90(profiles))\r\n #transform data from longeron nodes [xyz] to:\r\n #a_arr - rotation angle around the rotation axis\r\n #r_arr - length of a segment perpenticular to the rotation axis and corresponding lateral mesh edge\r\n #z_arr - corresponding z coordiantes\r\n #v_arr - direction vector of the coresponding lateral mesh edge\r\n a_arr, r_arr, z_arr, v_arr = cf.transform(strokes, add_pedestal_bottom=True,add_pedestal_top=True)\r\n\r\n #make a summary plots\r\n cf.plot_loft_paths(profiles)\r\n cf.plot_loft_paths(pos)\r\n cf.plot_surf(a_arr,z_arr,r_arr)\r\n\r\n #collect data to the dictionary longeron wise\r\n res_dict = {'a_arr':np.rot90(a_arr, k=-1),\r\n 'r_arr':np.rot90(r_arr, k=-1),\r\n 'z_arr':np.rot90(z_arr, k=-1),\r\n 'v_arr':np.rot90(v_arr, k=-1)}\r\n\r\n #save result dictionary\r\n if not o_fname:\r\n o_fname = i_fname\r\n\r\n fname='{}_{}.pickle'.format(o_fname, sect_num)\r\n with open(fname, 'wb') as f:\r\n # Pickle the 'data' dictionary using the highest protocol available.\r\n pickle.dump(res_dict, f, pickle.HIGHEST_PROTOCOL)\r\n\r\n print(fname, ' saved')","def unitQuad_Edge(lens, N=3):\n template = [ np.array([0,0]), np.array([lens[0], 0]), None, None ] #Template from which to generate other Quad Vertex Lists\n leftDegenerate = template.copy() #Left Limit of quad if you were to rotate edge 3 CCW about the origin until you no longer can\n rightDegenerate = template.copy() #Right Limit of quad if you were to rotate edge 2 CW about point 1 until you no longer can,\n # or alternatively, how far edge 3 can rotate CW until the quad is degenerate\n try:\n leftDegenerate[3] = np.array( circleIntersection(leftDegenerate[0], lens[3], leftDegenerate[1], lens[1]+lens[2]) )\n leftDegenerate[2] = ( lens[1] / (lens[2]+lens[1]) ) * (leftDegenerate[3]-leftDegenerate[1]) + leftDegenerate[1]\n except: \n leftDegenerate[3] = np.array([-lens[3],0])\n leftDegenerate[2] = np.array( circleIntersection(leftDegenerate[3], lens[2], leftDegenerate[1], lens[1]) )\n\n try:\n rightDegenerate[2] = np.array( circleIntersection(rightDegenerate[0], lens[2]+lens[3], rightDegenerate[1], lens[1]) )\n rightDegenerate[3] = ( lens[3] / (lens[3]+lens[2]) ) * rightDegenerate[2]\n except:\n rightDegenerate[2] = np.array([lens[0]+lens[1], 0])\n rightDegenerate[3] = np.array( circleIntersection(rightDegenerate[0], lens[3], rightDegenerate[2], lens[2]))\n \n rightOfOrigin = np.array([1,0]) #Theta = 0 on the Unit Circle\n thetaMin = angle_between(leftDegenerate[3], rightOfOrigin) #Angle of \n thetaMax = angle_between(rightDegenerate[3], rightOfOrigin)\n pitch = (thetaMax - thetaMin) / (N-1)\n\n result = []\n result.append(leftDegenerate) \n for i in range(1, N-1):\n result.append(template.copy())\n result[i][3] = lens[3]*unitCircPt(i*pitch+thetaMin)\n result[i][2] = np.array(circleIntersection( result[i][3], lens[2], result[i][1], lens[1]))\n result.append(rightDegenerate) \n\n return listify(result)","def voxelize1(self,points,triangles,slices, direction):\n\t\t\n\t\tself.dirction = direction\n\t\tself.vertices = points\n\t\tself.triangles = triangles\n\t\n\t\tllc,urc=self.find_boundbox(points) # find the lower left corner (llc) and upper right corner (urc) of the vertices\n\t\tself.llc = llc\n\t\tself.urc = urc\n\t\t\n\t\tsliceProto, res=self.prepare_voxel_slice(slices,llc,urc,direction) # create the prototype slice volume for the voxel slicing\n\t\tself.res = res\n\t\tself.sliceProto = sliceProto\n\t\t\n\t\tself.slicePoints, minPoints, maxPoints=self.point_list(res,llc,urc,direction) # prepare the list of points to slice at\n\t\n\t#partialVoxelSlicer=partial(voxel_slice,points=points,triangles=triangles,res=res,llc=llc,sliceProto=sliceProto) # prepare a single-input version of the voxel slicer for parallelization\n\t\n\t#pool=multiprocessing.Pool(processes=max(1,multiprocessing.cpu_count()-1)) \n\t\n\t#layers=pool.map(partialVoxelSlicer,slicePoints) # perform the voxel conversion\n\t\n\t#volume=numpy.array(layers,dtype='bool') # create the 3d volume\n\t\n\t#return volume\n\t\tlayersR = list()\n\t\tlayersG = list()\n\t\tlayersB = list()\n\t\tvolumeGeneral = list()\n\t\tself.boolLayers = list()\n\t\t#self.boolResult = list()\n\t\t#maxArray = numpy.amax(slicePoints, axis=0)\n\t\t#minArray = numpy.amin(slicePoints, axis=0)\n\t\tself.maxValue = maxPoints[direction]\n\t\tself.minValue = minPoints[direction]\n\t\tself.ratio = 255 / (self.maxValue - self.minValue)\n\t\tfor i in self.slicePoints:\n\t\t\tboolResult = self.voxel_slice(i, points, triangles, res, llc, sliceProto, direction)\n\t\t\tprint boolResult.shape\n\t\t\ttupleResultR = numpy.zeros(boolResult.shape, dtype=uint8)\n\t\t\ttupleResultG = numpy.zeros(boolResult.shape, dtype=uint8)\n\t\t\ttupleResultB = numpy.zeros(boolResult.shape, dtype=uint8)\n\t\t\t#tupleResult.astype(uint8)\n\t\t\tj = numpy.nditer(boolResult, flags=['multi_index'], op_flags=['readwrite'])\n\t\t\twhile not j.finished:\n\t\t\t\tif j[0] == True:\n\t\t\t\t\t#tupleResult[j.multi_index] = round((i[direction] - minValue) * self.ratio) + 1\n\t\t\t\t\t#tupleResult[j.multi_index] = 78\n\t\t\t\t\ttupleResultR[j.multi_index] = 0\n\t\t\t\t\ttupleResultG[j.multi_index] = 255\n\t\t\t\t\ttupleResultB[j.multi_index] = 255\t\t\t\t\t\n\t\t\t\telse:\n\t\t\t\t\ttupleResultR[j.multi_index] = 0\n\t\t\t\t\ttupleResultG[j.multi_index] = 0\n\t\t\t\t\ttupleResultB[j.multi_index] = 0\n\t\t\t\tj.iternext()\n\t\t\tself.boolLayers.append(boolResult)\n\t\t\tlayersR.append(tupleResultR)\n\t\t\tlayersG.append(tupleResultG)\n\t\t\tlayersB.append(tupleResultB)\n\t\tprint \"i got here\"\n\t\tvolumeR=numpy.array(layersR) # create the 3d volume\n\t\tvolumeG=numpy.array(layersG) \n\t\tvolumeB=numpy.array(layersB)\n\t\tvolumeGeneral.append(volumeR)\n\t\tvolumeGeneral.append(volumeG)\n\t\tvolumeGeneral.append(volumeB)\n\t\t\n\t\tf1=open('./cube.txt', 'w+')\n\t\tprint >> f1, self.boolLayers\n\t\treturn volumeGeneral","def planeSliceGnoKDI(uxmax, uymax, rF2, lc, ax, ay, m, n, npoints = 5000, comp = True):\n\n # Calculate coefficients\n alp = rF2*lc\n coeff = alp*np.array([1./ax**2, 1./ay**2])\n uF2x, uF2y = rF2*np.array([1./ax**2, 1./ay**2])\n\n # Calculate caustic intersections\n ucross = polishedRoots(causticEqSlice, uxmax, uymax, args = (alp, m, n, ax, ay))\n ncross = len(ucross)\n upcross = mapToUp(ucross.T, alp, ax, ay)\n p = np.argsort(upcross[0])\n upcross = upcross.T[p]\n ucross = ucross[p]\n print(upcross)\n print(ucross)\n\n # Calculate sign of second derivative at caustics\n sigs = np.zeros(ncross)\n for i in range(ncross):\n sigs[i] = np.sign(ax**2/rF2 + lc*(lensh(*[ucross[i][0], ucross[i][1]])[0]))\n print(sigs)\n\n # Set up quantities for proper u' plane slicing\n ymin = -m*uxmax + n\n ymax = m*uxmax + n\n if ymin < -uymax:\n xmin = (-uymax - n)/m\n ymin = m*xmin + n\n else:\n xmin = -uxmax\n if ymax > uymax:\n xmax = (uymax - n)/m\n ymax = m*xmax + n\n else:\n xmax = uxmax\n\n cdist = uxmax/(np.abs(50*lc))\n print(cdist)\n\n bound = np.insert(upcross, 0, np.array([[xmin, ymin]]), axis = 0) # set up boundaries\n bound = np.append(bound, np.array([[xmax, ymax]]), axis = 0)\n midpoints = [(bound[i] + bound[i+1])/2. for i in range(len(bound) - 1)] # find middle point between boundaries\n nzones = len(midpoints)\n nreal = np.zeros(nzones)\n print(nzones)\n for i in range(nzones): # find number of roots at each midpoint\n mpoint = midpoints[i]\n nreal[i] = len(findRoots(lensEq, 2*uxmax, 2*uymax, args = (mpoint, coeff), N = 1000))\n upxvecs = np.array([np.linspace(bound[i-1][0] + cdist, bound[i][0] - cdist, npoints) for i in range(1, ncross + 2)]) # generate upx vector\n segs = np.asarray([lineVert(upx, m, n) for upx in upxvecs]) # generate slice across plane\n diff = difference(nreal) # determine number of complex solutions\n if comp == True:\n ncomplex = np.ones(nzones)*100\n for i in range(nzones):\n if diff[i] == 0 or diff[i] == -2:\n ncomplex[i] = 1\n elif diff[i] == -4:\n ncomplex[i] = 2\n elif diff[i] == 4:\n ncomplex[i] = 0\n else:\n ncomplex = np.zeros(nzones)\n \n print(nreal)\n print(ncomplex)\n\n # Solve lens equation at each coordinate\n allroots = rootFinder(segs, nreal, ncomplex, npoints, ucross, uxmax, uymax, coeff)\n \n # Calculate fields\n allfields = []\n for i in range(nzones):\n fields = obsCalc(GOfield, allroots[i], len(allroots[i][0]), npoints, 3, args=(rF2, lc, ax, ay))\n allfields.append(fields)\n\n # Construct uniform asymptotics\n asymp = uniAsymp(allroots, allfields, nreal, ncomplex, npoints, nzones, sigs)\n interp = UnivariateSpline(upxvecs.flatten(), asymp, s = 0)\n finx = np.linspace(xmin, xmax, 4*npoints)\n asymG = interp(finx)\n\n # Plots\n fig = plt.figure(figsize = (6, 10))\n # grid = gs.GridSpec(1, 2)\n # tableax = plt.subplot(grid[1, :])\n # tableax2 = plt.subplot(grid[2, :])\n # ax0, ax1 = plt.subplot(grid[0, 0]), plt.subplot(grid[0, 1])\n\n # rx = np.linspace(-uxmax, uxmax, gsizex)\n # ry = np.linspace(-uymax, uymax, gsizey)\n # ux, uy = np.meshgrid(rx, ry)\n\n # rx2 = np.linspace(xmin, xmax, gsizex)\n # im0 = ax0.imshow(soln, origin = 'lower', extent = extent, aspect = 'auto') # Plot entire screen\n # cbar = fig.colorbar(im0, ax = ax0)\n # cbar.set_label(r'$\\log{G}$', fontsize = 16)\n # cbar.set_label('G', fontsize=16)\n # ucaus = causCurve([ux, uy], lc*np.array([uF2x, uF2y]))\n # cs = plt.contour(np.linspace(-uxmax, uxmax, gsizex), ry, ucaus, levels = [0, np.inf], linewidths = 0)\n # paths = cs.collections[0].get_paths()\n # uppaths = []\n # for p in paths:\n # cuvert = np.array(p.vertices).T\n # upx, upy = mapToUp(cuvert, alp, ax, ay)\n # ax0.plot(upx, upy, color = 'white') # Plot caustic curves\n # ax0.scatter(upcross.T[0], upcross.T[1], color = 'white')\n # ax0.plot(rx2, rx2*m + n, color = 'white') # Plot observer motion\n # ax0.set_xlabel(r\"$u'_x$\", fontsize = 16)\n # ax0.set_ylim([-uymax, uymax])\n # ax0.set_xlim([-uxmax, uxmax])\n # ax0.set_ylabel(r\"$u'_y$\", fontsize = 16)\n # ax0.set_title(\"Gain in the u' plane\")\n\n # G = map_coordinates(soln.T, np.vstack((xx, yy))) # Plot gain along observer motion\n # G = G - G[-1] + 1\n fig = plt.figure(figsize = (7, 3), dpi = 100)\n ax1 = plt.subplot()\n # ax1.plot(rx2, G, color = 'blue', label = \"Gain from FFT\")\n for caus in upcross.T[0]:\n ax1.plot([caus, caus], [-10, 1000], ls = 'dashed', color = 'black')\n ax1.plot(finx, asymG, color = 'blue')\n ax1.set_ylim(-cdist, np.max(asymG) + 1.)\n ax1.set_xlim(xmin, xmax)\n ax1.set_xlabel(r\"$u'_x$\", fontsize = 16)\n ax1.set_ylabel('G', fontsize = 16)\n # ax1.set_title(\"Slice Gain\")\n ax1.grid()\n # ax1.legend(loc = 1)\n\n\n # col_labels = ['Parameter', 'Value'] # Create table with parameter values\n # if np.abs(dm/pctocm) < 1:\n # dmlabel = \"{:.2E}\".format(Decimal(dm/pctocm))\n # else:\n # dmlabel = str(dm/pctocm)\n # tablevals = [[r'$d_{so} \\: (kpc)$', np.around(dso/pctocm/kpc, 2)], [r'$d_{sl} \\: (kpc)$', np.around(dsl/pctocm/kpc, 3)], [r'$a_x \\: (AU)$', np.around(ax/autocm, 3)], [r'$a_y \\: (AU)$', np.around(ay/autocm, 3)], [r'$DM_l \\: (pc \\, cm^{-3})$', dmlabel], [r\"$\\nu$ (GHz)\", f/GHz], ['Slope', np.around(m, 2)], ['Offset', n]]\n # tableax.axis('tight')\n # tableax.axis('off')\n # table = tableax.table(cellText = np.asarray(tablevals).T, colWidths = np.ones(8)*0.045, rowLabels = col_labels, loc = 'center')\n # table.auto_set_font_size(False)\n # table.set_fontsize(11)\n # table.scale(2.5, 2.5)\n \n # row_label = ['Lens shape']\n # val = [['$%s$' % sym.latex(lensf)]]\n # tableax2.axis('tight')\n # tableax2.axis('off')\n # table2 = tableax2.table(cellText=val, colWidths=[0.0015*len(sym.latex(lensf))], rowLabels=row_label, loc='top')\n # table2.auto_set_font_size(False)\n # table2.set_fontsize(12)\n # table2.scale(2.5, 2.5)\n\n # grid.tight_layout(fig, pad = 1.5)\n plt.tight_layout()\n plt.show()\n return","def ccm_unred(wave, flux, ebv, r_v=\"\"):\n import numpy as np\n wave = np.array(wave, float)\n flux = np.array(flux, float)\n \n if wave.size != flux.size: raise TypeError, 'ERROR - wave and flux vectors must be the same size'\n \n if not bool(r_v): r_v = 3.1\n \n x = 10000.0/wave\n npts = wave.size\n a = np.zeros(npts, float)\n b = np.zeros(npts, float)\n \n ###############################\n #Infrared\n \n good = np.where( (x > 0.3) & (x < 1.1) )\n a[good] = 0.574 * x[good]**(1.61)\n b[good] = -0.527 * x[good]**(1.61)\n \n ###############################\n # Optical & Near IR\n \n good = np.where( (x >= 1.1) & (x < 3.3) )\n y = x[good] - 1.82\n \n c1 = np.array([ 1.0 , 0.104, -0.609, 0.701, 1.137, \\\n -1.718, -0.827, 1.647, -0.505 ])\n c2 = np.array([ 0.0, 1.952, 2.908, -3.989, -7.985, \\\n 11.102, 5.491, -10.805, 3.347 ] )\n \n a[good] = np.polyval(c1[::-1], y)\n b[good] = np.polyval(c2[::-1], y)\n \n ###############################\n # Mid-UV\n \n good = np.where( (x >= 3.3) & (x < 8) )\n y = x[good]\n F_a = np.zeros(np.size(good),float)\n F_b = np.zeros(np.size(good),float)\n good1 = np.where( y > 5.9 )\n \n if np.size(good1) > 0:\n y1 = y[good1] - 5.9\n F_a[ good1] = -0.04473 * y1**2 - 0.009779 * y1**3\n F_b[ good1] = 0.2130 * y1**2 + 0.1207 * y1**3\n \n a[good] = 1.752 - 0.316*y - (0.104 / ( (y-4.67)**2 + 0.341 )) + F_a\n b[good] = -3.090 + 1.825*y + (1.206 / ( (y-4.62)**2 + 0.263 )) + F_b\n \n ###############################\n # Far-UV\n \n good = np.where( (x >= 8) & (x <= 11) )\n y = x[good] - 8.0\n c1 = [ -1.073, -0.628, 0.137, -0.070 ]\n c2 = [ 13.670, 4.257, -0.420, 0.374 ]\n a[good] = np.polyval(c1[::-1], y)\n b[good] = np.polyval(c2[::-1], y)\n \n # Applying Extinction Correction\n \n a_v = r_v * ebv\n a_lambda = a_v * (a + b/r_v)\n \n funred = flux * 10.0**(0.4*a_lambda) \n \n return funred","def set_und_surface(self):\n if (self.dimension == '3D'):\n self.part_RVE.Set(\n cells=self.part_RVE.cells.getSequenceFromMask(mask=('[#1 ]', ), ),\n name='Set_RVE')\n elif (self.dimension == '2D'):\n self.part_RVE.Set(\n faces=self.part_RVE.faces.getSequenceFromMask(mask=('[#1 ]', ), ),\n name='Set_RVE')\n else:\n print('dimension Error!')","def genebmp(dirName, sou,slnt,dx,dy):\r\n\r\n if sou=='source':\r\n tabres=np.zeros((slnt,dx,dy),np.int16)\r\n else:\r\n tabres=np.zeros((slnt,dx,dy),np.uint8)\r\n\r\n\r\n dirFileP = os.path.join(dirName, sou)\r\n\r\n (top,tail)=os.path.split(dirName)\r\n print ('generate image in :',tail, 'directory :',sou)\r\n fileList =[name for name in os.listdir(dirFileP) if \".dcm\" in name.lower()]\r\n\r\n for filename in fileList:\r\n FilesDCM =(os.path.join(dirFileP,filename))\r\n RefDs = dicom.read_file(FilesDCM)\r\n dsr= RefDs.pixel_array\r\n dsr=dsr.astype('int16')\r\n fxs=float(RefDs.PixelSpacing[0])/avgPixelSpacing\r\n scanNumber=int(RefDs.InstanceNumber)\r\n if dsr.max()>dsr.min():\r\n if sou !='source' :\r\n dsr=normi(dsr)\r\n dsr=cv2.resize(dsr,None,fx=fxs,fy=fxs,interpolation=cv2.INTER_LINEAR)\r\n if sou == 'lung':\r\n np.putmask(dsr,dsr>0,100)\r\n\r\n elif sou !='source':\r\n np.putmask(dsr,dsr==1,0)\r\n np.putmask(dsr,dsr>0,100)\r\n else :\r\n dsr[dsr == -2000] = 0\r\n intercept = RefDs.RescaleIntercept\r\n slope = RefDs.RescaleSlope\r\n if slope != 1:\r\n dsr = slope * dsr.astype(np.float64)\r\n dsr = dsr.astype(np.int16)\r\n\r\n dsr += np.int16(intercept)\r\n dsr = dsr.astype('int16')\r\n# print dsr.min(),dsr.max(),dsr.shape\r\n dsr=cv2.resize(dsr,None,fx=fxs,fy=fxs,interpolation=cv2.INTER_LINEAR)\r\n\r\n tabres[scanNumber]= dsr\r\n\r\n return tabres","def uvsRBackwardWarp(mot, rect):\n u, v, s, x0, y0 = mot\n return np.r_[rect[:2] - u + s * x0, rect[2:] - v + s * y0] / (1 + s)","def test_generate_frustum_planes_stereo() -> None:\n near_clip_dist = 3.56 # arbitrary value\n\n # Set \"focal_length_x_px_\"\n fx_px = 3666.534329132812\n\n # Set \"focal_length_y_px_\"\n fy_px = 3673.5030423482513\n\n # Set \"focal_center_x_px_\"\n cx_px = 1235.0158218941356\n\n # Set \"focal_center_y_px_\"\n cy_px = 1008.4536901420888\n\n camera_name = \"stereo_front_left\"\n height_px = 1550\n width_px = 2048\n\n pinhole_camera = _create_pinhole_camera(\n fx_px=fx_px,\n fy_px=fy_px,\n cx_px=cx_px,\n cy_px=cy_px,\n height_px=height_px,\n width_px=width_px,\n cam_name=camera_name,\n )\n (\n left_plane,\n right_plane,\n near_plane,\n bottom_plane,\n top_plane,\n ) = pinhole_camera.frustum_planes(near_clip_dist)\n\n left_plane_expected: NDArrayFloat = np.array([fx_px, 0.0, width_px / 2.0, 0.0])\n right_plane_expected: NDArrayFloat = np.array([-fx_px, 0.0, width_px / 2.0, 0.0])\n near_plane_expected: NDArrayFloat = np.array([0.0, 0.0, 1.0, -near_clip_dist])\n bottom_plane_expected: NDArrayFloat = np.array([0.0, -fx_px, height_px / 2.0, 0.0])\n top_plane_expected: NDArrayFloat = np.array([0.0, fx_px, height_px / 2.0, 0.0])\n\n assert np.allclose(\n left_plane, left_plane_expected / np.linalg.norm(left_plane_expected)\n )\n assert np.allclose(\n right_plane, right_plane_expected / np.linalg.norm(right_plane_expected)\n )\n assert np.allclose(\n bottom_plane, bottom_plane_expected / np.linalg.norm(bottom_plane_expected)\n )\n assert np.allclose(\n top_plane, top_plane_expected / np.linalg.norm(top_plane_expected)\n )\n assert np.allclose(near_plane, near_plane_expected)","def calc_uv(self, x, y, prev=False):\n assert len(x) == self.N\n assert len(y) == self.N\n u = np.zeros(self.N, self.x.dtype)\n v = np.zeros(self.N, self.y.dtype)\n for n in xrange(self.N):\n # don't include self interaction\n if prev:\n x0 = self.xprev[np.r_[:n,n+1:self.N]]\n y0 = self.yprev[np.r_[:n,n+1:self.N]]\n else:\n x0 = self.x[np.r_[:n,n+1:self.N]]\n y0 = self.y[np.r_[:n,n+1:self.N]]\n s0 = self.s[np.r_[:n,n+1:self.N]]\n u0, v0 = self.uv_at_xy(x[n], y[n], x0, y0, s0)\n u[n] = u0.sum()\n v[n] = v0.sum()\n return u, v","def build(self):\n # Generate a 4x4 identity matrix, which will be the basis for the view matrix.\n vtm = np.identity( 4, float )\n # Generate a translation matrix to move the VRP to the origin and then premultiply the vtm by the translation matrix.\n t1 = np.matrix( [[1, 0, 0, -self.vrp[0, 0]],\n [0, 1, 0, -self.vrp[0, 1]],\n [0, 0, 1, -self.vrp[0, 2]],\n [0, 0, 0, 1] ] )\n\n vtm = t1 * vtm\n\n # Calculate the view reference axes tu, tvup, tvpn.\n tu = np.cross(self.vup, self.vpn)\n tvup = np.cross(self.vpn, tu)\n tvpn = self.vpn.copy()\n\n # Normalize the view axes tu, tvup, and tvpn to unit length.\n\n # if this doesn't work, create my own normalize function\n tu = self.normalize(tu)\n tvup = self.normalize(tvup)\n tvpn = self.normalize(tvpn)\n\n # Copy the orthonormal axes tu, tvup, and tvpn back to self.u, self.vup and self.vpn.\n self.u = tu.copy()\n self.vup = tvup.copy()\n self.vpn = tvpn.copy()\n\n # Use the normalized view reference axes to generate the rotation matrix \n # to align the view reference axes and then premultiply M by the rotation.\n r1 = np.matrix( [[ tu[0, 0], tu[0, 1], tu[0, 2], 0.0 ],\n [ tvup[0, 0], tvup[0, 1], tvup[0, 2], 0.0 ],\n [ tvpn[0, 0], tvpn[0, 1], tvpn[0, 2], 0.0 ],\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\n\n vtm = r1 * vtm\n\n # Translate the lower left corner of the view space to the origin.\n # extent of the view volume in the X and Y view axes.\n vtm = self.T( 0.5*self.extent[0], 0.5*self.extent[1], 0 ) * vtm\n\n vtm = self.S( -self.screen[0] / self.extent[0], -self.screen[1] / self.extent[1], 1.0 / self.extent[2] ) * vtm\n\n vtm = self.T( self.screen[0] + self.offset[0], self.screen[1] + self.offset[1], 0 ) * vtm\n\n return vtm","def internal_wave_KE(U, V, z, bin_idx, wl_min, wl_max, bin_size):\n \n \n Uspeci = []\n Vspeci = []\n Uspec = []\n Vspec = []\n Upowi = []\n Vpowi = []\n Upower = []\n Vpower = []\n U = U**2\n V = V**2\n \n sp = np.nanmean(np.gradient(z, axis=0))\n \n U_mx, U_kx = specGrid(U[bin_idx[0,:],0], sp, bin_size)\n \n for Ui, Vi in zip(U.T, V.T):\n \n for binIn in bin_idx:\n Uspec1 = SpectrumGen(Ui[binIn], bin_size)\n Upowi.append(power_spec(Uspec1))\n Uspeci.append(Uspec1)\n Vspec1 = SpectrumGen(Vi[binIn], bin_size)\n Vpowi.append(power_spec(Vspec1))\n Vspeci.append(Vspec1)\n \n Uspeci = np.vstack(Uspeci)\n Vspeci = np.vstack(Vspeci)\n Upowi = np.vstack(Upowi)\n Vpowi = np.vstack(Vpowi)\n \n Uspec.append(Uspeci)\n Vspec.append(Vspeci)\n Upower.append(Upowi)\n Vpower.append(Vpowi)\n Uspeci = []\n Vspeci = []\n Upowi = []\n Vpowi = []\n \n # integrate Power Spec of U and V between chosen vertical wavelengths\n Uint = []\n Vint = []\n \n for Us, Vs in zip(Upower, Vpower):\n Ui = np.vstack([power_int_smart(binIn,\\\n U_mx, wl_min, wl_max) for binIn in Us])\n Vi = np.vstack([power_int_smart(binIn,\\\n U_mx, wl_min, wl_max) for binIn in Vs])\n Uint.append(Ui)\n Vint.append(Vi)\n \n Ui = []\n Vi = []\n \n \n Uint = np.hstack(Uint)\n Vint = np.hstack(Vint)\n \n Ek = 0.5*(Uint + Vint)\n \n return Ek, Upower, Vpower, U_kx, Uspec, Vspec","def _forward(self, m, v_k):\n tmp = gpuarray.zeros(self._dest_shape,\n dtype=self._op.precision_complex)\n\n self._op.apply(m, tmp)\n self._op.adjoint(tmp, v_k)\n # v_k = v_k + bla.*m\n if self._double:\n add_scaled_vector_vector_double(v_k, v_k, self._weights, m)\n else:\n add_scaled_vector_vector(v_k, v_k, self._weights, m)\n tmp.gpudata.free()","def removeplane(img, slce=0.4):\n img[img == 0] = np.nan\n\n xr, yr = np.arange(slce*img.shape[0],(1-slce)*img.shape[0],dtype=int),\\\n np.arange(slce*img.shape[1],(1-slce)*img.shape[1],dtype=int)\n x, y = np.meshgrid(xr,yr)\n\n \n subimg = img[xr[0]:xr[-1]+1,yr[0]:yr[-1]+1]\n imgf = subimg[np.isfinite(subimg)].flatten()\n\n vecs = np.ones((5,imgf.size))\n vecs[0,:] = x[np.isfinite(subimg)].flatten()\n vecs[1,:] = y[np.isfinite(subimg)].flatten()\n vecs[2,:] = x[np.isfinite(subimg)].flatten()**2\n vecs[3,:] = y[np.isfinite(subimg)].flatten()**2\n\n C = vecs.dot(vecs.T)\n xv = la.inv(C).dot(vecs.dot(imgf[:,np.newaxis]))\n x, y = np.meshgrid(np.arange(img.shape[0]), np.arange(img.shape[1]))\n\n img -= (xv[0]*x + xv[1]*y + \\\n xv[2]*x**2 + xv[3]*y**2 + \\\n xv[4])\n return img","def generaCubo(self):\r\n #Use Panda predefined format for vertex coordinate only\r\n format = GeomVertexFormat.getV3()\r\n \r\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \r\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\r\n \r\n #I will have to write vertex data so I create a writer for these data\r\n vertex = GeomVertexWriter(vdata, 'vertex')\r\n \r\n #I now use the writer to add vertex data\r\n vertex.addData3f(0, 0, 0)\r\n vertex.addData3f(1, 1, 1)\r\n vertex.addData3f(0, 1, 1)\r\n vertex.addData3f(0, 1, 0)\r\n vertex.addData3f(0, 0, 1)\r\n vertex.addData3f(1, 0, 0)\r\n vertex.addData3f(1, 0, 1)\r\n vertex.addData3f(1, 1, 0)\r\n \r\n #I now create 12 triangles\r\n prim = GeomTriangles(Geom.UHStatic)\r\n\r\n #and then I add vertex to them\r\n #Next time use addVertices(0,1,2) !!!\r\n prim.addVertex(7)\r\n prim.addVertex(0)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(3)\r\n prim.addVertex(0)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(2)\r\n prim.addVertex(6)\r\n prim.addVertex(4)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(6)\r\n prim.addVertex(2)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(7)\r\n prim.addVertex(2)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(2)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(3)\r\n prim.addVertex(4)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(2)\r\n prim.addVertex(4)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(0)\r\n prim.addVertex(6)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(4)\r\n prim.addVertex(6)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(5)\r\n prim.addVertex(1)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(6)\r\n prim.addVertex(1)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n #Create a Geom to bing vertex data to primitives\r\n geom = Geom(vdata)\r\n geom.addPrimitive(prim)\r\n\r\n #Create a node for the Geom in order to be able to render it\r\n node = GeomNode('gnode')\r\n node.addGeom(geom)\r\n\r\n #Adde the node to the scene graph == render it!\r\n nodePath = render.attachNewNode(node)\r\n \r\n #is this needed?\r\n nodePath.setPos( 0, 5, 0)\r\n \r\n self.camera.lookAt(nodePath)\r\n \r\n base.setBackgroundColor( .0, .0, .0 )\r\n \r\n taskMgr.add(self.SpinCameraTask, \"SpinCameraTask\")","def set_original_planes(self, display_opt):\n\n # get 4-chamber view\n four_ch_view_plane_normal = self.find_4ch_view(display_opt)\n\n # set rodriguez rotation around midline (apex to C)\n axis_of_rot = np.array(self.epi_apex_node - self.C)\n self.axis_of_rot_normalized = axis_of_rot/np.linalg.norm(axis_of_rot)\n\n # get 2-chamber view (90-counterclock rotation from 4ch)\n new_P = my_rodriguez_rotation(self.plane_pts, self.axis_of_rot_normalized,\n math.radians(self.orig_view_angles[1])) # rodriguez rotation around midline\n two_ch_view_plane_normal = find_plane_eq(new_P[0, :], new_P[1, :], new_P[2, :])\n\n # get 3-chamber view (additional 30-60 counterclock rotation from 3ch)\n new_P = my_rodriguez_rotation(self.plane_pts, self.axis_of_rot_normalized, math.radians(self.orig_view_angles[2]))\n three_ch_view_plane_normal = find_plane_eq(new_P[0, :], new_P[1, :], new_P[2, :])\n\n if display_opt:\n _ = self.mesh_slicer(four_ch_view_plane_normal, 'mesh')\n _ = self.mesh_slicer(two_ch_view_plane_normal, 'mesh')\n _ = self.mesh_slicer(three_ch_view_plane_normal, 'mesh')\n\n self.original_planes = np.vstack((four_ch_view_plane_normal,\n two_ch_view_plane_normal,\n three_ch_view_plane_normal))","def addUVPatch(self,p,uv):\n assert len(p) == 16\n assert len(uv) == 4\n indexPatch = [self.register(v) for v in p]\n indexUVPatch = [self.uvregister(v) for v in uv]\n self.get('patchmesh.patches').append(indexPatch)\n self.get('patchmesh.uvpatches').append(indexUVPatch)","def _forward(self, m, v_k):\n tmp = gpuarray.zeros(self._dest_shape, dtype=np.complex64, order='C')\n self._op.apply(m, tmp)\n self._op.adjoint(tmp, v_k)\n add_scaled_vector(v_k, m, self._tau, v_k)","def test_set_vx_to_vy(self, cpu):\n for x in range(0x0, 0xF):\n for y in range(0x0, 0xF):\n if x != y:\n cpu.opcode = 0x8000 | (x << 8) | (y << 4)\n for v in range(0x0, 0xFF):\n cpu.V_register[y] = v\n cpu.set_vx_to_vy()\n assert(cpu.V_register[x] == v)","def make_raw_vertex_image(data1, cmap = 'hot', vmin = 0, vmax = 1, \n data2 = [], vmin2 = 0, vmax2 = 1, subject = 'fsaverage', data2D = False):\n \n # Get curvature\n curv = cortex.db.get_surfinfo(subject, type = 'curvature', recache=False)#,smooth=1)\n # Adjust curvature contrast / color. Alternately, you could work\n # with curv.data, maybe threshold it, and apply a color map. \n curv.data[curv.data>0] = .1\n curv.data[curv.data<=0] = -.1\n #curv.data = np.sign(curv.data.data) * .25\n \n curv.vmin = -1\n curv.vmax = 1\n curv.cmap = 'gray'\n \n # Create display data \n vx = cortex.Vertex(data1, subject, cmap = cmap, vmin = vmin, vmax = vmax)\n \n # Pick an arbitrary region to mask out\n # (in your case you could use np.isnan on your data in similar fashion)\n if data2D:\n data2[np.isnan(data2)] = vmin2\n norm2 = colors.Normalize(vmin2, vmax2) \n alpha = np.clip(norm2(data2), 0, 1)\n else:\n alpha = ~np.isnan(data1) #(data < 0.2) | (data > 0.4)\n alpha = alpha.astype(np.float)\n \n # Map to RGB\n vx_rgb = np.vstack([vx.raw.red.data, vx.raw.green.data, vx.raw.blue.data])\n vx_rgb[:,alpha>0] = vx_rgb[:,alpha>0] * alpha[alpha>0]\n \n curv_rgb = np.vstack([curv.raw.red.data, curv.raw.green.data, curv.raw.blue.data])\n # do this to avoid artifacts where curvature gets color of 0 valur of colormap\n curv_rgb[:,np.where((vx_rgb > 0))[-1]] = curv_rgb[:,np.where((vx_rgb > 0))[-1]] * (1-alpha)[np.where((vx_rgb > 0))[-1]]\n\n # Alpha mask\n display_data = curv_rgb + vx_rgb \n\n # Create vertex RGB object out of R, G, B channels\n vx_fin = cortex.VertexRGB(*display_data, subject, curvature_brightness = 0.4, curvature_contrast = 0.1)\n\n return vx_fin","def plot_uv(self):\n self.current_plot = 'uv'\n self.ax_zoomed = False\n \n uu = self.uv.d_uv_data['UU']*1e6\n vv = self.uv.d_uv_data['VV']*1e6\n xx = self.uv.d_array_geometry['STABXYZ'][:,0]\n yy = self.uv.d_array_geometry['STABXYZ'][:,1]\n pmax, pmin = np.max([uu, vv])*1.1, np.min([uu,vv])*1.1\n\n \n fig = self.sp_fig\n plt.subplot(121, aspect='equal')\n ax = plt.plot(xx, yy, 'bo')\n for i in range(len(xx)):\n plt.text(xx[i], yy[i], self.uv.d_array_geometry['ANNAME'][i].strip('Stand').strip('Tile'))\n\n plt.title(\"Antenna positions\")\n plt.xlabel(\"X [m]\")\n plt.ylabel(\"Y [m]\")\n \n plt.subplot(122, aspect='equal')\n ax = plt.plot(uu, vv, 'b.')\n plt.title(\"UV data\")\n plt.xlabel(\"UU [$\\\\mu s$]\")\n plt.ylabel(\"VV [$\\\\mu s$]\")\n plt.xlim(pmin, pmax)\n plt.ylim(pmin, pmax)\n return fig, ax","def uvSnapshot(arg=None):\n\n FILE_NAME = 'uv.jpg'\n RESOLUTION = 4096\n\n sel = getListSelection()\n ac = autoConnect.AutoConnect()\n\n if ac.PHOTOSHOP_PATH is None:\n raise WindowsError('Couldn\\'t find Adobe Photoshop.')\n\n for s in sel:\n shaderName = shaderUtility.customStringToShaderName(s)\n if [f for f in ac.DATA.keys() if shaderName == f] == []:\n print '# Shader doesn\\'t have an AutoConnect setup.'\n continue\n\n # Launch photoshop process\n\n editTexture()\n\n usedBy = shaderUtility.data[shaderName]['usedBy']\n parents = []\n for u in usedBy:\n parent = cmds.listRelatives(u, allParents=True,\n path=True)[0]\n parents.append(parent)\n cmds.select(parents)\n\n p = path.normpath(path.join(ac.workspace, ac.sourceImages,\n shaderName))\n if os.path.isdir(p) is not True:\n os.mkdir(p)\n path.normpath(path.join(p, FILE_NAME))\n cmds.uvSnapshot(\n name=path.normpath(path.join(p, FILE_NAME)),\n overwrite=True,\n antiAliased=True,\n fileFormat='jpg',\n xResolution=RESOLUTION,\n yResolution=RESOLUTION,\n )\n\n # Let's call Photoshop\n\n script = psCommand.script\n PS_SCRIPT = script.replace('<UV_Image_Path>',\n path.normpath(path.join(p,\n FILE_NAME)).replace('\\\\', '\\\\\\\\'\n )).replace('<Texture_PSD_Name>',\n '%s.psd' % shaderName)\n\n tempDir = tempfile.gettempdir()\n scriptFile = 'psScript.jsx'\n\n p = path.join(tempDir, scriptFile)\n f = open(p, 'w')\n f.write(PS_SCRIPT)\n f.close()\n\n cmd = '\"%s\" \"%s\"' % (path.normpath(ac.PHOTOSHOP_PATH),\n path.normpath(p))\n process = QProcess()\n process.startDetached(cmd)","def saveVelocityAndPressureVTK_binary(pressure,u,v,w,x,y,z,filename,dims):\n numEl_size = u.size; numEl = np.prod(numEl_size);\n # open the file and write the ASCII header:\n file = open(filename,'w')\n file.write('# vtk DataFile Version 3.0\\n')\n file.write('VTK file for data post-processed with Python\\n')\n file.write('Binary\\n\\n')\n file.write('DATASET STRUCTURED_GRID\\n')\n file.write('DIMENSIONS %d %d %d \\n'%(dims[0],dims[1],dims[2]))\n file.write('POINTS %d float\\n'%(numEl))\n file.close()\n \n # append binary x,y,z data\n file = open(filename,'ab')\n for i in range(len(x)): # there really needs to be a better way.\n pt = [x[i],y[i],z[i]]\n pt_buf = array('f',pt)\n pt_buf.byteswap()\n file.write(pt_buf)\n \n \n file.close()\n \n # append an ASCII sub header\n file = open(filename,'a')\n file.write('POINT_DATA %d \\n'%numEl)\n file.write('VECTORS velocity_vectors float\\n')\n file.close()\n \n # append binary u,v,w data\n file = open(filename,'ab')\n for i in range(len(u)):\n pt = [u[i],v[i],w[i]]\n pt_buf = array('f',pt)\n pt_buf.byteswap()\n file.write(pt_buf)\n \n file.close()\n \n # append ASCII sub header for scalar velocity magnitude data\n file = open(filename,'a')\n file.write('SCALARS VelocityMagnitude float\\n')\n file.write('LOOKUP_TABLE default\\n')\n \n file.close()\n \n file = open(filename,'ab')\n v_mag = np.sqrt(u**2+v**2+w**2)\n file = open(filename,'ab')\n p_buf = array('f',v_mag); p_buf.byteswap()\n file.write(p_buf)\n file.close()\n \n \n # append another ASCII sub header for the scalar pressure data\n file = open(filename,'a')\n file.write('SCALARS Pressure float\\n')\n file.write('LOOKUP_TABLE default\\n')\n file.close()\n \n # append binary pressure data\n file = open(filename,'ab')\n p_buf = array('f',pressure); p_buf.byteswap()\n file.write(p_buf)\n file.close()","def uvgrid(self):\n if self.baselines_type != \"grid_centres\":\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv + 1) # +1 because these are bin edges.\n return (ugrid[1:] + ugrid[:-1]) / 2\n else:\n # return the uv\n return self.baselines","def moveStageToWell(self, u, v): \n c= \"/cli:python /app:matrix /sys:1 /cmd:moveteowell \"\n c += \" /upos:\"+str(u)\n c += \" /vpos:\"+str(v)\n self.sendCMDstring(c)","def registerUVPatches(self,uvpl):\n self.set('patchmesh.uvpatches',uvpl)","def texMoveUVShellContext(*args, exists: bool=True, image1: Union[AnyStr, bool]=\"\", image2:\n Union[AnyStr, bool]=\"\", image3: Union[AnyStr, bool]=\"\", iterations:\n Union[int, bool]=0, mask: bool=True, position: bool=True,\n shellBorder: Union[float, bool]=0.0, q=True, query=True, e=True,\n edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def writeVelocityPlot(self):\n name = \"velocity.vtk\"\n chargeFile = open(name,'w')\n chargeFile.write(\"%s\\n\"%(\"# vtk DataFile Version 2.0\"))\n chargeFile.write(\"%s\\n\"%(\"obtained via hydraulicmodule\"))\n chargeFile.write(\"%s\\n\"%(\"ASCII\"))\n chargeFile.write(\"%s\\n\"%(\"DATASET UNSTRUCTURED_GRID\"))\n chargeFile.write(\"%s %i %s\\n\"%(\"POINTS\",len(self.points),\"double\"))\n dim = self.mesh.getSpaceDimensions()\n if (dim==2): \n for ind in range(0,len(self.points)):\n chargeFile.write(\"%15.8e %15.8e %15.8e\\n\"%(self.points[ind][0],\\\n self.points[ind][1],\\\n 0.))\n pass\n pass\n elif (dim==3): \n for ind in range(0,len(self.points)):\n chargeFile.write(\"%15.8e %15.8e %15.8e\\n\"%(self.points[ind][0],\\\n self.points[ind][1],\\\n self.points[ind][2]))\n pass\n pass\n else:\n raise Exception(\" error in mesh dimension \") \n numberOfCells = self.mesh.getNumberOfCells()\n connectivity = self.mesh.getConnectivity()\n\n cellListSize = 0\n for i in range(0,numberOfCells): # gmsh meshes: type of elements\n gmshType = connectivity[i][1]\n if gmshType == 1: # 2-node line\n cellListSize += 3\n pass\n elif gmshType == 2: # 3-node triangles\n cellListSize += 4\n pass\n elif gmshType == 3: # 4-node quadrangles\n cellListSize += 5\n pass\n elif gmshType == 4: # 4-node tetrahedron\n cellListSize += 5\n pass\n elif gmshType == 5: # 8-node hexahedrons\n cellListSize += 9\n pass\n pass\n chargeFile.write(\"CELLS %i %i\\n\"%(numberOfCells,cellListSize))\n ind = 0\n for cell in connectivity:\n ind = cell[2]+3\n# print \" ctm dbg cell \",vtkTyp,ind,cell,\" perm \",permutation[ind],permutation[ind+1],permutation[ind+2],permutation[ind+3]\n # \n vtkTyp = _vtkGmsh(cell[1])\n if (vtkTyp==3): # 2-node line\n ind = cell[2]+3\n chargeFile.write(\"%i %i %i\\n\"%(\n 2,\\\n cell[ind]-1,\\\n cell[ind+1]-1)\n )\n pass\n \n elif (vtkTyp==5): # triangles\n chargeFile.write(\"%i %i %i %i\\n\"%(\n 3, \n cell[ind]-1,\\\n cell[ind+1]-1,\\\n cell[ind+2]-1)\n )\n pass\n elif (vtkTyp==9): # quadr\n chargeFile.write(\"%i %i %i %i %i\\n\"%(\n 4,\\\n cell[ind]-1,\\\n cell[ind+1]-1,\\\n cell[ind+2]-1,\\\n cell[ind+3]-1)\n )\n pass\n elif (vtkTyp==10): # tetra\n chargeFile.write(\"%i %i %i %i %i\\n\"%(\n 4,\\\n cell[ind]-1,\\\n cell[ind+1]-1,\\\n cell[ind+2]-1,\\\n cell[ind+3]-1)\n )\n pass\n elif (vtkTyp==12): # hexahedron\n chargeFile.write(\"%i %i %i %i %i %i %i %i %i\\n\"%(\n 8,\\\n cell[ind]-1,\\\n cell[ind+1]-1,\\\n cell[ind+2]-1,\\\n cell[ind+3]-1,\\\n cell[ind+4]-1,\\\n cell[ind+5]-1,\\\n cell[ind+6]-1,\\\n cell[ind+7]-1)\n )\n pass\n pass\n chargeFile.write(\"%s %i\\n\"%(\"CELL_TYPES\",numberOfCells))\n#\n for i in range(0,numberOfCells):\n gmshType = connectivity[i][1]\n\n if (gmshType)==1:\n cellTyp = 3\n pass\n elif (gmshType)==2:\n cellTyp = 5\n pass\n elif (gmshType)==3:\n cellTyp = 9\n pass\n elif (gmshType)==4:\n cellTyp = 10\n pass\n elif (gmshType)==5:\n cellTyp = 12\n pass\n elif (gmshType)==6:\n cellTyp = 13\n pass\n elif gmshType == 7:\n cellTyp = 14\n pass\n else:\n raise Exception(\" check gmshtype \")\n chargeFile.write(\"%i\\n\"%(cellTyp))\n chargeFile.write(\"%s %d\\n\"%(\"POINT_DATA\",len(self.points)))\n chargeFile.write(\"%s\\n\"%(\"VECTORS vectors float\"))\n for velocityComponent in self.velocity:\n chargeFile.write(\" %e %e %e\\n \"%(velocityComponent[0], velocityComponent[1], velocityComponent[2]))\n chargeFile.write(\"%s\\n\"%(\"SCALARS charge double\"))\n chargeFile.write(\"%s\\n\"%(\"LOOKUP_TABLE default\"))\n#\n \n chargeDataFile=open(\"./\" + self.flowComponent.meshDirectoryName + \"/\" + \"HeVel.dat\",'r')\n line = chargeDataFile.readline()\n while \"Number Of Nodes\" not in line:\n line = chargeDataFile.readline()\n#line.split()\n nodesNumber = line.split()[-1]\n while \"Perm\" not in line:\n line = chargeDataFile.readline()\n#\n# We read the permutation\n#\n for i in range(int(nodesNumber)): chargeDataFile.readline()\n#\n# We read the charge\n#\n for i in range(int(nodesNumber)): chargeFile.write(\" %15.10e\\n \"%(float(chargeDataFile.readline())))","def product_stitch_sequential(input_unw_files: List[str],\n input_conncomp_files: List[str],\n arrres: List[float],\n output_unw: Optional[str] = './unwMerged',\n output_conn: Optional[str] = './connCompMerged',\n output_format: Optional[str] = 'ENVI',\n bounds: Optional[tuple] = None,\n clip_json: Optional[str] = None,\n mask_file: Optional[str] = None,\n # [meandiff, cycle2pi]\n correction_method: Optional[str] = 'cycle2pi',\n range_correction: Optional[bool] = True,\n verbose: Optional[bool] = False,\n save_fig: Optional[bool] = False,\n overwrite: Optional[bool] = True) -> None:\n\n # Outputs\n output_unw = Path(output_unw).absolute()\n if not output_unw.parent.exists():\n output_unw.parent.mkdir()\n output_conn = Path(output_conn).absolute()\n if not output_conn.parent.exists():\n output_conn.parent.mkdir()\n # create temp files\n temp_unw_out = output_unw.parent / ('temp_' + output_unw.name)\n temp_conn_out = output_conn.parent / ('temp_' + output_conn.name)\n\n # Create VRT and exit early if only one frame passed,\n # and therefore no stitching needed\n if len(input_unw_files) == 1:\n gdal.BuildVRT(str(temp_unw_out.with_suffix('.vrt')),\n input_unw_files)\n gdal.BuildVRT(str(temp_conn_out.with_suffix('.vrt')),\n input_conncomp_files)\n\n else:\n (combined_unwrap,\n combined_conn,\n combined_snwe) = stitch_unwrapped_frames(\n input_unw_files,\n input_conncomp_files,\n correction_method=correction_method,\n range_correction=range_correction,\n direction_N_S=True,\n verbose=verbose)\n\n # Write\n # write stitched unwrappedPhase\n write_GUNW_array(\n temp_unw_out, combined_unwrap, combined_snwe,\n format=output_format, verbose=verbose,\n update_mode=overwrite, add_vrt=True, nodata=0.0)\n\n # write stitched connectedComponents\n write_GUNW_array(\n temp_conn_out, combined_conn, combined_snwe,\n format=output_format, verbose=verbose,\n update_mode=overwrite, add_vrt=True, nodata=-1.0)\n\n # Crop\n [print(f'Cropping to {bounds}') if verbose and bounds else None]\n if overwrite:\n [print(f'Removing {output_unw}, {output_conn}') if verbose else None]\n output_unw.unlink(missing_ok=True)\n output_conn.unlink(missing_ok=True)\n\n # NOTE: Run gdal.Warp on temp file, if input and output are the same\n # warp creates empty raster, investigate why\n # Also, it looks like it is important to close gdal.Warp\n # gdal.Warp/Translate add 6 seconds to runtime\n\n for output, input in zip([output_unw, output_conn],\n [temp_unw_out, temp_conn_out]):\n # Crop if selected\n ds = gdal.Warp(str(output),\n str(input.with_suffix('.vrt')),\n format=output_format,\n cutlineDSName=clip_json,\n xRes=arrres[0], yRes=arrres[1],\n targetAlignedPixels=True,\n # cropToCutline = True,\n outputBounds=bounds\n )\n ds = None\n # Update VRT\n [print(f'Writing {output}, {output.with_suffix(\".vrt\")}')\n if verbose else None]\n gdal.Translate(str(output.with_suffix('.vrt')),\n str(output), format=\"VRT\")\n # Remove temp files\n [ii.unlink() for ii in [input, input.with_suffix('.vrt'),\n input.with_suffix('.xml'),\n input.with_suffix('.hdr'),\n input.with_suffix('.aux.xml')] if ii.exists()]\n\n # Mask\n if mask_file:\n if isinstance(mask_file, str):\n mask = gdal.Open(mask_file)\n else:\n # for gdal instance, from prep_mask\n mask = mask_file\n\n mask_array = mask.ReadAsArray()\n array = get_GUNW_array(str(output.with_suffix('.vrt')))\n\n if output == output_conn:\n # Mask connected components\n array[array == -1.0] = np.nan\n update_array = mask_array * array\n update_array = np.nan_to_num(update_array, nan=-1.0)\n # update_array[np.isnan(update_array)] = -1.0\n else:\n update_array = mask_array * array\n\n update_file = gdal.Open(str(output), gdal.GA_Update)\n update_file = update_file.GetRasterBand(1).WriteArray(update_array)\n update_file = None\n\n # Plot stitched\n # NOTE: saving output figure adds 4 seconds\n if save_fig:\n plot_GUNW_stitched(str(output_unw.with_suffix('.vrt')),\n str(output_conn.with_suffix('.vrt')))\n\n # Remove temp files\n [ii.unlink() for ii in [temp_unw_out,\n temp_unw_out] if ii.exists()]","def recompile(self):\n\n self.vaos = []\n try:\n self.program, uniforms = self.build_prog(self.gl)\n self.u_time, self.u_width, self.u_height = uniforms\n vao = GLUtil.screen_vao(self.gl, self.program)\n self.vaos.append(vao)\n\n self.compute, uniforms, buffers = self.build_cs(self.gl)\n self.u_cstime, self.u_cswidth, self.u_csheight = uniforms\n self.buf_in, self.buf_out = buffers\n\n self.set_gpu_wh(width, height)\n\n self.gx, self.gy = int(width / 8), int(height / 8)\n self.set_gpu_time()\n\n log(\"[Renderer] shader recompiled.\")\n\n except Exception as e:\n log(e)","def offset_to_uvd(self, x):\n self.batch_size = x.shape[0]\n self.W = x.shape[2]\n self.H = x.shape[3] \n self.D = 5\n self.grid_size = self.W*self.H*self.D\n \n grid_linear = x.reshape(self.batch_size, 64, -1)\n\n index = torch.from_numpy(np.asarray(np.unravel_index(np.arange(self.grid_size), \n (self.W, self.H, self.D)))).type(torch.FloatTensor)\n u = index[0, :].unsqueeze(0).expand(21, -1)\n v = index[1, :].unsqueeze(0).expand(21, -1)\n z = index[2, :].unsqueeze(0).expand(21, -1)\n\n if self.device != \"cpu\":\n u = u.cuda()\n v = v.cuda()\n z = z.cuda()\n\n pred_uvd_no_offset = grid_linear[:, :63, :].reshape(self.batch_size, 21, 3, self.grid_size)\n pred_conf = grid_linear[:, 63, :].reshape(self.batch_size, self.W, self.H, self.D)\n pred_conf = torch.sigmoid(pred_conf)\n \n # middle finger root is hand root\n pred_uvd_no_offset[:, self.hand_root, :, :] = torch.sigmoid(pred_uvd_no_offset[:, self.hand_root, :, :])\n \n pred_uvd = pred_uvd_no_offset.clone().detach()\n pred_uvd[:, :, 0, :] = (pred_uvd[:, :, 0, :] + u) / self.W\n pred_uvd[:, :, 1, :] = (pred_uvd[:, :, 1, :] + v) / self.H\n pred_uvd[:, :, 2, :] = (pred_uvd[:, :, 2, :] + z) / self.D\n \n pred_uvd_no_offset = pred_uvd_no_offset.reshape(self.batch_size, 21, 3, self.W, self.H, self.D)\n \n return pred_uvd_no_offset, pred_uvd, pred_conf","def get_bforce_wm_ws_Gx_surf(self):\n\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w'] \n \n self.Gm1 = np.zeros([Ly])\n self.dGm1_dS = np.zeros([Ly]) \n self.Gt1 = np.zeros([Ly])\n self.dGt1_dS = np.zeros([Ly]) \n self.Bfsfc_bl = np.zeros([Ly])\n self.Av_bl = np.zeros([Ly])\n self.dAv_bl = np.zeros([Ly])\n \n #debugging\n self.wm_surf = np.zeros([Ly])\n self.ws_surf = np.zeros([Ly]) \n\n #---> j-loop\n for j in range(Ly): \n k_w = self.kbl[j] # KBL is \"new bl index after calling find_new_kbl()\n z_bl = z_u_w[j,N] - self.hbls[j]\n zscale = self.hbls[j] \n \n if self.swr_frac[j,k_w-1] > 0:\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\n \n else:\n Bfsfc = self.Bo[j] + self.Bosol[j]\n \n # CALCUALTE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm_surf[j] = wm\n self.ws_surf[j] = ws \n\n if self.LIMIT_UNSTABLE_ONLY:\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\n else:\n f1 = 0\n\n \n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n\n #MOMENTUM \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl[j] = Av_bl\n self.dAv_bl[j] = dAv_bl\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \n\n #TEMPERATURE(BUOYANCY)\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \n\n self.Bfsfc_bl[j] = Bfsfc","def registerUVVertices(self,uvl):\n self.set('patchmesh.uvvertices',FuzzList(uvl))","def rdmb_povray_save_q(out_file,\n vs,\n ucs, vcs,\n width=800, height=600,\n rotx=0, roty=0, rotz=0,\n angle=14):\n\n ucmax = 6.0\n ucs = ucs / ucmax\n ucs[ucs > 1.0] = 1.0\n # ucs = ucs / np.max(ucs)\n\n rot1 = [rotx, 0, 0]\n rot2 = [0, roty, 0]\n rot3 = [0, 0, rotz]\n\n camera = Camera('location', [0, 0, -25],\n 'look_at', [0, 0, 0],\n 'angle', angle,\n 'right x*image_width/image_height')\n\n light = LightSource([0, 0, -10],\n 'color', [1.0, 1.0, 1.0], 'parallel', 'shadowless')\n light1 = LightSource([-10, 0, 0],\n 'color', [0.5, 0.5, 0.5], 'parallel', 'shadowless')\n light2 = LightSource([10, 0, 0],\n 'color', [0.5, 0.5, 0.5], 'parallel', 'shadowless')\n light3 = LightSource([0, -10, 0],\n 'color', [0.5, 0.5, 0.5], 'parallel', 'shadowless')\n light4 = LightSource([0, 10, 0],\n 'color', [0.5, 0.5, 0.5], 'parallel', 'shadowless')\n\n background = Background('color', [1, 1, 1, 1])\n\n spheres = [Sphere(v, 0.02,\n Finish('ambient', 1.0),\n Texture(Pigment('color',\n [0.3+uc*0.7, 0.2+uc*0.8, 0.2+uc*0.8])),\n 'rotate', rot1,\n 'rotate', rot2,\n 'rotate', rot3) for v, uc in zip(vs, ucs)]\n\n objects = [light, light1, light2, light3, light4, background] + spheres\n\n scene = Scene(camera, objects=objects)\n scene.render(out_file, width=width, height=height,\n output_alpha=True, antialiasing=0.001,\n tempfile=out_file+\"__temp__.pov\")","def createTerraces(u,v,altitude_profile,wind_angle,pass_length,image_passes,max_alt_diff,min_terrace_len):\n # Create terraces from pass\n current_terrace = [] # Initilise current terrace points as empty\n average_alt = 0 # Store the average altitude\n if len(altitude_profile) > 0: # If there is some altitude data for this pass\n max_altitude = np.max(altitude_profile)\n min_altitude = np.min(altitude_profile)\n if max_altitude - min_altitude < max_alt_diff: # If the entire pass is within the altitude limits\n # Find the mean altitude\n for i in range(0,len(altitude_profile)):\n average_alt += altitude_profile[i]\n average_alt = average_alt/len(altitude_profile)\n terrace_start = (u,v,average_alt)\n terrace_end = (u,v+pass_length,average_alt)\n\n coords = convertCoords([[terrace_start[0],terrace_start[1]]],wind_angle,'xy')\n terrace_start = (coords[0][0],coords[0][1],average_alt)\n\n coords = convertCoords([[terrace_end[0],terrace_end[1]]],wind_angle,'xy')\n terrace_end = (coords[0][0],coords[0][1],average_alt)\n\n image_passes.append(Image_Pass(terrace_start,terrace_end,average_alt,wind_angle))\n else:\n # Calculate terraces\n index = 0\n\n current_altitude = 0\n current_min_altitude = 0\n current_max_altitude = 0\n while index < len(altitude_profile):\n if index + 3 > len(altitude_profile):\n if current_altitude == 0:\n for alt in range(0,2):\n current_altitude += altitude_profile[index+alt]\n current_altitude = current_altitude/3\n for val in range(0,3):\n current_terrace.append([x,y,current_altitude])\n # Add all to current pass\n terrace_start = current_terrace[0]\n terrace_end = current_terrace[len(current_terrace)-1]\n image_passes.append(Image_Pass(terrace_start,terrace_end,current_altitude,wind_angle))\n break\n\n if len(current_terrace) == 0:\n # Look ahead to find gradient\n grad = altitude_profile[index+1] - altitude_profile[index]\n grad += altitude_profile[index+2] - altitude_profile[index]\n #grad += altitude_profile[index+3] - altitude_profile[index]\n grad = grad/2\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n if grad > 0:\n current_altitude = altitude_profile[index]+max_alt_diff/2\n current_terrace.append([x,y,current_altitude])\n elif grad < 0:\n current_altitude = altitude_profile[index]-max_alt_diff/2\n current_terrace.append([x,y,current_altitude])\n else:\n current_altitude = altitude_profile[index]\n current_terrace.append([x,y,current_altitude])\n current_min_altitude = current_altitude - max_alt_diff/2\n current_max_altitude = current_altitude + max_alt_diff/2\n\n else:\n # Add to the terrace\n if altitude_profile[index] > current_min_altitude and altitude_profile[index] < current_max_altitude:\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n elif altitude_profile[index+1] > current_min_altitude and altitude_profile[index+1] < current_max_altitude:\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n index += 1\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n elif altitude_profile[index+2] > current_min_altitude and altitude_profile[index+2] < current_max_altitude:\n for val in range(0,2):\n coords = convertCoords([[u,v+index+val]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n index += 1\n index -= 1\n else:\n if len(current_terrace) > min_terrace_len:\n # Create new terrace\n terrace_start = current_terrace[0]\n terrace_end = current_terrace[len(current_terrace)-1]\n image_passes.append(Image_Pass(terrace_start,terrace_end,current_altitude,wind_angle))\n current_terrace = []\n current_altitude = 0\n else:\n # Requires more image locations\n print(\"Not long enough\")\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n #current_max_altitude += max_alt_diff/2\n #current_min_altitude -+ max_alt_diff/2\n\n index += 1\n else:\n pass\n return image_passes","def test_set_vx_to_vx_shr(self, cpu):\n for x in range(0x0, 0xF):\n for v in range(0x0, 0xFF):\n cpu.V_register[x] = v\n cpu.opcode = 0x8006 | (x << 8)\n cpu.set_vx_to_vx_shr()\n if v & 0x1 == 1:\n assert(cpu.V_register[0xF] == 1)\n else:\n assert(cpu.V_register[0xF] == 0)\n assert(cpu.V_register[x] == v/2)","def compact_mesh(remote, objectid):\n cmd1 = mmapi.StoredCommands()\n key1 = cmd1.AppendSceneCommand_CompactMesh(objectid)\n remote.runCommand(cmd1)","def compute(self):\n # this just initializes all gradients to the vector (0,0,0)\n self.data = [ZERO_GRADIENT] * (self.volume.dim_x * self.volume.dim_y * self.volume.dim_z)\n\n for i in range(1, self.volume.dim_x-1):\n for j in range(1, self.volume.dim_y-1):\n for k in range(1, self.volume.dim_z-1):\n d_x = 0.5 * (self.volume.get_voxel(i+1, j, k) - self.volume.get_voxel(i-1, j, k))\n d_y = 0.5 * (self.volume.get_voxel(i, j+1, k) - self.volume.get_voxel(i, j-1, k))\n d_z = 0.5 * (self.volume.get_voxel(i, j, k+1) - self.volume.get_voxel(i, j, k-1))\n self.set_gradient(i, j, k, VoxelGradient(d_x, d_y, d_z))","def stabilization(videopath,\n smoothing_radius=50,\n fixed_area=[0, -1, 0, -1],\n stab_points=200):\n\n # Read original video\n # Extract directory and videoname for saving purposes\n capture = cv2.VideoCapture(videopath)\n directory, videoname = os.path.split(videopath)\n videoname = os.path.splitext(videoname)[0]\n\n # Get number of frames\n # Get width and height of video stream\n # Get frames per second (fps)\n n_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))\n w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))\n h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))\n fps = capture.get(cv2.CAP_PROP_FPS)\n\n # Set up output video\n out = cv2.VideoWriter(os.path.join(directory, str(videoname)+'_stabilized.mp4'),\n -1,\n fps,\n (w, h))\n\n # Read first frame\n # Convert frame to grayscale and extract part of image\n _, prev = capture.read()\n xmin, xmax, ymin, ymax = fixed_area\n prev_gray = cv2.cvtColor(prev, cv2.COLOR_BGR2GRAY)[ymin:ymax, xmin:xmax]\n\n # Pre-define transformation-store array\n transforms = np.zeros((n_frames-1, 3), np.float32)\n\n # Filling in transformation array per frameset\n with tqdm(total=2*(n_frames-2), ncols=50) as pbar:\n for i in range(n_frames-2):\n # Detect feature points in previous frame\n prev_pts = cv2.goodFeaturesToTrack(prev_gray,\n maxCorners=stab_points,\n qualityLevel=0.1,\n minDistance=100,\n blockSize=10)\n # Read next frame\n # If not success: break loop\n success, curr = capture.read()\n if not success:\n break\n\n # Convert to grayscale and extract part of image\n # Calculate optical flow (i.e. track feature points)\n # Sanity check\n curr_gray = cv2.cvtColor(curr, cv2.COLOR_BGR2GRAY)[ymin:ymax,\n xmin:xmax]\n curr_pts, status, err = cv2.calcOpticalFlowPyrLK(prev_gray,\n curr_gray,\n prev_pts,\n None)\n assert prev_pts.shape == curr_pts.shape\n\n # Filter only valid points\n idx = np.where(status == 1)[0]\n prev_pts = prev_pts[idx]\n curr_pts = curr_pts[idx]\n\n # Find transformation matrix\n m = cv2.estimateAffinePartial2D(prev_pts, curr_pts)[0]\n\n # Extract translation\n # Extract rotation angle\n dx = m[0, 2]\n dy = m[1, 2]\n da = np.arctan2(m[1, 0], m[0, 0])\n\n # Store transformation\n transforms[i] = [dx, dy, da]\n\n # Move to next frame\n prev_gray = curr_gray\n\n pbar.update(1)\n\n # Compute trajectory using cumulative sum of transformations\n # Create variable to store smoothed trajectory\n # Calculate diference in smoothed_trajectory and trajectory\n trajectory = np.cumsum(transforms, axis=0)\n smoothed_trajectory = smooth(trajectory, smoothing_radius)\n difference = smoothed_trajectory - trajectory\n\n # Calculate newer transformation array\n transform_smooth = transforms + difference\n\n # Reset stream to first frame\n capture.set(cv2.CAP_PROP_POS_FRAMES, 0)\n\n # Apply transformations to video\n for i in range(n_frames-2):\n # Read next frame\n success, frame = capture.read()\n if not success:\n break\n\n # Extract transformations from the new transformation array\n dx = transform_smooth[i, 0]\n dy = transform_smooth[i, 1]\n da = transform_smooth[i, 2]\n\n # Reconstruct transformation matrix accordingly to new values\n m = np.zeros((2, 3), np.float32)\n m[0, 0] = np.cos(da)\n m[0, 1] = -np.sin(da)\n m[1, 0] = np.sin(da)\n m[1, 1] = np.cos(da)\n m[0, 2] = dx\n m[1, 2] = dy\n\n # Apply affine wrapping to the given frame\n # Fix border artifacts\n frame_stabilized = cv2.warpAffine(frame, m, (w, h))\n frame_stabilized = fixBorder(frame_stabilized)\n\n # Save new frame\n out.write(frame_stabilized)\n\n pbar.update(1)\n\n # Release original and stabilized video\n capture.release()\n out.release()","def world2uv(self, vertices):\n batch_size = vertices.shape[0]\n face_vertices_ = face_vertices(vertices, self.faces.expand(batch_size, -1, -1))\n uv_vertices = self.uv_rasterizer(self.uvcoords.expand(batch_size, -1, -1), self.uvfaces.expand(batch_size, -1, -1), face_vertices_)[:, :3]\n return uv_vertices","def uvsWarp(mot, coi, destrect, crop_it=True):\n def resampleMei(coi, srect, drect):\n isrect = coi2imcoord(coi, srect)\n crect = np.array([np.floor(isrect[0]), np.ceil(isrect[1]), np.floor(isrect[2]), np.ceil(isrect[3])]).astype(np.int)\n cutim = coi.im[crect[2] - 1:crect[3], crect[0] - 1:crect[1]]\n cisrect = isrect - np.array([crect[0], crect[0], crect[2], crect[2]]) + 1\n s = rectSize(drect) + 1\n rim = resample1D(cutim, cisrect[2:], s[1], 1)\n rim = resample1D(rim, cisrect[:2], s[0], 2)\n\n return rim\n\n def resample1D(Ain, source, dests, dim):\n A = Ain.astype(np.float)\n rr = np.linspace(source[0], source[1], dests)\n lp = np.floor(rr).astype(np.int) - 1\n rp = np.ceil(rr).astype(np.int) - 1\n rw = np.mod(rr, 1)\n lw = 1 - rw\n\n if dim == 1:\n B = A[lp, :] * lw.T[:, np.newaxis] + A[rp, :] * rw.T[:, np.newaxis]\n elif dim == 2:\n B = A[:, lp] * lw + A[:, rp] * rw\n return B\n\n crect = coiImageRect(coi)\n idestrect = rect2int(destrect)\n\n if crop_it:\n wirect = uvsRWarp(mot, rectEnlarge(crect, -0.99))\n assert np.all(np.mod(rectSize(destrect), 1) == 0)\n doffset = np.mod(destrect[0:3:2] + 0.5, 1)\n destrect = rect2int(rectIntersect(wirect, destrect))\n idestrect = rect2int(destrect, doffset)\n\n if np.any(rectSize(destrect) < 1):\n wim = np.zeros((0, 0))\n else:\n srect = uvsRBackwardWarp(mot, idestrect)\n wim = resampleMei(coi, srect, idestrect)\n wcoi = coimage(wim, tuple(1 - idestrect[0:3:2]), '{}_warp'.format(coi.label), coi.level)\n\n return wcoi","def render_2d_vector(v1, gridsize=50):\n\n fb = pixel_op() \n fb.create_buffer(800, 800)\n fb.graticule(gridsize)\n fb.render_vector_2d( v1, scale=gridsize)\n fb.save('vec.png')","def MeshMachine(main):\n\n # oDesign definition\n oDesign = main['ANSYS']['oDesign']\n\n # Data for the rotor mesh\n RotorName = main['ANSYS']['Rotor&Magnets']['Name'][0]\n RotorNumMaxElem = main['ANSYS']['Mesh']['Rotor']['NumMaxElem']\n RotorMaxLength = main['ANSYS']['Mesh']['Rotor']['MaxLength']\n\n # Data for the magnets mesh\n PMNames = main['ANSYS']['Rotor&Magnets']['PMNames']\n PMNumMaxElem = main['ANSYS']['Mesh']['Magnets']['NumMaxElem']\n PMMaxLength = main['ANSYS']['Mesh']['Magnets']['MaxLength']\n\n # Data for the Stator mesh\n StatorName = main['ANSYS']['Stator']['Name']\n StatorNormalDev = main['ANSYS']['Mesh']['Stator']['NormalDev']\n StatorAspectRatio = main['ANSYS']['Mesh']['Stator']['AspectRatio']\n\n # Data for the Stator mesh\n CoilNames = main['ANSYS']['Winding']['CoilNames']\n WindingNumMaxElem = main['ANSYS']['Mesh']['Winding']['NumMaxElem']\n WindingMaxLength = main['ANSYS']['Mesh']['Winding']['MaxLength']\n\n WindingName = []\n for phase in CoilNames:\n for direction in phase:\n WindingName += direction\n\n # Creating meshes\n oModule = oDesign.GetModule(\"MeshSetup\")\n\n # Rotor meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Rotor\",\n \"RefineInside:=\", True,\n \"Enabled:=\", True,\n \"Objects:=\", [RotorName],\n \"RestrictElem:=\", False,\n \"NumMaxElem:=\", str(RotorNumMaxElem),\n \"RestrictLength:=\", True,\n \"MaxLength:=\", str(RotorMaxLength)+\"mm\"\n ]\n )\n # Magnet meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Magnets\",\n \"RefineInside:=\", True,\n \"Enabled:=\", True,\n \"Objects:=\", PMNames,\n \"RestrictElem:=\", False,\n \"NumMaxElem:=\", str(PMNumMaxElem),\n \"RestrictLength:=\", True,\n \"MaxLength:=\", str(PMMaxLength)+\"mm\"\n ]\n )\n # Stator meshes\n oModule.AssignTrueSurfOp(\n [\n \"NAME:Stator\",\n \"Objects:=\", [StatorName],\n \"CurvedSurfaceApproxChoice:=\", \"ManualSettings\",\n \"SurfDevChoice:=\", 0,\n \"NormalDevChoice:=\", 2,\n \"NormalDev:=\", str(StatorNormalDev) + \"deg\",\n \"AspectRatioChoice:=\", 2,\n \"AspectRatio:=\", str(StatorAspectRatio)\n ]\n )\n\n # Coil meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Coils\",\n \"RefineInside:=\"\t, True,\n \"Enabled:=\"\t\t, True,\n \"Objects:=\"\t\t, WindingName,\n \"RestrictElem:=\"\t, False,\n \"NumMaxElem:=\"\t\t, str(WindingNumMaxElem),\n \"RestrictLength:=\"\t, True,\n \"MaxLength:=\"\t\t, str(WindingMaxLength) +\"mm\"\n ]\n )\n\n return main","def uv(vec):\n return vec / sqrt(dot(vec, vec))","def update(self):\r\n\r\n # Update the vision frames in the system\r\n self._system.update()\r\n\r\n # Create blank PIL images to hold the video streams\r\n layered = PIL.Image.new('RGBA', (400, 400))\r\n stacked = PIL.Image.new('RGBA', (200, 800))\r\n control = PIL.Image.new('RGBA', (600, 800))\r\n\r\n focalpoint = self._system[self._appString[\"device\"].get()].focalpoint()\r\n # print(focalpoint)\r\n\r\n # Get each vision key and vision for the selected device\r\n visionList = [(visionKey, vision) for visionKey, vision in self._system[self._appString[\"device\"].get()]]\r\n\r\n # Loop through each vision in the vision list\r\n for i, (visionKey, vision) in enumerate(visionList):\r\n\r\n # Grab the frames from the vision when it is \"curr\"\r\n frameList = [frame for frameKey, frame in vision if frameKey==self._appString[\"frame\"].get()]\r\n\r\n # Loop through each frame in the frame list\r\n for frame in frameList:\r\n\r\n # Get the properties and turn the image into RGBA\r\n ratio, size = vision.properties()\r\n rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)\r\n\r\n # print(rgbFrame.shape)\r\n width, height, channels = rgbFrame.shape\r\n\r\n # Paste the images together in layered\r\n\r\n imgFrame = PIL.Image.fromarray(cv2.resize(rgbFrame, (int(400 * ratio), int(400 * ratio))))\r\n layered.paste(imgFrame, (int(200 * (1 - ratio)), int(200 * (1 - ratio))))\r\n\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 / width)), int(200 * (1 - ratio) - focalpoint[1] * (200 / height))))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 // width)), int(200 * (1 - ratio) - focalpoint[1] * (200 // height))))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (ratio ** -1)), int(200 * (1 - ratio) - focalpoint[1] * (ratio ** -1))))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200/width) / ratio), int(200 * (1 - ratio) - focalpoint[1] * (200/height) / ratio)))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 / width)), int(200 * (1 - ratio) - focalpoint[1] * (200 / height))))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (ratio ** -1) / 200), int(200 * (1 - ratio) - focalpoint[1] * (ratio ** -1) / 200)))\r\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (400//width * (1- ratio))), int(200 * (1 - ratio) - focalpoint[1] * (400//height * (1 - ratio)))))\r\n\r\n # Paste the images together in stacked\r\n imgFrame = PIL.Image.fromarray(cv2.resize(rgbFrame, (200, 200)))\r\n stacked.paste(imgFrame, (0, 200 * i))\r\n\r\n # Add the stacked image to the canvas\r\n self._pilFrames[\"stacked\"] = PIL.ImageTk.PhotoImage(image=stacked)\r\n self._appCanvas[\"stacked\"].create_image(100, 0, image=self._pilFrames[\"stacked\"], anchor=tkinter.NW)\r\n\r\n # Add the layered image to the canvas\r\n self._pilFrames[\"layered\"] = PIL.ImageTk.PhotoImage(image=layered)\r\n self._appCanvas[\"layered\"].create_image(0, 0, image=self._pilFrames[\"layered\"], anchor=tkinter.NW)\r\n\r\n # Add the control image to the canvas\r\n imgFrame = cv2.cvtColor(self._system[self._appString[\"device\"].get()][self._appString[\"vision\"].get()][self._appString[\"frame\"].get()], cv2.COLOR_BGR2RGBA)\r\n control = PIL.Image.fromarray(cv2.resize(imgFrame, (600, 600)))\r\n self._pilFrames[\"control\"] = PIL.ImageTk.PhotoImage(image=control)\r\n self._appCanvas[\"control\"].create_image(100, 90, image=self._pilFrames[\"control\"], anchor=tkinter.NW)\r\n\r\n # Continue to update with a delay of 15\r\n self.after(15, self.update)","def pipeline(image):\n # undistort image\n undistorted_image = undistort_image(image)\n superimposed_image = find_lanes(undistorted_image)\n labels = find_vehicles(undistorted_image)\n\n draw_img = draw_labeled_bboxes(superimposed_image, labels)\n\n \n return draw_img","def gpuMBIR(tomo,angles,center,input_params):\n print('Starting GPU MBIR recon')\n #allocate space for final answer \n af.set_device(input_params['gpu_device']) #Set the device number for gpu based code\n #Change tomopy format\n new_tomo=np.transpose(tomo,(1,2,0)) #slice, columns, angles\n im_size = new_tomo.shape[1]\n num_slice = new_tomo.shape[0]\n num_angles=new_tomo.shape[2]\n pad_size=np.int16(im_size*input_params['oversamp_factor'])\n# nufft_scaling = (np.pi/pad_size)**2\n num_iter = input_params['num_iter']\n mrf_sigma = input_params['smoothness']\n mrf_p = input_params['p']\n print('MRF params p=%f sigma=%f' %(mrf_p,mrf_sigma))\n #Initialize structures for NUFFT\n sino={}\n geom={}\n sino['Ns'] = pad_size#Sinogram size after padding\n sino['Ns_orig'] = im_size #size of original sinogram\n sino['center'] = center + (sino['Ns']/2 - sino['Ns_orig']/2) #for padded sinogram\n sino['angles'] = angles\n \n #Initialize NUFFT parameters\n print('Initialize NUFFT params')\n nufft_params = init_nufft_params(sino,geom)\n\n temp_y = afnp.zeros((sino['Ns'],num_angles),dtype=afnp.complex64)\n temp_x = afnp.zeros((sino['Ns'],sino['Ns']),dtype=afnp.complex64)\n x_recon = afnp.zeros((num_slice/2,sino['Ns_orig'],sino['Ns_orig']),dtype=afnp.complex64)\n \n pad_idx = slice(sino['Ns']/2-sino['Ns_orig']/2,sino['Ns']/2+sino['Ns_orig']/2)\n\n #allocate output array\n rec_mbir_final=np.zeros((num_slice,sino['Ns_orig'],sino['Ns_orig']),dtype=np.float32)\n \n #Move all data to GPU\n print('Moving data to GPU')\n slice_1=slice(0,num_slice,2)\n slice_2=slice(1,num_slice,2)\n gdata=afnp.array(new_tomo[slice_1]+1j*new_tomo[slice_2],dtype=afnp.complex64)\n gradient = afnp.zeros((num_slice/2,sino['Ns_orig'],sino['Ns_orig']), dtype=afnp.complex64)#temp array to store the derivative of cost func\n z_recon = afnp.zeros((num_slice/2,sino['Ns_orig'],sino['Ns_orig']),dtype=afnp.complex64)#Nesterov method variables\n t_nes = 1\n \n #Compute Lipschitz of gradient\n print('Computing Lipschitz of gradient')\n x_ones= afnp.ones((1,sino['Ns_orig'],sino['Ns_orig']),dtype=afnp.complex64)\n temp_x[pad_idx,pad_idx]=x_ones[0]\n temp_proj=forward_project(temp_x,nufft_params)\n temp_backproj=(back_project(temp_proj,nufft_params))[pad_idx,pad_idx]\n print('Adding Hessian of regularizer')\n temp_backproj2=afnp.zeros((1,sino['Ns_orig'],sino['Ns_orig']),dtype=afnp.complex64)\n temp_backproj2[0]=temp_backproj\n add_hessian(mrf_sigma,x_ones, temp_backproj2)\n L = np.max([temp_backproj2.real.max(),temp_backproj2.imag.max()])\n print('Lipschitz constant = %f' %(L))\n del x_ones,temp_proj,temp_backproj,temp_backproj2\n\n #loop over all slices\n for iter_num in range(num_iter):\n print('Iteration %d of %d'%(iter_num,num_iter))\n #Derivative of the data fitting term\n for i in range(num_slice/2):\n temp_x[pad_idx,pad_idx]=x_recon[i]\n Ax = forward_project(temp_x,nufft_params)\n temp_y[pad_idx]=gdata[i]\n gradient[i] =(back_project((Ax-temp_y),nufft_params))[pad_idx,pad_idx] #nufft_scaling\n #Derivative of regularization term\n tvd_update(mrf_p,mrf_sigma,x_recon, gradient) \n #x_recon-=gradient/L\n x_recon,z_recon,t_nes=nesterovOGM2update(x_recon,z_recon,t_nes,gradient,L)\n \n #Move to CPU\n #Rescale result to match tomopy\n rec_mbir=np.array(x_recon,dtype=np.complex64)\n rec_mbir_final[slice_1]=np.array(rec_mbir.real,dtype=np.float32)\n rec_mbir_final[slice_2]=np.array(rec_mbir.imag,dtype=np.float32)\n return rec_mbir_final","def warp(im, u, v):\n assert im.shape == u.shape and \\\n u.shape == v.shape\n \n im_warp = np.empty_like(im)\n #\n # Your code here\n #\n ## Hint: You may find function griddata from package scipy.interpolate useful\n ## code inspired by: https://towardsdatascience.com/image-geometric-transformation-in-numpy-and-opencv-936f5cd1d315\n ## https://github.com/rajat95/Optical-Flow-Warping-Tensorflow/blob/master/warp.py\n ## https://sergevideo.blogspot.com/2014/11/writing-simple-optical-flow-in-python.html\n ## https://github.com/liruoteng/OpticalFlowToolkit/blob/master/lib/flowlib.py\n\n # get image dimensions [y, x]\n im_height, im_width = im.shape\n \n # number of pixel\n N = im_height * im_width\n\n iy, ix = np.mgrid[0:im_height, 0:im_width] # int-meshgrid\n fy, fx = np.mgrid[0:im_height:1.0, 0:im_width:1.0] # float-meshgrid\n\n # add the optical flow to the indices (float)\n fx = fx + u\n fy = fy + v\n\n points = np.c_[ix.reshape(N, 1), iy.reshape(N, 1)]\n xi = np.c_[fx.reshape(N, 1), fy.reshape(N, 1)]\n values = im.reshape(N, 1)\n im_interpol = griddata(points, values, xi, method='linear', fill_value=0.0)\n im_warp = im_interpol.reshape(im_height, im_width)\n\n assert im_warp.shape == im.shape\n return im_warp","def vesuvio_example():\n router = Router(topo_file=PROJECT_PATH + \"vtk/Vesuvio\")\n router.routing(32729, 31991)\n # write to vtk\n router.write2vtk(router.acqueduct)\n # render_vtk(\"vtk/Vesuvio\")","def _update_surface_normals(self):\n\n # This is the case if there are too few points to\n # compute normals so there can be values to remove\n\n #can be important for parallel\n self.swarm.shadow_particles_fetch()\n\n if self.empty:\n self.director.data[...] = 0.0\n else:\n\n particle_coords = self.swarm.particleCoordinates.data\n\n Nx = np.empty(self.swarm.particleLocalCount)\n Ny = np.empty(self.swarm.particleLocalCount)\n Nz = np.empty(self.swarm.particleLocalCount)\n\n for i, xyz in enumerate(particle_coords):\n r, neighbours = self.kdtree.query(particle_coords[i], k=4)\n\n # this point is neighbour[0] and neighbour points are neighbours[(1,2,3)]\n XYZ1 = self.kdtree.data[neighbours[1]]\n XYZ2 = self.kdtree.data[neighbours[2]]\n XYZ3 = self.kdtree.data[neighbours[3]]\n\n dXYZ1 = XYZ2 - XYZ1\n dXYZ2 = XYZ3 - XYZ1\n\n # Cross product of those 2 vectors can be use as the local normal (perhaps)\n\n Nx[i], Ny[i], Nz[i] = np.cross(dXYZ1, dXYZ2)\n #if i == 0:\n # print(Nx, Ny, Nz)\n # print(xyz[0], xyz[1],xyz[2])\n # print((self.insidePt[0] - xyz[0]) * Nx[i] )\n\n if (self.insidePt):\n sign = np.sign( (self.insidePt[0] - xyz[0]) * Nx[i] +\n (self.insidePt[1] - xyz[1]) * Ny[i] +\n (self.insidePt[2] - xyz[2]) * Nz[i] )\n Nx[i] *= sign\n Ny[i] *= sign\n Nz[i] *= sign\n\n\n for i in range(0, self.swarm.particleLocalCount):\n scale = 1.0 / np.sqrt(Nx[i]**2 + Ny[i]**2 + Nz[i]**2)\n Nx[i] *= scale\n Ny[i] *= scale\n Nz[i] *= scale\n\n\n self.director.data[:,0] = Nx[:]\n self.director.data[:,1] = Ny[:]\n self.director.data[:,2] = Nz[:]\n\n print(\"Surf Norms\")\n\n return","def polyMultiLayoutUV(*args, flipReversed: bool=True, gridU: int=0, gridV: int=0, layout: int=0,\n layoutMethod: int=0, offsetU: float=0.0, offsetV: float=0.0,\n percentageSpace: float=0.0, prescale: int=0, rotateForBestFit: int=0,\n scale: int=0, sizeU: float=0.0, sizeV: float=0.0, uvSetName: AnyStr=\"\",\n **kwargs)->None:\n pass","def addUVPoly(self,p,uv):\n for (t,uvt) in triangulateUV(p,uv):\n self.addUVTri(t,uvt)\n return self","def triangulationMatting(self):\n\n success = False\n msg = 'Placeholder'\n\n #########################################\n ## PLACE YOUR CODE BETWEEN THESE LINES ##\n #########################################\n if self._images[\"backA\"].shape != self._images[\"backB\"].shape or self._images[\"compA\"].shape != self._images[\"compB\"].shape or self._images[\"compA\"].shape != self._images[\"compB\"].shape or self._images[\"compA\"].shape != self._images[\"compB\"].shape or self._images[\"compA\"].shape != self._images[\"compB\"].shape or self._images[\"compA\"].shape != self._images[\"compB\"].shape:\n success = False\n msg = \"Input files have different sizes.\"\n\n elif (self._images[\"backA\"] is not None) and (self._images[\"backB\"] is not None) \\\n and (self._images[\"compA\"] is not None) and (self._images[\"compB\"] is not None):\n # four rgb arrays\n success = True\n backA = self._images[\"backA\"] / 255.0\n backA.astype(np.float32)\n backB = self._images[\"backB\"] / 255.0\n backB.astype(np.float32)\n compA = self._images[\"compA\"] / 255.0\n compA.astype(np.float32)\n compB = self._images[\"compB\"] / 255.0\n compB.astype(np.float32)\n\n backA_R = backA[:, :, 2]\n backB_R = backB[:, :, 2]\n\n compA_R = compA[:, :, 2]\n compA_G = compA[:, :, 1]\n compA_B = compA[:, :, 0]\n compB_R = compB[:, :, 2]\n compB_G = compB[:, :, 1]\n compB_B = compB[:, :, 0]\n\n backA_G = backA[:, :, 1]\n backB_G = backB[:, :, 1]\n\n backA_B = backA[:, :, 0]\n backB_B = backB[:, :, 0]\n\n\n alpha = 1.0 - (((compA_R - compB_R) * (backA_R - backB_R) +\n (compA_G - compB_G) * (backA_G - backB_G) +\n (compA_B - compB_B) * (backA_B - backB_B)) /\n ((backA_R - backB_R) ** 2 + (backA_G - backB_G) ** 2 + (backA_B - backB_B) ** 2))\n # backA .. comB = image\n # four rgb arrays\n # assume they have the same shape\n # height = backA.shape[0]\n # width = backA.shape[1]\n\n colOut_R = compA_R - backA_R + alpha * backA_R\n colOut_G = compA_G - backA_G + alpha * backA_G\n colOut_B = compA_B - backA_B + alpha * backA_B\n colOut = cv.merge((colOut_B, colOut_G, colOut_R))\n # for i in range(height):\n # for j in range(width):\n # A = np.array([[1, 0, 0, -backA[i, j][2]],\n # [0, 1, 0, -backA[i, j][1]],\n # [0, 0, 1, -backA[i, j][0]],\n # [1, 0, 0, -backB[i, j][2]],\n # [0, 1, 0, -backB[i, j][1]],\n # [0, 0, 1, -backB[i, j][0]]])\n # B = np.array([[compA[i, j][2] - backA[i, j][2]],\n # [compA[i, j][1] - backA[i, j][1]],\n # [compA[i, j][0] - backA[i, j][0]],\n # [compB[i, j][2] - backB[i, j][2]],\n # [compB[i, j][1] - backB[i, j][1]],\n # [compB[i, j][0] - backB[i, j][0]]])\n # x = np.matmul(np.matmul(inv(np.matmul(A.transpose(), A)), A.transpose()), B)\n # '''\n # AT = A.transpose()\n # ATA = np.matmul(AT, A)\n # ATA_inv = inv(ATA)\n # ATA_inv_AT = np.matmul(ATA_inv, AT)\n # x = np.matmul(ATA_inv_AT, B)\n # '''\n # colOut[i, j] = np.array([[x[2][0], x[1][0], x[0][0]]])\n # alpha[i, j] = x[3]\n\n alpha = alpha * 255.0\n colOut *= 255.0\n self._images[\"colOut\"] = colOut\n self._images[\"alphaOut\"] = alpha\n\n\n else:\n msg = \"Missing pictures\"\n #########################################\n\n return success, msg","def do_stuff(self):\n self.create_tourism_raster()","def vector_comp(X, Y, U, V, skip=5, *, t_axis=0, pcolor_kw={}, quiver_kw={}):\n # plot the magnitude of the vectors as a pcolormesh\n magnitude = np.sqrt(U**2+V**2)\n pcolor_block = Pcolormesh(X, Y, magnitude, t_axis=t_axis, **pcolor_kw)\n\n # use a subset of the data to plot the arrows as a quiver plot.\n xy_slice = tuple([slice(None, None, skip)]*len(X.shape))\n\n uv_slice = [slice(None, None, skip)]*len(U.shape)\n uv_slice[t_axis] = slice(None)\n uv_slice = tuple(uv_slice)\n\n quiver_block = Quiver(X[xy_slice], Y[xy_slice],\n U[uv_slice]/magnitude[uv_slice],\n V[uv_slice]/magnitude[uv_slice],\n t_axis=t_axis, **quiver_kw)\n\n return [pcolor_block, quiver_block]","def opticalFlow(im1: np.ndarray, im2: np.ndarray, step_size=10, win_size=5) -> (np.ndarray, np.ndarray):\r\n if im1.ndim == 3:\r\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\r\n if im2.ndim == 3:\r\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\r\n\r\n ker = np.array([[1, 0, -1]])\r\n I_x = cv2.filter2D(im2, -1, ker, cv2.BORDER_REPLICATE)\r\n I_y = cv2.filter2D(im2, -1, ker.T, cv2.BORDER_REPLICATE)\r\n\r\n I_t = im2 - im1\r\n pts = []\r\n uv = []\r\n h, w = I_x.shape[:2]\r\n half_win = win_size // 2\r\n for i in range(half_win, h - half_win + 1, step_size):\r\n for j in range(half_win, w - half_win + 1, step_size):\r\n mat_x = I_x[i - half_win:i + half_win + 1, j - half_win:j + half_win + 1]\r\n mat_y = I_y[i - half_win:i + half_win + 1, j - half_win:j + half_win + 1]\r\n ATA = np.array([[np.sum(mat_x * mat_x), np.sum(mat_x * mat_y)],\r\n [np.sum(mat_x * mat_y), np.sum(mat_y * mat_y)]])\r\n lambdas = np.linalg.eigvals(ATA)\r\n if lambdas.min() > 1 and lambdas.max() / lambdas.min() < 100:\r\n mat_t = I_t[i - half_win:i + half_win + 1, j - half_win:j + half_win + 1]\r\n ATb = np.array([-np.sum(mat_x * mat_t), -np.sum(mat_y * mat_t)])\r\n local_uv = np.linalg.inv(ATA).dot(ATb)\r\n uv.append(local_uv * (-1))\r\n pts.append([j, i])\r\n pts = np.array(pts)\r\n uv = np.array(uv)\r\n return pts, uv","def get_uv(u, v):\n uv = np.zeros((2, 2))\n uv[0][0] = u[0]\n uv[1][0] = u[1]\n uv[0][1] = v[0]\n uv[1][1] = v[1]\n return uv","def uv_at_xy(self, x, y, x0, y0, s0):\n dx, dy = self.distance(x0, y0, x, y)\n #print 'dx, dy:', dx, dy\n rr2 = (dx**2 + dy**2)**-1\n u = - s0 * dy * r_twopi * rr2\n v = s0 * dx * r_twopi * rr2\n #print 'u, v', u, v\n return u, v"],"string":"[\n \"def apply_uvs(mesh, bsp_verts):\\n\\n mesh.uv_textures.new(\\\"UVs\\\")\\n bm = bmesh.new()\\n bm.from_mesh(mesh)\\n\\n if hasattr(bm.faces, \\\"ensure_lookup_table\\\"): \\n bm.faces.ensure_lookup_table()\\n\\n uv_layer = bm.loops.layers.uv[0]\\n\\n for face_idx, current_face in enumerate(bm.faces):\\n current_face.loops[0][uv_layer].uv = bsp_verts[current_face.loops[0].vert.index][1]\\n current_face.loops[1][uv_layer].uv = bsp_verts[current_face.loops[1].vert.index][1]\\n current_face.loops[2][uv_layer].uv = bsp_verts[current_face.loops[2].vert.index][1]\\n \\n bm.to_mesh(mesh)\",\n \"def voxelize4(self, materials):\\n\\t\\tlayers = list()\\n\\t\\tlayersR = list()\\n\\t\\tlayersG = list()\\n\\t\\tlayersB = list()\\n\\t\\t\\n\\t\\tlayerMaterial = list()\\n\\t\\tself.volumeComposition = list()\\n\\t\\tfor l in range(len(materials)):\\n\\t\\t\\tlayerMaterial.append(list())\\n\\t\\t\\tself.volumeComposition.append(list())\\n\\n\\t\\tvolumeGeneral = list()\\n\\t\\tm = 0\\n\\t\\tfor i in self.slicePoints:\\n\\t\\t\\t#print self.boolResult[m].shape\\n\\t\\t\\ttupleResultR = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\\n\\t\\t\\ttupleResultG = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\\n\\t\\t\\ttupleResultB = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\\n\\t\\t\\ttupleMaterial = list()\\n\\t\\t\\tfor l in range(len(materials)):\\n\\t\\t\\t\\ttupleMaterial.append(numpy.zeros(self.boolLayers[m].shape, dtype=float))\\n\\t\\t\\t\\n\\t\\t\\tj = numpy.nditer(self.boolLayers[m], flags=['multi_index'], op_flags=['readwrite'])\\n\\t\\t\\twhile not j.finished:\\n\\t\\t\\t\\tif j[0] == True:\\n\\t\\t\\t\\t#tupleResult[j.multi_index] = round((i[direction] - minValue) * ratio)\\n\\t\\t\\t\\t#tupleResult[j.multi_index] = 78\\n\\t\\t\\t\\t\\tprint type(j.multi_index)\\n\\t\\t\\t\\t\\tprint j.multi_index\\n\\t\\t\\t\\t\\t#tupleResult[j.multi_index] = planeWeight * math.fabs((j.multi_index[1] - planeOrigin[0]) * planeNormal[0] + (j.multi_index[0] - planeOrigin[1]) * planeNormal[1] + (i[2] - planeOrigin[2]) * planeNormal[2]) + pointWeight * math.sqrt(math.pow((j.multi_index[1]- pointValue[0]),2) + math.pow((j.multi_index[0] - pointValue[1]), 2)+math.pow((i[2] - pointValue[2]),2))\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tdistanceList = []\\n\\t\\t\\t\\t\\ttotalDistance = 0.0\\n\\t\\t\\t\\t\\tfor k in range(len(materials)):\\n\\t\\t\\t\\t\\t\\tif materials[k].controlSourceType == \\\"Plane\\\":\\n\\t\\t\\t\\t\\t\\t\\tGplane = math.fabs((j.multi_index[1] - materials[k].origin[0]) * materials[k].normal[0] + (j.multi_index[0] - materials[k].origin[1]) * materials[k].normal[1] + (i[2] - materials[k].origin[2]) * materials[k].normal[2])\\n\\t\\t\\t\\t\\t\\t\\tdistanceList.append(Gplane)\\n\\t\\t\\t\\t\\t\\t\\ttotalDistance += Gplane\\n\\t\\t\\t\\t\\t\\tif materials[k].controlSourceType == \\\"Point\\\":\\n\\t\\t\\t\\t\\t\\t\\tGpoint = (math.sqrt(math.pow((j.multi_index[1]- materials[k].point[0]),2) + math.pow((j.multi_index[0] - materials[k].point[1]), 2)+math.pow((i[2] - materials[k].point[2]),2)))\\n\\t\\t\\t\\t\\t\\t\\tdistanceList.append(Gpoint)\\n\\t\\t\\t\\t\\t\\t\\ttotalDistance += Gpoint\\n\\t\\t\\t\\t\\tfor k in range(len(distanceList)):\\n\\t\\t\\t\\t\\t\\tdistanceList[k] = distanceList[k] / totalDistance\\n\\t\\t\\t\\t\\t\\tdistanceList[k] = 1.0 - distanceList[k]\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\ttupleMaterial[k][j.multi_index] = distanceList[k]\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\ttupleResultR[j.multi_index] += materials[k].materialColor[0] * distanceList[k] * materials[k].weight\\n\\t\\t\\t\\t\\t\\ttupleResultG[j.multi_index] += materials[k].materialColor[1] * distanceList[k] * materials[k].weight\\n\\t\\t\\t\\t\\t\\ttupleResultB[j.multi_index] += materials[k].materialColor[2] * distanceList[k] * materials[k].weight\\n\\t\\t\\t\\t\\t#if(tupleResult[j.multi_index] > 0):\\n\\t\\t\\t\\t\\t#\\ttupleResult[j.multi_index] = round(tupleResult[j.multi_index]) \\n\\t\\t\\t\\t\\t#if(tupleResult[j.multi_index] == 0):\\n\\t\\t\\t\\t\\t#\\t\\ttupleResult[j.multi_index] = 1\\n\\t\\t\\t\\t\\t#if(tupleResult[j.multi_index] < 0):\\n\\t\\t\\t\\t\\t#\\ttupleResult[j.multi_index] = round(0 - tupleResult[j.multi_index]) \\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttupleResultR[j.multi_index] = 0\\n\\t\\t\\t\\t\\ttupleResultG[j.multi_index] = 0\\n\\t\\t\\t\\t\\ttupleResultB[j.multi_index] = 0\\n\\t\\t\\t\\t\\tfor k in range(len(materials)):\\n\\t\\t\\t\\t\\t\\ttupleMaterial[k][j.multi_index] = 0.0\\n\\t\\t\\t\\tj.iternext()\\n\\t\\t\\tlayersR.append(tupleResultR)\\n\\t\\t\\tlayersG.append(tupleResultG)\\n\\t\\t\\tlayersB.append(tupleResultB)\\n\\t\\t\\tfor k in range(len(materials)):\\n\\t\\t\\t\\tlayerMaterial[k].append(tupleMaterial[k])\\n\\t\\t\\t\\t\\n\\t\\t\\tm = m + 1\\n\\t\\tprint \\\"i got here\\\"\\n\\t\\tvolumeR=numpy.array(layersR) # create the 3d volume\\n\\t\\tvolumeG=numpy.array(layersG) \\n\\t\\tvolumeB=numpy.array(layersB)\\n\\t\\tfor k in range(len(materials)):\\n\\t\\t\\tself.volumeComposition[k] = numpy.array(layerMaterial[k])\\n\\t\\t\\n\\t\\tvolumeGeneral.append(volumeR)\\n\\t\\tvolumeGeneral.append(volumeG)\\n\\t\\tvolumeGeneral.append(volumeB)\\n\\t\\treturn volumeGeneral\",\n \"def edge_velocity(self):\\n #reflext x values at x edges\\n self.u[1,:,0] = -self.u[1,:,1]\\n self.u[1,:,-1] = -self.u[1,:,-2]\\n #mirror x values at y edges \\n self.u[1,0,:] = self.u[1,1,:]\\n self.u[1,-1,:] = self.u[1,-2,:]\\n #mirror y values at x edges\\n self.u[0,:,0] = self.u[0,:,1]\\n self.u[0,:,-1] = self.u[0,:,-2]\\n #mirror y values at y edges \\n self.u[0,0,:] = -self.u[0,1,:]\\n self.u[0,-1,:] = -self.u[0,-2,:]\",\n \"def CreateBiPennate1():\\r\\n \\r\\n print('Opening Data...')\\r\\n # Load Surface Mesh Data and generate normals\\r\\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\\r\\n header, PointData, PolygonData = CreateMatrixVTK(VTKString)\\r\\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\\r\\n # Load full volume centroid\\r\\n NCF_Str = OpenData(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\\\",\\\"new_centroids_file.dat\\\")\\r\\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\\r\\n print('Loading Finished \\\\n Rotating Vectors...')\\r\\n \\r\\n # Rotate Vectors\\r\\n RotVectors1 = np.zeros((Vectors1.shape[0],3))\\r\\n\\r\\n idxpos = np.argwhere(Centroids1[:,1] >= 0)\\r\\n idxpos = idxpos.flatten()\\r\\n idxneg = np.argwhere(Centroids1[:,1] < 0)\\r\\n idxneg = idxneg.flatten()\\r\\n\\r\\n PosVectors = RotationTransform(Vectors1[idxpos,:],degZ = 30)\\r\\n NegVectors = RotationTransform(Vectors1[idxneg,:],degZ = -30)\\r\\n RotVectors1[idxpos,:] = PosVectors[:,:]\\r\\n RotVectors1[idxneg,:] = NegVectors[:,:]\\r\\n print('Vectors Rotated \\\\n Inserting Plane...')\\r\\n \\r\\n # Create Plane of vectors through centreline.\\r\\n PlaneCentroids,PlaneVectors = InsertPlane(Centroids1,RotVectors1,50,4)\\r\\n print('Plane Inserted \\\\n Interpolating Centroids...')\\r\\n \\r\\n # Interpolate Vectors\\r\\n Vectors2 = VectorInter(PlaneCentroids,PlaneVectors,Centroids2)\\r\\n # Make the data more sparse to display better.\\r\\n C1,V1 = SparseData(PlaneCentroids,PlaneVectors,1)\\r\\n C2,V2 = SparseData(Centroids2,Vectors2,1)\\r\\n print('Interpolation Finished \\\\n Plotting...')\\r\\n \\r\\n # Plot Data\\r\\n fig = plt.figure()\\r\\n\\r\\n ax1 = fig.add_subplot(121,projection = '3d')\\r\\n DisplaySliceVectors(C1,V1,ax1,5,10)\\r\\n\\r\\n ax2 = fig.add_subplot(122,projection = '3d')\\r\\n DisplaySliceVectors(C2,V2,ax2,5,10)\\r\\n\\r\\n plt.show()\\r\\n\\r\\n header = 'TITLE = \\\\\\\"New Centroid Vectors\\\\\\\"\\\\nVARIABLES = \\\\\\\"XV\\\\\\\", \\\\\\\"YV\\\\\\\", \\\\\\\"ZV\\\\\\\" \\\\nZONE T=\\\\\\\"Step 0 Incr 0\\\\\\\" \\\\nF = VECTORS'\\r\\n\\r\\n np.savetxt(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/BiPennateCentralPlaneFibres30.dat\\\",Vectors2,header = header,comments='')\",\n \"def _prepare_plane(self):\\n verticies = [\\n # main plane - note that the mainplane is scaled so the mat_plane\\n # matrix will it transform to the correct coordinates\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n\\n # coord plane\\n 0, 0,\\n 0, -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], 0,\\n 0, 0,\\n\\n # axes\\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\\n 0, 0, 0, -self.o_wh[1], #y\\n ]\\n\\n colors = [\\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n .9, .9, .9, 9.0, # plot box\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n 0.0, 0.0, 0.0, 1.0, #lines\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n ]\\n\\n self._fonts = []\\n for u in range(1, self._unit_count[0]+1):\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]+0.02)\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]-0.02)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\\n (-self.o_wh[1]+(self.i_border[3])*0.5)\\n ])\\n for u in range(0, self._unit_count[1]):\\n verticies.append(0.02)\\n verticies.append(-self._unit_w[1]*u)\\n verticies.append(-0.02)\\n verticies.append(-self._unit_w[1]*u)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\\n (0.025)*self._scaling[0],\\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\\n ])\\n\\n self._draw_plane_indicies = (0, 12)\\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\\n\\n # convert data into valid data format\\n verticies = numpy.array(verticies, dtype=numpy.float32)\\n colors = numpy.array(colors, dtype=numpy.float32)\\n\\n self._plane_vao = util.VAO()\\n self._plane_vbo = util.VBO(2)\\n\\n with self._plane_vao:\\n # plane verticies\\n with self._plane_vbo.get(0):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(0)\\n\\n # place vertex colors\\n with self._plane_vbo.get(1):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(1)\",\n \"def CreateBiPennate2():\\r\\n \\r\\n print('Opening Data...')\\r\\n # Load Surface Mesh Data and generate normals\\r\\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\\r\\n header, PointData, PolygonData = CreateMatrixVTK(VTKString)\\r\\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\\r\\n Vectors1 = LongaxisOrtho(Vectors1)\\r\\n # Load full volume centroid\\r\\n NCF_Str = OpenData(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/Project_Gastro/workflows/Cesim/musc_mod_v2/OutputFiles\\\",\\\"new_centroids_file.dat\\\")\\r\\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\\r\\n print('Loading Finished \\\\n Rotating Vectors...')\\r\\n \\r\\n # Rotate Vectors\\r\\n RotVectors1 = np.zeros((np.shape(Vectors1)[0],3))\\r\\n\\r\\n idxpos = np.argwhere(Centroids1[:,1] >= 0)\\r\\n idxpos = idxpos.flatten()\\r\\n idxneg = np.argwhere(Centroids1[:,1] < 0)\\r\\n idxneg = idxneg.flatten()\\r\\n\\r\\n PosVectors = RotationTransform(Vectors1[idxpos,:],degZ = -30)\\r\\n NegVectors = RotationTransform(Vectors1[idxneg,:],degZ = 30)\\r\\n RotVectors1[idxpos,:] = PosVectors[:,:]\\r\\n RotVectors1[idxneg,:] = NegVectors[:,:]\\r\\n print('Vectors Rotated \\\\n Inserting Plane...')\\r\\n \\r\\n # Create Plane of vectors through centreline.\\r\\n PlaneCentroids,PlaneVectors = InsertPlane(Centroids1,RotVectors1,50,4)\\r\\n print('Plane Inserted \\\\n Interpolating Centroids...')\\r\\n \\r\\n # Interpolate Vectors\\r\\n Vectors2 = VectorInter(PlaneCentroids,PlaneVectors,Centroids2)\\r\\n # Make the data more sparse to display better.\\r\\n C1,V1 = SparseData(PlaneCentroids,PlaneVectors,0.1)\\r\\n C2,V2 = SparseData(Centroids2,Vectors2,0.1)\\r\\n print('Interpolation Finished \\\\n Plotting...')\\r\\n \\r\\n # Plot Data\\r\\n fig = plt.figure()\\r\\n\\r\\n ax1 = fig.add_subplot(211,projection = '3d')\\r\\n DisplaySliceVectors(C1,V1,ax1,1,1)\\r\\n\\r\\n ax2 = fig.add_subplot(212,projection = '3d')\\r\\n DisplaySliceVectors(C2,V2,ax2,1,1)\\r\\n\\r\\n plt.show()\\r\\n\\r\\n header = 'TITLE = \\\\\\\"New Centroid Vectors\\\\\\\"\\\\nVARIABLES = \\\\\\\"XV\\\\\\\", \\\\\\\"YV\\\\\\\", \\\\\\\"ZV\\\\\\\" \\\\nZONE T=\\\\\\\"Step 0 Incr 0\\\\\\\" \\\\nF = VECTORS'\\r\\n\\r\\n np.savetxt(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/BiPennateCentralPlaneFibres.dat\\\",Vectors2,header = header,comments='')\",\n \"def InterpolateSurfaceVectorsWithPlane():\\r\\n # Load Surface Mesh Data and generate normals\\r\\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\\r\\n header, PointData, PolygonData = CreateMatrixVTK(VTKString)\\r\\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\\r\\n # Load full volume centroid\\r\\n NCF_Str = OpenData(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\\\",\\\"new_centroids_file.dat\\\")\\r\\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\\r\\n print('Loading Finished \\\\n Inserting Plane...')\\r\\n # Create Plane of vectors through centreline.\\r\\n PlaneCentroids,PlaneVectors = InsertPlane(Centroids1,Vectors1,50,8)\\r\\n print('Plane Inserted \\\\n Interpolating Centroids...')\\r\\n # Interpolate Vectors\\r\\n Vectors2 = VectorInter(PlaneCentroids,PlaneVectors,Centroids2)\\r\\n # Make the data more sparse to display better.\\r\\n C1,V1 = SparseData(PlaneCentroids,PlaneVectors,0.5)\\r\\n C2,V2 = SparseData(Centroids2,Vectors2,0.5)\\r\\n print('Interpolation Finished \\\\n Plotting...')\\r\\n # Plot Data\\r\\n fig = plt.figure()\\r\\n\\r\\n ax1 = fig.add_subplot(121,projection = '3d')\\r\\n DisplaySliceVectors(C1,V1,ax1,5,10)\\r\\n\\r\\n ax2 = fig.add_subplot(122,projection = '3d')\\r\\n DisplaySliceVectors(C2,V2,ax2,5,10)\\r\\n\\r\\n plt.show()\\r\\n\\r\\n header = 'TITLE = \\\\\\\"Normal Surface Vectors With Central axis Plane\\\\\\\"\\\\nVARIABLES = \\\\\\\"XV\\\\\\\", \\\\\\\"YV\\\\\\\", \\\\\\\"ZV\\\\\\\" \\\\nZONE T=\\\\\\\"Step 0 Incr 0\\\\\\\" \\\\nF = VECTORS'\\r\\n\\r\\n np.savetxt(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/SurfacePlaneVectorInterpolation.dat\\\",Vectors2,header = header,comments='')\",\n \"def untangleUV(*args, mapBorder: AnyStr=\\\"\\\", maxRelaxIterations: int=0, pinBorder: bool=True,\\n pinSelected: bool=True, pinUnselected: bool=True, relax: AnyStr=\\\"\\\",\\n relaxTolerance: float=0.0, shapeDetail: float=0.0, **kwargs)->int:\\n pass\",\n \"def planeSliceTOAFig(uxmax, uymax, dso, dsl, f, dm, m, n, ax, ay, npoints, xax = True, yax = True):\\n \\n # Calculate coefficients\\n rF2 = rFsqr(dso, dsl, f)\\n uF2x, uF2y = rF2*np.array([1./ax**2, 1./ay**2])\\n lc = lensc(dm, f)\\n alp = rF2*lc\\n coeff = alp*np.array([1./ax**2, 1./ay**2])\\n tg0 = tg0coeff(dso, dsl)\\n tdm0 = tdm0coeff(dm, f)\\n\\n # Calculate caustic intersections\\n ucross = polishedRoots(causticEqSlice, uxmax, uymax, args=(alp, m, n, ax, ay))\\n ncross = len(ucross)\\n upcross = mapToUp(ucross.T, alp, ax, ay)\\n p = np.argsort(upcross[0])\\n upcross = upcross.T[p]\\n ucross = ucross[p]\\n # print(upcross)\\n \\n # Set up quantities for proper u' plane slicing\\n ymin = -m*uxmax + n\\n ymax = m*uxmax + n\\n if ymin < -uymax:\\n xmin = (-uymax - n)/m\\n ymin = m*xmin + n\\n else:\\n xmin = -uxmax\\n if ymax > uymax:\\n xmax = (uymax - n)/m\\n ymax = m*xmax + n\\n else:\\n xmax = uxmax\\n \\n cdist = uxmax/(np.abs(50*lc))\\n \\n bound = np.insert(upcross, 0, np.array([[xmin, ymin]]), axis = 0) # set up boundaries\\n bound = np.append(bound, np.array([[xmax, ymax]]), axis = 0)\\n midpoints = [(bound[i] + bound[i+1])/2. for i in range(len(bound) - 1)] # find middle point between boundaries\\n nzones = len(midpoints)\\n nreal = np.zeros(nzones, dtype = int)\\n for i in range(nzones): # find number of roots at each midpoint\\n mpoint = midpoints[i]\\n nreal[i] = len(findRoots(lensEq, 2*uxmax, 2*uymax, args = (mpoint, coeff)))\\n upxvecs = np.array([np.linspace(bound[i-1][0] + cdist, bound[i][0] - cdist, npoints) for i in range(1, ncross + 2)]) # generate upx vector\\n segs = np.asarray([lineVert(upx, m, n) for upx in upxvecs]) # generate slice across plane\\n ncomplex = np.zeros(nzones) # don't care about complex solutions in this case\\n print(nreal)\\n \\n # Find roots\\n allroots = rootFinder(segs, nreal, ncomplex, npoints, ucross, uxmax, uymax, coeff)\\n \\n # Calculate TOAs\\n alltoas = []\\n for i in range(nzones):\\n toas = obsCalc(deltat, allroots[i], int(nreal[i]), npoints, 1, args = (tg0, tdm0, alp, ax, ay)).real\\n alltoas.append(toas)\\n \\n # Plots\\n fig, ax1 = plt.subplots(figsize=(10, 8), dpi = 100)\\n # grid = gs.GridSpec(2, 2, width_ratios=[4, 1])\\n # ax0 = plt.subplot(grid[1:, 1])\\n # ax1 = plt.subplot(grid[0, 1])\\n \\n \\n # ax2 = plt.subplot(grid[:, 0]) # Plot results\\n colors = assignColor(allroots, nreal)\\n l = []\\n for i in range(len(upxvecs)):\\n zone = alltoas[i]\\n for j in range(len(zone)):\\n line = ax1.plot(upxvecs[i], zone[j], color = colors[i][j], lw = 3.)\\n l.append(line)\\n for i in range(ncross):\\n ax1.plot([upcross[i][0], upcross[i][0]], [-100, 100], color = 'black', ls = 'dashed', scaley = False, scalex = False, lw = 2.5)\\n label = r'$\\\\nu = $' + str(f/GHz) + ' GHz'\\n ax1.text(0.05, 0.9, label, transform=ax1.transAxes, fontsize = 28, bbox=dict(facecolor = 'white', alpha=1.))\\n # ax1.set_ylim(min(alltoas.flatten() - 1), max(alltoas.flatten() + 1))\\n if not xax:\\n ax1.xaxis.set_ticklabels([])\\n else:\\n ax1.set_xlabel(r\\\"$u'_x$\\\", fontsize=28)\\n if not yax:\\n ax1.yaxis.set_ticklabels([])\\n else:\\n ax1.set_ylabel(r'$\\\\Delta t \\\\: (\\\\mu s)$', fontsize=28)\\n if dm > 0:\\n ax1.set_ylim(-0.5, 15.)\\n else:\\n ax1.set_ylim(-2.5, 10.)\\n ax1.tick_params(labelsize = 22)\\n ax1.grid()\\n \\n ax2 = inset_axes(ax1, width='18%', height='23%', loc=1)\\n rx = np.linspace(-uxmax, uxmax, 1000) # Plot caustic surfaces\\n ry = np.linspace(-uxmax, uxmax, 1000)\\n uvec = np.meshgrid(rx, ry)\\n ucaus = causCurve(uvec, coeff)\\n cs = ax2.contour(rx, ry, ucaus, levels = [0, np.inf], linewidths = 0)\\n paths = cs.collections[0].get_paths()\\n uppaths = []\\n for p in paths:\\n cuvert = np.array(p.vertices).T\\n upx, upy = mapToUp(cuvert, alp, ax, ay)\\n ax2.plot(upx, upy, color = 'blue')\\n ax2.plot(np.linspace(xmin, xmax, 10), np.linspace(ymin, ymax, 10), color = 'green')\\n ax2.scatter(upcross.T[0], upcross.T[1], color = 'green')\\n # ax2.set_xlabel(r\\\"$u'_x$\\\")\\n # ax2.set_ylabel(r\\\"$u'_y$\\\")\\n ax2.set_xlim(-uxmax, uxmax)\\n ax2.tick_params(labelsize = 16)\\n # ax1.set_title(\\\"Caustic curves\\\")\\n # ax1.set_aspect('equal', anchor = 'N')\\n ax2.grid()\\n # ax2.tight_layout()\\n \\n plt.tight_layout()\\n plt.show()\\n return\",\n \"def uvregister(self,v):\\n return self.get('patchmesh.uvvertices').intern(v)\",\n \"def uvmap(self, p):\\n # bottom left corner of the plane\\n p00 = self.position - (self.sx * self.n0) / 2 - (self.sy * self.n1) / 2\\n dif_vector = p - p00\\n u = np.dot(dif_vector, self.n0) / self.sx\\n v = np.dot(dif_vector, self.n1) / self.sy\\n return u, v\",\n \"def add_subdivision(self):\\n temp_sub_vertices = []\\n for plane in (self.subdivision_list):\\n current_mids = []\\n mid_m_01 = Vec3d(0, 0, 0, 0)\\n mid_m_12 = Vec3d(0, 0, 0, 0)\\n mid_m_20 = Vec3d(0, 0, 0, 0)\\n\\n mid_m_01.x = (plane[0].x + plane[1].x) / 2\\n mid_m_01.y = (plane[0].y + plane[1].y) / 2\\n mid_m_01.z = (plane[0].z + plane[1].z) / 2\\n mid_m_01.w = plane[0].w\\n\\n mid_m_12.x = (plane[1].x + plane[2].x) / 2\\n mid_m_12.y = (plane[1].y + plane[2].y) / 2\\n mid_m_12.z = (plane[1].z + plane[2].z) / 2\\n mid_m_12.w = plane[1].w\\n\\n mid_m_20.x = (plane[2].x + plane[0].x) / 2\\n mid_m_20.y = (plane[2].y + plane[0].y) / 2\\n mid_m_20.z = (plane[2].z + plane[0].z) / 2\\n mid_m_20.w = plane[2].w\\n\\n current_mids = [mid_m_01, mid_m_12, mid_m_20]\\n temp_sub_vertices.append(current_mids)\\n\\n for index in range(len(current_mids)):\\n v0 = Vec3d(0, 0, 0, 0)\\n v1 = Vec3d(0, 0, 0, 0)\\n v2 = Vec3d(0, 0, 0, 0)\\n\\n v0.x = plane[index].x\\n v0.y = plane[index].y\\n v0.z = plane[index].z\\n\\n v1.x = current_mids[index].x\\n v1.y = current_mids[index].y\\n v1.z = current_mids[index].z\\n\\n v2.x = current_mids[index - 1].x\\n v2.y = current_mids[index - 1].y\\n v2.z = current_mids[index - 1].z\\n\\n temp_sub_vertices.append([v0, v1, v2])\\n\\n self.subdivision_list = temp_sub_vertices\",\n \"def test_set_vx_to_vx_plus_vy(self, cpu):\\n for x in range(0x0, 0xF):\\n for y in range(0x0, 0xF):\\n if x != y:\\n cpu.opcode = 0x8004 | (x << 8) | (y << 4)\\n for v1 in range(0x0, 0xFF):\\n for v2 in range(0x0, 0xFF):\\n cpu.V_register[x] = v1\\n cpu.V_register[y] = v2\\n cpu.set_vx_to_vx_plus_vy()\\n value = v1 + v2\\n if value > 0xFF:\\n assert(cpu.V_register[0xF] == 1)\\n assert(cpu.V_register[x] == value & 0xFF)\\n else:\\n assert(cpu.V_register[0xF] == 0)\\n assert(cpu.V_register[x] == value)\",\n \"def blackbodyUV(temp):\\n lam=lambda wl: planckian(temp, wl)\\n xyz=spectrumToTristim(perfectrefl, lam)\\n uvy=xyzTouvY(xyz)\\n return [uvy[0], uvy[1]*2.0/3]\",\n \"def extforce (u, v):\\r\\n\\r\\n for i in range (height):\\r\\n for j in range (width):\\r\\n u[i,j], v[i,j] = np.stack((u[i,j], v[i,j])) + dt * extacc\\r\\n\\r\\n return u, v\",\n \"def levelsets_to_vector_field(levelsets, stepsize):\\r\\n vector_field_shape = levelsets[0][0].shape\\r\\n y_comp_combined = np.ndarray(vector_field_shape)\\r\\n x_comp_combined = np.ndarray(vector_field_shape)\\r\\n y_comp_combined.fill(np.nan)\\r\\n x_comp_combined.fill(np.nan)\\r\\n\\r\\n for source, target in levelsets:\\r\\n labels_present = set(np.array([source.flatten(),target.flatten()]).flatten())\\r\\n labels_present.remove(0)#relates to background\\r\\n\\r\\n #print(labels_present)\\r\\n for l in labels_present:\\r\\n\\r\\n source_cluster = source == l\\r\\n target_cluster = target == l\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"plt.imshow(source_cluster.astype(np.int32)+target_cluster.astype(np.int32))\\r\\n plt.show()\\r\\n print(\\\"-----------\\\")\\\"\\\"\\\"\\r\\n\\r\\n #plot_gradient_field(source_cluster.astype(np.int32), target_cluster.astype(np.int32))\\r\\n\\r\\n y_comp, x_comp = array_to_vector_field(source_cluster, target_cluster, stepsize=stepsize)\\r\\n y_comp_combined[~np.isnan(y_comp)] = y_comp[~np.isnan(y_comp)]\\r\\n x_comp_combined[~np.isnan(x_comp)] = x_comp[~np.isnan(x_comp)]\\r\\n return y_comp_combined, x_comp_combined\",\n \"def uvregister(self,v):\\n return self.get('mesh.uvvertices').intern(v)\",\n \"def vector_arrows(Out, x, y, z, plot_layer):\\n\\n x = sort_dim(x)\\n y = sort_dim(y)\\n z = sort_dim(z)\\n\\n # length of array in each dimension\\n Ny = len(y)-1\\n Nx = len(x)-1\\n Nz = len(z)-1\\n\\n # coordinates of cell centres\\n # (halfway between L and R edges)\\n xm = 0.5 * (x[:-1] + x[1:])\\n ym = 0.5 * (y[:-1] + y[1:])\\n zm = 0.5 * (z[:-1] + z[1:])\\n\\n # create empty arrays for output\\n U = np.zeros((len(Out.Qx[:,0,0,0]),len(Out.Qx[0,:,0,0]),len(Out.Qx[0,0,:,0]),len(Out.Qx[0,0,0,:])+1)) \\n V = np.zeros((len(Out.Qy[:,0,0,0]),len(Out.Qy[0,:,0,0]),len(Out.Qy[0,0,:,0])+1,len(Out.Qy[0,0,0,:])))\\n W = np.zeros((len(Out.Qz[:,0,0,0]),len(Out.Qz[0,:,0,0])+1,len(Out.Qz[0,0,:,0]),len(Out.Qz[0,0,0,:])))\\n\\n # create mesh\\n X, Y, = np.meshgrid(xm, ym) # coordinates of cell centers\\n Z = np.meshgrid(zm)\\n\\n # iterate through timesteps\\n for t in range(len(Out.Qy[:,0,0,0])): # number of timesteps\\n\\n #grab relevant timestep from Out array\\n Qx = Out.Qx[t,:,:,:]\\n Qy = Out.Qy[t,:,:,:]\\n Qz = Out.Qz[t,:,:,:]\\n\\n # Calculate flows at cell centers by interpolating between L and R faces\\n Ut = np.concatenate((Qx[plot_layer, :, 0].reshape((1, Ny, 1)), \\\\\\n 0.5 * (Qx[plot_layer, :, :-1].reshape((1, Ny, Nx-2)) +\\\\\\n Qx[plot_layer, :, 1: ].reshape((1, Ny, Nx-2))), \\\\\\n Qx[plot_layer, :, -1].reshape((1, Ny, 1))), axis=2).reshape((Ny,Nx))\\n\\n Vt = np.concatenate((Qy[plot_layer, 0, :].reshape((1, 1, Nx)), \\\\\\n 0.5 * (Qy[plot_layer, :-1, :].reshape((1, Ny-2, Nx)) +\\\\\\n Qy[plot_layer, 1:, :].reshape((1, Ny-2, Nx))), \\\\\\n Qy[plot_layer, -1, :].reshape((1, 1, Nx))), axis=1).reshape((Ny,Nx))\\n\\n # average flow across vertical cell to get z flow at cell centre\\n QzTop = Qz[0:-1,:,:]\\n QzBot = Qz[1:,:,:]\\n Wt = (QzTop+QzBot)/2\\n \\n # add results to output arrays\\n U[t,:,:,:] = Ut\\n V[t,:,:,:] = Vt\\n W[t,1:-1,:,:] = Wt\\n\\n return X,Y,Z,U,V,W\",\n \"def scale_uv(self):\\n self.u = [i * self.scale * self.scaleratio for i in self.u]\\n self.v = [i * self.scale for i in self.v]\",\n \"def render(self, scene):\\n if self.degenerate:\\n return\\n # The number of subdivisions around the hoop's radial direction.\\n if self.thickness:\\n band_coverage = scene.pixel_coverage(self.pos, self.thickness)\\n else:\\n band_coverage = scene.pixel_coverage(self.pos, self.radius * 0.1)\\n if band_coverage < 0:\\n band_coverage = 1000\\n bands = sqrt(band_coverage * 4.0)\\n bands = clamp(4, bands, 40)\\n # The number of subdivisions around the hoop's tangential direction.\\n ring_coverage = scene.pixel_coverage(self.pos, self.radius)\\n if ring_coverage < 0:\\n ring_coverage = 1000\\n rings = sqrt(ring_coverage * 4.0)\\n rings = clamp(4, rings, 80)\\n slices = int(rings)\\n inner_slices = int(bands)\\n radius = self.radius\\n inner_radius = self.thickness\\n\\n # Create the vertex and normal arrays.\\n vertices = []\\n normals = []\\n\\n outer_angle_step = 2 * pi / (slices - 1)\\n inner_angle_step = 2 * pi / (inner_slices - 1)\\n outer_angle = 0.\\n for i in range(slices):\\n cos_outer_angle = cos(outer_angle)\\n sin_outer_angle = sin(outer_angle)\\n inner_angle = 0.\\n for j in range(inner_slices):\\n cos_inner_angle = cos(inner_angle)\\n sin_inner_angle = sin(inner_angle)\\n\\n diameter = (radius + inner_radius * cos_inner_angle)\\n vertex_x = diameter * cos_outer_angle\\n vertex_y = diameter * sin_outer_angle\\n vertex_z = inner_radius * sin_inner_angle\\n\\n normal_x = cos_outer_angle * cos_inner_angle\\n normal_y = sin_outer_angle * cos_inner_angle\\n normal_z = sin_inner_angle\\n\\n vertices.extend([vertex_x, vertex_y, vertex_z])\\n normals.extend([normal_x, normal_y, normal_z])\\n inner_angle += inner_angle_step\\n outer_angle += outer_angle_step\\n\\n # Create ctypes arrays of the lists\\n vertices = (gl.GLfloat *len(vertices))(*vertices)\\n normals = (gl.GLfloat * len(normals))(*normals)\\n\\n # Create a list of triangle indices.\\n indices = []\\n for i in range(slices - 1):\\n for j in range(inner_slices - 1):\\n pos = i * inner_slices + j\\n indices.extend([pos, pos + inner_slices, pos + inner_slices +\\n 1])\\n indices.extend([pos, pos + inner_slices + 1, pos + 1])\\n indices = (gl.GLuint * len(indices))(*indices)\\n\\n # Compile a display list\\n self.list = gl.glGenLists(1)\\n gl.glNewList(self.list, gl.GL_COMPILE)\\n self.color.gl_set(self.opacity)\\n\\n gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)\\n gl.glEnableClientState(gl.GL_VERTEX_ARRAY)\\n gl.glEnableClientState(gl.GL_NORMAL_ARRAY)\\n self.model_world_transform(scene.gcf,\\n Vector([self.radius, self.radius,\\n self.radius])).gl_mult()\\n\\n gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)\\n gl.glNormalPointer(gl.GL_FLOAT, 0, normals)\\n gl.glDrawElements(gl.GL_TRIANGLES, len(indices), gl.GL_UNSIGNED_INT,\\n indices)\\n gl.glPopClientAttrib()\\n\\n gl.glEndList()\\n gl.glCallList(self.list)\",\n \"def planeSliceGFig2(uxmax, uymax, rF2, lc, ax, ay, m, n, npoints = 3000, gsizex = 2048, gsizey = 2048, comp = True):\\n\\n # Calculate coefficients\\n alp = rF2*lc\\n coeff = alp*np.array([1./ax**2, 1./ay**2])\\n uF2x, uF2y = rF2*np.array([1./ax**2, 1./ay**2])\\n\\n # Calculate caustic intersections\\n ucross = polishedRoots(causticEqSlice, uxmax, uymax, args = (alp, m, n, ax, ay))\\n ncross = len(ucross)\\n upcross = mapToUp(ucross.T, alp, ax, ay)\\n p = np.argsort(upcross[0])\\n upcross = upcross.T[p]\\n ucross = ucross[p]\\n print(upcross)\\n print(ucross)\\n\\n # Calculate sign of second derivative at caustics\\n sigs = np.zeros(ncross)\\n for i in range(ncross):\\n sigs[i] = np.sign(ax**2/rF2 + lc*(lensh(*[ucross[i][0], ucross[i][1]])[0]))\\n print(sigs)\\n\\n # Set up quantities for proper u' plane slicing\\n ymin = -m*uxmax + n\\n ymax = m*uxmax + n\\n if ymin < -uymax:\\n xmin = (-uymax - n)/m\\n ymin = m*xmin + n\\n else:\\n xmin = -uxmax\\n if ymax > uymax:\\n xmax = (uymax - n)/m\\n ymax = m*xmax + n\\n else:\\n xmax = uxmax\\n xx = np.linspace(gridToPixel(xmin, uxmax, gsizex/2), gridToPixel(xmax, uxmax, gsizex/2) - 1, gsizex)\\n yy = np.linspace(gridToPixel(ymin, uymax, gsizey/2), gridToPixel(ymax, uymax, gsizey/2) - 1, gsizey)\\n\\n cdist = uxmax/(np.abs(100*lc))\\n print(cdist)\\n\\n bound = np.insert(upcross, 0, np.array([[xmin, ymin]]), axis = 0) # set up boundaries\\n bound = np.append(bound, np.array([[xmax, ymax]]), axis = 0)\\n midpoints = [(bound[i] + bound[i+1])/2. for i in range(len(bound) - 1)] # find middle point between boundaries\\n nzones = len(midpoints)\\n nreal = np.zeros(nzones, dtype = int)\\n print(nzones)\\n for i in range(nzones): # find number of roots at each midpoint\\n mpoint = midpoints[i]\\n nreal[i] = int(len(findRoots(lensEq, 2*uxmax, 2*uymax, args = (mpoint, coeff), N = 1000)))\\n upxvecs = np.array([np.linspace(bound[i-1][0] + cdist, bound[i][0] - cdist, npoints) for i in range(1, ncross + 2)]) # generate upx vector\\n segs = np.asarray([lineVert(upx, m, n) for upx in upxvecs]) # generate slice across plane\\n if comp == True:\\n diff = difference(nreal) # determine number of complex solutions\\n ncomplex = np.ones(nzones)*100\\n for i in range(nzones):\\n if diff[i] == 0 or diff[i] == -2:\\n ncomplex[i] = 1\\n elif diff[i] == -4:\\n ncomplex[i] = 2\\n elif diff[i] == 4:\\n ncomplex[i] = 0\\n else:\\n ncomplex = np.zeros(nzones)\\n \\n print(nreal)\\n print(ncomplex)\\n\\n # Solve lens equation at each coordinate\\n allroots = rootFinder(segs, nreal, ncomplex, npoints, ucross, uxmax, uymax, coeff)\\n \\n # Calculate fields\\n allfields = []\\n for i in range(nzones):\\n fields = obsCalc(GOfield, allroots[i], len(allroots[i][0]), npoints, 1, args=(rF2, lc, ax, ay))\\n allfields.append(fields)\\n \\n fogain = np.zeros([nzones, npoints])\\n zogain = np.zeros([nzones, npoints])\\n for i in range(nzones):\\n nroots = nreal[i]\\n if nroots == 1:\\n fogain[i] = np.abs(allfields[i])**2\\n zogain[i] = np.abs(allfields[i])**2\\n else:\\n fogain[i] = np.abs(np.sum(allfields[i], axis = 0))**2\\n zog = 0\\n for j in range(nroots):\\n zog = zog + np.abs(allfields[i][j])**2\\n zogain[i] = zog\\n \\n fogain = fogain.flatten()\\n zogain = zogain.flatten()\\n\\n # Construct uniform asymptotics\\n # asymp = uniAsymp(allroots, allfields, nreal, ncomplex, npoints, nzones, sigs)\\n # interp = UnivariateSpline(upxvecs.flatten(), asymp, s = 0)\\n # finx = np.linspace(xmin, xmax, 4*npoints)\\n # asymG = interp(finx)\\n\\n # KDI\\n rx = np.linspace(-2*uxmax, 2*uxmax, gsizex)\\n ry = np.linspace(-2*uymax, 2*uymax, gsizey)\\n dux = 4*uxmax/gsizex\\n duy = 4*uymax/gsizey\\n extent = (-uxmax, uxmax, -uymax, uymax)\\n ux, uy = np.meshgrid(rx, ry)\\n lens = lensPhase(ux, uy, lc)\\n lensfft = fft2(lens)\\n geo = geoPhase(ux, uy, uF2x, uF2y)\\n geofft = fft2(geo)\\n fieldfft = lensfft*geofft\\n field = fftshift(ifft2(fieldfft))\\n soln = np.abs((dux*duy*field)**2/(4*pi**2*uF2x*uF2y))\\n soln = soln[int(0.25*gsizex):int(0.75*gsizex), int(0.25*gsizey):int(0.75*gsizey)]\\n\\n # Plots\\n fig = plt.figure(figsize = (15, 6), dpi = 100)\\n grid = gs.GridSpec(2, 2)\\n # grid = gs.GridSpec(1, 2)\\n # tableax = plt.subplot(grid[1, :])\\n # tableax2 = plt.subplot(grid[2, :])\\n ax0, ax1 = plt.subplot(grid[:, 0]), plt.subplot(grid[0, 1])\\n # ax0, ax2 = plt.subplot(grid[0]), plt.subplot(grid[1])\\n ax2 = plt.subplot(grid[1, 1], sharex=ax1)\\n\\n rx = np.linspace(-uxmax, uxmax, gsizex)\\n ry = np.linspace(-uymax, uymax, gsizey)\\n ux, uy = np.meshgrid(rx, ry)\\n\\n rx2 = np.linspace(xmin, xmax, gsizex)\\n im0 = ax0.imshow(soln, origin = 'lower', extent = extent, aspect = 'auto') # Plot entire screen\\n cbar = fig.colorbar(im0, ax = ax0)\\n cbar.set_label('G', fontsize = 18)\\n cbar.ax.tick_params(labelsize=14)\\n ucaus = causCurve([ux, uy], lc*np.array([uF2x, uF2y]))\\n cs = plt.contour(np.linspace(-uxmax, uxmax, gsizex), ry, ucaus, levels = [0, np.inf], linewidths = 0)\\n paths = cs.collections[0].get_paths()\\n uppaths = []\\n for p in paths:\\n cuvert = np.array(p.vertices).T\\n upx, upy = mapToUp(cuvert, alp, ax, ay)\\n ax0.plot(upx, upy, color = 'white') # Plot caustic curves\\n ax0.scatter(upcross.T[0], upcross.T[1], color = 'white')\\n ax0.plot(rx2, rx2*m + n, color = 'white') # Plot observer motion\\n ax0.set_xlabel(r\\\"$u'_x$\\\", fontsize = 18)\\n ax0.set_ylim([-uymax, uymax])\\n ax0.set_xlim([-uxmax, uxmax])\\n ax0.set_ylabel(r\\\"$u'_y$\\\", fontsize = 18)\\n ax0.tick_params(labelsize = 14)\\n # ax0.set_title(\\\"Gain in the u' plane\\\")\\n\\n G = map_coordinates(soln.T, np.vstack((xx, yy))) # Plot gain along observer motion\\n G = G - G[-1] + 1\\n ax1.plot(rx2, G, color = 'blue', label = \\\"FFT gain\\\", linewidth = 1.)\\n for caus in upcross.T[0]:\\n ax1.plot([caus, caus], [-10, 1000], ls = 'dashed', color = 'black')\\n xaxis = upxvecs.flatten()\\n ax1.plot(xaxis, zogain, color = 'red', label = r'$0^{th}$ order GO gain')\\n ax1.set_ylim(-cdist, np.max(G) + 1.)\\n ax1.set_xlim(np.min(rx2), np.max(rx2))\\n # ax1.set_xlabel(r\\\"$u'_x$\\\")\\n ax1.set_ylabel('G', fontsize = 18)\\n ax1.legend(loc = 1, fontsize = 12)\\n ax1.tick_params(labelsize = 14)\\n # ax1.set_title(\\\"Slice Gain\\\")\\n ax1.grid()\\n \\n # Plot gain along observer motion\\n ax2.plot(rx2, G, color='blue', label=\\\"FFT gain\\\", linewidth=1.)\\n for caus in upcross.T[0]:\\n ax2.plot([caus, caus], [-10, 1000], ls='dashed', color='black')\\n ax2.plot(xaxis, fogain, color='orange', label=r'$1^{st}$ order GO gain')\\n ax2.set_ylim(-cdist, np.max(G) + 1.)\\n ax2.set_xlim(np.min(rx2), np.max(rx2))\\n ax2.set_xlabel(r\\\"$u'_x$\\\", fontsize = 18)\\n ax2.set_ylabel('G', fontsize = 18)\\n ax2.legend(loc = 1, fontsize = 12)\\n # ax1.set_title(\\\"Slice Gain\\\")\\n ax2.tick_params(labelsize = 14)\\n ax2.grid()\\n grid.tight_layout(fig)\\n\\n # col_labels = ['Parameter', 'Value'] # Create table with parameter values\\n # if np.abs(dm/pctocm) < 1:\\n # dmlabel = \\\"{:.2E}\\\".format(Decimal(dm/pctocm))\\n # else:\\n # dmlabel = str(dm/pctocm)\\n # tablevals = [[r'$d_{so} \\\\: (kpc)$', np.around(dso/pctocm/kpc, 2)], [r'$d_{sl} \\\\: (kpc)$', np.around(dsl/pctocm/kpc, 3)], [r'$a_x \\\\: (AU)$', np.around(ax/autocm, 3)], [r'$a_y \\\\: (AU)$', np.around(ay/autocm, 3)], [r'$DM_l \\\\: (pc \\\\, cm^{-3})$', dmlabel], [r\\\"$\\\\nu$ (GHz)\\\", f/GHz], ['Slope', np.around(m, 2)], ['Offset', n]]\\n # tableax.axis('tight')\\n # tableax.axis('off')\\n # table = tableax.table(cellText = np.asarray(tablevals).T, colWidths = np.ones(8)*0.045, rowLabels = col_labels, loc = 'center')\\n # table.auto_set_font_size(False)\\n # table.set_fontsize(11)\\n # table.scale(2.5, 2.5)\\n \\n # row_label = ['Lens shape']\\n # val = [['$%s$' % sym.latex(lensf)]]\\n # tableax2.axis('tight')\\n # tableax2.axis('off')\\n # table2 = tableax2.table(cellText=val, colWidths=[0.0015*len(sym.latex(lensf))], rowLabels=row_label, loc='top')\\n # table2.auto_set_font_size(False)\\n # table2.set_fontsize(12)\\n # table2.scale(2.5, 2.5)\\n\\n plt.show()\\n return\",\n \"def check_uv_border_crossing(progress_controller=None):\\n if progress_controller is None:\\n progress_controller = ProgressControllerBase()\\n\\n # skip if this is a representation\\n v = staging.get(\\\"version\\\")\\n if v and Representation.repr_separator in v.take_name:\\n progress_controller.complete()\\n return\\n\\n all_meshes = pm.ls(type=\\\"mesh\\\")\\n mesh_count = len(all_meshes)\\n progress_controller.maximum = mesh_count\\n nodes_with_uvs_crossing_borders = []\\n\\n for node in all_meshes:\\n all_uvs = node.getUVs()\\n # before doing anything get all the uvs and skip if all of them are\\n # in the same UV quadrant (which is the wrong name, sorry!)\\n all_uvs_u = sorted(all_uvs[0])\\n all_uvs_v = sorted(all_uvs[1])\\n if int(all_uvs_u[0]) == int(all_uvs_u[-1]) and int(all_uvs_v[0]) == int(\\n all_uvs_v[-1]\\n ):\\n # skip this mesh\\n continue\\n\\n #\\n # Group uvs according to their UV shells\\n #\\n # The following method is 20-25% faster than using getUvShellsIds()\\n #\\n num_uvs = node.numUVs()\\n uv_ids = list(range(num_uvs))\\n\\n uv_shells_and_uv_ids = []\\n uv_shells_and_uv_coords = []\\n\\n i = 0\\n while len(uv_ids) and i < num_uvs + 1:\\n current_uv_id = uv_ids[0]\\n # the polyListComponentConversion takes 85% of the processing time\\n # of getting the uvShells here\\n shell_uv_group_ids = pm.polyListComponentConversion(\\n \\\"%s.map[%s]\\\" % (node.name(), current_uv_id), toUV=1, uvShell=1\\n )\\n\\n uv_shell_uv_ids = []\\n uv_shell_uv_coords = [[], []]\\n for uv_group_ids in shell_uv_group_ids:\\n if \\\":\\\" in uv_group_ids:\\n splits = uv_group_ids.split(\\\":\\\")\\n start_uv_id = int(splits[0].split(\\\"[\\\")[1])\\n end_uv_id = int(splits[1].split(\\\"]\\\")[0])\\n else:\\n splits = uv_group_ids.split(\\\"[\\\")\\n start_uv_id = int(splits[1].split(\\\"]\\\")[0])\\n end_uv_id = start_uv_id\\n\\n for j in range(start_uv_id, end_uv_id + 1):\\n uv_ids.remove(j)\\n uv_shell_uv_ids.append(j)\\n uv_shell_uv_coords[0].append(all_uvs[0][j])\\n uv_shell_uv_coords[1].append(all_uvs[1][j])\\n\\n # store the uv ids and uv coords in this shell\\n uv_shells_and_uv_ids.append(uv_shell_uv_ids)\\n uv_shells_and_uv_coords.append(uv_shell_uv_coords)\\n\\n # go to the next pseudo uv shell id\\n i += 1\\n\\n # now check all uvs per shell\\n try:\\n for uv_shell_uv_coords in uv_shells_and_uv_coords:\\n us = sorted(uv_shell_uv_coords[0])\\n vs = sorted(uv_shell_uv_coords[1])\\n\\n # check first and last u and v values\\n if int(us[0]) != int(us[-1]) or int(vs[0]) != int(vs[-1]):\\n # they are not equal it is crossing spaces\\n nodes_with_uvs_crossing_borders.append(node)\\n break\\n except (IndexError, RuntimeError) as e:\\n print(\\\"%s\\\\nnode: %s\\\" % (e, node))\\n raise RuntimeError()\\n\\n progress_controller.increment()\\n\\n progress_controller.complete()\\n if len(nodes_with_uvs_crossing_borders):\\n # get transform nodes\\n tra_nodes = list(map(lambda x: x.getParent(), nodes_with_uvs_crossing_borders))\\n pm.select(tra_nodes)\\n raise RuntimeError(\\n \\\"\\\"\\\"There are nodes with <b>UV-Shells</b> that are crossing\\n <b>UV BORDERS</b>:<br><br>%s\\\"\\\"\\\"\\n % \\\"<br>\\\".join(map(lambda x: x.name(), tra_nodes[:MAX_NODE_DISPLAY]))\\n )\",\n \"def clean_line_with_uvt_mask(cfg, spw, fullcube=False, parallel=True):\\n log_post(':: Running clean with uv-taper ({0}, {1})'.format(targ.name, spw.name))\\n imagename = cfg.get_basename(spw, ext='smask')\\n maskname = cfg.get_basename(spw, ext='uvtaper') + '.image.smask'\\n spw_id = cfg.get_spw_id(spw)\\n # restart parameters\\n if not fullcube and spw.line_win != -1:\\n start = spw.nchan // 2 - spw.line_win\\n nchan = spw.line_win * 2\\n else:\\n start = -1\\n nchan = -1\\n delete_all_extensions(imagename)\\n tclean(\\n vis=cfg.vis,\\n imagename=imagename,\\n field=targ.name,\\n spw=spw_id,\\n specmode='cube',\\n outframe='lsrk',\\n veltype='radio',\\n restfreq=spw.restfreq,\\n start=start,\\n nchan=nchan,\\n imsize=cfg.array_config.imsize,\\n cell=cfg.array_config.cell,\\n # gridder parameters\\n gridder='standard',\\n # deconvolver parameters\\n deconvolver='multiscale',\\n scales=[0, 5, 10], # point, 1, 2 beam hpbw's\\n smallscalebias=0.6,\\n restoringbeam='common',\\n weighting='briggs',\\n robust=2.0,\\n niter=int(1e6),\\n nsigma=2.0,\\n interactive=False,\\n parallel=parallel,\\n # mask from smoothed uv-taper\\n usemask='user',\\n mask=maskname,\\n verbose=True,\\n )\\n workdir = '{0}.workdirectory'.format(imagename)\\n if os.path.exists(workdir):\\n shutil.rmtree(workdir)\",\n \"def CreateLandmask(Fieldset, test = False):\\n \\n \\n \\\"\\\"\\\"\\n This first set of lines creates a numpy array with u velocities and a numpy\\n array with v velocities. First we get the U and V fields from the dataset. Then\\n we compute a time chunk, which is needed because of the dataset. Then we only\\n take the first slice of the U and V field (we do not need more for finding the land\\n and ocean grids). As last we make an empty array which will be filled with zeros and \\n ones.\\n \\\"\\\"\\\"\\n fU = Fieldset.U\\n fV = Fieldset.V\\n Fieldset.computeTimeChunk(fU.grid.time[0], 1) \\n uvel_mask_c = fU.data[0,:,:] \\n vvel_mask_c = fV.data[0,:,:]\\n# vvel_mask_c = np.roll(vvel_mask_c, 1, axis = 0)\\n landmask = np.zeros((uvel_mask_c.shape[0], uvel_mask_c.shape[1]))\\n \\n \\\"\\\"\\\"\\n The first loop checks the value of the u and v velocitites. Notice that we get the\\n values of two adjacent grid, since we're working with a C-grid.\\n Visualizations of velocities in the C-grids(see below). So for a grid to be flagged identified\\n as a land grid two U velocities and 2 V velocities need to be zero. The first loop makes all\\n ocean grids 1 and land grids 0. \\n ____ ____ ____ ____\\n | V | V | \\n | | | \\n U T U T U\\n | | | \\n |____V____|_____V_____| \\n \\\"\\\"\\\"\\n \\n for i in range (len(landmask[:,0])-1):\\n for j in range (len(landmask[0,:])-1):\\n u1 = uvel_mask_c[i,j]\\n\\n u2 = uvel_mask_c[i,j+1]\\n\\n v1 = vvel_mask_c[i,j]\\n\\n v2 = vvel_mask_c[i+1,j]\\n\\n if u1 != 0 or u2 != 0 or v1 != 0 or v2 != 0:\\n landmask[i,j] = 1\\n \\n \\n \\\"\\\"\\\"\\n Change all zero to 1 and rest 0. since we want the land grids to be 1 and ocean\\n grids to be 0. \\n \\\"\\\"\\\"\\n \\n landmask = ChangeValues(landmask,0,1) \\n \\n \\\"\\\"\\\"\\n The created landmask needs to be shifted upwards one grid. We will\\n use the numpy roll function to do this.\\n \\\"\\\"\\\"\\n \\n if test == True:\\n plt.figure()\\n plt.imshow(landmask)\\n plt.colorbar()\\n \\n return landmask\",\n \"def test_uv_degrid():\\n\\n layout = read_layout(layout_path=f\\\"{test_data}/test_mwa.txt\\\")\\n xyz = enh_xyz(layout=layout, latitude=mwa_geo.latitude.radians)\\n uvw = xyz_uvw(xyz=xyz, freq=freq, dec0=mwa_geo.latitude.radians, ha0=0)\\n uv = uv_degrid(max_lambda=1400, nside=20, uvw=uvw, sigma=3, kersize=21, kernel=None)\\n\\n assert uv.shape == (20, 20)\\n assert uv[0, 0] == 0.0\",\n \"def set_vx_to_vx_or_vy(self, cpu):\\n for x in range(0x0, 0xF):\\n for y in range(0x0, 0xF):\\n if x != y:\\n cpu.opcode = 0x8001 | (x << 8) | (y << 4)\\n for v1 in range(0x0, 0xFF):\\n for v2 in range(0x0, 0xFF):\\n cpu.V_register[x] = v1\\n cpu.V_register[y] = v2\\n cpu.set_vx_to_vx_or_vy()\\n assert(cpu.V_register[x] == v1 | v2)\",\n \"def test_set_vx_to_vx_or_vy(self, cpu):\\n for x in range(0x0, 0xF):\\n for y in range(0x0, 0xF):\\n if x != y:\\n cpu.opcode = 0x8003 | (x << 8) | (y << 4)\\n for v1 in range(0x0, 0xFF):\\n for v2 in range(0x0, 0xFF):\\n cpu.V_register[x] = v1\\n cpu.V_register[y] = v2\\n cpu.set_vx_to_vx_or_vy()\\n assert(cpu.V_register[x] == v1 | v2)\",\n \"def draw_vectors(self):\\r\\n for v in self.vehicles:\\r\\n pg.draw.line(self.screen, (0, 255, 0), v.pos, v.pos + v.extent, 1)\\r\\n pg.draw.circle(self.screen, (0, 255, 0),\\r\\n (int(v.pos.x + v.extent.x),\\r\\n int(v.pos.y + v.extent.y)), 30, 1)\\r\\n start = v.pos + v.extent\\r\\n end = v.target\\r\\n d = end - start\\r\\n if d.length_squared() < 2000:\\r\\n pg.draw.line(self.screen, (0, 255, 0), start, end, 1)\",\n \"def InterpolateSurfaceVectors():\\r\\n \\r\\n # Load Surface Mesh Data and generate normals\\r\\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\\r\\n header, PointData, PolygonData = CreateMatrixVTK(VTKString)\\r\\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\\r\\n # Load full volume centroid\\r\\n NCF_Str = OpenData(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\\\",\\\"new_centroids_file.dat\\\")\\r\\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\\r\\n \\r\\n # Interpolate Vectors\\r\\n Vectors2 = VectorInter(Centroids1,Vectors1,Centroids2)\\r\\n # Make the data sparser to display better.\\r\\n C1,V1 = SparseData(Centroids1,Vectors1,0.2)\\r\\n C2,V2 = SparseData(Centroids2,Vectors2,0.2)\\r\\n\\r\\n # Plot Data\\r\\n fig = plt.figure()\\r\\n\\r\\n ax1 = fig.add_subplot(121,projection = '3d')\\r\\n DisplaySliceVectors(C1,V1,ax1,1,10)\\r\\n\\r\\n ax2 = fig.add_subplot(122,projection = '3d')\\r\\n DisplaySliceVectors(C2,V2,ax2,1,10)\\r\\n\\r\\n plt.show()\\r\\n\\r\\n header = 'TITLE = \\\\\\\"Normal Surface Vectors\\\\\\\"\\\\nVARIABLES = \\\\\\\"XV\\\\\\\", \\\\\\\"YV\\\\\\\", \\\\\\\"ZV\\\\\\\" \\\\nZONE T=\\\\\\\"Step 0 Incr 0\\\\\\\" \\\\nF = VECTORS'\\r\\n\\r\\n np.savetxt(\\\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/NormalVectorInterpolation.dat\\\",Vectors2,header = header,comments='')\",\n \"def run():\\n\\n def assignToon(context):\\n def instanciate_group(nodes, group_name):\\n group = nodes.new(type='ShaderNodeGroup')\\n group.node_tree = bpy.data.node_groups[group_name]\\n return group\\n\\n def assignToonShader(material):\\n '''To do Handle if the material output doesnt exist'''\\n toonShader = instanciate_group(material.node_tree.nodes, \\\"ToonShader_2\\\")\\n node2 = material.node_tree.nodes['Material Output']\\n material.node_tree.links.new(toonShader.outputs[0], node2.inputs[0])\\n\\n objects = bpy.context.selected_objects\\n for obj in objects:\\n if len(obj.material_slots) < 1:\\n\\n bpy.ops.object.material_slot_add()\\n\\n if obj.name not in bpy.data.materials:\\n\\n mat = bpy.data.materials.new(obj.name)\\n else:\\n mat = bpy.data.materials[obj.name]\\n\\n obj.data.materials[0] = mat\\n mat.use_nodes = True\\n\\n for mat in obj.data.materials:\\n if mat.name == '':\\n mat.name = obj.name\\n\\n matNodes = mat.node_tree.nodes\\n\\n assignToonShader(mat)\\n if 'Principled BSDF' in matNodes:\\n matNodes.remove(matNodes['Principled BSDF'])\\n # else:\\n # for n in matNodes:\\n # if n != material.node_tree.nodes['Material Output']:\\n # matNodes.remove(n)\\n\\n\\n shaderPath = r'D:/COMPANIES/loneCoconut/render/MILVIO_CGL/assets/lib/TOONSCEENSETUP/shd/publish/001.000/high/lib_TOONSCEENSETUP_shd.blend'\\n collection_name = 'ToonSceneSetup'\\n # dict_ = {'company': 'loneCoconut',\\n # 'context': 'render',\\n # 'project': 'MILVIO',\\n # 'scope': 'assets',\\n # 'seq': 'lib',\\n # 'shot': 'TOONSCEENSETUP',\\n # 'task': 'shd',\\n # 'user': 'publish',\\n # 'resolution': 'high'}\\n # shaderPath = lm.LumberObject(dict_)\\n # print(shaderPath.latest_version().path_root)\\n #\\n # collection_name = shaderPath.shot\\n\\n if collection_name not in bpy.data.collections:\\n\\n # link all collections starting with 'MyCollection'\\n with bpy.data.libraries.load(shaderPath, link=False) as (data_from, data_to):\\n data_to.collections = [c for c in data_from.collections if c.startswith(collection_name)]\\n\\n # link collection to scene collection\\n for coll in data_to.collections:\\n if coll is not None:\\n bpy.data.scenes['Scene'].collection.children.link(coll)\\n\\n else:\\n print(\\\"Toon Shader Exist\\\")\\n\\n\\n assignToon(bpy.context)\",\n \"def test_set_vx_to_vx_and_vy(self, cpu):\\n for x in range(0x0, 0xF):\\n for y in range(0x0, 0xF):\\n if x != y:\\n cpu.opcode = 0x8002 | (x << 8) | (y << 4)\\n for v1 in range(0x0, 0xFF):\\n for v2 in range(0x0, 0xFF):\\n cpu.V_register[x] = v1\\n cpu.V_register[y] = v2\\n cpu.set_vx_to_vx_and_vy()\\n assert(cpu.V_register[x] == v1 & v2)\",\n \"def makeVideo(self):\\n \\n #from morphforge.morphology.util import TriMeshBuilderVerySimple\\n import sys\\n sys.path.append('/usr/share/pyshared/')\\n \\n #import morphforge\\n from morphforge.morphology.mesh import MeshBuilderRings\\n MonkeyPatchMayaVi()\\n #import enthought.mayavi.mlab as mlab\\n from mayavi import mlab\\n \\n assert len(self.morphs)==1\\n mesh = MeshBuilderRings().build(self.morphs[0])\\n \\n \\n #mlab.options.offscreen = True\\n \\n \\n @mlab.show\\n @mlab.animate(delay=100 )#, ui=False) #(delay=500, ui=False)\\n def _showSimpleCylinders():\\n \\n f = mlab.figure( bgcolor=None, fgcolor=None, engine=None, size=(1024, 768))\\n #f = mlab.gcf() \\n #c = TriMeshBuilderVerySimple(self.morphs[0])\\n #mlab.triangular_mesh(c.x, c.y, c.z, c.triangles, colormap=self.colormap)\\n mlab.triangular_mesh(mesh.vertices[:,0], mesh.vertices[:,1], mesh.vertices[:,2], mesh.triangles, colormap=self.colormap)\\n \\n for i in itertools.count():\\n print i\\n f.scene.camera.azimuth(0.1)\\n mlab.savefig('/home/michael/Desktop/out/O%04d.png'%i)#, size=(1024,768))\\n f.scene.render()\\n if i> 3600:\\n break\\n yield\\n \\n _showSimpleCylinders()\",\n \"def pov_render(self, camera_position = (0,0,-10), camera_target = (0,0,0)):\\n\\n \\\"\\\"\\\"\\n f=pov.File(\\\"demo.pov\\\",\\\"colors.inc\\\",\\\"stones.inc\\\")\\n \\n cam = pov.Camera(location=camera_position, sky=(1,0,1),look_at=camera_target)\\n light = pov.LightSource( camera_position, color=\\\"White\\\")\\n \\n povObjs = [cam, light]\\n for obj in self.objects[1:]:\\n # test coordinate transfroms\\n # print M\\n # vectors = np.array([[0,0,0,1], #origin\\n # [1,0,0,1], # x\\n # [0,1,0,1], # y\\n # [0,0,1,1]]).transpose() # z\\n # origin,x,y,z = (T*vectors).transpose()\\n povObjs.append(povObj(obj))\\n \\n #print tuple(povObjs)\\n f.write(*tuple(povObjs))\\n f.close()\\n #sphere1 = pov.Sphere( (1,1,2), 2, pov.Texture(pov.Pigment(color=\\\"Yellow\\\")))\\n #sphere2 = pov.Sphere( (0,1,2), 2, pov.Texture(pov.Pigment(color=\\\"Yellow\\\")))\\n # composite2 = None#pov.Difference(sphere1, sphere2)\\n # \\n \\n \\n \\n \\n \\n # f.write( cam, composite2, light )\\n # f.close()\\n subprocess.call(\\\"povray +H2400 +W3200 demo.pov\\\", shell=True)\\n os.system(\\\"open demo.png\\\")\\n \\\"\\\"\\\"\",\n \"def test_set_vx_to_vx_minus_vy(self, cpu):\\n for x in range(0x0, 0xF):\\n for y in range(0x0, 0xF):\\n if x != y:\\n cpu.opcode = 0x8005 | (x << 8) | (y << 4)\\n for v1 in range(0x0, 0xFF):\\n for v2 in range(0x0, 0xFF):\\n cpu.V_register[x] = v1\\n cpu.V_register[y] = v2\\n cpu.set_vx_to_vx_minus_vy()\\n value = v1 - v2\\n if value > 0:\\n assert(cpu.V_register[0xF] == 1)\\n else:\\n assert(cpu.V_register[0xF] == 0)\\n if value >= 0:\\n assert(cpu.V_register[x] == value)\\n else:\\n assert(cpu.V_register[x] == 0x100 + value)\",\n \"def __concatenate_planes_to_444yuv_frame(self, y_plane, u_plane, v_plane):\\n np.set_printoptions(formatter={'int': hex})\\n\\n y_plane.shape = (self.frame_height, self.frame_width, 1)\\n u_plane.shape = (self.frame_height, self.frame_width, 1)\\n v_plane.shape = (self.frame_height, self.frame_width, 1)\\n\\n yuv = np.concatenate((y_plane, u_plane, v_plane), axis=2)\\n\\n # Use OpenCV to convert color since the implementation is MUCH faster\\n if self.__convert_to_bgr:\\n yuv = cv.cvtColor(yuv, cv.COLOR_YUV2BGR)\\n\\n return yuv\",\n \"def gen_dtu_mvs_path(dtu_data_folder, mode='training'):\\n sample_list = []\\n \\n # parse camera pairs\\n cluster_file_path = dtu_data_folder + '/Cameras/pair.txt'\\n cluster_list = open(cluster_file_path).read().split()\\n\\n # 3 sets\\n training_set = [2, 6, 7, 8, 14, 16, 18, 19, 20, 22, 30, 31, 36, 39, 41, 42, 44,\\n 45, 46, 47, 50, 51, 52, 53, 55, 57, 58, 60, 61, 63, 64, 65, 68, 69, 70, 71, 72,\\n 74, 76, 83, 84, 85, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,\\n 101, 102, 103, 104, 105, 107, 108, 109, 111, 112, 113, 115, 116, 119, 120,\\n 121, 122, 123, 124, 125, 126, 127, 128]\\n validation_set = [3, 5, 17, 21, 28, 35, 37, 38, 40, 43, 56, 59, 66, 67, 82, 86, 106, 117]\\n evaluation_set = [1, 4, 9, 10, 11, 12, 13, 15, 23, 24, 29, 32, 33, 34, 48, 49, 62, 75, 77, \\n 110, 114, 118]\\n\\n # for each dataset\\n data_set = []\\n if mode == 'training':\\n data_set = training_set\\n elif mode == 'validation':\\n data_set = validation_set\\n elif mode == 'evaluation':\\n data_set = evaluation_set\\n\\n # for each dataset\\n for i in data_set:\\n\\n image_folder = os.path.join(dtu_data_folder, ('Rectified/scan%d' % i))\\n cam_folder = os.path.join(dtu_data_folder, 'Cameras')\\n depth_folder = os.path.join(dtu_data_folder, ('Depths/scan%d' % i))\\n\\n if mode == 'training':\\n # for each lighting\\n for j in range(0, 7):\\n # for each reference image\\n for p in range(0, int(cluster_list[0])):\\n paths = []\\n # ref image\\n ref_index = int(cluster_list[22 * p + 1])\\n ref_image_path = os.path.join(\\n image_folder, ('rect_%03d_%d_r5000.png' % ((ref_index + 1), j)))\\n ref_cam_path = os.path.join(cam_folder, ('%08d_cam.txt' % ref_index))\\n paths.append(ref_image_path)\\n paths.append(ref_cam_path)\\n # view images\\n for view in range(FLAGS.view_num - 1):\\n view_index = int(cluster_list[22 * p + 2 * view + 3])\\n view_image_path = os.path.join(\\n image_folder, ('rect_%03d_%d_r5000.png' % ((view_index + 1), j)))\\n view_cam_path = os.path.join(cam_folder, ('%08d_cam.txt' % view_index))\\n paths.append(view_image_path)\\n paths.append(view_cam_path)\\n # depth path\\n depth_image_path = os.path.join(depth_folder, ('depth_map_%04d.pfm' % ref_index))\\n paths.append(depth_image_path)\\n sample_list.append(paths)\\n else:\\n # for each reference image\\n j = 5\\n for p in range(0, int(cluster_list[0])):\\n paths = []\\n # ref image\\n ref_index = int(cluster_list[22 * p + 1])\\n ref_image_path = os.path.join(\\n image_folder, ('rect_%03d_%d_r5000.png' % ((ref_index + 1), j)))\\n ref_cam_path = os.path.join(cam_folder, ('%08d_cam.txt' % ref_index))\\n paths.append(ref_image_path)\\n paths.append(ref_cam_path)\\n # view images\\n for view in range(FLAGS.view_num - 1):\\n view_index = int(cluster_list[22 * p + 2 * view + 3])\\n view_image_path = os.path.join(\\n image_folder, ('rect_%03d_%d_r5000.png' % ((view_index + 1), j)))\\n view_cam_path = os.path.join(cam_folder, ('%08d_cam.txt' % view_index))\\n paths.append(view_image_path)\\n paths.append(view_cam_path)\\n # depth path\\n depth_image_path = os.path.join(depth_folder, ('depth_map_%04d.pfm' % ref_index))\\n paths.append(depth_image_path)\\n sample_list.append(paths)\\n \\n return sample_list\",\n \"def stempot(self,xmax,ymax,nx,ny,atms,pixelshift,scalefactor):\\n #zed=2 for rutherford scattering of the nucleus, less for screening\\n zed = 1.7\\n\\n ix = numpy.arange(1.0,nx)\\n iy = numpy.arange(1.0,ny)\\n dx = xmax/nx\\n dy = ymax/ny\\n rx = numpy.arange(0,xmax-dx,dx)\\n ry = numpy.arange(0,ymax-dy,dy)\\n\\n Zatom = atms.get_atomic_numbers()\\n #translate atoms such that the center of mass is in the center of the computational cell\\n com = atms.get_center_of_mass()\\n #com = [ 44.40963074 , 44.65497562 , 44.90406073] #for AuNP\\n #com = numpy.array(com)\\n #print 'com',com -0.149836425, 0.29967285, 0\\n #com += [0.41205016875, 0.6742639125, 0] #for rotated line profile \\n #com += [-0.149836425, 0.29967285, 0] #for AuNP\\n #com += pixelshift\\n #print 'com+pixelshift',com\\n cop = xmax/2.0\\n trans = [cop-i for i in com]\\n atms.translate(trans)\\n positions=atms.get_positions()\\n ax=[]\\n ay=[]\\n az=[]\\n for o,t,h in positions:\\n ax.append(o)\\n ay.append(t)\\n az.append(h)\\n ax = numpy.array(ax)\\n ay = numpy.array(ay)\\n az = numpy.array(az)\\n amax = len(Zatom)\\n\\n #find boundaries of slice\\n axmin = min(ax)\\n axmax = max(ax)\\n aymin = min(ay)\\n aymax = max(ay)\\n\\n V= numpy.zeros((nx,ny))\\n\\n #map x and y coords of the atoms to the nearest grid points\\n #A fraction of the atom must be assigned to the closest gridpoints\\n #to avoid sum and difference frequencies appearing in the image\\n #grid point to the left of the atom\\n ix = numpy.array([math.floor(axi/dx) for axi in ax])\\n #apply periodic boundary conditions\\n iax = numpy.array([math.fmod(iaxi,nx) for iaxi in ix])\\n ibx = numpy.array([math.fmod(iaxi+1,nx) for iaxi in ix])\\n #fraction of atom at iax\\n fax = numpy.array([1-math.fmod((axi/dx),1 ) for axi in ax])\\n #grid point above the atom\\n iy = numpy.array([math.floor(ayi/dy) for ayi in ay])\\n #apply periodic boundary conditions\\n iay = numpy.array([math.fmod(iayi,ny) for iayi in iy])\\n iby = numpy.array([math.fmod(iayi+1,ny) for iayi in iy])\\n #fraction of atom at iay \\n fay = numpy.array([1-math.fmod((ayi/dy),1 ) for ayi in ay])\\n #Add each atom to the potential grid\\n V1 = numpy.array([fax[i] * fay[i] * (Zatom[i]**zed) for i in range(len(fax))])\\n V2 = numpy.array([(1-fax[i]) * fay[i] * (Zatom[i]**zed) for i in range(len(fax))])\\n V3 = numpy.array([fax[i] * (1-fay[i]) * (Zatom[i]**zed) for i in range(len(fax))])\\n V4 = numpy.array([(1-fax[i]) * (1-fay[i]) * (Zatom[i]**zed) for i in range(len(fax))])\\n #V1 = numpy.array([fax[i] * fay[i] * scalefactor for i in range(len(fax))])\\n #V2 = numpy.array([(1-fax[i]) * fay[i] * scalefactor for i in range(len(fax))])\\n #V3 = numpy.array([fax[i] * (1-fay[i]) * scalefactor for i in range(len(fax))])\\n #V4 = numpy.array([(1-fax[i]) * (1-fay[i]) * scalefactor for i in range(len(fax))])\\n\\n for j in range(amax):\\n V[iax[j],iay[j]] += V1[j]\\n V[ibx[j],iay[j]] += V2[j]\\n V[iax[j],iby[j]] += V3[j]\\n V[ibx[j],iby[j]] += V4[j]\\n rev_trans = [-1.0*i for i in trans]\\n atms.translate(rev_trans)\\n return V\",\n \"def test_set_vx_to_vy_minus_vx(self, cpu):\\n for x in range(0x0, 0xF):\\n for y in range(0x0, 0xF):\\n if x != y:\\n cpu.opcode = 0x8007 | (x << 8) | (y << 4)\\n for v1 in range(0x0, 0xFF):\\n for v2 in range(0x0, 0xFF):\\n cpu.V_register[x] = v1\\n cpu.V_register[y] = v2\\n cpu.set_vx_to_vy_minus_vx()\\n value = v2 - v1\\n if value > 0:\\n assert(cpu.V_register[0xF] == 1)\\n else:\\n assert(cpu.V_register[0xF] == 0)\\n if value >= 0:\\n assert(cpu.V_register[x] == value)\\n else:\\n assert(cpu.V_register[x] == 0x100 + value)\",\n \"def main_proc(self, ds=5.0):\\n\\n # Preprocessing\\n # downsampling edge pixels\\n pcd_t_ds = self.pcd_t.voxel_down_sample(voxel_size=ds)\\n pcd_t_ds, center_t = centering(pcd_t_ds)\\n self.result_id = 0\\n reg_trans = None\\n\\n self.pcd_registrated = list() # results of ICP\\n for i in range(len(self.pcd_s)):\\n self.pcd_s[i].paint_uniform_color([0.0, 0.0, 1.0])\\n pcd_s_ds = self.pcd_s[i].voxel_down_sample(voxel_size=ds)\\n\\n pcd_s_ds, center_s = centering(pcd_s_ds)\\n ts_c = np.identity(4)\\n ts_c[:3, 3] = -center_s\\n tt_c = np.identity(4)\\n tt_c[:3, 3] = center_t\\n\\n # Registration by ICP algorithm\\n reg = ICPRegistration(pcd_s_ds, pcd_t_ds)\\n reg.set_distance_tolerance(ds * 0.5)\\n mse, rt = reg.registration()\\n if mse < self.mse:\\n self.result_id = i\\n print(\\\"Init:\\\", self.initial_angles[i], self.mse, \\\"==>\\\", mse)\\n self.mse = mse\\n reg_trans = rt\\n TT = np.dot(reg_trans, ts_c)\\n self.trans_final = np.dot(tt_c, TT)\\n\\n # check transformation progress\\n \\\"\\\"\\\"\\n hoge = copy.deepcopy(pcd_s_ds)\\n hoge.paint_uniform_color([1,0,0])\\n mesh_frame = o3d.geometry.TriangleMesh.create_coordinate_frame(size=100., origin=[0.0,0.0,0.0])\\n o3d.visualization.draw_geometries( [mesh_frame,hoge, pcd_t_ds], width=640, height=500)\\n hoge.transform( rt )\\n o3d.visualization.draw_geometries( [mesh_frame,hoge, pcd_t_ds], width=640, height=500)\\n \\\"\\\"\\\"\\n\\n self.pcds = reg.pcds\\n self.d = reg.d\\n # Get registration result\\n # translation[x,y] and rotation\\n _, _, rotate = mat2rpy(self.trans_final)\\n print(\\\"Initial angle is:\\\", self.initial_angles[self.result_id])\\n rotate = np.radians(self.initial_angles[self.result_id]) + rotate\\n translation = self.trans_final[:2, 3]\\n\\n # Choose the direction that results in the smaller rotation\\n if rotate > tau:\\n rotate -= tau\\n elif rotate < 0:\\n rotate += tau\\n\\n self.rotate = rotate\\n return self.rotate, translation, self.mse\",\n \"def uvmap(self, p):\\n pass\",\n \"def planeSliceGFig3(uxmax, uymax, rF2, lc, ax, ay, m, n, npoints = 3000, gsizex = 2048, gsizey = 2048, comp = True):\\n\\n # Calculate coefficients\\n alp = rF2*lc\\n coeff = alp*np.array([1./ax**2, 1./ay**2])\\n uF2x, uF2y = rF2*np.array([1./ax**2, 1./ay**2])\\n\\n # Calculate caustic intersections\\n ucross = polishedRoots(causticEqSlice, uxmax, uymax, args = (alp, m, n, ax, ay))\\n ncross = len(ucross)\\n upcross = mapToUp(ucross.T, alp, ax, ay)\\n p = np.argsort(upcross[0])\\n upcross = upcross.T[p]\\n ucross = ucross[p]\\n print(upcross)\\n print(ucross)\\n\\n # Calculate sign of second derivative at caustics\\n sigs = np.zeros(ncross)\\n for i in range(ncross):\\n sigs[i] = np.sign(ax**2/rF2 + lc*(lensh(*[ucross[i][0], ucross[i][1]])[0]))\\n print(sigs)\\n\\n # Set up quantities for proper u' plane slicing\\n ymin = -m*uxmax + n\\n ymax = m*uxmax + n\\n if ymin < -uymax:\\n xmin = (-uymax - n)/m\\n ymin = m*xmin + n\\n else:\\n xmin = -uxmax\\n if ymax > uymax:\\n xmax = (uymax - n)/m\\n ymax = m*xmax + n\\n else:\\n xmax = uxmax\\n xx = np.linspace(gridToPixel(xmin, uxmax, gsizex/2), gridToPixel(xmax, uxmax, gsizex/2) - 1, gsizex)\\n yy = np.linspace(gridToPixel(ymin, uymax, gsizey/2), gridToPixel(ymax, uymax, gsizey/2) - 1, gsizey)\\n\\n cdist = uxmax/(np.abs(100*lc))\\n print(cdist)\\n\\n bound = np.insert(upcross, 0, np.array([[xmin, ymin]]), axis = 0) # set up boundaries\\n bound = np.append(bound, np.array([[xmax, ymax]]), axis = 0)\\n # print(bound)\\n midpoints = [(bound[i] + bound[i+1])/2. for i in range(len(bound) - 1)] # find middle point between boundaries\\n nzones = len(midpoints)\\n nreal = np.zeros(nzones)\\n print(nzones)\\n for i in range(nzones): # find number of roots at each midpoint\\n mpoint = midpoints[i]\\n nreal[i] = len(findRoots(lensEq, 2*uxmax, 2*uymax, args = (mpoint, coeff), N = 1000))\\n upxvecs = np.array([np.linspace(bound[i-1][0] + cdist, bound[i][0] - cdist, npoints) for i in range(1, ncross + 2)]) # generate upx vector\\n # print(upxvecs)\\n segs = np.asarray([lineVert(upx, m, n) for upx in upxvecs]) # generate slice across plane\\n diff = difference(nreal) # determine number of complex solutions\\n if comp == True:\\n ncomplex = np.ones(nzones)*100\\n for i in range(nzones):\\n if diff[i] == 0 or diff[i] == -2:\\n ncomplex[i] = 1\\n elif diff[i] == -4:\\n ncomplex[i] = 2\\n elif diff[i] == 4:\\n ncomplex[i] = 0\\n else:\\n ncomplex = np.zeros(nzones)\\n \\n print(nreal)\\n print(ncomplex)\\n\\n # Solve lens equation at each coordinate\\n allroots = rootFinder(segs, nreal, ncomplex, npoints, ucross, uxmax, uymax, coeff)\\n \\n # Calculate fields\\n allfields = []\\n for i in range(nzones):\\n fields = obsCalc(GOfield, allroots[i], len(allroots[i][0]), npoints, 3, args=(rF2, lc, ax, ay))\\n allfields.append(fields)\\n\\n # Construct uniform asymptotics\\n asymp = uniAsymp(allroots, allfields, nreal, ncomplex, npoints, nzones, sigs)\\n interp = UnivariateSpline(upxvecs.flatten(), asymp, s = 0)\\n finx = np.linspace(xmin, xmax, 4*npoints)\\n asymG = interp(finx)\\n\\n # KDI\\n rx = np.linspace(-2*uxmax, 2*uxmax, gsizex)\\n ry = np.linspace(-2*uymax, 2*uymax, gsizey)\\n dux = 4*uxmax/gsizex\\n duy = 4*uymax/gsizey\\n extent = (-uxmax, uxmax, -uymax, uymax)\\n ux, uy = np.meshgrid(rx, ry)\\n lens = lensPhase(ux, uy, lc)\\n lensfft = fft2(lens)\\n geo = geoPhase(ux, uy, uF2x, uF2y)\\n geofft = fft2(geo)\\n fieldfft = lensfft*geofft\\n field = fftshift(ifft2(fieldfft))\\n soln = np.abs((dux*duy*field)**2/(4*pi**2*uF2x*uF2y))\\n soln = soln[int(0.25*gsizex):int(0.75*gsizex), int(0.25*gsizey):int(0.75*gsizey)]\\n\\n # Plots\\n fig = plt.figure(figsize = (15, 6), dpi = 100)\\n grid = gs.GridSpec(1, 2)\\n # tableax = plt.subplot(grid[1, :])\\n # tableax2 = plt.subplot(grid[2, :])\\n ax0, ax1 = plt.subplot(grid[0, 0]), plt.subplot(grid[0, 1])\\n\\n rx = np.linspace(-uxmax, uxmax, gsizex)\\n ry = np.linspace(-uymax, uymax, gsizey)\\n ux, uy = np.meshgrid(rx, ry)\\n\\n rx2 = np.linspace(xmin, xmax, gsizex)\\n im0 = ax0.imshow(soln, origin = 'lower', extent = extent, aspect = 'auto') # Plot entire screen\\n cbar = fig.colorbar(im0, ax = ax0)\\n # cbar.set_label(r'$\\\\log{G}$', fontsize = 16)\\n cbar.set_label('G', fontsize=18)\\n cbar.ax.tick_params(labelsize=14)\\n ucaus = causCurve([ux, uy], lc*np.array([uF2x, uF2y]))\\n cs = plt.contour(np.linspace(-uxmax, uxmax, gsizex), ry, ucaus, levels = [0, np.inf], linewidths = 0)\\n paths = cs.collections[0].get_paths()\\n uppaths = []\\n for p in paths:\\n cuvert = np.array(p.vertices).T\\n upx, upy = mapToUp(cuvert, alp, ax, ay)\\n ax0.plot(upx, upy, color = 'white') # Plot caustic curves\\n ax0.scatter(upcross.T[0], upcross.T[1], color = 'white')\\n ax0.plot(rx2, rx2*m + n, color = 'white') # Plot observer motion\\n ax0.set_xlabel(r\\\"$u'_x$\\\", fontsize = 18)\\n ax0.set_ylim([-uymax, uymax])\\n ax0.set_xlim([-uxmax, uxmax])\\n ax0.set_ylabel(r\\\"$u'_y$\\\", fontsize = 18)\\n ax0.tick_params(labelsize = 14)\\n # ax0.set_title(\\\"Gain in the u' plane\\\")\\n\\n G = map_coordinates(soln.T, np.vstack((xx, yy))) # Plot gain along observer motion\\n G = G - G[-1] + 1\\n ax1.plot(rx2, G, color = 'blue', label = \\\"FFT gain\\\")\\n for caus in upcross.T[0]:\\n ax1.plot([caus, caus], [-10, 1000], ls = 'dashed', color = 'black')\\n ax1.plot(finx, asymG, color = 'red', label = r\\\"$2^{nd}$ order GO gain\\\")\\n ax1.set_ylim(-cdist, np.max(asymG) + 1.)\\n ax1.set_xlim(np.min(rx2), np.max(rx2))\\n ax1.set_xlabel(r\\\"$u'_x$\\\", fontsize = 18)\\n ax1.set_ylabel('G', fontsize = 18)\\n # ax1.set_title(\\\"Slice Gain\\\")\\n ax1.tick_params(labelsize = 14)\\n ax1.grid()\\n ax1.legend(loc = 1, fontsize = 14)\\n\\n\\n # col_labels = ['Parameter', 'Value'] # Create table with parameter values\\n # if np.abs(dm/pctocm) < 1:\\n # dmlabel = \\\"{:.2E}\\\".format(Decimal(dm/pctocm))\\n # else:\\n # dmlabel = str(dm/pctocm)\\n # tablevals = [[r'$d_{so} \\\\: (kpc)$', np.around(dso/pctocm/kpc, 2)], [r'$d_{sl} \\\\: (kpc)$', np.around(dsl/pctocm/kpc, 3)], [r'$a_x \\\\: (AU)$', np.around(ax/autocm, 3)], [r'$a_y \\\\: (AU)$', np.around(ay/autocm, 3)], [r'$DM_l \\\\: (pc \\\\, cm^{-3})$', dmlabel], [r\\\"$\\\\nu$ (GHz)\\\", f/GHz], ['Slope', np.around(m, 2)], ['Offset', n]]\\n # tableax.axis('tight')\\n # tableax.axis('off')\\n # table = tableax.table(cellText = np.asarray(tablevals).T, colWidths = np.ones(8)*0.045, rowLabels = col_labels, loc = 'center')\\n # table.auto_set_font_size(False)\\n # table.set_fontsize(11)\\n # table.scale(2.5, 2.5)\\n \\n # row_label = ['Lens shape']\\n # val = [['$%s$' % sym.latex(lensf)]]\\n # tableax2.axis('tight')\\n # tableax2.axis('off')\\n # table2 = tableax2.table(cellText=val, colWidths=[0.0015*len(sym.latex(lensf))], rowLabels=row_label, loc='top')\\n # table2.auto_set_font_size(False)\\n # table2.set_fontsize(12)\\n # table2.scale(2.5, 2.5)\\n\\n grid.tight_layout(fig, pad = 1.5)\\n plt.show()\\n return\",\n \"def project (u, v):\\r\\n\\r\\n # Construct linear system Ap = d\\r\\n A = sps.lil_matrix ((width*height, width*height))\\r\\n d = np.zeros ((width*height))\\r\\n\\r\\n for i in range (1, height-1):\\r\\n for j in range (1, width-1):\\r\\n A[index(i,j), index(i,j)] = 4\\r\\n A[index(i,j), index(i-1,j)] = -1\\r\\n A[index(i,j), index(i+1,j)] = -1\\r\\n A[index(i,j), index(i,j-1)] = -1\\r\\n A[index(i,j), index(i,j+1)] = -1\\r\\n \\r\\n d[index(i,j)] = -1/h * (u[i,j] - u[i,j-1] + v[i,j] - v[i-1,j])\\r\\n\\r\\n # Unhandled boundary cases, we assume solid walls that don't move\\r\\n A[index(0,0), index(0,0)] = 2\\r\\n A[index(0,0), index(1,0)] = -1\\r\\n A[index(0,0), index(0,1)] = -1\\r\\n d[index(0,0)] = -1/h * (u[0,0] + v[0,0])\\r\\n\\r\\n A[index(height-1,0), index(0,0)] = 2\\r\\n A[index(height-1,0), index(height-1,1)] = -1\\r\\n A[index(height-1,0), index(height-2,0)] = -1\\r\\n d[index(height-1,0)] = -1/h * (u[height-1,0] - v[height-2,0])\\r\\n\\r\\n A[index(0,width-1), index(0,width-1)] = 2\\r\\n A[index(0,width-1), index(1,width-1)] = -1\\r\\n A[index(0,width-1), index(0,width-2)] = -1\\r\\n d[index(0,width-1)] = -1/h * (-u[0,width-2] + v[0,width-1])\\r\\n\\r\\n A[index(height-1,width-1), index(height-1,width-1)] = 2\\r\\n A[index(height-1,width-1), index(height-2,width-1)] = -1\\r\\n A[index(height-1,width-1), index(height-1,width-2)] = -1\\r\\n d[index(height-1,width-1)] = -1/h * (-u[height-1,width-2] - v[height-2,width-1])\\r\\n\\r\\n\\r\\n for i in range (1, height-1):\\r\\n A[index(i,0), index(i,0)] = 3\\r\\n A[index(i,0), index(i-1,0)] = -1\\r\\n A[index(i,0), index(i+1,0)] = -1\\r\\n A[index(i,0), index(i,1)] = -1\\r\\n d[index(i,0)] = -1/h * (u[i,0] + v[i,0] - v[i-1,0])\\r\\n\\r\\n for i in range (1, height-1):\\r\\n A[index(i,width-1), index(i,width-1)] = 3\\r\\n A[index(i,width-1), index(i-1,width-1)] = -1\\r\\n A[index(i,width-1), index(i+1,width-1)] = -1\\r\\n A[index(i,width-1), index(i,width-2)] = -1\\r\\n d[index(i,width-1)] = -1/h * (- u[i,width-2] + v[i, width-1] - v[i-1,width-1])\\r\\n\\r\\n for j in range (1, width-1):\\r\\n A[index(0,j), index(0,j)] = 3\\r\\n A[index(0,j), index(1,j)] = -1\\r\\n A[index(0,j), index(0,j-1)] = -1\\r\\n A[index(0,j), index(0,j+1)] = -1\\r\\n d[index(0,j)] = -1/h * (u[0,j] - u[0,j-1] + v[0,j])\\r\\n \\r\\n for j in range (1, width-1):\\r\\n A[index(height-1,j), index(height-1,j)] = 3\\r\\n A[index(height-1,j), index(height-2,j)] = -1\\r\\n A[index(height-1,j), index(height-1,j-1)] = -1\\r\\n A[index(height-1,j), index(height-1,j+1)] = -1\\r\\n d[index(height-1,j)] = -1/h * (u[height-1,j] - u[height-1,j-1] - v[height-2,j])\\r\\n\\r\\n\\r\\n A = A * dt / (density * h**2)\\r\\n\\r\\n A = sps.csr_matrix (A)\\r\\n p = np.reshape(spsolve (A, d), (height, width))\\r\\n\\r\\n # Calculate new velocity field based on this pressure field\\r\\n for i in range (height):\\r\\n for j in range (width):\\r\\n if (i == height-1 and j == width-1) or (i == height-1 and j == 0) or (i == 0 and j == width-1) or (i == 0 and j == 0):\\r\\n # Set vertical velocity to movement of solid wall 0\\r\\n u[i,j] = 0\\r\\n v[i,j] = 0\\r\\n elif i == height-1 or i == 0:\\r\\n u[i,j] = u[i,j] - dt / (density * h) * (p[i,j+1] - p[i,j])\\r\\n v[i,j] = 0\\r\\n elif j == width-1 or j == 0:\\r\\n u[i,j] = 0\\r\\n v[i,j] = v[i,j] - dt / (density * h) * (p[i+1,j] - p[i,j])\\r\\n else:\\r\\n u[i,j] = u[i,j] - dt / (density * h) * (p[i,j+1] - p[i,j])\\r\\n v[i,j] = v[i,j] - dt / (density * h) * (p[i+1,j] - p[i,j])\\r\\n\\r\\n # let's get some inflow\\r\\n u[4:12, 0] = 1\\r\\n\\r\\n return u, v, p\",\n \"def prog(args):\\r\\n i_fname, o_fname, pedestal_params, split_list, Num_W = args\\r\\n mesh = stl.mesh.Mesh.from_file(i_fname)\\r\\n #rotate mesh since by default the rotation axis is along X\\r\\n mesh.rotate([0,1,0],np.pi/2)\\r\\n\\r\\n v_arr = np.round(np.vstack(mesh.vectors).astype(float), decimals=1)\\r\\n\\r\\n splt0_arr = np.array(split_list)\\r\\n splt1_arr = np.roll(splt0_arr,-1)\\r\\n\\r\\n pos = cf.cartesian2cylyndrical(v_arr, Num_W)\\r\\n\\r\\n #make splits\\r\\n pos_list=[]\\r\\n for splt0, splt1 in zip(splt0_arr[:-1], splt1_arr[:-1]):\\r\\n pos_idx = np.where((splt0<=pos[:,:,2]) & (splt1>pos[:,:,2]))[0]\\r\\n print(splt0, splt1)\\r\\n #pos = [r, th, z] sectionwise\\r\\n pos_list.append(pos[pos_idx])\\r\\n #add pedestal mesh\\r\\n\\r\\n for sect_num, pos in enumerate(pos_list):\\r\\n pos = cf.add_pedestal(pos, pedestal_params)\\r\\n profiles=np.zeros_like(pos)\\r\\n\\r\\n for i in np.arange(np.shape(pos)[0]):\\r\\n profiles[i] = cf.cylyndrical2cartesian(pos[i])\\r\\n\\r\\n strokes = np.flipud(np.rot90(profiles))\\r\\n #transform data from longeron nodes [xyz] to:\\r\\n #a_arr - rotation angle around the rotation axis\\r\\n #r_arr - length of a segment perpenticular to the rotation axis and corresponding lateral mesh edge\\r\\n #z_arr - corresponding z coordiantes\\r\\n #v_arr - direction vector of the coresponding lateral mesh edge\\r\\n a_arr, r_arr, z_arr, v_arr = cf.transform(strokes, add_pedestal_bottom=True,add_pedestal_top=True)\\r\\n\\r\\n #make a summary plots\\r\\n cf.plot_loft_paths(profiles)\\r\\n cf.plot_loft_paths(pos)\\r\\n cf.plot_surf(a_arr,z_arr,r_arr)\\r\\n\\r\\n #collect data to the dictionary longeron wise\\r\\n res_dict = {'a_arr':np.rot90(a_arr, k=-1),\\r\\n 'r_arr':np.rot90(r_arr, k=-1),\\r\\n 'z_arr':np.rot90(z_arr, k=-1),\\r\\n 'v_arr':np.rot90(v_arr, k=-1)}\\r\\n\\r\\n #save result dictionary\\r\\n if not o_fname:\\r\\n o_fname = i_fname\\r\\n\\r\\n fname='{}_{}.pickle'.format(o_fname, sect_num)\\r\\n with open(fname, 'wb') as f:\\r\\n # Pickle the 'data' dictionary using the highest protocol available.\\r\\n pickle.dump(res_dict, f, pickle.HIGHEST_PROTOCOL)\\r\\n\\r\\n print(fname, ' saved')\",\n \"def unitQuad_Edge(lens, N=3):\\n template = [ np.array([0,0]), np.array([lens[0], 0]), None, None ] #Template from which to generate other Quad Vertex Lists\\n leftDegenerate = template.copy() #Left Limit of quad if you were to rotate edge 3 CCW about the origin until you no longer can\\n rightDegenerate = template.copy() #Right Limit of quad if you were to rotate edge 2 CW about point 1 until you no longer can,\\n # or alternatively, how far edge 3 can rotate CW until the quad is degenerate\\n try:\\n leftDegenerate[3] = np.array( circleIntersection(leftDegenerate[0], lens[3], leftDegenerate[1], lens[1]+lens[2]) )\\n leftDegenerate[2] = ( lens[1] / (lens[2]+lens[1]) ) * (leftDegenerate[3]-leftDegenerate[1]) + leftDegenerate[1]\\n except: \\n leftDegenerate[3] = np.array([-lens[3],0])\\n leftDegenerate[2] = np.array( circleIntersection(leftDegenerate[3], lens[2], leftDegenerate[1], lens[1]) )\\n\\n try:\\n rightDegenerate[2] = np.array( circleIntersection(rightDegenerate[0], lens[2]+lens[3], rightDegenerate[1], lens[1]) )\\n rightDegenerate[3] = ( lens[3] / (lens[3]+lens[2]) ) * rightDegenerate[2]\\n except:\\n rightDegenerate[2] = np.array([lens[0]+lens[1], 0])\\n rightDegenerate[3] = np.array( circleIntersection(rightDegenerate[0], lens[3], rightDegenerate[2], lens[2]))\\n \\n rightOfOrigin = np.array([1,0]) #Theta = 0 on the Unit Circle\\n thetaMin = angle_between(leftDegenerate[3], rightOfOrigin) #Angle of \\n thetaMax = angle_between(rightDegenerate[3], rightOfOrigin)\\n pitch = (thetaMax - thetaMin) / (N-1)\\n\\n result = []\\n result.append(leftDegenerate) \\n for i in range(1, N-1):\\n result.append(template.copy())\\n result[i][3] = lens[3]*unitCircPt(i*pitch+thetaMin)\\n result[i][2] = np.array(circleIntersection( result[i][3], lens[2], result[i][1], lens[1]))\\n result.append(rightDegenerate) \\n\\n return listify(result)\",\n \"def voxelize1(self,points,triangles,slices, direction):\\n\\t\\t\\n\\t\\tself.dirction = direction\\n\\t\\tself.vertices = points\\n\\t\\tself.triangles = triangles\\n\\t\\n\\t\\tllc,urc=self.find_boundbox(points) # find the lower left corner (llc) and upper right corner (urc) of the vertices\\n\\t\\tself.llc = llc\\n\\t\\tself.urc = urc\\n\\t\\t\\n\\t\\tsliceProto, res=self.prepare_voxel_slice(slices,llc,urc,direction) # create the prototype slice volume for the voxel slicing\\n\\t\\tself.res = res\\n\\t\\tself.sliceProto = sliceProto\\n\\t\\t\\n\\t\\tself.slicePoints, minPoints, maxPoints=self.point_list(res,llc,urc,direction) # prepare the list of points to slice at\\n\\t\\n\\t#partialVoxelSlicer=partial(voxel_slice,points=points,triangles=triangles,res=res,llc=llc,sliceProto=sliceProto) # prepare a single-input version of the voxel slicer for parallelization\\n\\t\\n\\t#pool=multiprocessing.Pool(processes=max(1,multiprocessing.cpu_count()-1)) \\n\\t\\n\\t#layers=pool.map(partialVoxelSlicer,slicePoints) # perform the voxel conversion\\n\\t\\n\\t#volume=numpy.array(layers,dtype='bool') # create the 3d volume\\n\\t\\n\\t#return volume\\n\\t\\tlayersR = list()\\n\\t\\tlayersG = list()\\n\\t\\tlayersB = list()\\n\\t\\tvolumeGeneral = list()\\n\\t\\tself.boolLayers = list()\\n\\t\\t#self.boolResult = list()\\n\\t\\t#maxArray = numpy.amax(slicePoints, axis=0)\\n\\t\\t#minArray = numpy.amin(slicePoints, axis=0)\\n\\t\\tself.maxValue = maxPoints[direction]\\n\\t\\tself.minValue = minPoints[direction]\\n\\t\\tself.ratio = 255 / (self.maxValue - self.minValue)\\n\\t\\tfor i in self.slicePoints:\\n\\t\\t\\tboolResult = self.voxel_slice(i, points, triangles, res, llc, sliceProto, direction)\\n\\t\\t\\tprint boolResult.shape\\n\\t\\t\\ttupleResultR = numpy.zeros(boolResult.shape, dtype=uint8)\\n\\t\\t\\ttupleResultG = numpy.zeros(boolResult.shape, dtype=uint8)\\n\\t\\t\\ttupleResultB = numpy.zeros(boolResult.shape, dtype=uint8)\\n\\t\\t\\t#tupleResult.astype(uint8)\\n\\t\\t\\tj = numpy.nditer(boolResult, flags=['multi_index'], op_flags=['readwrite'])\\n\\t\\t\\twhile not j.finished:\\n\\t\\t\\t\\tif j[0] == True:\\n\\t\\t\\t\\t\\t#tupleResult[j.multi_index] = round((i[direction] - minValue) * self.ratio) + 1\\n\\t\\t\\t\\t\\t#tupleResult[j.multi_index] = 78\\n\\t\\t\\t\\t\\ttupleResultR[j.multi_index] = 0\\n\\t\\t\\t\\t\\ttupleResultG[j.multi_index] = 255\\n\\t\\t\\t\\t\\ttupleResultB[j.multi_index] = 255\\t\\t\\t\\t\\t\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttupleResultR[j.multi_index] = 0\\n\\t\\t\\t\\t\\ttupleResultG[j.multi_index] = 0\\n\\t\\t\\t\\t\\ttupleResultB[j.multi_index] = 0\\n\\t\\t\\t\\tj.iternext()\\n\\t\\t\\tself.boolLayers.append(boolResult)\\n\\t\\t\\tlayersR.append(tupleResultR)\\n\\t\\t\\tlayersG.append(tupleResultG)\\n\\t\\t\\tlayersB.append(tupleResultB)\\n\\t\\tprint \\\"i got here\\\"\\n\\t\\tvolumeR=numpy.array(layersR) # create the 3d volume\\n\\t\\tvolumeG=numpy.array(layersG) \\n\\t\\tvolumeB=numpy.array(layersB)\\n\\t\\tvolumeGeneral.append(volumeR)\\n\\t\\tvolumeGeneral.append(volumeG)\\n\\t\\tvolumeGeneral.append(volumeB)\\n\\t\\t\\n\\t\\tf1=open('./cube.txt', 'w+')\\n\\t\\tprint >> f1, self.boolLayers\\n\\t\\treturn volumeGeneral\",\n \"def planeSliceGnoKDI(uxmax, uymax, rF2, lc, ax, ay, m, n, npoints = 5000, comp = True):\\n\\n # Calculate coefficients\\n alp = rF2*lc\\n coeff = alp*np.array([1./ax**2, 1./ay**2])\\n uF2x, uF2y = rF2*np.array([1./ax**2, 1./ay**2])\\n\\n # Calculate caustic intersections\\n ucross = polishedRoots(causticEqSlice, uxmax, uymax, args = (alp, m, n, ax, ay))\\n ncross = len(ucross)\\n upcross = mapToUp(ucross.T, alp, ax, ay)\\n p = np.argsort(upcross[0])\\n upcross = upcross.T[p]\\n ucross = ucross[p]\\n print(upcross)\\n print(ucross)\\n\\n # Calculate sign of second derivative at caustics\\n sigs = np.zeros(ncross)\\n for i in range(ncross):\\n sigs[i] = np.sign(ax**2/rF2 + lc*(lensh(*[ucross[i][0], ucross[i][1]])[0]))\\n print(sigs)\\n\\n # Set up quantities for proper u' plane slicing\\n ymin = -m*uxmax + n\\n ymax = m*uxmax + n\\n if ymin < -uymax:\\n xmin = (-uymax - n)/m\\n ymin = m*xmin + n\\n else:\\n xmin = -uxmax\\n if ymax > uymax:\\n xmax = (uymax - n)/m\\n ymax = m*xmax + n\\n else:\\n xmax = uxmax\\n\\n cdist = uxmax/(np.abs(50*lc))\\n print(cdist)\\n\\n bound = np.insert(upcross, 0, np.array([[xmin, ymin]]), axis = 0) # set up boundaries\\n bound = np.append(bound, np.array([[xmax, ymax]]), axis = 0)\\n midpoints = [(bound[i] + bound[i+1])/2. for i in range(len(bound) - 1)] # find middle point between boundaries\\n nzones = len(midpoints)\\n nreal = np.zeros(nzones)\\n print(nzones)\\n for i in range(nzones): # find number of roots at each midpoint\\n mpoint = midpoints[i]\\n nreal[i] = len(findRoots(lensEq, 2*uxmax, 2*uymax, args = (mpoint, coeff), N = 1000))\\n upxvecs = np.array([np.linspace(bound[i-1][0] + cdist, bound[i][0] - cdist, npoints) for i in range(1, ncross + 2)]) # generate upx vector\\n segs = np.asarray([lineVert(upx, m, n) for upx in upxvecs]) # generate slice across plane\\n diff = difference(nreal) # determine number of complex solutions\\n if comp == True:\\n ncomplex = np.ones(nzones)*100\\n for i in range(nzones):\\n if diff[i] == 0 or diff[i] == -2:\\n ncomplex[i] = 1\\n elif diff[i] == -4:\\n ncomplex[i] = 2\\n elif diff[i] == 4:\\n ncomplex[i] = 0\\n else:\\n ncomplex = np.zeros(nzones)\\n \\n print(nreal)\\n print(ncomplex)\\n\\n # Solve lens equation at each coordinate\\n allroots = rootFinder(segs, nreal, ncomplex, npoints, ucross, uxmax, uymax, coeff)\\n \\n # Calculate fields\\n allfields = []\\n for i in range(nzones):\\n fields = obsCalc(GOfield, allroots[i], len(allroots[i][0]), npoints, 3, args=(rF2, lc, ax, ay))\\n allfields.append(fields)\\n\\n # Construct uniform asymptotics\\n asymp = uniAsymp(allroots, allfields, nreal, ncomplex, npoints, nzones, sigs)\\n interp = UnivariateSpline(upxvecs.flatten(), asymp, s = 0)\\n finx = np.linspace(xmin, xmax, 4*npoints)\\n asymG = interp(finx)\\n\\n # Plots\\n fig = plt.figure(figsize = (6, 10))\\n # grid = gs.GridSpec(1, 2)\\n # tableax = plt.subplot(grid[1, :])\\n # tableax2 = plt.subplot(grid[2, :])\\n # ax0, ax1 = plt.subplot(grid[0, 0]), plt.subplot(grid[0, 1])\\n\\n # rx = np.linspace(-uxmax, uxmax, gsizex)\\n # ry = np.linspace(-uymax, uymax, gsizey)\\n # ux, uy = np.meshgrid(rx, ry)\\n\\n # rx2 = np.linspace(xmin, xmax, gsizex)\\n # im0 = ax0.imshow(soln, origin = 'lower', extent = extent, aspect = 'auto') # Plot entire screen\\n # cbar = fig.colorbar(im0, ax = ax0)\\n # cbar.set_label(r'$\\\\log{G}$', fontsize = 16)\\n # cbar.set_label('G', fontsize=16)\\n # ucaus = causCurve([ux, uy], lc*np.array([uF2x, uF2y]))\\n # cs = plt.contour(np.linspace(-uxmax, uxmax, gsizex), ry, ucaus, levels = [0, np.inf], linewidths = 0)\\n # paths = cs.collections[0].get_paths()\\n # uppaths = []\\n # for p in paths:\\n # cuvert = np.array(p.vertices).T\\n # upx, upy = mapToUp(cuvert, alp, ax, ay)\\n # ax0.plot(upx, upy, color = 'white') # Plot caustic curves\\n # ax0.scatter(upcross.T[0], upcross.T[1], color = 'white')\\n # ax0.plot(rx2, rx2*m + n, color = 'white') # Plot observer motion\\n # ax0.set_xlabel(r\\\"$u'_x$\\\", fontsize = 16)\\n # ax0.set_ylim([-uymax, uymax])\\n # ax0.set_xlim([-uxmax, uxmax])\\n # ax0.set_ylabel(r\\\"$u'_y$\\\", fontsize = 16)\\n # ax0.set_title(\\\"Gain in the u' plane\\\")\\n\\n # G = map_coordinates(soln.T, np.vstack((xx, yy))) # Plot gain along observer motion\\n # G = G - G[-1] + 1\\n fig = plt.figure(figsize = (7, 3), dpi = 100)\\n ax1 = plt.subplot()\\n # ax1.plot(rx2, G, color = 'blue', label = \\\"Gain from FFT\\\")\\n for caus in upcross.T[0]:\\n ax1.plot([caus, caus], [-10, 1000], ls = 'dashed', color = 'black')\\n ax1.plot(finx, asymG, color = 'blue')\\n ax1.set_ylim(-cdist, np.max(asymG) + 1.)\\n ax1.set_xlim(xmin, xmax)\\n ax1.set_xlabel(r\\\"$u'_x$\\\", fontsize = 16)\\n ax1.set_ylabel('G', fontsize = 16)\\n # ax1.set_title(\\\"Slice Gain\\\")\\n ax1.grid()\\n # ax1.legend(loc = 1)\\n\\n\\n # col_labels = ['Parameter', 'Value'] # Create table with parameter values\\n # if np.abs(dm/pctocm) < 1:\\n # dmlabel = \\\"{:.2E}\\\".format(Decimal(dm/pctocm))\\n # else:\\n # dmlabel = str(dm/pctocm)\\n # tablevals = [[r'$d_{so} \\\\: (kpc)$', np.around(dso/pctocm/kpc, 2)], [r'$d_{sl} \\\\: (kpc)$', np.around(dsl/pctocm/kpc, 3)], [r'$a_x \\\\: (AU)$', np.around(ax/autocm, 3)], [r'$a_y \\\\: (AU)$', np.around(ay/autocm, 3)], [r'$DM_l \\\\: (pc \\\\, cm^{-3})$', dmlabel], [r\\\"$\\\\nu$ (GHz)\\\", f/GHz], ['Slope', np.around(m, 2)], ['Offset', n]]\\n # tableax.axis('tight')\\n # tableax.axis('off')\\n # table = tableax.table(cellText = np.asarray(tablevals).T, colWidths = np.ones(8)*0.045, rowLabels = col_labels, loc = 'center')\\n # table.auto_set_font_size(False)\\n # table.set_fontsize(11)\\n # table.scale(2.5, 2.5)\\n \\n # row_label = ['Lens shape']\\n # val = [['$%s$' % sym.latex(lensf)]]\\n # tableax2.axis('tight')\\n # tableax2.axis('off')\\n # table2 = tableax2.table(cellText=val, colWidths=[0.0015*len(sym.latex(lensf))], rowLabels=row_label, loc='top')\\n # table2.auto_set_font_size(False)\\n # table2.set_fontsize(12)\\n # table2.scale(2.5, 2.5)\\n\\n # grid.tight_layout(fig, pad = 1.5)\\n plt.tight_layout()\\n plt.show()\\n return\",\n \"def ccm_unred(wave, flux, ebv, r_v=\\\"\\\"):\\n import numpy as np\\n wave = np.array(wave, float)\\n flux = np.array(flux, float)\\n \\n if wave.size != flux.size: raise TypeError, 'ERROR - wave and flux vectors must be the same size'\\n \\n if not bool(r_v): r_v = 3.1\\n \\n x = 10000.0/wave\\n npts = wave.size\\n a = np.zeros(npts, float)\\n b = np.zeros(npts, float)\\n \\n ###############################\\n #Infrared\\n \\n good = np.where( (x > 0.3) & (x < 1.1) )\\n a[good] = 0.574 * x[good]**(1.61)\\n b[good] = -0.527 * x[good]**(1.61)\\n \\n ###############################\\n # Optical & Near IR\\n \\n good = np.where( (x >= 1.1) & (x < 3.3) )\\n y = x[good] - 1.82\\n \\n c1 = np.array([ 1.0 , 0.104, -0.609, 0.701, 1.137, \\\\\\n -1.718, -0.827, 1.647, -0.505 ])\\n c2 = np.array([ 0.0, 1.952, 2.908, -3.989, -7.985, \\\\\\n 11.102, 5.491, -10.805, 3.347 ] )\\n \\n a[good] = np.polyval(c1[::-1], y)\\n b[good] = np.polyval(c2[::-1], y)\\n \\n ###############################\\n # Mid-UV\\n \\n good = np.where( (x >= 3.3) & (x < 8) )\\n y = x[good]\\n F_a = np.zeros(np.size(good),float)\\n F_b = np.zeros(np.size(good),float)\\n good1 = np.where( y > 5.9 )\\n \\n if np.size(good1) > 0:\\n y1 = y[good1] - 5.9\\n F_a[ good1] = -0.04473 * y1**2 - 0.009779 * y1**3\\n F_b[ good1] = 0.2130 * y1**2 + 0.1207 * y1**3\\n \\n a[good] = 1.752 - 0.316*y - (0.104 / ( (y-4.67)**2 + 0.341 )) + F_a\\n b[good] = -3.090 + 1.825*y + (1.206 / ( (y-4.62)**2 + 0.263 )) + F_b\\n \\n ###############################\\n # Far-UV\\n \\n good = np.where( (x >= 8) & (x <= 11) )\\n y = x[good] - 8.0\\n c1 = [ -1.073, -0.628, 0.137, -0.070 ]\\n c2 = [ 13.670, 4.257, -0.420, 0.374 ]\\n a[good] = np.polyval(c1[::-1], y)\\n b[good] = np.polyval(c2[::-1], y)\\n \\n # Applying Extinction Correction\\n \\n a_v = r_v * ebv\\n a_lambda = a_v * (a + b/r_v)\\n \\n funred = flux * 10.0**(0.4*a_lambda) \\n \\n return funred\",\n \"def set_und_surface(self):\\n if (self.dimension == '3D'):\\n self.part_RVE.Set(\\n cells=self.part_RVE.cells.getSequenceFromMask(mask=('[#1 ]', ), ),\\n name='Set_RVE')\\n elif (self.dimension == '2D'):\\n self.part_RVE.Set(\\n faces=self.part_RVE.faces.getSequenceFromMask(mask=('[#1 ]', ), ),\\n name='Set_RVE')\\n else:\\n print('dimension Error!')\",\n \"def genebmp(dirName, sou,slnt,dx,dy):\\r\\n\\r\\n if sou=='source':\\r\\n tabres=np.zeros((slnt,dx,dy),np.int16)\\r\\n else:\\r\\n tabres=np.zeros((slnt,dx,dy),np.uint8)\\r\\n\\r\\n\\r\\n dirFileP = os.path.join(dirName, sou)\\r\\n\\r\\n (top,tail)=os.path.split(dirName)\\r\\n print ('generate image in :',tail, 'directory :',sou)\\r\\n fileList =[name for name in os.listdir(dirFileP) if \\\".dcm\\\" in name.lower()]\\r\\n\\r\\n for filename in fileList:\\r\\n FilesDCM =(os.path.join(dirFileP,filename))\\r\\n RefDs = dicom.read_file(FilesDCM)\\r\\n dsr= RefDs.pixel_array\\r\\n dsr=dsr.astype('int16')\\r\\n fxs=float(RefDs.PixelSpacing[0])/avgPixelSpacing\\r\\n scanNumber=int(RefDs.InstanceNumber)\\r\\n if dsr.max()>dsr.min():\\r\\n if sou !='source' :\\r\\n dsr=normi(dsr)\\r\\n dsr=cv2.resize(dsr,None,fx=fxs,fy=fxs,interpolation=cv2.INTER_LINEAR)\\r\\n if sou == 'lung':\\r\\n np.putmask(dsr,dsr>0,100)\\r\\n\\r\\n elif sou !='source':\\r\\n np.putmask(dsr,dsr==1,0)\\r\\n np.putmask(dsr,dsr>0,100)\\r\\n else :\\r\\n dsr[dsr == -2000] = 0\\r\\n intercept = RefDs.RescaleIntercept\\r\\n slope = RefDs.RescaleSlope\\r\\n if slope != 1:\\r\\n dsr = slope * dsr.astype(np.float64)\\r\\n dsr = dsr.astype(np.int16)\\r\\n\\r\\n dsr += np.int16(intercept)\\r\\n dsr = dsr.astype('int16')\\r\\n# print dsr.min(),dsr.max(),dsr.shape\\r\\n dsr=cv2.resize(dsr,None,fx=fxs,fy=fxs,interpolation=cv2.INTER_LINEAR)\\r\\n\\r\\n tabres[scanNumber]= dsr\\r\\n\\r\\n return tabres\",\n \"def uvsRBackwardWarp(mot, rect):\\n u, v, s, x0, y0 = mot\\n return np.r_[rect[:2] - u + s * x0, rect[2:] - v + s * y0] / (1 + s)\",\n \"def test_generate_frustum_planes_stereo() -> None:\\n near_clip_dist = 3.56 # arbitrary value\\n\\n # Set \\\"focal_length_x_px_\\\"\\n fx_px = 3666.534329132812\\n\\n # Set \\\"focal_length_y_px_\\\"\\n fy_px = 3673.5030423482513\\n\\n # Set \\\"focal_center_x_px_\\\"\\n cx_px = 1235.0158218941356\\n\\n # Set \\\"focal_center_y_px_\\\"\\n cy_px = 1008.4536901420888\\n\\n camera_name = \\\"stereo_front_left\\\"\\n height_px = 1550\\n width_px = 2048\\n\\n pinhole_camera = _create_pinhole_camera(\\n fx_px=fx_px,\\n fy_px=fy_px,\\n cx_px=cx_px,\\n cy_px=cy_px,\\n height_px=height_px,\\n width_px=width_px,\\n cam_name=camera_name,\\n )\\n (\\n left_plane,\\n right_plane,\\n near_plane,\\n bottom_plane,\\n top_plane,\\n ) = pinhole_camera.frustum_planes(near_clip_dist)\\n\\n left_plane_expected: NDArrayFloat = np.array([fx_px, 0.0, width_px / 2.0, 0.0])\\n right_plane_expected: NDArrayFloat = np.array([-fx_px, 0.0, width_px / 2.0, 0.0])\\n near_plane_expected: NDArrayFloat = np.array([0.0, 0.0, 1.0, -near_clip_dist])\\n bottom_plane_expected: NDArrayFloat = np.array([0.0, -fx_px, height_px / 2.0, 0.0])\\n top_plane_expected: NDArrayFloat = np.array([0.0, fx_px, height_px / 2.0, 0.0])\\n\\n assert np.allclose(\\n left_plane, left_plane_expected / np.linalg.norm(left_plane_expected)\\n )\\n assert np.allclose(\\n right_plane, right_plane_expected / np.linalg.norm(right_plane_expected)\\n )\\n assert np.allclose(\\n bottom_plane, bottom_plane_expected / np.linalg.norm(bottom_plane_expected)\\n )\\n assert np.allclose(\\n top_plane, top_plane_expected / np.linalg.norm(top_plane_expected)\\n )\\n assert np.allclose(near_plane, near_plane_expected)\",\n \"def calc_uv(self, x, y, prev=False):\\n assert len(x) == self.N\\n assert len(y) == self.N\\n u = np.zeros(self.N, self.x.dtype)\\n v = np.zeros(self.N, self.y.dtype)\\n for n in xrange(self.N):\\n # don't include self interaction\\n if prev:\\n x0 = self.xprev[np.r_[:n,n+1:self.N]]\\n y0 = self.yprev[np.r_[:n,n+1:self.N]]\\n else:\\n x0 = self.x[np.r_[:n,n+1:self.N]]\\n y0 = self.y[np.r_[:n,n+1:self.N]]\\n s0 = self.s[np.r_[:n,n+1:self.N]]\\n u0, v0 = self.uv_at_xy(x[n], y[n], x0, y0, s0)\\n u[n] = u0.sum()\\n v[n] = v0.sum()\\n return u, v\",\n \"def build(self):\\n # Generate a 4x4 identity matrix, which will be the basis for the view matrix.\\n vtm = np.identity( 4, float )\\n # Generate a translation matrix to move the VRP to the origin and then premultiply the vtm by the translation matrix.\\n t1 = np.matrix( [[1, 0, 0, -self.vrp[0, 0]],\\n [0, 1, 0, -self.vrp[0, 1]],\\n [0, 0, 1, -self.vrp[0, 2]],\\n [0, 0, 0, 1] ] )\\n\\n vtm = t1 * vtm\\n\\n # Calculate the view reference axes tu, tvup, tvpn.\\n tu = np.cross(self.vup, self.vpn)\\n tvup = np.cross(self.vpn, tu)\\n tvpn = self.vpn.copy()\\n\\n # Normalize the view axes tu, tvup, and tvpn to unit length.\\n\\n # if this doesn't work, create my own normalize function\\n tu = self.normalize(tu)\\n tvup = self.normalize(tvup)\\n tvpn = self.normalize(tvpn)\\n\\n # Copy the orthonormal axes tu, tvup, and tvpn back to self.u, self.vup and self.vpn.\\n self.u = tu.copy()\\n self.vup = tvup.copy()\\n self.vpn = tvpn.copy()\\n\\n # Use the normalized view reference axes to generate the rotation matrix \\n # to align the view reference axes and then premultiply M by the rotation.\\n r1 = np.matrix( [[ tu[0, 0], tu[0, 1], tu[0, 2], 0.0 ],\\n [ tvup[0, 0], tvup[0, 1], tvup[0, 2], 0.0 ],\\n [ tvpn[0, 0], tvpn[0, 1], tvpn[0, 2], 0.0 ],\\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\\n\\n vtm = r1 * vtm\\n\\n # Translate the lower left corner of the view space to the origin.\\n # extent of the view volume in the X and Y view axes.\\n vtm = self.T( 0.5*self.extent[0], 0.5*self.extent[1], 0 ) * vtm\\n\\n vtm = self.S( -self.screen[0] / self.extent[0], -self.screen[1] / self.extent[1], 1.0 / self.extent[2] ) * vtm\\n\\n vtm = self.T( self.screen[0] + self.offset[0], self.screen[1] + self.offset[1], 0 ) * vtm\\n\\n return vtm\",\n \"def internal_wave_KE(U, V, z, bin_idx, wl_min, wl_max, bin_size):\\n \\n \\n Uspeci = []\\n Vspeci = []\\n Uspec = []\\n Vspec = []\\n Upowi = []\\n Vpowi = []\\n Upower = []\\n Vpower = []\\n U = U**2\\n V = V**2\\n \\n sp = np.nanmean(np.gradient(z, axis=0))\\n \\n U_mx, U_kx = specGrid(U[bin_idx[0,:],0], sp, bin_size)\\n \\n for Ui, Vi in zip(U.T, V.T):\\n \\n for binIn in bin_idx:\\n Uspec1 = SpectrumGen(Ui[binIn], bin_size)\\n Upowi.append(power_spec(Uspec1))\\n Uspeci.append(Uspec1)\\n Vspec1 = SpectrumGen(Vi[binIn], bin_size)\\n Vpowi.append(power_spec(Vspec1))\\n Vspeci.append(Vspec1)\\n \\n Uspeci = np.vstack(Uspeci)\\n Vspeci = np.vstack(Vspeci)\\n Upowi = np.vstack(Upowi)\\n Vpowi = np.vstack(Vpowi)\\n \\n Uspec.append(Uspeci)\\n Vspec.append(Vspeci)\\n Upower.append(Upowi)\\n Vpower.append(Vpowi)\\n Uspeci = []\\n Vspeci = []\\n Upowi = []\\n Vpowi = []\\n \\n # integrate Power Spec of U and V between chosen vertical wavelengths\\n Uint = []\\n Vint = []\\n \\n for Us, Vs in zip(Upower, Vpower):\\n Ui = np.vstack([power_int_smart(binIn,\\\\\\n U_mx, wl_min, wl_max) for binIn in Us])\\n Vi = np.vstack([power_int_smart(binIn,\\\\\\n U_mx, wl_min, wl_max) for binIn in Vs])\\n Uint.append(Ui)\\n Vint.append(Vi)\\n \\n Ui = []\\n Vi = []\\n \\n \\n Uint = np.hstack(Uint)\\n Vint = np.hstack(Vint)\\n \\n Ek = 0.5*(Uint + Vint)\\n \\n return Ek, Upower, Vpower, U_kx, Uspec, Vspec\",\n \"def _forward(self, m, v_k):\\n tmp = gpuarray.zeros(self._dest_shape,\\n dtype=self._op.precision_complex)\\n\\n self._op.apply(m, tmp)\\n self._op.adjoint(tmp, v_k)\\n # v_k = v_k + bla.*m\\n if self._double:\\n add_scaled_vector_vector_double(v_k, v_k, self._weights, m)\\n else:\\n add_scaled_vector_vector(v_k, v_k, self._weights, m)\\n tmp.gpudata.free()\",\n \"def removeplane(img, slce=0.4):\\n img[img == 0] = np.nan\\n\\n xr, yr = np.arange(slce*img.shape[0],(1-slce)*img.shape[0],dtype=int),\\\\\\n np.arange(slce*img.shape[1],(1-slce)*img.shape[1],dtype=int)\\n x, y = np.meshgrid(xr,yr)\\n\\n \\n subimg = img[xr[0]:xr[-1]+1,yr[0]:yr[-1]+1]\\n imgf = subimg[np.isfinite(subimg)].flatten()\\n\\n vecs = np.ones((5,imgf.size))\\n vecs[0,:] = x[np.isfinite(subimg)].flatten()\\n vecs[1,:] = y[np.isfinite(subimg)].flatten()\\n vecs[2,:] = x[np.isfinite(subimg)].flatten()**2\\n vecs[3,:] = y[np.isfinite(subimg)].flatten()**2\\n\\n C = vecs.dot(vecs.T)\\n xv = la.inv(C).dot(vecs.dot(imgf[:,np.newaxis]))\\n x, y = np.meshgrid(np.arange(img.shape[0]), np.arange(img.shape[1]))\\n\\n img -= (xv[0]*x + xv[1]*y + \\\\\\n xv[2]*x**2 + xv[3]*y**2 + \\\\\\n xv[4])\\n return img\",\n \"def generaCubo(self):\\r\\n #Use Panda predefined format for vertex coordinate only\\r\\n format = GeomVertexFormat.getV3()\\r\\n \\r\\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \\r\\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\\r\\n \\r\\n #I will have to write vertex data so I create a writer for these data\\r\\n vertex = GeomVertexWriter(vdata, 'vertex')\\r\\n \\r\\n #I now use the writer to add vertex data\\r\\n vertex.addData3f(0, 0, 0)\\r\\n vertex.addData3f(1, 1, 1)\\r\\n vertex.addData3f(0, 1, 1)\\r\\n vertex.addData3f(0, 1, 0)\\r\\n vertex.addData3f(0, 0, 1)\\r\\n vertex.addData3f(1, 0, 0)\\r\\n vertex.addData3f(1, 0, 1)\\r\\n vertex.addData3f(1, 1, 0)\\r\\n \\r\\n #I now create 12 triangles\\r\\n prim = GeomTriangles(Geom.UHStatic)\\r\\n\\r\\n #and then I add vertex to them\\r\\n #Next time use addVertices(0,1,2) !!!\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(3)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(2)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(4)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(2)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(3)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(5)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n #Create a Geom to bing vertex data to primitives\\r\\n geom = Geom(vdata)\\r\\n geom.addPrimitive(prim)\\r\\n\\r\\n #Create a node for the Geom in order to be able to render it\\r\\n node = GeomNode('gnode')\\r\\n node.addGeom(geom)\\r\\n\\r\\n #Adde the node to the scene graph == render it!\\r\\n nodePath = render.attachNewNode(node)\\r\\n \\r\\n #is this needed?\\r\\n nodePath.setPos( 0, 5, 0)\\r\\n \\r\\n self.camera.lookAt(nodePath)\\r\\n \\r\\n base.setBackgroundColor( .0, .0, .0 )\\r\\n \\r\\n taskMgr.add(self.SpinCameraTask, \\\"SpinCameraTask\\\")\",\n \"def set_original_planes(self, display_opt):\\n\\n # get 4-chamber view\\n four_ch_view_plane_normal = self.find_4ch_view(display_opt)\\n\\n # set rodriguez rotation around midline (apex to C)\\n axis_of_rot = np.array(self.epi_apex_node - self.C)\\n self.axis_of_rot_normalized = axis_of_rot/np.linalg.norm(axis_of_rot)\\n\\n # get 2-chamber view (90-counterclock rotation from 4ch)\\n new_P = my_rodriguez_rotation(self.plane_pts, self.axis_of_rot_normalized,\\n math.radians(self.orig_view_angles[1])) # rodriguez rotation around midline\\n two_ch_view_plane_normal = find_plane_eq(new_P[0, :], new_P[1, :], new_P[2, :])\\n\\n # get 3-chamber view (additional 30-60 counterclock rotation from 3ch)\\n new_P = my_rodriguez_rotation(self.plane_pts, self.axis_of_rot_normalized, math.radians(self.orig_view_angles[2]))\\n three_ch_view_plane_normal = find_plane_eq(new_P[0, :], new_P[1, :], new_P[2, :])\\n\\n if display_opt:\\n _ = self.mesh_slicer(four_ch_view_plane_normal, 'mesh')\\n _ = self.mesh_slicer(two_ch_view_plane_normal, 'mesh')\\n _ = self.mesh_slicer(three_ch_view_plane_normal, 'mesh')\\n\\n self.original_planes = np.vstack((four_ch_view_plane_normal,\\n two_ch_view_plane_normal,\\n three_ch_view_plane_normal))\",\n \"def addUVPatch(self,p,uv):\\n assert len(p) == 16\\n assert len(uv) == 4\\n indexPatch = [self.register(v) for v in p]\\n indexUVPatch = [self.uvregister(v) for v in uv]\\n self.get('patchmesh.patches').append(indexPatch)\\n self.get('patchmesh.uvpatches').append(indexUVPatch)\",\n \"def _forward(self, m, v_k):\\n tmp = gpuarray.zeros(self._dest_shape, dtype=np.complex64, order='C')\\n self._op.apply(m, tmp)\\n self._op.adjoint(tmp, v_k)\\n add_scaled_vector(v_k, m, self._tau, v_k)\",\n \"def test_set_vx_to_vy(self, cpu):\\n for x in range(0x0, 0xF):\\n for y in range(0x0, 0xF):\\n if x != y:\\n cpu.opcode = 0x8000 | (x << 8) | (y << 4)\\n for v in range(0x0, 0xFF):\\n cpu.V_register[y] = v\\n cpu.set_vx_to_vy()\\n assert(cpu.V_register[x] == v)\",\n \"def make_raw_vertex_image(data1, cmap = 'hot', vmin = 0, vmax = 1, \\n data2 = [], vmin2 = 0, vmax2 = 1, subject = 'fsaverage', data2D = False):\\n \\n # Get curvature\\n curv = cortex.db.get_surfinfo(subject, type = 'curvature', recache=False)#,smooth=1)\\n # Adjust curvature contrast / color. Alternately, you could work\\n # with curv.data, maybe threshold it, and apply a color map. \\n curv.data[curv.data>0] = .1\\n curv.data[curv.data<=0] = -.1\\n #curv.data = np.sign(curv.data.data) * .25\\n \\n curv.vmin = -1\\n curv.vmax = 1\\n curv.cmap = 'gray'\\n \\n # Create display data \\n vx = cortex.Vertex(data1, subject, cmap = cmap, vmin = vmin, vmax = vmax)\\n \\n # Pick an arbitrary region to mask out\\n # (in your case you could use np.isnan on your data in similar fashion)\\n if data2D:\\n data2[np.isnan(data2)] = vmin2\\n norm2 = colors.Normalize(vmin2, vmax2) \\n alpha = np.clip(norm2(data2), 0, 1)\\n else:\\n alpha = ~np.isnan(data1) #(data < 0.2) | (data > 0.4)\\n alpha = alpha.astype(np.float)\\n \\n # Map to RGB\\n vx_rgb = np.vstack([vx.raw.red.data, vx.raw.green.data, vx.raw.blue.data])\\n vx_rgb[:,alpha>0] = vx_rgb[:,alpha>0] * alpha[alpha>0]\\n \\n curv_rgb = np.vstack([curv.raw.red.data, curv.raw.green.data, curv.raw.blue.data])\\n # do this to avoid artifacts where curvature gets color of 0 valur of colormap\\n curv_rgb[:,np.where((vx_rgb > 0))[-1]] = curv_rgb[:,np.where((vx_rgb > 0))[-1]] * (1-alpha)[np.where((vx_rgb > 0))[-1]]\\n\\n # Alpha mask\\n display_data = curv_rgb + vx_rgb \\n\\n # Create vertex RGB object out of R, G, B channels\\n vx_fin = cortex.VertexRGB(*display_data, subject, curvature_brightness = 0.4, curvature_contrast = 0.1)\\n\\n return vx_fin\",\n \"def plot_uv(self):\\n self.current_plot = 'uv'\\n self.ax_zoomed = False\\n \\n uu = self.uv.d_uv_data['UU']*1e6\\n vv = self.uv.d_uv_data['VV']*1e6\\n xx = self.uv.d_array_geometry['STABXYZ'][:,0]\\n yy = self.uv.d_array_geometry['STABXYZ'][:,1]\\n pmax, pmin = np.max([uu, vv])*1.1, np.min([uu,vv])*1.1\\n\\n \\n fig = self.sp_fig\\n plt.subplot(121, aspect='equal')\\n ax = plt.plot(xx, yy, 'bo')\\n for i in range(len(xx)):\\n plt.text(xx[i], yy[i], self.uv.d_array_geometry['ANNAME'][i].strip('Stand').strip('Tile'))\\n\\n plt.title(\\\"Antenna positions\\\")\\n plt.xlabel(\\\"X [m]\\\")\\n plt.ylabel(\\\"Y [m]\\\")\\n \\n plt.subplot(122, aspect='equal')\\n ax = plt.plot(uu, vv, 'b.')\\n plt.title(\\\"UV data\\\")\\n plt.xlabel(\\\"UU [$\\\\\\\\mu s$]\\\")\\n plt.ylabel(\\\"VV [$\\\\\\\\mu s$]\\\")\\n plt.xlim(pmin, pmax)\\n plt.ylim(pmin, pmax)\\n return fig, ax\",\n \"def uvSnapshot(arg=None):\\n\\n FILE_NAME = 'uv.jpg'\\n RESOLUTION = 4096\\n\\n sel = getListSelection()\\n ac = autoConnect.AutoConnect()\\n\\n if ac.PHOTOSHOP_PATH is None:\\n raise WindowsError('Couldn\\\\'t find Adobe Photoshop.')\\n\\n for s in sel:\\n shaderName = shaderUtility.customStringToShaderName(s)\\n if [f for f in ac.DATA.keys() if shaderName == f] == []:\\n print '# Shader doesn\\\\'t have an AutoConnect setup.'\\n continue\\n\\n # Launch photoshop process\\n\\n editTexture()\\n\\n usedBy = shaderUtility.data[shaderName]['usedBy']\\n parents = []\\n for u in usedBy:\\n parent = cmds.listRelatives(u, allParents=True,\\n path=True)[0]\\n parents.append(parent)\\n cmds.select(parents)\\n\\n p = path.normpath(path.join(ac.workspace, ac.sourceImages,\\n shaderName))\\n if os.path.isdir(p) is not True:\\n os.mkdir(p)\\n path.normpath(path.join(p, FILE_NAME))\\n cmds.uvSnapshot(\\n name=path.normpath(path.join(p, FILE_NAME)),\\n overwrite=True,\\n antiAliased=True,\\n fileFormat='jpg',\\n xResolution=RESOLUTION,\\n yResolution=RESOLUTION,\\n )\\n\\n # Let's call Photoshop\\n\\n script = psCommand.script\\n PS_SCRIPT = script.replace('<UV_Image_Path>',\\n path.normpath(path.join(p,\\n FILE_NAME)).replace('\\\\\\\\', '\\\\\\\\\\\\\\\\'\\n )).replace('<Texture_PSD_Name>',\\n '%s.psd' % shaderName)\\n\\n tempDir = tempfile.gettempdir()\\n scriptFile = 'psScript.jsx'\\n\\n p = path.join(tempDir, scriptFile)\\n f = open(p, 'w')\\n f.write(PS_SCRIPT)\\n f.close()\\n\\n cmd = '\\\"%s\\\" \\\"%s\\\"' % (path.normpath(ac.PHOTOSHOP_PATH),\\n path.normpath(p))\\n process = QProcess()\\n process.startDetached(cmd)\",\n \"def saveVelocityAndPressureVTK_binary(pressure,u,v,w,x,y,z,filename,dims):\\n numEl_size = u.size; numEl = np.prod(numEl_size);\\n # open the file and write the ASCII header:\\n file = open(filename,'w')\\n file.write('# vtk DataFile Version 3.0\\\\n')\\n file.write('VTK file for data post-processed with Python\\\\n')\\n file.write('Binary\\\\n\\\\n')\\n file.write('DATASET STRUCTURED_GRID\\\\n')\\n file.write('DIMENSIONS %d %d %d \\\\n'%(dims[0],dims[1],dims[2]))\\n file.write('POINTS %d float\\\\n'%(numEl))\\n file.close()\\n \\n # append binary x,y,z data\\n file = open(filename,'ab')\\n for i in range(len(x)): # there really needs to be a better way.\\n pt = [x[i],y[i],z[i]]\\n pt_buf = array('f',pt)\\n pt_buf.byteswap()\\n file.write(pt_buf)\\n \\n \\n file.close()\\n \\n # append an ASCII sub header\\n file = open(filename,'a')\\n file.write('POINT_DATA %d \\\\n'%numEl)\\n file.write('VECTORS velocity_vectors float\\\\n')\\n file.close()\\n \\n # append binary u,v,w data\\n file = open(filename,'ab')\\n for i in range(len(u)):\\n pt = [u[i],v[i],w[i]]\\n pt_buf = array('f',pt)\\n pt_buf.byteswap()\\n file.write(pt_buf)\\n \\n file.close()\\n \\n # append ASCII sub header for scalar velocity magnitude data\\n file = open(filename,'a')\\n file.write('SCALARS VelocityMagnitude float\\\\n')\\n file.write('LOOKUP_TABLE default\\\\n')\\n \\n file.close()\\n \\n file = open(filename,'ab')\\n v_mag = np.sqrt(u**2+v**2+w**2)\\n file = open(filename,'ab')\\n p_buf = array('f',v_mag); p_buf.byteswap()\\n file.write(p_buf)\\n file.close()\\n \\n \\n # append another ASCII sub header for the scalar pressure data\\n file = open(filename,'a')\\n file.write('SCALARS Pressure float\\\\n')\\n file.write('LOOKUP_TABLE default\\\\n')\\n file.close()\\n \\n # append binary pressure data\\n file = open(filename,'ab')\\n p_buf = array('f',pressure); p_buf.byteswap()\\n file.write(p_buf)\\n file.close()\",\n \"def uvgrid(self):\\n if self.baselines_type != \\\"grid_centres\\\":\\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv + 1) # +1 because these are bin edges.\\n return (ugrid[1:] + ugrid[:-1]) / 2\\n else:\\n # return the uv\\n return self.baselines\",\n \"def moveStageToWell(self, u, v): \\n c= \\\"/cli:python /app:matrix /sys:1 /cmd:moveteowell \\\"\\n c += \\\" /upos:\\\"+str(u)\\n c += \\\" /vpos:\\\"+str(v)\\n self.sendCMDstring(c)\",\n \"def registerUVPatches(self,uvpl):\\n self.set('patchmesh.uvpatches',uvpl)\",\n \"def texMoveUVShellContext(*args, exists: bool=True, image1: Union[AnyStr, bool]=\\\"\\\", image2:\\n Union[AnyStr, bool]=\\\"\\\", image3: Union[AnyStr, bool]=\\\"\\\", iterations:\\n Union[int, bool]=0, mask: bool=True, position: bool=True,\\n shellBorder: Union[float, bool]=0.0, q=True, query=True, e=True,\\n edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def writeVelocityPlot(self):\\n name = \\\"velocity.vtk\\\"\\n chargeFile = open(name,'w')\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"# vtk DataFile Version 2.0\\\"))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"obtained via hydraulicmodule\\\"))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"ASCII\\\"))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"DATASET UNSTRUCTURED_GRID\\\"))\\n chargeFile.write(\\\"%s %i %s\\\\n\\\"%(\\\"POINTS\\\",len(self.points),\\\"double\\\"))\\n dim = self.mesh.getSpaceDimensions()\\n if (dim==2): \\n for ind in range(0,len(self.points)):\\n chargeFile.write(\\\"%15.8e %15.8e %15.8e\\\\n\\\"%(self.points[ind][0],\\\\\\n self.points[ind][1],\\\\\\n 0.))\\n pass\\n pass\\n elif (dim==3): \\n for ind in range(0,len(self.points)):\\n chargeFile.write(\\\"%15.8e %15.8e %15.8e\\\\n\\\"%(self.points[ind][0],\\\\\\n self.points[ind][1],\\\\\\n self.points[ind][2]))\\n pass\\n pass\\n else:\\n raise Exception(\\\" error in mesh dimension \\\") \\n numberOfCells = self.mesh.getNumberOfCells()\\n connectivity = self.mesh.getConnectivity()\\n\\n cellListSize = 0\\n for i in range(0,numberOfCells): # gmsh meshes: type of elements\\n gmshType = connectivity[i][1]\\n if gmshType == 1: # 2-node line\\n cellListSize += 3\\n pass\\n elif gmshType == 2: # 3-node triangles\\n cellListSize += 4\\n pass\\n elif gmshType == 3: # 4-node quadrangles\\n cellListSize += 5\\n pass\\n elif gmshType == 4: # 4-node tetrahedron\\n cellListSize += 5\\n pass\\n elif gmshType == 5: # 8-node hexahedrons\\n cellListSize += 9\\n pass\\n pass\\n chargeFile.write(\\\"CELLS %i %i\\\\n\\\"%(numberOfCells,cellListSize))\\n ind = 0\\n for cell in connectivity:\\n ind = cell[2]+3\\n# print \\\" ctm dbg cell \\\",vtkTyp,ind,cell,\\\" perm \\\",permutation[ind],permutation[ind+1],permutation[ind+2],permutation[ind+3]\\n # \\n vtkTyp = _vtkGmsh(cell[1])\\n if (vtkTyp==3): # 2-node line\\n ind = cell[2]+3\\n chargeFile.write(\\\"%i %i %i\\\\n\\\"%(\\n 2,\\\\\\n cell[ind]-1,\\\\\\n cell[ind+1]-1)\\n )\\n pass\\n \\n elif (vtkTyp==5): # triangles\\n chargeFile.write(\\\"%i %i %i %i\\\\n\\\"%(\\n 3, \\n cell[ind]-1,\\\\\\n cell[ind+1]-1,\\\\\\n cell[ind+2]-1)\\n )\\n pass\\n elif (vtkTyp==9): # quadr\\n chargeFile.write(\\\"%i %i %i %i %i\\\\n\\\"%(\\n 4,\\\\\\n cell[ind]-1,\\\\\\n cell[ind+1]-1,\\\\\\n cell[ind+2]-1,\\\\\\n cell[ind+3]-1)\\n )\\n pass\\n elif (vtkTyp==10): # tetra\\n chargeFile.write(\\\"%i %i %i %i %i\\\\n\\\"%(\\n 4,\\\\\\n cell[ind]-1,\\\\\\n cell[ind+1]-1,\\\\\\n cell[ind+2]-1,\\\\\\n cell[ind+3]-1)\\n )\\n pass\\n elif (vtkTyp==12): # hexahedron\\n chargeFile.write(\\\"%i %i %i %i %i %i %i %i %i\\\\n\\\"%(\\n 8,\\\\\\n cell[ind]-1,\\\\\\n cell[ind+1]-1,\\\\\\n cell[ind+2]-1,\\\\\\n cell[ind+3]-1,\\\\\\n cell[ind+4]-1,\\\\\\n cell[ind+5]-1,\\\\\\n cell[ind+6]-1,\\\\\\n cell[ind+7]-1)\\n )\\n pass\\n pass\\n chargeFile.write(\\\"%s %i\\\\n\\\"%(\\\"CELL_TYPES\\\",numberOfCells))\\n#\\n for i in range(0,numberOfCells):\\n gmshType = connectivity[i][1]\\n\\n if (gmshType)==1:\\n cellTyp = 3\\n pass\\n elif (gmshType)==2:\\n cellTyp = 5\\n pass\\n elif (gmshType)==3:\\n cellTyp = 9\\n pass\\n elif (gmshType)==4:\\n cellTyp = 10\\n pass\\n elif (gmshType)==5:\\n cellTyp = 12\\n pass\\n elif (gmshType)==6:\\n cellTyp = 13\\n pass\\n elif gmshType == 7:\\n cellTyp = 14\\n pass\\n else:\\n raise Exception(\\\" check gmshtype \\\")\\n chargeFile.write(\\\"%i\\\\n\\\"%(cellTyp))\\n chargeFile.write(\\\"%s %d\\\\n\\\"%(\\\"POINT_DATA\\\",len(self.points)))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"VECTORS vectors float\\\"))\\n for velocityComponent in self.velocity:\\n chargeFile.write(\\\" %e %e %e\\\\n \\\"%(velocityComponent[0], velocityComponent[1], velocityComponent[2]))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"SCALARS charge double\\\"))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"LOOKUP_TABLE default\\\"))\\n#\\n \\n chargeDataFile=open(\\\"./\\\" + self.flowComponent.meshDirectoryName + \\\"/\\\" + \\\"HeVel.dat\\\",'r')\\n line = chargeDataFile.readline()\\n while \\\"Number Of Nodes\\\" not in line:\\n line = chargeDataFile.readline()\\n#line.split()\\n nodesNumber = line.split()[-1]\\n while \\\"Perm\\\" not in line:\\n line = chargeDataFile.readline()\\n#\\n# We read the permutation\\n#\\n for i in range(int(nodesNumber)): chargeDataFile.readline()\\n#\\n# We read the charge\\n#\\n for i in range(int(nodesNumber)): chargeFile.write(\\\" %15.10e\\\\n \\\"%(float(chargeDataFile.readline())))\",\n \"def product_stitch_sequential(input_unw_files: List[str],\\n input_conncomp_files: List[str],\\n arrres: List[float],\\n output_unw: Optional[str] = './unwMerged',\\n output_conn: Optional[str] = './connCompMerged',\\n output_format: Optional[str] = 'ENVI',\\n bounds: Optional[tuple] = None,\\n clip_json: Optional[str] = None,\\n mask_file: Optional[str] = None,\\n # [meandiff, cycle2pi]\\n correction_method: Optional[str] = 'cycle2pi',\\n range_correction: Optional[bool] = True,\\n verbose: Optional[bool] = False,\\n save_fig: Optional[bool] = False,\\n overwrite: Optional[bool] = True) -> None:\\n\\n # Outputs\\n output_unw = Path(output_unw).absolute()\\n if not output_unw.parent.exists():\\n output_unw.parent.mkdir()\\n output_conn = Path(output_conn).absolute()\\n if not output_conn.parent.exists():\\n output_conn.parent.mkdir()\\n # create temp files\\n temp_unw_out = output_unw.parent / ('temp_' + output_unw.name)\\n temp_conn_out = output_conn.parent / ('temp_' + output_conn.name)\\n\\n # Create VRT and exit early if only one frame passed,\\n # and therefore no stitching needed\\n if len(input_unw_files) == 1:\\n gdal.BuildVRT(str(temp_unw_out.with_suffix('.vrt')),\\n input_unw_files)\\n gdal.BuildVRT(str(temp_conn_out.with_suffix('.vrt')),\\n input_conncomp_files)\\n\\n else:\\n (combined_unwrap,\\n combined_conn,\\n combined_snwe) = stitch_unwrapped_frames(\\n input_unw_files,\\n input_conncomp_files,\\n correction_method=correction_method,\\n range_correction=range_correction,\\n direction_N_S=True,\\n verbose=verbose)\\n\\n # Write\\n # write stitched unwrappedPhase\\n write_GUNW_array(\\n temp_unw_out, combined_unwrap, combined_snwe,\\n format=output_format, verbose=verbose,\\n update_mode=overwrite, add_vrt=True, nodata=0.0)\\n\\n # write stitched connectedComponents\\n write_GUNW_array(\\n temp_conn_out, combined_conn, combined_snwe,\\n format=output_format, verbose=verbose,\\n update_mode=overwrite, add_vrt=True, nodata=-1.0)\\n\\n # Crop\\n [print(f'Cropping to {bounds}') if verbose and bounds else None]\\n if overwrite:\\n [print(f'Removing {output_unw}, {output_conn}') if verbose else None]\\n output_unw.unlink(missing_ok=True)\\n output_conn.unlink(missing_ok=True)\\n\\n # NOTE: Run gdal.Warp on temp file, if input and output are the same\\n # warp creates empty raster, investigate why\\n # Also, it looks like it is important to close gdal.Warp\\n # gdal.Warp/Translate add 6 seconds to runtime\\n\\n for output, input in zip([output_unw, output_conn],\\n [temp_unw_out, temp_conn_out]):\\n # Crop if selected\\n ds = gdal.Warp(str(output),\\n str(input.with_suffix('.vrt')),\\n format=output_format,\\n cutlineDSName=clip_json,\\n xRes=arrres[0], yRes=arrres[1],\\n targetAlignedPixels=True,\\n # cropToCutline = True,\\n outputBounds=bounds\\n )\\n ds = None\\n # Update VRT\\n [print(f'Writing {output}, {output.with_suffix(\\\".vrt\\\")}')\\n if verbose else None]\\n gdal.Translate(str(output.with_suffix('.vrt')),\\n str(output), format=\\\"VRT\\\")\\n # Remove temp files\\n [ii.unlink() for ii in [input, input.with_suffix('.vrt'),\\n input.with_suffix('.xml'),\\n input.with_suffix('.hdr'),\\n input.with_suffix('.aux.xml')] if ii.exists()]\\n\\n # Mask\\n if mask_file:\\n if isinstance(mask_file, str):\\n mask = gdal.Open(mask_file)\\n else:\\n # for gdal instance, from prep_mask\\n mask = mask_file\\n\\n mask_array = mask.ReadAsArray()\\n array = get_GUNW_array(str(output.with_suffix('.vrt')))\\n\\n if output == output_conn:\\n # Mask connected components\\n array[array == -1.0] = np.nan\\n update_array = mask_array * array\\n update_array = np.nan_to_num(update_array, nan=-1.0)\\n # update_array[np.isnan(update_array)] = -1.0\\n else:\\n update_array = mask_array * array\\n\\n update_file = gdal.Open(str(output), gdal.GA_Update)\\n update_file = update_file.GetRasterBand(1).WriteArray(update_array)\\n update_file = None\\n\\n # Plot stitched\\n # NOTE: saving output figure adds 4 seconds\\n if save_fig:\\n plot_GUNW_stitched(str(output_unw.with_suffix('.vrt')),\\n str(output_conn.with_suffix('.vrt')))\\n\\n # Remove temp files\\n [ii.unlink() for ii in [temp_unw_out,\\n temp_unw_out] if ii.exists()]\",\n \"def recompile(self):\\n\\n self.vaos = []\\n try:\\n self.program, uniforms = self.build_prog(self.gl)\\n self.u_time, self.u_width, self.u_height = uniforms\\n vao = GLUtil.screen_vao(self.gl, self.program)\\n self.vaos.append(vao)\\n\\n self.compute, uniforms, buffers = self.build_cs(self.gl)\\n self.u_cstime, self.u_cswidth, self.u_csheight = uniforms\\n self.buf_in, self.buf_out = buffers\\n\\n self.set_gpu_wh(width, height)\\n\\n self.gx, self.gy = int(width / 8), int(height / 8)\\n self.set_gpu_time()\\n\\n log(\\\"[Renderer] shader recompiled.\\\")\\n\\n except Exception as e:\\n log(e)\",\n \"def offset_to_uvd(self, x):\\n self.batch_size = x.shape[0]\\n self.W = x.shape[2]\\n self.H = x.shape[3] \\n self.D = 5\\n self.grid_size = self.W*self.H*self.D\\n \\n grid_linear = x.reshape(self.batch_size, 64, -1)\\n\\n index = torch.from_numpy(np.asarray(np.unravel_index(np.arange(self.grid_size), \\n (self.W, self.H, self.D)))).type(torch.FloatTensor)\\n u = index[0, :].unsqueeze(0).expand(21, -1)\\n v = index[1, :].unsqueeze(0).expand(21, -1)\\n z = index[2, :].unsqueeze(0).expand(21, -1)\\n\\n if self.device != \\\"cpu\\\":\\n u = u.cuda()\\n v = v.cuda()\\n z = z.cuda()\\n\\n pred_uvd_no_offset = grid_linear[:, :63, :].reshape(self.batch_size, 21, 3, self.grid_size)\\n pred_conf = grid_linear[:, 63, :].reshape(self.batch_size, self.W, self.H, self.D)\\n pred_conf = torch.sigmoid(pred_conf)\\n \\n # middle finger root is hand root\\n pred_uvd_no_offset[:, self.hand_root, :, :] = torch.sigmoid(pred_uvd_no_offset[:, self.hand_root, :, :])\\n \\n pred_uvd = pred_uvd_no_offset.clone().detach()\\n pred_uvd[:, :, 0, :] = (pred_uvd[:, :, 0, :] + u) / self.W\\n pred_uvd[:, :, 1, :] = (pred_uvd[:, :, 1, :] + v) / self.H\\n pred_uvd[:, :, 2, :] = (pred_uvd[:, :, 2, :] + z) / self.D\\n \\n pred_uvd_no_offset = pred_uvd_no_offset.reshape(self.batch_size, 21, 3, self.W, self.H, self.D)\\n \\n return pred_uvd_no_offset, pred_uvd, pred_conf\",\n \"def get_bforce_wm_ws_Gx_surf(self):\\n\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w'] \\n \\n self.Gm1 = np.zeros([Ly])\\n self.dGm1_dS = np.zeros([Ly]) \\n self.Gt1 = np.zeros([Ly])\\n self.dGt1_dS = np.zeros([Ly]) \\n self.Bfsfc_bl = np.zeros([Ly])\\n self.Av_bl = np.zeros([Ly])\\n self.dAv_bl = np.zeros([Ly])\\n \\n #debugging\\n self.wm_surf = np.zeros([Ly])\\n self.ws_surf = np.zeros([Ly]) \\n\\n #---> j-loop\\n for j in range(Ly): \\n k_w = self.kbl[j] # KBL is \\\"new bl index after calling find_new_kbl()\\n z_bl = z_u_w[j,N] - self.hbls[j]\\n zscale = self.hbls[j] \\n \\n if self.swr_frac[j,k_w-1] > 0:\\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\\n \\n else:\\n Bfsfc = self.Bo[j] + self.Bosol[j]\\n \\n # CALCUALTE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm_surf[j] = wm\\n self.ws_surf[j] = ws \\n\\n if self.LIMIT_UNSTABLE_ONLY:\\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\\n else:\\n f1 = 0\\n\\n \\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n\\n #MOMENTUM \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl[j] = Av_bl\\n self.dAv_bl[j] = dAv_bl\\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \\n\\n #TEMPERATURE(BUOYANCY)\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \\n\\n self.Bfsfc_bl[j] = Bfsfc\",\n \"def registerUVVertices(self,uvl):\\n self.set('patchmesh.uvvertices',FuzzList(uvl))\",\n \"def rdmb_povray_save_q(out_file,\\n vs,\\n ucs, vcs,\\n width=800, height=600,\\n rotx=0, roty=0, rotz=0,\\n angle=14):\\n\\n ucmax = 6.0\\n ucs = ucs / ucmax\\n ucs[ucs > 1.0] = 1.0\\n # ucs = ucs / np.max(ucs)\\n\\n rot1 = [rotx, 0, 0]\\n rot2 = [0, roty, 0]\\n rot3 = [0, 0, rotz]\\n\\n camera = Camera('location', [0, 0, -25],\\n 'look_at', [0, 0, 0],\\n 'angle', angle,\\n 'right x*image_width/image_height')\\n\\n light = LightSource([0, 0, -10],\\n 'color', [1.0, 1.0, 1.0], 'parallel', 'shadowless')\\n light1 = LightSource([-10, 0, 0],\\n 'color', [0.5, 0.5, 0.5], 'parallel', 'shadowless')\\n light2 = LightSource([10, 0, 0],\\n 'color', [0.5, 0.5, 0.5], 'parallel', 'shadowless')\\n light3 = LightSource([0, -10, 0],\\n 'color', [0.5, 0.5, 0.5], 'parallel', 'shadowless')\\n light4 = LightSource([0, 10, 0],\\n 'color', [0.5, 0.5, 0.5], 'parallel', 'shadowless')\\n\\n background = Background('color', [1, 1, 1, 1])\\n\\n spheres = [Sphere(v, 0.02,\\n Finish('ambient', 1.0),\\n Texture(Pigment('color',\\n [0.3+uc*0.7, 0.2+uc*0.8, 0.2+uc*0.8])),\\n 'rotate', rot1,\\n 'rotate', rot2,\\n 'rotate', rot3) for v, uc in zip(vs, ucs)]\\n\\n objects = [light, light1, light2, light3, light4, background] + spheres\\n\\n scene = Scene(camera, objects=objects)\\n scene.render(out_file, width=width, height=height,\\n output_alpha=True, antialiasing=0.001,\\n tempfile=out_file+\\\"__temp__.pov\\\")\",\n \"def createTerraces(u,v,altitude_profile,wind_angle,pass_length,image_passes,max_alt_diff,min_terrace_len):\\n # Create terraces from pass\\n current_terrace = [] # Initilise current terrace points as empty\\n average_alt = 0 # Store the average altitude\\n if len(altitude_profile) > 0: # If there is some altitude data for this pass\\n max_altitude = np.max(altitude_profile)\\n min_altitude = np.min(altitude_profile)\\n if max_altitude - min_altitude < max_alt_diff: # If the entire pass is within the altitude limits\\n # Find the mean altitude\\n for i in range(0,len(altitude_profile)):\\n average_alt += altitude_profile[i]\\n average_alt = average_alt/len(altitude_profile)\\n terrace_start = (u,v,average_alt)\\n terrace_end = (u,v+pass_length,average_alt)\\n\\n coords = convertCoords([[terrace_start[0],terrace_start[1]]],wind_angle,'xy')\\n terrace_start = (coords[0][0],coords[0][1],average_alt)\\n\\n coords = convertCoords([[terrace_end[0],terrace_end[1]]],wind_angle,'xy')\\n terrace_end = (coords[0][0],coords[0][1],average_alt)\\n\\n image_passes.append(Image_Pass(terrace_start,terrace_end,average_alt,wind_angle))\\n else:\\n # Calculate terraces\\n index = 0\\n\\n current_altitude = 0\\n current_min_altitude = 0\\n current_max_altitude = 0\\n while index < len(altitude_profile):\\n if index + 3 > len(altitude_profile):\\n if current_altitude == 0:\\n for alt in range(0,2):\\n current_altitude += altitude_profile[index+alt]\\n current_altitude = current_altitude/3\\n for val in range(0,3):\\n current_terrace.append([x,y,current_altitude])\\n # Add all to current pass\\n terrace_start = current_terrace[0]\\n terrace_end = current_terrace[len(current_terrace)-1]\\n image_passes.append(Image_Pass(terrace_start,terrace_end,current_altitude,wind_angle))\\n break\\n\\n if len(current_terrace) == 0:\\n # Look ahead to find gradient\\n grad = altitude_profile[index+1] - altitude_profile[index]\\n grad += altitude_profile[index+2] - altitude_profile[index]\\n #grad += altitude_profile[index+3] - altitude_profile[index]\\n grad = grad/2\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n if grad > 0:\\n current_altitude = altitude_profile[index]+max_alt_diff/2\\n current_terrace.append([x,y,current_altitude])\\n elif grad < 0:\\n current_altitude = altitude_profile[index]-max_alt_diff/2\\n current_terrace.append([x,y,current_altitude])\\n else:\\n current_altitude = altitude_profile[index]\\n current_terrace.append([x,y,current_altitude])\\n current_min_altitude = current_altitude - max_alt_diff/2\\n current_max_altitude = current_altitude + max_alt_diff/2\\n\\n else:\\n # Add to the terrace\\n if altitude_profile[index] > current_min_altitude and altitude_profile[index] < current_max_altitude:\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n elif altitude_profile[index+1] > current_min_altitude and altitude_profile[index+1] < current_max_altitude:\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n index += 1\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n elif altitude_profile[index+2] > current_min_altitude and altitude_profile[index+2] < current_max_altitude:\\n for val in range(0,2):\\n coords = convertCoords([[u,v+index+val]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n index += 1\\n index -= 1\\n else:\\n if len(current_terrace) > min_terrace_len:\\n # Create new terrace\\n terrace_start = current_terrace[0]\\n terrace_end = current_terrace[len(current_terrace)-1]\\n image_passes.append(Image_Pass(terrace_start,terrace_end,current_altitude,wind_angle))\\n current_terrace = []\\n current_altitude = 0\\n else:\\n # Requires more image locations\\n print(\\\"Not long enough\\\")\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n #current_max_altitude += max_alt_diff/2\\n #current_min_altitude -+ max_alt_diff/2\\n\\n index += 1\\n else:\\n pass\\n return image_passes\",\n \"def test_set_vx_to_vx_shr(self, cpu):\\n for x in range(0x0, 0xF):\\n for v in range(0x0, 0xFF):\\n cpu.V_register[x] = v\\n cpu.opcode = 0x8006 | (x << 8)\\n cpu.set_vx_to_vx_shr()\\n if v & 0x1 == 1:\\n assert(cpu.V_register[0xF] == 1)\\n else:\\n assert(cpu.V_register[0xF] == 0)\\n assert(cpu.V_register[x] == v/2)\",\n \"def compact_mesh(remote, objectid):\\n cmd1 = mmapi.StoredCommands()\\n key1 = cmd1.AppendSceneCommand_CompactMesh(objectid)\\n remote.runCommand(cmd1)\",\n \"def compute(self):\\n # this just initializes all gradients to the vector (0,0,0)\\n self.data = [ZERO_GRADIENT] * (self.volume.dim_x * self.volume.dim_y * self.volume.dim_z)\\n\\n for i in range(1, self.volume.dim_x-1):\\n for j in range(1, self.volume.dim_y-1):\\n for k in range(1, self.volume.dim_z-1):\\n d_x = 0.5 * (self.volume.get_voxel(i+1, j, k) - self.volume.get_voxel(i-1, j, k))\\n d_y = 0.5 * (self.volume.get_voxel(i, j+1, k) - self.volume.get_voxel(i, j-1, k))\\n d_z = 0.5 * (self.volume.get_voxel(i, j, k+1) - self.volume.get_voxel(i, j, k-1))\\n self.set_gradient(i, j, k, VoxelGradient(d_x, d_y, d_z))\",\n \"def stabilization(videopath,\\n smoothing_radius=50,\\n fixed_area=[0, -1, 0, -1],\\n stab_points=200):\\n\\n # Read original video\\n # Extract directory and videoname for saving purposes\\n capture = cv2.VideoCapture(videopath)\\n directory, videoname = os.path.split(videopath)\\n videoname = os.path.splitext(videoname)[0]\\n\\n # Get number of frames\\n # Get width and height of video stream\\n # Get frames per second (fps)\\n n_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))\\n w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))\\n h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n fps = capture.get(cv2.CAP_PROP_FPS)\\n\\n # Set up output video\\n out = cv2.VideoWriter(os.path.join(directory, str(videoname)+'_stabilized.mp4'),\\n -1,\\n fps,\\n (w, h))\\n\\n # Read first frame\\n # Convert frame to grayscale and extract part of image\\n _, prev = capture.read()\\n xmin, xmax, ymin, ymax = fixed_area\\n prev_gray = cv2.cvtColor(prev, cv2.COLOR_BGR2GRAY)[ymin:ymax, xmin:xmax]\\n\\n # Pre-define transformation-store array\\n transforms = np.zeros((n_frames-1, 3), np.float32)\\n\\n # Filling in transformation array per frameset\\n with tqdm(total=2*(n_frames-2), ncols=50) as pbar:\\n for i in range(n_frames-2):\\n # Detect feature points in previous frame\\n prev_pts = cv2.goodFeaturesToTrack(prev_gray,\\n maxCorners=stab_points,\\n qualityLevel=0.1,\\n minDistance=100,\\n blockSize=10)\\n # Read next frame\\n # If not success: break loop\\n success, curr = capture.read()\\n if not success:\\n break\\n\\n # Convert to grayscale and extract part of image\\n # Calculate optical flow (i.e. track feature points)\\n # Sanity check\\n curr_gray = cv2.cvtColor(curr, cv2.COLOR_BGR2GRAY)[ymin:ymax,\\n xmin:xmax]\\n curr_pts, status, err = cv2.calcOpticalFlowPyrLK(prev_gray,\\n curr_gray,\\n prev_pts,\\n None)\\n assert prev_pts.shape == curr_pts.shape\\n\\n # Filter only valid points\\n idx = np.where(status == 1)[0]\\n prev_pts = prev_pts[idx]\\n curr_pts = curr_pts[idx]\\n\\n # Find transformation matrix\\n m = cv2.estimateAffinePartial2D(prev_pts, curr_pts)[0]\\n\\n # Extract translation\\n # Extract rotation angle\\n dx = m[0, 2]\\n dy = m[1, 2]\\n da = np.arctan2(m[1, 0], m[0, 0])\\n\\n # Store transformation\\n transforms[i] = [dx, dy, da]\\n\\n # Move to next frame\\n prev_gray = curr_gray\\n\\n pbar.update(1)\\n\\n # Compute trajectory using cumulative sum of transformations\\n # Create variable to store smoothed trajectory\\n # Calculate diference in smoothed_trajectory and trajectory\\n trajectory = np.cumsum(transforms, axis=0)\\n smoothed_trajectory = smooth(trajectory, smoothing_radius)\\n difference = smoothed_trajectory - trajectory\\n\\n # Calculate newer transformation array\\n transform_smooth = transforms + difference\\n\\n # Reset stream to first frame\\n capture.set(cv2.CAP_PROP_POS_FRAMES, 0)\\n\\n # Apply transformations to video\\n for i in range(n_frames-2):\\n # Read next frame\\n success, frame = capture.read()\\n if not success:\\n break\\n\\n # Extract transformations from the new transformation array\\n dx = transform_smooth[i, 0]\\n dy = transform_smooth[i, 1]\\n da = transform_smooth[i, 2]\\n\\n # Reconstruct transformation matrix accordingly to new values\\n m = np.zeros((2, 3), np.float32)\\n m[0, 0] = np.cos(da)\\n m[0, 1] = -np.sin(da)\\n m[1, 0] = np.sin(da)\\n m[1, 1] = np.cos(da)\\n m[0, 2] = dx\\n m[1, 2] = dy\\n\\n # Apply affine wrapping to the given frame\\n # Fix border artifacts\\n frame_stabilized = cv2.warpAffine(frame, m, (w, h))\\n frame_stabilized = fixBorder(frame_stabilized)\\n\\n # Save new frame\\n out.write(frame_stabilized)\\n\\n pbar.update(1)\\n\\n # Release original and stabilized video\\n capture.release()\\n out.release()\",\n \"def world2uv(self, vertices):\\n batch_size = vertices.shape[0]\\n face_vertices_ = face_vertices(vertices, self.faces.expand(batch_size, -1, -1))\\n uv_vertices = self.uv_rasterizer(self.uvcoords.expand(batch_size, -1, -1), self.uvfaces.expand(batch_size, -1, -1), face_vertices_)[:, :3]\\n return uv_vertices\",\n \"def uvsWarp(mot, coi, destrect, crop_it=True):\\n def resampleMei(coi, srect, drect):\\n isrect = coi2imcoord(coi, srect)\\n crect = np.array([np.floor(isrect[0]), np.ceil(isrect[1]), np.floor(isrect[2]), np.ceil(isrect[3])]).astype(np.int)\\n cutim = coi.im[crect[2] - 1:crect[3], crect[0] - 1:crect[1]]\\n cisrect = isrect - np.array([crect[0], crect[0], crect[2], crect[2]]) + 1\\n s = rectSize(drect) + 1\\n rim = resample1D(cutim, cisrect[2:], s[1], 1)\\n rim = resample1D(rim, cisrect[:2], s[0], 2)\\n\\n return rim\\n\\n def resample1D(Ain, source, dests, dim):\\n A = Ain.astype(np.float)\\n rr = np.linspace(source[0], source[1], dests)\\n lp = np.floor(rr).astype(np.int) - 1\\n rp = np.ceil(rr).astype(np.int) - 1\\n rw = np.mod(rr, 1)\\n lw = 1 - rw\\n\\n if dim == 1:\\n B = A[lp, :] * lw.T[:, np.newaxis] + A[rp, :] * rw.T[:, np.newaxis]\\n elif dim == 2:\\n B = A[:, lp] * lw + A[:, rp] * rw\\n return B\\n\\n crect = coiImageRect(coi)\\n idestrect = rect2int(destrect)\\n\\n if crop_it:\\n wirect = uvsRWarp(mot, rectEnlarge(crect, -0.99))\\n assert np.all(np.mod(rectSize(destrect), 1) == 0)\\n doffset = np.mod(destrect[0:3:2] + 0.5, 1)\\n destrect = rect2int(rectIntersect(wirect, destrect))\\n idestrect = rect2int(destrect, doffset)\\n\\n if np.any(rectSize(destrect) < 1):\\n wim = np.zeros((0, 0))\\n else:\\n srect = uvsRBackwardWarp(mot, idestrect)\\n wim = resampleMei(coi, srect, idestrect)\\n wcoi = coimage(wim, tuple(1 - idestrect[0:3:2]), '{}_warp'.format(coi.label), coi.level)\\n\\n return wcoi\",\n \"def render_2d_vector(v1, gridsize=50):\\n\\n fb = pixel_op() \\n fb.create_buffer(800, 800)\\n fb.graticule(gridsize)\\n fb.render_vector_2d( v1, scale=gridsize)\\n fb.save('vec.png')\",\n \"def MeshMachine(main):\\n\\n # oDesign definition\\n oDesign = main['ANSYS']['oDesign']\\n\\n # Data for the rotor mesh\\n RotorName = main['ANSYS']['Rotor&Magnets']['Name'][0]\\n RotorNumMaxElem = main['ANSYS']['Mesh']['Rotor']['NumMaxElem']\\n RotorMaxLength = main['ANSYS']['Mesh']['Rotor']['MaxLength']\\n\\n # Data for the magnets mesh\\n PMNames = main['ANSYS']['Rotor&Magnets']['PMNames']\\n PMNumMaxElem = main['ANSYS']['Mesh']['Magnets']['NumMaxElem']\\n PMMaxLength = main['ANSYS']['Mesh']['Magnets']['MaxLength']\\n\\n # Data for the Stator mesh\\n StatorName = main['ANSYS']['Stator']['Name']\\n StatorNormalDev = main['ANSYS']['Mesh']['Stator']['NormalDev']\\n StatorAspectRatio = main['ANSYS']['Mesh']['Stator']['AspectRatio']\\n\\n # Data for the Stator mesh\\n CoilNames = main['ANSYS']['Winding']['CoilNames']\\n WindingNumMaxElem = main['ANSYS']['Mesh']['Winding']['NumMaxElem']\\n WindingMaxLength = main['ANSYS']['Mesh']['Winding']['MaxLength']\\n\\n WindingName = []\\n for phase in CoilNames:\\n for direction in phase:\\n WindingName += direction\\n\\n # Creating meshes\\n oModule = oDesign.GetModule(\\\"MeshSetup\\\")\\n\\n # Rotor meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Rotor\\\",\\n \\\"RefineInside:=\\\", True,\\n \\\"Enabled:=\\\", True,\\n \\\"Objects:=\\\", [RotorName],\\n \\\"RestrictElem:=\\\", False,\\n \\\"NumMaxElem:=\\\", str(RotorNumMaxElem),\\n \\\"RestrictLength:=\\\", True,\\n \\\"MaxLength:=\\\", str(RotorMaxLength)+\\\"mm\\\"\\n ]\\n )\\n # Magnet meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Magnets\\\",\\n \\\"RefineInside:=\\\", True,\\n \\\"Enabled:=\\\", True,\\n \\\"Objects:=\\\", PMNames,\\n \\\"RestrictElem:=\\\", False,\\n \\\"NumMaxElem:=\\\", str(PMNumMaxElem),\\n \\\"RestrictLength:=\\\", True,\\n \\\"MaxLength:=\\\", str(PMMaxLength)+\\\"mm\\\"\\n ]\\n )\\n # Stator meshes\\n oModule.AssignTrueSurfOp(\\n [\\n \\\"NAME:Stator\\\",\\n \\\"Objects:=\\\", [StatorName],\\n \\\"CurvedSurfaceApproxChoice:=\\\", \\\"ManualSettings\\\",\\n \\\"SurfDevChoice:=\\\", 0,\\n \\\"NormalDevChoice:=\\\", 2,\\n \\\"NormalDev:=\\\", str(StatorNormalDev) + \\\"deg\\\",\\n \\\"AspectRatioChoice:=\\\", 2,\\n \\\"AspectRatio:=\\\", str(StatorAspectRatio)\\n ]\\n )\\n\\n # Coil meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Coils\\\",\\n \\\"RefineInside:=\\\"\\t, True,\\n \\\"Enabled:=\\\"\\t\\t, True,\\n \\\"Objects:=\\\"\\t\\t, WindingName,\\n \\\"RestrictElem:=\\\"\\t, False,\\n \\\"NumMaxElem:=\\\"\\t\\t, str(WindingNumMaxElem),\\n \\\"RestrictLength:=\\\"\\t, True,\\n \\\"MaxLength:=\\\"\\t\\t, str(WindingMaxLength) +\\\"mm\\\"\\n ]\\n )\\n\\n return main\",\n \"def uv(vec):\\n return vec / sqrt(dot(vec, vec))\",\n \"def update(self):\\r\\n\\r\\n # Update the vision frames in the system\\r\\n self._system.update()\\r\\n\\r\\n # Create blank PIL images to hold the video streams\\r\\n layered = PIL.Image.new('RGBA', (400, 400))\\r\\n stacked = PIL.Image.new('RGBA', (200, 800))\\r\\n control = PIL.Image.new('RGBA', (600, 800))\\r\\n\\r\\n focalpoint = self._system[self._appString[\\\"device\\\"].get()].focalpoint()\\r\\n # print(focalpoint)\\r\\n\\r\\n # Get each vision key and vision for the selected device\\r\\n visionList = [(visionKey, vision) for visionKey, vision in self._system[self._appString[\\\"device\\\"].get()]]\\r\\n\\r\\n # Loop through each vision in the vision list\\r\\n for i, (visionKey, vision) in enumerate(visionList):\\r\\n\\r\\n # Grab the frames from the vision when it is \\\"curr\\\"\\r\\n frameList = [frame for frameKey, frame in vision if frameKey==self._appString[\\\"frame\\\"].get()]\\r\\n\\r\\n # Loop through each frame in the frame list\\r\\n for frame in frameList:\\r\\n\\r\\n # Get the properties and turn the image into RGBA\\r\\n ratio, size = vision.properties()\\r\\n rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)\\r\\n\\r\\n # print(rgbFrame.shape)\\r\\n width, height, channels = rgbFrame.shape\\r\\n\\r\\n # Paste the images together in layered\\r\\n\\r\\n imgFrame = PIL.Image.fromarray(cv2.resize(rgbFrame, (int(400 * ratio), int(400 * ratio))))\\r\\n layered.paste(imgFrame, (int(200 * (1 - ratio)), int(200 * (1 - ratio))))\\r\\n\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 / width)), int(200 * (1 - ratio) - focalpoint[1] * (200 / height))))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 // width)), int(200 * (1 - ratio) - focalpoint[1] * (200 // height))))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (ratio ** -1)), int(200 * (1 - ratio) - focalpoint[1] * (ratio ** -1))))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200/width) / ratio), int(200 * (1 - ratio) - focalpoint[1] * (200/height) / ratio)))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (200 / width)), int(200 * (1 - ratio) - focalpoint[1] * (200 / height))))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (ratio ** -1) / 200), int(200 * (1 - ratio) - focalpoint[1] * (ratio ** -1) / 200)))\\r\\n # layered.paste(imgFrame, (int(200 * (1 - ratio) + focalpoint[0] * (400//width * (1- ratio))), int(200 * (1 - ratio) - focalpoint[1] * (400//height * (1 - ratio)))))\\r\\n\\r\\n # Paste the images together in stacked\\r\\n imgFrame = PIL.Image.fromarray(cv2.resize(rgbFrame, (200, 200)))\\r\\n stacked.paste(imgFrame, (0, 200 * i))\\r\\n\\r\\n # Add the stacked image to the canvas\\r\\n self._pilFrames[\\\"stacked\\\"] = PIL.ImageTk.PhotoImage(image=stacked)\\r\\n self._appCanvas[\\\"stacked\\\"].create_image(100, 0, image=self._pilFrames[\\\"stacked\\\"], anchor=tkinter.NW)\\r\\n\\r\\n # Add the layered image to the canvas\\r\\n self._pilFrames[\\\"layered\\\"] = PIL.ImageTk.PhotoImage(image=layered)\\r\\n self._appCanvas[\\\"layered\\\"].create_image(0, 0, image=self._pilFrames[\\\"layered\\\"], anchor=tkinter.NW)\\r\\n\\r\\n # Add the control image to the canvas\\r\\n imgFrame = cv2.cvtColor(self._system[self._appString[\\\"device\\\"].get()][self._appString[\\\"vision\\\"].get()][self._appString[\\\"frame\\\"].get()], cv2.COLOR_BGR2RGBA)\\r\\n control = PIL.Image.fromarray(cv2.resize(imgFrame, (600, 600)))\\r\\n self._pilFrames[\\\"control\\\"] = PIL.ImageTk.PhotoImage(image=control)\\r\\n self._appCanvas[\\\"control\\\"].create_image(100, 90, image=self._pilFrames[\\\"control\\\"], anchor=tkinter.NW)\\r\\n\\r\\n # Continue to update with a delay of 15\\r\\n self.after(15, self.update)\",\n \"def pipeline(image):\\n # undistort image\\n undistorted_image = undistort_image(image)\\n superimposed_image = find_lanes(undistorted_image)\\n labels = find_vehicles(undistorted_image)\\n\\n draw_img = draw_labeled_bboxes(superimposed_image, labels)\\n\\n \\n return draw_img\",\n \"def gpuMBIR(tomo,angles,center,input_params):\\n print('Starting GPU MBIR recon')\\n #allocate space for final answer \\n af.set_device(input_params['gpu_device']) #Set the device number for gpu based code\\n #Change tomopy format\\n new_tomo=np.transpose(tomo,(1,2,0)) #slice, columns, angles\\n im_size = new_tomo.shape[1]\\n num_slice = new_tomo.shape[0]\\n num_angles=new_tomo.shape[2]\\n pad_size=np.int16(im_size*input_params['oversamp_factor'])\\n# nufft_scaling = (np.pi/pad_size)**2\\n num_iter = input_params['num_iter']\\n mrf_sigma = input_params['smoothness']\\n mrf_p = input_params['p']\\n print('MRF params p=%f sigma=%f' %(mrf_p,mrf_sigma))\\n #Initialize structures for NUFFT\\n sino={}\\n geom={}\\n sino['Ns'] = pad_size#Sinogram size after padding\\n sino['Ns_orig'] = im_size #size of original sinogram\\n sino['center'] = center + (sino['Ns']/2 - sino['Ns_orig']/2) #for padded sinogram\\n sino['angles'] = angles\\n \\n #Initialize NUFFT parameters\\n print('Initialize NUFFT params')\\n nufft_params = init_nufft_params(sino,geom)\\n\\n temp_y = afnp.zeros((sino['Ns'],num_angles),dtype=afnp.complex64)\\n temp_x = afnp.zeros((sino['Ns'],sino['Ns']),dtype=afnp.complex64)\\n x_recon = afnp.zeros((num_slice/2,sino['Ns_orig'],sino['Ns_orig']),dtype=afnp.complex64)\\n \\n pad_idx = slice(sino['Ns']/2-sino['Ns_orig']/2,sino['Ns']/2+sino['Ns_orig']/2)\\n\\n #allocate output array\\n rec_mbir_final=np.zeros((num_slice,sino['Ns_orig'],sino['Ns_orig']),dtype=np.float32)\\n \\n #Move all data to GPU\\n print('Moving data to GPU')\\n slice_1=slice(0,num_slice,2)\\n slice_2=slice(1,num_slice,2)\\n gdata=afnp.array(new_tomo[slice_1]+1j*new_tomo[slice_2],dtype=afnp.complex64)\\n gradient = afnp.zeros((num_slice/2,sino['Ns_orig'],sino['Ns_orig']), dtype=afnp.complex64)#temp array to store the derivative of cost func\\n z_recon = afnp.zeros((num_slice/2,sino['Ns_orig'],sino['Ns_orig']),dtype=afnp.complex64)#Nesterov method variables\\n t_nes = 1\\n \\n #Compute Lipschitz of gradient\\n print('Computing Lipschitz of gradient')\\n x_ones= afnp.ones((1,sino['Ns_orig'],sino['Ns_orig']),dtype=afnp.complex64)\\n temp_x[pad_idx,pad_idx]=x_ones[0]\\n temp_proj=forward_project(temp_x,nufft_params)\\n temp_backproj=(back_project(temp_proj,nufft_params))[pad_idx,pad_idx]\\n print('Adding Hessian of regularizer')\\n temp_backproj2=afnp.zeros((1,sino['Ns_orig'],sino['Ns_orig']),dtype=afnp.complex64)\\n temp_backproj2[0]=temp_backproj\\n add_hessian(mrf_sigma,x_ones, temp_backproj2)\\n L = np.max([temp_backproj2.real.max(),temp_backproj2.imag.max()])\\n print('Lipschitz constant = %f' %(L))\\n del x_ones,temp_proj,temp_backproj,temp_backproj2\\n\\n #loop over all slices\\n for iter_num in range(num_iter):\\n print('Iteration %d of %d'%(iter_num,num_iter))\\n #Derivative of the data fitting term\\n for i in range(num_slice/2):\\n temp_x[pad_idx,pad_idx]=x_recon[i]\\n Ax = forward_project(temp_x,nufft_params)\\n temp_y[pad_idx]=gdata[i]\\n gradient[i] =(back_project((Ax-temp_y),nufft_params))[pad_idx,pad_idx] #nufft_scaling\\n #Derivative of regularization term\\n tvd_update(mrf_p,mrf_sigma,x_recon, gradient) \\n #x_recon-=gradient/L\\n x_recon,z_recon,t_nes=nesterovOGM2update(x_recon,z_recon,t_nes,gradient,L)\\n \\n #Move to CPU\\n #Rescale result to match tomopy\\n rec_mbir=np.array(x_recon,dtype=np.complex64)\\n rec_mbir_final[slice_1]=np.array(rec_mbir.real,dtype=np.float32)\\n rec_mbir_final[slice_2]=np.array(rec_mbir.imag,dtype=np.float32)\\n return rec_mbir_final\",\n \"def warp(im, u, v):\\n assert im.shape == u.shape and \\\\\\n u.shape == v.shape\\n \\n im_warp = np.empty_like(im)\\n #\\n # Your code here\\n #\\n ## Hint: You may find function griddata from package scipy.interpolate useful\\n ## code inspired by: https://towardsdatascience.com/image-geometric-transformation-in-numpy-and-opencv-936f5cd1d315\\n ## https://github.com/rajat95/Optical-Flow-Warping-Tensorflow/blob/master/warp.py\\n ## https://sergevideo.blogspot.com/2014/11/writing-simple-optical-flow-in-python.html\\n ## https://github.com/liruoteng/OpticalFlowToolkit/blob/master/lib/flowlib.py\\n\\n # get image dimensions [y, x]\\n im_height, im_width = im.shape\\n \\n # number of pixel\\n N = im_height * im_width\\n\\n iy, ix = np.mgrid[0:im_height, 0:im_width] # int-meshgrid\\n fy, fx = np.mgrid[0:im_height:1.0, 0:im_width:1.0] # float-meshgrid\\n\\n # add the optical flow to the indices (float)\\n fx = fx + u\\n fy = fy + v\\n\\n points = np.c_[ix.reshape(N, 1), iy.reshape(N, 1)]\\n xi = np.c_[fx.reshape(N, 1), fy.reshape(N, 1)]\\n values = im.reshape(N, 1)\\n im_interpol = griddata(points, values, xi, method='linear', fill_value=0.0)\\n im_warp = im_interpol.reshape(im_height, im_width)\\n\\n assert im_warp.shape == im.shape\\n return im_warp\",\n \"def vesuvio_example():\\n router = Router(topo_file=PROJECT_PATH + \\\"vtk/Vesuvio\\\")\\n router.routing(32729, 31991)\\n # write to vtk\\n router.write2vtk(router.acqueduct)\\n # render_vtk(\\\"vtk/Vesuvio\\\")\",\n \"def _update_surface_normals(self):\\n\\n # This is the case if there are too few points to\\n # compute normals so there can be values to remove\\n\\n #can be important for parallel\\n self.swarm.shadow_particles_fetch()\\n\\n if self.empty:\\n self.director.data[...] = 0.0\\n else:\\n\\n particle_coords = self.swarm.particleCoordinates.data\\n\\n Nx = np.empty(self.swarm.particleLocalCount)\\n Ny = np.empty(self.swarm.particleLocalCount)\\n Nz = np.empty(self.swarm.particleLocalCount)\\n\\n for i, xyz in enumerate(particle_coords):\\n r, neighbours = self.kdtree.query(particle_coords[i], k=4)\\n\\n # this point is neighbour[0] and neighbour points are neighbours[(1,2,3)]\\n XYZ1 = self.kdtree.data[neighbours[1]]\\n XYZ2 = self.kdtree.data[neighbours[2]]\\n XYZ3 = self.kdtree.data[neighbours[3]]\\n\\n dXYZ1 = XYZ2 - XYZ1\\n dXYZ2 = XYZ3 - XYZ1\\n\\n # Cross product of those 2 vectors can be use as the local normal (perhaps)\\n\\n Nx[i], Ny[i], Nz[i] = np.cross(dXYZ1, dXYZ2)\\n #if i == 0:\\n # print(Nx, Ny, Nz)\\n # print(xyz[0], xyz[1],xyz[2])\\n # print((self.insidePt[0] - xyz[0]) * Nx[i] )\\n\\n if (self.insidePt):\\n sign = np.sign( (self.insidePt[0] - xyz[0]) * Nx[i] +\\n (self.insidePt[1] - xyz[1]) * Ny[i] +\\n (self.insidePt[2] - xyz[2]) * Nz[i] )\\n Nx[i] *= sign\\n Ny[i] *= sign\\n Nz[i] *= sign\\n\\n\\n for i in range(0, self.swarm.particleLocalCount):\\n scale = 1.0 / np.sqrt(Nx[i]**2 + Ny[i]**2 + Nz[i]**2)\\n Nx[i] *= scale\\n Ny[i] *= scale\\n Nz[i] *= scale\\n\\n\\n self.director.data[:,0] = Nx[:]\\n self.director.data[:,1] = Ny[:]\\n self.director.data[:,2] = Nz[:]\\n\\n print(\\\"Surf Norms\\\")\\n\\n return\",\n \"def polyMultiLayoutUV(*args, flipReversed: bool=True, gridU: int=0, gridV: int=0, layout: int=0,\\n layoutMethod: int=0, offsetU: float=0.0, offsetV: float=0.0,\\n percentageSpace: float=0.0, prescale: int=0, rotateForBestFit: int=0,\\n scale: int=0, sizeU: float=0.0, sizeV: float=0.0, uvSetName: AnyStr=\\\"\\\",\\n **kwargs)->None:\\n pass\",\n \"def addUVPoly(self,p,uv):\\n for (t,uvt) in triangulateUV(p,uv):\\n self.addUVTri(t,uvt)\\n return self\",\n \"def triangulationMatting(self):\\n\\n success = False\\n msg = 'Placeholder'\\n\\n #########################################\\n ## PLACE YOUR CODE BETWEEN THESE LINES ##\\n #########################################\\n if self._images[\\\"backA\\\"].shape != self._images[\\\"backB\\\"].shape or self._images[\\\"compA\\\"].shape != self._images[\\\"compB\\\"].shape or self._images[\\\"compA\\\"].shape != self._images[\\\"compB\\\"].shape or self._images[\\\"compA\\\"].shape != self._images[\\\"compB\\\"].shape or self._images[\\\"compA\\\"].shape != self._images[\\\"compB\\\"].shape or self._images[\\\"compA\\\"].shape != self._images[\\\"compB\\\"].shape:\\n success = False\\n msg = \\\"Input files have different sizes.\\\"\\n\\n elif (self._images[\\\"backA\\\"] is not None) and (self._images[\\\"backB\\\"] is not None) \\\\\\n and (self._images[\\\"compA\\\"] is not None) and (self._images[\\\"compB\\\"] is not None):\\n # four rgb arrays\\n success = True\\n backA = self._images[\\\"backA\\\"] / 255.0\\n backA.astype(np.float32)\\n backB = self._images[\\\"backB\\\"] / 255.0\\n backB.astype(np.float32)\\n compA = self._images[\\\"compA\\\"] / 255.0\\n compA.astype(np.float32)\\n compB = self._images[\\\"compB\\\"] / 255.0\\n compB.astype(np.float32)\\n\\n backA_R = backA[:, :, 2]\\n backB_R = backB[:, :, 2]\\n\\n compA_R = compA[:, :, 2]\\n compA_G = compA[:, :, 1]\\n compA_B = compA[:, :, 0]\\n compB_R = compB[:, :, 2]\\n compB_G = compB[:, :, 1]\\n compB_B = compB[:, :, 0]\\n\\n backA_G = backA[:, :, 1]\\n backB_G = backB[:, :, 1]\\n\\n backA_B = backA[:, :, 0]\\n backB_B = backB[:, :, 0]\\n\\n\\n alpha = 1.0 - (((compA_R - compB_R) * (backA_R - backB_R) +\\n (compA_G - compB_G) * (backA_G - backB_G) +\\n (compA_B - compB_B) * (backA_B - backB_B)) /\\n ((backA_R - backB_R) ** 2 + (backA_G - backB_G) ** 2 + (backA_B - backB_B) ** 2))\\n # backA .. comB = image\\n # four rgb arrays\\n # assume they have the same shape\\n # height = backA.shape[0]\\n # width = backA.shape[1]\\n\\n colOut_R = compA_R - backA_R + alpha * backA_R\\n colOut_G = compA_G - backA_G + alpha * backA_G\\n colOut_B = compA_B - backA_B + alpha * backA_B\\n colOut = cv.merge((colOut_B, colOut_G, colOut_R))\\n # for i in range(height):\\n # for j in range(width):\\n # A = np.array([[1, 0, 0, -backA[i, j][2]],\\n # [0, 1, 0, -backA[i, j][1]],\\n # [0, 0, 1, -backA[i, j][0]],\\n # [1, 0, 0, -backB[i, j][2]],\\n # [0, 1, 0, -backB[i, j][1]],\\n # [0, 0, 1, -backB[i, j][0]]])\\n # B = np.array([[compA[i, j][2] - backA[i, j][2]],\\n # [compA[i, j][1] - backA[i, j][1]],\\n # [compA[i, j][0] - backA[i, j][0]],\\n # [compB[i, j][2] - backB[i, j][2]],\\n # [compB[i, j][1] - backB[i, j][1]],\\n # [compB[i, j][0] - backB[i, j][0]]])\\n # x = np.matmul(np.matmul(inv(np.matmul(A.transpose(), A)), A.transpose()), B)\\n # '''\\n # AT = A.transpose()\\n # ATA = np.matmul(AT, A)\\n # ATA_inv = inv(ATA)\\n # ATA_inv_AT = np.matmul(ATA_inv, AT)\\n # x = np.matmul(ATA_inv_AT, B)\\n # '''\\n # colOut[i, j] = np.array([[x[2][0], x[1][0], x[0][0]]])\\n # alpha[i, j] = x[3]\\n\\n alpha = alpha * 255.0\\n colOut *= 255.0\\n self._images[\\\"colOut\\\"] = colOut\\n self._images[\\\"alphaOut\\\"] = alpha\\n\\n\\n else:\\n msg = \\\"Missing pictures\\\"\\n #########################################\\n\\n return success, msg\",\n \"def do_stuff(self):\\n self.create_tourism_raster()\",\n \"def vector_comp(X, Y, U, V, skip=5, *, t_axis=0, pcolor_kw={}, quiver_kw={}):\\n # plot the magnitude of the vectors as a pcolormesh\\n magnitude = np.sqrt(U**2+V**2)\\n pcolor_block = Pcolormesh(X, Y, magnitude, t_axis=t_axis, **pcolor_kw)\\n\\n # use a subset of the data to plot the arrows as a quiver plot.\\n xy_slice = tuple([slice(None, None, skip)]*len(X.shape))\\n\\n uv_slice = [slice(None, None, skip)]*len(U.shape)\\n uv_slice[t_axis] = slice(None)\\n uv_slice = tuple(uv_slice)\\n\\n quiver_block = Quiver(X[xy_slice], Y[xy_slice],\\n U[uv_slice]/magnitude[uv_slice],\\n V[uv_slice]/magnitude[uv_slice],\\n t_axis=t_axis, **quiver_kw)\\n\\n return [pcolor_block, quiver_block]\",\n \"def opticalFlow(im1: np.ndarray, im2: np.ndarray, step_size=10, win_size=5) -> (np.ndarray, np.ndarray):\\r\\n if im1.ndim == 3:\\r\\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\\r\\n if im2.ndim == 3:\\r\\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\\r\\n\\r\\n ker = np.array([[1, 0, -1]])\\r\\n I_x = cv2.filter2D(im2, -1, ker, cv2.BORDER_REPLICATE)\\r\\n I_y = cv2.filter2D(im2, -1, ker.T, cv2.BORDER_REPLICATE)\\r\\n\\r\\n I_t = im2 - im1\\r\\n pts = []\\r\\n uv = []\\r\\n h, w = I_x.shape[:2]\\r\\n half_win = win_size // 2\\r\\n for i in range(half_win, h - half_win + 1, step_size):\\r\\n for j in range(half_win, w - half_win + 1, step_size):\\r\\n mat_x = I_x[i - half_win:i + half_win + 1, j - half_win:j + half_win + 1]\\r\\n mat_y = I_y[i - half_win:i + half_win + 1, j - half_win:j + half_win + 1]\\r\\n ATA = np.array([[np.sum(mat_x * mat_x), np.sum(mat_x * mat_y)],\\r\\n [np.sum(mat_x * mat_y), np.sum(mat_y * mat_y)]])\\r\\n lambdas = np.linalg.eigvals(ATA)\\r\\n if lambdas.min() > 1 and lambdas.max() / lambdas.min() < 100:\\r\\n mat_t = I_t[i - half_win:i + half_win + 1, j - half_win:j + half_win + 1]\\r\\n ATb = np.array([-np.sum(mat_x * mat_t), -np.sum(mat_y * mat_t)])\\r\\n local_uv = np.linalg.inv(ATA).dot(ATb)\\r\\n uv.append(local_uv * (-1))\\r\\n pts.append([j, i])\\r\\n pts = np.array(pts)\\r\\n uv = np.array(uv)\\r\\n return pts, uv\",\n \"def get_uv(u, v):\\n uv = np.zeros((2, 2))\\n uv[0][0] = u[0]\\n uv[1][0] = u[1]\\n uv[0][1] = v[0]\\n uv[1][1] = v[1]\\n return uv\",\n \"def uv_at_xy(self, x, y, x0, y0, s0):\\n dx, dy = self.distance(x0, y0, x, y)\\n #print 'dx, dy:', dx, dy\\n rr2 = (dx**2 + dy**2)**-1\\n u = - s0 * dy * r_twopi * rr2\\n v = s0 * dx * r_twopi * rr2\\n #print 'u, v', u, v\\n return u, v\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5860706","0.5756254","0.558495","0.55116755","0.5500914","0.54856575","0.5411383","0.53948486","0.53849983","0.5343461","0.5337835","0.5308709","0.53073806","0.53056586","0.5296829","0.5273831","0.52715695","0.5257271","0.52373564","0.5233863","0.52252555","0.5224352","0.5209211","0.5199574","0.5192895","0.5185242","0.51826525","0.51823306","0.5169408","0.51657516","0.51523936","0.5148985","0.5147463","0.5145048","0.51427555","0.5135557","0.513102","0.5128258","0.5126369","0.51188886","0.511446","0.5105716","0.5095628","0.50922894","0.507283","0.50664425","0.50653666","0.5059666","0.5033812","0.50062853","0.49860814","0.49754858","0.49562857","0.49549395","0.49530366","0.49515972","0.49459863","0.49428034","0.49416497","0.49411026","0.49372083","0.49352843","0.49340084","0.49313226","0.4927199","0.4922836","0.49179173","0.4917672","0.49168167","0.49155763","0.49099725","0.4905241","0.49021432","0.48998514","0.4898929","0.48988813","0.48930645","0.48901126","0.4890039","0.48867375","0.4886003","0.48830453","0.48761192","0.48755687","0.4872256","0.48671296","0.48622224","0.48572218","0.48464495","0.48439246","0.4838243","0.48310995","0.48295075","0.4818481","0.481789","0.48176116","0.48146912","0.4810111","0.48078552","0.4806719"],"string":"[\n \"0.5860706\",\n \"0.5756254\",\n \"0.558495\",\n \"0.55116755\",\n \"0.5500914\",\n \"0.54856575\",\n \"0.5411383\",\n \"0.53948486\",\n \"0.53849983\",\n \"0.5343461\",\n \"0.5337835\",\n \"0.5308709\",\n \"0.53073806\",\n \"0.53056586\",\n \"0.5296829\",\n \"0.5273831\",\n \"0.52715695\",\n \"0.5257271\",\n \"0.52373564\",\n \"0.5233863\",\n \"0.52252555\",\n \"0.5224352\",\n \"0.5209211\",\n \"0.5199574\",\n \"0.5192895\",\n \"0.5185242\",\n \"0.51826525\",\n \"0.51823306\",\n \"0.5169408\",\n \"0.51657516\",\n \"0.51523936\",\n \"0.5148985\",\n \"0.5147463\",\n \"0.5145048\",\n \"0.51427555\",\n \"0.5135557\",\n \"0.513102\",\n \"0.5128258\",\n \"0.5126369\",\n \"0.51188886\",\n \"0.511446\",\n \"0.5105716\",\n \"0.5095628\",\n \"0.50922894\",\n \"0.507283\",\n \"0.50664425\",\n \"0.50653666\",\n \"0.5059666\",\n \"0.5033812\",\n \"0.50062853\",\n \"0.49860814\",\n \"0.49754858\",\n \"0.49562857\",\n \"0.49549395\",\n \"0.49530366\",\n \"0.49515972\",\n \"0.49459863\",\n \"0.49428034\",\n \"0.49416497\",\n \"0.49411026\",\n \"0.49372083\",\n \"0.49352843\",\n \"0.49340084\",\n \"0.49313226\",\n \"0.4927199\",\n \"0.4922836\",\n \"0.49179173\",\n \"0.4917672\",\n \"0.49168167\",\n \"0.49155763\",\n \"0.49099725\",\n \"0.4905241\",\n \"0.49021432\",\n \"0.48998514\",\n \"0.4898929\",\n \"0.48988813\",\n \"0.48930645\",\n \"0.48901126\",\n \"0.4890039\",\n \"0.48867375\",\n \"0.4886003\",\n \"0.48830453\",\n \"0.48761192\",\n \"0.48755687\",\n \"0.4872256\",\n \"0.48671296\",\n \"0.48622224\",\n \"0.48572218\",\n \"0.48464495\",\n \"0.48439246\",\n \"0.4838243\",\n \"0.48310995\",\n \"0.48295075\",\n \"0.4818481\",\n \"0.481789\",\n \"0.48176116\",\n \"0.48146912\",\n \"0.4810111\",\n \"0.48078552\",\n \"0.4806719\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61613876"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6383,"cells":{"query":{"kind":"string","value":"Drive the feather combination. Functionally, this means Cleaning the individual ms separately. Imaging the individual ms. Feathering the two together."},"document":{"kind":"string","value":"def _drive_feather(param_dict, clargs, output_basename, casa_instance):\n\n # todo later -> the imstat stuff\n\n script = []\n\n thresh, seven_meter_clean_args = utils.param_dict_to_clean_input(\n param_dict, seven_meter=True)\n\n _, twelve_meter_clean_args = utils.param_dict_to_clean_input(\n param_dict, seven_meter=False)\n\n if clargs.verbose:\n utils.eprint('Seven meter clean args {}'.format(\n seven_meter_clean_args))\n utils.eprint('Twelve meter clean args {}'.format(\n twelve_meter_clean_args))\n utils.eprint('Running individual cleaning...')\n\n seven_meter_cleaned = drivecasa.commands.reduction.clean(\n script,\n niter=10000,\n vis_paths=param_dict['seven_meter_filename'],\n threshold_in_jy=thresh,\n other_clean_args=seven_meter_clean_args,\n out_path=os.path.abspath(output_basename))\n\n twelve_meter_cleaned = drivecasa.commands.reduction.clean(\n script,\n niter=10000,\n vis_paths=param_dict['twelve_meter_filename'],\n threshold_in_jy=thresh,\n other_clean_args=twelve_meter_clean_args,\n out_path=os.path.abspath(output_basename))\n\n if not clargs.generate:\n _ = casa_instance.run_script(script, timeout=None)\n\n if clargs.generate:\n utils.output_to_file(script, output_basename)\n\n if clargs.verbose:\n utils.eprint('Individual cleanings complete. Now feathering.')\n\n script = []\n\n feathered_image = additional_casa_commands.feather(script,\n output_basename=output_basename,\n highres=twelve_meter_cleaned.image,\n lowres=seven_meter_cleaned.image,\n weighting=_calc_feather_weighting(param_dict))\n if clargs.verbose:\n utils.eprint(\"Feather script\")\n utils.eprint(script)\n\n if not clargs.generate:\n _ = casa_instance.run_script(script, timeout=None)\n\n if clargs.generate:\n utils.output_to_file(script, output_basename)\n\n script = []\n if param_dict['moments']:\n for moment in param_dict['moments']:\n _ = additional_casa_commands.immoments(\n script, feathered_image, feathered_image, moment)\n\n if clargs.verbose:\n utils.eprint(\"Moments\")\n utils.eprint(script)\n\n if not clargs.generate:\n _ = casa_instance.run_script(script, timeout=None)\n\n if clargs.generate:\n utils.output_to_file(script, output_basename)\n\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _removeFX(self):\r\n\t\tnodesToClean = [CONST.FOAM_FLUID_SHAPENODE, CONST.WAKE_FLUID_SHAPENODE, 'fluids_hrc']\r\n\t\tfor eachNode in nodesToClean:\r\n\t\t\ttry:\r\n\t\t\t\tcmds.delete(each)\r\n\t\t\texcept:\r\n\t\t\t\tpass\r\n\r\n\t\tfor eachCache in cmds.ls(type = 'cacheFile'):\r\n\t\t\tcmds.delete(eachCache)","def step(self):\n self.world.slosh_oceans()\n self.world.transfer_energy_vertically()\n self.world.transfer_energy_horizontally()\n self.world.absorb_energy_from_core()\n self.world.absorb_energy_from_sun(self.sun)","def run(self):\n\n self.steer()\n self.drive()","def at_med_filt(self):\n\t fmed = self.fm - nd.median_filter(self.fm, size=self.header['tdurcad']*3)\n\n\t # Shift t-series so first transit is at t = 0 \n\t dt = t0shft(self.t,self.P,self.t0)\n\t tf = self.t + dt\n\t phase = np.mod(tf + 0.25 * self.P, self.P) / self.P - 0.25\n\t tPF = phase * self.P # Phase folded time\n\n\t # bin up the points\n\t for nbpt in [1,5]:\n\t # Return bins of a so that nbpt fit in a transit\n\t nbins = np.round( tPF.ptp()/self.tdur*nbpt ) \n\t bins = np.linspace(tPF.min(),tPF.max(),nbins+1)\n\t fmed = ma.masked_invalid(fmed)\n\t btPF,bfmed = hbinavg(tPF[~fmed.mask],fmed[~fmed.mask],bins)\n \n\t rbmed = np.rec.fromarrays([btPF,bfmed],names=['t','f'])\n\n\t self.add_dset('rbmed%i' % nbpt, rbmed, description='Binned phase-folded, median filtered timeseries, %i points per tdur'% nbpt) \n\n\t self.add_dset('fmed',fmed,description='Median detrended flux')","def at_med_filt(self):\n\t fmed = self.fm - nd.median_filter(self.fm, size=self.header['tdurcad']*3)\n\n\t # Shift t-series so first transit is at t = 0 \n\t dt = t0shft(self.t,self.P,self.t0)\n\t tf = self.t + dt\n\t phase = np.mod(tf + 0.25 * self.P, self.P) / self.P - 0.25\n\t tPF = phase * self.P # Phase folded time\n\n\t # bin up the points\n\t for nbpt in [1,5]:\n\t # Return bins of a so that nbpt fit in a transit\n\t nbins = np.round( tPF.ptp()/self.tdur*nbpt ) \n\t bins = np.linspace(tPF.min(),tPF.max(),nbins+1)\n\t fmed = ma.masked_invalid(fmed)\n\t btPF,bfmed = hbinavg(tPF[~fmed.mask],fmed[~fmed.mask],bins)\n \n\t rbmed = np.rec.fromarrays([btPF,bfmed],names=['t','f'])\n\n\t self.add_dset('rbmed%i' % nbpt, rbmed, description='Binned phase-folded, median filtered timeseries, %i points per tdur'% nbpt) \n\n\t self.add_dset('fmed',fmed,description='Median detrended flux')","def test_apply_father_wavelet_dirac(self):\n pass","def runBrighterFatter():\n RunData([getFiles(mintime=(15, 12, 20), maxtime=(15, 24, 16), folder='data/31Jul/')[0],], out='I800nmlow',\n wavelength='l800l')\n RunData([getFiles(mintime=(15, 28, 40), maxtime=(15, 39, 21), folder='data/31Jul/')[2],], out='I800nmmed',\n wavelength='l800m')\n RunData([getFiles(mintime=(15, 40, 07), maxtime=(15, 45, 14), folder='data/29Jul/')[4],], out='I800nmhigh',\n wavelength='l800h')","def applyMorphologicalCleaning(self, image):","def stop(self):\n self.stop_aperture()","def processFoil(self):\n \n # Split airfoil in upper and lower portions\n self.__airfoilSplit()\n \n # Interpolate\n self.__hinterpolate()","def burn_step(self):\n change = np.full((self.width, self.height), 0)\n for x in range(0, self.width - 1):\n for y in range(0, self.height - 1):\n # How fast we go through the fuel\n if random.randrange(2) == 0:\n self.fire_check_point(x, y, change)\n\n self.temp = np.maximum(change, self.temp)","def moveFWto(self, filtpos):\n self.askFW(\"3FDE\") # Dumps errors \n self.askFW(\"3FMP \" + str(filtpos))\n self.waitFW()\n self.askFW(\"3FDE\") # Dumps errors \n self.askFW(\"1HDE\") # Dumps errors \n self.askFW(\"2HDE\") # Dumps errors","def drive(self, kilometres_driven):\n self.fuel -= (self.litres_per_kilometre * kilometres_driven)","def run(self):\n self.coffee_machine.water_tank.decrease_weight(self.coffee_machine.chosen_coffee_data.get('water_weight'))","def removeInsignificant(self):\n #TODO make sure this method now works AFTER meanCurves and analyseCures have been run\n \n # Searching for curves that are in the noise\n if len(self.plate.noProtein) > 0:\n thresholdm, i = rh.meanSd([self.originalPlate.wells[x].monoThresh for x in self.plate.noProtein])\n for well in self.originalPlate.wells:\n if not self.originalPlate.wells[well].contents.isControl and well not in self.delCurves:\n if self.originalPlate.wells[well].monoThresh > thresholdm/1.15:\n #self.wells[well].fluorescence = None\n self.delCurves.append(well)\n\n # Searching for curves that have overloaded the sensor\n for well in self.wells:\n if well not in self.delCurves:\n mini = self.wells[well].fluorescence[0]\n maxi = self.wells[well].fluorescence[0]\n\n maxInd = 0\n for i in range(len(self.wells[well].fluorescence)):\n if self.wells[well].fluorescence[i] > maxi:\n maxi = self.wells[well].fluorescence[i]\n maxInd = i\n if self.wells[well].fluorescence[i] < mini:\n mini = self.wells[well].fluorescence[i]\n\n diff = maxi - mini\n\n # A boundry defining how much the points can fluctuate and still be considered flat\n lowFlatBoundry = maxi - 0.005*diff\n\n # Look each way to see how many temperature steps the curve stays flat for\n count = 0\n ind = maxInd - 1\n while ind>=0:\n if self.wells[well].fluorescence[ind] > lowFlatBoundry:\n count += 1\n ind -= 1\n else:\n break\n ind = maxInd+1\n while ind<len(self.wells[well].fluorescence):\n if self.wells[well].fluorescence[ind] > lowFlatBoundry:\n count += 1 \n ind += 1\n else:\n break\n if well not in self.delCurves and count >= 10:\n self.delCurves.append(well) \n return","def step(self):\n if self.store_paths:\n leapfrog_steps = self._max_leapfrog_steps\n else:\n leapfrog_steps = torch.ceil(self._max_leapfrog_steps * torch.rand(1)).int()\n self.potential_ = self.get_potential()\n self.metric_ = self.get_metric()\n self.momentum = self.resample_momenta()\n self.hamiltonian_ = self.get_hamiltonian()\n old_hamiltonian = self.hamiltonian_\n if self.shadow:\n if self.max_shadow is not None:\n old_shadow = torch.max(self.shadow_.clone() + self.max_shadow, old_hamiltonian)\n else:\n old_shadow = self.shadow_.clone()\n rejected = False\n for step in range(leapfrog_steps):\n if (self._integrator == 'RMHMC') and (self.lbfgs == False):\n self.momentum, rejected = self.implicit_half_kick()\n self.parameters = self.parameters.detach().requires_grad_(True)\n if rejected:\n break\n self.parameters, rejected = self.implicit_drift()\n self.parameters = self.parameters.detach().requires_grad_(True)\n if rejected:\n break\n self.momentum, rejected = self.explicit_half_kick()\n self.parameters = self.parameters.detach().requires_grad_(True)\n if rejected:\n break\n elif self.lbfgs == True:\n self.momentum, rejected = self.lbfgs_half_kick()\n self.parameters = self.parameters.detach().requires_grad_(True)\n if rejected:\n break\n self.parameters, rejected = self.lbfgs_drift()\n self.parameters = self.parameters.detach().requires_grad_(True)\n if rejected:\n break\n self.momentum = self.explicit_half_kick()\n self.parameters = self.parameters.detach().requires_grad_(True)\n if rejected:\n break\n else:\n self.momentum, rejected = self.explicit_half_kick()\n self.parameters = self.parameters.detach().requires_grad_(True)\n self.parameters = self.explicit_drift()\n self.parameters = self.parameters.detach().requires_grad_(True)\n self.momentum, rejected = self.explicit_half_kick()\n self.parameters = self.parameters.detach().requires_grad_(True)\n if self.store_paths:\n self.paths.append(self.parameters.detach())\n new_hamiltonian = self.get_hamiltonian()\n ratio = old_hamiltonian - new_hamiltonian\n self.hamiltonian_error.append(ratio.detach().unsqueeze(0))\n if self.shadow:\n if self.max_shadow is not None:\n new_shadow = torch.max(self.get_shadow() + self.max_shadow, new_hamiltonian)\n else:\n new_shadow = self.get_shadow()\n shadow_error = old_shadow - new_shadow\n newratio = ratio + shadow_error\n self.shadow_hamiltonian_error.append(newratio.detach().unsqueeze(0))\n ratio = newratio\n\n uniform_rand = torch.rand(1)\n if uniform_rand >= torch.exp(ratio):\n # Reject sample\n rejected = True\n\n if rejected:\n if (len(self.momenta) > 10) and (self.momenta[-1] == self.momenta[-10]).sum().item():\n self.degenerate = True\n self.rejected += 1\n self.momentum = self.momenta[-1]\n self.parameters = self.samples[-1].clone().detach().requires_grad_(True)\n if self.shadow:\n radon_nikodym = torch.exp(old_shadow).unsqueeze(0)\n \n if self.verbose:\n print(\"(Rejected)\", int(self.acceptance_rate() * 100), \"%; Log-ratio: \",\n ratio.detach())\n else:\n self.accepted += 1\n if self.shadow:\n radon_nikodym = torch.exp(new_shadow).unsqueeze(0)\n if self.verbose:\n print(\"(Accepted)\", int(self.acceptance_rate() * 100), \"%; Log-ratio: \",\n ratio.detach())\n self.samples.append(self.parameters.detach())\n self.momenta.append(self.momentum)\n self.hamiltonians.append(self.hamiltonian_.detach())\n self.rands_.append(uniform_rand)\n self.shadows.append(self.shadow_.detach())\n if self.shadow:\n self.radon_nikodym.append(radon_nikodym.detach())\n return None","def clean_tod(self,d,ifeed,feed):\n scan_edges = d[f'{self.level2}/Statistics/scan_edges'][...]\n nscans = scan_edges.shape[0]\n\n feed_tod = d[f'{self.level2}/averaged_tod'][ifeed,:,:,:]\n weights = np.zeros(feed_tod.shape)\n mask = np.zeros(feed_tod.shape[-1],dtype=bool)\n az = d['level1/spectrometer/pixel_pointing/pixel_az'][ifeed,:]\n el = d['level1/spectrometer/pixel_pointing/pixel_el'][ifeed,:]\n\n # Statistics for this feed \n medfilt_coefficient = d[f'{self.level2}/Statistics/filter_coefficients'][ifeed,...]\n atmos = d[f'{self.level2}/Statistics/atmos'][ifeed,...]\n atmos_coefficient = d[f'{self.level2}/Statistics/atmos_coefficients'][ifeed,...]\n wnoise_auto = d[f'{self.level2}/Statistics/wnoise_auto'][ifeed,...]\n fnoise_fits = d[f'{self.level2}/Statistics/fnoise_fits'][ifeed,...]\n\n # then the data for each scan\n last = 0\n scan_samples = []\n for iscan,(start,end) in enumerate(scan_edges):\n scan_samples = np.arange(start,end,dtype=int)\n median_filter = d[f'{self.level2}/Statistics/FilterTod_Scan{iscan:02d}'][ifeed,...]\n N = int((end-start))\n end = start+N\n tod = feed_tod[...,start:end]\n mask[start:end] = True\n # Subtract atmospheric fluctuations per channel\n for iband in range(4):\n for ichannel in range(64):\n #if self.channelmask[ifeed,iband,ichannel] == False:\n amdl = Statistics.AtmosGroundModel(atmos[iband,iscan],az[start:end],el[start:end]) *\\\n atmos_coefficient[iband,ichannel,iscan,0]\n if self.median_filter:\n tod[iband,ichannel,:] -= median_filter[iband,:N] * medfilt_coefficient[iband,ichannel,iscan,0]\n if self.atmosphere:\n tod[iband,ichannel,:] -= amdl\n tod[iband,ichannel,:] -= np.nanmedian(tod[iband,ichannel,:])\n\n\n wnoise = wnoise_auto[:,:,iscan,0]\n weights[...,start:end] = 1./wnoise[...,None]**2\n bad = np.isnan(weights) | np.isinf(weights) | ~np.isfinite(feed_tod)\n feed_tod[bad] = 0\n weights[bad] = 0\n\n return feed_tod, weights, mask","def stop_aperture(self):\n self.aperture_id = None\n self.mode = \"\"","def climb(self):\n print(\"Inside WoodElf.climb\")","def masterflat(input_file):\n #set original directory\n original_path = os.getcwd()\n data_path = input_file['data_path']\n save_path = input_file['save_path']\n #Change your directory to data diretory\n os.chdir(data_path)\n #list all flat images\n flat = glob.glob('flat*.fits')\n print 'Loading flat images \\nTotal of flat files = ',len(flat),'\\nFiles = \\n'\n print flat\n #if save_path exist, continue; if not, create.\n if not os.path.exists(save_path):\n os.makedirs(save_path)\n #create a list of bias images and copy images to save_path\n os.system('cp flat*.fits '+save_path)\n #creating the names of flat with bias subctracted\n bflat = []\n for i in flat:\n bflat.append('B'+i)\n print '\\n Names os flat images with bias subtracted: \\n \\n',bflat\n #change for save_path directory\n os.chdir(save_path)\n #verify if previous superbias exist\n if os.path.isfile('superflat.fits') == True:\n os.system('rm superflat.fits')\n #verify if exits previous bflat*.fits files and remove then.\n for i in bflat:\n if os.path.isfile(i) == True:\n os.system('rm -f '+i)\n print '\\nCreating superflat .... \\n'\n #create the list of flat images and bflat images\n #flat = string.join(flat,',')\n #bflat = string.join(bflat,',')\n print '\\n Subtracting bias from flat images and creating bflat images.... \\n'\n #iraf.imarith()\n for i in range(len(flat)):\n iraf.imarith(flat[i],'-','superbias.fits',bflat[i])\n #print statistics from bflat*.fits images\n iraf.imstat(bflat[i])\n print '\\n .... done \\n'\n #clean previos flat*.fits files\n print '\\n Clean flat*.fits images .... \\n'\n os.system('rm flat*.fits')\n print '\\n .... done. \\n'\n #normalizing each flat\n print '\\nNormalizing each flat ....\\n'\n #checking if mean from numpy is the same from your bflat images using imstat\n #take the mean of each bflat image\n bflat_mean = np.zeros(len(bflat))\n for i in range(len(bflat)):\n image = fits.getdata(bflat[i])\n image = np.array(image,dtype='Float64')\n bflat_mean[i] = round(np.mean(image))\n image = 0 #clean image allocate to this variable\n print 'The mean of each bflat image, respectivaly ...'\n print bflat_mean\n #creating the names of bflat images after the normalization:\n abflat = []\n for i in bflat:\n abflat.append('A'+i)\n print '\\n Names os bflat images with bias subtracted and normalizad: \\n \\n',abflat\n #verify if exist previous ABflat*.fits images and remove then.\n for i in abflat:\n if os.path.isfile(i) == True:\n os.system('rm -f '+i)\n for i in range(len(abflat)):\n iraf.imarith(bflat[i],'/',bflat_mean[i],abflat[i])\n print '\\n.... done!\\n'\n # print '\\n Cleaning bflat*.fits images ....\\n'\n # os.system('rm Bflat*.fits')\n print '\\n.... done.\\n'\n print 'Statistics of the abflat*.fits images .... \\n'\n for i in range(len(abflat)):\n iraf.imstat(abflat[i])\n print '\\n Combining abflat images ....\\n'\n\n # ablist = string.join(abflat,',')\n # iraf.imcombine(ablist,'superflat.fits')\n #change how import flat files\n #usning the abflat list of flat files We will create a pandas python dataframe\n ablist = DataFrame(abflat)\n ablist.columns=['flat_files']\n ablist.to_csv('flat_list',index_label=False,index=False,header=False)\n #combine all flat images\n iraf.imcombine('@flat_list','superflat.fits')\n iraf.imstat('superflat.fits')\n print '\\n .... done. \\n'\n # print '\\nCleaning ABflat*.fits images ....\\n'\n # os.system('rm ABflat*.fits')\n print '\\n.... done!'\n #Verify if the image was created:\n output = glob.glob('superflat*.fits')\n if len(output) != 0:\n output = 0\n else:\n output = 1\n #Return to original directory\n os.chdir(original_path)\n #last mensage\n print '\\n MASTERFLAT.FITS created! \\n'\n print '\\n END of Data Reduction for create a masterflat.fits file. \\n'\n #obtain the value of return\n if output == 1:\n print '!!! ERROR/WARNING !!!'\n print 'Check if the superbias was created or if there is more than one superbias image.'\n return output","def start_fare(self):\n self.current_fare_distance = 0","def _remove_flux_extinction(self):\n self.fluxUnred = self.flux.copy()\n self.fluxErrUnred = self.fluxErr.copy()\n self.fluxRenorm = self.flux.copy()\n self.fluxErrRenorm = self.fluxErr.copy()\n\n # Using negative a_v so that extinction.apply works in reverse and removes the extinction\n if self.mwebv:\n extinctions = extinction.fitzpatrick99(wave=self._good_filter_wave, \\\n a_v=-3.1 * self.mwebv, r_v=3.1, unit='aa')\n\n for i, pb in enumerate(self._good_filters):\n mask = (self.passband == pb)\n\n flux_pb = self.flux[mask]\n fluxerr_pb = self.fluxErr[mask]\n npbobs = len(flux_pb)\n\n if npbobs < 1:\n return\n\n if self.mwebv:\n flux_out = extinction.apply(extinctions[i], flux_pb, inplace=False)\n fluxerr_out = extinction.apply(extinctions[i], fluxerr_pb, inplace=False)\n else:\n flux_out = flux_pb\n fluxerr_out = fluxerr_pb\n self.fluxUnred[mask] = flux_out\n self.fluxErrUnred[mask] = fluxerr_out\n\n if npbobs > 1:\n # there's at least enough observations to find minimum and maximum\n minfluxpb = flux_out.min()\n maxfluxpb = flux_out.max()\n norm = maxfluxpb - minfluxpb\n self.fluxRenorm[mask] = (flux_out - minfluxpb) / norm\n self.fluxErrRenorm[mask] = fluxerr_out / norm\n elif npbobs == 1:\n # deal with the case with one observation in this passband by setting renorm = 0.5\n norm = self.fluxUnred[mask] / 0.5\n self.fluxRenorm[mask] /= norm\n self.fluxErrRenorm[mask] /= norm\n\n self._default_cols = ['time', 'flux', 'fluxErr', 'fluxUnred', 'fluxErrUnred', \\\n 'fluxRenorm', 'fluxErrRenorm', 'photflag', 'zeropoint', 'obsId']\n return","def expand_slicer_aperture(system):\n\n # First of all, we need to find the Surface Number for the IMAGE SLICER\n N_surfaces = system.LDE.NumberOfSurfaces\n surface_names = {} # A dictionary of surface number -> surface comment\n for k in np.arange(1, N_surfaces):\n surface_names[k] = system.LDE.GetSurfaceAt(k).Comment\n # find the Slicer surface number\n try:\n # The naming convention for this surface has changed. Not the same for Nominal Design as Monte Carlos\n slicer_num = list(surface_names.keys())[list(surface_names.values()).index('Slicer Mirror')]\n except ValueError:\n slicer_num = list(surface_names.keys())[list(surface_names.values()).index('IFU ISA')]\n slicer = system.LDE.GetSurfaceAt(slicer_num)\n\n # Read Current Aperture Settings\n apt_type = slicer.ApertureData.CurrentType\n # print(\"Aperture type: \", apt_type)\n if apt_type == 4: # 4 is Rectangular aperture\n current_apt_sett = slicer.ApertureData.CurrentTypeSettings\n # print(\"Current Settings:\")\n x0 = current_apt_sett._S_RectangularAperture.XHalfWidth\n y0 = current_apt_sett._S_RectangularAperture.YHalfWidth\n # If the Y aperture hasn't been changed already, we change it here to 999 mm to get all rays through\n if y0 != 999:\n # Change Settings\n aperture_settings = slicer.ApertureData.CreateApertureTypeSettings(\n constants.SurfaceApertureTypes_RectangularAperture)\n aperture_settings._S_RectangularAperture.XHalfWidth = x0\n aperture_settings._S_RectangularAperture.YHalfWidth = 999\n slicer.ApertureData.ChangeApertureTypeSettings(aperture_settings)\n\n current_apt_sett = slicer.ApertureData.CurrentTypeSettings\n # Notify that we have successfully modified the aperture\n print(\"Changing aperture of surface: \", slicer.Comment)\n print(\"New Settings:\")\n print(\"X_HalfWidth = %.2f\" % current_apt_sett._S_RectangularAperture.XHalfWidth)\n print(\"Y_HalfWidth = %.2f\" % current_apt_sett._S_RectangularAperture.YHalfWidth)\n\n return","def setup_fermi(self):\n eventclass=5 # 2 (Source) or 5 (UltracleanVeto)\n eventtype=0 # 0 (all), 3 (bestpsf) or 5 (top3 quartiles)\n mask_type='top300'\n force_mask_at_bin_number=10\n\n self.f1 = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min=0,CTB_en_max=40,nside=self.nside,eventclass=eventclass,eventtype=eventtype,newstyle=1,data_July16=True)\n\n if mask_type != 'False':\n self.f1.make_ps_mask(mask_type = mask_type,force_energy = True,energy_bin = force_mask_at_bin_number)\n self.f1.add_diffuse_newstyle(comp = 'p7', eventclass = eventclass, eventtype = eventtype)\n self.f1.add_bubbles(comp='bubs') #bubbles\n self.f1.add_iso(comp='iso') #iso\n self.f1.add_ps_model(comp='ps_model')\n\n # Exposure correct J_map_arr\n self.J_map_arr *= self.f1.CTB_exposure_maps\n\n # Add J-factor map with mean 1 in each energy bin\n self.f1.add_template_by_hand('J_map',np.array([self.J_map_arr[i]/np.mean(self.J_map_arr[i]) for i in range(40)]))","def enemy_waves(self):\n\n pass","def make_flats(side='blue',overwrite=False):\r\n\r\n iraf.unlearn('flatcombine')\r\n iraf.flatcombine.ccdtype = \"\"\r\n iraf.flatcombine.process = \"no\"\r\n iraf.flatcombine.subsets = \"no\"\r\n iraf.flatcombine.rdnoise = \"RON\"\r\n iraf.flatcombine.gain = \"GAIN\"\r\n for aperture in ['0.5', '1.0', '1.5', '2.0']:\r\n flats = find_flats(aperture, side=side)\r\n if len(flats) > 0:\r\n if overwrite:\r\n iraf.delete('flat_%s_%s.fits' % (side, aperture), verify='no')\r\n iraf.delete('temp.fits' , verify='no')\r\n iraf.delete('tempsmooth.fits', verify='no')\r\n iraf.delete('norm_temp.fits', verify='no')\r\n # normalize the flat\r\n if side == 'blue': \r\n if len(flats) < 3:\r\n iraf.flatcombine(','.join(flats), output='temp', reject='pclip')\r\n if len(flats) >= 3:\r\n iraf.flatcombine(','.join(flats), output='temp', reject='avsigclip') \r\n iraf.twodspec.longslit.dispaxis = 2\r\n # iraf.unlearn('response')\r\n # iraf.response.function = 'legendre'\r\n iraf.response.order = 100\r\n # iraf.response.high_rej = 5\r\n # iraf.response.low_rej = 2\r\n # iraf.response.niterate = 10\r\n # iraf.response('temp[0]', 'temp[0]',\r\n # 'flat_%s_%s.fits' % (side, aperture), interactive=\"no\")\r\n # iraf.response('norm_temp[0]', 'norm_temp[0]', \r\n # 'flat_%s_%s.fits' % (side, aperture), interactive=\"no\")\r\n # os.rename('temp.fits', 'raw_flat_%s_%s.fits' % (side, aperture))\r\n iraf.imfilter.boxcar('temp', 'tempsmooth', xwindow='1', ywindow='500')\r\n iraf.imarith('temp', '/', 'tempsmooth', 'norm_temp.fits')\r\n iraf.response('norm_temp[0]', 'norm_temp[0]', \r\n 'flat_%s_%s.fits' % (side, aperture), interactive=\"no\")\r\n os.rename('norm_temp.fits', 'raw_flat_%s_%s.fits' % (side, aperture))\r\n else:\r\n if len(flats) < 3:\r\n iraf.flatcombine(','.join(flats), output='temp', reject='pclip')\r\n if len(flats) >= 3:\r\n iraf.flatcombine(','.join(flats), output='temp', reject='avsigclip') \r\n iraf.twodspec.longslit.dispaxis = 1\r\n iraf.unlearn('response')\r\n iraf.response.function = \"spline3\" \r\n iraf.response.order = 100\r\n iraf.response.high_rej = 3\r\n iraf.response.low_rej = 3\r\n iraf.response.niterate = 3\r\n iraf.response('temp[0]', 'temp[0]',\r\n 'flat_%s_%s.fits' % (side, aperture), interactive=\"no\")\r\n # iraf.response('norm_temp[0]', 'norm_temp[0]', \r\n # 'flat_%s_%s.fits' % (side, aperture), interactive=\"no\")\r\n os.rename('temp.fits', 'raw_flat_%s_%s.fits' % (side, aperture))\r\n # iraf.unlearn('response')\r\n # iraf.response.function = \"spline3\"\r\n # iraf.response.order = 100\r\n # iraf.response.niterate = 3\r\n # iraf.response.low_rej = 3\r\n # iraf.response.high_rej = 3\r\n # if side == 'blue':\r\n # iraf.twodspec.longslit.dispaxis = 2\r\n # else:\r\n # iraf.twodspec.longslit.dispaxis = 1\r\n \r\n\r\n # measure flat-field error from sigma images\r\n iraf.unlearn('imcombine')\r\n iraf.imcombine.reject = 'avsigclip'\r\n iraf.imcombine(','.join(flats), output='flat', sigma='sigma', scale='mode')\r\n iraf.imarith('sigma', '/', 'flat', 'frac')\r\n s = iraf.imstat('frac.fits', fields=\"mean\", nclip=20, Stdout=1, format=\"no\")\r\n print 'Flat field error: ', np.float(s[0])\r\n iraf.delete('flat.fits', verify=\"no\")\r\n iraf.delete('sigma.fits', verify=\"no\")\r\n iraf.delete('frac.fits', verify=\"no\")\r\n else:\r\n print \"No dome or internal flats for the %s arcsec slit.\" % aperture","def step7(self):\n for indx, mr in enumerate(self.mrs):\n self.log.info(\"Set boot drive on controller:%d\"\n % (mr.ctrl_id))\n for vd in self.mr_vds[indx]:\n if (int(mr.cli.bootdrive_vd_get()) != vd):\n mr.cli.bootdrive_vd_set(vd_id=self.mr_vds[indx][indx],\n setting=\"On\")\n break","def main():\n print_banner()\n params = read_steering()\n s, x, y, cur, theta = build_kinoshita()\n s, x, y, cur, theta = read_centerline(s, x, y, cur, theta)\n s, x, y, cur, theta = extend_centerline(s, x, y, cur, theta)\n for t in range(TSTEPS+1):\n cur, theta = tan2curv(s, x, y)\n cur_ori = np.copy(cur)\n cur = filter_curvature(cur, t)\n cur_flt = np.copy(cur)\n cur = lag(s, cur, t)\n cur_lag = np.copy(cur)\n beck_bed = build_beck(cur, s, t)\n allxyz = offset_all(x, y, beck_bed, t)\n if t == 0:\n write_xyz_file(allxyz)\n write_mesh_file(allxyz, beck_bed)\n oxbowxList, oxbowyList = [], []\n centerlinexList, centerlineyList = [], []\n if np.mod(t, GPRINT) == 0:\n centerlinexList.append(x)\n centerlineyList.append(y)\n mf.make_figure(x, y, allxyz, cur_ori, cur_flt, cur_lag, s, beck_bed,\n params, t, oxbowxList, oxbowyList, centerlinexList, centerlineyList)\n if t == TSTEPS:\n break\n s, x, y = migration(s, x, y, cur_flt, cur_lag, theta, t)\n s, x, y, oxbowx, oxbowy, found_cutoff = cutoff(s, x, y)\n s, x, y = smooth_centerline(x, y)\n s, x, y, cur, theta = resample_centerline(s, x, y)\n if found_cutoff:\n oxbowxList.append(oxbowx)\n oxbowyList.append(oxbowy)\n make_gif()\n job_done()","def fire_smelter(self):\n # Get the smelter\n screenshot = utils.take_screenshot()\n forge = screenshot[152:168, 168:184]\n\n # Check if the cold forge exists\n result = cv2.matchTemplate(forge, self.cold_forge_template, cv2.TM_CCORR_NORMED)\n max_val = cv2.minMaxLoc(result)[1]\n\n # Found cold forge, light it and wait\n if max_val > 0.9:\n pyautogui.moveTo(192, 159, 0.15)\n pyautogui.doubleClick()\n sleep(1.5)","def _clean_files(self):\n if self.delfiles & 1:\n ProcUtils.remove(self.okm)\n if self.delfiles & 2:\n ProcUtils.remove(self.hkm)\n if self.delfiles & 4:\n ProcUtils.remove(self.qkm)\n if self.delfiles & 8:\n ProcUtils.remove(self.obc)\n\n if self.log is False:\n ProcUtils.remove(self.pcf_file)\n base = os.path.basename(self.okm)\n ProcUtils.remove(os.path.join(self.dirs['run'],\n '.'.join(['LogReport', base])))\n ProcUtils.remove(os.path.join(self.dirs['run'],\n '.'.join(['LogStatus', base])))\n ProcUtils.remove(os.path.join(self.dirs['run'],\n '.'.join(['LogUser', base])))","def _sweepDir(self, f):\n lastCellFaceVal = np.zeros((self.cells[0].nG, self.cells[0].sNords))\n if f == 2:\n cellList = reversed(self.cells)\n else:\n cellList = self.cells\n blowoff = False\n for cell in cellList:\n if hasattr(cell, 'boundaryCond') and not blowoff:\n cell.applyBC(self.depth)\n blowoff = True\n else:\n # Interior cell\n cell.ordFlux[:, f, :] = lastCellFaceVal[:, :]\n # Only sweep through ordinates that have a component in same direction as\n # current sweep dir.\n dotDir = cell.sNmu * cell.faceNormals[f - 1]\n ordsInSweepDir = np.where(dotDir < 0.)\n for o in np.arange(cell.sNords)[ordsInSweepDir]:\n cell.ordFlux[:, 0, o] = (cell.ordFlux[:, f, o] + self.deltaX * cell.qin[:, 0, o] / (2. * np.abs(cell.sNmu[o]))) / \\\n (1. + self.totalXs * self.deltaX / (2. * np.abs(cell.sNmu[o])))\n if f == 1:\n cell.ordFlux[:, 2, o] = 2. * cell.ordFlux[:, 0, o] - cell.ordFlux[:, f, o]\n lastCellFaceVal[:, o] = cell.ordFlux[:, 2, o]\n elif f == 2:\n cell.ordFlux[:, 1, o] = 2. * cell.ordFlux[:, 0, o] - cell.ordFlux[:, f, o]\n lastCellFaceVal[:, o] = cell.ordFlux[:, 1, o]\n if np.any(cell.ordFlux[:, :, :] < 0.0):\n #print(\"WARNING: Negative flux detected! Refine mesh.\")\n maxStepSize = 2. * np.min(np.abs(cell.sNmu)) * min(1. / self.totalXs)\n #print(\"Max Step size in 1D: \" + str(maxStepSize))\n # refineFactor = 2. # TODO: compute refinement factor on the fly\n #raise Exception('coarse', refineFactor)","def effect(self):\n # Get script's \"--what\" option value.\n what = self.options.what / 10.\n negative_kerf = False\n if what < 0.:\n what = -what\n negative_kerf = True\n\n kerf_in_mm = self.unittouu(str(what) + \" mm\")\n\n operation_list = [\"StrokeToPath\", \"SelectionUnion\",\n \"SelectionBreakApart\", \"SelectionUnion\", \"SelectionBreakApart\"]\n if negative_kerf:\n operation_list[-2] = \"SelectionIntersect\"\n\n join_ext = metaext.MetaEffect(operation_list)\n\n if not self.set_appropriate_width(kerf_in_mm):\n objectify = metaext.MetaEffect([\"ObjectToPath\"])\n objectify.effect(self.document, self.selected, self.doc_ids)\n if not self.set_appropriate_width(kerf_in_mm):\n inkex.error(\"Didn't found any selected path, breaking\")\n return\n \n join_ext.effect(self.document, self.selected, self.doc_ids)\n\n for _, node in self.selected.iteritems():\n #inkex.debug(\"node %s\" % inkex.etree.tostring(node))\n if node.tag == inkex.addNS('path', 'svg'):\n new_width = self.unittouu(\"0.5mm\")\n colour = '#ff0000' if negative_kerf else '#000000'\n style = {'stroke-width': new_width, 'fill': 'none',\n 'stroke': colour}\n style = simplestyle.formatStyle(style)\n node.set('style', style)\n # inkex.debug(\"node %s\" % inkex.etree.tostring(node))","def skywalker(this, **kargs):\n\t\t\n\t\t# Arguments\n\t\tbin = kargs.get('bin', this._BINARY)\n\t\toffshore = kargs.get('offshore', 5)\n\t\tminSize = kargs.get('minSize', 3)\n\t\tblur = kargs.get('blur', False)\n\t\t\n\t\tif blur: # Flou de test\n\t\t\tkernel = np.ones((3, 3), np.float32)/9\n\t\t\tbin = cv2.filter2D(bin, -1, kernel)\n\t\t\n\t\t# On duplique l'image pour le rendu final\n\t\tscan = EmptyFrom(bin, 3)\n\t\tscan[:,:,0] = scan[:,:,1] = scan[:,:,2] = bin\n\t\tthis._SCAN = scan\n\t\t\n\t\tstep = 0 # Compteur de pas dans le vide\n\t\tstart, end = None, None\n\t\t\n\t\t# Dimensions de l'image à scanner\n\t\tsize = D2Point(width(bin), height(bin))\n\t\tratio = size if minSize < 1 else 1\n\t\t\n\t\t# Scan pixel par pixel, en partant du bas\n\t\tfor v in xrange(int(size.y)-1, -1, -1):\n\t\t\tfor u in xrange(int(size.x)):\n\t\t\t\n\t\t\t\tif bin.item((v, u)): # Si un pixel != 0:\n\t\t\t\t\tscan[v,u] = [0, 0, 255] # Rouge.\n\t\t\t\t\tstep = 0 # On reset le jump\n\t\t\t\t\t\n\t\t\t\t\t# Si c'est le premier\n\t\t\t\t\tif not start:\n\t\t\t\t\t\tstart = D2Point(u, v)\n\t\t\t\t\t\tend = D2Point(u, v)\n\t\t\t\t\telse: # On trace\n\t\t\t\t\t\tend.x, end.y = u, v\n\t\t\t\t\n\t\t\t\telif end:\n\t\t\t\t\tif step < offshore:\n\t\t\t\t\t\tscan[v,u] = [0, 255, 255] # Jaune\n\t\t\t\t\t\tstep += 1 # On continue\n\t\t\t\t\telif abs((start - end)/ratio) < minSize:\n\t\t\t\t\t\tstart, end = None, None\n\t\t\t\t\telse: break\n\t\t\t\t# elif end: break\n\t\t\t###\n\t\t\tif end: break\n\t\t###\n\t\t\n\t\tif end: # Si on a trouvé une fin\n\t\t\t\n\t\t\t# Point médian = doigt\n\t\t\tresult = start % end\n\t\t\t\n\t\t\t# Visuel\n\t\t\tscan[:,result.x,:] = [0, 255, 0] # On trace une bande verte\n\t\t\tscan[result.y,:,:] = [0, 127, 0] # On trace une autre bande verte\n\t\t\t\n\t\t\t# Reformatage\n\t\t\tresult /= size-1 # On remet en ratio d'image\n\t\t\tresult.x = 1 - result.x # On inverse le côté de mesure\n\t\t\t\n\t\t\t# Stockage\n\t\t\tthis._DETECTED = result # On stocke le point détecté\n\t\t\tthis._BOTTOM = result.y == 1 # On clic ou bien ?\n\t\t\n\t\t# Si rien\n\t\telse:\n\t\t\tresult = None\n\t\t\tthis._BOTTOM = False\n\t\t\n\t\t# Tchao\n\t\treturn result","def watershed(self, debug=False):\n kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\n opening = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_OPEN, kernel, iterations=2)\n sure_bg = cv2.dilate(self.th[:, :, 0], kernel, iterations=3)\n dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)\n ret, sure_fg = cv2.threshold(dist_transform, 0.1 * dist_transform.max(), 255, 0)\n sure_fg = np.uint8(sure_fg)\n unknown = cv2.subtract(sure_bg, sure_fg)\n ret, markers = cv2.connectedComponents(sure_fg)\n markers += 1\n markers[unknown == 255] = 0\n markers = cv2.watershed(self.img, markers)\n self.add_color(markers)\n if debug:\n cv2.imshow(\"fg\", unknown)\n cv2.imshow(\"op\", opening)\n cv2.imshow(\"o3\", sure_bg)","def farm(w,h,status='harvest',loops=1):\n h1 = int(h/2) # var to get seeds from first half (or fewer) of rows\n food_key = 5 # hotbar key for food\n dirt_place_time = 4.5\n walk_time = 0.33\n wait_time = 0.7\n grow_time = 540 # time for plants to grow = 600s - (time to log out & in) \n \n ctrl.resetCamera('down')\n for loop in range(loops):\n for y in range(h):\n for x in range(w):\n # checks if char is hungry before moving, & eats food on food_key\n if img_obj.isHungry():\n ctrl.eatFood(key=food_key)\n if status == 'harvest':\n # picks up farm patch, loot seeds, places farm patch, continues \n if y < h1: \n ctrl.selectOption('down')\n time.sleep(dirt_place_time) # takes 3 sec + more time due to server lag\n ctrl.selectOption('right')\n ctrl.loot() \n \n ctrl.walk('down', walk_time * 2, jump=True)\n ctrl.selectOption('down')\n ctrl.clickLMB()\n time.sleep(dirt_place_time)\n \n ctrl.walk('up', walk_time, jump=True)\n \n else:\n ctrl.selectOption('right')\n for i in range(12): # takes 5 seconds to harvest, in 6 seconds, f key is pressed 12 times\n ctrl.loot()\n time.sleep(.5)\n \n time.sleep(wait_time) # delay to make sure it jumps to the next patch\n # plants seeds - assumes char is holding seeds\n ctrl.selectOption('right')\n for i in range(12): # takes 5 seconds to harvest, in 5.5 seconds, f key is pressed 11 times\n ctrl.loot()\n time.sleep(.5)\n time.sleep(wait_time)\n \n # moves char to next farm patch\n if x != (w-1): # if not on last farm patch of row\n if y % 2 == 0:\n direction = 'left'\n else:\n direction = 'right'\n ctrl.walk(direction, walk_time, jump=True)\n time.sleep(wait_time) # delay for server lag\n \n # moves char up to next row if not on last row\n if y != (h-1):\n ctrl.walk('up', walk_time, jump=True)\n \n # final loot loop to get remaining items\n # for i in range(10):\n # ctrl.loot()\n # time.sleep(.5)\n \n # returns char to bottom right farm patch\n if (h) % 2 != 0: # if height is odd, move char to right side\n for x in range(w-1):\n ctrl.walk('right', walk_time, jump=True)\n time.sleep(wait_time)\n for y in range(h-1):\n ctrl.walk('down', walk_time * 2, jump=True)\n time.sleep(wait_time)\n \n # returns to lobby, waits for plants to grow, logs in\n ctrl.returnToLobby()\n time.sleep(grow_time)\n ctrl.enterGame()\n # resets camera to be aligned facing North as camera will always be pointed North after logging in\n ctrl.walk('up', .1, jump=True) \n time.sleep(wait_time)\n ctrl.walk('down', .1, jump=True)\n \n ctrl.resetCamera('down')\n # when relogging, char is displaced sometimes, this checks if field is selected, if not it'll try to find it, if that fails the program exits\n if not (img_obj.checkObjTitle('field')):\n ctrl.walk('left', walk_time, jump=True)\n if not (img_obj.checkObjTitle('field')):\n ctrl.walk('up', walk_time, jump=True)\n if not (img_obj.checkObjTitle('field')):\n break","def test_f2_circuit_maker(self):\n fho = tfho.test_file_handle_object()\n W = 5\n G = 20\n fg = .9\n X = 10\n fx = .85\n gate_maker = g.TYPE_TO_GATE_GEN[g.TEST_TYPES.RANDOM]\n # family 2 files:\n t_circuit_file_name = \"circuit_file_trimming\"\n t_circuit_file = fho.get_file_object(t_circuit_file_name, 'w')\n t_input_file_name = \"input_file_trimming\"\n t_input_file = fho.get_file_object(t_input_file_name, 'w')\n t_output_file_name = \"output_file_trimming\"\n t_output_file = fho.get_file_object(t_output_file_name, 'w')\n nt_circuit_file_name = \"circuit_file_no_trimming\"\n nt_circuit_file = fho.get_file_object(nt_circuit_file_name, 'w')\n nt_input_file_name = \"input_file_no_trimming\"\n nt_input_file = fho.get_file_object(nt_input_file_name, 'w')\n nt_output_file_name = \"output_file_no_trimming\"\n nt_output_file = fho.get_file_object(nt_output_file_name, 'w')\n level_type_array = [g.LEVEL_TYPES.XOR, g.LEVEL_TYPES.RANDOM,\n g.LEVEL_TYPES.XOR]\n F = 2\n # make a family 1 circuit with trimming:\n sr.seed(self.rand_seed)\n t_gen = g.f1f2_circuit_maker_with_trimming_switch(W, G, fg,\n t_circuit_file,\n t_input_file,\n t_output_file,\n X, fx, gate_maker,\n level_type_array, True)\n t_gen.generate()\n # make a family 1 circuit without trimming, with the same randomness:\n sr.seed(self.rand_seed)\n nt_gen = g.f1f2_circuit_maker_with_trimming_switch(W, G, fg,\n nt_circuit_file,\n nt_input_file,\n nt_output_file,\n X, fx, gate_maker,\n level_type_array, False)\n nt_gen.generate()\n # obtain strings representing the contents of all the resulting files:\n t_circuit_string = fho.get_file(t_circuit_file_name).getvalue()\n t_input_string = fho.get_file(t_input_file_name).getvalue()\n t_output_string = fho.get_file(t_output_file_name).getvalue()\n nt_circuit_string = fho.get_file(nt_circuit_file_name).getvalue()\n nt_input_string = fho.get_file(nt_input_file_name).getvalue()\n nt_output_string = fho.get_file(nt_output_file_name).getvalue()\n # make sure that the inputs and outputs produced by the trimming and\n # no trimming algorithms are the same:\n self.assertEqual(t_input_string, nt_input_string)\n self.assertEqual(t_output_string, nt_output_string)\n # make sure that the input begins and ends with a bracket:\n self.assertEqual(\"[\", t_input_string[0])\n self.assertEqual(\"]\", t_input_string[-1])\n # make sure that each input element is a bit:\n for bit in t_input_string[1:-1]:\n self.assertTrue((bit == '0') or (bit == '1'))\n # make sure that the output is a bit:\n self.assertTrue((t_output_string == '0') or (t_output_string == '1'))\n # make sure that the two circuit headers are the same, and that they\n # contain the correct values:\n t_circuit_header = t_circuit_string.split(\"\\n\")[0]\n nt_circuit_header = nt_circuit_string.split(\"\\n\")[0]\n self.assertEqual(t_circuit_header, nt_circuit_header)\n (W_string, G_string, X_string, F_string) = t_circuit_header.split(\",\")\n W_value = int(W_string.split(\"=\")[-1])\n G_value = int(G_string.split(\"=\")[-1])\n X_value = int(X_string.split(\"=\")[-1])\n F_value = int(F_string.split(\"=\")[-1])\n self.assertEqual(W, W_value)\n self.assertEqual(G, G_value)\n self.assertEqual(F, F_value)\n # note that we cannot test that the circuits themselves are the same,\n # because the trimming algorithm produces a circuit with gates listed\n # in a different order.","def clean_morphs():\n blendshapes = cmds.ls(type=\"blendShape\")\n for blendShape in blendshapes:\n blend_target_list = cmds.listAttr(blendShape + '.w', m=True)\n\n for blend_target in blend_target_list:\n bs_fixed = blend_target.replace(\"head__eCTRL\", \"\")\n if (bs_fixed.find(\"__\") > 1):\n bs_split = bs_fixed.split(\"__\")\n bs_fixed = bs_fixed.replace(bs_split[0]+\"__\", \"\")\n bs_fixed = bs_fixed.replace(\"headInner__\", \"\")\n bs_fixed = bs_fixed.replace(\"head_eCTRL\", \"\")\n bs_fixed = bs_fixed.replace(\"head__\", \"\")\n bs_fixed = bs_fixed.replace(\"head_\", \"\")\n bs_fixed = bs_fixed.replace(\"PHM\", \"\")\n bs_fixed = bs_fixed.replace(\"CTRL\", \"\")\n bs_fixed = bs_fixed.replace(\"QT1\", \"\")\n bs_fixed = bs_fixed.replace(\"Shape\", \"\")\n\n oldMorph = blendShape + \".\" + blend_target\n try:\n # Rename Morphs (Blendshapes)\n cmds.aliasAttr(bs_fixed, oldMorph)\n except:\n pass","def on_run(self):\n self.set_illumination({'mode': 'breathe'})","def disarm(self):\n pass","def other_wakes(self, current, *turbines):\r\n \"\"\" EXECUTE THIS FUNCTION IN THE FARM CLASS! \"\"\"\r\n self.nodisplacements = []\r\n self.procedures = []\r\n \r\n # blockage matrices:\r\n self.bn = []\r\n self.bt = []\r\n \r\n for i, turbine in enumerate(turbines):\r\n # append the own wake matrices when the current turbine is \r\n # compared to itself:\r\n \r\n if i == current:\r\n self.bn.append(Turbine.wn)\r\n self.bt.append(Turbine.wt)\r\n elif i != current:\r\n # it is shadowed when at least one control point of the current\r\n # turbine lies in the direct wake of the i-th turbine.\r\n self.shadowed = np.any((self.yi[i]>=-1) & (self.yi[i]<=1))\r\n self.behind = self.x0 > turbine.x0\r\n \r\n if (self.shadowed and self.behind):\r\n # compute obstruction matrices:\r\n self.set_templates(self.yi[i])\r\n self.offset_templates(i, turbine)\r\n \r\n # offsetted block matrices are appended to the list:\r\n self.bn.append(self.newQn)\r\n self.bt.append(self.newQt)\r\n else:\r\n # add empty blockage matrices if there is no obstruction:\r\n self.bn.append(np.copy(Turbine.zeros))\r\n self.bt.append(np.copy(Turbine.zeros))","def skimmer(bigCut, skimLoc, wsOut):\n\tprint \"Cutting on: \\n\",bigCut\n\n\tskim = TChain(\"skimTree\")\n\tskim.Add(skimLoc)\n\tlib.SetTreeInputs(skim, lib.skimDict)\n\n\tskim.SetEntryList(0)\n\tskim.Draw(\">>elist\", bigCut, \"entrylist\")\n\telist = gDirectory.Get(\"elist\")\n\tprint \"Found \",elist.GetN(),\" skim file entries.\"\n\tskim.SetEntryList(elist)\n\n\tds = GATDataSet()\n\twb = GATWaveformBrowser()\n\tds = wb.LoadSkimWaveforms(skim, bigCut)\n\tprint \"Found \",wb.GetNWaveforms(),\" waveforms.\"\n\n\tgat = ds.GetGatifiedChain()\n\tlib.SetTreeInputs(gat, lib.gatDict)\n\n\tbuilt = ds.GetBuiltChain()\n\tlib.SetTreeInputs(built, lib.builtDict)\n\n\tout = TFile(wsOut,\"RECREATE\")\n\n\twaveTree = TTree(\"waveTree\",\"wave-skim single waveforms\")\n\tenf = np.zeros(1,dtype=float)\n\tt50 = np.zeros(1,dtype=float)\n\trunTime = np.zeros(1,dtype=float)\n\tgatEnt, gatHit, skimEnt, builtEnt, eventTreeEntry, chn = 0., 0., 0., 0., 0., 0.\n\twf = MGTWaveform()\n\twaveTree.Branch(\"gatEnt\",long(gatEnt),\"gatEnt/L\")\n\twaveTree.Branch(\"gatHit\",long(gatHit),\"gatHit/L\")\n\twaveTree.Branch(\"builtEnt\",long(builtEnt),\"builtEnt/L\")\n\twaveTree.Branch(\"skimEnt\",long(skimEnt),\"skimEnt/L\")\n\twaveTree.Branch(\"eventTreeEntry\",long(eventTreeEntry),\"eventTreeEntry/L\")\n\twaveTree.Branch(\"waveform\",wf)\n\twaveTree.Branch(\"channel\",int(chn),\"channel/I\")\n\twaveTree.Branch(\"trapENFCal\",enf,\"trapENFCal/D\")\n\twaveTree.Branch(\"blrwfFMR50\",t50,\"blrwfFMR50/D\")\n\twaveTree.Branch(\"runTime\",runTime,\"runTime/D\")\n\n\t# save the entry numbers for the full event tree\n\tEntryList = []\n\n\t# fill waveTree\n\tlastEvent = 0\n\teventTreeEntry = -1\n\teventMismatchCount = 0\n\twfMismatchCount = 0\n\tfor waveNum in xrange(wb.GetNWaveforms()):\n\n\t\tgatEnt = wb.GetEntryNumber(waveNum)\n\t\tgatHit = wb.GetIterationNumber(waveNum)\n\t\tgat.GetEntry(gatEnt)\n\t\tbuilt.GetEntry(gatEnt)\n\t\tbuiltEnt = built.GetEntryNumber(gatEnt)\n\t\tskimEnt = 0\n\t\tfor ientry in xrange(elist.GetN()):\n\t\t\tentryNumber = skim.GetEntryNumber(ientry)\n\t\t\tskim.LoadTree( entryNumber )\n\t\t\tskim.GetEntry( entryNumber )\n\t\t\t# gat.LoadTree returns the entry number of the original tree\n\t\t\tif skim.iEvent==gat.LoadTree(gatEnt):\n\t\t\t\tskimEnt = entryNumber\n\t\t\t\tbreak\n\t\tskim.GetEntry(skimEnt)\n\n\t\tif abs(lib.timestamp.at(0)/1E8 - lib.s_tloc_s[0]) > 0.001:\n\t\t\tprint \"waveform\",waveNum,\": mismatched events!\"\n\t\t\teventMismatchCount += 1\n\t\t\tprint \"skim - run %d enf.at(0) %.3f enf.size %d time %.2f\" % (lib.s_run[0], lib.s_trapENFCal.at(0), lib.s_trapENFCal.size(), lib.s_tloc_s[0])\n\t\t\tprint \"gat - run %d enf.at(0) %.3f enf.size %d time %.2f\\n\" % (lib.run[0], lib.trapENFCal.at(0), lib.trapENFCal.size(), lib.timestamp.at(0)/1E8)\n\t\t\tcontinue\n\n\t\t# output some physics\n\t\twf = wb.GetWaveform(waveNum)\n\n\t\tnullchk = str(wf)\n\t\tif \"nil\" in nullchk:\n\t\t\tprint \"waveform\",waveNum,\",iteration \",gatHit,\": unexpected number of waveforms ...\"\n\t\t\twfMismatchCount +=1\n\t\t\tprint \"skim - run %d enf.at(0) %.3f enf.size %d time %.2f\" % (lib.s_run[0], lib.s_trapENFCal.at(0), lib.s_trapENFCal.size(), lib.s_tloc_s[0])\n\t\t\tprint \"gat - run %d enf.at(0) %.3f enf.size %d time %.2f\\n\" % (lib.run[0], lib.trapENFCal.at(0), lib.trapENFCal.size(), lib.timestamp.at(0)/1E8)\n\t\t\tcontinue\n\n\t\tchn = lib.channel.at(gatHit)\n\t\tenf[0] = lib.trapENFCal.at(gatHit)\n\t\tt50[0] = lib.blrwfFMR50.at(gatHit)\n\t\trunTime[0] = lib.timestamp.at(gatHit)/1E8\n\n\t\t# so you can match waveTree to eventTree\n\t\tif lastEvent != gatEnt:\n\t\t\teventTreeEntry += 1\n\t\t\tEntryList.append([gatEnt,skimEnt])\n\n\t\twaveTree.Fill()\n\n\t\tlastEvent = gatEnt\n\n\tprint \"\\nDone. For %d waveforms:\" % wb.GetNWaveforms()\n\tprint \"\\t%d had mismatched gat/skim events based on timestamp differences (and were skipped)\" % eventMismatchCount\n\tprint \"\\t%d had fewer wf's than expected in the built data (and were skipped).\" % wfMismatchCount\n\n\twaveTree.Write()\n\n\t# now fill the full event tree by looping over EntryList\n\tprint \"\\n filling full event tree ...\\n\"\n\teventTree = TTree(\"eventTree\",\"wave-skim full output\")\n\toutDict = lib.CreateOutputDict('all')\n\tlib.SetTreeOutputs(eventTree, outDict)\n\n\tfor i in EntryList:\n\t\tgatEntry = i[0]\n\t\tskimEntry = i[1]\n\n\t\tgat.GetEntry(gatEntry)\n\t\tbuilt.GetEntry(gatEntry)\n\t\tskim.GetEntry(skimEntry)\n\n\t\t# verify we get the same output as before\n\t\t# print \"skim - run %d enf-0 %.3f size %d time %.2f\" % (lib.s_run[0],lib.s_trapENFCal.at(0),lib.s_trapENFCal.size(),lib.s_tloc_s[0])\n\t\t# print \"gat - run %d enf-0 %.3f size %d time %.2f\\n\" % (lib.run[0],lib.trapENFCal.at(0),lib.trapENFCal.size(),lib.timestamp.at(0)/1E8)\n\n\t\teventTree.Fill()\n\n\teventTree.Write()\n\tout.Close()","def stop_step_sweep(self):\n self.write(\":SOUR:SWE:CONT:STAT OFF\")","def teleopPeriodic(self):\n self.drive.arcadeDrive(1, 0)\n self.brushless.set(1)\n self.spark.set(self.joystick.getY())","def _guider_flat_apogeeShutter(self, nCall, nInfo, nWarn, nErr, finish=False, didFail=False):\n cmdState = self.actorState.gotoField\n cmdState.reinitialize(self.cmd)\n result = masterThread.guider_flat(\n self.cmd, cmdState, myGlobals.actorState, 'guider', apogeeShutter=True)\n self.assertEqual(result, not didFail)\n self._check_cmd(nCall, nInfo, nWarn, nErr, finish, didFail=didFail)","def remove_events(self):\n tofiltercalibfnames1, tofiltercalibfnames2 = split_into_telescopes(self.tofiltercalibfnames)\n\n nameiter = tqdm(self.superstarmcolfnames)\n for ssmcolfname in nameiter:\n nameiter.set_description(f\"Processing {path.basename(ssmcolfname)}\")\n currentrun = get_run(ssmcolfname)\n ssmcoldf = pd.read_csv(ssmcolfname, index_col=False)\n # newfname1 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames1, self.m1sscols)\n # newfname2 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames2, self.m2sscols)\n # if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\n # os.remove(newfname1)\n # os.remove(newfname2)\n # continue\n tofiltercalibdf1, oldname1 = self._merge_subruns(tofiltercalibfnames1,\n currentrun, getoldname=True)\n tofiltercalibdf2, oldname2 = self._merge_subruns(tofiltercalibfnames2,\n currentrun, getoldname=True)\n if len(tofiltercalibdf1) == 0:\n logger.warning(f\"calibfiles already processed, skipping {path.basename(ssmcolfname)} current run: {currentrun} \\n\")\n continue\n\n filtermask1 = self.get_filtermask(tofiltercalibdf1.iloc[:, self.mcolidx], ssmcoldf[self.m1sscols])\n filtermask2 = self.get_filtermask(tofiltercalibdf2.iloc[:, self.mcolidx], ssmcoldf[self.m2sscols])\n if self.invert is False:\n filtermask1, tofiltercalibdf1 = self.fix_idiosyncracies(filtermask1, tofiltercalibdf1, ssmcoldf[self.m1sscols])\n filtermask2, tofiltercalibdf2 = self.fix_idiosyncracies(filtermask2, tofiltercalibdf2, ssmcoldf[self.m2sscols])\n\n if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\n continue\n\n newfname1 = self._get_newfilename(oldname=oldname1)\n newfname2 = self._get_newfilename(oldname=oldname2)\n\n nameiter.set_description(f\"Saving {path.basename(newfname1)}\")\n tofiltercalibdf1.iloc[filtermask1].to_csv(newfname1, header=False, index=False)\n nameiter.set_description(f\"Saving {path.basename(newfname2)}\")\n tofiltercalibdf2.iloc[filtermask2].to_csv(newfname2, header=False, index=False)\n self.outfilenames.extend([newfname1, newfname2])\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun))\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun))","def runCalFlat(lst, hband=False, darkLst=None, rootFolder='', nlCoef=None, satCounts=None, BPM=None, distMapLimitsFile='', plot=True, nChannel=32, nRowsAvg=0,rowSplit=1,nlSplit=32, combSplit=32,bpmCorRng=100, crReject=False, skipObsinfo=False,winRng=51, polyFitDegree=3, imgSmth=5,nlFile='',bpmFile='', satFile='',darkFile='',flatCutOff=0.1,flatSmooth=0, logfile=None, gain=1., ron=None, dispAxis=0,limSmth=20, ask=True, obsCoords=None,satSplit=32, centGuess=None, flatCor=False, flatCorFile=''):\n\n colorama.init()\n \n plt.ioff()\n\n t0 = time.time()\n \n #create processed directory, in case it doesn't exist\n wifisIO.createDir('processed')\n wifisIO.createDir('quality_control')\n\n if hband:\n print('*** WORKING ON H-BAND DATA ***')\n \n #create processed directory, in case it doesn't exist\n wifisIO.createDir('processed')\n\n if (plot):\n wifisIO.createDir('quality_control')\n\n procFlux = []\n procSigma = []\n procSatFrame = []\n\n #go through list and process each file individually\n #************\n #eventually need to add capability to create master flat from groups\n #************\n\n for lstNum in range(len(lst)):\n if (lst.ndim>1):\n folder = lst[lstNum,0]\n else:\n folder = lst[lstNum]\n\n t1 = time.time()\n\n savename = 'processed/'+folder\n\n #first check master flat and limits exists\n \n if(os.path.exists(savename+'_flat.fits') and os.path.exists(savename+'_flat_limits.fits') and os.path.exists(savename+'_flat_slices.fits') and os.path.exists(savename+'_flat_slices_norm.fits')):\n cont = 'n'\n if ask:\n cont = wifisIO.userInput('All processed flat field files already exists for ' +folder+', do you want to continue processing (y/n)?')\n else:\n cont = 'y'\n \n if (cont.lower() == 'y'):\n print('*** Working on folder ' + folder + ' ***')\n\n if (os.path.exists(savename+'_flat.fits')):\n cont = 'n'\n cont = wifisIO.userInput('Processed flat field file already exists for ' +folder+', do you want to continue processing (y/n)?')\n \n if (not cont.lower() == 'y'):\n print('Reading image '+savename+'_flat.fits instead')\n flatImgs, hdr= wifisIO.readImgsFromFile(savename+'_flat.fits')\n flatImg, sigmaImg, satFrame = flatImgs\n if (type(hdr) is list):\n hdr = hdr[0]\n contProc2=False\n else:\n contProc2=True\n else:\n contProc2=True\n \n if contProc2:\n flatImg, sigmaImg, satFrame, hdr = processRamp.auto(folder, rootFolder,savename+'_flat.fits', satCounts, nlCoef, BPM, nChannel=nChannel, rowSplit=rowSplit, nlSplit=nlSplit, combSplit=combSplit, crReject=crReject, bpmCorRng=bpmCorRng, skipObsinfo=skipObsinfo, nRows=nRowsAvg, rampNum=None, nlFile=nlFile, satFile=satFile, bpmFile=bpmFile, gain=gain, ron=ron, logfile=logfile, obsCoords=obsCoords, avgAll=True, satSplit=satSplit)\n \n #carry out dark subtraction\n if darkLst is not None and darkLst[0] is not None:\n print('Subtracting dark ramp')\n if len(darkLst)>1:\n dark, darkSig = darkLst[:2]\n sigmaImg = np.sqrt(sigmaImg**2 + darkSig**2)\n else:\n dark = darkLst[0]\n logfile.write('*** Warning: No uncertainty associated with dark image ***\\n')\n print(colorama.Fore.RED+'*** WARNING: No uncertainty associated with dark image ***'+colorama.Style.RESET_ALL)\n\n flatImg -= dark\n hdr.add_history('Dark image subtracted using file:')\n hdr.add_history(darkFile)\n if logfile is not None:\n logfile.write('Subtracted dark image using file:\\n')\n logfile.write(darkFile+'\\n')\n else:\n print(colorama.Fore.RED+'*** WARNING: No dark image provided, or file does not exist ***'+colorama.Style.RESET_ALL)\n if logfile is not None:\n logfile.write('*** WARNING: No dark image provided, or file ' + str(darkFile)+' does not exist ***')\n\n if os.path.exists(savename+'_flat_limits.fits'):\n cont = wifisIO.userInput('Limits file already exists for ' +folder+ ', do you want to continue processing (y/n)?')\n \n if (not cont.lower() == 'y'):\n print('Reading limits '+savename+'_flat_limits.fits instead')\n finalLimits, limitsHdr= wifisIO.readImgsFromFile(savename+'_flat_limits.fits')\n shft = limitsHdr['LIMSHIFT']\n contProc2 = False\n else:\n contProc2 = True\n else:\n contProc2= True\n \n if (contProc2):\n print('Finding slice limits and extracting slices')\n\n #remove comment about contents of file\n hdrTmp = hdr[::-1]\n hdrTmp.remove('COMMENT')\n hdr = hdrTmp[::-1]\n \n #find limits of each slice with the reference pixels, but the returned limits exclude them\n limits = slices.findLimits(flatImg, dispAxis=dispAxis, winRng=winRng, imgSmth=imgSmth, limSmth=limSmth, rmRef=True,centGuess=centGuess)\n\n if logfile is not None:\n logfile.write('Identified slice limits using the following parameters:\\n')\n logfile.write('dispAxis: '+str(dispAxis)+'\\n')\n logfile.write('winRng: ' + str(winRng)+'\\n')\n logfile.write('imgSmth: ' + str(imgSmth)+'\\n')\n logfile.write('limSmth: ' + str(limSmth)+'\\n')\n \n if hband:\n print('Using suitable region of detector to determine flat limits')\n if logfile is not None:\n logfile.write('Using suitable region of detector to determine flat limits:\\n')\n\n #only use region with suitable flux\n if dispAxis == 0:\n flatImgMed = np.nanmedian(flatImg[4:-4,4:-4], axis=1)\n else:\n flatImgMed = np.nanmedian(flatImg[4:-4,4:-4], axis=0)\n \n flatImgMedGrad = np.gradient(flatImgMed)\n medMax = np.nanargmax(flatImgMed)\n lim1 = np.nanargmax(flatImgMedGrad[:medMax])\n lim2 = np.nanargmin(flatImgMedGrad[medMax:])+medMax\n\n if logfile is not None:\n logfile.write('Using following detector limits to set slice limits:\\n')\n logfile.write(str(lim1)+ ' ' + str(lim2)+'\\n')\n \n polyLimits = slices.polyFitLimits(limits, degree=2, sigmaClipRounds=2, constRegion=[lim1,lim2])\n else:\n #get smoother limits, if desired, using polynomial fitting\n polyLimits = slices.polyFitLimits(limits, degree=polyFitDegree, sigmaClipRounds=2)\n\n if logfile is not None:\n logfile.write('Fit polynomial to slice edge traces using:\\n')\n logfile.write('Polynomial degree: ' + str(polyFitDegree)+'\\n')\n logfile.write('sigmaClipRounds: ' + str(2)+'\\n')\n\n if hband:\n logfile.write('Only used pixels between ' + str(lim1) +' and ' + str(lim2)+'\\n')\n \n if os.path.exists(distMapLimitsFile):\n print('Finding slice limits relative to distortion map file')\n hdr.add_history('Slice limits are relative to the following file:')\n hdr.add_history(distMapLimitsFile)\n distMapLimits = wifisIO.readImgsFromFile(distMapLimitsFile)[0]\n if logfile is not None:\n logfile.write('Finding slice limits relative to distortion map file:\\n')\n logfile.write(distMapLimitsFile+'\\n')\n\n if hband:\n shft = int(np.nanmedian(polyLimits[1:-1,lim1:lim2+1] - distMapLimits[1:-1,lim1:lim2+1]))\n else:\n shft = int(np.nanmedian(polyLimits[1:-1,:] - distMapLimits[1:-1,:]))\n \n if logfile is not None:\n logfile.write('Median pixel shift using all inner edge limits is ' + str(shft)+'\\n')\n finalLimits = distMapLimits\n else:\n finalLimits = polyLimits\n shft = 0\n\n if logfile is not None:\n logfile.write('*** WARNING:No slice limits provided for distortion map. Finding independent slice limits ***\\n')\n logfile.write(distMapLimitsFile+'\\n')\n \n \n #write distMapLimits + shft to file\n hdr.set('LIMSHIFT',shft, 'Limits shift relative to Ronchi slices')\n hdr.add_comment('File contains the edge limits for each slice')\n\n wifisIO.writeFits(finalLimits.astype('float32'),savename+'_flat_limits.fits', hdr=hdr, ask=False)\n\n #remove comment about contents of file\n hdrTmp = hdr[::-1]\n hdrTmp.remove('COMMENT')\n hdr = hdrTmp[::-1]\n \n #save figures of tracing results for quality control purposes\n if (plot):\n print('Plotting results')\n plt.ioff()\n wifisIO.createDir('quality_control')\n \n pdfName = 'quality_control/'+folder+'_flat_slices_traces.pdf'\n with PdfPages(pdfName) as pdf:\n fig = plt.figure()\n #med1= np.nanmedian(flatImg)\n interval = ZScaleInterval()\n lims = interval.get_limits(flatImg[4:-4,4:-4])\n #plt.imshow(flatImg[4:-4,4:-4], aspect='auto', cmap='jet', clim=[0,2.*med1], origin='lower')\n plt.imshow(flatImg[4:-4,4:-4], aspect='auto', cmap='jet', clim=lims, origin='lower')\n \n plt.xlim=(0,2040)\n plt.colorbar()\n for l in range(limits.shape[0]):\n if dispAxis==0:\n plt.plot(limits[l], np.arange(limits.shape[1]),'k', linewidth=1) #drawn limits\n plt.plot(np.clip(finalLimits[l]+shft,0, flatImg[4:-4,4:-4].shape[0]-1), np.arange(limits.shape[1]),'r--', linewidth=1) #shifted ronchi limits, if provided, or polynomial fit\n else:\n plt.plot(np.arange(limits.shape[1]),limits[l],'k', linewidth=1) #drawn limits\n plt.plot(np.arange(limits.shape[1]),np.clip(finalLimits[l]+shft,0, flatImg[4:-4,4:-4].shape[0]-1),'r--', linewidth=1) #shifted ronchi limits\n\n if hband:\n if dispAxis==0:\n plt.plot([0,flatImg[4:-4,4:-4].shape[1]-1],[lim1,lim1],'b:',linewidth=1)\n plt.plot([0,flatImg[4:-4,4:-4].shape[1]-1],[lim2,lim2],'b:',linewidth=1)\n else:\n plt.plot([lim1,lim1],[0,flatImg[4:-4,4:-4].shape[1]-1],'b:',linewidth=1)\n plt.plot([lim2,lim2],[0,flatImg[4:-4,4:-4].shape[1]-1],'b:',linewidth=1)\n\n plt.tight_layout()\n pdf.savefig()\n plt.close(fig)\n\n #get rid of reference pixels\n flatImg = flatImg[4:-4, 4:-4]\n sigmaImg = sigmaImg[4:-4, 4:-4]\n satFrame = satFrame[4:-4,4:-4]\n\n if logfile is not None:\n logfile.write('Removing reference pixels\\n')\n \n if os.path.exists(savename+'_flat_slices.fits'):\n cont='n'\n cont = wifisIO.userInput('Flat slices file already exists for ' +folder+ ', do you want to continue processing (y/n)?')\n\n if (not cont.lower() == 'y'):\n print('Reading slices file '+savename+'_flat_slices.fits instead')\n flatSlices = wifisIO.readImgsFromFile(savename+'_flat_slices.fits')[0]\n contProc2 = False\n else:\n contProc2 = True\n else:\n contProc2= True\n \n if (contProc2):\n print('Extracting slices') \n #now extract the individual slices\n flatSlices = slices.extSlices(flatImg, finalLimits, dispAxis=dispAxis, shft=shft)\n for slc in flatSlices:\n slc = slc.astype('float32')\n \n if logfile is not None:\n logfile.write('Extracted flat slices\\n')\n \n #extract uncertainty slices\n sigmaSlices = slices.extSlices(sigmaImg, finalLimits, dispAxis=dispAxis, shft=shft)\n for slc in sigmaSlices:\n slc = slc.astype('float32')\n \n if logfile is not None:\n logfile.write('Extracted uncertainty slices\\n')\n \n #extract saturation slices\n satSlices = slices.extSlices(satFrame, finalLimits, dispAxis=dispAxis, shft=shft)\n for slc in satSlices:\n slc = slc.astype('float32')\n \n if logfile is not None:\n logfile.write('Extracted saturation info slices\\n')\n \n #write slices to file\n hdr.add_comment('File contains each slice image as separate extension')\n wifisIO.writeFits(flatSlices+sigmaSlices+satSlices,savename+'_flat_slices.fits',hdr=hdr, ask=False)\n \n #remove comment about contents of file\n hdrTmp = hdr[::-1]\n hdrTmp.remove('COMMENT')\n hdr = hdrTmp[::-1]\n \n if os.path.exists(savename+'_flat_slices_norm.fits'):\n cont = 'n'\n cont = wifisIO.userInput('Normalized flat slices file already exists for ' +folder+', do you want to continue processing (y/n)?')\n \n if (not cont.lower() == 'y'):\n contProc2 = False\n else:\n contProc2 = True\n else:\n contProc2= True\n \n if (contProc2):\n print('Getting normalized flat field')\n #now get smoothed and normalized response function\n flatNorm = slices.getResponseAll(flatSlices, flatSmooth, flatCutOff)\n for slc in flatNorm:\n slc = slc.astype('float32')\n \n hdr.add_comment('File contains the normalized flat-field response function')\n hdr.add_history('Smoothed using Gaussian with 1-sigma width of ' + str(flatSmooth) + ' pixels')\n hdr.add_history('Normalized cutoff threshold is ' + str(flatCutOff))\n\n if logfile is not None:\n logfile.write('Computed normalized response function from flat slices using the following parameters:\\n')\n logfile.write('flatSmooth: ' + str(flatSmooth)+'\\n')\n logfile.write('flatCutoff: ' + str(flatCutOff)+'\\n')\n \n sigmaNorm = slices.ffCorrectAll(sigmaSlices, flatNorm)\n for slc in sigmaNorm:\n slc = slc.astype('float32')\n \n if logfile is not None:\n logfile.write('Computed uncertainties for normalized response function for each slice\\n')\n\n if flatCor:\n print('Correcting flat field response function')\n logfile.write('Correcting flat field response function using file:\\n')\n logfile.write(flatCorFile+'\\n')\n \n flatCorSlices = wifisIO.readImgsFromFile(flatCorFile)[0]\n flatNorm = slices.ffCorrectAll(flatNorm, flatCorSlices)\n hdr.add_history('Corrected flat field response function using file:')\n hdr.add_history(flatCorFile)\n\n if len(flatCorSlices)>nSlices:\n hdr.add_history('Uncertainties include correction')\n sigmaNorm = wifisUncertainties.multiplySlices(flatNorm,sigmaNorm,flatCorSlices[:nSlices],flatCorSlices[nSlices:2*nSlices])\n\n else:\n hdr.add_history('Uncertainties do not include correction')\n logfile.write('*** WARNING: Response correction does not include uncertainties***\\n')\n\n else:\n #print(colorama.Fore.RED+'*** WARNING: Flat field correction file does not exist, skipping ***'+colorama.Style.RESET_ALL)\n \n #logfile.write('*** WARNING: Flat field correction file does not exist, skipping ***\\n')\n print('Flat field correction file off...skipping')\n \n logfile.write('Flat field correction file off...skipping\\n')\n \n #write normalized images to file\n wifisIO.writeFits(flatNorm + sigmaNorm + satSlices,savename+'_flat_slices_norm.fits',hdr=hdr, ask=False)\n print('*** Finished processing ' + folder + ' in ' + str(time.time()-t1) + ' seconds ***')\n \n return","def generate_flare_set(self):\n\n # x_count = 10\n # m_count = 10\n files = []\n for file in os.listdir(self.flare_path):\n files.append(file)\n # if file[0] == 'M' and m_count >0:\n # files.append(file)\n # m_count-=1\n # elif file[0] == \"X\" and x_count >0:\n # files.append(file)\n # x_count-=1\n\n return files","def test_f1_circuit_maker(self):\n fho = tfho.test_file_handle_object()\n W = 5\n G = 20\n fg = .9\n X = 10\n fx = .85\n gate_maker = g.TYPE_TO_GATE_GEN[g.TEST_TYPES.RANDOM]\n # family 1 files:\n t_circuit_file_name = \"circuit_file_trimming\"\n t_circuit_file = fho.get_file_object(t_circuit_file_name, 'w')\n t_input_file_name = \"input_file_trimming\"\n t_input_file = fho.get_file_object(t_input_file_name, 'w')\n t_output_file_name = \"output_file_trimming\"\n t_output_file = fho.get_file_object(t_output_file_name, 'w')\n nt_circuit_file_name = \"circuit_file_no_trimming\"\n nt_circuit_file = fho.get_file_object(nt_circuit_file_name, 'w')\n nt_input_file_name = \"input_file_no_trimming\"\n nt_input_file = fho.get_file_object(nt_input_file_name, 'w')\n nt_output_file_name = \"output_file_no_trimming\"\n nt_output_file = fho.get_file_object(nt_output_file_name, 'w')\n level_type_array = [g.LEVEL_TYPES.RANDOM]\n F = 1\n # make a family 1 circuit with trimming:\n sr.seed(self.rand_seed)\n t_gen = g.f1f2_circuit_maker_with_trimming_switch(W, G, fg,\n t_circuit_file,\n t_input_file,\n t_output_file,\n X, fx, gate_maker,\n level_type_array, True)\n t_gen.generate()\n # make a family 1 circuit without trimming, with the same randomness:\n sr.seed(self.rand_seed)\n nt_gen = g.f1f2_circuit_maker_with_trimming_switch(W, G, fg,\n nt_circuit_file,\n nt_input_file,\n nt_output_file,\n X, fx, gate_maker,\n level_type_array, False)\n nt_gen.generate()\n # obtain strings representing the contents of all the resulting files:\n t_circuit_string = fho.get_file(t_circuit_file_name).getvalue()\n t_input_string = fho.get_file(t_input_file_name).getvalue()\n t_output_string = fho.get_file(t_output_file_name).getvalue()\n nt_circuit_string = fho.get_file(nt_circuit_file_name).getvalue()\n nt_input_string = fho.get_file(nt_input_file_name).getvalue()\n nt_output_string = fho.get_file(nt_output_file_name).getvalue()\n # make sure that the inputs and outputs produced by the trimming and\n # no trimming algorithms are the same:\n self.assertEqual(t_input_string, nt_input_string)\n self.assertEqual(t_output_string, nt_output_string)\n # make sure that the input begins and ends with a bracket:\n self.assertEqual(\"[\", t_input_string[0])\n self.assertEqual(\"]\", t_input_string[-1])\n # make sure that each input element is a bit:\n for bit in t_input_string[1:-1]:\n self.assertTrue((bit == '0') or (bit == '1'))\n # make sure that the output is a bit:\n self.assertTrue((t_output_string == '0') or (t_output_string == '1'))\n # make sure that the two circuit headers are the same, and that they\n # contain the correct values:\n t_circuit_header = t_circuit_string.split(\"\\n\")[0]\n nt_circuit_header = nt_circuit_string.split(\"\\n\")[0]\n self.assertEqual(t_circuit_header, nt_circuit_header)\n (W_string, G_string, F_string) = t_circuit_header.split(\",\")\n W_value = int(W_string.split(\"=\")[-1])\n G_value = int(G_string.split(\"=\")[-1])\n F_value = int(F_string.split(\"=\")[-1])\n self.assertEqual(W, W_value)\n self.assertEqual(G, G_value)\n self.assertEqual(F, F_value)\n # note that we cannot test that the circuits themselves are the same,\n # because the trimming algorithm produces a circuit with gates listed\n # in a different order.","def spilloverEff(freq,fD, FFBW, dB_at_bw, feed_type):\n theta0 = fD2angle(fD,units='degrees')\n tt = 0.0\n dtt = 0.1\n theta = np.arange(0.0,180.0+dtt,dtt)\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\n theta = theta*math.pi/180.0\n\n # integrate over main beam\n gmb = np.where(theta < (theta0/2.0)*math.pi/180.0)\n kern = g[gmb]*np.sin(theta[gmb]) \n num = integ.trapz(kern,dx=dtt*math.pi/180.0)\n # integrate over full beam\n kern = g*np.sin(theta)\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\n \n n_spill = num/den\n return n_spill","def run(self, src, dest):\n self.logger.debug('Start the blurring. src=\"%s\", dest=\"%s\"', src, dest)\n create_frames(src, self.work['frames'])\n data = self.analyze()\n\n for frame_no, frame in enumerate(self.work.files('frames')):\n basename = os.path.basename(frame)\n areas = []\n for values in data:\n for sector in values['sectors']:\n if frame_no in range(sector[0]-self.offset, sector[1]+self.offset):\n areas.append(values['area'])\n break\n if areas:\n self.blur.blur_image(frame, areas, os.path.join(self.work['cleaned'], basename))\n else:\n copyfile(frame, os.path.join(self.work['cleaned'], basename))\n save_frames(self.work['cleaned'], dest)","def spectate(self):\n pass","async def breathe(self, params):\n intensity = params.get('intensity', 255)\n wait_ms = params.get('wait_ms', 2)\n try:\n while True:\n await self.lights.breathe(intensity, wait_ms=wait_ms)\n except KeyboardInterrupt:\n pass","def _sweepDir(self, f):\n lastCellFaceVal = np.zeros((self.regions[0].cells[0].nG,\n self.regions[0].cells[0].sNords))\n if f == 2:\n sweepTree = reversed(self.sweepTree)\n else:\n sweepTree = self.sweepTree\n blowoff = False\n for j, i in sweepTree:\n cell = self.regions[j].cells[i]\n if hasattr(cell, 'boundaryCond') and not blowoff:\n cell.applyBC(self.depth)\n blowoff = True\n else:\n # Interior cell\n cell.ordFlux[:, f, :] = lastCellFaceVal[:, :]\n # Only sweep through ordinates that have a component in same direction as\n # current sweep dir. Filter ords by dot product\n dotDir = cell.sNmu * cell.faceNormals[f - 1]\n ordsInSweepDir = np.where(dotDir < 0.)\n for o in np.arange(cell.sNords)[ordsInSweepDir]:\n cell.ordFlux[:, 0, o] = (cell.ordFlux[:, f, o] + self.regions[j].deltaX * cell.qin[:, 0, o] / (2. * np.abs(cell.sNmu[o]))) / \\\n (1. + self.regions[j].totalXs * self.regions[j].deltaX / (2. * np.abs(cell.sNmu[o])))\n if f == 1:\n cell.ordFlux[:, 2, o] = 2. * cell.ordFlux[:, 0, o] - cell.ordFlux[:, f, o]\n lastCellFaceVal[:, o] = cell.ordFlux[:, 2, o]\n elif f == 2:\n cell.ordFlux[:, 1, o] = 2. * cell.ordFlux[:, 0, o] - cell.ordFlux[:, f, o]\n lastCellFaceVal[:, o] = cell.ordFlux[:, 1, o]\n if np.any(cell.ordFlux[:, :, :] < 0.0):\n #print(\"WARNING: Negative flux detected! Refine mesh in region #:\" + str(j))\n maxStepSize = 2. * np.min(np.abs(cell.sNmu)) * min(1. / self.regions[j].totalXs)\n #print(\"Max Step size in 1D: \" + str(maxStepSize))\n # automatically gen refine factor: TODO: auto refine mesh\n # refineFactor = self.regions[j].deltaX / maxStepSize\n #raise Exception('coarse', refineFactor)","def masterFlat(flat_list, master_dark_fname, normalize = 'median', local_sig_bad_pix = 3, \\\n global_sig_bad_pix = 9, local_box_size = 11, hotp_map_fname = None, verbose=False,\n output_dir = None,min_flux=1000):\n\n #Open the master dark\n master_dark_hdu = f.open(master_dark_fname)\n master_dark = master_dark_hdu[0].data\n dark_shape = np.shape(master_dark)\n\n if verbose:\n print((\"Subtracting {} from each flat file\".format(master_dark_fname)))\n dark_exp_time = master_dark_hdu[0].header['EXPTIME']\n\n #Open all files into a 3D array\n #foo = np.empty((dark_shape[0],dark_shape[1],len(flat_list)))\n foo = []\n\n #Open first flat file to check exposure time and filter\n first_flat_hdu = f.open(flat_list[0])\n flat_exp_time = first_flat_hdu[0].header['EXPTIME']\n\n\n\n if dark_exp_time != flat_exp_time:\n print(\"The master dark file doesn't have the same exposure time as the flats. We'll scale the dark for now, but this isn't ideal\", UserWarning)\n factor = flat_exp_time/dark_exp_time\n else:\n factor = 1.\n\n #We've already read it, so we'll stick it in foo\n\n print(\"Combining flat files\")\n for i in range(0,len(flat_list)):\n try: \n #subtract dark for each file, then normalize by mode\n hdu = f.open(flat_list[i],ignore_missing_end=True)\n d_sub = hdu[0].data - factor*master_dark\n if np.nanmedian(d_sub) < min_flux:\n #print(\"Skipping file {}, because its flux is lower than {}\".format(flat_list[i],min_flux))\n continue\n #normalize\n if normalize == 'mode':\n d_sub = d_sub/mode(d_sub, axis = None, nan_policy = 'omit')\n elif normalize == 'median':\n d_sub = d_sub/np.nanmedian(d_sub)\n #foo[:,:,i] = d_sub\n foo.append(d_sub)\n except:\n print(\"Some error. Skipping file {}\".format(i)) \n #Median combine frames\n flat = np.median(foo, axis = 0)\n\n #Filter bad pixels\n #bad_px = sigma_clip(flat, sigma = sig_bad_pix) #old and bad\n ###Major update here: do sigma clipping on the pix-to-pix flat with the large scale vignette removed\n ###Also add local sigma clipping\n def stddevFilter(img, box_size):\n \"\"\" from\n https://stackoverflow.com/questions/28931265/calculating-variance-of-an-image-python-efficiently/36266187#36266187\n This function compute the standard deviation of an image in a\n moving box of a given size. The pixel i,j of the output is the\n standard deviation of the pixel value in the box_size x box_size box\n around the i,j pixel in the original image.\n \"\"\"\n wmean, wsqrmean = (cv2.boxFilter(x, -1, (box_size, box_size), \\\n borderType=cv2.BORDER_REFLECT) for x in (img, img*img))\n return np.sqrt(wsqrmean - wmean*wmean)\n\n #median flat\n median_flat = median_filter(flat, local_box_size) #arbitrary size, shouldn't matter as long as it's big enough\n #standard deviation image\n stddev_im = stddevFilter(flat, local_box_size)\n\n #Local clipping\n local_bad_pix = np.abs(median_flat - flat) > local_sig_bad_pix*stddev_im\n\n #Global clipping here to reject awful pixels and dust, bad columns, etc\n pix_to_pix = flat/median_flat\n global_bad_px = sigma_clip(pix_to_pix, sigma = global_sig_bad_pix).mask #9 seems to work best\n\n #also set all 0 and negative pixels in flat as bad\n non_positive = flat <= 0\n\n #logic combine\n bad_px = np.logical_or(global_bad_px, local_bad_pix)\n\n #also add non_positive pixels\n bad_px = np.logical_or(bad_px, non_positive)\n\n #Normalize good pixel values\n if normalize == 'median':\n norm_flat = flat/np.nanmedian(flat[~bad_px])\n elif normalize == 'mode':\n norm_flat = flat/mode(flat, axis = None, nan_policy = 'omit')\n #Stick it back in the last hdu\n hdu[0].data = norm_flat\n\n #Add pipeline version and history keywords\n vers = version.get_version()\n hdu[0].header.set('PL_VERS',vers,'Version of pipeline used for processing')\n hdu[0].header['HISTORY'] = \"############################\"\n hdu[0].header['HISTORY'] = \"Created master flat by median combining the following:\"\n for i in range(len(flat_list)):\n hdu[0].header['HISTORY'] = flat_list[i]\n hdu[0].header['HISTORY'] = \"Normalized to the median of the master flat\"\n hdu[0].header['HISTORY'] = \"Performed bad pixel local and global sigma clipping with {}, {}sigmas\".format(local_sig_bad_pix, global_sig_bad_pix)\n hdu[0].header['HISTORY'] = \"############################\"\n\n #Parse the last fileanme\n if output_dir is not None:\n flat_outname = flat_list[-1].rsplit('.',1)[0]+\"_master_flat.fits\"\n flat_outname = flat_outname.rsplit('/',1)[-1]\n flat_outname = output_dir+flat_outname\n else:\n flat_outname = flat_list[-1].rsplit('.',1)[0]+\"_master_flat.fits\"\n\n #Write the fits file\n if verbose:\n print((\"Writing master flat to {}\".format(flat_outname)))\n hdu.writeto(flat_outname, overwrite=True)\n\n #If there's already a hot pixel map then we'll add to it.\n if hotp_map_fname != None:\n #read in the existing bp map\n #hdu = f.open(hotp_map_fname)\n #hdu[0].data += np.array(bad_px.mask, dtype=float)\n #hdu[0].data = np.logical_or(hdu[0].data.astype(bool), bad_px) #use logical or to combine bad pixel maps\n #bp_outname = flat_list[-1].rsplit('.',1)[0]+\"_bp_map.fits\"\n print(\"Will deal with hot pixel map from dark frames in the calibrate function\")\n\n #else:\n #Parse the last fileanme\n if output_dir is not None:\n bp_outname = flat_list[-1].rsplit('.',1)[0]+\"_bp_map.fits\"\n bp_outname = bp_outname.rsplit('/',1)[-1]\n bp_outname = output_dir+bp_outname\n else:\n bp_outname = flat_list[-1].rsplit('.',1)[0]+\"_bp_map.fits\"\n\n ##### Now write the bad pixel map\n hdu[0].data = bad_px.astype(int)#np.array(bad_px.mask, dtype=float)\n #Parse the last fileanme\n # bp_outname = flat_list[-1].rsplit('.',1)[0]+\"_bp_map.fits\"\n\n #Add history keywords\n hdu[0].header['HISTORY'] = \"############################\"\n hdu[0].header['HISTORY'] = \"Created bad pixel map by sigma clipping on pixel-to-pixel flat{}\".format(flat_outname)\n hdu[0].header['HISTORY'] = \"Bad pixel cutoffs: local sigma = {} and global sigma = {} for clipping\".format(local_sig_bad_pix, global_sig_bad_pix)\n #hdu[0].header['HISTORY'] = \"Bad pixel cutoff of {}sigma\".format(sig_bad_pix)\n hdu[0].header['HISTORY'] = \"A pixel value of 1 indicates a bad pixel\"\n hdu[0].header['HISTORY'] = \"############################\"\n\n if verbose:\n print((\"Writing bad pixel map to {}\".format(bp_outname)))\n #Write the fits file\n hdu.writeto(bp_outname, overwrite=True)\n\n return flat_outname, bp_outname","def apply_cuts(objects):\n #- Check if objects is a filename instead of the actual data\n if isinstance(objects, (str, unicode)):\n objects = io.read_tractor(objects)\n \n #- undo Milky Way extinction\n flux = unextinct_fluxes(objects)\n gflux = flux['GFLUX']\n rflux = flux['RFLUX']\n zflux = flux['ZFLUX']\n w1flux = flux['W1FLUX']\n wflux = flux['WFLUX']\n \n #- DR1 has targets off the edge of the brick; trim to just this brick\n if 'BRICK_PRIMARY' in objects.dtype.names:\n primary = objects['BRICK_PRIMARY']\n else:\n primary = np.ones(len(objects), dtype=bool)\n \n #----- LRG\n lrg = primary.copy()\n lrg &= rflux > 10**((22.5-23.0)/2.5)\n lrg &= zflux > 10**((22.5-20.56)/2.5)\n lrg &= w1flux > 10**((22.5-19.35)/2.5)\n lrg &= zflux > rflux * 10**(1.6/2.5)\n #- clip to avoid warnings from negative numbers raised to fractional powers\n lrg &= w1flux * rflux.clip(0)**(1.33-1) > zflux.clip(0)**1.33 * 10**(-0.33/2.5)\n\n #----- ELG\n elg = primary.copy()\n elg &= rflux > 10**((22.5-23.4)/2.5)\n elg &= zflux > rflux * 10**(0.3/2.5)\n elg &= zflux < rflux * 10**(1.5/2.5)\n elg &= rflux**2 < gflux * zflux * 10**(-0.2/2.5)\n elg &= zflux < gflux * 10**(1.2/2.5)\n\n #----- Quasars\n psflike = ((objects['TYPE'] == 'PSF') | (objects['TYPE'] == 'PSF ')) \n qso = primary.copy()\n qso &= psflike\n qso &= rflux > 10**((22.5-23.0)/2.5)\n qso &= rflux < gflux * 10**(1.0/2.5)\n qso &= zflux > rflux * 10**(-0.3/2.5)\n qso &= zflux < rflux * 10**(1.1/2.5)\n #- clip to avoid warnings from negative numbers raised to fractional powers\n qso &= wflux * gflux.clip(0)**1.2 > rflux.clip(0)**(1+1.2) * 10**(-0.4/2.5)\n ### qso &= wflux * gflux**1.2 > rflux**(1+1.2) * 10**(2/2.5)\n\n #------ Bright Galaxy Survey\n #- 'PSF' for astropy.io.fits; 'PSF ' for fitsio (sigh)\n bgs = primary.copy()\n bgs &= ~psflike\n bgs &= rflux > 10**((22.5-19.35)/2.5)\n\n #----- Standard stars\n fstd = primary.copy()\n fstd &= psflike\n fracflux = objects['DECAM_FRACFLUX'].T \n signal2noise = objects['DECAM_FLUX'] * np.sqrt(objects['DECAM_FLUX_IVAR'])\n with warnings.catch_warnings():\n warnings.simplefilter('ignore')\n for j in (1,2,4): #- g, r, z\n fstd &= fracflux[j] < 0.04\n fstd &= signal2noise[:, j] > 10\n\n #- observed flux; no Milky Way extinction\n obs_rflux = objects['DECAM_FLUX'][:, 2]\n fstd &= obs_rflux < 10**((22.5-16.0)/2.5)\n fstd &= obs_rflux > 10**((22.5-19.0)/2.5)\n #- colors near BD+17; ignore warnings about flux<=0\n with warnings.catch_warnings():\n warnings.simplefilter('ignore')\n grcolor = 2.5 * np.log10(rflux / gflux)\n rzcolor = 2.5 * np.log10(zflux / rflux)\n fstd &= (grcolor - 0.32)**2 + (rzcolor - 0.13)**2 < 0.06**2\n\n #-----\n #- construct the targetflag bits\n #- Currently our only cuts are DECam based (i.e. South)\n desi_target = lrg * desi_mask.LRG_SOUTH\n desi_target |= elg * desi_mask.ELG_SOUTH\n desi_target |= qso * desi_mask.QSO_SOUTH\n\n desi_target |= lrg * desi_mask.LRG\n desi_target |= elg * desi_mask.ELG\n desi_target |= qso * desi_mask.QSO\n\n desi_target |= fstd * desi_mask.STD_FSTAR\n \n bgs_target = bgs * bgs_mask.BGS_BRIGHT\n bgs_target |= bgs * bgs_mask.BGS_BRIGHT_SOUTH\n\n #- nothing for MWS yet; will be GAIA-based\n mws_target = np.zeros_like(bgs_target)\n\n #- Are any BGS or MWS bit set? Tell desi_target too.\n desi_target |= (bgs_target != 0) * desi_mask.BGS_ANY\n desi_target |= (mws_target != 0) * desi_mask.MWS_ANY\n\n return desi_target, bgs_target, mws_target","def remove_shadow(self):\n #Separate the RGB\n rgb_planes = cv.split(self.frame)\n\n result_norm_planes = []\n #Go through the planes, get a dilated image and a blur image, then get the difference between the two images, then normalize the final image\n for plane in rgb_planes:\n dilated_img = cv.dilate(plane, np.ones((7,7), np.uint8))\n bg_img = cv.medianBlur(dilated_img, 21)\n diff_img = 255 - cv.absdiff(plane, bg_img)\n norm_img = cv.normalize(diff_img,None, alpha=0, beta=255, norm_type=cv.NORM_MINMAX, dtype=cv.CV_8UC1)\n result_norm_planes.append(norm_img)\n\n result_norm = cv.merge(result_norm_planes)\n\n self.frame = result_norm","def foward_shimmey(self):\n for x in range(6):\n self.right(primary=60, counter=30)\n time.sleep(.5)\n self.left(primary=70, counter=30)\n time.sleep(.5)\n self.back()\n time.sleep(2) \n self.stop()","def SetWireDivideTool(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_FaceDivide_SetWireDivideTool(self, *args)","def clean(times,signal, f0=None, fn=None, df=None, freqbins=None, niter=10.,\n gain=1.0):\n T = times.ptp()\n n = len(times)\n if freqbins is None:\n freqbins = [f0,fn]\n \n startfreqs = np.array(freqbins[0::2])\n endfreqs = np.array(freqbins[1::2])\n nbins = len(freqbins)-1\n \n nf = int(fn/df)\n \n #-- do clean computation, seems not so straightforward to thread cleaning\n f,wpow,wpha = pyclean.main_clean(times,signal,fn,nf,gain,niter,nbins,\\\n startfreqs,endfreqs)\n \n return f,wpow","def filtering(self):\r\n # 1 ###########################################################################################################\r\n fft_image = np.fft.fft2(self.image)\r\n # 2 ###########################################################################################################\r\n fft_shift_image = np.fft.fftshift(fft_image)\r\n\r\n ###\r\n mag_dft = np.log(np.abs(fft_shift_image))\r\n mag_dft = (255 * (mag_dft / np.max(mag_dft))).astype(dtype='uint8')\r\n ###\r\n\r\n # 3 ###########################################################################################################\r\n if self.filter_name == 'butterworth_l' or self.filter_name == 'butterworth_h':\r\n mask = self.filter(fft_shift_image.shape, self.cutoff, self.order)\r\n else:\r\n mask = self.filter(fft_shift_image.shape, self.cutoff)\r\n # 4 ###########################################################################################################\r\n # multiply the dft (fft shift image) by the mask\r\n filtered_image = fft_shift_image * mask\r\n\r\n ###\r\n mag_filtered_image = mag_dft * mask\r\n ###\r\n\r\n # 5 ###########################################################################################################\r\n inverse_fft_shift_image = np.fft.ifftshift(filtered_image)\r\n # 6 ###########################################################################################################\r\n inverse_fft_image = np.fft.ifft2(inverse_fft_shift_image)\r\n # 7 ###########################################################################################################\r\n mag_image = np.zeros(inverse_fft_image.shape, dtype=complex)\r\n for i in range(inverse_fft_image.shape[0]):\r\n for j in range(inverse_fft_image.shape[1]):\r\n if inverse_fft_image[i][j] < 0:\r\n mag_image[i][j] = -1 * inverse_fft_image[i][j]\r\n else:\r\n mag_image[i][j] = inverse_fft_image[i][j]\r\n # magnitude of inverse fft is complete\r\n # 8 ###########################################################################################################\r\n full_contrast_image = self.post_process_image(mag_image)\r\n\r\n return [mag_dft, mag_filtered_image, full_contrast_image]","def filtering(self):\n from numpy import fft\n import numpy as np\n\n _image_dft = fft.fft2(self.image)\n _image_dft = fft.fftshift(_image_dft)\n # dft = DFT.DFT()\n # plt.figure(1) \n # plt.imshow(self.image)\n # plt.figure(2)\n # plt.imshow(20*np.log10(abs(_image_dft))) \n # print(_image_dft)\n # print(abs(_image_dft))\n # plt.show()\n filter = self.filter(self.image.shape, self.cutoff, self.order) \\\n if self.filter_name.startswith('butterworth') \\\n else self.filter(self.image.shape, self.cutoff)\n \n _image_dft_filtered = _image_dft * filter\n _image_filtered = abs(fft.ifft2(_image_dft_filtered))\n \n return [ self.post_process_image(_image_filtered), \\\n self.post_process_image(20*np.log10(abs(_image_dft)+.00001)), \\\n self.post_process_image(20*np.log10(abs(_image_dft_filtered)+.00001)) ]","def CleanBadPixels(spectraUp,spectraDown):\n \n Clean_Up= []\n Clean_Do = []\n Clean_Av = []\n eps=25. # this is the minumum background Please check\n NBSPEC=len(spectraUp)\n for index in np.arange(0,NBSPEC):\n s_up=spectraUp[index]\n s_do=spectraDown[index]\n \n index_up=np.where(s_up<eps)\n index_do=np.where(s_do<eps)\n \n s_up[index_up]=s_do[index_up]\n s_do[index_do]=s_up[index_do]\n s_av=(s_up+s_do)/2.\n \n Clean_Up.append(s_up)\n Clean_Do.append(s_do)\n Clean_Av.append(s_av)\n \n return Clean_Up, Clean_Do,Clean_Av","def force_wo_scf(self):\n self.report('INFO: run Force theorem calculations')\n\n status = self.change_fleurinp()\n if status:\n return status\n\n fleurin = self.ctx.fleurinp\n\n # Do not copy mixing_history* files from the parent\n settings = {'remove_from_remotecopy_list': ['mixing_history*']}\n\n # Retrieve remote folder from the inputs\n remote = self.inputs.remote\n\n label = 'DMI_force_theorem'\n description = 'The is the force theorem calculation for DMI energy.'\n\n code = self.inputs.fleur\n options = self.ctx.options.copy()\n\n inputs_builder = get_inputs_fleur(code,\n remote,\n fleurin,\n options,\n label,\n description,\n settings,\n add_comp_para=self.ctx.wf_dict['add_comp_para'])\n future = self.submit(FleurBaseWorkChain, **inputs_builder)\n return ToContext(f_t=future)","def step(self):\n # gets who has fired who in this step\n blues_fire_reds = np.array([[blue.fires_(red) for red in self.red_drones] for blue in self.blue_drones])\n reds_fire_blues = np.array([[red.fires_(blue) for blue in self.blue_drones] for red in self.red_drones])\n\n # if the foe is no longer seen, the count restarts from 0\n self.blues_have_fired_reds *= blues_fire_reds\n self.reds_have_fired_blues *= reds_fire_blues\n\n # and the count is incremented for the others\n self.blues_have_fired_reds += blues_fire_reds\n self.reds_have_fired_blues += reds_fire_blues\n\n # np magic : first find the list of duos shooter/shot, keep the shots (only once)\n red_deads = np.unique(np.argwhere(self.blues_have_fired_reds >= self.blue_shots_to_kill).T[1])\n blue_deads = np.unique(np.argwhere(self.reds_have_fired_blues >= self.red_shots_to_kill).T[1])\n\n\n # tell the drones that they are dead\n for drone_id in blue_deads:\n self.blue_drones[drone_id].is_killed(is_blue=True)\n for drone_id in red_deads:\n self.red_drones[drone_id].is_killed(is_blue=False)\n\n # consider only living drones\n blue_drones = [drone for drone in self.blue_drones if drone.is_alive]\n red_drones = [drone for drone in self.red_drones if drone.is_alive]\n\n bf_obs, rf_obs = self.get_observation()\n bf_reward = rf_reward = 0\n remaining_blues, remaining_reds = len(blue_drones), len(red_drones),\n blue_shots, red_shots = len(blue_deads), len(red_deads)\n\n if blue_shots + red_shots > 0:\n print('someone is killed: {0} blues and {1} reds'.format(blue_shots, red_shots))\n\n return bf_obs, bf_reward, remaining_blues, blue_shots, rf_obs, rf_reward, remaining_reds, red_shots","def butterfly(self):\n\n self.log.info(\"Begin Butterfly\")\n\n dst = os.path.join(self.cfg['start_dir'], 'Butterfly', 'src')\n try:\n os.chdir(dst)\n except OSError, err:\n self.log.error(\"Butterfly: failed to change to dst dir %s\" % (dst, err))\n\n cmd = \"ant\"\n run_cmd(cmd)\n\n self.log.info(\"End Butterfly\")","def run(self):\n self.coffee_machine.beans_tank.decrease_weight(self.coffee_machine.chosen_coffee_data.get('beans_weight'))","def flattenTest():\n x = rampfloat(0,0,1,n1,n2)\n t = rampfloat(0,1,0,n1,n2)\n smax = 5.0\n a = smax/(n1-1)\n b = 2*PI/(n2-1)\n bx = mul(b,x)\n bt = mul(b,t)\n cosbx = cos(bx)\n sinbx = sin(bx)\n acosbx = mul(a,cosbx)\n asinbx = mul(a,sinbx)\n p2 = div(mul(bt,acosbx),add(1,asinbx))\n el = fillfloat(1,n1,n2)\n fl = FlattenerCg(8.0,0.01)\n sf = fl.findShifts(p2,el) # found shifts\n se = neg(mul(t,asinbx)) # exact shifts\n plot(sf,jet,-smax,smax)\n plot(se,jet,-smax,smax)","def do_stuff(self):\n self.create_tourism_raster()","def _fly(self):\n logger.info(\"flyer activity()\")\n if self.complete_status is None:\n logger.info(\"leaving activity() - not complete\")\n return\n\n # TODO: do the activity here\n logger.info(\"writing data... \")\n for step in range(self._steps):\n t = time.time()\n x = t - self.t0\n d = dict(\n time=t,\n data=dict(x=x),\n timestamps=dict(x=t)\n )\n self._data.append(d)\n time.sleep(.5)\n logger.info(\"done\")\n\n # once started, we notify by updating the status object\n self.kickoff_status.set_finished()\n\n # TODO: wait for completion\n\n # after the wait, we declare victory\n # self.complete_status.set_finished()\n # logger.info(\"_fly() complete. status = \" + str(self.complete_status))","def cleanup(self):\n self.subpixel, self.pixel = self.stepup(self.subpixel, self.pixel, AxisDistance.pixelsize)\n self.pixel, self.tile = self.stepup(self.pixel, self.tile, AxisDistance.tilesize)","def go():\n ##########\n #\n # MB19284\n #\n ##########\n\n ##########\n # Kp-band reduction\n ##########\n\n target = 'mb19284'\n sci_files = ['i200822_a011{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\n sci_files += ['i200822_a012{0:03d}_flip'.format(ii) for ii in range(2, 25+1)]\n sky_files = ['i200822_a018{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\n refSrc = [917.75, 1033.5] # This is the target\n # Alternative star to try (bright star to bottom of target): [1015, 581.9]\n \n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\n trim=0, weight='strehl', submaps=3, instrument=osiris)\n\n ##########\n #\n # KB200101\n #\n ##########\n\n ##########\n # Kp-band reduction\n ##########\n\n # -- If you have more than one position angle, make sure to\n # clean them seperatly.\n # -- Strehl and Ref src should be the pixel coordinates of a bright\n # (but non saturated) source in the first exposure of sci_files.\n # -- If you use the OSIRIS image, you must include the full filename in the list. \n target = 'kb200101'\n sci_files = ['i200822_a014{0:03d}_flip'.format(ii) for ii in range(2, 28+1)]\n sci_files += ['i200822_a015{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\n sci_files += ['i200822_a016{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\n sky_files = ['i200822_a017{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\n refSrc = [975, 1006] # This is the target\n # Alternative star to try (bright star to right of target): [1158, 994]\n \n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\n trim=1, weight='strehl', submaps=3, instrument=osiris)","def farm_damage(turbineX,turbineY,windDirections,windFrequencies,Omega_free,free_speed,Omega_close,close_speed,Omega_far,far_speed,\n Rhub,r,chord,theta,af,Rtip,B,rho,mu,precone,hubHt,nSector,pitch,yaw_deg,TI=0.11):\n\n damage = np.zeros_like(turbineX)\n nDirections = len(windDirections)\n nTurbines = len(turbineX)\n\n for j in range(nDirections):\n turbineXw, turbineYw = fast_calc_aep.windframe(windDirections[j], turbineX, turbineY)\n for i in range(nTurbines):\n damage[i] += get_edgewise_damage(turbineXw,turbineYw,i,Omega_free,free_speed,Omega_close,close_speed,Omega_far,far_speed,\n Rhub,r,chord,theta,af,Rtip,B,rho,mu,precone,hubHt,nSector,pitch,yaw_deg,TI=TI)*windFrequencies[j]\n return damage","def go_infFD(self):\n\n response = self.send_lens_cmd(['05', '00', '00', '00'], fast_mode=True)\n self.wait_focus_move()","def cruise(self):\n while self.dist() > self.SAFE_STOP_DIST:\n time.sleep(.2)\n self.fwd()\n self.stop()","def test2(self):\r\n\t\tif not self._motion.breakout():\r\n\t\t\tself._motion.initialize()\r\n\t\tif not self._motion.breakout():\r\n\t\t\tself._motion.sweepDuckie()\r\n\t\tif not self._motion.breakout():\r\n\t\t\tself._motion.duckieAlignX()\r\n\t\tif not self._motion.breakout():\r\n\t\t\tself._motion.duckieAlignY()\r\n\t\tif not self._motion.breakout():\r\n\t\t\tself._motion.duckieLowerEE()\r\n\t\tif not self._motion.breakout():\r\n\t\t\tself._motion.duckieSuctionOn()\r\n\t\tif not self._motion.breakout():\r\n\t\t\tself._motion.duckieLiftEE()\r\n\t\tself._motion.terminate()","def do_harvest_extraction_emissions(self, unused_t):\n # this is an example of a process that is owned by SocialSystem\n # but affects its cells and the world:\n for c in self.cells:\n c.d_terrestrial_carbon -= c.biomass_harvest_flow\n c.d_fossil_carbon -= c.fossil_extraction_flow\n self.world.d_atmospheric_carbon += self.carbon_emission_flow","def myfly(flyers, *, md=None):\n yield from bps.open_run(md)\n for flyer in flyers:\n yield from bps.kickoff(flyer, wait=True)\n for flyer in flyers:\n yield from bps.complete(flyer, wait=True)\n for flyer in flyers:\n yield from bps.collect(flyer, stream=True)\n yield from bps.close_run()","def main():\n amplitute_variation = [0.98, 1.02]\n frequency_variation = [0, 0.06]\n transition_band = [(0.1*math.pi), (0.4*math.pi)]\n (passband, stopband, transition_band_diff) = set_diffs(\n amplitute_variation, frequency_variation, transition_band)\n omega_c = np.mean(transition_band)\n dB = to_dB(stopband)\n windowing_type = choose_window_type(dB)\n M = get_magnetude(transition_band_diff, windowing_type)\n result_filter = create_filter(M, omega_c, windowing_type)\n print('Filter: {0}\\nNormalized_filter: {1}'.format(\n result_filter, normalize(result_filter)))","async def send_drones_to_extractor(self):\n if self.vespene < 100 and not self.already_pending_upgrade(UpgradeId.ZERGLINGMOVEMENTSPEED):\n for extractor in self.gas_buildings:\n drones_needed_to_fill_extractor = extractor.ideal_harvesters - extractor.assigned_harvesters\n if drones_needed_to_fill_extractor > 0:\n for drone in self.workers.closer_than(10, extractor).take(drones_needed_to_fill_extractor):\n self.do(drone.gather(extractor))","def Perform(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_WireDivide_Perform(self, *args)","def BoatEarMoon():\n D=1\n alpha=math.radians(83)\n beta=math.radians(42) \n phi=math.radians(70) \n mu=math.radians(10) \n omega=math.radians(30) \n A=25, a=12, b=20, L=0, P=0, W1=0, W2=0, N=0\n \n resMode()","def main():\n for i in range(4):\n fix_tower()\n if front_is_clear():\n move_to_next()","def settle_falilng_shape(self):\n if self.falling_shape:\n self._settle_shape(self.falling_shape)\n self.falling_shape = None\n self.new_shape()","def teleopPeriodic(self):\n #self.drive.arcadeDrive(-1*self.stick.getRawAxis(0), self.stick.getRawAxis(1))\n '''\n if self.stick.getRawButton(7) == True:\n self.driveFlag=0\n self.drive.setMaxOutput(0.5)\n if self.stick.getRawButton(8) == True:\n self.driveFlag=1\n self.driveb = wpilib.drive.DifferentialDrive(self.right, self.left)\n self.driveb.setMaxOutput(0.5)\n if self.driveFlag==1:\n self.driveb.arcadeDrive(self.stick.getRawAxis(5), self.stick.getRawAxis(4))\n '''\n if self.driveFlag==0:\n self.drive.arcadeDrive(self.stick.getRawAxis(1), self.stick.getRawAxis(0))\n \n #Camera Point Front:\n if self.stick.getPOV()==0:\n self.SV1.set(1.0)\n self.sd.putValue('Camera','Forward')\n #Camera Point Back:\n if self.stick.getPOV()==180:\n self.SV1.set(-1.0)\n self.sd.putValue('Camera','Backward')\n #Orient Servo 2\n if self.stick.getPOV()==90:\n self.SV2.set(0.5)\n #Orient Servo 2\n if self.stick.getPOV()==270:\n self.SV2.set(-0.6)\n \n if self.stick.getRawButton(1) == True:\n self.prepareCubeFlag = 1\n self.EC1.reset()\n if self.prepareCubeFlag > 0:\n self.prepareGrabCube()\n if self.stick.getRawButton(2) == True:\n self.grabCubeFlag = 1\n self.EC1.reset()\n if self.grabCubeFlag > 0:\n self.grabCube()\n self.EC2.reset()\n if self.stick.getRawButton(3) == True:\n self.deliverCubeFlag = 1\n if self.deliverCubeFlag > 0: \n self.deliverCube()\n if self.stick.getRawButton(5) == True:\n self.E.set(-0.3)\n if self.stick.getRawButton(6) == True:\n self.E.set(0.3)\n \n #Dashboard\n self.sd.putNumber('Speed', 0.5)\n self.sd.putNumber('Gyro',self.gyro.getAngle())\n self.sd.putValue(\"Camera\", \"Forwards\")\n self.sd.putValue(\"SW1\", self.SW1.get())\n self.sd.putValue(\"SW0\", self.SW0.get())\n self.sd.putValue(\"EC1\",self.EC1.getDistance())\n self.sd.putValue(\"EC2\",self.EC2.getDistance())","def run1():\n #Reseting motors\n ResetRobot.reset_wheel_motors()\n ResetRobot.reset_attachment_motors()\n CalibrateRobot.calibrate_gyro()\n\n #mission M01 and M02 - space travel and solar panel\n M01_M02()\n \n #Mission M05- Extraction \n M05_M14()\n\n #Back to base before Gerhard (Remove comment if necessary)\n return_to_base1()\n\n # Must delete for competition.. This is to set up forklift to repeat run.\n Robot.attachment_left.on_for_rotations(-100, 8) #Raises Forklift ","def clean(self):\n\n if (self.clean_level == 'dusty') | (self.clean_level == 'clean'):\n idx, = np.where(self['B_flag'] == 0)\n self.data = self[idx, :]\n\n return","def mv_step(self):\n # def mv_all(self):\n self.device_reg_data &= ~(0x1 << 3)\n bus.write_byte_data(self.device_address, self.device_reg_mode1, self.device_reg_data)","def kernelStopping(self):\n # Always call parent method to be safe.\n super().kernelStopping()\n self.writeFundamental()","def fuse(self):\n # TODO: Don't fuse unless they have None as the end slants?\n i = 0\n while i < len(self.segments) - 1:\n left = self.segments[i]\n right = self.segments[i + 1]\n if (\n isinstance(left, LineSegment)\n and isinstance(right, LineSegment)\n and left.width == right.width\n and left.color == right.color\n and collinear(left.a, left.b, right.b)\n ):\n fused_segment = left.fused_with(right)\n self.segments[i:i+2] = [fused_segment]\n # Leave i unchanged so fused_segment will be the\n # \"left\" segment next iteration.\n else:\n # Cannot fuse, try the next pair.\n i += 1","def cleanup_steps(self):\n # NOTE: This must be called so that camera pipeline is closed successfully\n self.thread.stop()\n cv2.imwrite('images/temp_training_lax_goal.png',\n self.updated_temp_goal_image)","def mv_all(self):\n # def mv_step(self):\n self.device_reg_data &= ~(0x1 << 2)\n bus.write_byte_data(self.device_address, self.device_reg_mode1, self.device_reg_data)","def test_drive(self):\n global ENV, TRAFFIC_LIGHT\n ENV = simpy.Environment()\n TRAFFIC_LIGHT = TrafficLight()\n bus = Bus(nr=0)\n ENV.process(bus.drive())\n ENV.run()\n self.assertEqual(bus.movement.to_pos, 600)","def run(self):\n\n print(self.rf)\n\n try:\n if not os.path.exists(self.iso_f1): # If no iso file exists, it automatically creates one\n ratio = 1\n ncol, nlin, nelem, blocks, centerxy = mesh_geometry(self.mf)\n isod = [[1, 1 * ratio] for i in range(nelem)]\n isodat = str(nelem) + '\\n' + '\\n'.join([' '.join(list(map(str, l))) for l in isod])\n with open(self.iso_f1, 'w') as md:\n md.write(isodat)\n md.close()\n except:\n pass\n\n print('starting Crtomo')\n\n file_list = [self.mf, self.ef, self.df, self.rwf,\n self.iso_f1, self.iso_f2, self.smf, self.f1, self.rmf, self.f3]\n\n pfn = jp(self.rf, 'config')\n if not os.path.exists(pfn):\n os.mkdir(pfn)\n\n copyfile(jp(os.path.dirname(self.crtomo_exe), 'crtritime.cfg'), jp(pfn, 'crtritime.cfg')) # Copies cfg file\n\n for f in file_list: # Copies each important file in the 'config' folder\n try:\n fname = path_leaf(f)\n copyfile(f, jp(pfn, fname))\n except:\n pass\n\n sp.call([self.crtomo_exe]) # Runs the exe\n\n print('process over')","def darksubtract(dir='Flats', master_dark='Darks/Dark60sec0807.fits'):\n # master_dark = input(\"Which Master Dark in the /Darks/ folder (or otherwise) would you like to use?\")\n\n # if answer == 'Y':\n # print(\"The script is now running....\")\n # else:\n # print(\"You have chosen to quit this program\")\n # raise SystemExit\n\n if dir == \"Flats\":\n dir = 'Flats/*/'\n elif dir == \"Skys\":\n dir = 'Skys/*/'\n elif dir ==\"Objects\":\n dir = 'Objects/*/*/'\n\n mdark = CCDData.read(master_dark, unit=\"adu\")\n\n for d in glob(dir):\n keys = ['OBJECT', 'CAMNAME', 'FWINAME', 'ITIME', 'DATE-OBS', 'FLSPECTR', 'HISTORY']\n images = ImageFileCollection(d, keywords=keys, glob_exclude='d*', glob_include='*.fits')\n\n directory = d + '/dark_subtracted'\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n # Read in all files from /FLATS/ subdirectories and subtract the master_dark. The output is stored in 'dflat'.\n for flat, fname in images.hdus(return_fname=True):\n meta = flat.header\n meta['FILENAME'] = fname\n flat_exposure = flat.header['ITIME']\n flats = CCDData(data=flat.data.astype('float32'), meta=meta, unit=\"adu\")\n dflat = (ccdproc.subtract_dark(flats, mdark, exposure_time='ITIME',\n exposure_unit=u.second,\n add_keyword={'HISTORY': 'Dark Subtracted', 'OBSDATE': flat.header['DATE-OBS'],\n 'CRVAL1': meta['CRVAL1'], 'CRVAL2': meta['CRVAL2']},\n scale=True))\n #print(dflat.meta['CRVAL1'])\n dflat.wcs = None\n dflat.write(directory + '/d' + fname, overwrite=True)\n fits.writeto","def goForwardsMF(state, dico):\n oppDef = nearest_defender_def(state, state.opponents, dico['rayDribble'])\n if oppDef is not None:\n tm = free_teammate(state, dico['angleInter'])\n if tm is not None and must_pass_ball(state, tm, dico['angleInter']) \\\n and not is_under_pressure(state, tm, dico['rayPressing']):\n return passBall(state, tm, dico['powerPasse'], dico['thetaPasse'], dico['coeffPushUp'])+\\\n pushUp(state, dico['coeffPushUp'])\n if state.numPlayers == 4:\n return dribble(state, oppDef, dico['angleDribble'], dico['powerDribble'], dico['coeffAD'])\n else : # state.numPlayers == 2\n return dribble_speed(state, oppDef, dico['angleDribble'], dico['powerDribble'], dico['coeffAD'])\n return control(state, dico['controleMT'])","def run(self) :\n file = ROOT.TFile(self.input, \"UPDATE\")\n if not file :\n print \"file not found: \", self.input\n for dir in self.directories :\n if self.verbose:\n print \"Morphing directory: %s\" % dir\n for sample in self.samples :\n if self.verbose:\n print \"Morphing sample: %s\" % sample\n for idx in range(len(self.masses)-1) :\n nbin = int((float(self.masses[idx+1])-float(self.masses[idx]))/self.step_size)\n if nbin > 1 :\n for x in range(nbin-1) :\n # This formatting is valid for 0.5 GeV bins up to TeV\n # Returns 111 for 111.0, 111.5 for 111.5\n value = \"%.4g\" % (float(self.masses[idx])+(x+1)*float(self.step_size))\n if self.verbose:\n print \"Morphing %0.1f between (%0.1f, %0.1f)\" % tuple(float(x) for x in (value, self.masses[idx], self.masses[idx+1]))\n self.morph_hist(file, dir, sample, self.masses[idx], self.masses[idx+1], value)\n for uncert in self.uncerts :\n if not uncert == '' :\n self.morph_hist(file, dir, sample+'_'+uncert+'Up', self.masses[idx], self.masses[idx+1], value)\n self.morph_hist(file, dir, sample+'_'+uncert+'Down', self.masses[idx], self.masses[idx+1], value)\n else :\n if self.verbose :\n print \"nothing needs to be done here: nbin =\", nbin","def to_feather(self,dirPaths,expandCategory=False,expandTime=False,preprocessType='ignore',sepLabel = False,version = 1,chunksize=None):\n return io.to_feather(\n dirPaths= dirPaths,\n time_series_data= self.time_series_data,\n expandCategory = expandCategory,\n expandTime = expandTime,\n preprocessType = preprocessType,\n seperateLabels= sepLabel,\n version= version,\n chunksize= chunksize\n )","def post_solve_bird_wood(arbiter, space_obj, _):\n #removing polygon\n removed_poly = []\n if arbiter.total_impulse.length > 1100:\n object1, object2 = arbiter.shapes\n for Each_column in columns:\n if object2 == Each_column.shape:\n removed_poly.append(Each_column)\n for Each_beam in beams:\n if object2 == Each_beam.shape:\n removed_poly.append(Each_beam)\n for Each_poly in removed_poly:\n if Each_poly in columns:\n columns.remove(Each_poly)\n if Each_poly in beams:\n beams.remove(Each_poly)\n space_obj.remove(object2, object2.body)\n #you can also remove bird if you want","def segment_and_find_positions(self):\n initial_image = self.data\n xdim = self.data.shape[0]\n\n ydim = self.data.shape[1]\n downsized_image = transform.resize(\n initial_image,\n (xdim / DOWNSCALING_FACTOR, ydim / DOWNSCALING_FACTOR),\n mode=\"constant\",\n )\n rescaled_image = exposure.rescale_intensity(downsized_image)\n print(\"Starting Canny filtering\")\n g_edges = skimage.feature.canny(\n rescaled_image,\n sigma=self.canny_sigma,\n low_threshold=self.canny_low_threshold,\n )\n print(\"Starting dilation\")\n dilation = morphology.dilation(g_edges, morphology.disk(3))\n print(\"Starting erosion\")\n eroded = morphology.erosion(dilation, morphology.disk(4))\n dilation = morphology.dilation(\n eroded, morphology.diamond(4)\n ) # Dont change to disk\n print(\"Starting to remove small holes\")\n filled = morphology.remove_small_holes(\n dilation, area_threshold=self.remove_small_holes_area_threshold\n )\n print(\"Starting erosion\")\n eroded = morphology.erosion(filled, morphology.diamond(3))\n print(\"Applying filters\")\n filtered_image = eroded\n if self.colony_filters_dict is not None:\n for filter_name in self.colony_filters_dict.keys():\n filtered_image = segmentation_filters.apply_filter(\n filter_name, filtered_image, self.colony_filters_dict[filter_name]\n )\n\n colony_edges = morphology.dilation(feature.canny(filtered_image, 0.01))\n print(\"Starting outlining\")\n outline = downsized_image.copy()\n outline[colony_edges] = 65535\n distance = ndimage.distance_transform_edt(filtered_image)\n smoothed_well = ndimage.gaussian_filter(downsized_image, 0.35)\n outline.copy()\n objs, num_objs = ndimage.label(filtered_image)\n print(\"Applying filters for points\")\n if self.mode == \"A\":\n # point selection: Smoothest point in the center region\n for obj in range(1, num_objs + 1):\n print(\"On object {} of {}\".format(obj, num_objs))\n mask = objs == obj\n dist_mask = distance * mask\n # for each colony,\n # find the maximum distance from the two fold distance map.\n # The edge is at 0% and the center of the colony is at 100%\n d_max = dist_mask.max()\n # Getting the points which is at least 40% away from the edge\n top_percent = dist_mask > (d_max * 0.40)\n colony_mask = smoothed_well * top_percent\n colony_edges = feature.canny(colony_mask, 0.1)\n # applying the second distance transform\n # to find the smoothest point in the correct region\n inner_edges = ndimage.distance_transform_edt(\n ~colony_edges * top_percent\n )\n smooth_point = numpy.where(inner_edges == inner_edges.max())\n smooth_point = (smooth_point[0][0], smooth_point[1][0])\n smooth_point_corrected = (\n smooth_point[0] * DOWNSCALING_FACTOR,\n smooth_point[1] * DOWNSCALING_FACTOR,\n )\n self._point_locations.append(smooth_point_corrected)\n elif self.mode == \"C\":\n for obj in range(1, num_objs + 1):\n print(\"On object {} of {}\".format(obj, num_objs))\n mask = objs == obj\n dist_mask = distance * mask\n # point selection: edge, ridge & center respectively\n self.get_mode_c_points(dist_mask, 0, 0.03)\n self.get_mode_c_points(dist_mask, 0.15, 0.20)\n self.get_mode_c_points(dist_mask, 0.90, 0.99)","def main():\n\n # Create an instance of our Star Targeter tool\n starTargeter = StarTargetTool()\n\n # Connect to Maxim and perform basic setup\n starTargeter.connect()\n\n\n # Calibrate the autoguider orientation and scale if requested\n if PERFORM_CALIBRATION:\n starTargeter.calibrateAutoGuider(EXPOSURE_LENGTH_SECONDS) \n\n # When autoguiding, Maxim normally creats a tiny subframe around\n # the target star. Since our star may be hundreds of pixels off\n # from the desired fiber position, first call this routine to\n # take some full-frame exposures and perform coarse adjustments\n # to get the star near the target\n starCenteredSuccessfully = starTargeter.findStarAndMoveToTarget(EXPOSURE_LENGTH_SECONDS, FIBER_X, FIBER_Y, ROUGH_TOLERANCE_PIXELS, maxIterations=5)\n\n if starCenteredSuccessfully:\n # Use Maxim's built-in star tracking routine to\n # accurately position the star and keep it\n # on target\n starTargeter.subframeAndKeepStarOnTarget(EXPOSURE_LENGTH_SECONDS, FIBER_X, FIBER_Y, ROUGH_TOLERANCE_PIXELS)\n else:\n print \"STAR CENTERING FAILED\""],"string":"[\n \"def _removeFX(self):\\r\\n\\t\\tnodesToClean = [CONST.FOAM_FLUID_SHAPENODE, CONST.WAKE_FLUID_SHAPENODE, 'fluids_hrc']\\r\\n\\t\\tfor eachNode in nodesToClean:\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tcmds.delete(each)\\r\\n\\t\\t\\texcept:\\r\\n\\t\\t\\t\\tpass\\r\\n\\r\\n\\t\\tfor eachCache in cmds.ls(type = 'cacheFile'):\\r\\n\\t\\t\\tcmds.delete(eachCache)\",\n \"def step(self):\\n self.world.slosh_oceans()\\n self.world.transfer_energy_vertically()\\n self.world.transfer_energy_horizontally()\\n self.world.absorb_energy_from_core()\\n self.world.absorb_energy_from_sun(self.sun)\",\n \"def run(self):\\n\\n self.steer()\\n self.drive()\",\n \"def at_med_filt(self):\\n\\t fmed = self.fm - nd.median_filter(self.fm, size=self.header['tdurcad']*3)\\n\\n\\t # Shift t-series so first transit is at t = 0 \\n\\t dt = t0shft(self.t,self.P,self.t0)\\n\\t tf = self.t + dt\\n\\t phase = np.mod(tf + 0.25 * self.P, self.P) / self.P - 0.25\\n\\t tPF = phase * self.P # Phase folded time\\n\\n\\t # bin up the points\\n\\t for nbpt in [1,5]:\\n\\t # Return bins of a so that nbpt fit in a transit\\n\\t nbins = np.round( tPF.ptp()/self.tdur*nbpt ) \\n\\t bins = np.linspace(tPF.min(),tPF.max(),nbins+1)\\n\\t fmed = ma.masked_invalid(fmed)\\n\\t btPF,bfmed = hbinavg(tPF[~fmed.mask],fmed[~fmed.mask],bins)\\n \\n\\t rbmed = np.rec.fromarrays([btPF,bfmed],names=['t','f'])\\n\\n\\t self.add_dset('rbmed%i' % nbpt, rbmed, description='Binned phase-folded, median filtered timeseries, %i points per tdur'% nbpt) \\n\\n\\t self.add_dset('fmed',fmed,description='Median detrended flux')\",\n \"def at_med_filt(self):\\n\\t fmed = self.fm - nd.median_filter(self.fm, size=self.header['tdurcad']*3)\\n\\n\\t # Shift t-series so first transit is at t = 0 \\n\\t dt = t0shft(self.t,self.P,self.t0)\\n\\t tf = self.t + dt\\n\\t phase = np.mod(tf + 0.25 * self.P, self.P) / self.P - 0.25\\n\\t tPF = phase * self.P # Phase folded time\\n\\n\\t # bin up the points\\n\\t for nbpt in [1,5]:\\n\\t # Return bins of a so that nbpt fit in a transit\\n\\t nbins = np.round( tPF.ptp()/self.tdur*nbpt ) \\n\\t bins = np.linspace(tPF.min(),tPF.max(),nbins+1)\\n\\t fmed = ma.masked_invalid(fmed)\\n\\t btPF,bfmed = hbinavg(tPF[~fmed.mask],fmed[~fmed.mask],bins)\\n \\n\\t rbmed = np.rec.fromarrays([btPF,bfmed],names=['t','f'])\\n\\n\\t self.add_dset('rbmed%i' % nbpt, rbmed, description='Binned phase-folded, median filtered timeseries, %i points per tdur'% nbpt) \\n\\n\\t self.add_dset('fmed',fmed,description='Median detrended flux')\",\n \"def test_apply_father_wavelet_dirac(self):\\n pass\",\n \"def runBrighterFatter():\\n RunData([getFiles(mintime=(15, 12, 20), maxtime=(15, 24, 16), folder='data/31Jul/')[0],], out='I800nmlow',\\n wavelength='l800l')\\n RunData([getFiles(mintime=(15, 28, 40), maxtime=(15, 39, 21), folder='data/31Jul/')[2],], out='I800nmmed',\\n wavelength='l800m')\\n RunData([getFiles(mintime=(15, 40, 07), maxtime=(15, 45, 14), folder='data/29Jul/')[4],], out='I800nmhigh',\\n wavelength='l800h')\",\n \"def applyMorphologicalCleaning(self, image):\",\n \"def stop(self):\\n self.stop_aperture()\",\n \"def processFoil(self):\\n \\n # Split airfoil in upper and lower portions\\n self.__airfoilSplit()\\n \\n # Interpolate\\n self.__hinterpolate()\",\n \"def burn_step(self):\\n change = np.full((self.width, self.height), 0)\\n for x in range(0, self.width - 1):\\n for y in range(0, self.height - 1):\\n # How fast we go through the fuel\\n if random.randrange(2) == 0:\\n self.fire_check_point(x, y, change)\\n\\n self.temp = np.maximum(change, self.temp)\",\n \"def moveFWto(self, filtpos):\\n self.askFW(\\\"3FDE\\\") # Dumps errors \\n self.askFW(\\\"3FMP \\\" + str(filtpos))\\n self.waitFW()\\n self.askFW(\\\"3FDE\\\") # Dumps errors \\n self.askFW(\\\"1HDE\\\") # Dumps errors \\n self.askFW(\\\"2HDE\\\") # Dumps errors\",\n \"def drive(self, kilometres_driven):\\n self.fuel -= (self.litres_per_kilometre * kilometres_driven)\",\n \"def run(self):\\n self.coffee_machine.water_tank.decrease_weight(self.coffee_machine.chosen_coffee_data.get('water_weight'))\",\n \"def removeInsignificant(self):\\n #TODO make sure this method now works AFTER meanCurves and analyseCures have been run\\n \\n # Searching for curves that are in the noise\\n if len(self.plate.noProtein) > 0:\\n thresholdm, i = rh.meanSd([self.originalPlate.wells[x].monoThresh for x in self.plate.noProtein])\\n for well in self.originalPlate.wells:\\n if not self.originalPlate.wells[well].contents.isControl and well not in self.delCurves:\\n if self.originalPlate.wells[well].monoThresh > thresholdm/1.15:\\n #self.wells[well].fluorescence = None\\n self.delCurves.append(well)\\n\\n # Searching for curves that have overloaded the sensor\\n for well in self.wells:\\n if well not in self.delCurves:\\n mini = self.wells[well].fluorescence[0]\\n maxi = self.wells[well].fluorescence[0]\\n\\n maxInd = 0\\n for i in range(len(self.wells[well].fluorescence)):\\n if self.wells[well].fluorescence[i] > maxi:\\n maxi = self.wells[well].fluorescence[i]\\n maxInd = i\\n if self.wells[well].fluorescence[i] < mini:\\n mini = self.wells[well].fluorescence[i]\\n\\n diff = maxi - mini\\n\\n # A boundry defining how much the points can fluctuate and still be considered flat\\n lowFlatBoundry = maxi - 0.005*diff\\n\\n # Look each way to see how many temperature steps the curve stays flat for\\n count = 0\\n ind = maxInd - 1\\n while ind>=0:\\n if self.wells[well].fluorescence[ind] > lowFlatBoundry:\\n count += 1\\n ind -= 1\\n else:\\n break\\n ind = maxInd+1\\n while ind<len(self.wells[well].fluorescence):\\n if self.wells[well].fluorescence[ind] > lowFlatBoundry:\\n count += 1 \\n ind += 1\\n else:\\n break\\n if well not in self.delCurves and count >= 10:\\n self.delCurves.append(well) \\n return\",\n \"def step(self):\\n if self.store_paths:\\n leapfrog_steps = self._max_leapfrog_steps\\n else:\\n leapfrog_steps = torch.ceil(self._max_leapfrog_steps * torch.rand(1)).int()\\n self.potential_ = self.get_potential()\\n self.metric_ = self.get_metric()\\n self.momentum = self.resample_momenta()\\n self.hamiltonian_ = self.get_hamiltonian()\\n old_hamiltonian = self.hamiltonian_\\n if self.shadow:\\n if self.max_shadow is not None:\\n old_shadow = torch.max(self.shadow_.clone() + self.max_shadow, old_hamiltonian)\\n else:\\n old_shadow = self.shadow_.clone()\\n rejected = False\\n for step in range(leapfrog_steps):\\n if (self._integrator == 'RMHMC') and (self.lbfgs == False):\\n self.momentum, rejected = self.implicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n self.parameters, rejected = self.implicit_drift()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n self.momentum, rejected = self.explicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n elif self.lbfgs == True:\\n self.momentum, rejected = self.lbfgs_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n self.parameters, rejected = self.lbfgs_drift()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n self.momentum = self.explicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n else:\\n self.momentum, rejected = self.explicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n self.parameters = self.explicit_drift()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n self.momentum, rejected = self.explicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if self.store_paths:\\n self.paths.append(self.parameters.detach())\\n new_hamiltonian = self.get_hamiltonian()\\n ratio = old_hamiltonian - new_hamiltonian\\n self.hamiltonian_error.append(ratio.detach().unsqueeze(0))\\n if self.shadow:\\n if self.max_shadow is not None:\\n new_shadow = torch.max(self.get_shadow() + self.max_shadow, new_hamiltonian)\\n else:\\n new_shadow = self.get_shadow()\\n shadow_error = old_shadow - new_shadow\\n newratio = ratio + shadow_error\\n self.shadow_hamiltonian_error.append(newratio.detach().unsqueeze(0))\\n ratio = newratio\\n\\n uniform_rand = torch.rand(1)\\n if uniform_rand >= torch.exp(ratio):\\n # Reject sample\\n rejected = True\\n\\n if rejected:\\n if (len(self.momenta) > 10) and (self.momenta[-1] == self.momenta[-10]).sum().item():\\n self.degenerate = True\\n self.rejected += 1\\n self.momentum = self.momenta[-1]\\n self.parameters = self.samples[-1].clone().detach().requires_grad_(True)\\n if self.shadow:\\n radon_nikodym = torch.exp(old_shadow).unsqueeze(0)\\n \\n if self.verbose:\\n print(\\\"(Rejected)\\\", int(self.acceptance_rate() * 100), \\\"%; Log-ratio: \\\",\\n ratio.detach())\\n else:\\n self.accepted += 1\\n if self.shadow:\\n radon_nikodym = torch.exp(new_shadow).unsqueeze(0)\\n if self.verbose:\\n print(\\\"(Accepted)\\\", int(self.acceptance_rate() * 100), \\\"%; Log-ratio: \\\",\\n ratio.detach())\\n self.samples.append(self.parameters.detach())\\n self.momenta.append(self.momentum)\\n self.hamiltonians.append(self.hamiltonian_.detach())\\n self.rands_.append(uniform_rand)\\n self.shadows.append(self.shadow_.detach())\\n if self.shadow:\\n self.radon_nikodym.append(radon_nikodym.detach())\\n return None\",\n \"def clean_tod(self,d,ifeed,feed):\\n scan_edges = d[f'{self.level2}/Statistics/scan_edges'][...]\\n nscans = scan_edges.shape[0]\\n\\n feed_tod = d[f'{self.level2}/averaged_tod'][ifeed,:,:,:]\\n weights = np.zeros(feed_tod.shape)\\n mask = np.zeros(feed_tod.shape[-1],dtype=bool)\\n az = d['level1/spectrometer/pixel_pointing/pixel_az'][ifeed,:]\\n el = d['level1/spectrometer/pixel_pointing/pixel_el'][ifeed,:]\\n\\n # Statistics for this feed \\n medfilt_coefficient = d[f'{self.level2}/Statistics/filter_coefficients'][ifeed,...]\\n atmos = d[f'{self.level2}/Statistics/atmos'][ifeed,...]\\n atmos_coefficient = d[f'{self.level2}/Statistics/atmos_coefficients'][ifeed,...]\\n wnoise_auto = d[f'{self.level2}/Statistics/wnoise_auto'][ifeed,...]\\n fnoise_fits = d[f'{self.level2}/Statistics/fnoise_fits'][ifeed,...]\\n\\n # then the data for each scan\\n last = 0\\n scan_samples = []\\n for iscan,(start,end) in enumerate(scan_edges):\\n scan_samples = np.arange(start,end,dtype=int)\\n median_filter = d[f'{self.level2}/Statistics/FilterTod_Scan{iscan:02d}'][ifeed,...]\\n N = int((end-start))\\n end = start+N\\n tod = feed_tod[...,start:end]\\n mask[start:end] = True\\n # Subtract atmospheric fluctuations per channel\\n for iband in range(4):\\n for ichannel in range(64):\\n #if self.channelmask[ifeed,iband,ichannel] == False:\\n amdl = Statistics.AtmosGroundModel(atmos[iband,iscan],az[start:end],el[start:end]) *\\\\\\n atmos_coefficient[iband,ichannel,iscan,0]\\n if self.median_filter:\\n tod[iband,ichannel,:] -= median_filter[iband,:N] * medfilt_coefficient[iband,ichannel,iscan,0]\\n if self.atmosphere:\\n tod[iband,ichannel,:] -= amdl\\n tod[iband,ichannel,:] -= np.nanmedian(tod[iband,ichannel,:])\\n\\n\\n wnoise = wnoise_auto[:,:,iscan,0]\\n weights[...,start:end] = 1./wnoise[...,None]**2\\n bad = np.isnan(weights) | np.isinf(weights) | ~np.isfinite(feed_tod)\\n feed_tod[bad] = 0\\n weights[bad] = 0\\n\\n return feed_tod, weights, mask\",\n \"def stop_aperture(self):\\n self.aperture_id = None\\n self.mode = \\\"\\\"\",\n \"def climb(self):\\n print(\\\"Inside WoodElf.climb\\\")\",\n \"def masterflat(input_file):\\n #set original directory\\n original_path = os.getcwd()\\n data_path = input_file['data_path']\\n save_path = input_file['save_path']\\n #Change your directory to data diretory\\n os.chdir(data_path)\\n #list all flat images\\n flat = glob.glob('flat*.fits')\\n print 'Loading flat images \\\\nTotal of flat files = ',len(flat),'\\\\nFiles = \\\\n'\\n print flat\\n #if save_path exist, continue; if not, create.\\n if not os.path.exists(save_path):\\n os.makedirs(save_path)\\n #create a list of bias images and copy images to save_path\\n os.system('cp flat*.fits '+save_path)\\n #creating the names of flat with bias subctracted\\n bflat = []\\n for i in flat:\\n bflat.append('B'+i)\\n print '\\\\n Names os flat images with bias subtracted: \\\\n \\\\n',bflat\\n #change for save_path directory\\n os.chdir(save_path)\\n #verify if previous superbias exist\\n if os.path.isfile('superflat.fits') == True:\\n os.system('rm superflat.fits')\\n #verify if exits previous bflat*.fits files and remove then.\\n for i in bflat:\\n if os.path.isfile(i) == True:\\n os.system('rm -f '+i)\\n print '\\\\nCreating superflat .... \\\\n'\\n #create the list of flat images and bflat images\\n #flat = string.join(flat,',')\\n #bflat = string.join(bflat,',')\\n print '\\\\n Subtracting bias from flat images and creating bflat images.... \\\\n'\\n #iraf.imarith()\\n for i in range(len(flat)):\\n iraf.imarith(flat[i],'-','superbias.fits',bflat[i])\\n #print statistics from bflat*.fits images\\n iraf.imstat(bflat[i])\\n print '\\\\n .... done \\\\n'\\n #clean previos flat*.fits files\\n print '\\\\n Clean flat*.fits images .... \\\\n'\\n os.system('rm flat*.fits')\\n print '\\\\n .... done. \\\\n'\\n #normalizing each flat\\n print '\\\\nNormalizing each flat ....\\\\n'\\n #checking if mean from numpy is the same from your bflat images using imstat\\n #take the mean of each bflat image\\n bflat_mean = np.zeros(len(bflat))\\n for i in range(len(bflat)):\\n image = fits.getdata(bflat[i])\\n image = np.array(image,dtype='Float64')\\n bflat_mean[i] = round(np.mean(image))\\n image = 0 #clean image allocate to this variable\\n print 'The mean of each bflat image, respectivaly ...'\\n print bflat_mean\\n #creating the names of bflat images after the normalization:\\n abflat = []\\n for i in bflat:\\n abflat.append('A'+i)\\n print '\\\\n Names os bflat images with bias subtracted and normalizad: \\\\n \\\\n',abflat\\n #verify if exist previous ABflat*.fits images and remove then.\\n for i in abflat:\\n if os.path.isfile(i) == True:\\n os.system('rm -f '+i)\\n for i in range(len(abflat)):\\n iraf.imarith(bflat[i],'/',bflat_mean[i],abflat[i])\\n print '\\\\n.... done!\\\\n'\\n # print '\\\\n Cleaning bflat*.fits images ....\\\\n'\\n # os.system('rm Bflat*.fits')\\n print '\\\\n.... done.\\\\n'\\n print 'Statistics of the abflat*.fits images .... \\\\n'\\n for i in range(len(abflat)):\\n iraf.imstat(abflat[i])\\n print '\\\\n Combining abflat images ....\\\\n'\\n\\n # ablist = string.join(abflat,',')\\n # iraf.imcombine(ablist,'superflat.fits')\\n #change how import flat files\\n #usning the abflat list of flat files We will create a pandas python dataframe\\n ablist = DataFrame(abflat)\\n ablist.columns=['flat_files']\\n ablist.to_csv('flat_list',index_label=False,index=False,header=False)\\n #combine all flat images\\n iraf.imcombine('@flat_list','superflat.fits')\\n iraf.imstat('superflat.fits')\\n print '\\\\n .... done. \\\\n'\\n # print '\\\\nCleaning ABflat*.fits images ....\\\\n'\\n # os.system('rm ABflat*.fits')\\n print '\\\\n.... done!'\\n #Verify if the image was created:\\n output = glob.glob('superflat*.fits')\\n if len(output) != 0:\\n output = 0\\n else:\\n output = 1\\n #Return to original directory\\n os.chdir(original_path)\\n #last mensage\\n print '\\\\n MASTERFLAT.FITS created! \\\\n'\\n print '\\\\n END of Data Reduction for create a masterflat.fits file. \\\\n'\\n #obtain the value of return\\n if output == 1:\\n print '!!! ERROR/WARNING !!!'\\n print 'Check if the superbias was created or if there is more than one superbias image.'\\n return output\",\n \"def start_fare(self):\\n self.current_fare_distance = 0\",\n \"def _remove_flux_extinction(self):\\n self.fluxUnred = self.flux.copy()\\n self.fluxErrUnred = self.fluxErr.copy()\\n self.fluxRenorm = self.flux.copy()\\n self.fluxErrRenorm = self.fluxErr.copy()\\n\\n # Using negative a_v so that extinction.apply works in reverse and removes the extinction\\n if self.mwebv:\\n extinctions = extinction.fitzpatrick99(wave=self._good_filter_wave, \\\\\\n a_v=-3.1 * self.mwebv, r_v=3.1, unit='aa')\\n\\n for i, pb in enumerate(self._good_filters):\\n mask = (self.passband == pb)\\n\\n flux_pb = self.flux[mask]\\n fluxerr_pb = self.fluxErr[mask]\\n npbobs = len(flux_pb)\\n\\n if npbobs < 1:\\n return\\n\\n if self.mwebv:\\n flux_out = extinction.apply(extinctions[i], flux_pb, inplace=False)\\n fluxerr_out = extinction.apply(extinctions[i], fluxerr_pb, inplace=False)\\n else:\\n flux_out = flux_pb\\n fluxerr_out = fluxerr_pb\\n self.fluxUnred[mask] = flux_out\\n self.fluxErrUnred[mask] = fluxerr_out\\n\\n if npbobs > 1:\\n # there's at least enough observations to find minimum and maximum\\n minfluxpb = flux_out.min()\\n maxfluxpb = flux_out.max()\\n norm = maxfluxpb - minfluxpb\\n self.fluxRenorm[mask] = (flux_out - minfluxpb) / norm\\n self.fluxErrRenorm[mask] = fluxerr_out / norm\\n elif npbobs == 1:\\n # deal with the case with one observation in this passband by setting renorm = 0.5\\n norm = self.fluxUnred[mask] / 0.5\\n self.fluxRenorm[mask] /= norm\\n self.fluxErrRenorm[mask] /= norm\\n\\n self._default_cols = ['time', 'flux', 'fluxErr', 'fluxUnred', 'fluxErrUnred', \\\\\\n 'fluxRenorm', 'fluxErrRenorm', 'photflag', 'zeropoint', 'obsId']\\n return\",\n \"def expand_slicer_aperture(system):\\n\\n # First of all, we need to find the Surface Number for the IMAGE SLICER\\n N_surfaces = system.LDE.NumberOfSurfaces\\n surface_names = {} # A dictionary of surface number -> surface comment\\n for k in np.arange(1, N_surfaces):\\n surface_names[k] = system.LDE.GetSurfaceAt(k).Comment\\n # find the Slicer surface number\\n try:\\n # The naming convention for this surface has changed. Not the same for Nominal Design as Monte Carlos\\n slicer_num = list(surface_names.keys())[list(surface_names.values()).index('Slicer Mirror')]\\n except ValueError:\\n slicer_num = list(surface_names.keys())[list(surface_names.values()).index('IFU ISA')]\\n slicer = system.LDE.GetSurfaceAt(slicer_num)\\n\\n # Read Current Aperture Settings\\n apt_type = slicer.ApertureData.CurrentType\\n # print(\\\"Aperture type: \\\", apt_type)\\n if apt_type == 4: # 4 is Rectangular aperture\\n current_apt_sett = slicer.ApertureData.CurrentTypeSettings\\n # print(\\\"Current Settings:\\\")\\n x0 = current_apt_sett._S_RectangularAperture.XHalfWidth\\n y0 = current_apt_sett._S_RectangularAperture.YHalfWidth\\n # If the Y aperture hasn't been changed already, we change it here to 999 mm to get all rays through\\n if y0 != 999:\\n # Change Settings\\n aperture_settings = slicer.ApertureData.CreateApertureTypeSettings(\\n constants.SurfaceApertureTypes_RectangularAperture)\\n aperture_settings._S_RectangularAperture.XHalfWidth = x0\\n aperture_settings._S_RectangularAperture.YHalfWidth = 999\\n slicer.ApertureData.ChangeApertureTypeSettings(aperture_settings)\\n\\n current_apt_sett = slicer.ApertureData.CurrentTypeSettings\\n # Notify that we have successfully modified the aperture\\n print(\\\"Changing aperture of surface: \\\", slicer.Comment)\\n print(\\\"New Settings:\\\")\\n print(\\\"X_HalfWidth = %.2f\\\" % current_apt_sett._S_RectangularAperture.XHalfWidth)\\n print(\\\"Y_HalfWidth = %.2f\\\" % current_apt_sett._S_RectangularAperture.YHalfWidth)\\n\\n return\",\n \"def setup_fermi(self):\\n eventclass=5 # 2 (Source) or 5 (UltracleanVeto)\\n eventtype=0 # 0 (all), 3 (bestpsf) or 5 (top3 quartiles)\\n mask_type='top300'\\n force_mask_at_bin_number=10\\n\\n self.f1 = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min=0,CTB_en_max=40,nside=self.nside,eventclass=eventclass,eventtype=eventtype,newstyle=1,data_July16=True)\\n\\n if mask_type != 'False':\\n self.f1.make_ps_mask(mask_type = mask_type,force_energy = True,energy_bin = force_mask_at_bin_number)\\n self.f1.add_diffuse_newstyle(comp = 'p7', eventclass = eventclass, eventtype = eventtype)\\n self.f1.add_bubbles(comp='bubs') #bubbles\\n self.f1.add_iso(comp='iso') #iso\\n self.f1.add_ps_model(comp='ps_model')\\n\\n # Exposure correct J_map_arr\\n self.J_map_arr *= self.f1.CTB_exposure_maps\\n\\n # Add J-factor map with mean 1 in each energy bin\\n self.f1.add_template_by_hand('J_map',np.array([self.J_map_arr[i]/np.mean(self.J_map_arr[i]) for i in range(40)]))\",\n \"def enemy_waves(self):\\n\\n pass\",\n \"def make_flats(side='blue',overwrite=False):\\r\\n\\r\\n iraf.unlearn('flatcombine')\\r\\n iraf.flatcombine.ccdtype = \\\"\\\"\\r\\n iraf.flatcombine.process = \\\"no\\\"\\r\\n iraf.flatcombine.subsets = \\\"no\\\"\\r\\n iraf.flatcombine.rdnoise = \\\"RON\\\"\\r\\n iraf.flatcombine.gain = \\\"GAIN\\\"\\r\\n for aperture in ['0.5', '1.0', '1.5', '2.0']:\\r\\n flats = find_flats(aperture, side=side)\\r\\n if len(flats) > 0:\\r\\n if overwrite:\\r\\n iraf.delete('flat_%s_%s.fits' % (side, aperture), verify='no')\\r\\n iraf.delete('temp.fits' , verify='no')\\r\\n iraf.delete('tempsmooth.fits', verify='no')\\r\\n iraf.delete('norm_temp.fits', verify='no')\\r\\n # normalize the flat\\r\\n if side == 'blue': \\r\\n if len(flats) < 3:\\r\\n iraf.flatcombine(','.join(flats), output='temp', reject='pclip')\\r\\n if len(flats) >= 3:\\r\\n iraf.flatcombine(','.join(flats), output='temp', reject='avsigclip') \\r\\n iraf.twodspec.longslit.dispaxis = 2\\r\\n # iraf.unlearn('response')\\r\\n # iraf.response.function = 'legendre'\\r\\n iraf.response.order = 100\\r\\n # iraf.response.high_rej = 5\\r\\n # iraf.response.low_rej = 2\\r\\n # iraf.response.niterate = 10\\r\\n # iraf.response('temp[0]', 'temp[0]',\\r\\n # 'flat_%s_%s.fits' % (side, aperture), interactive=\\\"no\\\")\\r\\n # iraf.response('norm_temp[0]', 'norm_temp[0]', \\r\\n # 'flat_%s_%s.fits' % (side, aperture), interactive=\\\"no\\\")\\r\\n # os.rename('temp.fits', 'raw_flat_%s_%s.fits' % (side, aperture))\\r\\n iraf.imfilter.boxcar('temp', 'tempsmooth', xwindow='1', ywindow='500')\\r\\n iraf.imarith('temp', '/', 'tempsmooth', 'norm_temp.fits')\\r\\n iraf.response('norm_temp[0]', 'norm_temp[0]', \\r\\n 'flat_%s_%s.fits' % (side, aperture), interactive=\\\"no\\\")\\r\\n os.rename('norm_temp.fits', 'raw_flat_%s_%s.fits' % (side, aperture))\\r\\n else:\\r\\n if len(flats) < 3:\\r\\n iraf.flatcombine(','.join(flats), output='temp', reject='pclip')\\r\\n if len(flats) >= 3:\\r\\n iraf.flatcombine(','.join(flats), output='temp', reject='avsigclip') \\r\\n iraf.twodspec.longslit.dispaxis = 1\\r\\n iraf.unlearn('response')\\r\\n iraf.response.function = \\\"spline3\\\" \\r\\n iraf.response.order = 100\\r\\n iraf.response.high_rej = 3\\r\\n iraf.response.low_rej = 3\\r\\n iraf.response.niterate = 3\\r\\n iraf.response('temp[0]', 'temp[0]',\\r\\n 'flat_%s_%s.fits' % (side, aperture), interactive=\\\"no\\\")\\r\\n # iraf.response('norm_temp[0]', 'norm_temp[0]', \\r\\n # 'flat_%s_%s.fits' % (side, aperture), interactive=\\\"no\\\")\\r\\n os.rename('temp.fits', 'raw_flat_%s_%s.fits' % (side, aperture))\\r\\n # iraf.unlearn('response')\\r\\n # iraf.response.function = \\\"spline3\\\"\\r\\n # iraf.response.order = 100\\r\\n # iraf.response.niterate = 3\\r\\n # iraf.response.low_rej = 3\\r\\n # iraf.response.high_rej = 3\\r\\n # if side == 'blue':\\r\\n # iraf.twodspec.longslit.dispaxis = 2\\r\\n # else:\\r\\n # iraf.twodspec.longslit.dispaxis = 1\\r\\n \\r\\n\\r\\n # measure flat-field error from sigma images\\r\\n iraf.unlearn('imcombine')\\r\\n iraf.imcombine.reject = 'avsigclip'\\r\\n iraf.imcombine(','.join(flats), output='flat', sigma='sigma', scale='mode')\\r\\n iraf.imarith('sigma', '/', 'flat', 'frac')\\r\\n s = iraf.imstat('frac.fits', fields=\\\"mean\\\", nclip=20, Stdout=1, format=\\\"no\\\")\\r\\n print 'Flat field error: ', np.float(s[0])\\r\\n iraf.delete('flat.fits', verify=\\\"no\\\")\\r\\n iraf.delete('sigma.fits', verify=\\\"no\\\")\\r\\n iraf.delete('frac.fits', verify=\\\"no\\\")\\r\\n else:\\r\\n print \\\"No dome or internal flats for the %s arcsec slit.\\\" % aperture\",\n \"def step7(self):\\n for indx, mr in enumerate(self.mrs):\\n self.log.info(\\\"Set boot drive on controller:%d\\\"\\n % (mr.ctrl_id))\\n for vd in self.mr_vds[indx]:\\n if (int(mr.cli.bootdrive_vd_get()) != vd):\\n mr.cli.bootdrive_vd_set(vd_id=self.mr_vds[indx][indx],\\n setting=\\\"On\\\")\\n break\",\n \"def main():\\n print_banner()\\n params = read_steering()\\n s, x, y, cur, theta = build_kinoshita()\\n s, x, y, cur, theta = read_centerline(s, x, y, cur, theta)\\n s, x, y, cur, theta = extend_centerline(s, x, y, cur, theta)\\n for t in range(TSTEPS+1):\\n cur, theta = tan2curv(s, x, y)\\n cur_ori = np.copy(cur)\\n cur = filter_curvature(cur, t)\\n cur_flt = np.copy(cur)\\n cur = lag(s, cur, t)\\n cur_lag = np.copy(cur)\\n beck_bed = build_beck(cur, s, t)\\n allxyz = offset_all(x, y, beck_bed, t)\\n if t == 0:\\n write_xyz_file(allxyz)\\n write_mesh_file(allxyz, beck_bed)\\n oxbowxList, oxbowyList = [], []\\n centerlinexList, centerlineyList = [], []\\n if np.mod(t, GPRINT) == 0:\\n centerlinexList.append(x)\\n centerlineyList.append(y)\\n mf.make_figure(x, y, allxyz, cur_ori, cur_flt, cur_lag, s, beck_bed,\\n params, t, oxbowxList, oxbowyList, centerlinexList, centerlineyList)\\n if t == TSTEPS:\\n break\\n s, x, y = migration(s, x, y, cur_flt, cur_lag, theta, t)\\n s, x, y, oxbowx, oxbowy, found_cutoff = cutoff(s, x, y)\\n s, x, y = smooth_centerline(x, y)\\n s, x, y, cur, theta = resample_centerline(s, x, y)\\n if found_cutoff:\\n oxbowxList.append(oxbowx)\\n oxbowyList.append(oxbowy)\\n make_gif()\\n job_done()\",\n \"def fire_smelter(self):\\n # Get the smelter\\n screenshot = utils.take_screenshot()\\n forge = screenshot[152:168, 168:184]\\n\\n # Check if the cold forge exists\\n result = cv2.matchTemplate(forge, self.cold_forge_template, cv2.TM_CCORR_NORMED)\\n max_val = cv2.minMaxLoc(result)[1]\\n\\n # Found cold forge, light it and wait\\n if max_val > 0.9:\\n pyautogui.moveTo(192, 159, 0.15)\\n pyautogui.doubleClick()\\n sleep(1.5)\",\n \"def _clean_files(self):\\n if self.delfiles & 1:\\n ProcUtils.remove(self.okm)\\n if self.delfiles & 2:\\n ProcUtils.remove(self.hkm)\\n if self.delfiles & 4:\\n ProcUtils.remove(self.qkm)\\n if self.delfiles & 8:\\n ProcUtils.remove(self.obc)\\n\\n if self.log is False:\\n ProcUtils.remove(self.pcf_file)\\n base = os.path.basename(self.okm)\\n ProcUtils.remove(os.path.join(self.dirs['run'],\\n '.'.join(['LogReport', base])))\\n ProcUtils.remove(os.path.join(self.dirs['run'],\\n '.'.join(['LogStatus', base])))\\n ProcUtils.remove(os.path.join(self.dirs['run'],\\n '.'.join(['LogUser', base])))\",\n \"def _sweepDir(self, f):\\n lastCellFaceVal = np.zeros((self.cells[0].nG, self.cells[0].sNords))\\n if f == 2:\\n cellList = reversed(self.cells)\\n else:\\n cellList = self.cells\\n blowoff = False\\n for cell in cellList:\\n if hasattr(cell, 'boundaryCond') and not blowoff:\\n cell.applyBC(self.depth)\\n blowoff = True\\n else:\\n # Interior cell\\n cell.ordFlux[:, f, :] = lastCellFaceVal[:, :]\\n # Only sweep through ordinates that have a component in same direction as\\n # current sweep dir.\\n dotDir = cell.sNmu * cell.faceNormals[f - 1]\\n ordsInSweepDir = np.where(dotDir < 0.)\\n for o in np.arange(cell.sNords)[ordsInSweepDir]:\\n cell.ordFlux[:, 0, o] = (cell.ordFlux[:, f, o] + self.deltaX * cell.qin[:, 0, o] / (2. * np.abs(cell.sNmu[o]))) / \\\\\\n (1. + self.totalXs * self.deltaX / (2. * np.abs(cell.sNmu[o])))\\n if f == 1:\\n cell.ordFlux[:, 2, o] = 2. * cell.ordFlux[:, 0, o] - cell.ordFlux[:, f, o]\\n lastCellFaceVal[:, o] = cell.ordFlux[:, 2, o]\\n elif f == 2:\\n cell.ordFlux[:, 1, o] = 2. * cell.ordFlux[:, 0, o] - cell.ordFlux[:, f, o]\\n lastCellFaceVal[:, o] = cell.ordFlux[:, 1, o]\\n if np.any(cell.ordFlux[:, :, :] < 0.0):\\n #print(\\\"WARNING: Negative flux detected! Refine mesh.\\\")\\n maxStepSize = 2. * np.min(np.abs(cell.sNmu)) * min(1. / self.totalXs)\\n #print(\\\"Max Step size in 1D: \\\" + str(maxStepSize))\\n # refineFactor = 2. # TODO: compute refinement factor on the fly\\n #raise Exception('coarse', refineFactor)\",\n \"def effect(self):\\n # Get script's \\\"--what\\\" option value.\\n what = self.options.what / 10.\\n negative_kerf = False\\n if what < 0.:\\n what = -what\\n negative_kerf = True\\n\\n kerf_in_mm = self.unittouu(str(what) + \\\" mm\\\")\\n\\n operation_list = [\\\"StrokeToPath\\\", \\\"SelectionUnion\\\",\\n \\\"SelectionBreakApart\\\", \\\"SelectionUnion\\\", \\\"SelectionBreakApart\\\"]\\n if negative_kerf:\\n operation_list[-2] = \\\"SelectionIntersect\\\"\\n\\n join_ext = metaext.MetaEffect(operation_list)\\n\\n if not self.set_appropriate_width(kerf_in_mm):\\n objectify = metaext.MetaEffect([\\\"ObjectToPath\\\"])\\n objectify.effect(self.document, self.selected, self.doc_ids)\\n if not self.set_appropriate_width(kerf_in_mm):\\n inkex.error(\\\"Didn't found any selected path, breaking\\\")\\n return\\n \\n join_ext.effect(self.document, self.selected, self.doc_ids)\\n\\n for _, node in self.selected.iteritems():\\n #inkex.debug(\\\"node %s\\\" % inkex.etree.tostring(node))\\n if node.tag == inkex.addNS('path', 'svg'):\\n new_width = self.unittouu(\\\"0.5mm\\\")\\n colour = '#ff0000' if negative_kerf else '#000000'\\n style = {'stroke-width': new_width, 'fill': 'none',\\n 'stroke': colour}\\n style = simplestyle.formatStyle(style)\\n node.set('style', style)\\n # inkex.debug(\\\"node %s\\\" % inkex.etree.tostring(node))\",\n \"def skywalker(this, **kargs):\\n\\t\\t\\n\\t\\t# Arguments\\n\\t\\tbin = kargs.get('bin', this._BINARY)\\n\\t\\toffshore = kargs.get('offshore', 5)\\n\\t\\tminSize = kargs.get('minSize', 3)\\n\\t\\tblur = kargs.get('blur', False)\\n\\t\\t\\n\\t\\tif blur: # Flou de test\\n\\t\\t\\tkernel = np.ones((3, 3), np.float32)/9\\n\\t\\t\\tbin = cv2.filter2D(bin, -1, kernel)\\n\\t\\t\\n\\t\\t# On duplique l'image pour le rendu final\\n\\t\\tscan = EmptyFrom(bin, 3)\\n\\t\\tscan[:,:,0] = scan[:,:,1] = scan[:,:,2] = bin\\n\\t\\tthis._SCAN = scan\\n\\t\\t\\n\\t\\tstep = 0 # Compteur de pas dans le vide\\n\\t\\tstart, end = None, None\\n\\t\\t\\n\\t\\t# Dimensions de l'image à scanner\\n\\t\\tsize = D2Point(width(bin), height(bin))\\n\\t\\tratio = size if minSize < 1 else 1\\n\\t\\t\\n\\t\\t# Scan pixel par pixel, en partant du bas\\n\\t\\tfor v in xrange(int(size.y)-1, -1, -1):\\n\\t\\t\\tfor u in xrange(int(size.x)):\\n\\t\\t\\t\\n\\t\\t\\t\\tif bin.item((v, u)): # Si un pixel != 0:\\n\\t\\t\\t\\t\\tscan[v,u] = [0, 0, 255] # Rouge.\\n\\t\\t\\t\\t\\tstep = 0 # On reset le jump\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t# Si c'est le premier\\n\\t\\t\\t\\t\\tif not start:\\n\\t\\t\\t\\t\\t\\tstart = D2Point(u, v)\\n\\t\\t\\t\\t\\t\\tend = D2Point(u, v)\\n\\t\\t\\t\\t\\telse: # On trace\\n\\t\\t\\t\\t\\t\\tend.x, end.y = u, v\\n\\t\\t\\t\\t\\n\\t\\t\\t\\telif end:\\n\\t\\t\\t\\t\\tif step < offshore:\\n\\t\\t\\t\\t\\t\\tscan[v,u] = [0, 255, 255] # Jaune\\n\\t\\t\\t\\t\\t\\tstep += 1 # On continue\\n\\t\\t\\t\\t\\telif abs((start - end)/ratio) < minSize:\\n\\t\\t\\t\\t\\t\\tstart, end = None, None\\n\\t\\t\\t\\t\\telse: break\\n\\t\\t\\t\\t# elif end: break\\n\\t\\t\\t###\\n\\t\\t\\tif end: break\\n\\t\\t###\\n\\t\\t\\n\\t\\tif end: # Si on a trouvé une fin\\n\\t\\t\\t\\n\\t\\t\\t# Point médian = doigt\\n\\t\\t\\tresult = start % end\\n\\t\\t\\t\\n\\t\\t\\t# Visuel\\n\\t\\t\\tscan[:,result.x,:] = [0, 255, 0] # On trace une bande verte\\n\\t\\t\\tscan[result.y,:,:] = [0, 127, 0] # On trace une autre bande verte\\n\\t\\t\\t\\n\\t\\t\\t# Reformatage\\n\\t\\t\\tresult /= size-1 # On remet en ratio d'image\\n\\t\\t\\tresult.x = 1 - result.x # On inverse le côté de mesure\\n\\t\\t\\t\\n\\t\\t\\t# Stockage\\n\\t\\t\\tthis._DETECTED = result # On stocke le point détecté\\n\\t\\t\\tthis._BOTTOM = result.y == 1 # On clic ou bien ?\\n\\t\\t\\n\\t\\t# Si rien\\n\\t\\telse:\\n\\t\\t\\tresult = None\\n\\t\\t\\tthis._BOTTOM = False\\n\\t\\t\\n\\t\\t# Tchao\\n\\t\\treturn result\",\n \"def watershed(self, debug=False):\\n kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\\n opening = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_OPEN, kernel, iterations=2)\\n sure_bg = cv2.dilate(self.th[:, :, 0], kernel, iterations=3)\\n dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)\\n ret, sure_fg = cv2.threshold(dist_transform, 0.1 * dist_transform.max(), 255, 0)\\n sure_fg = np.uint8(sure_fg)\\n unknown = cv2.subtract(sure_bg, sure_fg)\\n ret, markers = cv2.connectedComponents(sure_fg)\\n markers += 1\\n markers[unknown == 255] = 0\\n markers = cv2.watershed(self.img, markers)\\n self.add_color(markers)\\n if debug:\\n cv2.imshow(\\\"fg\\\", unknown)\\n cv2.imshow(\\\"op\\\", opening)\\n cv2.imshow(\\\"o3\\\", sure_bg)\",\n \"def farm(w,h,status='harvest',loops=1):\\n h1 = int(h/2) # var to get seeds from first half (or fewer) of rows\\n food_key = 5 # hotbar key for food\\n dirt_place_time = 4.5\\n walk_time = 0.33\\n wait_time = 0.7\\n grow_time = 540 # time for plants to grow = 600s - (time to log out & in) \\n \\n ctrl.resetCamera('down')\\n for loop in range(loops):\\n for y in range(h):\\n for x in range(w):\\n # checks if char is hungry before moving, & eats food on food_key\\n if img_obj.isHungry():\\n ctrl.eatFood(key=food_key)\\n if status == 'harvest':\\n # picks up farm patch, loot seeds, places farm patch, continues \\n if y < h1: \\n ctrl.selectOption('down')\\n time.sleep(dirt_place_time) # takes 3 sec + more time due to server lag\\n ctrl.selectOption('right')\\n ctrl.loot() \\n \\n ctrl.walk('down', walk_time * 2, jump=True)\\n ctrl.selectOption('down')\\n ctrl.clickLMB()\\n time.sleep(dirt_place_time)\\n \\n ctrl.walk('up', walk_time, jump=True)\\n \\n else:\\n ctrl.selectOption('right')\\n for i in range(12): # takes 5 seconds to harvest, in 6 seconds, f key is pressed 12 times\\n ctrl.loot()\\n time.sleep(.5)\\n \\n time.sleep(wait_time) # delay to make sure it jumps to the next patch\\n # plants seeds - assumes char is holding seeds\\n ctrl.selectOption('right')\\n for i in range(12): # takes 5 seconds to harvest, in 5.5 seconds, f key is pressed 11 times\\n ctrl.loot()\\n time.sleep(.5)\\n time.sleep(wait_time)\\n \\n # moves char to next farm patch\\n if x != (w-1): # if not on last farm patch of row\\n if y % 2 == 0:\\n direction = 'left'\\n else:\\n direction = 'right'\\n ctrl.walk(direction, walk_time, jump=True)\\n time.sleep(wait_time) # delay for server lag\\n \\n # moves char up to next row if not on last row\\n if y != (h-1):\\n ctrl.walk('up', walk_time, jump=True)\\n \\n # final loot loop to get remaining items\\n # for i in range(10):\\n # ctrl.loot()\\n # time.sleep(.5)\\n \\n # returns char to bottom right farm patch\\n if (h) % 2 != 0: # if height is odd, move char to right side\\n for x in range(w-1):\\n ctrl.walk('right', walk_time, jump=True)\\n time.sleep(wait_time)\\n for y in range(h-1):\\n ctrl.walk('down', walk_time * 2, jump=True)\\n time.sleep(wait_time)\\n \\n # returns to lobby, waits for plants to grow, logs in\\n ctrl.returnToLobby()\\n time.sleep(grow_time)\\n ctrl.enterGame()\\n # resets camera to be aligned facing North as camera will always be pointed North after logging in\\n ctrl.walk('up', .1, jump=True) \\n time.sleep(wait_time)\\n ctrl.walk('down', .1, jump=True)\\n \\n ctrl.resetCamera('down')\\n # when relogging, char is displaced sometimes, this checks if field is selected, if not it'll try to find it, if that fails the program exits\\n if not (img_obj.checkObjTitle('field')):\\n ctrl.walk('left', walk_time, jump=True)\\n if not (img_obj.checkObjTitle('field')):\\n ctrl.walk('up', walk_time, jump=True)\\n if not (img_obj.checkObjTitle('field')):\\n break\",\n \"def test_f2_circuit_maker(self):\\n fho = tfho.test_file_handle_object()\\n W = 5\\n G = 20\\n fg = .9\\n X = 10\\n fx = .85\\n gate_maker = g.TYPE_TO_GATE_GEN[g.TEST_TYPES.RANDOM]\\n # family 2 files:\\n t_circuit_file_name = \\\"circuit_file_trimming\\\"\\n t_circuit_file = fho.get_file_object(t_circuit_file_name, 'w')\\n t_input_file_name = \\\"input_file_trimming\\\"\\n t_input_file = fho.get_file_object(t_input_file_name, 'w')\\n t_output_file_name = \\\"output_file_trimming\\\"\\n t_output_file = fho.get_file_object(t_output_file_name, 'w')\\n nt_circuit_file_name = \\\"circuit_file_no_trimming\\\"\\n nt_circuit_file = fho.get_file_object(nt_circuit_file_name, 'w')\\n nt_input_file_name = \\\"input_file_no_trimming\\\"\\n nt_input_file = fho.get_file_object(nt_input_file_name, 'w')\\n nt_output_file_name = \\\"output_file_no_trimming\\\"\\n nt_output_file = fho.get_file_object(nt_output_file_name, 'w')\\n level_type_array = [g.LEVEL_TYPES.XOR, g.LEVEL_TYPES.RANDOM,\\n g.LEVEL_TYPES.XOR]\\n F = 2\\n # make a family 1 circuit with trimming:\\n sr.seed(self.rand_seed)\\n t_gen = g.f1f2_circuit_maker_with_trimming_switch(W, G, fg,\\n t_circuit_file,\\n t_input_file,\\n t_output_file,\\n X, fx, gate_maker,\\n level_type_array, True)\\n t_gen.generate()\\n # make a family 1 circuit without trimming, with the same randomness:\\n sr.seed(self.rand_seed)\\n nt_gen = g.f1f2_circuit_maker_with_trimming_switch(W, G, fg,\\n nt_circuit_file,\\n nt_input_file,\\n nt_output_file,\\n X, fx, gate_maker,\\n level_type_array, False)\\n nt_gen.generate()\\n # obtain strings representing the contents of all the resulting files:\\n t_circuit_string = fho.get_file(t_circuit_file_name).getvalue()\\n t_input_string = fho.get_file(t_input_file_name).getvalue()\\n t_output_string = fho.get_file(t_output_file_name).getvalue()\\n nt_circuit_string = fho.get_file(nt_circuit_file_name).getvalue()\\n nt_input_string = fho.get_file(nt_input_file_name).getvalue()\\n nt_output_string = fho.get_file(nt_output_file_name).getvalue()\\n # make sure that the inputs and outputs produced by the trimming and\\n # no trimming algorithms are the same:\\n self.assertEqual(t_input_string, nt_input_string)\\n self.assertEqual(t_output_string, nt_output_string)\\n # make sure that the input begins and ends with a bracket:\\n self.assertEqual(\\\"[\\\", t_input_string[0])\\n self.assertEqual(\\\"]\\\", t_input_string[-1])\\n # make sure that each input element is a bit:\\n for bit in t_input_string[1:-1]:\\n self.assertTrue((bit == '0') or (bit == '1'))\\n # make sure that the output is a bit:\\n self.assertTrue((t_output_string == '0') or (t_output_string == '1'))\\n # make sure that the two circuit headers are the same, and that they\\n # contain the correct values:\\n t_circuit_header = t_circuit_string.split(\\\"\\\\n\\\")[0]\\n nt_circuit_header = nt_circuit_string.split(\\\"\\\\n\\\")[0]\\n self.assertEqual(t_circuit_header, nt_circuit_header)\\n (W_string, G_string, X_string, F_string) = t_circuit_header.split(\\\",\\\")\\n W_value = int(W_string.split(\\\"=\\\")[-1])\\n G_value = int(G_string.split(\\\"=\\\")[-1])\\n X_value = int(X_string.split(\\\"=\\\")[-1])\\n F_value = int(F_string.split(\\\"=\\\")[-1])\\n self.assertEqual(W, W_value)\\n self.assertEqual(G, G_value)\\n self.assertEqual(F, F_value)\\n # note that we cannot test that the circuits themselves are the same,\\n # because the trimming algorithm produces a circuit with gates listed\\n # in a different order.\",\n \"def clean_morphs():\\n blendshapes = cmds.ls(type=\\\"blendShape\\\")\\n for blendShape in blendshapes:\\n blend_target_list = cmds.listAttr(blendShape + '.w', m=True)\\n\\n for blend_target in blend_target_list:\\n bs_fixed = blend_target.replace(\\\"head__eCTRL\\\", \\\"\\\")\\n if (bs_fixed.find(\\\"__\\\") > 1):\\n bs_split = bs_fixed.split(\\\"__\\\")\\n bs_fixed = bs_fixed.replace(bs_split[0]+\\\"__\\\", \\\"\\\")\\n bs_fixed = bs_fixed.replace(\\\"headInner__\\\", \\\"\\\")\\n bs_fixed = bs_fixed.replace(\\\"head_eCTRL\\\", \\\"\\\")\\n bs_fixed = bs_fixed.replace(\\\"head__\\\", \\\"\\\")\\n bs_fixed = bs_fixed.replace(\\\"head_\\\", \\\"\\\")\\n bs_fixed = bs_fixed.replace(\\\"PHM\\\", \\\"\\\")\\n bs_fixed = bs_fixed.replace(\\\"CTRL\\\", \\\"\\\")\\n bs_fixed = bs_fixed.replace(\\\"QT1\\\", \\\"\\\")\\n bs_fixed = bs_fixed.replace(\\\"Shape\\\", \\\"\\\")\\n\\n oldMorph = blendShape + \\\".\\\" + blend_target\\n try:\\n # Rename Morphs (Blendshapes)\\n cmds.aliasAttr(bs_fixed, oldMorph)\\n except:\\n pass\",\n \"def on_run(self):\\n self.set_illumination({'mode': 'breathe'})\",\n \"def disarm(self):\\n pass\",\n \"def other_wakes(self, current, *turbines):\\r\\n \\\"\\\"\\\" EXECUTE THIS FUNCTION IN THE FARM CLASS! \\\"\\\"\\\"\\r\\n self.nodisplacements = []\\r\\n self.procedures = []\\r\\n \\r\\n # blockage matrices:\\r\\n self.bn = []\\r\\n self.bt = []\\r\\n \\r\\n for i, turbine in enumerate(turbines):\\r\\n # append the own wake matrices when the current turbine is \\r\\n # compared to itself:\\r\\n \\r\\n if i == current:\\r\\n self.bn.append(Turbine.wn)\\r\\n self.bt.append(Turbine.wt)\\r\\n elif i != current:\\r\\n # it is shadowed when at least one control point of the current\\r\\n # turbine lies in the direct wake of the i-th turbine.\\r\\n self.shadowed = np.any((self.yi[i]>=-1) & (self.yi[i]<=1))\\r\\n self.behind = self.x0 > turbine.x0\\r\\n \\r\\n if (self.shadowed and self.behind):\\r\\n # compute obstruction matrices:\\r\\n self.set_templates(self.yi[i])\\r\\n self.offset_templates(i, turbine)\\r\\n \\r\\n # offsetted block matrices are appended to the list:\\r\\n self.bn.append(self.newQn)\\r\\n self.bt.append(self.newQt)\\r\\n else:\\r\\n # add empty blockage matrices if there is no obstruction:\\r\\n self.bn.append(np.copy(Turbine.zeros))\\r\\n self.bt.append(np.copy(Turbine.zeros))\",\n \"def skimmer(bigCut, skimLoc, wsOut):\\n\\tprint \\\"Cutting on: \\\\n\\\",bigCut\\n\\n\\tskim = TChain(\\\"skimTree\\\")\\n\\tskim.Add(skimLoc)\\n\\tlib.SetTreeInputs(skim, lib.skimDict)\\n\\n\\tskim.SetEntryList(0)\\n\\tskim.Draw(\\\">>elist\\\", bigCut, \\\"entrylist\\\")\\n\\telist = gDirectory.Get(\\\"elist\\\")\\n\\tprint \\\"Found \\\",elist.GetN(),\\\" skim file entries.\\\"\\n\\tskim.SetEntryList(elist)\\n\\n\\tds = GATDataSet()\\n\\twb = GATWaveformBrowser()\\n\\tds = wb.LoadSkimWaveforms(skim, bigCut)\\n\\tprint \\\"Found \\\",wb.GetNWaveforms(),\\\" waveforms.\\\"\\n\\n\\tgat = ds.GetGatifiedChain()\\n\\tlib.SetTreeInputs(gat, lib.gatDict)\\n\\n\\tbuilt = ds.GetBuiltChain()\\n\\tlib.SetTreeInputs(built, lib.builtDict)\\n\\n\\tout = TFile(wsOut,\\\"RECREATE\\\")\\n\\n\\twaveTree = TTree(\\\"waveTree\\\",\\\"wave-skim single waveforms\\\")\\n\\tenf = np.zeros(1,dtype=float)\\n\\tt50 = np.zeros(1,dtype=float)\\n\\trunTime = np.zeros(1,dtype=float)\\n\\tgatEnt, gatHit, skimEnt, builtEnt, eventTreeEntry, chn = 0., 0., 0., 0., 0., 0.\\n\\twf = MGTWaveform()\\n\\twaveTree.Branch(\\\"gatEnt\\\",long(gatEnt),\\\"gatEnt/L\\\")\\n\\twaveTree.Branch(\\\"gatHit\\\",long(gatHit),\\\"gatHit/L\\\")\\n\\twaveTree.Branch(\\\"builtEnt\\\",long(builtEnt),\\\"builtEnt/L\\\")\\n\\twaveTree.Branch(\\\"skimEnt\\\",long(skimEnt),\\\"skimEnt/L\\\")\\n\\twaveTree.Branch(\\\"eventTreeEntry\\\",long(eventTreeEntry),\\\"eventTreeEntry/L\\\")\\n\\twaveTree.Branch(\\\"waveform\\\",wf)\\n\\twaveTree.Branch(\\\"channel\\\",int(chn),\\\"channel/I\\\")\\n\\twaveTree.Branch(\\\"trapENFCal\\\",enf,\\\"trapENFCal/D\\\")\\n\\twaveTree.Branch(\\\"blrwfFMR50\\\",t50,\\\"blrwfFMR50/D\\\")\\n\\twaveTree.Branch(\\\"runTime\\\",runTime,\\\"runTime/D\\\")\\n\\n\\t# save the entry numbers for the full event tree\\n\\tEntryList = []\\n\\n\\t# fill waveTree\\n\\tlastEvent = 0\\n\\teventTreeEntry = -1\\n\\teventMismatchCount = 0\\n\\twfMismatchCount = 0\\n\\tfor waveNum in xrange(wb.GetNWaveforms()):\\n\\n\\t\\tgatEnt = wb.GetEntryNumber(waveNum)\\n\\t\\tgatHit = wb.GetIterationNumber(waveNum)\\n\\t\\tgat.GetEntry(gatEnt)\\n\\t\\tbuilt.GetEntry(gatEnt)\\n\\t\\tbuiltEnt = built.GetEntryNumber(gatEnt)\\n\\t\\tskimEnt = 0\\n\\t\\tfor ientry in xrange(elist.GetN()):\\n\\t\\t\\tentryNumber = skim.GetEntryNumber(ientry)\\n\\t\\t\\tskim.LoadTree( entryNumber )\\n\\t\\t\\tskim.GetEntry( entryNumber )\\n\\t\\t\\t# gat.LoadTree returns the entry number of the original tree\\n\\t\\t\\tif skim.iEvent==gat.LoadTree(gatEnt):\\n\\t\\t\\t\\tskimEnt = entryNumber\\n\\t\\t\\t\\tbreak\\n\\t\\tskim.GetEntry(skimEnt)\\n\\n\\t\\tif abs(lib.timestamp.at(0)/1E8 - lib.s_tloc_s[0]) > 0.001:\\n\\t\\t\\tprint \\\"waveform\\\",waveNum,\\\": mismatched events!\\\"\\n\\t\\t\\teventMismatchCount += 1\\n\\t\\t\\tprint \\\"skim - run %d enf.at(0) %.3f enf.size %d time %.2f\\\" % (lib.s_run[0], lib.s_trapENFCal.at(0), lib.s_trapENFCal.size(), lib.s_tloc_s[0])\\n\\t\\t\\tprint \\\"gat - run %d enf.at(0) %.3f enf.size %d time %.2f\\\\n\\\" % (lib.run[0], lib.trapENFCal.at(0), lib.trapENFCal.size(), lib.timestamp.at(0)/1E8)\\n\\t\\t\\tcontinue\\n\\n\\t\\t# output some physics\\n\\t\\twf = wb.GetWaveform(waveNum)\\n\\n\\t\\tnullchk = str(wf)\\n\\t\\tif \\\"nil\\\" in nullchk:\\n\\t\\t\\tprint \\\"waveform\\\",waveNum,\\\",iteration \\\",gatHit,\\\": unexpected number of waveforms ...\\\"\\n\\t\\t\\twfMismatchCount +=1\\n\\t\\t\\tprint \\\"skim - run %d enf.at(0) %.3f enf.size %d time %.2f\\\" % (lib.s_run[0], lib.s_trapENFCal.at(0), lib.s_trapENFCal.size(), lib.s_tloc_s[0])\\n\\t\\t\\tprint \\\"gat - run %d enf.at(0) %.3f enf.size %d time %.2f\\\\n\\\" % (lib.run[0], lib.trapENFCal.at(0), lib.trapENFCal.size(), lib.timestamp.at(0)/1E8)\\n\\t\\t\\tcontinue\\n\\n\\t\\tchn = lib.channel.at(gatHit)\\n\\t\\tenf[0] = lib.trapENFCal.at(gatHit)\\n\\t\\tt50[0] = lib.blrwfFMR50.at(gatHit)\\n\\t\\trunTime[0] = lib.timestamp.at(gatHit)/1E8\\n\\n\\t\\t# so you can match waveTree to eventTree\\n\\t\\tif lastEvent != gatEnt:\\n\\t\\t\\teventTreeEntry += 1\\n\\t\\t\\tEntryList.append([gatEnt,skimEnt])\\n\\n\\t\\twaveTree.Fill()\\n\\n\\t\\tlastEvent = gatEnt\\n\\n\\tprint \\\"\\\\nDone. For %d waveforms:\\\" % wb.GetNWaveforms()\\n\\tprint \\\"\\\\t%d had mismatched gat/skim events based on timestamp differences (and were skipped)\\\" % eventMismatchCount\\n\\tprint \\\"\\\\t%d had fewer wf's than expected in the built data (and were skipped).\\\" % wfMismatchCount\\n\\n\\twaveTree.Write()\\n\\n\\t# now fill the full event tree by looping over EntryList\\n\\tprint \\\"\\\\n filling full event tree ...\\\\n\\\"\\n\\teventTree = TTree(\\\"eventTree\\\",\\\"wave-skim full output\\\")\\n\\toutDict = lib.CreateOutputDict('all')\\n\\tlib.SetTreeOutputs(eventTree, outDict)\\n\\n\\tfor i in EntryList:\\n\\t\\tgatEntry = i[0]\\n\\t\\tskimEntry = i[1]\\n\\n\\t\\tgat.GetEntry(gatEntry)\\n\\t\\tbuilt.GetEntry(gatEntry)\\n\\t\\tskim.GetEntry(skimEntry)\\n\\n\\t\\t# verify we get the same output as before\\n\\t\\t# print \\\"skim - run %d enf-0 %.3f size %d time %.2f\\\" % (lib.s_run[0],lib.s_trapENFCal.at(0),lib.s_trapENFCal.size(),lib.s_tloc_s[0])\\n\\t\\t# print \\\"gat - run %d enf-0 %.3f size %d time %.2f\\\\n\\\" % (lib.run[0],lib.trapENFCal.at(0),lib.trapENFCal.size(),lib.timestamp.at(0)/1E8)\\n\\n\\t\\teventTree.Fill()\\n\\n\\teventTree.Write()\\n\\tout.Close()\",\n \"def stop_step_sweep(self):\\n self.write(\\\":SOUR:SWE:CONT:STAT OFF\\\")\",\n \"def teleopPeriodic(self):\\n self.drive.arcadeDrive(1, 0)\\n self.brushless.set(1)\\n self.spark.set(self.joystick.getY())\",\n \"def _guider_flat_apogeeShutter(self, nCall, nInfo, nWarn, nErr, finish=False, didFail=False):\\n cmdState = self.actorState.gotoField\\n cmdState.reinitialize(self.cmd)\\n result = masterThread.guider_flat(\\n self.cmd, cmdState, myGlobals.actorState, 'guider', apogeeShutter=True)\\n self.assertEqual(result, not didFail)\\n self._check_cmd(nCall, nInfo, nWarn, nErr, finish, didFail=didFail)\",\n \"def remove_events(self):\\n tofiltercalibfnames1, tofiltercalibfnames2 = split_into_telescopes(self.tofiltercalibfnames)\\n\\n nameiter = tqdm(self.superstarmcolfnames)\\n for ssmcolfname in nameiter:\\n nameiter.set_description(f\\\"Processing {path.basename(ssmcolfname)}\\\")\\n currentrun = get_run(ssmcolfname)\\n ssmcoldf = pd.read_csv(ssmcolfname, index_col=False)\\n # newfname1 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames1, self.m1sscols)\\n # newfname2 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames2, self.m2sscols)\\n # if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\\n # os.remove(newfname1)\\n # os.remove(newfname2)\\n # continue\\n tofiltercalibdf1, oldname1 = self._merge_subruns(tofiltercalibfnames1,\\n currentrun, getoldname=True)\\n tofiltercalibdf2, oldname2 = self._merge_subruns(tofiltercalibfnames2,\\n currentrun, getoldname=True)\\n if len(tofiltercalibdf1) == 0:\\n logger.warning(f\\\"calibfiles already processed, skipping {path.basename(ssmcolfname)} current run: {currentrun} \\\\n\\\")\\n continue\\n\\n filtermask1 = self.get_filtermask(tofiltercalibdf1.iloc[:, self.mcolidx], ssmcoldf[self.m1sscols])\\n filtermask2 = self.get_filtermask(tofiltercalibdf2.iloc[:, self.mcolidx], ssmcoldf[self.m2sscols])\\n if self.invert is False:\\n filtermask1, tofiltercalibdf1 = self.fix_idiosyncracies(filtermask1, tofiltercalibdf1, ssmcoldf[self.m1sscols])\\n filtermask2, tofiltercalibdf2 = self.fix_idiosyncracies(filtermask2, tofiltercalibdf2, ssmcoldf[self.m2sscols])\\n\\n if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\\n continue\\n\\n newfname1 = self._get_newfilename(oldname=oldname1)\\n newfname2 = self._get_newfilename(oldname=oldname2)\\n\\n nameiter.set_description(f\\\"Saving {path.basename(newfname1)}\\\")\\n tofiltercalibdf1.iloc[filtermask1].to_csv(newfname1, header=False, index=False)\\n nameiter.set_description(f\\\"Saving {path.basename(newfname2)}\\\")\\n tofiltercalibdf2.iloc[filtermask2].to_csv(newfname2, header=False, index=False)\\n self.outfilenames.extend([newfname1, newfname2])\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun))\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun))\",\n \"def runCalFlat(lst, hband=False, darkLst=None, rootFolder='', nlCoef=None, satCounts=None, BPM=None, distMapLimitsFile='', plot=True, nChannel=32, nRowsAvg=0,rowSplit=1,nlSplit=32, combSplit=32,bpmCorRng=100, crReject=False, skipObsinfo=False,winRng=51, polyFitDegree=3, imgSmth=5,nlFile='',bpmFile='', satFile='',darkFile='',flatCutOff=0.1,flatSmooth=0, logfile=None, gain=1., ron=None, dispAxis=0,limSmth=20, ask=True, obsCoords=None,satSplit=32, centGuess=None, flatCor=False, flatCorFile=''):\\n\\n colorama.init()\\n \\n plt.ioff()\\n\\n t0 = time.time()\\n \\n #create processed directory, in case it doesn't exist\\n wifisIO.createDir('processed')\\n wifisIO.createDir('quality_control')\\n\\n if hband:\\n print('*** WORKING ON H-BAND DATA ***')\\n \\n #create processed directory, in case it doesn't exist\\n wifisIO.createDir('processed')\\n\\n if (plot):\\n wifisIO.createDir('quality_control')\\n\\n procFlux = []\\n procSigma = []\\n procSatFrame = []\\n\\n #go through list and process each file individually\\n #************\\n #eventually need to add capability to create master flat from groups\\n #************\\n\\n for lstNum in range(len(lst)):\\n if (lst.ndim>1):\\n folder = lst[lstNum,0]\\n else:\\n folder = lst[lstNum]\\n\\n t1 = time.time()\\n\\n savename = 'processed/'+folder\\n\\n #first check master flat and limits exists\\n \\n if(os.path.exists(savename+'_flat.fits') and os.path.exists(savename+'_flat_limits.fits') and os.path.exists(savename+'_flat_slices.fits') and os.path.exists(savename+'_flat_slices_norm.fits')):\\n cont = 'n'\\n if ask:\\n cont = wifisIO.userInput('All processed flat field files already exists for ' +folder+', do you want to continue processing (y/n)?')\\n else:\\n cont = 'y'\\n \\n if (cont.lower() == 'y'):\\n print('*** Working on folder ' + folder + ' ***')\\n\\n if (os.path.exists(savename+'_flat.fits')):\\n cont = 'n'\\n cont = wifisIO.userInput('Processed flat field file already exists for ' +folder+', do you want to continue processing (y/n)?')\\n \\n if (not cont.lower() == 'y'):\\n print('Reading image '+savename+'_flat.fits instead')\\n flatImgs, hdr= wifisIO.readImgsFromFile(savename+'_flat.fits')\\n flatImg, sigmaImg, satFrame = flatImgs\\n if (type(hdr) is list):\\n hdr = hdr[0]\\n contProc2=False\\n else:\\n contProc2=True\\n else:\\n contProc2=True\\n \\n if contProc2:\\n flatImg, sigmaImg, satFrame, hdr = processRamp.auto(folder, rootFolder,savename+'_flat.fits', satCounts, nlCoef, BPM, nChannel=nChannel, rowSplit=rowSplit, nlSplit=nlSplit, combSplit=combSplit, crReject=crReject, bpmCorRng=bpmCorRng, skipObsinfo=skipObsinfo, nRows=nRowsAvg, rampNum=None, nlFile=nlFile, satFile=satFile, bpmFile=bpmFile, gain=gain, ron=ron, logfile=logfile, obsCoords=obsCoords, avgAll=True, satSplit=satSplit)\\n \\n #carry out dark subtraction\\n if darkLst is not None and darkLst[0] is not None:\\n print('Subtracting dark ramp')\\n if len(darkLst)>1:\\n dark, darkSig = darkLst[:2]\\n sigmaImg = np.sqrt(sigmaImg**2 + darkSig**2)\\n else:\\n dark = darkLst[0]\\n logfile.write('*** Warning: No uncertainty associated with dark image ***\\\\n')\\n print(colorama.Fore.RED+'*** WARNING: No uncertainty associated with dark image ***'+colorama.Style.RESET_ALL)\\n\\n flatImg -= dark\\n hdr.add_history('Dark image subtracted using file:')\\n hdr.add_history(darkFile)\\n if logfile is not None:\\n logfile.write('Subtracted dark image using file:\\\\n')\\n logfile.write(darkFile+'\\\\n')\\n else:\\n print(colorama.Fore.RED+'*** WARNING: No dark image provided, or file does not exist ***'+colorama.Style.RESET_ALL)\\n if logfile is not None:\\n logfile.write('*** WARNING: No dark image provided, or file ' + str(darkFile)+' does not exist ***')\\n\\n if os.path.exists(savename+'_flat_limits.fits'):\\n cont = wifisIO.userInput('Limits file already exists for ' +folder+ ', do you want to continue processing (y/n)?')\\n \\n if (not cont.lower() == 'y'):\\n print('Reading limits '+savename+'_flat_limits.fits instead')\\n finalLimits, limitsHdr= wifisIO.readImgsFromFile(savename+'_flat_limits.fits')\\n shft = limitsHdr['LIMSHIFT']\\n contProc2 = False\\n else:\\n contProc2 = True\\n else:\\n contProc2= True\\n \\n if (contProc2):\\n print('Finding slice limits and extracting slices')\\n\\n #remove comment about contents of file\\n hdrTmp = hdr[::-1]\\n hdrTmp.remove('COMMENT')\\n hdr = hdrTmp[::-1]\\n \\n #find limits of each slice with the reference pixels, but the returned limits exclude them\\n limits = slices.findLimits(flatImg, dispAxis=dispAxis, winRng=winRng, imgSmth=imgSmth, limSmth=limSmth, rmRef=True,centGuess=centGuess)\\n\\n if logfile is not None:\\n logfile.write('Identified slice limits using the following parameters:\\\\n')\\n logfile.write('dispAxis: '+str(dispAxis)+'\\\\n')\\n logfile.write('winRng: ' + str(winRng)+'\\\\n')\\n logfile.write('imgSmth: ' + str(imgSmth)+'\\\\n')\\n logfile.write('limSmth: ' + str(limSmth)+'\\\\n')\\n \\n if hband:\\n print('Using suitable region of detector to determine flat limits')\\n if logfile is not None:\\n logfile.write('Using suitable region of detector to determine flat limits:\\\\n')\\n\\n #only use region with suitable flux\\n if dispAxis == 0:\\n flatImgMed = np.nanmedian(flatImg[4:-4,4:-4], axis=1)\\n else:\\n flatImgMed = np.nanmedian(flatImg[4:-4,4:-4], axis=0)\\n \\n flatImgMedGrad = np.gradient(flatImgMed)\\n medMax = np.nanargmax(flatImgMed)\\n lim1 = np.nanargmax(flatImgMedGrad[:medMax])\\n lim2 = np.nanargmin(flatImgMedGrad[medMax:])+medMax\\n\\n if logfile is not None:\\n logfile.write('Using following detector limits to set slice limits:\\\\n')\\n logfile.write(str(lim1)+ ' ' + str(lim2)+'\\\\n')\\n \\n polyLimits = slices.polyFitLimits(limits, degree=2, sigmaClipRounds=2, constRegion=[lim1,lim2])\\n else:\\n #get smoother limits, if desired, using polynomial fitting\\n polyLimits = slices.polyFitLimits(limits, degree=polyFitDegree, sigmaClipRounds=2)\\n\\n if logfile is not None:\\n logfile.write('Fit polynomial to slice edge traces using:\\\\n')\\n logfile.write('Polynomial degree: ' + str(polyFitDegree)+'\\\\n')\\n logfile.write('sigmaClipRounds: ' + str(2)+'\\\\n')\\n\\n if hband:\\n logfile.write('Only used pixels between ' + str(lim1) +' and ' + str(lim2)+'\\\\n')\\n \\n if os.path.exists(distMapLimitsFile):\\n print('Finding slice limits relative to distortion map file')\\n hdr.add_history('Slice limits are relative to the following file:')\\n hdr.add_history(distMapLimitsFile)\\n distMapLimits = wifisIO.readImgsFromFile(distMapLimitsFile)[0]\\n if logfile is not None:\\n logfile.write('Finding slice limits relative to distortion map file:\\\\n')\\n logfile.write(distMapLimitsFile+'\\\\n')\\n\\n if hband:\\n shft = int(np.nanmedian(polyLimits[1:-1,lim1:lim2+1] - distMapLimits[1:-1,lim1:lim2+1]))\\n else:\\n shft = int(np.nanmedian(polyLimits[1:-1,:] - distMapLimits[1:-1,:]))\\n \\n if logfile is not None:\\n logfile.write('Median pixel shift using all inner edge limits is ' + str(shft)+'\\\\n')\\n finalLimits = distMapLimits\\n else:\\n finalLimits = polyLimits\\n shft = 0\\n\\n if logfile is not None:\\n logfile.write('*** WARNING:No slice limits provided for distortion map. Finding independent slice limits ***\\\\n')\\n logfile.write(distMapLimitsFile+'\\\\n')\\n \\n \\n #write distMapLimits + shft to file\\n hdr.set('LIMSHIFT',shft, 'Limits shift relative to Ronchi slices')\\n hdr.add_comment('File contains the edge limits for each slice')\\n\\n wifisIO.writeFits(finalLimits.astype('float32'),savename+'_flat_limits.fits', hdr=hdr, ask=False)\\n\\n #remove comment about contents of file\\n hdrTmp = hdr[::-1]\\n hdrTmp.remove('COMMENT')\\n hdr = hdrTmp[::-1]\\n \\n #save figures of tracing results for quality control purposes\\n if (plot):\\n print('Plotting results')\\n plt.ioff()\\n wifisIO.createDir('quality_control')\\n \\n pdfName = 'quality_control/'+folder+'_flat_slices_traces.pdf'\\n with PdfPages(pdfName) as pdf:\\n fig = plt.figure()\\n #med1= np.nanmedian(flatImg)\\n interval = ZScaleInterval()\\n lims = interval.get_limits(flatImg[4:-4,4:-4])\\n #plt.imshow(flatImg[4:-4,4:-4], aspect='auto', cmap='jet', clim=[0,2.*med1], origin='lower')\\n plt.imshow(flatImg[4:-4,4:-4], aspect='auto', cmap='jet', clim=lims, origin='lower')\\n \\n plt.xlim=(0,2040)\\n plt.colorbar()\\n for l in range(limits.shape[0]):\\n if dispAxis==0:\\n plt.plot(limits[l], np.arange(limits.shape[1]),'k', linewidth=1) #drawn limits\\n plt.plot(np.clip(finalLimits[l]+shft,0, flatImg[4:-4,4:-4].shape[0]-1), np.arange(limits.shape[1]),'r--', linewidth=1) #shifted ronchi limits, if provided, or polynomial fit\\n else:\\n plt.plot(np.arange(limits.shape[1]),limits[l],'k', linewidth=1) #drawn limits\\n plt.plot(np.arange(limits.shape[1]),np.clip(finalLimits[l]+shft,0, flatImg[4:-4,4:-4].shape[0]-1),'r--', linewidth=1) #shifted ronchi limits\\n\\n if hband:\\n if dispAxis==0:\\n plt.plot([0,flatImg[4:-4,4:-4].shape[1]-1],[lim1,lim1],'b:',linewidth=1)\\n plt.plot([0,flatImg[4:-4,4:-4].shape[1]-1],[lim2,lim2],'b:',linewidth=1)\\n else:\\n plt.plot([lim1,lim1],[0,flatImg[4:-4,4:-4].shape[1]-1],'b:',linewidth=1)\\n plt.plot([lim2,lim2],[0,flatImg[4:-4,4:-4].shape[1]-1],'b:',linewidth=1)\\n\\n plt.tight_layout()\\n pdf.savefig()\\n plt.close(fig)\\n\\n #get rid of reference pixels\\n flatImg = flatImg[4:-4, 4:-4]\\n sigmaImg = sigmaImg[4:-4, 4:-4]\\n satFrame = satFrame[4:-4,4:-4]\\n\\n if logfile is not None:\\n logfile.write('Removing reference pixels\\\\n')\\n \\n if os.path.exists(savename+'_flat_slices.fits'):\\n cont='n'\\n cont = wifisIO.userInput('Flat slices file already exists for ' +folder+ ', do you want to continue processing (y/n)?')\\n\\n if (not cont.lower() == 'y'):\\n print('Reading slices file '+savename+'_flat_slices.fits instead')\\n flatSlices = wifisIO.readImgsFromFile(savename+'_flat_slices.fits')[0]\\n contProc2 = False\\n else:\\n contProc2 = True\\n else:\\n contProc2= True\\n \\n if (contProc2):\\n print('Extracting slices') \\n #now extract the individual slices\\n flatSlices = slices.extSlices(flatImg, finalLimits, dispAxis=dispAxis, shft=shft)\\n for slc in flatSlices:\\n slc = slc.astype('float32')\\n \\n if logfile is not None:\\n logfile.write('Extracted flat slices\\\\n')\\n \\n #extract uncertainty slices\\n sigmaSlices = slices.extSlices(sigmaImg, finalLimits, dispAxis=dispAxis, shft=shft)\\n for slc in sigmaSlices:\\n slc = slc.astype('float32')\\n \\n if logfile is not None:\\n logfile.write('Extracted uncertainty slices\\\\n')\\n \\n #extract saturation slices\\n satSlices = slices.extSlices(satFrame, finalLimits, dispAxis=dispAxis, shft=shft)\\n for slc in satSlices:\\n slc = slc.astype('float32')\\n \\n if logfile is not None:\\n logfile.write('Extracted saturation info slices\\\\n')\\n \\n #write slices to file\\n hdr.add_comment('File contains each slice image as separate extension')\\n wifisIO.writeFits(flatSlices+sigmaSlices+satSlices,savename+'_flat_slices.fits',hdr=hdr, ask=False)\\n \\n #remove comment about contents of file\\n hdrTmp = hdr[::-1]\\n hdrTmp.remove('COMMENT')\\n hdr = hdrTmp[::-1]\\n \\n if os.path.exists(savename+'_flat_slices_norm.fits'):\\n cont = 'n'\\n cont = wifisIO.userInput('Normalized flat slices file already exists for ' +folder+', do you want to continue processing (y/n)?')\\n \\n if (not cont.lower() == 'y'):\\n contProc2 = False\\n else:\\n contProc2 = True\\n else:\\n contProc2= True\\n \\n if (contProc2):\\n print('Getting normalized flat field')\\n #now get smoothed and normalized response function\\n flatNorm = slices.getResponseAll(flatSlices, flatSmooth, flatCutOff)\\n for slc in flatNorm:\\n slc = slc.astype('float32')\\n \\n hdr.add_comment('File contains the normalized flat-field response function')\\n hdr.add_history('Smoothed using Gaussian with 1-sigma width of ' + str(flatSmooth) + ' pixels')\\n hdr.add_history('Normalized cutoff threshold is ' + str(flatCutOff))\\n\\n if logfile is not None:\\n logfile.write('Computed normalized response function from flat slices using the following parameters:\\\\n')\\n logfile.write('flatSmooth: ' + str(flatSmooth)+'\\\\n')\\n logfile.write('flatCutoff: ' + str(flatCutOff)+'\\\\n')\\n \\n sigmaNorm = slices.ffCorrectAll(sigmaSlices, flatNorm)\\n for slc in sigmaNorm:\\n slc = slc.astype('float32')\\n \\n if logfile is not None:\\n logfile.write('Computed uncertainties for normalized response function for each slice\\\\n')\\n\\n if flatCor:\\n print('Correcting flat field response function')\\n logfile.write('Correcting flat field response function using file:\\\\n')\\n logfile.write(flatCorFile+'\\\\n')\\n \\n flatCorSlices = wifisIO.readImgsFromFile(flatCorFile)[0]\\n flatNorm = slices.ffCorrectAll(flatNorm, flatCorSlices)\\n hdr.add_history('Corrected flat field response function using file:')\\n hdr.add_history(flatCorFile)\\n\\n if len(flatCorSlices)>nSlices:\\n hdr.add_history('Uncertainties include correction')\\n sigmaNorm = wifisUncertainties.multiplySlices(flatNorm,sigmaNorm,flatCorSlices[:nSlices],flatCorSlices[nSlices:2*nSlices])\\n\\n else:\\n hdr.add_history('Uncertainties do not include correction')\\n logfile.write('*** WARNING: Response correction does not include uncertainties***\\\\n')\\n\\n else:\\n #print(colorama.Fore.RED+'*** WARNING: Flat field correction file does not exist, skipping ***'+colorama.Style.RESET_ALL)\\n \\n #logfile.write('*** WARNING: Flat field correction file does not exist, skipping ***\\\\n')\\n print('Flat field correction file off...skipping')\\n \\n logfile.write('Flat field correction file off...skipping\\\\n')\\n \\n #write normalized images to file\\n wifisIO.writeFits(flatNorm + sigmaNorm + satSlices,savename+'_flat_slices_norm.fits',hdr=hdr, ask=False)\\n print('*** Finished processing ' + folder + ' in ' + str(time.time()-t1) + ' seconds ***')\\n \\n return\",\n \"def generate_flare_set(self):\\n\\n # x_count = 10\\n # m_count = 10\\n files = []\\n for file in os.listdir(self.flare_path):\\n files.append(file)\\n # if file[0] == 'M' and m_count >0:\\n # files.append(file)\\n # m_count-=1\\n # elif file[0] == \\\"X\\\" and x_count >0:\\n # files.append(file)\\n # x_count-=1\\n\\n return files\",\n \"def test_f1_circuit_maker(self):\\n fho = tfho.test_file_handle_object()\\n W = 5\\n G = 20\\n fg = .9\\n X = 10\\n fx = .85\\n gate_maker = g.TYPE_TO_GATE_GEN[g.TEST_TYPES.RANDOM]\\n # family 1 files:\\n t_circuit_file_name = \\\"circuit_file_trimming\\\"\\n t_circuit_file = fho.get_file_object(t_circuit_file_name, 'w')\\n t_input_file_name = \\\"input_file_trimming\\\"\\n t_input_file = fho.get_file_object(t_input_file_name, 'w')\\n t_output_file_name = \\\"output_file_trimming\\\"\\n t_output_file = fho.get_file_object(t_output_file_name, 'w')\\n nt_circuit_file_name = \\\"circuit_file_no_trimming\\\"\\n nt_circuit_file = fho.get_file_object(nt_circuit_file_name, 'w')\\n nt_input_file_name = \\\"input_file_no_trimming\\\"\\n nt_input_file = fho.get_file_object(nt_input_file_name, 'w')\\n nt_output_file_name = \\\"output_file_no_trimming\\\"\\n nt_output_file = fho.get_file_object(nt_output_file_name, 'w')\\n level_type_array = [g.LEVEL_TYPES.RANDOM]\\n F = 1\\n # make a family 1 circuit with trimming:\\n sr.seed(self.rand_seed)\\n t_gen = g.f1f2_circuit_maker_with_trimming_switch(W, G, fg,\\n t_circuit_file,\\n t_input_file,\\n t_output_file,\\n X, fx, gate_maker,\\n level_type_array, True)\\n t_gen.generate()\\n # make a family 1 circuit without trimming, with the same randomness:\\n sr.seed(self.rand_seed)\\n nt_gen = g.f1f2_circuit_maker_with_trimming_switch(W, G, fg,\\n nt_circuit_file,\\n nt_input_file,\\n nt_output_file,\\n X, fx, gate_maker,\\n level_type_array, False)\\n nt_gen.generate()\\n # obtain strings representing the contents of all the resulting files:\\n t_circuit_string = fho.get_file(t_circuit_file_name).getvalue()\\n t_input_string = fho.get_file(t_input_file_name).getvalue()\\n t_output_string = fho.get_file(t_output_file_name).getvalue()\\n nt_circuit_string = fho.get_file(nt_circuit_file_name).getvalue()\\n nt_input_string = fho.get_file(nt_input_file_name).getvalue()\\n nt_output_string = fho.get_file(nt_output_file_name).getvalue()\\n # make sure that the inputs and outputs produced by the trimming and\\n # no trimming algorithms are the same:\\n self.assertEqual(t_input_string, nt_input_string)\\n self.assertEqual(t_output_string, nt_output_string)\\n # make sure that the input begins and ends with a bracket:\\n self.assertEqual(\\\"[\\\", t_input_string[0])\\n self.assertEqual(\\\"]\\\", t_input_string[-1])\\n # make sure that each input element is a bit:\\n for bit in t_input_string[1:-1]:\\n self.assertTrue((bit == '0') or (bit == '1'))\\n # make sure that the output is a bit:\\n self.assertTrue((t_output_string == '0') or (t_output_string == '1'))\\n # make sure that the two circuit headers are the same, and that they\\n # contain the correct values:\\n t_circuit_header = t_circuit_string.split(\\\"\\\\n\\\")[0]\\n nt_circuit_header = nt_circuit_string.split(\\\"\\\\n\\\")[0]\\n self.assertEqual(t_circuit_header, nt_circuit_header)\\n (W_string, G_string, F_string) = t_circuit_header.split(\\\",\\\")\\n W_value = int(W_string.split(\\\"=\\\")[-1])\\n G_value = int(G_string.split(\\\"=\\\")[-1])\\n F_value = int(F_string.split(\\\"=\\\")[-1])\\n self.assertEqual(W, W_value)\\n self.assertEqual(G, G_value)\\n self.assertEqual(F, F_value)\\n # note that we cannot test that the circuits themselves are the same,\\n # because the trimming algorithm produces a circuit with gates listed\\n # in a different order.\",\n \"def spilloverEff(freq,fD, FFBW, dB_at_bw, feed_type):\\n theta0 = fD2angle(fD,units='degrees')\\n tt = 0.0\\n dtt = 0.1\\n theta = np.arange(0.0,180.0+dtt,dtt)\\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\\n theta = theta*math.pi/180.0\\n\\n # integrate over main beam\\n gmb = np.where(theta < (theta0/2.0)*math.pi/180.0)\\n kern = g[gmb]*np.sin(theta[gmb]) \\n num = integ.trapz(kern,dx=dtt*math.pi/180.0)\\n # integrate over full beam\\n kern = g*np.sin(theta)\\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\\n \\n n_spill = num/den\\n return n_spill\",\n \"def run(self, src, dest):\\n self.logger.debug('Start the blurring. src=\\\"%s\\\", dest=\\\"%s\\\"', src, dest)\\n create_frames(src, self.work['frames'])\\n data = self.analyze()\\n\\n for frame_no, frame in enumerate(self.work.files('frames')):\\n basename = os.path.basename(frame)\\n areas = []\\n for values in data:\\n for sector in values['sectors']:\\n if frame_no in range(sector[0]-self.offset, sector[1]+self.offset):\\n areas.append(values['area'])\\n break\\n if areas:\\n self.blur.blur_image(frame, areas, os.path.join(self.work['cleaned'], basename))\\n else:\\n copyfile(frame, os.path.join(self.work['cleaned'], basename))\\n save_frames(self.work['cleaned'], dest)\",\n \"def spectate(self):\\n pass\",\n \"async def breathe(self, params):\\n intensity = params.get('intensity', 255)\\n wait_ms = params.get('wait_ms', 2)\\n try:\\n while True:\\n await self.lights.breathe(intensity, wait_ms=wait_ms)\\n except KeyboardInterrupt:\\n pass\",\n \"def _sweepDir(self, f):\\n lastCellFaceVal = np.zeros((self.regions[0].cells[0].nG,\\n self.regions[0].cells[0].sNords))\\n if f == 2:\\n sweepTree = reversed(self.sweepTree)\\n else:\\n sweepTree = self.sweepTree\\n blowoff = False\\n for j, i in sweepTree:\\n cell = self.regions[j].cells[i]\\n if hasattr(cell, 'boundaryCond') and not blowoff:\\n cell.applyBC(self.depth)\\n blowoff = True\\n else:\\n # Interior cell\\n cell.ordFlux[:, f, :] = lastCellFaceVal[:, :]\\n # Only sweep through ordinates that have a component in same direction as\\n # current sweep dir. Filter ords by dot product\\n dotDir = cell.sNmu * cell.faceNormals[f - 1]\\n ordsInSweepDir = np.where(dotDir < 0.)\\n for o in np.arange(cell.sNords)[ordsInSweepDir]:\\n cell.ordFlux[:, 0, o] = (cell.ordFlux[:, f, o] + self.regions[j].deltaX * cell.qin[:, 0, o] / (2. * np.abs(cell.sNmu[o]))) / \\\\\\n (1. + self.regions[j].totalXs * self.regions[j].deltaX / (2. * np.abs(cell.sNmu[o])))\\n if f == 1:\\n cell.ordFlux[:, 2, o] = 2. * cell.ordFlux[:, 0, o] - cell.ordFlux[:, f, o]\\n lastCellFaceVal[:, o] = cell.ordFlux[:, 2, o]\\n elif f == 2:\\n cell.ordFlux[:, 1, o] = 2. * cell.ordFlux[:, 0, o] - cell.ordFlux[:, f, o]\\n lastCellFaceVal[:, o] = cell.ordFlux[:, 1, o]\\n if np.any(cell.ordFlux[:, :, :] < 0.0):\\n #print(\\\"WARNING: Negative flux detected! Refine mesh in region #:\\\" + str(j))\\n maxStepSize = 2. * np.min(np.abs(cell.sNmu)) * min(1. / self.regions[j].totalXs)\\n #print(\\\"Max Step size in 1D: \\\" + str(maxStepSize))\\n # automatically gen refine factor: TODO: auto refine mesh\\n # refineFactor = self.regions[j].deltaX / maxStepSize\\n #raise Exception('coarse', refineFactor)\",\n \"def masterFlat(flat_list, master_dark_fname, normalize = 'median', local_sig_bad_pix = 3, \\\\\\n global_sig_bad_pix = 9, local_box_size = 11, hotp_map_fname = None, verbose=False,\\n output_dir = None,min_flux=1000):\\n\\n #Open the master dark\\n master_dark_hdu = f.open(master_dark_fname)\\n master_dark = master_dark_hdu[0].data\\n dark_shape = np.shape(master_dark)\\n\\n if verbose:\\n print((\\\"Subtracting {} from each flat file\\\".format(master_dark_fname)))\\n dark_exp_time = master_dark_hdu[0].header['EXPTIME']\\n\\n #Open all files into a 3D array\\n #foo = np.empty((dark_shape[0],dark_shape[1],len(flat_list)))\\n foo = []\\n\\n #Open first flat file to check exposure time and filter\\n first_flat_hdu = f.open(flat_list[0])\\n flat_exp_time = first_flat_hdu[0].header['EXPTIME']\\n\\n\\n\\n if dark_exp_time != flat_exp_time:\\n print(\\\"The master dark file doesn't have the same exposure time as the flats. We'll scale the dark for now, but this isn't ideal\\\", UserWarning)\\n factor = flat_exp_time/dark_exp_time\\n else:\\n factor = 1.\\n\\n #We've already read it, so we'll stick it in foo\\n\\n print(\\\"Combining flat files\\\")\\n for i in range(0,len(flat_list)):\\n try: \\n #subtract dark for each file, then normalize by mode\\n hdu = f.open(flat_list[i],ignore_missing_end=True)\\n d_sub = hdu[0].data - factor*master_dark\\n if np.nanmedian(d_sub) < min_flux:\\n #print(\\\"Skipping file {}, because its flux is lower than {}\\\".format(flat_list[i],min_flux))\\n continue\\n #normalize\\n if normalize == 'mode':\\n d_sub = d_sub/mode(d_sub, axis = None, nan_policy = 'omit')\\n elif normalize == 'median':\\n d_sub = d_sub/np.nanmedian(d_sub)\\n #foo[:,:,i] = d_sub\\n foo.append(d_sub)\\n except:\\n print(\\\"Some error. Skipping file {}\\\".format(i)) \\n #Median combine frames\\n flat = np.median(foo, axis = 0)\\n\\n #Filter bad pixels\\n #bad_px = sigma_clip(flat, sigma = sig_bad_pix) #old and bad\\n ###Major update here: do sigma clipping on the pix-to-pix flat with the large scale vignette removed\\n ###Also add local sigma clipping\\n def stddevFilter(img, box_size):\\n \\\"\\\"\\\" from\\n https://stackoverflow.com/questions/28931265/calculating-variance-of-an-image-python-efficiently/36266187#36266187\\n This function compute the standard deviation of an image in a\\n moving box of a given size. The pixel i,j of the output is the\\n standard deviation of the pixel value in the box_size x box_size box\\n around the i,j pixel in the original image.\\n \\\"\\\"\\\"\\n wmean, wsqrmean = (cv2.boxFilter(x, -1, (box_size, box_size), \\\\\\n borderType=cv2.BORDER_REFLECT) for x in (img, img*img))\\n return np.sqrt(wsqrmean - wmean*wmean)\\n\\n #median flat\\n median_flat = median_filter(flat, local_box_size) #arbitrary size, shouldn't matter as long as it's big enough\\n #standard deviation image\\n stddev_im = stddevFilter(flat, local_box_size)\\n\\n #Local clipping\\n local_bad_pix = np.abs(median_flat - flat) > local_sig_bad_pix*stddev_im\\n\\n #Global clipping here to reject awful pixels and dust, bad columns, etc\\n pix_to_pix = flat/median_flat\\n global_bad_px = sigma_clip(pix_to_pix, sigma = global_sig_bad_pix).mask #9 seems to work best\\n\\n #also set all 0 and negative pixels in flat as bad\\n non_positive = flat <= 0\\n\\n #logic combine\\n bad_px = np.logical_or(global_bad_px, local_bad_pix)\\n\\n #also add non_positive pixels\\n bad_px = np.logical_or(bad_px, non_positive)\\n\\n #Normalize good pixel values\\n if normalize == 'median':\\n norm_flat = flat/np.nanmedian(flat[~bad_px])\\n elif normalize == 'mode':\\n norm_flat = flat/mode(flat, axis = None, nan_policy = 'omit')\\n #Stick it back in the last hdu\\n hdu[0].data = norm_flat\\n\\n #Add pipeline version and history keywords\\n vers = version.get_version()\\n hdu[0].header.set('PL_VERS',vers,'Version of pipeline used for processing')\\n hdu[0].header['HISTORY'] = \\\"############################\\\"\\n hdu[0].header['HISTORY'] = \\\"Created master flat by median combining the following:\\\"\\n for i in range(len(flat_list)):\\n hdu[0].header['HISTORY'] = flat_list[i]\\n hdu[0].header['HISTORY'] = \\\"Normalized to the median of the master flat\\\"\\n hdu[0].header['HISTORY'] = \\\"Performed bad pixel local and global sigma clipping with {}, {}sigmas\\\".format(local_sig_bad_pix, global_sig_bad_pix)\\n hdu[0].header['HISTORY'] = \\\"############################\\\"\\n\\n #Parse the last fileanme\\n if output_dir is not None:\\n flat_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_master_flat.fits\\\"\\n flat_outname = flat_outname.rsplit('/',1)[-1]\\n flat_outname = output_dir+flat_outname\\n else:\\n flat_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_master_flat.fits\\\"\\n\\n #Write the fits file\\n if verbose:\\n print((\\\"Writing master flat to {}\\\".format(flat_outname)))\\n hdu.writeto(flat_outname, overwrite=True)\\n\\n #If there's already a hot pixel map then we'll add to it.\\n if hotp_map_fname != None:\\n #read in the existing bp map\\n #hdu = f.open(hotp_map_fname)\\n #hdu[0].data += np.array(bad_px.mask, dtype=float)\\n #hdu[0].data = np.logical_or(hdu[0].data.astype(bool), bad_px) #use logical or to combine bad pixel maps\\n #bp_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_bp_map.fits\\\"\\n print(\\\"Will deal with hot pixel map from dark frames in the calibrate function\\\")\\n\\n #else:\\n #Parse the last fileanme\\n if output_dir is not None:\\n bp_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_bp_map.fits\\\"\\n bp_outname = bp_outname.rsplit('/',1)[-1]\\n bp_outname = output_dir+bp_outname\\n else:\\n bp_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_bp_map.fits\\\"\\n\\n ##### Now write the bad pixel map\\n hdu[0].data = bad_px.astype(int)#np.array(bad_px.mask, dtype=float)\\n #Parse the last fileanme\\n # bp_outname = flat_list[-1].rsplit('.',1)[0]+\\\"_bp_map.fits\\\"\\n\\n #Add history keywords\\n hdu[0].header['HISTORY'] = \\\"############################\\\"\\n hdu[0].header['HISTORY'] = \\\"Created bad pixel map by sigma clipping on pixel-to-pixel flat{}\\\".format(flat_outname)\\n hdu[0].header['HISTORY'] = \\\"Bad pixel cutoffs: local sigma = {} and global sigma = {} for clipping\\\".format(local_sig_bad_pix, global_sig_bad_pix)\\n #hdu[0].header['HISTORY'] = \\\"Bad pixel cutoff of {}sigma\\\".format(sig_bad_pix)\\n hdu[0].header['HISTORY'] = \\\"A pixel value of 1 indicates a bad pixel\\\"\\n hdu[0].header['HISTORY'] = \\\"############################\\\"\\n\\n if verbose:\\n print((\\\"Writing bad pixel map to {}\\\".format(bp_outname)))\\n #Write the fits file\\n hdu.writeto(bp_outname, overwrite=True)\\n\\n return flat_outname, bp_outname\",\n \"def apply_cuts(objects):\\n #- Check if objects is a filename instead of the actual data\\n if isinstance(objects, (str, unicode)):\\n objects = io.read_tractor(objects)\\n \\n #- undo Milky Way extinction\\n flux = unextinct_fluxes(objects)\\n gflux = flux['GFLUX']\\n rflux = flux['RFLUX']\\n zflux = flux['ZFLUX']\\n w1flux = flux['W1FLUX']\\n wflux = flux['WFLUX']\\n \\n #- DR1 has targets off the edge of the brick; trim to just this brick\\n if 'BRICK_PRIMARY' in objects.dtype.names:\\n primary = objects['BRICK_PRIMARY']\\n else:\\n primary = np.ones(len(objects), dtype=bool)\\n \\n #----- LRG\\n lrg = primary.copy()\\n lrg &= rflux > 10**((22.5-23.0)/2.5)\\n lrg &= zflux > 10**((22.5-20.56)/2.5)\\n lrg &= w1flux > 10**((22.5-19.35)/2.5)\\n lrg &= zflux > rflux * 10**(1.6/2.5)\\n #- clip to avoid warnings from negative numbers raised to fractional powers\\n lrg &= w1flux * rflux.clip(0)**(1.33-1) > zflux.clip(0)**1.33 * 10**(-0.33/2.5)\\n\\n #----- ELG\\n elg = primary.copy()\\n elg &= rflux > 10**((22.5-23.4)/2.5)\\n elg &= zflux > rflux * 10**(0.3/2.5)\\n elg &= zflux < rflux * 10**(1.5/2.5)\\n elg &= rflux**2 < gflux * zflux * 10**(-0.2/2.5)\\n elg &= zflux < gflux * 10**(1.2/2.5)\\n\\n #----- Quasars\\n psflike = ((objects['TYPE'] == 'PSF') | (objects['TYPE'] == 'PSF ')) \\n qso = primary.copy()\\n qso &= psflike\\n qso &= rflux > 10**((22.5-23.0)/2.5)\\n qso &= rflux < gflux * 10**(1.0/2.5)\\n qso &= zflux > rflux * 10**(-0.3/2.5)\\n qso &= zflux < rflux * 10**(1.1/2.5)\\n #- clip to avoid warnings from negative numbers raised to fractional powers\\n qso &= wflux * gflux.clip(0)**1.2 > rflux.clip(0)**(1+1.2) * 10**(-0.4/2.5)\\n ### qso &= wflux * gflux**1.2 > rflux**(1+1.2) * 10**(2/2.5)\\n\\n #------ Bright Galaxy Survey\\n #- 'PSF' for astropy.io.fits; 'PSF ' for fitsio (sigh)\\n bgs = primary.copy()\\n bgs &= ~psflike\\n bgs &= rflux > 10**((22.5-19.35)/2.5)\\n\\n #----- Standard stars\\n fstd = primary.copy()\\n fstd &= psflike\\n fracflux = objects['DECAM_FRACFLUX'].T \\n signal2noise = objects['DECAM_FLUX'] * np.sqrt(objects['DECAM_FLUX_IVAR'])\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n for j in (1,2,4): #- g, r, z\\n fstd &= fracflux[j] < 0.04\\n fstd &= signal2noise[:, j] > 10\\n\\n #- observed flux; no Milky Way extinction\\n obs_rflux = objects['DECAM_FLUX'][:, 2]\\n fstd &= obs_rflux < 10**((22.5-16.0)/2.5)\\n fstd &= obs_rflux > 10**((22.5-19.0)/2.5)\\n #- colors near BD+17; ignore warnings about flux<=0\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n grcolor = 2.5 * np.log10(rflux / gflux)\\n rzcolor = 2.5 * np.log10(zflux / rflux)\\n fstd &= (grcolor - 0.32)**2 + (rzcolor - 0.13)**2 < 0.06**2\\n\\n #-----\\n #- construct the targetflag bits\\n #- Currently our only cuts are DECam based (i.e. South)\\n desi_target = lrg * desi_mask.LRG_SOUTH\\n desi_target |= elg * desi_mask.ELG_SOUTH\\n desi_target |= qso * desi_mask.QSO_SOUTH\\n\\n desi_target |= lrg * desi_mask.LRG\\n desi_target |= elg * desi_mask.ELG\\n desi_target |= qso * desi_mask.QSO\\n\\n desi_target |= fstd * desi_mask.STD_FSTAR\\n \\n bgs_target = bgs * bgs_mask.BGS_BRIGHT\\n bgs_target |= bgs * bgs_mask.BGS_BRIGHT_SOUTH\\n\\n #- nothing for MWS yet; will be GAIA-based\\n mws_target = np.zeros_like(bgs_target)\\n\\n #- Are any BGS or MWS bit set? Tell desi_target too.\\n desi_target |= (bgs_target != 0) * desi_mask.BGS_ANY\\n desi_target |= (mws_target != 0) * desi_mask.MWS_ANY\\n\\n return desi_target, bgs_target, mws_target\",\n \"def remove_shadow(self):\\n #Separate the RGB\\n rgb_planes = cv.split(self.frame)\\n\\n result_norm_planes = []\\n #Go through the planes, get a dilated image and a blur image, then get the difference between the two images, then normalize the final image\\n for plane in rgb_planes:\\n dilated_img = cv.dilate(plane, np.ones((7,7), np.uint8))\\n bg_img = cv.medianBlur(dilated_img, 21)\\n diff_img = 255 - cv.absdiff(plane, bg_img)\\n norm_img = cv.normalize(diff_img,None, alpha=0, beta=255, norm_type=cv.NORM_MINMAX, dtype=cv.CV_8UC1)\\n result_norm_planes.append(norm_img)\\n\\n result_norm = cv.merge(result_norm_planes)\\n\\n self.frame = result_norm\",\n \"def foward_shimmey(self):\\n for x in range(6):\\n self.right(primary=60, counter=30)\\n time.sleep(.5)\\n self.left(primary=70, counter=30)\\n time.sleep(.5)\\n self.back()\\n time.sleep(2) \\n self.stop()\",\n \"def SetWireDivideTool(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_FaceDivide_SetWireDivideTool(self, *args)\",\n \"def clean(times,signal, f0=None, fn=None, df=None, freqbins=None, niter=10.,\\n gain=1.0):\\n T = times.ptp()\\n n = len(times)\\n if freqbins is None:\\n freqbins = [f0,fn]\\n \\n startfreqs = np.array(freqbins[0::2])\\n endfreqs = np.array(freqbins[1::2])\\n nbins = len(freqbins)-1\\n \\n nf = int(fn/df)\\n \\n #-- do clean computation, seems not so straightforward to thread cleaning\\n f,wpow,wpha = pyclean.main_clean(times,signal,fn,nf,gain,niter,nbins,\\\\\\n startfreqs,endfreqs)\\n \\n return f,wpow\",\n \"def filtering(self):\\r\\n # 1 ###########################################################################################################\\r\\n fft_image = np.fft.fft2(self.image)\\r\\n # 2 ###########################################################################################################\\r\\n fft_shift_image = np.fft.fftshift(fft_image)\\r\\n\\r\\n ###\\r\\n mag_dft = np.log(np.abs(fft_shift_image))\\r\\n mag_dft = (255 * (mag_dft / np.max(mag_dft))).astype(dtype='uint8')\\r\\n ###\\r\\n\\r\\n # 3 ###########################################################################################################\\r\\n if self.filter_name == 'butterworth_l' or self.filter_name == 'butterworth_h':\\r\\n mask = self.filter(fft_shift_image.shape, self.cutoff, self.order)\\r\\n else:\\r\\n mask = self.filter(fft_shift_image.shape, self.cutoff)\\r\\n # 4 ###########################################################################################################\\r\\n # multiply the dft (fft shift image) by the mask\\r\\n filtered_image = fft_shift_image * mask\\r\\n\\r\\n ###\\r\\n mag_filtered_image = mag_dft * mask\\r\\n ###\\r\\n\\r\\n # 5 ###########################################################################################################\\r\\n inverse_fft_shift_image = np.fft.ifftshift(filtered_image)\\r\\n # 6 ###########################################################################################################\\r\\n inverse_fft_image = np.fft.ifft2(inverse_fft_shift_image)\\r\\n # 7 ###########################################################################################################\\r\\n mag_image = np.zeros(inverse_fft_image.shape, dtype=complex)\\r\\n for i in range(inverse_fft_image.shape[0]):\\r\\n for j in range(inverse_fft_image.shape[1]):\\r\\n if inverse_fft_image[i][j] < 0:\\r\\n mag_image[i][j] = -1 * inverse_fft_image[i][j]\\r\\n else:\\r\\n mag_image[i][j] = inverse_fft_image[i][j]\\r\\n # magnitude of inverse fft is complete\\r\\n # 8 ###########################################################################################################\\r\\n full_contrast_image = self.post_process_image(mag_image)\\r\\n\\r\\n return [mag_dft, mag_filtered_image, full_contrast_image]\",\n \"def filtering(self):\\n from numpy import fft\\n import numpy as np\\n\\n _image_dft = fft.fft2(self.image)\\n _image_dft = fft.fftshift(_image_dft)\\n # dft = DFT.DFT()\\n # plt.figure(1) \\n # plt.imshow(self.image)\\n # plt.figure(2)\\n # plt.imshow(20*np.log10(abs(_image_dft))) \\n # print(_image_dft)\\n # print(abs(_image_dft))\\n # plt.show()\\n filter = self.filter(self.image.shape, self.cutoff, self.order) \\\\\\n if self.filter_name.startswith('butterworth') \\\\\\n else self.filter(self.image.shape, self.cutoff)\\n \\n _image_dft_filtered = _image_dft * filter\\n _image_filtered = abs(fft.ifft2(_image_dft_filtered))\\n \\n return [ self.post_process_image(_image_filtered), \\\\\\n self.post_process_image(20*np.log10(abs(_image_dft)+.00001)), \\\\\\n self.post_process_image(20*np.log10(abs(_image_dft_filtered)+.00001)) ]\",\n \"def CleanBadPixels(spectraUp,spectraDown):\\n \\n Clean_Up= []\\n Clean_Do = []\\n Clean_Av = []\\n eps=25. # this is the minumum background Please check\\n NBSPEC=len(spectraUp)\\n for index in np.arange(0,NBSPEC):\\n s_up=spectraUp[index]\\n s_do=spectraDown[index]\\n \\n index_up=np.where(s_up<eps)\\n index_do=np.where(s_do<eps)\\n \\n s_up[index_up]=s_do[index_up]\\n s_do[index_do]=s_up[index_do]\\n s_av=(s_up+s_do)/2.\\n \\n Clean_Up.append(s_up)\\n Clean_Do.append(s_do)\\n Clean_Av.append(s_av)\\n \\n return Clean_Up, Clean_Do,Clean_Av\",\n \"def force_wo_scf(self):\\n self.report('INFO: run Force theorem calculations')\\n\\n status = self.change_fleurinp()\\n if status:\\n return status\\n\\n fleurin = self.ctx.fleurinp\\n\\n # Do not copy mixing_history* files from the parent\\n settings = {'remove_from_remotecopy_list': ['mixing_history*']}\\n\\n # Retrieve remote folder from the inputs\\n remote = self.inputs.remote\\n\\n label = 'DMI_force_theorem'\\n description = 'The is the force theorem calculation for DMI energy.'\\n\\n code = self.inputs.fleur\\n options = self.ctx.options.copy()\\n\\n inputs_builder = get_inputs_fleur(code,\\n remote,\\n fleurin,\\n options,\\n label,\\n description,\\n settings,\\n add_comp_para=self.ctx.wf_dict['add_comp_para'])\\n future = self.submit(FleurBaseWorkChain, **inputs_builder)\\n return ToContext(f_t=future)\",\n \"def step(self):\\n # gets who has fired who in this step\\n blues_fire_reds = np.array([[blue.fires_(red) for red in self.red_drones] for blue in self.blue_drones])\\n reds_fire_blues = np.array([[red.fires_(blue) for blue in self.blue_drones] for red in self.red_drones])\\n\\n # if the foe is no longer seen, the count restarts from 0\\n self.blues_have_fired_reds *= blues_fire_reds\\n self.reds_have_fired_blues *= reds_fire_blues\\n\\n # and the count is incremented for the others\\n self.blues_have_fired_reds += blues_fire_reds\\n self.reds_have_fired_blues += reds_fire_blues\\n\\n # np magic : first find the list of duos shooter/shot, keep the shots (only once)\\n red_deads = np.unique(np.argwhere(self.blues_have_fired_reds >= self.blue_shots_to_kill).T[1])\\n blue_deads = np.unique(np.argwhere(self.reds_have_fired_blues >= self.red_shots_to_kill).T[1])\\n\\n\\n # tell the drones that they are dead\\n for drone_id in blue_deads:\\n self.blue_drones[drone_id].is_killed(is_blue=True)\\n for drone_id in red_deads:\\n self.red_drones[drone_id].is_killed(is_blue=False)\\n\\n # consider only living drones\\n blue_drones = [drone for drone in self.blue_drones if drone.is_alive]\\n red_drones = [drone for drone in self.red_drones if drone.is_alive]\\n\\n bf_obs, rf_obs = self.get_observation()\\n bf_reward = rf_reward = 0\\n remaining_blues, remaining_reds = len(blue_drones), len(red_drones),\\n blue_shots, red_shots = len(blue_deads), len(red_deads)\\n\\n if blue_shots + red_shots > 0:\\n print('someone is killed: {0} blues and {1} reds'.format(blue_shots, red_shots))\\n\\n return bf_obs, bf_reward, remaining_blues, blue_shots, rf_obs, rf_reward, remaining_reds, red_shots\",\n \"def butterfly(self):\\n\\n self.log.info(\\\"Begin Butterfly\\\")\\n\\n dst = os.path.join(self.cfg['start_dir'], 'Butterfly', 'src')\\n try:\\n os.chdir(dst)\\n except OSError, err:\\n self.log.error(\\\"Butterfly: failed to change to dst dir %s\\\" % (dst, err))\\n\\n cmd = \\\"ant\\\"\\n run_cmd(cmd)\\n\\n self.log.info(\\\"End Butterfly\\\")\",\n \"def run(self):\\n self.coffee_machine.beans_tank.decrease_weight(self.coffee_machine.chosen_coffee_data.get('beans_weight'))\",\n \"def flattenTest():\\n x = rampfloat(0,0,1,n1,n2)\\n t = rampfloat(0,1,0,n1,n2)\\n smax = 5.0\\n a = smax/(n1-1)\\n b = 2*PI/(n2-1)\\n bx = mul(b,x)\\n bt = mul(b,t)\\n cosbx = cos(bx)\\n sinbx = sin(bx)\\n acosbx = mul(a,cosbx)\\n asinbx = mul(a,sinbx)\\n p2 = div(mul(bt,acosbx),add(1,asinbx))\\n el = fillfloat(1,n1,n2)\\n fl = FlattenerCg(8.0,0.01)\\n sf = fl.findShifts(p2,el) # found shifts\\n se = neg(mul(t,asinbx)) # exact shifts\\n plot(sf,jet,-smax,smax)\\n plot(se,jet,-smax,smax)\",\n \"def do_stuff(self):\\n self.create_tourism_raster()\",\n \"def _fly(self):\\n logger.info(\\\"flyer activity()\\\")\\n if self.complete_status is None:\\n logger.info(\\\"leaving activity() - not complete\\\")\\n return\\n\\n # TODO: do the activity here\\n logger.info(\\\"writing data... \\\")\\n for step in range(self._steps):\\n t = time.time()\\n x = t - self.t0\\n d = dict(\\n time=t,\\n data=dict(x=x),\\n timestamps=dict(x=t)\\n )\\n self._data.append(d)\\n time.sleep(.5)\\n logger.info(\\\"done\\\")\\n\\n # once started, we notify by updating the status object\\n self.kickoff_status.set_finished()\\n\\n # TODO: wait for completion\\n\\n # after the wait, we declare victory\\n # self.complete_status.set_finished()\\n # logger.info(\\\"_fly() complete. status = \\\" + str(self.complete_status))\",\n \"def cleanup(self):\\n self.subpixel, self.pixel = self.stepup(self.subpixel, self.pixel, AxisDistance.pixelsize)\\n self.pixel, self.tile = self.stepup(self.pixel, self.tile, AxisDistance.tilesize)\",\n \"def go():\\n ##########\\n #\\n # MB19284\\n #\\n ##########\\n\\n ##########\\n # Kp-band reduction\\n ##########\\n\\n target = 'mb19284'\\n sci_files = ['i200822_a011{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\\n sci_files += ['i200822_a012{0:03d}_flip'.format(ii) for ii in range(2, 25+1)]\\n sky_files = ['i200822_a018{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\\n refSrc = [917.75, 1033.5] # This is the target\\n # Alternative star to try (bright star to bottom of target): [1015, 581.9]\\n \\n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\\n trim=0, weight='strehl', submaps=3, instrument=osiris)\\n\\n ##########\\n #\\n # KB200101\\n #\\n ##########\\n\\n ##########\\n # Kp-band reduction\\n ##########\\n\\n # -- If you have more than one position angle, make sure to\\n # clean them seperatly.\\n # -- Strehl and Ref src should be the pixel coordinates of a bright\\n # (but non saturated) source in the first exposure of sci_files.\\n # -- If you use the OSIRIS image, you must include the full filename in the list. \\n target = 'kb200101'\\n sci_files = ['i200822_a014{0:03d}_flip'.format(ii) for ii in range(2, 28+1)]\\n sci_files += ['i200822_a015{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\\n sci_files += ['i200822_a016{0:03d}_flip'.format(ii) for ii in range(2, 5+1)]\\n sky_files = ['i200822_a017{0:03d}_flip'.format(ii) for ii in range(2, 6+1)]\\n refSrc = [975, 1006] # This is the target\\n # Alternative star to try (bright star to right of target): [1158, 994]\\n \\n sky.makesky(sky_files, target, 'kp_tdOpen', instrument=osiris)\\n data.clean(sci_files, target, 'kp_tdOpen', refSrc, refSrc, field=target, instrument=osiris)\\n data.calcStrehl(sci_files, 'kp_tdOpen', field=target, instrument=osiris)\\n data.combine(sci_files, 'kp_tdOpen', epoch, field=target,\\n trim=1, weight='strehl', submaps=3, instrument=osiris)\",\n \"def farm_damage(turbineX,turbineY,windDirections,windFrequencies,Omega_free,free_speed,Omega_close,close_speed,Omega_far,far_speed,\\n Rhub,r,chord,theta,af,Rtip,B,rho,mu,precone,hubHt,nSector,pitch,yaw_deg,TI=0.11):\\n\\n damage = np.zeros_like(turbineX)\\n nDirections = len(windDirections)\\n nTurbines = len(turbineX)\\n\\n for j in range(nDirections):\\n turbineXw, turbineYw = fast_calc_aep.windframe(windDirections[j], turbineX, turbineY)\\n for i in range(nTurbines):\\n damage[i] += get_edgewise_damage(turbineXw,turbineYw,i,Omega_free,free_speed,Omega_close,close_speed,Omega_far,far_speed,\\n Rhub,r,chord,theta,af,Rtip,B,rho,mu,precone,hubHt,nSector,pitch,yaw_deg,TI=TI)*windFrequencies[j]\\n return damage\",\n \"def go_infFD(self):\\n\\n response = self.send_lens_cmd(['05', '00', '00', '00'], fast_mode=True)\\n self.wait_focus_move()\",\n \"def cruise(self):\\n while self.dist() > self.SAFE_STOP_DIST:\\n time.sleep(.2)\\n self.fwd()\\n self.stop()\",\n \"def test2(self):\\r\\n\\t\\tif not self._motion.breakout():\\r\\n\\t\\t\\tself._motion.initialize()\\r\\n\\t\\tif not self._motion.breakout():\\r\\n\\t\\t\\tself._motion.sweepDuckie()\\r\\n\\t\\tif not self._motion.breakout():\\r\\n\\t\\t\\tself._motion.duckieAlignX()\\r\\n\\t\\tif not self._motion.breakout():\\r\\n\\t\\t\\tself._motion.duckieAlignY()\\r\\n\\t\\tif not self._motion.breakout():\\r\\n\\t\\t\\tself._motion.duckieLowerEE()\\r\\n\\t\\tif not self._motion.breakout():\\r\\n\\t\\t\\tself._motion.duckieSuctionOn()\\r\\n\\t\\tif not self._motion.breakout():\\r\\n\\t\\t\\tself._motion.duckieLiftEE()\\r\\n\\t\\tself._motion.terminate()\",\n \"def do_harvest_extraction_emissions(self, unused_t):\\n # this is an example of a process that is owned by SocialSystem\\n # but affects its cells and the world:\\n for c in self.cells:\\n c.d_terrestrial_carbon -= c.biomass_harvest_flow\\n c.d_fossil_carbon -= c.fossil_extraction_flow\\n self.world.d_atmospheric_carbon += self.carbon_emission_flow\",\n \"def myfly(flyers, *, md=None):\\n yield from bps.open_run(md)\\n for flyer in flyers:\\n yield from bps.kickoff(flyer, wait=True)\\n for flyer in flyers:\\n yield from bps.complete(flyer, wait=True)\\n for flyer in flyers:\\n yield from bps.collect(flyer, stream=True)\\n yield from bps.close_run()\",\n \"def main():\\n amplitute_variation = [0.98, 1.02]\\n frequency_variation = [0, 0.06]\\n transition_band = [(0.1*math.pi), (0.4*math.pi)]\\n (passband, stopband, transition_band_diff) = set_diffs(\\n amplitute_variation, frequency_variation, transition_band)\\n omega_c = np.mean(transition_band)\\n dB = to_dB(stopband)\\n windowing_type = choose_window_type(dB)\\n M = get_magnetude(transition_band_diff, windowing_type)\\n result_filter = create_filter(M, omega_c, windowing_type)\\n print('Filter: {0}\\\\nNormalized_filter: {1}'.format(\\n result_filter, normalize(result_filter)))\",\n \"async def send_drones_to_extractor(self):\\n if self.vespene < 100 and not self.already_pending_upgrade(UpgradeId.ZERGLINGMOVEMENTSPEED):\\n for extractor in self.gas_buildings:\\n drones_needed_to_fill_extractor = extractor.ideal_harvesters - extractor.assigned_harvesters\\n if drones_needed_to_fill_extractor > 0:\\n for drone in self.workers.closer_than(10, extractor).take(drones_needed_to_fill_extractor):\\n self.do(drone.gather(extractor))\",\n \"def Perform(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_WireDivide_Perform(self, *args)\",\n \"def BoatEarMoon():\\n D=1\\n alpha=math.radians(83)\\n beta=math.radians(42) \\n phi=math.radians(70) \\n mu=math.radians(10) \\n omega=math.radians(30) \\n A=25, a=12, b=20, L=0, P=0, W1=0, W2=0, N=0\\n \\n resMode()\",\n \"def main():\\n for i in range(4):\\n fix_tower()\\n if front_is_clear():\\n move_to_next()\",\n \"def settle_falilng_shape(self):\\n if self.falling_shape:\\n self._settle_shape(self.falling_shape)\\n self.falling_shape = None\\n self.new_shape()\",\n \"def teleopPeriodic(self):\\n #self.drive.arcadeDrive(-1*self.stick.getRawAxis(0), self.stick.getRawAxis(1))\\n '''\\n if self.stick.getRawButton(7) == True:\\n self.driveFlag=0\\n self.drive.setMaxOutput(0.5)\\n if self.stick.getRawButton(8) == True:\\n self.driveFlag=1\\n self.driveb = wpilib.drive.DifferentialDrive(self.right, self.left)\\n self.driveb.setMaxOutput(0.5)\\n if self.driveFlag==1:\\n self.driveb.arcadeDrive(self.stick.getRawAxis(5), self.stick.getRawAxis(4))\\n '''\\n if self.driveFlag==0:\\n self.drive.arcadeDrive(self.stick.getRawAxis(1), self.stick.getRawAxis(0))\\n \\n #Camera Point Front:\\n if self.stick.getPOV()==0:\\n self.SV1.set(1.0)\\n self.sd.putValue('Camera','Forward')\\n #Camera Point Back:\\n if self.stick.getPOV()==180:\\n self.SV1.set(-1.0)\\n self.sd.putValue('Camera','Backward')\\n #Orient Servo 2\\n if self.stick.getPOV()==90:\\n self.SV2.set(0.5)\\n #Orient Servo 2\\n if self.stick.getPOV()==270:\\n self.SV2.set(-0.6)\\n \\n if self.stick.getRawButton(1) == True:\\n self.prepareCubeFlag = 1\\n self.EC1.reset()\\n if self.prepareCubeFlag > 0:\\n self.prepareGrabCube()\\n if self.stick.getRawButton(2) == True:\\n self.grabCubeFlag = 1\\n self.EC1.reset()\\n if self.grabCubeFlag > 0:\\n self.grabCube()\\n self.EC2.reset()\\n if self.stick.getRawButton(3) == True:\\n self.deliverCubeFlag = 1\\n if self.deliverCubeFlag > 0: \\n self.deliverCube()\\n if self.stick.getRawButton(5) == True:\\n self.E.set(-0.3)\\n if self.stick.getRawButton(6) == True:\\n self.E.set(0.3)\\n \\n #Dashboard\\n self.sd.putNumber('Speed', 0.5)\\n self.sd.putNumber('Gyro',self.gyro.getAngle())\\n self.sd.putValue(\\\"Camera\\\", \\\"Forwards\\\")\\n self.sd.putValue(\\\"SW1\\\", self.SW1.get())\\n self.sd.putValue(\\\"SW0\\\", self.SW0.get())\\n self.sd.putValue(\\\"EC1\\\",self.EC1.getDistance())\\n self.sd.putValue(\\\"EC2\\\",self.EC2.getDistance())\",\n \"def run1():\\n #Reseting motors\\n ResetRobot.reset_wheel_motors()\\n ResetRobot.reset_attachment_motors()\\n CalibrateRobot.calibrate_gyro()\\n\\n #mission M01 and M02 - space travel and solar panel\\n M01_M02()\\n \\n #Mission M05- Extraction \\n M05_M14()\\n\\n #Back to base before Gerhard (Remove comment if necessary)\\n return_to_base1()\\n\\n # Must delete for competition.. This is to set up forklift to repeat run.\\n Robot.attachment_left.on_for_rotations(-100, 8) #Raises Forklift \",\n \"def clean(self):\\n\\n if (self.clean_level == 'dusty') | (self.clean_level == 'clean'):\\n idx, = np.where(self['B_flag'] == 0)\\n self.data = self[idx, :]\\n\\n return\",\n \"def mv_step(self):\\n # def mv_all(self):\\n self.device_reg_data &= ~(0x1 << 3)\\n bus.write_byte_data(self.device_address, self.device_reg_mode1, self.device_reg_data)\",\n \"def kernelStopping(self):\\n # Always call parent method to be safe.\\n super().kernelStopping()\\n self.writeFundamental()\",\n \"def fuse(self):\\n # TODO: Don't fuse unless they have None as the end slants?\\n i = 0\\n while i < len(self.segments) - 1:\\n left = self.segments[i]\\n right = self.segments[i + 1]\\n if (\\n isinstance(left, LineSegment)\\n and isinstance(right, LineSegment)\\n and left.width == right.width\\n and left.color == right.color\\n and collinear(left.a, left.b, right.b)\\n ):\\n fused_segment = left.fused_with(right)\\n self.segments[i:i+2] = [fused_segment]\\n # Leave i unchanged so fused_segment will be the\\n # \\\"left\\\" segment next iteration.\\n else:\\n # Cannot fuse, try the next pair.\\n i += 1\",\n \"def cleanup_steps(self):\\n # NOTE: This must be called so that camera pipeline is closed successfully\\n self.thread.stop()\\n cv2.imwrite('images/temp_training_lax_goal.png',\\n self.updated_temp_goal_image)\",\n \"def mv_all(self):\\n # def mv_step(self):\\n self.device_reg_data &= ~(0x1 << 2)\\n bus.write_byte_data(self.device_address, self.device_reg_mode1, self.device_reg_data)\",\n \"def test_drive(self):\\n global ENV, TRAFFIC_LIGHT\\n ENV = simpy.Environment()\\n TRAFFIC_LIGHT = TrafficLight()\\n bus = Bus(nr=0)\\n ENV.process(bus.drive())\\n ENV.run()\\n self.assertEqual(bus.movement.to_pos, 600)\",\n \"def run(self):\\n\\n print(self.rf)\\n\\n try:\\n if not os.path.exists(self.iso_f1): # If no iso file exists, it automatically creates one\\n ratio = 1\\n ncol, nlin, nelem, blocks, centerxy = mesh_geometry(self.mf)\\n isod = [[1, 1 * ratio] for i in range(nelem)]\\n isodat = str(nelem) + '\\\\n' + '\\\\n'.join([' '.join(list(map(str, l))) for l in isod])\\n with open(self.iso_f1, 'w') as md:\\n md.write(isodat)\\n md.close()\\n except:\\n pass\\n\\n print('starting Crtomo')\\n\\n file_list = [self.mf, self.ef, self.df, self.rwf,\\n self.iso_f1, self.iso_f2, self.smf, self.f1, self.rmf, self.f3]\\n\\n pfn = jp(self.rf, 'config')\\n if not os.path.exists(pfn):\\n os.mkdir(pfn)\\n\\n copyfile(jp(os.path.dirname(self.crtomo_exe), 'crtritime.cfg'), jp(pfn, 'crtritime.cfg')) # Copies cfg file\\n\\n for f in file_list: # Copies each important file in the 'config' folder\\n try:\\n fname = path_leaf(f)\\n copyfile(f, jp(pfn, fname))\\n except:\\n pass\\n\\n sp.call([self.crtomo_exe]) # Runs the exe\\n\\n print('process over')\",\n \"def darksubtract(dir='Flats', master_dark='Darks/Dark60sec0807.fits'):\\n # master_dark = input(\\\"Which Master Dark in the /Darks/ folder (or otherwise) would you like to use?\\\")\\n\\n # if answer == 'Y':\\n # print(\\\"The script is now running....\\\")\\n # else:\\n # print(\\\"You have chosen to quit this program\\\")\\n # raise SystemExit\\n\\n if dir == \\\"Flats\\\":\\n dir = 'Flats/*/'\\n elif dir == \\\"Skys\\\":\\n dir = 'Skys/*/'\\n elif dir ==\\\"Objects\\\":\\n dir = 'Objects/*/*/'\\n\\n mdark = CCDData.read(master_dark, unit=\\\"adu\\\")\\n\\n for d in glob(dir):\\n keys = ['OBJECT', 'CAMNAME', 'FWINAME', 'ITIME', 'DATE-OBS', 'FLSPECTR', 'HISTORY']\\n images = ImageFileCollection(d, keywords=keys, glob_exclude='d*', glob_include='*.fits')\\n\\n directory = d + '/dark_subtracted'\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n # Read in all files from /FLATS/ subdirectories and subtract the master_dark. The output is stored in 'dflat'.\\n for flat, fname in images.hdus(return_fname=True):\\n meta = flat.header\\n meta['FILENAME'] = fname\\n flat_exposure = flat.header['ITIME']\\n flats = CCDData(data=flat.data.astype('float32'), meta=meta, unit=\\\"adu\\\")\\n dflat = (ccdproc.subtract_dark(flats, mdark, exposure_time='ITIME',\\n exposure_unit=u.second,\\n add_keyword={'HISTORY': 'Dark Subtracted', 'OBSDATE': flat.header['DATE-OBS'],\\n 'CRVAL1': meta['CRVAL1'], 'CRVAL2': meta['CRVAL2']},\\n scale=True))\\n #print(dflat.meta['CRVAL1'])\\n dflat.wcs = None\\n dflat.write(directory + '/d' + fname, overwrite=True)\\n fits.writeto\",\n \"def goForwardsMF(state, dico):\\n oppDef = nearest_defender_def(state, state.opponents, dico['rayDribble'])\\n if oppDef is not None:\\n tm = free_teammate(state, dico['angleInter'])\\n if tm is not None and must_pass_ball(state, tm, dico['angleInter']) \\\\\\n and not is_under_pressure(state, tm, dico['rayPressing']):\\n return passBall(state, tm, dico['powerPasse'], dico['thetaPasse'], dico['coeffPushUp'])+\\\\\\n pushUp(state, dico['coeffPushUp'])\\n if state.numPlayers == 4:\\n return dribble(state, oppDef, dico['angleDribble'], dico['powerDribble'], dico['coeffAD'])\\n else : # state.numPlayers == 2\\n return dribble_speed(state, oppDef, dico['angleDribble'], dico['powerDribble'], dico['coeffAD'])\\n return control(state, dico['controleMT'])\",\n \"def run(self) :\\n file = ROOT.TFile(self.input, \\\"UPDATE\\\")\\n if not file :\\n print \\\"file not found: \\\", self.input\\n for dir in self.directories :\\n if self.verbose:\\n print \\\"Morphing directory: %s\\\" % dir\\n for sample in self.samples :\\n if self.verbose:\\n print \\\"Morphing sample: %s\\\" % sample\\n for idx in range(len(self.masses)-1) :\\n nbin = int((float(self.masses[idx+1])-float(self.masses[idx]))/self.step_size)\\n if nbin > 1 :\\n for x in range(nbin-1) :\\n # This formatting is valid for 0.5 GeV bins up to TeV\\n # Returns 111 for 111.0, 111.5 for 111.5\\n value = \\\"%.4g\\\" % (float(self.masses[idx])+(x+1)*float(self.step_size))\\n if self.verbose:\\n print \\\"Morphing %0.1f between (%0.1f, %0.1f)\\\" % tuple(float(x) for x in (value, self.masses[idx], self.masses[idx+1]))\\n self.morph_hist(file, dir, sample, self.masses[idx], self.masses[idx+1], value)\\n for uncert in self.uncerts :\\n if not uncert == '' :\\n self.morph_hist(file, dir, sample+'_'+uncert+'Up', self.masses[idx], self.masses[idx+1], value)\\n self.morph_hist(file, dir, sample+'_'+uncert+'Down', self.masses[idx], self.masses[idx+1], value)\\n else :\\n if self.verbose :\\n print \\\"nothing needs to be done here: nbin =\\\", nbin\",\n \"def to_feather(self,dirPaths,expandCategory=False,expandTime=False,preprocessType='ignore',sepLabel = False,version = 1,chunksize=None):\\n return io.to_feather(\\n dirPaths= dirPaths,\\n time_series_data= self.time_series_data,\\n expandCategory = expandCategory,\\n expandTime = expandTime,\\n preprocessType = preprocessType,\\n seperateLabels= sepLabel,\\n version= version,\\n chunksize= chunksize\\n )\",\n \"def post_solve_bird_wood(arbiter, space_obj, _):\\n #removing polygon\\n removed_poly = []\\n if arbiter.total_impulse.length > 1100:\\n object1, object2 = arbiter.shapes\\n for Each_column in columns:\\n if object2 == Each_column.shape:\\n removed_poly.append(Each_column)\\n for Each_beam in beams:\\n if object2 == Each_beam.shape:\\n removed_poly.append(Each_beam)\\n for Each_poly in removed_poly:\\n if Each_poly in columns:\\n columns.remove(Each_poly)\\n if Each_poly in beams:\\n beams.remove(Each_poly)\\n space_obj.remove(object2, object2.body)\\n #you can also remove bird if you want\",\n \"def segment_and_find_positions(self):\\n initial_image = self.data\\n xdim = self.data.shape[0]\\n\\n ydim = self.data.shape[1]\\n downsized_image = transform.resize(\\n initial_image,\\n (xdim / DOWNSCALING_FACTOR, ydim / DOWNSCALING_FACTOR),\\n mode=\\\"constant\\\",\\n )\\n rescaled_image = exposure.rescale_intensity(downsized_image)\\n print(\\\"Starting Canny filtering\\\")\\n g_edges = skimage.feature.canny(\\n rescaled_image,\\n sigma=self.canny_sigma,\\n low_threshold=self.canny_low_threshold,\\n )\\n print(\\\"Starting dilation\\\")\\n dilation = morphology.dilation(g_edges, morphology.disk(3))\\n print(\\\"Starting erosion\\\")\\n eroded = morphology.erosion(dilation, morphology.disk(4))\\n dilation = morphology.dilation(\\n eroded, morphology.diamond(4)\\n ) # Dont change to disk\\n print(\\\"Starting to remove small holes\\\")\\n filled = morphology.remove_small_holes(\\n dilation, area_threshold=self.remove_small_holes_area_threshold\\n )\\n print(\\\"Starting erosion\\\")\\n eroded = morphology.erosion(filled, morphology.diamond(3))\\n print(\\\"Applying filters\\\")\\n filtered_image = eroded\\n if self.colony_filters_dict is not None:\\n for filter_name in self.colony_filters_dict.keys():\\n filtered_image = segmentation_filters.apply_filter(\\n filter_name, filtered_image, self.colony_filters_dict[filter_name]\\n )\\n\\n colony_edges = morphology.dilation(feature.canny(filtered_image, 0.01))\\n print(\\\"Starting outlining\\\")\\n outline = downsized_image.copy()\\n outline[colony_edges] = 65535\\n distance = ndimage.distance_transform_edt(filtered_image)\\n smoothed_well = ndimage.gaussian_filter(downsized_image, 0.35)\\n outline.copy()\\n objs, num_objs = ndimage.label(filtered_image)\\n print(\\\"Applying filters for points\\\")\\n if self.mode == \\\"A\\\":\\n # point selection: Smoothest point in the center region\\n for obj in range(1, num_objs + 1):\\n print(\\\"On object {} of {}\\\".format(obj, num_objs))\\n mask = objs == obj\\n dist_mask = distance * mask\\n # for each colony,\\n # find the maximum distance from the two fold distance map.\\n # The edge is at 0% and the center of the colony is at 100%\\n d_max = dist_mask.max()\\n # Getting the points which is at least 40% away from the edge\\n top_percent = dist_mask > (d_max * 0.40)\\n colony_mask = smoothed_well * top_percent\\n colony_edges = feature.canny(colony_mask, 0.1)\\n # applying the second distance transform\\n # to find the smoothest point in the correct region\\n inner_edges = ndimage.distance_transform_edt(\\n ~colony_edges * top_percent\\n )\\n smooth_point = numpy.where(inner_edges == inner_edges.max())\\n smooth_point = (smooth_point[0][0], smooth_point[1][0])\\n smooth_point_corrected = (\\n smooth_point[0] * DOWNSCALING_FACTOR,\\n smooth_point[1] * DOWNSCALING_FACTOR,\\n )\\n self._point_locations.append(smooth_point_corrected)\\n elif self.mode == \\\"C\\\":\\n for obj in range(1, num_objs + 1):\\n print(\\\"On object {} of {}\\\".format(obj, num_objs))\\n mask = objs == obj\\n dist_mask = distance * mask\\n # point selection: edge, ridge & center respectively\\n self.get_mode_c_points(dist_mask, 0, 0.03)\\n self.get_mode_c_points(dist_mask, 0.15, 0.20)\\n self.get_mode_c_points(dist_mask, 0.90, 0.99)\",\n \"def main():\\n\\n # Create an instance of our Star Targeter tool\\n starTargeter = StarTargetTool()\\n\\n # Connect to Maxim and perform basic setup\\n starTargeter.connect()\\n\\n\\n # Calibrate the autoguider orientation and scale if requested\\n if PERFORM_CALIBRATION:\\n starTargeter.calibrateAutoGuider(EXPOSURE_LENGTH_SECONDS) \\n\\n # When autoguiding, Maxim normally creats a tiny subframe around\\n # the target star. Since our star may be hundreds of pixels off\\n # from the desired fiber position, first call this routine to\\n # take some full-frame exposures and perform coarse adjustments\\n # to get the star near the target\\n starCenteredSuccessfully = starTargeter.findStarAndMoveToTarget(EXPOSURE_LENGTH_SECONDS, FIBER_X, FIBER_Y, ROUGH_TOLERANCE_PIXELS, maxIterations=5)\\n\\n if starCenteredSuccessfully:\\n # Use Maxim's built-in star tracking routine to\\n # accurately position the star and keep it\\n # on target\\n starTargeter.subframeAndKeepStarOnTarget(EXPOSURE_LENGTH_SECONDS, FIBER_X, FIBER_Y, ROUGH_TOLERANCE_PIXELS)\\n else:\\n print \\\"STAR CENTERING FAILED\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.53458524","0.5341943","0.5341767","0.51823235","0.51823235","0.51713705","0.51584935","0.50687635","0.50499785","0.5038589","0.50249314","0.5024092","0.5023892","0.50143516","0.49986392","0.49689344","0.49604985","0.49398032","0.49370384","0.49188516","0.49081752","0.49075094","0.48980296","0.48947164","0.48892295","0.48620415","0.48538738","0.4850283","0.4842821","0.4827529","0.48196313","0.4805282","0.4790036","0.47821322","0.4774477","0.47664732","0.47640637","0.4761411","0.47610113","0.47497538","0.4749624","0.47484174","0.4743739","0.47391304","0.47233537","0.47233206","0.4714534","0.46966663","0.46950075","0.46924388","0.46910372","0.4683103","0.46829882","0.46820697","0.467815","0.4672467","0.46606663","0.46490225","0.4645599","0.4644494","0.46365115","0.46362466","0.4619292","0.46161592","0.46149042","0.461001","0.46061638","0.46036988","0.45898086","0.45844966","0.4577253","0.457196","0.45700324","0.45665032","0.4566263","0.45656142","0.4563296","0.45628685","0.45627326","0.45549983","0.45526817","0.455111","0.45504323","0.45451874","0.45436367","0.4542598","0.45421752","0.4540018","0.45329702","0.4532631","0.45276147","0.4527134","0.45238483","0.4523481","0.45221317","0.45184627","0.45184508","0.4513548","0.45102504","0.45070773"],"string":"[\n \"0.53458524\",\n \"0.5341943\",\n \"0.5341767\",\n \"0.51823235\",\n \"0.51823235\",\n \"0.51713705\",\n \"0.51584935\",\n \"0.50687635\",\n \"0.50499785\",\n \"0.5038589\",\n \"0.50249314\",\n \"0.5024092\",\n \"0.5023892\",\n \"0.50143516\",\n \"0.49986392\",\n \"0.49689344\",\n \"0.49604985\",\n \"0.49398032\",\n \"0.49370384\",\n \"0.49188516\",\n \"0.49081752\",\n \"0.49075094\",\n \"0.48980296\",\n \"0.48947164\",\n \"0.48892295\",\n \"0.48620415\",\n \"0.48538738\",\n \"0.4850283\",\n \"0.4842821\",\n \"0.4827529\",\n \"0.48196313\",\n \"0.4805282\",\n \"0.4790036\",\n \"0.47821322\",\n \"0.4774477\",\n \"0.47664732\",\n \"0.47640637\",\n \"0.4761411\",\n \"0.47610113\",\n \"0.47497538\",\n \"0.4749624\",\n \"0.47484174\",\n \"0.4743739\",\n \"0.47391304\",\n \"0.47233537\",\n \"0.47233206\",\n \"0.4714534\",\n \"0.46966663\",\n \"0.46950075\",\n \"0.46924388\",\n \"0.46910372\",\n \"0.4683103\",\n \"0.46829882\",\n \"0.46820697\",\n \"0.467815\",\n \"0.4672467\",\n \"0.46606663\",\n \"0.46490225\",\n \"0.4645599\",\n \"0.4644494\",\n \"0.46365115\",\n \"0.46362466\",\n \"0.4619292\",\n \"0.46161592\",\n \"0.46149042\",\n \"0.461001\",\n \"0.46061638\",\n \"0.46036988\",\n \"0.45898086\",\n \"0.45844966\",\n \"0.4577253\",\n \"0.457196\",\n \"0.45700324\",\n \"0.45665032\",\n \"0.4566263\",\n \"0.45656142\",\n \"0.4563296\",\n \"0.45628685\",\n \"0.45627326\",\n \"0.45549983\",\n \"0.45526817\",\n \"0.455111\",\n \"0.45504323\",\n \"0.45451874\",\n \"0.45436367\",\n \"0.4542598\",\n \"0.45421752\",\n \"0.4540018\",\n \"0.45329702\",\n \"0.4532631\",\n \"0.45276147\",\n \"0.4527134\",\n \"0.45238483\",\n \"0.4523481\",\n \"0.45221317\",\n \"0.45184627\",\n \"0.45184508\",\n \"0.4513548\",\n \"0.45102504\",\n \"0.45070773\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72748023"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6384,"cells":{"query":{"kind":"string","value":"Calculate weightings to use for the feather task"},"document":{"kind":"string","value":"def _calc_feather_weighting(param_dict):\n weightings = param_dict['weightings']\n\n if not isinstance(weightings, (list, tuple)):\n return 1.0\n\n return float(weightings[1]) / float(weightings[0])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def calculate_weighted_results():\n pass","def weight(self):","def getWeight(self) -> float:\n ...","def calculateWeights(self):\n return self.distances #En lo que encontramos una funcion que represente","def get_weights(self):","def calculate_weights():\n weights = {}\n\n\n # estimate run time of step 1 (fast sweep)\n f_range = sweeper_script.settings['stop'] - sweeper_script.settings['start']\n N_samples = sweeper_script.settings['samplecount']\n df = f_range / N_samples\n\n t = N_samples / df\n\n weights['quick scan'] = t\n\n # estimate run time of step 2 (high res sweep)\n df = self.settings['high_res_df']\n N_samples = self.settings['high_res_N']\n\n t = N_samples / df\n\n weights['high res scan'] = t\n\n\n total_time = sum([v for k, v in weights.iteritems()])\n\n weights = {k: v/total_time for k, v in weights.iteritems()}\n\n print('weights',weights)\n\n return weights","def get_weight(self):\n pass","def get_weight(self):\n pass","def calcweight( self ):\n weight = 0\n zeroval = 0\n for sensor in ('right_top', 'right_bottom', 'left_top', 'left_bottom'):\n\t\treading = self.readings[sensor]\n\t\tcalibration = self.named_calibration[sensor]\n if sensor == 'right_top':\n zeroval = self.rtzv\n elif sensor == 'right_bottom':\n zeroval = self.rbzv\n elif sensor == 'left_top':\n zeroval = self.ltzv\n else:\n zeroval = self.lbzv\n\t\tif reading > calibration[2]:\n\t\t\tprint \"Warning, %s reading above upper calibration value\" % sensor\n\t\tif reading < calibration[1]:\n\t\t\tweight += 1700 * (reading + zeroval - calibration[0]) / (calibration[1] - calibration[0])\n\t\telse:\n\t\t\tweight += 1700 * (reading + zeroval - calibration[1]) / (calibration[2] - calibration[1]) + 1700\n\n if self.debug == 1:\n print \"weight calculated pre-conversion\", weight\n print \"return val\", self.converttolbs( weight / 100.0 )\n\n # return self.converttolbs( weight / 100.0 )\n return weight / 100.0","def weights(self):\r\n\t\treturn None","def weights(self) -> List[float]:","def _weigh_object(self, host_state, weight_properties):\n\n weight = 0.0\n if host_state.patch_prefer:\n weight += CONF.filter_scheduler.swmgmt_patch_weight_multiplier\n if host_state.upgrade_prefer:\n weight += CONF.filter_scheduler.swmgmt_upgrade_weight_multiplier\n return weight","def get_weight(self):\n # FIXME: BELUM ADA KEPUTUSAN\n return 0","def weight(self):\n counters = [\n (\"total_mhz\", self.dominfo.vms_online + self.dominfo.cpus_online / 4.0),\n (\"memory\", self.dominfo.vms_online + self.dominfo.ram_online / 4096.0),\n ]\n load_w = sum((self.node[k] / float(v or 1)) / self.node[k] for k, v in counters)\n return load_w * self.srv_weight","def totalWeighting(distance, count, data, n):\n\n weighting = (data)*(distance)*count\n weighting = weighting/(np.sum(np.sum(weighting))) \n return weighting","def getWeights(self, gameState, action):\n # return {'successorScore': 1.0}\n if self.isOffensive:\n return self.getOffensiveWeights(gameState, action)\n else:\n return self.getDefensiveWeights(gameState, action)","def _get_weight(self, reaction: db.Reaction) -> Tuple[float, float]:\n for step in reaction.get_elementary_steps(self.db_manager):\n # # # Barrierless weights for barrierless reactions\n if step.get_type() == db.ElementaryStepType.BARRIERLESS:\n return self.barrierless_weight, self.barrierless_weight\n return 1.0, 1.0","def calculate_weight(self, element, total_cores_used, total_disk_used,\n total_memory_used):\n cpu_capacity = self.model.get_resource_from_id(\n resource.ResourceType.cpu_cores).get_capacity(element)\n\n disk_capacity = self.model.get_resource_from_id(\n resource.ResourceType.disk).get_capacity(element)\n\n memory_capacity = self.model.get_resource_from_id(\n resource.ResourceType.memory).get_capacity(element)\n\n score_cores = (1 - (float(cpu_capacity) - float(total_cores_used)) /\n float(cpu_capacity))\n\n # It's possible that disk_capacity is 0, e.g., m1.nano.disk = 0\n if disk_capacity == 0:\n score_disk = 0\n else:\n score_disk = (1 - (float(disk_capacity) - float(total_disk_used)) /\n float(disk_capacity))\n\n score_memory = (\n 1 - (float(memory_capacity) - float(total_memory_used)) /\n float(memory_capacity))\n # TODO(jed): take in account weight\n return (score_cores + score_disk + score_memory) / 3","def weight(self) -> None:\n assert hasattr(self, \"characterized_inventory\"), \"Must do lcia first\"\n if not hasattr(self, \"weighting_value\"):\n self.load_weighting_data()\n self.weighting_calculation()","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def weight(self) -> float:\r\n return self._weight","def ComputeWeights(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\n ...","def getWeights(self, gameState, actton):\n\t\treturn {'successorScore': 1.0}","def calc_weight(base):\n return weights[base] + sum([calc_weight(i) for i in leafs[base]])","def total_weight (self, checkfn=None):\n weight = 0\n for item in self:\n if checkfn is not None and not checkfn(item):\n continue\n assert hasattr(item, \"weight\")\n weight += item.weight\n return weight","def get_weight(self):\n return self.weight","def get_weight(self):\n return self.weight","def weight(self) -> int:\n weight = 0\n if self.models:\n weight += 401 - (1 if callable(self.models) else len(self.models))\n\n if self.manufacturers:\n weight += 301 - (\n 1 if callable(self.manufacturers) else len(self.manufacturers)\n )\n\n weight += 10 * len(self.channel_names)\n weight += 5 * len(self.generic_ids)\n if isinstance(self.aux_channels, frozenset):\n weight += 1 * len(self.aux_channels)\n return weight","def weight(self):\r\n return self._weight","def weight(self) -> int:\n return pulumi.get(self, \"weight\")","def weighted_metrics(self):\n return None","def weightGenerate(self):\n\t\tfor i in range(0, self.numberOfInput):\n\t\t\tself.weight.append(random.random()-0.5)","def weighting(self) -> None:\n warnings.warn('Please switch to `.weight`', DeprecationWarning)\n return self.weight()","def update_relative_weight(self):\n self.relative_weight = 1\n # Add up all of the historical cpu datapoints (higher CPU = more weight)\n for i in self.cpu_datapoints:\n self.relative_weight += i\n # Multiply by the status value (so VMs with red alarm have most weight)\n self.relative_weight *= (self.heartbeat_status * 10)","def weight(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"weight\")","def get_weight(self):\n return self.weight # return the weight value","def getWeight(self):\n return self.weight / (1 + self.numVisits)","def get_weight(self):\r\n weight = self.weight\r\n if weight is None:\r\n weight = 1\r\n return weight","def weight(self):\n return self._base.weight","def get_weights(self):\r\n return self.weights","def get_weights(self):\r\n return self.weights","def weighting_calculation(self) -> None:\n if hasattr(self, \"normalized_inventory\"):\n obj = self.normalized_inventory\n else:\n obj = self.characterized_inventory\n self.weighted_inventory = self.weighting_matrix * obj","def getWeightsAttack(self, gameState, action):\r\n return {'minDistToFood': -1,'getFood': 100}","def weight(self):\n return self._weight","def weight(self):\n return self._weight","def weight(self):\n return self._weight","def get_sample_weights(self):\n target_to_weight = {}\n for target, count in self.class_count.items():\n target_to_weight[target] = self.total / count\n\n sample_weights = []\n for _, target in self.imgs:\n sample_weights.append(target_to_weight[target])\n\n return sample_weights","def __weight_func(self, u: str, _: str, d: Dict):\n # # # Weight of edge\n edge_wt = d.get(\"weight\", 0)\n # # # List of required compounds\n tmp_required_compounds = d.get(\"required_compounds\", None)\n # # # Sum over costs of required compounds.\n # # # Only for edges from compound node to rxn node\n if ';' not in u and tmp_required_compounds is not None:\n required_compound_costs = np.sum([self.compound_costs[n] for n in tmp_required_compounds])\n else:\n required_compound_costs = 0.0\n\n return edge_wt + required_compound_costs","def gen_weights(self, f_target):\n\n # calculate x and psi\n x_track = self.cs.rollout()\n psi_track = self.gen_psi(x_track)\n\n # efficiently calculate BF weights using weighted linear regression\n self.w = jnp.zeros((self.n_dmps, self.n_bfs))\n for d in range(self.n_dmps):\n # spatial scaling term\n k = self.goal[d] - self.y0[d]\n for b in range(self.n_bfs):\n numer = jnp.sum(x_track * psi_track[:, b] * f_target[:, d])\n denom = jnp.sum(x_track ** 2 * psi_track[:, b])\n self.w[d, b] = numer / denom\n if abs(k) > 1e-5:\n self.w[d, b] /= k\n\n self.w = jnp.nan_to_num(self.w)","def calculations():\r\n\t\r\n\tpayload, avionics, booster = weight_input()\r\n\r\n\tdrogue_size, drogue_force = drogue_calc()\r\n\tmain_size, main_force = main_calc(avionics, booster, drogue_force) #total mass, payload detaches\r\n\r\n\tprint(\"Drogue is diameter is \" + str(drogue_size) + \" inches\")\r\n\tprint(\"Main is diameter is \" + str(main_size) + \" inches\")","def calc_is_weight(self, nodes_value):\n beta = self.beta.step()\n nodes_value = torch.tensor(nodes_value)\n sample_probabilities = nodes_value / self.sum_tree.top_node.value\n weights = ((1 / (len(self) * sample_probabilities.to(self.device))) ** beta)\n weights /= weights.max()\n return weights","def get_weights(self, extra=None):\n self._set_cuda_device()\n\n if extra is None:\n extra = {}\n\n # by default return current weights, return best if requested via model type.\n self.phase = FlPhase.GET_WEIGHTS\n\n if ExtraItems.MODEL_TYPE in extra:\n model_type = extra.get(ExtraItems.MODEL_TYPE)\n if not isinstance(model_type, ModelType):\n raise ValueError(\n f\"Expected requested model type to be of type `ModelType` but received {type(model_type)}\"\n )\n if model_type in self.model_filepaths:\n model_path = os.path.join(self.bundle_root, cast(str, self.model_filepaths[model_type]))\n if not os.path.isfile(model_path):\n raise ValueError(f\"No best model checkpoint exists at {model_path}\")\n weights = torch.load(model_path, map_location=\"cpu\")\n # if weights contain several state dicts, use the one defined by `save_dict_key`\n if isinstance(weights, dict) and self.save_dict_key in weights:\n weights = weights.get(self.save_dict_key)\n weigh_type: WeightType | None = WeightType.WEIGHTS\n stats: dict = {}\n self.logger.info(f\"Returning {model_type} checkpoint weights from {model_path}.\")\n else:\n raise ValueError(\n f\"Requested model type {model_type} not specified in `model_filepaths`: {self.model_filepaths}\"\n )\n else:\n if self.trainer:\n weights = get_state_dict(self.trainer.network)\n # returned weights will be on the cpu\n for k in weights.keys():\n weights[k] = weights[k].cpu()\n weigh_type = WeightType.WEIGHTS\n stats = self.trainer.get_stats()\n # calculate current iteration and epoch data after training.\n stats[FlStatistics.NUM_EXECUTED_ITERATIONS] = self.trainer.state.iteration - self.iter_of_start_time\n # compute weight differences\n if self.send_weight_diff:\n weights = compute_weight_diff(global_weights=self.global_weights, local_var_dict=weights)\n weigh_type = WeightType.WEIGHT_DIFF\n self.logger.info(\"Returning current weight differences.\")\n else:\n self.logger.info(\"Returning current weights.\")\n else:\n weights = None\n weigh_type = None\n stats = dict()\n\n if not isinstance(stats, dict):\n raise ValueError(f\"stats is not a dict, {stats}\")\n return_weights = ExchangeObject(\n weights=weights,\n optim=None, # could be self.optimizer.state_dict()\n weight_type=weigh_type,\n statistics=stats,\n )\n\n # filter weights if needed (use to apply differential privacy, encryption, compression, etc.)\n if self.post_weight_filters is not None:\n for _filter in self.post_weight_filters:\n return_weights = _filter(return_weights, extra)\n\n return return_weights","def get_weights(self):\n return self.weights\n #print(W)","def get_weights(self):\n return self._weight","def _weighted(self):\n return self.dataset.weighted(self.probability)","def update_weights(self):\n\t\tpass","def get_weights(self):\n return self.__weights","def weights(self):\n return self.__weights","def weights(self):\n return self.__weights","def weights(self):\n return self.__weights","def weights(self):\n return self.__weights","def weights(self):\n return self.__weights","def rebalance_weightings(context):\r\n total_ratio = 0\r\n log.info(\"*******Rebalancing weightings********\")\r\n print(context.up_ratios)\r\n \r\n for asset, ratio in context.up_ratios.items():\r\n total_ratio += ratio\r\n \r\n for asset, ratio in context.up_ratios.items():\r\n context.max_weights[asset] = ratio/total_ratio\r\n \r\n log.info(context.max_weights)","def class_weights(self):\n target_list = self.label\n count_dict = Counter(target_list)\n class_count = [count_dict[i] for i in range(3)]\n class_weights = len(target_list) / torch.tensor(class_count, dtype=torch.float)\n class_weights = class_weights / class_weights.sum()\n print(class_weights) # noqa: T001\n return class_weights","def get_weight_list(self) -> List[float]:\n return self._weight_list","def evaluate(self, representativeness: float, weight: float) -> float:\n pass","def weight() -> int:\n return floor(stakedTokens / MINIMUM_STAKE)","def my_assign_weights(context, data):\n pass","def weight_statistics(self) -> Dict[str, Dict[str, List[float]]]:\n return self._weights_statistics","def get_weights(self):\n return self.weights","def get_weights(self):\n return self.weights","def init_weights(self):\n\n params = torch.load(self.resnet_weight)\n\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\n\n\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\n self.fc3.out_features)\n self.fc3.weight.data.uniform_(-r, r)\n self.fc3.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\n self.fc4.out_features)\n self.fc4.weight.data.uniform_(-r, r)\n self.fc4.bias.data.fill_(0)","def weight(self):\n return self._hx711.get_weight()","def weights(self):\n return self._weights","def weights(self):\n return self._weights","def weights(self):\n return self._weights","def weights(self):\n return self._weights","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def update_speed_weights_step(self):\n \n weights_list = [self.W_speed_east, self.W_speed_west,self.W_speed_north,self.W_speed_south]\n speed_input_list = [self.speed_inputs_east,self.speed_inputs_west,\n self.speed_inputs_north,self.speed_inputs_south]\n \n if self.use_eight_directions is True:\n weights_list+=[self.W_speed_north_east,\n self.W_speed_north_west,self.W_speed_south_east,self.W_speed_south_west]\n \n speed_input_list+=[self.speed_inputs_north_east,self.speed_inputs_north_west, \n self.speed_inputs_south_east,self.speed_inputs_south_west]\n\n \n for weights,speed_input in zip(weights_list,speed_input_list):\n \n \n weight_update=speed_input*(self.rr[:self.N_e]-self.input_mean)*(self.rr_e_trace.T-self.input_mean)\n weights+=self.learn_rate_speed_weights*weight_update\n\n\n # normalize to fixed mean of incoming and outgoing weights\n weights-=(weights.mean(axis=1)-self.W_av_star)[:,np.newaxis]\n weights-=(weights.mean(axis=0)-self.W_av_star)[np.newaxis,:]\n \n # clip weights \n np.clip(weights,0,self.W_max_e,out=weights)","def getWeight(self, nengine, powerReq, tech_factor):\n\n P_ins = powerReq # in kw, per unit\n \n mass = turbo_engine(P_ins) *nengine\n\n total = {'total': mass*tech_factor}\n return total # dictionary, units are SI [kg]","def atom_weight(self, manager):\n identity = \"HOH\" if self.resname in WATER_RES_NAMES else self.identity()\n # Waters that don't have B-factors at least 1 stddev below the mean are\n # presumed to be correct\n if (identity == \"HOH\" and\n (self.atom.b > manager.b_mean_hoh - manager.b_stddev_hoh)):\n return 0\n if self.is_correctly_identified(identity = identity):\n return 0\n # B-factors/occupancies?\n if self.FOFC_PEAK in self.inaccuracies[identity] or self.atom.b < 1:\n return 1\n if self.FOFC_HOLE in self.inaccuracies[identity]:\n return -1\n return 0","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def numWeights(self):\r\n\t\treturn None","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def get_current_weight(self):\n return sum([shipment.weight for shipment in self.shipments])","def weight_setup(self, weighting):\n if weighting == \"overlap\":\n self.weights = overlap_generator(overlap, self.graph)\n elif weighting == \"unit\":\n self.weights = overlap_generator(unit, self.graph)\n elif weighting == \"min_norm\":\n self.weights = overlap_generator(min_norm, self.graph)\n else:\n self.weights = overlap_generator(normalized_overlap, self.graph)","def weight(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"weight\")"],"string":"[\n \"def calculate_weighted_results():\\n pass\",\n \"def weight(self):\",\n \"def getWeight(self) -> float:\\n ...\",\n \"def calculateWeights(self):\\n return self.distances #En lo que encontramos una funcion que represente\",\n \"def get_weights(self):\",\n \"def calculate_weights():\\n weights = {}\\n\\n\\n # estimate run time of step 1 (fast sweep)\\n f_range = sweeper_script.settings['stop'] - sweeper_script.settings['start']\\n N_samples = sweeper_script.settings['samplecount']\\n df = f_range / N_samples\\n\\n t = N_samples / df\\n\\n weights['quick scan'] = t\\n\\n # estimate run time of step 2 (high res sweep)\\n df = self.settings['high_res_df']\\n N_samples = self.settings['high_res_N']\\n\\n t = N_samples / df\\n\\n weights['high res scan'] = t\\n\\n\\n total_time = sum([v for k, v in weights.iteritems()])\\n\\n weights = {k: v/total_time for k, v in weights.iteritems()}\\n\\n print('weights',weights)\\n\\n return weights\",\n \"def get_weight(self):\\n pass\",\n \"def get_weight(self):\\n pass\",\n \"def calcweight( self ):\\n weight = 0\\n zeroval = 0\\n for sensor in ('right_top', 'right_bottom', 'left_top', 'left_bottom'):\\n\\t\\treading = self.readings[sensor]\\n\\t\\tcalibration = self.named_calibration[sensor]\\n if sensor == 'right_top':\\n zeroval = self.rtzv\\n elif sensor == 'right_bottom':\\n zeroval = self.rbzv\\n elif sensor == 'left_top':\\n zeroval = self.ltzv\\n else:\\n zeroval = self.lbzv\\n\\t\\tif reading > calibration[2]:\\n\\t\\t\\tprint \\\"Warning, %s reading above upper calibration value\\\" % sensor\\n\\t\\tif reading < calibration[1]:\\n\\t\\t\\tweight += 1700 * (reading + zeroval - calibration[0]) / (calibration[1] - calibration[0])\\n\\t\\telse:\\n\\t\\t\\tweight += 1700 * (reading + zeroval - calibration[1]) / (calibration[2] - calibration[1]) + 1700\\n\\n if self.debug == 1:\\n print \\\"weight calculated pre-conversion\\\", weight\\n print \\\"return val\\\", self.converttolbs( weight / 100.0 )\\n\\n # return self.converttolbs( weight / 100.0 )\\n return weight / 100.0\",\n \"def weights(self):\\r\\n\\t\\treturn None\",\n \"def weights(self) -> List[float]:\",\n \"def _weigh_object(self, host_state, weight_properties):\\n\\n weight = 0.0\\n if host_state.patch_prefer:\\n weight += CONF.filter_scheduler.swmgmt_patch_weight_multiplier\\n if host_state.upgrade_prefer:\\n weight += CONF.filter_scheduler.swmgmt_upgrade_weight_multiplier\\n return weight\",\n \"def get_weight(self):\\n # FIXME: BELUM ADA KEPUTUSAN\\n return 0\",\n \"def weight(self):\\n counters = [\\n (\\\"total_mhz\\\", self.dominfo.vms_online + self.dominfo.cpus_online / 4.0),\\n (\\\"memory\\\", self.dominfo.vms_online + self.dominfo.ram_online / 4096.0),\\n ]\\n load_w = sum((self.node[k] / float(v or 1)) / self.node[k] for k, v in counters)\\n return load_w * self.srv_weight\",\n \"def totalWeighting(distance, count, data, n):\\n\\n weighting = (data)*(distance)*count\\n weighting = weighting/(np.sum(np.sum(weighting))) \\n return weighting\",\n \"def getWeights(self, gameState, action):\\n # return {'successorScore': 1.0}\\n if self.isOffensive:\\n return self.getOffensiveWeights(gameState, action)\\n else:\\n return self.getDefensiveWeights(gameState, action)\",\n \"def _get_weight(self, reaction: db.Reaction) -> Tuple[float, float]:\\n for step in reaction.get_elementary_steps(self.db_manager):\\n # # # Barrierless weights for barrierless reactions\\n if step.get_type() == db.ElementaryStepType.BARRIERLESS:\\n return self.barrierless_weight, self.barrierless_weight\\n return 1.0, 1.0\",\n \"def calculate_weight(self, element, total_cores_used, total_disk_used,\\n total_memory_used):\\n cpu_capacity = self.model.get_resource_from_id(\\n resource.ResourceType.cpu_cores).get_capacity(element)\\n\\n disk_capacity = self.model.get_resource_from_id(\\n resource.ResourceType.disk).get_capacity(element)\\n\\n memory_capacity = self.model.get_resource_from_id(\\n resource.ResourceType.memory).get_capacity(element)\\n\\n score_cores = (1 - (float(cpu_capacity) - float(total_cores_used)) /\\n float(cpu_capacity))\\n\\n # It's possible that disk_capacity is 0, e.g., m1.nano.disk = 0\\n if disk_capacity == 0:\\n score_disk = 0\\n else:\\n score_disk = (1 - (float(disk_capacity) - float(total_disk_used)) /\\n float(disk_capacity))\\n\\n score_memory = (\\n 1 - (float(memory_capacity) - float(total_memory_used)) /\\n float(memory_capacity))\\n # TODO(jed): take in account weight\\n return (score_cores + score_disk + score_memory) / 3\",\n \"def weight(self) -> None:\\n assert hasattr(self, \\\"characterized_inventory\\\"), \\\"Must do lcia first\\\"\\n if not hasattr(self, \\\"weighting_value\\\"):\\n self.load_weighting_data()\\n self.weighting_calculation()\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def weight(self) -> float:\\r\\n return self._weight\",\n \"def ComputeWeights(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\\n ...\",\n \"def getWeights(self, gameState, actton):\\n\\t\\treturn {'successorScore': 1.0}\",\n \"def calc_weight(base):\\n return weights[base] + sum([calc_weight(i) for i in leafs[base]])\",\n \"def total_weight (self, checkfn=None):\\n weight = 0\\n for item in self:\\n if checkfn is not None and not checkfn(item):\\n continue\\n assert hasattr(item, \\\"weight\\\")\\n weight += item.weight\\n return weight\",\n \"def get_weight(self):\\n return self.weight\",\n \"def get_weight(self):\\n return self.weight\",\n \"def weight(self) -> int:\\n weight = 0\\n if self.models:\\n weight += 401 - (1 if callable(self.models) else len(self.models))\\n\\n if self.manufacturers:\\n weight += 301 - (\\n 1 if callable(self.manufacturers) else len(self.manufacturers)\\n )\\n\\n weight += 10 * len(self.channel_names)\\n weight += 5 * len(self.generic_ids)\\n if isinstance(self.aux_channels, frozenset):\\n weight += 1 * len(self.aux_channels)\\n return weight\",\n \"def weight(self):\\r\\n return self._weight\",\n \"def weight(self) -> int:\\n return pulumi.get(self, \\\"weight\\\")\",\n \"def weighted_metrics(self):\\n return None\",\n \"def weightGenerate(self):\\n\\t\\tfor i in range(0, self.numberOfInput):\\n\\t\\t\\tself.weight.append(random.random()-0.5)\",\n \"def weighting(self) -> None:\\n warnings.warn('Please switch to `.weight`', DeprecationWarning)\\n return self.weight()\",\n \"def update_relative_weight(self):\\n self.relative_weight = 1\\n # Add up all of the historical cpu datapoints (higher CPU = more weight)\\n for i in self.cpu_datapoints:\\n self.relative_weight += i\\n # Multiply by the status value (so VMs with red alarm have most weight)\\n self.relative_weight *= (self.heartbeat_status * 10)\",\n \"def weight(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"weight\\\")\",\n \"def get_weight(self):\\n return self.weight # return the weight value\",\n \"def getWeight(self):\\n return self.weight / (1 + self.numVisits)\",\n \"def get_weight(self):\\r\\n weight = self.weight\\r\\n if weight is None:\\r\\n weight = 1\\r\\n return weight\",\n \"def weight(self):\\n return self._base.weight\",\n \"def get_weights(self):\\r\\n return self.weights\",\n \"def get_weights(self):\\r\\n return self.weights\",\n \"def weighting_calculation(self) -> None:\\n if hasattr(self, \\\"normalized_inventory\\\"):\\n obj = self.normalized_inventory\\n else:\\n obj = self.characterized_inventory\\n self.weighted_inventory = self.weighting_matrix * obj\",\n \"def getWeightsAttack(self, gameState, action):\\r\\n return {'minDistToFood': -1,'getFood': 100}\",\n \"def weight(self):\\n return self._weight\",\n \"def weight(self):\\n return self._weight\",\n \"def weight(self):\\n return self._weight\",\n \"def get_sample_weights(self):\\n target_to_weight = {}\\n for target, count in self.class_count.items():\\n target_to_weight[target] = self.total / count\\n\\n sample_weights = []\\n for _, target in self.imgs:\\n sample_weights.append(target_to_weight[target])\\n\\n return sample_weights\",\n \"def __weight_func(self, u: str, _: str, d: Dict):\\n # # # Weight of edge\\n edge_wt = d.get(\\\"weight\\\", 0)\\n # # # List of required compounds\\n tmp_required_compounds = d.get(\\\"required_compounds\\\", None)\\n # # # Sum over costs of required compounds.\\n # # # Only for edges from compound node to rxn node\\n if ';' not in u and tmp_required_compounds is not None:\\n required_compound_costs = np.sum([self.compound_costs[n] for n in tmp_required_compounds])\\n else:\\n required_compound_costs = 0.0\\n\\n return edge_wt + required_compound_costs\",\n \"def gen_weights(self, f_target):\\n\\n # calculate x and psi\\n x_track = self.cs.rollout()\\n psi_track = self.gen_psi(x_track)\\n\\n # efficiently calculate BF weights using weighted linear regression\\n self.w = jnp.zeros((self.n_dmps, self.n_bfs))\\n for d in range(self.n_dmps):\\n # spatial scaling term\\n k = self.goal[d] - self.y0[d]\\n for b in range(self.n_bfs):\\n numer = jnp.sum(x_track * psi_track[:, b] * f_target[:, d])\\n denom = jnp.sum(x_track ** 2 * psi_track[:, b])\\n self.w[d, b] = numer / denom\\n if abs(k) > 1e-5:\\n self.w[d, b] /= k\\n\\n self.w = jnp.nan_to_num(self.w)\",\n \"def calculations():\\r\\n\\t\\r\\n\\tpayload, avionics, booster = weight_input()\\r\\n\\r\\n\\tdrogue_size, drogue_force = drogue_calc()\\r\\n\\tmain_size, main_force = main_calc(avionics, booster, drogue_force) #total mass, payload detaches\\r\\n\\r\\n\\tprint(\\\"Drogue is diameter is \\\" + str(drogue_size) + \\\" inches\\\")\\r\\n\\tprint(\\\"Main is diameter is \\\" + str(main_size) + \\\" inches\\\")\",\n \"def calc_is_weight(self, nodes_value):\\n beta = self.beta.step()\\n nodes_value = torch.tensor(nodes_value)\\n sample_probabilities = nodes_value / self.sum_tree.top_node.value\\n weights = ((1 / (len(self) * sample_probabilities.to(self.device))) ** beta)\\n weights /= weights.max()\\n return weights\",\n \"def get_weights(self, extra=None):\\n self._set_cuda_device()\\n\\n if extra is None:\\n extra = {}\\n\\n # by default return current weights, return best if requested via model type.\\n self.phase = FlPhase.GET_WEIGHTS\\n\\n if ExtraItems.MODEL_TYPE in extra:\\n model_type = extra.get(ExtraItems.MODEL_TYPE)\\n if not isinstance(model_type, ModelType):\\n raise ValueError(\\n f\\\"Expected requested model type to be of type `ModelType` but received {type(model_type)}\\\"\\n )\\n if model_type in self.model_filepaths:\\n model_path = os.path.join(self.bundle_root, cast(str, self.model_filepaths[model_type]))\\n if not os.path.isfile(model_path):\\n raise ValueError(f\\\"No best model checkpoint exists at {model_path}\\\")\\n weights = torch.load(model_path, map_location=\\\"cpu\\\")\\n # if weights contain several state dicts, use the one defined by `save_dict_key`\\n if isinstance(weights, dict) and self.save_dict_key in weights:\\n weights = weights.get(self.save_dict_key)\\n weigh_type: WeightType | None = WeightType.WEIGHTS\\n stats: dict = {}\\n self.logger.info(f\\\"Returning {model_type} checkpoint weights from {model_path}.\\\")\\n else:\\n raise ValueError(\\n f\\\"Requested model type {model_type} not specified in `model_filepaths`: {self.model_filepaths}\\\"\\n )\\n else:\\n if self.trainer:\\n weights = get_state_dict(self.trainer.network)\\n # returned weights will be on the cpu\\n for k in weights.keys():\\n weights[k] = weights[k].cpu()\\n weigh_type = WeightType.WEIGHTS\\n stats = self.trainer.get_stats()\\n # calculate current iteration and epoch data after training.\\n stats[FlStatistics.NUM_EXECUTED_ITERATIONS] = self.trainer.state.iteration - self.iter_of_start_time\\n # compute weight differences\\n if self.send_weight_diff:\\n weights = compute_weight_diff(global_weights=self.global_weights, local_var_dict=weights)\\n weigh_type = WeightType.WEIGHT_DIFF\\n self.logger.info(\\\"Returning current weight differences.\\\")\\n else:\\n self.logger.info(\\\"Returning current weights.\\\")\\n else:\\n weights = None\\n weigh_type = None\\n stats = dict()\\n\\n if not isinstance(stats, dict):\\n raise ValueError(f\\\"stats is not a dict, {stats}\\\")\\n return_weights = ExchangeObject(\\n weights=weights,\\n optim=None, # could be self.optimizer.state_dict()\\n weight_type=weigh_type,\\n statistics=stats,\\n )\\n\\n # filter weights if needed (use to apply differential privacy, encryption, compression, etc.)\\n if self.post_weight_filters is not None:\\n for _filter in self.post_weight_filters:\\n return_weights = _filter(return_weights, extra)\\n\\n return return_weights\",\n \"def get_weights(self):\\n return self.weights\\n #print(W)\",\n \"def get_weights(self):\\n return self._weight\",\n \"def _weighted(self):\\n return self.dataset.weighted(self.probability)\",\n \"def update_weights(self):\\n\\t\\tpass\",\n \"def get_weights(self):\\n return self.__weights\",\n \"def weights(self):\\n return self.__weights\",\n \"def weights(self):\\n return self.__weights\",\n \"def weights(self):\\n return self.__weights\",\n \"def weights(self):\\n return self.__weights\",\n \"def weights(self):\\n return self.__weights\",\n \"def rebalance_weightings(context):\\r\\n total_ratio = 0\\r\\n log.info(\\\"*******Rebalancing weightings********\\\")\\r\\n print(context.up_ratios)\\r\\n \\r\\n for asset, ratio in context.up_ratios.items():\\r\\n total_ratio += ratio\\r\\n \\r\\n for asset, ratio in context.up_ratios.items():\\r\\n context.max_weights[asset] = ratio/total_ratio\\r\\n \\r\\n log.info(context.max_weights)\",\n \"def class_weights(self):\\n target_list = self.label\\n count_dict = Counter(target_list)\\n class_count = [count_dict[i] for i in range(3)]\\n class_weights = len(target_list) / torch.tensor(class_count, dtype=torch.float)\\n class_weights = class_weights / class_weights.sum()\\n print(class_weights) # noqa: T001\\n return class_weights\",\n \"def get_weight_list(self) -> List[float]:\\n return self._weight_list\",\n \"def evaluate(self, representativeness: float, weight: float) -> float:\\n pass\",\n \"def weight() -> int:\\n return floor(stakedTokens / MINIMUM_STAKE)\",\n \"def my_assign_weights(context, data):\\n pass\",\n \"def weight_statistics(self) -> Dict[str, Dict[str, List[float]]]:\\n return self._weights_statistics\",\n \"def get_weights(self):\\n return self.weights\",\n \"def get_weights(self):\\n return self.weights\",\n \"def init_weights(self):\\n\\n params = torch.load(self.resnet_weight)\\n\\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\\n\\n\\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\\n self.fc3.out_features)\\n self.fc3.weight.data.uniform_(-r, r)\\n self.fc3.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\\n self.fc4.out_features)\\n self.fc4.weight.data.uniform_(-r, r)\\n self.fc4.bias.data.fill_(0)\",\n \"def weight(self):\\n return self._hx711.get_weight()\",\n \"def weights(self):\\n return self._weights\",\n \"def weights(self):\\n return self._weights\",\n \"def weights(self):\\n return self._weights\",\n \"def weights(self):\\n return self._weights\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def update_speed_weights_step(self):\\n \\n weights_list = [self.W_speed_east, self.W_speed_west,self.W_speed_north,self.W_speed_south]\\n speed_input_list = [self.speed_inputs_east,self.speed_inputs_west,\\n self.speed_inputs_north,self.speed_inputs_south]\\n \\n if self.use_eight_directions is True:\\n weights_list+=[self.W_speed_north_east,\\n self.W_speed_north_west,self.W_speed_south_east,self.W_speed_south_west]\\n \\n speed_input_list+=[self.speed_inputs_north_east,self.speed_inputs_north_west, \\n self.speed_inputs_south_east,self.speed_inputs_south_west]\\n\\n \\n for weights,speed_input in zip(weights_list,speed_input_list):\\n \\n \\n weight_update=speed_input*(self.rr[:self.N_e]-self.input_mean)*(self.rr_e_trace.T-self.input_mean)\\n weights+=self.learn_rate_speed_weights*weight_update\\n\\n\\n # normalize to fixed mean of incoming and outgoing weights\\n weights-=(weights.mean(axis=1)-self.W_av_star)[:,np.newaxis]\\n weights-=(weights.mean(axis=0)-self.W_av_star)[np.newaxis,:]\\n \\n # clip weights \\n np.clip(weights,0,self.W_max_e,out=weights)\",\n \"def getWeight(self, nengine, powerReq, tech_factor):\\n\\n P_ins = powerReq # in kw, per unit\\n \\n mass = turbo_engine(P_ins) *nengine\\n\\n total = {'total': mass*tech_factor}\\n return total # dictionary, units are SI [kg]\",\n \"def atom_weight(self, manager):\\n identity = \\\"HOH\\\" if self.resname in WATER_RES_NAMES else self.identity()\\n # Waters that don't have B-factors at least 1 stddev below the mean are\\n # presumed to be correct\\n if (identity == \\\"HOH\\\" and\\n (self.atom.b > manager.b_mean_hoh - manager.b_stddev_hoh)):\\n return 0\\n if self.is_correctly_identified(identity = identity):\\n return 0\\n # B-factors/occupancies?\\n if self.FOFC_PEAK in self.inaccuracies[identity] or self.atom.b < 1:\\n return 1\\n if self.FOFC_HOLE in self.inaccuracies[identity]:\\n return -1\\n return 0\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def numWeights(self):\\r\\n\\t\\treturn None\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def get_current_weight(self):\\n return sum([shipment.weight for shipment in self.shipments])\",\n \"def weight_setup(self, weighting):\\n if weighting == \\\"overlap\\\":\\n self.weights = overlap_generator(overlap, self.graph)\\n elif weighting == \\\"unit\\\":\\n self.weights = overlap_generator(unit, self.graph)\\n elif weighting == \\\"min_norm\\\":\\n self.weights = overlap_generator(min_norm, self.graph)\\n else:\\n self.weights = overlap_generator(normalized_overlap, self.graph)\",\n \"def weight(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"weight\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7639016","0.75578135","0.7499282","0.73658234","0.72466195","0.7217344","0.7214428","0.7214428","0.7117307","0.7097232","0.70433426","0.6888601","0.6846439","0.68106675","0.6809401","0.6799938","0.67643374","0.6751411","0.6691422","0.6686457","0.6686457","0.6686457","0.6686457","0.6686457","0.6686457","0.6686457","0.6686457","0.6682024","0.66690844","0.6659174","0.6629128","0.66236883","0.6519732","0.6519732","0.65141845","0.6496443","0.64906085","0.64893824","0.6487683","0.6472787","0.6465594","0.6428118","0.6419689","0.64136827","0.6412541","0.6402011","0.63970715","0.63970715","0.6392457","0.6389313","0.6382042","0.6382042","0.6382042","0.6381469","0.6362859","0.63493955","0.63467497","0.6340423","0.6337941","0.63358074","0.633212","0.6331442","0.63257194","0.6319266","0.6302551","0.6302551","0.6302551","0.6302551","0.6302551","0.62983894","0.6281971","0.6273886","0.6268608","0.62652904","0.6257366","0.62302333","0.6230086","0.6230086","0.6222227","0.6204293","0.6203435","0.6203435","0.6203435","0.6203435","0.6173934","0.61729836","0.61716783","0.61690176","0.61633563","0.6156919","0.6136526","0.6136526","0.6136526","0.6136526","0.6136526","0.6136526","0.6136526","0.61102957","0.61078686","0.6107025"],"string":"[\n \"0.7639016\",\n \"0.75578135\",\n \"0.7499282\",\n \"0.73658234\",\n \"0.72466195\",\n \"0.7217344\",\n \"0.7214428\",\n \"0.7214428\",\n \"0.7117307\",\n \"0.7097232\",\n \"0.70433426\",\n \"0.6888601\",\n \"0.6846439\",\n \"0.68106675\",\n \"0.6809401\",\n \"0.6799938\",\n \"0.67643374\",\n \"0.6751411\",\n \"0.6691422\",\n \"0.6686457\",\n \"0.6686457\",\n \"0.6686457\",\n \"0.6686457\",\n \"0.6686457\",\n \"0.6686457\",\n \"0.6686457\",\n \"0.6686457\",\n \"0.6682024\",\n \"0.66690844\",\n \"0.6659174\",\n \"0.6629128\",\n \"0.66236883\",\n \"0.6519732\",\n \"0.6519732\",\n \"0.65141845\",\n \"0.6496443\",\n \"0.64906085\",\n \"0.64893824\",\n \"0.6487683\",\n \"0.6472787\",\n \"0.6465594\",\n \"0.6428118\",\n \"0.6419689\",\n \"0.64136827\",\n \"0.6412541\",\n \"0.6402011\",\n \"0.63970715\",\n \"0.63970715\",\n \"0.6392457\",\n \"0.6389313\",\n \"0.6382042\",\n \"0.6382042\",\n \"0.6382042\",\n \"0.6381469\",\n \"0.6362859\",\n \"0.63493955\",\n \"0.63467497\",\n \"0.6340423\",\n \"0.6337941\",\n \"0.63358074\",\n \"0.633212\",\n \"0.6331442\",\n \"0.63257194\",\n \"0.6319266\",\n \"0.6302551\",\n \"0.6302551\",\n \"0.6302551\",\n \"0.6302551\",\n \"0.6302551\",\n \"0.62983894\",\n \"0.6281971\",\n \"0.6273886\",\n \"0.6268608\",\n \"0.62652904\",\n \"0.6257366\",\n \"0.62302333\",\n \"0.6230086\",\n \"0.6230086\",\n \"0.6222227\",\n \"0.6204293\",\n \"0.6203435\",\n \"0.6203435\",\n \"0.6203435\",\n \"0.6203435\",\n \"0.6173934\",\n \"0.61729836\",\n \"0.61716783\",\n \"0.61690176\",\n \"0.61633563\",\n \"0.6156919\",\n \"0.6136526\",\n \"0.6136526\",\n \"0.6136526\",\n \"0.6136526\",\n \"0.6136526\",\n \"0.6136526\",\n \"0.6136526\",\n \"0.61102957\",\n \"0.61078686\",\n \"0.6107025\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7724041"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6385,"cells":{"query":{"kind":"string","value":"Automatically generate a basename or else use the one provided."},"document":{"kind":"string","value":"def _gen_basename(param_dict, clargs):\n if param_dict['output_basename'] in ['', 'auto']:\n return clargs.input_fname.lower().split('.json')[0]\n\n else:\n return param_dict['output_basename']"},"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 make_fullname(basename, _type=None):\n return '{}.{}'.format(basename, extensions.get(_type, None))","def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True, ext=None):\n if not basename:\n msg = \"Unable to generate filename for command %s. \" % self.cmd\n msg += \"basename is not set!\"\n raise ValueError(msg)\n\n if cwd is None:\n cwd = os.getcwd()\n if ext is None:\n ext = Info.output_type_to_ext(self.inputs.outputtype)\n if change_ext:\n suffix = \"\".join((suffix, ext)) if suffix else ext\n\n if suffix is None:\n suffix = \"\"\n fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)\n return fname","def genBaseName(fileName):\n return fileName.split(\"_\")[0].split(\".\")[0]","def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True,\n ext='.mif'):\n\n if basename == '':\n msg = 'Unable to generate filename for command %s. ' % self.cmd\n msg += 'basename is not set!'\n raise ValueError(msg)\n if cwd is None:\n cwd = os.getcwd()\n if change_ext:\n if suffix:\n suffix = ''.join((suffix, ext))\n else:\n suffix = ext\n if suffix is None:\n suffix = ''\n fname = fname_presuffix(basename, suffix=suffix,\n use_ext=False, newpath=cwd)\n return fname","def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True,\n ext='.mif'):\n\n if basename == '':\n msg = 'Unable to generate filename for command %s. ' % self.cmd\n msg += 'basename is not set!'\n raise ValueError(msg)\n if cwd is None:\n cwd = os.getcwd()\n if change_ext:\n if suffix:\n suffix = ''.join((suffix, ext))\n else:\n suffix = ext\n if suffix is None:\n suffix = ''\n fname = fname_presuffix(basename, suffix=suffix,\n use_ext=False, newpath=cwd)\n return fname","def gen_save_name(basename = os.getcwd()):\n fname, suffix = basename.split('.') # just assume this is true.\n qualifier = 1\n unique_fname = fname\n while (os.path.exists(unique_fname + '.' + suffix)):\n unique_fname = fname + '_{}'.format(qualifier)\n qualifier += 1\n return unique_fname + '.' + suffix","def purebasename(self):\n return self._getbyspec(\"purebasename\")[0]","def purebasename(self):\n return self.namebase","def built_file_basename(self, name, type=None, **kw):\n if not kw.get('bare'):\n if type == self.EXECUTABLE:\n name = name + self._exe\n elif type == self.STATIC_LIB:\n name = self.lib_ + name + self._lib\n elif type == self.SHARED_LIB:\n name = self.dll_ + name + self._dll\n return name","def basename(source_file) :\n if source_file is not None and source_file != '' :\n return os.path.basename(source_file)\n\n return ''","def basename(path: str) -> str:\n pass","def getBaseName(filepath):\n return os.path.basename(filepath)","def base_name(path):\n return os.path.basename(path)","def generate_filename(filename: str) -> str:\n return f\"{str(uuid.uuid4())}.{get_extension(filename)}\"","def make_path(self, basename):\n return os.path.join(self.output_folder, basename.format(self.sample_name))","def basename(self):\n return self._getbyspec(\"basename\")[0]","def name(self) -> str:\n if '/' in self.path.strip('/'):\n basename: str = os.path.basename(self.path)\n return basename\n return self.path","def basename(self):\n return get_basename(self.filename)","def TaskBaseName(cls, task):\n if not task: return None\n return os.path.basename(task)","def fname( file_, base=None, new_base=None, new_ext=None ):\n if base and new_base:\n file_ = file_.replace(base, new_base, 1)\n if new_ext:\n file_ = os.path.splitext(file_)[0] + new_ext\n return file_","def generate_name(config):\n\n name = basename(config.name)\n if config.prepro is not None:\n name += \"_\" + config.prepro\n if config.extract_pos:\n name += \"_pos\"\n return name","def basename(self) -> str:\n return self._basename","def _UrlBaseName(url):\n return url.rstrip('/').rpartition('/')[-1]","def new_filename(fname=None,ndigits=3):\n if fname is None:\n ext = (\"%%.%ii\" % ndigits) % 1\n fname = \"%s.%s\" % (random_string(6), ext)\n \n if os.path.exists(fname): \n fname = increment_filename(fname,ndigits=ndigits)\n\n return fname","def getInputFileBasenameNoSuffix():\n\n inputFileBasename = getInputFileBasename()\n basenameRemovedSuffix = removeSuffix(inputFileBasename)\n return basenameRemovedSuffix","def basename(path):\r\n return split(path)[1]","def basefname(fname):\n return os.path.splitext(fname.split(\"\\\\\")[-1])[0]","def basename(self):\n return self.name.basename","def build_base_filename(self):\n if self.stream:\n self.stream.close()\n self.stream = None\n\n # remove old suffix\n # if self.suffix_time != \"\":\n # index = self.baseFilename.find(\".\" + self.suffix_time)\n # if index == -1:\n # index = self.baseFilename.rfind(\".\")\n # self.baseFilename = self.baseFilename[:index]\n\n # add new suffix\n current_time_tuple = time.localtime()\n self.suffix_time = time.strftime(self.suffix, current_time_tuple)\n self.baseFilename = self._get_format_filename()\n\n self.mode = 'a'\n if not self.delay:\n self.stream = self._open()","def get_basename(absolute_file_path):\r\n return absolute_file_path.split('/')[-1]","def format_filename(prefix, suffix, seq_len, uncased):\n seq_str = \"seq-{}\".format(seq_len)\n if uncased:\n case_str = \"uncased\"\n else:\n case_str = \"cased\"\n\n file_name = \"{}.{}.{}.{}\".format(prefix, seq_str, case_str, suffix)\n\n return file_name","def _create_unique_filename_with_integer_suffix(fullpath):\n # create an unique filename\n suffix = None\n suffix_cnt=1\n while os.path.exists(fullpath):\n if suffix: fullpath = fullpath[0:-len(suffix)]\n suffix = \".%s\" % suffix_cnt\n suffix_cnt+=1\n fullpath = fullpath + suffix\n return fullpath","def GetBase(self, fname, suffix):\n wds = fname.split('/')\n suff = suffix.replace('.BRIK','')\n suff = suff.replace('.HEAD','')\n if len(wds) > 1:\n return '.../%s' % '/'.join(wds[-2:]) + suff\n else:\n return fname + suff","def name_generator(identifier: str=\"\") -> str:\n return f\"thrifty-builder-test-{identifier}{uuid4()}\"","def createname(cls):\n name = config.get(\"pyzombie_filesystem\", \"execbase\")\n name = \"{0}_{1}\".format(name, datetime.utcnow().strftime(\"%Y%jT%H%M%SZ\"))\n if os.path.isdir(Executable.execdirpath(name)):\n #Need to handle the rare case of duplicate resource names---this\n #will happen all the time in testing, but rarely in production.\n index = 0\n altname = \"{0}_{1:03}\".format(name, index)\n while os.path.isdir(Executable.execdirpath(altname)):\n index = index + 1\n altname = \"{0}_{1:03}\".format(name, index)\n name = altname\n return name","def generateFilename(folder, prefix, ext):\n filename = os.path.basename(os.path.normpath(folder))\n if prefix:\n filename = \"{0}-{1}\".format(prefix, filename)\n path = getIncrementedFilename(os.path.join(folder, filename), ext)\n return path","def _get_random_name(self, base_name):\n return base_name + '_' + self.__id_generator()","def basename(self, t):\n t = self.canon(t)\n if isinstance(t, basestring):\n return t\n elif isinstance(t, Sequence):\n t0 = t\n while not isinstance(t0, basestring):\n t0 = t0[0]\n return t0\n else:\n _raise_type_error(t)","def executable_name(basename: str) -> str:\n if os.name == 'nt':\n return f\"{basename}.exe\"\n else:\n return basename","def get_basename(self):\n return self._basename","def _generate_filename(instance, filename, prefix):\n md5 = hashlib.md5()\n md5.update(struct.pack('f', time.time()))\n for chunk in instance.file.chunks():\n md5.update(chunk)\n extension = os.path.splitext(filename)[1]\n return os.path.join(prefix, md5.hexdigest() + extension)","def unique_filename(data):\n file = data\n get_ext = file.filename.split(\".\")[-1]\n new_name = \"%s.%s\" % (uuid.uuid4().hex, get_ext)\n return new_name","def _GetLabelFromBasename(self, basename):\n \n return basename","def build_base_filename(self):\n if self.stream:\n self.stream.close()\n self.stream = None\n\n # remove old suffix\n if self.suffix_time != \"\":\n index = self.baseFilename.find(\".\" + self.suffix_time)\n if index == -1:\n index = self.baseFilename.rfind(\".\")\n self.baseFilename = self.baseFilename[:index]\n\n # add new suffix\n current_time_tuple = time.localtime()\n self.suffix_time = time.strftime(self.suffix, current_time_tuple)\n self.baseFilename = self.baseFilename + \".\" + self.suffix_time\n self.mode = 'a'\n\n # create soft links\n index = self.baseFilename.rfind(\".\")\n os.unlink(self.baseFilename[:index])\n os.symlink(self.baseFilename, self.baseFilename[:index])\n\n if not self.delay:\n self.stream = self._open()","def genPathCopasi(self,nameBase,suffix=\".cps\"):\n i=0\n nameFree=False\n while not nameFree:\n copasi_filename = os.path.join(self.run_dir,nameBase+\n str(i)+suffix)\n nameFree = not os.path.exists(copasi_filename)\n i=i+1\n return copasi_filename","def basename(file_path):\n return os.path.basename(file_path)","def generate_file_filename(instance, filename):\n return _generate_filename(instance, filename, 'photos')","def filter_pathbase(val: Optional[str]) -> str:\n return os.path.basename(val or '')","def genSampleID(path):\n head, tail = ntpath.split(path)\n result = tail or ntpath.basename(head)\n return genBaseName(result.split(\".\")[0]) # Gets just the sample name, cleans out the \".cleaned.[EXT]\"","def base_name(self):\n return \".\".join(posixpath.basename(self.file_name).split(\".\")[:-1])","def basename(path):\n\n return path.rpartition(\"/\")[2]","async def filename_generator(self):\n chars = list(string.ascii_letters+string.digits)\n name = ''\n for i in range(random.randint(9, 25)):\n name += random.choice(chars)\n\n if name not in self.player['audio_files']:\n return name\n\n return await self.filename_generator()","def generate_filename(player_name):\n name = player_name.split()\n filename = '_'.join(name).lower()\n return filename","def basename(self):\n return self._basename","def get_base_name(path):\n return os.path.basename(path).split('.')[0]","def generate_unique_name(base):\n random_length = 10\n random_string = ''.join(random.choices(string.ascii_lowercase,\n k=random_length))\n return \"%s-%s\" % (base, random_string)","def get_filename(self, base_filename: str) -> str:\n folder = self.prepare_folder()\n i = 0\n cartridge_number = self.config['info']['cartridge_number']\n while os.path.isfile(os.path.join(folder, base_filename.format(\n cartridge_number=cartridge_number,\n i=i))):\n i += 1\n\n return os.path.join(folder, base_filename.format(cartridge_number=cartridge_number, i=i))","def _create_id(self):\r\n buildfile_relpath = os.path.dirname(self.address.buildfile.relpath)\r\n if buildfile_relpath in ('.', ''):\r\n return self.name\r\n else:\r\n return \"%s.%s\" % (buildfile_relpath.replace(os.sep, '.'), self.name)","def basename(self):\n return os.path.basename(self.filepath)","def generate_filename(extension, with_path=True, base_folder=None):\n name = get_md5(str(uuid4()))\n # if not extension:\n # extension = get_file_extension()\n if base_folder is not None:\n base_folder = \"%s/\" % base_folder.rstrip(\"/\")\n else:\n base_folder = \"\"\n\n if with_path:\n return \"%s%s/%s/%s/%s.%s\" % (base_folder, name[0], name[1], name[2], name, extension)\n else:\n return \"%s%s.%s\" % (base_folder, name, extension)","def _get_abgp_file_basename(OPTIONS):\n if OPTIONS.target:\n try:\n num_loci = OPTIONS.selected_num_loci\n except:\n num_loci = len(OPTIONS.loci) + len(OPTIONS.dnafiles)\n return \"%s.%s%sSL.\" % (ABFGP_VERSION,OPTIONS.target,num_loci)\n else:\n return \"%s.\" % ABGP_VERSION","def gen_file_name(filename, path=UPLOAD_FOLDER):\n\n i = 1\n while os.path.exists(os.path.join(path, filename)):\n name, extension = os.path.splitext(filename)\n filename = '%s_%s%s' % (name, str(i), extension)\n i += 1\n\n return filename","def guess(filename):\n for marker in [\".stem\",\"stem.\",\".seed\",\"seed.\"]:\n if filename.find(marker)>-1: \n return (filename.replace(marker,\"\"))\n\n if \"/\" in filename:\n index = filename.rfind(\"/\")\n return ( filename[:index+1]+\"generated_\"+filename[index+1:])\n else:\n return ( \"generated_\"+filename )","def output_filename(self, prefix, suffix):\n filename = \"%s%s%s\" % (prefix, _ExecutionWrapper._file_index, suffix)\n _ExecutionWrapper._file_index += 1\n return filename","def _get_file_name(name: types.TSeedName) -> str:\n return f\"{name}.yml\"","def generate_name(prefix):\n suffix = generate_uuid()[:8]\n return '{0}_{1}'.format(prefix, suffix)","def base_filename(self):\n return self.filename.split('.')[0]","def make_filename(key, extension):\n key = unicode(key.strip())\n return '{}.{}'.format(slugify(key), extension)","def make_backup_file_name(filename):\n\tbackup_suffix = '~' if os.name == 'posix' else '.backup'\n\tif filename.endswith(backup_suffix):\n\t\traise ValueError(\"Looks like a backup file: \" + filename)\n\treturn filename + backup_suffix","def get_file_basename(self):\n return self._basename[:]","def generate_filename(playlist_or_album_name, user_id_or_artist_id=None):\n filename = ''\n if user_id_or_artist_id:\n filename += user_id_or_artist_id + '_'\n filename += playlist_or_album_name + '_' + str(time_ns())\n return filename","def generate_filename(self, filename):\n filename = str(filename).replace(\"\\\\\", \"/\")\n # `filename` may include a path as returned by FileField.upload_to.\n dirname, filename = os.path.split(filename)\n if \"..\" in pathlib.PurePath(dirname).parts:\n raise SuspiciousFileOperation(\n \"Detected path traversal attempt in '%s'\" % dirname\n )\n return os.path.normpath(os.path.join(dirname, self.get_valid_name(filename)))","def GetSequentialFileName(base_name):\n name, ext = os.path.splitext(base_name)\n assert ext == '', 'base_name cannot contain file extension.'\n index = 0\n while True:\n output_name = '%s_%03d' % (name, index)\n if not glob.glob(output_name + '.*'):\n break\n index = index + 1\n return output_name","def use_name(self):\n projection = proj.get_projection(self.conf.projections, self.spec)\n if not projection:\n projection = self.conf.default_projections[\"all\"]\n\n name = self.spec.format(projection)\n # Not everybody is working on linux...\n parts = name.split(\"/\")\n name = os.path.join(*parts)\n # Add optional suffixes based on constraints\n path_elements = [name] + self.conf.suffixes\n return \"-\".join(path_elements)","def make_bids_basename(subject=None, session=None, task=None,\n acquisition=None, run=None, processing=None,\n recording=None, space=None, prefix=None, suffix=None):\n bids_path = BIDSPath(subject=subject, session=session, task=task,\n acquisition=acquisition, run=run,\n processing=processing, recording=recording,\n space=space, prefix=prefix, suffix=suffix)\n bids_path._check()\n return bids_path","def update_filename(instance, filename):\n path = os.path.join(\"documents_analizer\", \"documents\")\n name = \"{}{}\".format(highly_random_name(),\n os.path.splitext(filename)[1])\n return os.path.join(path, name)","def construct_basename(self, row, obstime=None):\n _obstime = self.construct_obstime(row) if obstime is None else obstime\n tiso = time.Time(_obstime, format='isot')\n dtime = datetime.datetime.strptime(tiso.value, '%Y-%m-%dT%H:%M:%S.%f')\n return '{0}-{1}_{2}_{3}{4}'.format(self['filename'][row].split('.fits')[0],\n self['target'][row].replace(\" \", \"\"),\n self.spectrograph.camera,\n datetime.datetime.strftime(dtime, '%Y%m%dT'),\n tiso.value.split(\"T\")[1].replace(':',''))","def get_filename(filepath):\n return os.path.basename(filepath)","def _unique_path(prefix):\n suffix = ''.join([\n random.choice(string.ascii_letters) for i in range(8)\n ])\n return '%s/%r.%s' % (prefix, time.time(), suffix)","def generate_unique_job_name(self, name='no_name_job'):\n # TODO: Make it more suitable for disk paths. (no *, -)\n from base64 import urlsafe_b64encode\n name = os.path.basename(name)\n return \"_\".join([os.path.split(name)[1], urlsafe_b64encode(os.urandom(3))])","def logname():\n global _basename\n \n parent = os.path.splitext(os.path.basename(wheresdaddy()))[0]\n return '.'.join([_basename, os.path.splitext(os.path.basename(sys.argv[0]))[0], parent])","def generate_object_storage_name(checksum, filename, default_ext=''):\n h = checksum\n basename, actual_ext = os.path.splitext(filename)\n ext = actual_ext if actual_ext else default_ext\n\n # Use / instead of os.path.join as Windows makes this \\\\\n directory = \"/\".join([settings.STORAGE_ROOT, h[0], h[1]])\n return os.path.join(directory, h + ext.lower())","def generate_file_name(well, channel, desc):\n \n return \"bPLATE_w\" + well + \"_\" + desc + \"_c\" + channel + \".png\"","def temp_name(self, filename):\n if self.params.get('nopart', False) or filename == '-' or \\\n (os.path.exists(encodeFilename(filename)) and not os.path.isfile(encodeFilename(filename))):\n return filename\n return filename + '.part'","def _getFileName(self, filePath):\r\n\t\thead, tail = ntpath.split(filePath)\r\n\t\treturn tail or ntpath.basename(head)","def _get_base_app_name(value):\n value = os.path.basename(value)\n if (\n value.endswith(\".exe\")\n or value.endswith(\".dll\")\n or value.endswith(\".so\")\n ):\n value = os.path.splitext(value)[0]\n\n return value","def _gen_image_filename(instance, filename):\n # First, store the original filename in the model\n instance.original_filename = filename\n\n return _unique_path(instance.owner.pk, filename)","def generate_filename(ext,sha512base16_hash=None):\n## # Timestamp filename\n## timestamp = str(get_current_unix_time())\n## filename = timestamp+\".\"+ext\n # Base16 hash filename\n filename = sha512base16_hash+\".\"+ext\n return filename","def _get_available_wav_basename(label, basedir):\n cont = 0\n label = os.path.join(basedir, label)\n wav_name = label + \".wav\"\n if os.path.exists(wav_name):\n while True: # search an inexistent name for new gmm\n wav_name = label + \"\" + str(cont) + \".wav\"\n if not os.path.exists(wav_name):\n break\n cont = cont + 1\n else:\n open(label+\".wav\",'w').close()\n return label\n open(label+str(cont)+\".wav\",'w').close()\n return label + str(cont)\n #end _get_available_wav_basename","def get_default_filename() -> str:\n return datetime.datetime.now().strftime(\"%Y-%m-%d_%H-%M-%S\")","def filename(self, url, default_file = \"index.html\"):\n purl = urlparse(url)\n file_name = purl[1] + purl[2] \n folder_name = (purl[1] + purl[2])\n \n if purl[2] == '':\n folder_name += ('/' + default_file)\n file_name += ('/' + default_file)\n elif purl[2] == '/':\n folder_name += default_file\n file_name += default_file\n elif (purl[2])[-1] == '/':\n file_name += ('/' + default_file)\n\n folder_path = dirname(folder_name)\n \n if not isdir(folder_path): # create archive dir if nec.\n if not exists(folder_path): \n makedirs(folder_path)\n return file_name","def basename(self, filename):\n return filename.replace(self.remote_path, '', 1).lstrip(sep)","def generate_filename(\r\n filepath,\r\n filestartwith,\r\n fileendwith,\r\n run_date,\r\n filemask):\r\n\r\n filedate = generate_dateformat(run_date, filemask)\r\n if not filedate:\r\n filename = filestartwith\r\n else:\r\n filename = filestartwith + filedate\r\n\r\n if fileendwith:\r\n filename = filename + fileendwith\r\n\r\n if filepath and len(filepath.strip()) > 0:\r\n filename = filepath.strip() + '/' + filename\r\n\r\n return filename","def thumbgen_filename(filename):\n name, ext = os.path.splitext(filename)\n return '%s_thumb%s' % (name, ext)","def thumbgen_filename(filename):\n name, ext = os.path.splitext(filename)\n return '%s_thumb%s' % (name, ext)","def create_file_basename(postfix: str, input_file_name: str, folder_path: str, data_root_dir: str = \"\"):\n\n # get the filename and directory\n filedir, filename = os.path.split(input_file_name)\n\n # jettison the extension to have just filename\n filename, ext = os.path.splitext(filename)\n while ext != \"\":\n filename, ext = os.path.splitext(filename)\n\n # use data_root_dir to find relative path to file\n filedir_rel_path = \"\"\n if data_root_dir:\n filedir_rel_path = os.path.relpath(filedir, data_root_dir)\n\n # sub-folder path will be original name without the extension\n subfolder_path = os.path.join(folder_path, filedir_rel_path, filename)\n if not os.path.exists(subfolder_path):\n os.makedirs(subfolder_path)\n\n # add the sub-folder plus the postfix name to become the file basename in the output path\n return os.path.join(subfolder_path, filename + \"_\" + postfix)","def _gen_thumbs_filename(instance, filename):\n return _unique_path(instance.owner.pk, filename, category='thumbs')","def getInputFileBasename(inputFilename = None):\n\n curInputFilename = getInputFilename()\n\n if inputFilename :\n curInputFilename = inputFilename\n\n # print \"curInputFilename=%s\"%(curInputFilename)\n inputBasename = getBasename(curInputFilename)\n # print \"inputBasename=%s\"%(inputBasename)\n return inputBasename","def form_unique_name(string):\r\n return string[len(BASEPATH) + 1:].replace('/', '\\\\')","def file_name(product, ext='json'):\n return f\"./output/{product}_{datetime.now().strftime('%Y-%m-%d_%H%M%S')}_transformed_{version}.{ext}\""],"string":"[\n \"def make_fullname(basename, _type=None):\\n return '{}.{}'.format(basename, extensions.get(_type, None))\",\n \"def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True, ext=None):\\n if not basename:\\n msg = \\\"Unable to generate filename for command %s. \\\" % self.cmd\\n msg += \\\"basename is not set!\\\"\\n raise ValueError(msg)\\n\\n if cwd is None:\\n cwd = os.getcwd()\\n if ext is None:\\n ext = Info.output_type_to_ext(self.inputs.outputtype)\\n if change_ext:\\n suffix = \\\"\\\".join((suffix, ext)) if suffix else ext\\n\\n if suffix is None:\\n suffix = \\\"\\\"\\n fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)\\n return fname\",\n \"def genBaseName(fileName):\\n return fileName.split(\\\"_\\\")[0].split(\\\".\\\")[0]\",\n \"def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True,\\n ext='.mif'):\\n\\n if basename == '':\\n msg = 'Unable to generate filename for command %s. ' % self.cmd\\n msg += 'basename is not set!'\\n raise ValueError(msg)\\n if cwd is None:\\n cwd = os.getcwd()\\n if change_ext:\\n if suffix:\\n suffix = ''.join((suffix, ext))\\n else:\\n suffix = ext\\n if suffix is None:\\n suffix = ''\\n fname = fname_presuffix(basename, suffix=suffix,\\n use_ext=False, newpath=cwd)\\n return fname\",\n \"def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True,\\n ext='.mif'):\\n\\n if basename == '':\\n msg = 'Unable to generate filename for command %s. ' % self.cmd\\n msg += 'basename is not set!'\\n raise ValueError(msg)\\n if cwd is None:\\n cwd = os.getcwd()\\n if change_ext:\\n if suffix:\\n suffix = ''.join((suffix, ext))\\n else:\\n suffix = ext\\n if suffix is None:\\n suffix = ''\\n fname = fname_presuffix(basename, suffix=suffix,\\n use_ext=False, newpath=cwd)\\n return fname\",\n \"def gen_save_name(basename = os.getcwd()):\\n fname, suffix = basename.split('.') # just assume this is true.\\n qualifier = 1\\n unique_fname = fname\\n while (os.path.exists(unique_fname + '.' + suffix)):\\n unique_fname = fname + '_{}'.format(qualifier)\\n qualifier += 1\\n return unique_fname + '.' + suffix\",\n \"def purebasename(self):\\n return self._getbyspec(\\\"purebasename\\\")[0]\",\n \"def purebasename(self):\\n return self.namebase\",\n \"def built_file_basename(self, name, type=None, **kw):\\n if not kw.get('bare'):\\n if type == self.EXECUTABLE:\\n name = name + self._exe\\n elif type == self.STATIC_LIB:\\n name = self.lib_ + name + self._lib\\n elif type == self.SHARED_LIB:\\n name = self.dll_ + name + self._dll\\n return name\",\n \"def basename(source_file) :\\n if source_file is not None and source_file != '' :\\n return os.path.basename(source_file)\\n\\n return ''\",\n \"def basename(path: str) -> str:\\n pass\",\n \"def getBaseName(filepath):\\n return os.path.basename(filepath)\",\n \"def base_name(path):\\n return os.path.basename(path)\",\n \"def generate_filename(filename: str) -> str:\\n return f\\\"{str(uuid.uuid4())}.{get_extension(filename)}\\\"\",\n \"def make_path(self, basename):\\n return os.path.join(self.output_folder, basename.format(self.sample_name))\",\n \"def basename(self):\\n return self._getbyspec(\\\"basename\\\")[0]\",\n \"def name(self) -> str:\\n if '/' in self.path.strip('/'):\\n basename: str = os.path.basename(self.path)\\n return basename\\n return self.path\",\n \"def basename(self):\\n return get_basename(self.filename)\",\n \"def TaskBaseName(cls, task):\\n if not task: return None\\n return os.path.basename(task)\",\n \"def fname( file_, base=None, new_base=None, new_ext=None ):\\n if base and new_base:\\n file_ = file_.replace(base, new_base, 1)\\n if new_ext:\\n file_ = os.path.splitext(file_)[0] + new_ext\\n return file_\",\n \"def generate_name(config):\\n\\n name = basename(config.name)\\n if config.prepro is not None:\\n name += \\\"_\\\" + config.prepro\\n if config.extract_pos:\\n name += \\\"_pos\\\"\\n return name\",\n \"def basename(self) -> str:\\n return self._basename\",\n \"def _UrlBaseName(url):\\n return url.rstrip('/').rpartition('/')[-1]\",\n \"def new_filename(fname=None,ndigits=3):\\n if fname is None:\\n ext = (\\\"%%.%ii\\\" % ndigits) % 1\\n fname = \\\"%s.%s\\\" % (random_string(6), ext)\\n \\n if os.path.exists(fname): \\n fname = increment_filename(fname,ndigits=ndigits)\\n\\n return fname\",\n \"def getInputFileBasenameNoSuffix():\\n\\n inputFileBasename = getInputFileBasename()\\n basenameRemovedSuffix = removeSuffix(inputFileBasename)\\n return basenameRemovedSuffix\",\n \"def basename(path):\\r\\n return split(path)[1]\",\n \"def basefname(fname):\\n return os.path.splitext(fname.split(\\\"\\\\\\\\\\\")[-1])[0]\",\n \"def basename(self):\\n return self.name.basename\",\n \"def build_base_filename(self):\\n if self.stream:\\n self.stream.close()\\n self.stream = None\\n\\n # remove old suffix\\n # if self.suffix_time != \\\"\\\":\\n # index = self.baseFilename.find(\\\".\\\" + self.suffix_time)\\n # if index == -1:\\n # index = self.baseFilename.rfind(\\\".\\\")\\n # self.baseFilename = self.baseFilename[:index]\\n\\n # add new suffix\\n current_time_tuple = time.localtime()\\n self.suffix_time = time.strftime(self.suffix, current_time_tuple)\\n self.baseFilename = self._get_format_filename()\\n\\n self.mode = 'a'\\n if not self.delay:\\n self.stream = self._open()\",\n \"def get_basename(absolute_file_path):\\r\\n return absolute_file_path.split('/')[-1]\",\n \"def format_filename(prefix, suffix, seq_len, uncased):\\n seq_str = \\\"seq-{}\\\".format(seq_len)\\n if uncased:\\n case_str = \\\"uncased\\\"\\n else:\\n case_str = \\\"cased\\\"\\n\\n file_name = \\\"{}.{}.{}.{}\\\".format(prefix, seq_str, case_str, suffix)\\n\\n return file_name\",\n \"def _create_unique_filename_with_integer_suffix(fullpath):\\n # create an unique filename\\n suffix = None\\n suffix_cnt=1\\n while os.path.exists(fullpath):\\n if suffix: fullpath = fullpath[0:-len(suffix)]\\n suffix = \\\".%s\\\" % suffix_cnt\\n suffix_cnt+=1\\n fullpath = fullpath + suffix\\n return fullpath\",\n \"def GetBase(self, fname, suffix):\\n wds = fname.split('/')\\n suff = suffix.replace('.BRIK','')\\n suff = suff.replace('.HEAD','')\\n if len(wds) > 1:\\n return '.../%s' % '/'.join(wds[-2:]) + suff\\n else:\\n return fname + suff\",\n \"def name_generator(identifier: str=\\\"\\\") -> str:\\n return f\\\"thrifty-builder-test-{identifier}{uuid4()}\\\"\",\n \"def createname(cls):\\n name = config.get(\\\"pyzombie_filesystem\\\", \\\"execbase\\\")\\n name = \\\"{0}_{1}\\\".format(name, datetime.utcnow().strftime(\\\"%Y%jT%H%M%SZ\\\"))\\n if os.path.isdir(Executable.execdirpath(name)):\\n #Need to handle the rare case of duplicate resource names---this\\n #will happen all the time in testing, but rarely in production.\\n index = 0\\n altname = \\\"{0}_{1:03}\\\".format(name, index)\\n while os.path.isdir(Executable.execdirpath(altname)):\\n index = index + 1\\n altname = \\\"{0}_{1:03}\\\".format(name, index)\\n name = altname\\n return name\",\n \"def generateFilename(folder, prefix, ext):\\n filename = os.path.basename(os.path.normpath(folder))\\n if prefix:\\n filename = \\\"{0}-{1}\\\".format(prefix, filename)\\n path = getIncrementedFilename(os.path.join(folder, filename), ext)\\n return path\",\n \"def _get_random_name(self, base_name):\\n return base_name + '_' + self.__id_generator()\",\n \"def basename(self, t):\\n t = self.canon(t)\\n if isinstance(t, basestring):\\n return t\\n elif isinstance(t, Sequence):\\n t0 = t\\n while not isinstance(t0, basestring):\\n t0 = t0[0]\\n return t0\\n else:\\n _raise_type_error(t)\",\n \"def executable_name(basename: str) -> str:\\n if os.name == 'nt':\\n return f\\\"{basename}.exe\\\"\\n else:\\n return basename\",\n \"def get_basename(self):\\n return self._basename\",\n \"def _generate_filename(instance, filename, prefix):\\n md5 = hashlib.md5()\\n md5.update(struct.pack('f', time.time()))\\n for chunk in instance.file.chunks():\\n md5.update(chunk)\\n extension = os.path.splitext(filename)[1]\\n return os.path.join(prefix, md5.hexdigest() + extension)\",\n \"def unique_filename(data):\\n file = data\\n get_ext = file.filename.split(\\\".\\\")[-1]\\n new_name = \\\"%s.%s\\\" % (uuid.uuid4().hex, get_ext)\\n return new_name\",\n \"def _GetLabelFromBasename(self, basename):\\n \\n return basename\",\n \"def build_base_filename(self):\\n if self.stream:\\n self.stream.close()\\n self.stream = None\\n\\n # remove old suffix\\n if self.suffix_time != \\\"\\\":\\n index = self.baseFilename.find(\\\".\\\" + self.suffix_time)\\n if index == -1:\\n index = self.baseFilename.rfind(\\\".\\\")\\n self.baseFilename = self.baseFilename[:index]\\n\\n # add new suffix\\n current_time_tuple = time.localtime()\\n self.suffix_time = time.strftime(self.suffix, current_time_tuple)\\n self.baseFilename = self.baseFilename + \\\".\\\" + self.suffix_time\\n self.mode = 'a'\\n\\n # create soft links\\n index = self.baseFilename.rfind(\\\".\\\")\\n os.unlink(self.baseFilename[:index])\\n os.symlink(self.baseFilename, self.baseFilename[:index])\\n\\n if not self.delay:\\n self.stream = self._open()\",\n \"def genPathCopasi(self,nameBase,suffix=\\\".cps\\\"):\\n i=0\\n nameFree=False\\n while not nameFree:\\n copasi_filename = os.path.join(self.run_dir,nameBase+\\n str(i)+suffix)\\n nameFree = not os.path.exists(copasi_filename)\\n i=i+1\\n return copasi_filename\",\n \"def basename(file_path):\\n return os.path.basename(file_path)\",\n \"def generate_file_filename(instance, filename):\\n return _generate_filename(instance, filename, 'photos')\",\n \"def filter_pathbase(val: Optional[str]) -> str:\\n return os.path.basename(val or '')\",\n \"def genSampleID(path):\\n head, tail = ntpath.split(path)\\n result = tail or ntpath.basename(head)\\n return genBaseName(result.split(\\\".\\\")[0]) # Gets just the sample name, cleans out the \\\".cleaned.[EXT]\\\"\",\n \"def base_name(self):\\n return \\\".\\\".join(posixpath.basename(self.file_name).split(\\\".\\\")[:-1])\",\n \"def basename(path):\\n\\n return path.rpartition(\\\"/\\\")[2]\",\n \"async def filename_generator(self):\\n chars = list(string.ascii_letters+string.digits)\\n name = ''\\n for i in range(random.randint(9, 25)):\\n name += random.choice(chars)\\n\\n if name not in self.player['audio_files']:\\n return name\\n\\n return await self.filename_generator()\",\n \"def generate_filename(player_name):\\n name = player_name.split()\\n filename = '_'.join(name).lower()\\n return filename\",\n \"def basename(self):\\n return self._basename\",\n \"def get_base_name(path):\\n return os.path.basename(path).split('.')[0]\",\n \"def generate_unique_name(base):\\n random_length = 10\\n random_string = ''.join(random.choices(string.ascii_lowercase,\\n k=random_length))\\n return \\\"%s-%s\\\" % (base, random_string)\",\n \"def get_filename(self, base_filename: str) -> str:\\n folder = self.prepare_folder()\\n i = 0\\n cartridge_number = self.config['info']['cartridge_number']\\n while os.path.isfile(os.path.join(folder, base_filename.format(\\n cartridge_number=cartridge_number,\\n i=i))):\\n i += 1\\n\\n return os.path.join(folder, base_filename.format(cartridge_number=cartridge_number, i=i))\",\n \"def _create_id(self):\\r\\n buildfile_relpath = os.path.dirname(self.address.buildfile.relpath)\\r\\n if buildfile_relpath in ('.', ''):\\r\\n return self.name\\r\\n else:\\r\\n return \\\"%s.%s\\\" % (buildfile_relpath.replace(os.sep, '.'), self.name)\",\n \"def basename(self):\\n return os.path.basename(self.filepath)\",\n \"def generate_filename(extension, with_path=True, base_folder=None):\\n name = get_md5(str(uuid4()))\\n # if not extension:\\n # extension = get_file_extension()\\n if base_folder is not None:\\n base_folder = \\\"%s/\\\" % base_folder.rstrip(\\\"/\\\")\\n else:\\n base_folder = \\\"\\\"\\n\\n if with_path:\\n return \\\"%s%s/%s/%s/%s.%s\\\" % (base_folder, name[0], name[1], name[2], name, extension)\\n else:\\n return \\\"%s%s.%s\\\" % (base_folder, name, extension)\",\n \"def _get_abgp_file_basename(OPTIONS):\\n if OPTIONS.target:\\n try:\\n num_loci = OPTIONS.selected_num_loci\\n except:\\n num_loci = len(OPTIONS.loci) + len(OPTIONS.dnafiles)\\n return \\\"%s.%s%sSL.\\\" % (ABFGP_VERSION,OPTIONS.target,num_loci)\\n else:\\n return \\\"%s.\\\" % ABGP_VERSION\",\n \"def gen_file_name(filename, path=UPLOAD_FOLDER):\\n\\n i = 1\\n while os.path.exists(os.path.join(path, filename)):\\n name, extension = os.path.splitext(filename)\\n filename = '%s_%s%s' % (name, str(i), extension)\\n i += 1\\n\\n return filename\",\n \"def guess(filename):\\n for marker in [\\\".stem\\\",\\\"stem.\\\",\\\".seed\\\",\\\"seed.\\\"]:\\n if filename.find(marker)>-1: \\n return (filename.replace(marker,\\\"\\\"))\\n\\n if \\\"/\\\" in filename:\\n index = filename.rfind(\\\"/\\\")\\n return ( filename[:index+1]+\\\"generated_\\\"+filename[index+1:])\\n else:\\n return ( \\\"generated_\\\"+filename )\",\n \"def output_filename(self, prefix, suffix):\\n filename = \\\"%s%s%s\\\" % (prefix, _ExecutionWrapper._file_index, suffix)\\n _ExecutionWrapper._file_index += 1\\n return filename\",\n \"def _get_file_name(name: types.TSeedName) -> str:\\n return f\\\"{name}.yml\\\"\",\n \"def generate_name(prefix):\\n suffix = generate_uuid()[:8]\\n return '{0}_{1}'.format(prefix, suffix)\",\n \"def base_filename(self):\\n return self.filename.split('.')[0]\",\n \"def make_filename(key, extension):\\n key = unicode(key.strip())\\n return '{}.{}'.format(slugify(key), extension)\",\n \"def make_backup_file_name(filename):\\n\\tbackup_suffix = '~' if os.name == 'posix' else '.backup'\\n\\tif filename.endswith(backup_suffix):\\n\\t\\traise ValueError(\\\"Looks like a backup file: \\\" + filename)\\n\\treturn filename + backup_suffix\",\n \"def get_file_basename(self):\\n return self._basename[:]\",\n \"def generate_filename(playlist_or_album_name, user_id_or_artist_id=None):\\n filename = ''\\n if user_id_or_artist_id:\\n filename += user_id_or_artist_id + '_'\\n filename += playlist_or_album_name + '_' + str(time_ns())\\n return filename\",\n \"def generate_filename(self, filename):\\n filename = str(filename).replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\n # `filename` may include a path as returned by FileField.upload_to.\\n dirname, filename = os.path.split(filename)\\n if \\\"..\\\" in pathlib.PurePath(dirname).parts:\\n raise SuspiciousFileOperation(\\n \\\"Detected path traversal attempt in '%s'\\\" % dirname\\n )\\n return os.path.normpath(os.path.join(dirname, self.get_valid_name(filename)))\",\n \"def GetSequentialFileName(base_name):\\n name, ext = os.path.splitext(base_name)\\n assert ext == '', 'base_name cannot contain file extension.'\\n index = 0\\n while True:\\n output_name = '%s_%03d' % (name, index)\\n if not glob.glob(output_name + '.*'):\\n break\\n index = index + 1\\n return output_name\",\n \"def use_name(self):\\n projection = proj.get_projection(self.conf.projections, self.spec)\\n if not projection:\\n projection = self.conf.default_projections[\\\"all\\\"]\\n\\n name = self.spec.format(projection)\\n # Not everybody is working on linux...\\n parts = name.split(\\\"/\\\")\\n name = os.path.join(*parts)\\n # Add optional suffixes based on constraints\\n path_elements = [name] + self.conf.suffixes\\n return \\\"-\\\".join(path_elements)\",\n \"def make_bids_basename(subject=None, session=None, task=None,\\n acquisition=None, run=None, processing=None,\\n recording=None, space=None, prefix=None, suffix=None):\\n bids_path = BIDSPath(subject=subject, session=session, task=task,\\n acquisition=acquisition, run=run,\\n processing=processing, recording=recording,\\n space=space, prefix=prefix, suffix=suffix)\\n bids_path._check()\\n return bids_path\",\n \"def update_filename(instance, filename):\\n path = os.path.join(\\\"documents_analizer\\\", \\\"documents\\\")\\n name = \\\"{}{}\\\".format(highly_random_name(),\\n os.path.splitext(filename)[1])\\n return os.path.join(path, name)\",\n \"def construct_basename(self, row, obstime=None):\\n _obstime = self.construct_obstime(row) if obstime is None else obstime\\n tiso = time.Time(_obstime, format='isot')\\n dtime = datetime.datetime.strptime(tiso.value, '%Y-%m-%dT%H:%M:%S.%f')\\n return '{0}-{1}_{2}_{3}{4}'.format(self['filename'][row].split('.fits')[0],\\n self['target'][row].replace(\\\" \\\", \\\"\\\"),\\n self.spectrograph.camera,\\n datetime.datetime.strftime(dtime, '%Y%m%dT'),\\n tiso.value.split(\\\"T\\\")[1].replace(':',''))\",\n \"def get_filename(filepath):\\n return os.path.basename(filepath)\",\n \"def _unique_path(prefix):\\n suffix = ''.join([\\n random.choice(string.ascii_letters) for i in range(8)\\n ])\\n return '%s/%r.%s' % (prefix, time.time(), suffix)\",\n \"def generate_unique_job_name(self, name='no_name_job'):\\n # TODO: Make it more suitable for disk paths. (no *, -)\\n from base64 import urlsafe_b64encode\\n name = os.path.basename(name)\\n return \\\"_\\\".join([os.path.split(name)[1], urlsafe_b64encode(os.urandom(3))])\",\n \"def logname():\\n global _basename\\n \\n parent = os.path.splitext(os.path.basename(wheresdaddy()))[0]\\n return '.'.join([_basename, os.path.splitext(os.path.basename(sys.argv[0]))[0], parent])\",\n \"def generate_object_storage_name(checksum, filename, default_ext=''):\\n h = checksum\\n basename, actual_ext = os.path.splitext(filename)\\n ext = actual_ext if actual_ext else default_ext\\n\\n # Use / instead of os.path.join as Windows makes this \\\\\\\\\\n directory = \\\"/\\\".join([settings.STORAGE_ROOT, h[0], h[1]])\\n return os.path.join(directory, h + ext.lower())\",\n \"def generate_file_name(well, channel, desc):\\n \\n return \\\"bPLATE_w\\\" + well + \\\"_\\\" + desc + \\\"_c\\\" + channel + \\\".png\\\"\",\n \"def temp_name(self, filename):\\n if self.params.get('nopart', False) or filename == '-' or \\\\\\n (os.path.exists(encodeFilename(filename)) and not os.path.isfile(encodeFilename(filename))):\\n return filename\\n return filename + '.part'\",\n \"def _getFileName(self, filePath):\\r\\n\\t\\thead, tail = ntpath.split(filePath)\\r\\n\\t\\treturn tail or ntpath.basename(head)\",\n \"def _get_base_app_name(value):\\n value = os.path.basename(value)\\n if (\\n value.endswith(\\\".exe\\\")\\n or value.endswith(\\\".dll\\\")\\n or value.endswith(\\\".so\\\")\\n ):\\n value = os.path.splitext(value)[0]\\n\\n return value\",\n \"def _gen_image_filename(instance, filename):\\n # First, store the original filename in the model\\n instance.original_filename = filename\\n\\n return _unique_path(instance.owner.pk, filename)\",\n \"def generate_filename(ext,sha512base16_hash=None):\\n## # Timestamp filename\\n## timestamp = str(get_current_unix_time())\\n## filename = timestamp+\\\".\\\"+ext\\n # Base16 hash filename\\n filename = sha512base16_hash+\\\".\\\"+ext\\n return filename\",\n \"def _get_available_wav_basename(label, basedir):\\n cont = 0\\n label = os.path.join(basedir, label)\\n wav_name = label + \\\".wav\\\"\\n if os.path.exists(wav_name):\\n while True: # search an inexistent name for new gmm\\n wav_name = label + \\\"\\\" + str(cont) + \\\".wav\\\"\\n if not os.path.exists(wav_name):\\n break\\n cont = cont + 1\\n else:\\n open(label+\\\".wav\\\",'w').close()\\n return label\\n open(label+str(cont)+\\\".wav\\\",'w').close()\\n return label + str(cont)\\n #end _get_available_wav_basename\",\n \"def get_default_filename() -> str:\\n return datetime.datetime.now().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")\",\n \"def filename(self, url, default_file = \\\"index.html\\\"):\\n purl = urlparse(url)\\n file_name = purl[1] + purl[2] \\n folder_name = (purl[1] + purl[2])\\n \\n if purl[2] == '':\\n folder_name += ('/' + default_file)\\n file_name += ('/' + default_file)\\n elif purl[2] == '/':\\n folder_name += default_file\\n file_name += default_file\\n elif (purl[2])[-1] == '/':\\n file_name += ('/' + default_file)\\n\\n folder_path = dirname(folder_name)\\n \\n if not isdir(folder_path): # create archive dir if nec.\\n if not exists(folder_path): \\n makedirs(folder_path)\\n return file_name\",\n \"def basename(self, filename):\\n return filename.replace(self.remote_path, '', 1).lstrip(sep)\",\n \"def generate_filename(\\r\\n filepath,\\r\\n filestartwith,\\r\\n fileendwith,\\r\\n run_date,\\r\\n filemask):\\r\\n\\r\\n filedate = generate_dateformat(run_date, filemask)\\r\\n if not filedate:\\r\\n filename = filestartwith\\r\\n else:\\r\\n filename = filestartwith + filedate\\r\\n\\r\\n if fileendwith:\\r\\n filename = filename + fileendwith\\r\\n\\r\\n if filepath and len(filepath.strip()) > 0:\\r\\n filename = filepath.strip() + '/' + filename\\r\\n\\r\\n return filename\",\n \"def thumbgen_filename(filename):\\n name, ext = os.path.splitext(filename)\\n return '%s_thumb%s' % (name, ext)\",\n \"def thumbgen_filename(filename):\\n name, ext = os.path.splitext(filename)\\n return '%s_thumb%s' % (name, ext)\",\n \"def create_file_basename(postfix: str, input_file_name: str, folder_path: str, data_root_dir: str = \\\"\\\"):\\n\\n # get the filename and directory\\n filedir, filename = os.path.split(input_file_name)\\n\\n # jettison the extension to have just filename\\n filename, ext = os.path.splitext(filename)\\n while ext != \\\"\\\":\\n filename, ext = os.path.splitext(filename)\\n\\n # use data_root_dir to find relative path to file\\n filedir_rel_path = \\\"\\\"\\n if data_root_dir:\\n filedir_rel_path = os.path.relpath(filedir, data_root_dir)\\n\\n # sub-folder path will be original name without the extension\\n subfolder_path = os.path.join(folder_path, filedir_rel_path, filename)\\n if not os.path.exists(subfolder_path):\\n os.makedirs(subfolder_path)\\n\\n # add the sub-folder plus the postfix name to become the file basename in the output path\\n return os.path.join(subfolder_path, filename + \\\"_\\\" + postfix)\",\n \"def _gen_thumbs_filename(instance, filename):\\n return _unique_path(instance.owner.pk, filename, category='thumbs')\",\n \"def getInputFileBasename(inputFilename = None):\\n\\n curInputFilename = getInputFilename()\\n\\n if inputFilename :\\n curInputFilename = inputFilename\\n\\n # print \\\"curInputFilename=%s\\\"%(curInputFilename)\\n inputBasename = getBasename(curInputFilename)\\n # print \\\"inputBasename=%s\\\"%(inputBasename)\\n return inputBasename\",\n \"def form_unique_name(string):\\r\\n return string[len(BASEPATH) + 1:].replace('/', '\\\\\\\\')\",\n \"def file_name(product, ext='json'):\\n return f\\\"./output/{product}_{datetime.now().strftime('%Y-%m-%d_%H%M%S')}_transformed_{version}.{ext}\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7162985","0.71130204","0.71064943","0.70725805","0.70725805","0.6988176","0.6869497","0.6849551","0.672568","0.6704061","0.66934615","0.65571934","0.6534404","0.64742374","0.6473847","0.646789","0.6352444","0.6296653","0.6274127","0.62643063","0.62446624","0.62266135","0.6223458","0.62166315","0.62140113","0.6213255","0.6211356","0.6198727","0.61853725","0.61833555","0.61613303","0.6151913","0.6146519","0.6144108","0.612996","0.61155814","0.6115496","0.6104637","0.60981166","0.6097714","0.60960203","0.60860085","0.6078829","0.6070952","0.6061638","0.6043562","0.60430604","0.60244954","0.6023564","0.5993007","0.5986139","0.59804976","0.5976161","0.59755385","0.59640884","0.59622794","0.59566605","0.59529","0.5943684","0.59417796","0.5936601","0.5935401","0.59347177","0.59281254","0.5919681","0.591484","0.5910397","0.59086275","0.59020025","0.5901095","0.59003294","0.58940285","0.58924705","0.58812","0.5875832","0.5873496","0.5872602","0.5871919","0.5864781","0.585982","0.5859217","0.5844224","0.58341086","0.5828121","0.58274245","0.58255994","0.58176947","0.58100516","0.5794008","0.5789715","0.57786906","0.57723397","0.57706344","0.57669705","0.57669705","0.57543373","0.574462","0.573529","0.5728477","0.5720918"],"string":"[\n \"0.7162985\",\n \"0.71130204\",\n \"0.71064943\",\n \"0.70725805\",\n \"0.70725805\",\n \"0.6988176\",\n \"0.6869497\",\n \"0.6849551\",\n \"0.672568\",\n \"0.6704061\",\n \"0.66934615\",\n \"0.65571934\",\n \"0.6534404\",\n \"0.64742374\",\n \"0.6473847\",\n \"0.646789\",\n \"0.6352444\",\n \"0.6296653\",\n \"0.6274127\",\n \"0.62643063\",\n \"0.62446624\",\n \"0.62266135\",\n \"0.6223458\",\n \"0.62166315\",\n \"0.62140113\",\n \"0.6213255\",\n \"0.6211356\",\n \"0.6198727\",\n \"0.61853725\",\n \"0.61833555\",\n \"0.61613303\",\n \"0.6151913\",\n \"0.6146519\",\n \"0.6144108\",\n \"0.612996\",\n \"0.61155814\",\n \"0.6115496\",\n \"0.6104637\",\n \"0.60981166\",\n \"0.6097714\",\n \"0.60960203\",\n \"0.60860085\",\n \"0.6078829\",\n \"0.6070952\",\n \"0.6061638\",\n \"0.6043562\",\n \"0.60430604\",\n \"0.60244954\",\n \"0.6023564\",\n \"0.5993007\",\n \"0.5986139\",\n \"0.59804976\",\n \"0.5976161\",\n \"0.59755385\",\n \"0.59640884\",\n \"0.59622794\",\n \"0.59566605\",\n \"0.59529\",\n \"0.5943684\",\n \"0.59417796\",\n \"0.5936601\",\n \"0.5935401\",\n \"0.59347177\",\n \"0.59281254\",\n \"0.5919681\",\n \"0.591484\",\n \"0.5910397\",\n \"0.59086275\",\n \"0.59020025\",\n \"0.5901095\",\n \"0.59003294\",\n \"0.58940285\",\n \"0.58924705\",\n \"0.58812\",\n \"0.5875832\",\n \"0.5873496\",\n \"0.5872602\",\n \"0.5871919\",\n \"0.5864781\",\n \"0.585982\",\n \"0.5859217\",\n \"0.5844224\",\n \"0.58341086\",\n \"0.5828121\",\n \"0.58274245\",\n \"0.58255994\",\n \"0.58176947\",\n \"0.58100516\",\n \"0.5794008\",\n \"0.5789715\",\n \"0.57786906\",\n \"0.57723397\",\n \"0.57706344\",\n \"0.57669705\",\n \"0.57669705\",\n \"0.57543373\",\n \"0.574462\",\n \"0.573529\",\n \"0.5728477\",\n \"0.5720918\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77820414"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6386,"cells":{"query":{"kind":"string","value":"fit gaussian to line"},"document":{"kind":"string","value":"def womgau(hop):\n import numpy as np\n import logging\n import matplotlib.pyplot as plt\n from scipy.optimize import curve_fit\n from tmath.wombat.womwaverange import womwaverange\n from tmath.wombat.womget_element import womget_element\n from tmath.wombat.inputter import inputter\n from tmath.wombat.inputter_single import inputter_single\n from tmath.wombat.gauss import gauss\n from tmath.wombat.gauss_cont import gauss_cont\n from tmath.wombat.yesno import yesno\n print(' ')\n logging.info('Object is {}'.format(hop[0].obname))\n print(' ')\n print('Spectrum runs from {} to {}'.format(hop[0].wave[0],hop[0].wave[-1]))\n print(' ')\n print('This routine expects the spectrum to be in flambda units.')\n print('It also expects a linear wavelength scale.')\n print(' ')\n print('Choose general region of spectrum\\n')\n nwave,nflux,mode=womwaverange(hop[0].wave,hop[0].flux,'none')\n print('\\nNow pick the exact range for the fit')\n waveint,fluxint,mode=womwaverange(nwave,nflux,mode)\n indexblue=womget_element(nwave, waveint[0])\n indexred=womget_element(nwave,waveint[-1])\n if (mode == 'w'):\n done = False\n while (not done):\n print(' ')\n wavecenter=inputter('Enter approximate center of Gaussian : ','float',False)\n indexcenter=womget_element(waveint,wavecenter)\n if (indexcenter <= 0) or (wavecenter > waveint[-1]):\n print('Bad central wavelength, try again')\n else:\n done = True\n else:\n done=False\n while (not done):\n print('Mark the approximate center of the Gaussian')\n pickcent=plt.ginput(1,timeout=-1)\n indexcenter=womget_element(waveint,pickcent[0][0])\n print('\\nApproximate center at {}'.format(waveint[indexcenter]))\n print('\\nIs this OK?')\n answer=yesno('y')\n if (answer == 'y'):\n done=True\n weights=np.sqrt(hop[0].var[indexblue:indexred+1])\n print(' ')\n continuum=inputter_single('Do you want to fit gaussian with (c)ontinuum, or (n)o continuum? ','cn')\n if (continuum == 'c'):\n p=[fluxint[indexcenter], waveint[indexcenter],3.0,1.0,waveint[0]]\n result=curve_fit(gauss_cont,waveint,fluxint,sigma=weights,p0=p,absolute_sigma=True,full_output=True)\n else:\n p=[fluxint[indexcenter], waveint[indexcenter],3.0]\n result=curve_fit(gauss,waveint,fluxint,sigma=weights,p0=p,absolute_sigma=True,full_output=True)\n coefferr=np.sqrt(np.diag(result[1]))\n coeff=result[0]\n # make 'finer-grained' version of fit, 0.2A/pix for calculations\n wavecalc=np.arange(2*5*50*abs(coeff[2]))*0.2+coeff[1]-0.2*5*50*abs(coeff[2])\n calccenter=womget_element(wavecalc,coeff[1])\n if (continuum == 'c'):\n fluxcalc=gauss_cont(wavecalc,*coeff)\n fluxcont=wavecalc*coeff[3]+coeff[4]\n fluxgaussian=fluxcalc-fluxcont\n linecont=fluxcont[calccenter]\n else:\n fluxcalc=gauss(wavecalc,*coeff)\n \n \n deltafit=wavecalc[1]-wavecalc[0]\n calcindexblue=womget_element(wavecalc,waveint[0])\n calcindexred=womget_element(wavecalc,waveint[-1])\n sumfluxcalc=np.sum(fluxcalc[calcindexblue:calcindexred+1]*deltafit)\n sumallfluxcalc=np.sum(fluxcalc*deltafit)\n chi=(result[2]['fvec']**2).sum()\n redchi=chi/(len(waveint)-len(coeff))\n if (continuum == 'c'):\n sumfluxgaussian=np.sum(fluxgaussian[calcindexblue:calcindexred+1]*deltafit)\n sumallfluxgaussian=np.sum(fluxgaussian*deltafit)\n sumfluxcont=np.sum(fluxcont[calcindexblue:calcindexred+1]*deltafit)\n sumallfluxcont=np.sum(fluxcont*deltafit)\n sumallfluxcont_test=np.sum(fluxcont)\n # propagate uncertainty (from old version) not sure this is correct\n height_pct=coefferr[0]/coeff[0]\n sigma_pct=coefferr[2]/coeff[2]\n flux_pct=np.sqrt(height_pct**2+sigma_pct**2)\n sumfluxgaussiansig=sumfluxgaussian*flux_pct\n sumallfluxgaussiansig=sumallfluxgaussian*flux_pct\n plt.cla()\n plt.plot(nwave,nflux,drawstyle='steps-mid',color='k')\n plt.ylabel('Flux')\n plt.xlabel('Wavelength')\n xmin,xmax=plt.xlim()\n ymin,ymax=plt.ylim()\n plt.plot(wavecalc,fluxcalc,drawstyle='steps-mid',color='b')\n if (continuum == 'c'):\n plt.plot(wavecalc,fluxgaussian,drawstyle='steps-mid',color='r')\n plt.plot(wavecalc,fluxcont,drawstyle='steps-mid',color='g')\n plt.plot([waveint[0],waveint[0]],[ymin,ymax],color='k',linestyle='--')\n plt.plot([waveint[-1],waveint[-1]],[ymin,ymax],color='k',linestyle='--')\n plt.xlim([xmin,xmax])\n plt.ylim([ymin,ymax])\n logging.info('For object {} Gaussian fit'.format(hop[0].obname))\n if (continuum == 'c'):\n print('\\nData = Black, Fit = Blue, Continuum = Green, Fit-Continuum = Red\\n')\n else:\n print('\\nData = Black, Fit = Blue\\n')\n logging.info('Height {:16.8f}+/-{:16.8f}'.format(coeff[0],coefferr[0]))\n logging.info('Center {:16.8f}+/-{:16.8f}'.format(coeff[1],coefferr[1]))\n logging.info('Sigma {:16.8f}+/-{:16.8f}'.format(coeff[2],coefferr[2]))\n if (continuum == 'c'):\n FWHM = 2.35482*np.abs(coeff[2])\n rest_wave = input('Rest wavelength [N/A]: ') or None\n redshift = input('Redshift [N/A]: ') or None\n if rest_wave:\n rest_wave = float(rest_wave)\n w1 = (rest_wave - FWHM/2.)/(1.+float(redshift)) \n w2 = (rest_wave + FWHM/2.)/(1.+float(redshift)) \n c = 299792.458\n v1 = -1.*c*((rest_wave/w1)**2. - 1)/(1+((rest_wave/w1)**2.))\n v2 = -1.*c*((rest_wave/w2)**2. - 1)/(1+((rest_wave/w2)**2.))\n logging.info('Slope {:16.8f}+/-{:16.8f}'.format(coeff[3],coefferr[3]))\n logging.info('Y-intercept {:16.8f}+/-{:16.8f}'.format(coeff[4],coefferr[4]))\n logging.info('FWHM {:16.8f}+/-{:16.8f}'.format(2.35482*np.abs(coeff[2]),2.35482*coefferr[2]))\n logging.info('FWHM (velocity) {:16.8f} km/s'.format(v2-v1))\n logging.info('Flux between dotted lines (Gaussian): {:16.8f}+/-{:16.8f}'.format(sumfluxgaussian, sumfluxgaussiansig))\n logging.info('EW between dotted lines (Gaussian): {:16.8f}'.format(sumfluxgaussian/linecont))\n logging.info('Flux for full (Gaussian): {:16.8f}+/-{:16.8f}'.format(sumallfluxgaussian, sumallfluxgaussiansig))\n logging.info('EW for full (Gaussian): {:16.8f}'.format(sumallfluxgaussian/linecont))\n logging.info('Continuum flux at line center: {:16.8f}'.format(linecont))\n\n \n logging.info('Chi^2: {}'.format(chi))\n logging.info('Reduced chi^2: {}'.format(redchi))\n logging.info('All fluxes might need to be scaled by 1e-15')\n print(' ')\n return hop"},"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 line_fit(x,y):\n\t# clean\n\tx = np.squeeze(x)\n\ty = np.squeeze(y)\n\t# concatenate\n\txy = np.concatenate((x[:,np.newaxis],y[:,np.newaxis]),1)\n\t# sort by x values\n\txy = xy[xy[:,0].argsort()]\n\t#print(xy)\n\tf = lambda x,m,b : m*x+b\n\tpars,_ = opt.curve_fit(f,xy[:,0],xy[:,1])\n\tm = pars[0]\n\tb = pars[1]\n\tpts = np.zeros((2,2))\n\tpts[0,0] = xy[0,0]\n\tpts[1,0] = xy[-1,0]\n\tpts[:,1] = pts[:,0]*m+b\n\tsig = np.std((xy[:,1]-f(xy[:,0],m,b)))\n\treturn pts, sig","def fitgaussian(self, data):\n params = self.moments(data)\n errorfunction = lambda p: ravel(self.Gauss(*p)(*indices(data.shape)) - data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: ravel(gaussian(*p)(*indices(data.shape)) -\n data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def fit_gaussian(array):\n\n shape = array.shape\n xmean, ymean = numpy.array(shape) / 2.\n\n xx, yy = numpy.mgrid[:shape[0], :shape[1]]\n\n g_init = astropy.modeling.models.Gaussian2D(amplitude=1., x_mean=xmean, y_mean=ymean,\n x_stddev=1., y_stddev=1.)\n\n f2 = astropy.modeling.fitting.LevMarLSQFitter()\n\n gg = f2(g_init, xx, yy, array)\n\n return gg","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\n data)\n p, success = leastsq(errorfunction, params)\n return p","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\n data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\n data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\n data)\n #p, success = optimize.leastsq(errorfunction, params)\n bnds = (0,30)\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\n #least square fitting(minimizes raw data and fit)\n return p","def gauss_fit(seld, data=''):\n mean, std = norm.fit(data)\n return mean, std","def Gaussian(x, mu=0, sigma=26.4, A=1, y0=0):\r\n #width = sigma*(2*np.sqrt(2*np.log(2)))\r\n b = 1/(sigma*np.sqrt(2*np.pi))\r\n f = b*np.power(np.e, -(((x-mu)**2)/(2*sigma**2)))\r\n return A*f + y0","def gaussian(mu, wid, x):\n return np.exp(-((x - mu) / (0.6005612 * wid))**2)","def fit_gauss(x, y):\n nx = numpy.array(x)\n ny = numpy.array(y)\n ne = numpy.ones(len(ny))\n#\n#--- we need to give an initial guess\n#\n ymax = numpy.max(ny)\n med = find_med(y)\n p0 = [ymax, med, 10, 0]\n\n fitobj = kmpfit.Fitter(residuals=residualsG, data=(nx,ny,ne))\n fitobj.fit(params0=p0)\n [amp, cent, width, floor] = fitobj.params\n\n return [amp, cent, width]","def gaussian(pars, x):\n A, b, mu, sigma = pars\n # return b + A/(np.sqrt(2*np.pi)*sigma**2) \\\n return b + A \\\n * np.exp(-.5*(x - mu)**2/sigma**2)","def gaussian(x, *parameters):\n position, sigma, amplitude, background = parameters\n return amplitude * np.exp(-(x - position)**2 / (2.0 * sigma**2)) + background","def fit_line(model,scaling):\n\treturn scaling*model","def gaussian(amp, fwhm, mean, x):\n return amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)","def line_gaussian_activity(self, x_loc):\n dist = np.abs(x_loc - self.pref_line_gaussian) # non_periodic boundary\n dist /= self.sd_gaussianline # standard deviation\n return np.exp(-dist ** 2 / 2)","def line_gaussian_activity(self, x_loc):\n dist = np.abs(x_loc - self.pref_line_gaussian) # non_periodic boundary\n dist /= self.sd_gaussianline # standard deviation\n return np.exp(-dist ** 2 / 2)","def fit_gaussian(x, y, z):\n\n def sym_gaussian(p):\n \"\"\"\n Returns a Gaussian function:\n a**2 * exp(-((x - x_0)**2 + (y - y_0)**2) / (2 * sigma**2))\n p = [a, x_0, y_0, sigma]\n \"\"\"\n a, x_0, y_0, sigma = p\n return a**2 \\\n * np.exp(-((x - x_0)**2 + (y - y_0)**2) / (2.0 * sigma**2))\n\n def sym_gaussian_resids(p):\n \"\"\"Residuals to be sent into leastsq\"\"\"\n return z - sym_gaussian(p)\n\n def guess_fit_gaussian():\n \"\"\"\n return a, x_0, y_0, and sigma based on computing moments of data\n \"\"\"\n a = z.max()\n\n # Compute moments\n total = z.sum()\n x_0 = np.dot(x, z) / total\n y_0 = np.dot(y, z) / total\n\n # Approximate sigmas\n sigma_x = np.dot(x**2, z) / total\n sigma_y = np.dot(y**2, z) / total\n sigma = np.sqrt(sigma_x * sigma_y)\n\n # Return guess\n return (a, x_0, y_0, sigma)\n\n # Get guess\n p0 = guess_fit_gaussian()\n\n # Perform optimization using nonlinear least squares\n popt, junk_output, info_dict, mesg, ier = \\\n scipy.optimize.leastsq(sym_gaussian_resids, p0, full_output=True)\n\n # Check to make sure leastsq was successful. If not, return centroid\n # estimate.\n if ier in (1, 2, 3, 4):\n return (popt[0]**2, popt[1], popt[2], popt[3])\n else:\n return p0","def fitgaussian(data):\n params = moments(data)\n errorfunction = lambda p: np.ravel(gaussian_norot(*p)(*np.indices(data.shape)) -\n data)\n #scipy rihjt\n # Levenberg-Marquadt algorithm -> leastsq\n #bnds = None\n height, x, y, width_x, width_y, he1, x1,y1, wi1, wi2 = params\n #p, success = optimize.leastsq(errorfunction, params)\n bnds = (0,30)\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\n \n #least square fitting(minimizes raw data and fit)\n\n if(p[0] < 1 and p[5] < 1 and p[1] > 0 and p[1] < 30 and p[2] > 0 and p[2] < 30 and p[6] > 0 and p[6] < 30 and p[7] > 0 and p[7] < 30):\n #print(\"pass case\")\n return(p)\n else:\n print(\"failed case\")\n print(\"height1\", p[0],\"height2\", p[5], \"X\", p[1],\"Y\", p[2],\"Y1\", p[6], \"Y2\", p[7])\n print(\"bounding error\" + str(numero)) \n\n return p","def fit_line(data, error_func):\n\n # Generate initial guess for line model\n l = np.float32([0, np.mean(data[:, 1])]) # slope = 0, intercept = mean(y values)\n\n # Plot initial guess (optional)\n x_ends = np.float32([-5, 5])\n plt.plot(x_ends, l[0] * x_ends + l[1], 'm--', linewidth = 2.0, label = 'Initial guess')\n\n # Call optimizer to minimize error function\n result = spo.minimize(error_func, l, args = (data, ), method = 'SLSQP', options = {'disp': True})\n return result.x","def gaussian(x, mu, sigma):\n return (np.exp(-(x - mu)**2 / 2.0 / sigma**2) /\n np.sqrt(2.0 * np.pi) / sigma)","def fit_gaussian2d(image):\n\n # Estimate center of target\n y_mean, x_mean = np.array(image.shape) // 2 # Center guess\n\n # Create model to fit\n model = models.Gaussian2D(amplitude=image.max(),\n x_mean=x_mean,\n y_mean=y_mean,\n fixed={}\n )\n\n # Fit model to grid\n fitted_model, fit = fit_model(image, model)\n\n return fitted_model","def gaussian_k(x0, y0, sigma, height, width):\n y = np.arange(0, width, 1, float)\n x = np.arange(0, height, 1, float)[:, np.newaxis]\n return np.exp(-((x - x0) ** 2 + (y - y0) ** 2) / (2 * sigma ** 2))","def fit(self, X, y):","def fit(self, X, y):","def fit(self, X, y):","def fit_gaussian(arr):\n\tif isinstance(arr, ac.kernels.Kernel):\n\t\tarr = arr.array\n\telif isinstance(arr, np.ndarray):\n\t\tpass\n\telse: \n\t\traise Exception(\"[psfmatch] input needs to be a kernel or array\")\n\n\tnx, ny = arr.shape\n\tx, y = get_xy_grid(nx, ny)\n\n\tmodel_init = am.functional_models.Gaussian2D(amplitude=arr.max(), x_mean=0., y_mean=0., x_stddev=5., y_stddev=5., theta=0.)\n\tfitter = am.fitting.LevMarLSQFitter()\n\n\t# with warnings.catch_warnings():\n\t\t# warnings.simplefilter('ignore')\n\tmodel_best = fitter(model_init, x, y, arr)\n\n\treturn model_best","def gaussian(x, mean, sigma):\n return np.exp(-np.square(x-mean)/(2*np.square(sigma))) / (np.sqrt(2*np.pi*sigma**2))","def gaussian(self, amp_step, sigma_step):\n l = len(self.overlaid_x_axis)\n x = np.linspace(0, l, l) - l/2 # centre of data\n\n # This is new code to 'guess' the size of the Gaussian from the\n # existing data rather than from hard-coded numbers.\n # TODO: test this! Possibly link up to the get_windowed_data function\n # as it uses a lot of the same functionality\n trigger = self.pv_monitor.arrays[self.controls.Arrays.WAVEFORMS][0]\n trace = self.pv_monitor.arrays[self.controls.Arrays.WAVEFORMS][1]\n amplitude = max(trace) + amp_step\n diff = np.diff(trigger)\n stepvalue = 0.5\n if min(diff) > -1 * stepvalue or max(diff) < stepvalue:\n raise RangeError\n else:\n maxtrig = next(x for x in diff if x > stepvalue)\n mintrig = next(x for x in diff if x < -1 * stepvalue)\n edges = [np.where(diff == maxtrig)[0][0],\n np.where(diff == mintrig)[0][0]]\n half_trigger_length = (edges[1]-edges[0])\n sigma = half_trigger_length/4 + sigma_step\n\n gauss = self.ax2.plot(amplitude * np.exp(-x**2 / (2 * sigma**2)), 'r')\n self.overlaid_lines.append(gauss)\n self.draw()","def gaussian(height, center_x, center_y, width_x, width_y):\n width_x = float(width_x)\n width_y = float(width_y)\n return lambda x,y: height*np.exp(\n -(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)","def gaussian(height, center_x, center_y, width_x, width_y):\n width_x = float(width_x)\n width_y = float(width_y)\n return lambda x,y: height*np.exp(\n -(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)","def gaussian(height, center_x, center_y, width_x, width_y):\n width_x = float(width_x)\n width_y = float(width_y)\n return lambda x,y: height*np.exp(\n -(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)","def gaussian(height, center_x, center_y, width_x, width_y):\n width_x = float(width_x)\n width_y = float(width_y)\n return lambda x,y: height*exp(\n -(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)","def lin_gaus_2d(x, y, A, mu_x, sigma_x, mu_y, sigma_y, m, b):\n return A * np.exp(-((x-mu_x)**2/(2.*sigma_x**2)+(y-mu_y)**2/(2.*sigma_y**2))) + y*m + b","def gaussian(p, x):\n #2008-09-11 15:11 IJC: Created for LINEPROFILE\n # 2011-05-18 11:46 IJC: Moved to analysis.\n # 2013-04-11 12:03 IJMC: Tried to speed things up slightly via copy=False\n # 2013-05-06 21:42 IJMC: Tried to speed things up a little more.\n\n if not isinstance(x, np.ndarray):\n x = array(x, dtype=float, copy=False)\n\n if len(p)==3:\n p = array(p, copy=True)\n p = concatenate((p, [0]))\n #elif len(p)==4:\n # p = array(p, copy=False)\n\n return p[3] + p[0]/(p[1]*sqrt(2*pi)) * exp(-(x-p[2])**2 / (2*p[1]**2))","def fit(self, x):\n self.alpha = np.mean(x)\n self.is_fit = True","def gaussian(x, amp, cen, wid):\n return amp * exp (-(x-cen)**2/(2*wid**2))","def _gaussian_distribution(self, x: ndarray, mu: float, sigma: float) -> ndarray:\n return 1 / (np.sqrt(2 * np.pi) * sigma) * np.exp(\n -np.power(\n (x - mu) / sigma, 2) / 2)","def fit_gaussian(self, mask=None):\n data = self.data\n mask = numpy.logical_or(mask, numpy.ma.getmaskarray(data))\n fdata = data[~mask].data\n xdata = numpy.asarray([cm[~mask]\n for cm in self.bset.cmesh]).transpose()\n scale, mean, cov = fit_ndgaussian(xdata, fdata)\n return scale, mean, cov","def gaussian(height, center_x, center_y, width_x, width_y):\n width_x = float(width_x)\n width_y = float(width_y)\n return lambda x,y: height*np.exp(-(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)","def gaussian(x, amp, wid, cen):\n return amp*np.exp(-(x-cen)**2/(2*wid**2))","def least_sqr_fit(self,x, y):\n A = np.array([ x, np.ones(len(x))])\n # linearly generated sequence\n a,f,g,h = np.linalg.lstsq(A.T,y) # obtaining the parameters\n print 'de gevonden rechte = %.10f x + %.10f' %(a[0], a[1])\n lined = map(lambda g: a[0]*g +a[1],x) # regression line\n return lined , a","def gaussian(x, x0=0.0, fwhm=1.0, ampl=1.0):\n return ampl * np.exp(-4 * np.log(2) * ((x - x0) / fwhm) ** 2)","def gaussian(x, y, params):\n\n n = len(x)\n mix = np.zeros((n,))\n\n ex = (((x - params[0])**2) / (2.*params[2]**2))\n ey = (((y - params[1])**2) / (2.*params[2]**2))\n mix = ex + ey\n\n pdf = np.sqrt((1. / (2*np.pi*params[2]**2))) * np.exp(-1*mix)\n\n return pdf","def random_line(a, b, sigma, size=10,start=-1,end=1):\n xdata = np.linspace(start,end,size)\n errors = scipy.stats.norm.rvs(loc=0,scale=sigma, size=size)\n ydata = a*xdata + b + errors\n return xdata, ydata","def gaussian(x, peak_x=.0, sigma=1.0, name=''):\n x = x.astype(np.float)\n variables = {'function': gaussian, 'peak_x': peak_x, 'sigma': sigma}\n y = np.exp((-1 * (x - peak_x)**2) / (2 * sigma**2))\n return packer(x, y, variables, name=name)","def doubleGaussian(p, x):\n # 2013-05-06 20:29 IJMC: Created\n\n x = array(x, dtype=float, copy=False)\n return gaussian(p[0:3], x) + gaussian(p[3:], x)","def gaussian(\n self,\n width=None,\n mfreq=None,\n chromaticity=None,\n dtype=None,\n power=True,\n ):\n widths, dtype = self._process_args(width, mfreq, chromaticity, dtype)\n response = np.exp(-0.5 * (self.xs / np.sin(widths)) ** 2)\n if power:\n response = response ** 2\n return response.astype(dtype)","def gaussian2d(x, y, A, sigma, x0):\n Z = A * np.exp(-( (x-x0[0])**2/(2*sigma[0]**2) + (y-x0[1])**2/(2*sigma[1]**2)))\n return Z","def expgaussian(mu, wid, timeconstant, x): \n # Gaussian signal broadened by an exponetial signal\n g = gaussian(mu, wid, x)\n \n hly = np.round( len(g) / 2.0 )\n ey = np.r_[np.zeros(hly),g,np.zeros(hly)]\n fy = np.fft.fft(ey)\n a = np.exp(-(np.arange(len(fy))) / timeconstant )\n fa = np.fft.fft(a)\n fy1 = fy * fa\n ybz = np.real(np.fft.ifft(fy1)) / np.sum(a)\n yb = ybz[hly:len(ybz)-hly]\n \n return yb","def fit_amplitudes(self, v=False):\n\n x = self.star.ds.mode_id['f0'].as_matrix()\n height = self.star.ds.mode_id['A0'].as_matrix()\n sd_height = self.star.ds.mode_id['A0_err'].as_matrix()\n if v: print 'x:', x\n if v: print 'height:', height\n if v: print 'sd_height:', sd_height\n\n mean = sum(height*x) / sum(height) # weighted mean x value\n sigma = np.sqrt(sum(height * (x - mean)**2) / sum(height)) # weighted Gaussian sd\n\n popt, pcov = curve_fit(self.Gauss, x, height,\\\n p0=[max(height), mean, sigma], sigma=sd_height, absolute_sigma=True)\n self.numax = popt[1]\n # sd_numax = np.sqrt(np.diag(pcov))[1] # the uncertaintiy on numax\n if v: print 'numax:', self.numax","def gaussian_kernel(training_ex, landmark, sigma=0.1):\n return np.exp(-(np.linalg.norm(training_ex - landmark) ** 2 / (2 * (sigma ** 2))))","def gaussian(amp, fwhm, mean):\n return lambda x: amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)","def gaussian2d(x, amplitude=1.0, center_x=0.0, sigma_x=1.0, center_y=0.0, sigma_y=1.0, rota=0.0):\n \n if len(x) == 1:\n y = x\n else:\n (x, y) = x\n \n if not sigma_y:\n sigma_y = sigma_x\n \n if not center_y:\n center_y = center_x\n \n if rota:\n center_x = center_x*np.cos(np.deg2rad(rota)) - center_y*np.sin(np.deg2rad(rota))\n center_y = center_x*np.sin(np.deg2rad(rota)) + center_y*np.cos(np.deg2rad(rota)) \n \n x = x*np.cos(np.deg2rad(rota)) - y*np.sin(np.deg2rad(rota))\n y = x*np.sin(np.deg2rad(rota)) + y*np.cos(np.deg2rad(rota))\n \n norm = 2.*np.pi*sigma_x*sigma_y\n #exp_x = np.power((x - center_x)/(sigma_x), 2.)\n #exp_y = np.power((y - center_y)/(sigma_y), 2.)\n g = amplitude*np.exp(-(((center_x - x)/sigma_x)**2 + \\\n ((center_y - y)/sigma_y)**2)/2.)\n \n return g #(amplitude/norm)*np.exp(-(exp_x + exp_y)/2.)","def lin_gaus(x,m,b,A,mu,sigma):\n return m*x+b + gaus(x,A,mu,sigma)","def gaussian(centre, k, intensity, xpos):\r\n\treturn intensity * np.exp(- np.power(k * (xpos - centre), 2))","def Gaussian(x, mu, sigma, a):\n amplitude = a / ( sigma * np.sqrt(2 * np.pi) )\n u = (x - mu) / sigma\n return amplitude * np.exp( -0.5 * (u**2) )","def gaussianise_series(self, train_x):\n\n n_batches = train_x.shape[0]\n\n for batch in range(n_batches):\n train_x[batch, :, :] = gaussianise(train_x[batch, :, :], target_sigma=1.0)\n\n return train_x","def gauss_rbins_fit(self, plotfig=False, plotrmax=50, normtype=1):\n A0 = self.rbins.max()\n sigmaArr = np.arange(200)*.2 + .2 # double check\n # sigmaArr=np.array([30.])\n sigma_min, rms, Amin = _gauss_rbins_fit(self.rArr, self.rbins, sigmaArr=sigmaArr, normtype=normtype)\n self.rbins_pre = Amin/np.sqrt(2*np.pi)/sigma_min*np.exp(-(self.rArr)**2/2./(sigma_min**2))\n self.Amin = Amin\n self.sigma_rbins = sigma_min\n self.rms = rms\n if plotfig:\n ax=plt.subplot()\n plt.plot(self.rArr, self.rbins, 'o', ms=10, label='observed')\n # plt.plot(self.rArr, self.rbins_pre_gauss, 'k--', lw=3, label='Best fit Gaussian distribution')\n plt.plot(self.rArr, self.rbins_pre, 'k--', lw=3, label='Best fit Gaussian distribution')\n plt.ylabel('PDF ', fontsize=30)\n plt.xlabel('Radius (nm)', fontsize=30)\n ax.tick_params(axis='x', labelsize=20)\n ax.tick_params(axis='y', labelsize=20)\n plt.legend(loc=0, fontsize=20, numpoints=1)\n plt.yscale('log', nonposy='clip')\n plt.xlim(0, plotrmax)\n plt.ylim(1e-8, 0.1)\n plt.show()","def gaussian_prior(self):\n self.prior = sps.multivariate_normal(self.m0,self.S0)","def gauss_fit_2(self, s, bin1):\n\t\tmean, std = sp.norm.fit(s)\t\t# Distribution fitting\n\t\tcount, bins, ignored = plt.hist(s, bin1, normed=True)\t# Extracting the parameters from the histogram\n\t\tpdf_fitted = sp.norm.pdf(bins, loc=mean, scale=std)\n\t\tprint \" \"\n\t\tprint \"Gaussian Distribution Extraction\"\n\t\tprint \"Extracted mean is :\", mean\n\t\tprint \"Extracted standard deviation is :\",std\n\t\tprint \" \"\n\t\tplt.plot(bins, pdf_fitted, linewidth=2, color='k', label='Gaussian')\n\t\tplt.title(\"Gaussian Distribution Estimation\")\n\t\tplt.show()\n\t\treturn pdf_fitted","def _multivariate_gaussian(self, x, mu_k, sigma_k):\n return multivariate_normal.pdf(x, mu_k, sigma_k)","def gaussian(T, Y, X, t, y, x, sigma, sigma_t=1):\n const_value = np.sqrt(2 * np.pi * sigma) ** 3\n norm = np.exp(\n -(\n ((X - x) ** 2) / (2 * sigma ** 2)\n + ((Y - y) ** 2) / (2 * sigma ** 2)\n + ((T - t) ** 2) / (2 * sigma_t ** 2)\n )\n )\n return norm / const_value","def fit_line(x_data, y_data):\n\tslope, y_intercept, r_value, p_value, std_err = stats.linregress(x_data, y_data)\n\tr_squared = r_value * r_value\n\treturn slope, y_intercept, r_squared, p_value, std_err","def fit(self, X):","def doubleGaussian(x, m1, s1, a1, m2, s2, a2):\n # primary peak\n g1 = np.exp(-0.5*((x-m1)/s1)**2)\n # secondary peak\n g2 = np.exp(-0.5*((x-m2)/s2)**2)\n # total model\n mod1 = 1 - a1 * g1\n mod2 = 1 - a2 * g2\n modt = mod1 + mod2 - 1\n return modt","def Gaussian(x,t,sigma):\n return np.exp(-(x-t)**2/(2*sigma**2))","def fitbivarGaussian(data):\n params = bivarParams(data)\n errorfunction = lambda p: ravel(bivarGaussian(*p)(*indices(data.shape)) -\n data)\n p, success = optimize.leastsq(errorfunction, params)\n return p","def fit_line_Vo(x, y, n):\n x1=x[0:n]\n y1=y[0:n]\n X = sm.add_constant(x1)\n model = sm.OLS(y1, X, missing='drop') # ignores entires where x or y is NaN\n fit = model.fit()\n m=fit.params[1] \n b=fit.params[0] \n# stderr=fit.bse # could also return stderr in each via fit.bse\n \n N = 100 # could be just 2 if you are only drawing a straight line...\n points = np.linspace(x.min(), x.max(), N)\n \n \n fig=plt.figure(1) #PLOTING TOGETHER\n \n ax = fig.add_subplot(111)\n ax.plot(x, y)\n ax.plot(points, m*points + b)\n \n plt.legend(['data','fitt Vo'],fontsize=16)\n \n ax.set_yscale('linear',fontsize=16)\n ax.tick_params(axis='x', labelsize=14)\n ax.tick_params(axis='y', labelsize=14)\n plt.ylabel('Abs',fontsize=16)\n plt.xlabel('Time(sec)',fontsize=16)\n ax.grid()\n plt.grid()\n plt.show()\n \n print(\"The Vo fitted model is: {0:2f}*x+{1:2f} \".format(m, b))\n return m,b","def _gaussian(self, c, sigma):\n d = 2*sigma*sigma\n ax = exp(-power(self._xx-self._xx.T[c], 2)/d)\n ay = exp(-power(self._yy-self._yy.T[c], 2)/d)\n return (ax * ay).T # the external product gives a matrix","def onedgauss(x,H,A,dx,w):\n #H,A,dx,w = params\n return H+A*np.exp(-(x-dx)**2/(2*w**2))","def gauss_smooth(data, sigma):\n\t\t\t# make the kernel 5 sigmas wide in each direction\n\t\t\tkernel = stats.norm.pdf(np.arange(-5*sigma, (5*sigma)+1), scale=sigma)\n\t\t\t\n\t\t\treturn sp.ndimage.convolve1d(data, kernel, axis=2)","def gaussian(t, params):\n DeprecationWarning(\"Using standard width. Better use gaussian_sigma.\")\n params['sigma'] = Qty(\n value=params['t_final'].get_value()/6,\n min_val=params['t_final'].get_value()/8,\n max_val=params['t_final'].get_value()/4,\n unit=params['t_final'].unit\n )\n return gaussian_sigma(t, params)","def regress(pts):\n # split points in list of x- and y-values\n xs, ys = split(pts)\n # adjust x- and y-values (subtract the mean)\n _, xsadj = adjust(xs)\n _, ysadj = adjust(ys)\n # calculate variances (spread) in x- and y-direction\n # If one of the two variances is (nearly) 0,\n # we short circuit our logic\n # -> points then have to be on a straight line\n # (either horizontal or vertical)\n sx = variance(xsadj, m=0)\n if near_zero(sx): # == 0\n return ysadj, xsadj\n sy = variance(ysadj, m=0)\n if near_zero(sy): # == 0\n return xsadj, ysadj\n # calculate covariance\n sxy = cov(xsadj, ysadj, 0, 0)\n # get list of eigenvalues and vectors\n # these are sorted based on size of eigenvalues\n eig_sorted = sorted(zip(*eig_2x2(sx, sxy, sxy, sy)), reverse=True)\n vecs = [vec for _, vec in eig_sorted]\n newxs, newys = [], []\n for pt in zip(xsadj, ysadj):\n # no need to transpose the vectors as they are\n xnew = vecs[0][0] * pt[0] + vecs[0][1] * pt[1]\n ynew = vecs[1][0] * pt[0] + vecs[1][1] * pt[1]\n newxs.append(xnew)\n # residuals?!\n # These should be squared distances to regression line that was fitted\n newys.append(ynew)\n return newxs, newys","def gaussian(x, sigma):\n try: r = np.exp(-0.5*(x/sigma)**2) \n except: r = np.zeros(len(x))\n return r","def gaussian(mu, sigma, start, end):\r\n \r\n val = np.linspace(start, end, 100)\r\n a = 1/(sigma*np.pi)\r\n b = - 0.5 * np.power((mu - val)/sigma, 2)\r\n return a*np.exp(b)","def bigaussian(mu, wid, x, m = 0.5):\n lx = x.shape[0]\n ix = np.where(x == mu)[0][0]\n \n y = np.ones(lx)\n y[0:ix] = gaussian(mu, wid * m, x[0:ix])\n y[ix+1:lx] = gaussian(mu, wid * (1 - m), x[ix+1:lx]) \n \n return y","def fit_model(self):\r\n\t\tself.mu = np.mean(self.x, axis = 0)\r\n\t\tself.sig = np.std(self.x, axis = 0)","def src_gauss(l, m, sigma_lm, A=1., i=0., pa=0., l0=0., m0=0.):\n l = np.atleast_1d(l)\n m = np.atleast_1d(m)\n sigma_x = sigma_lm\n sigma_y = sigma_lm * np.cos(i)\n a = 0.5 * ((np.cos(pa) / sigma_x)**2. + (np.sin(pa) / sigma_y)**2.)\n b = 0.5 * np.sin(2. * pa) * (sigma_x**-2. - sigma_y**-2.)\n c = 0.5 * ((np.sin(pa) / sigma_x)**2. + (np.cos(pa) / sigma_y)**2.)\n p = a * (l - l0)**2. + b * (l - l0) * (m - m0) + c * (m - m0)**2.\n I = A * np.exp(-p) / (2. * pi * sigma_x * sigma_y)\n return I","def g_multivariate_normal(x,M):\n return .5*np.dot(x,M+M.T)","def y_model(self, x):\n x = np.asanyarray(x, dtype=float)\n parvals = self.parvals(x)\n return Gaussian1D(**parvals)","def gaussianDist(self, x, mu, var):\n val = 1/(math.sqrt(2 * math.pi * var)) * math.exp(-1 * (x - mu)**2 / (2*var))\n return val","def fit(self, x, y): \n # *** START CODE HERE ***\n y = y.reshape(y.shape[0], 1)\n y_0 = (1 - y).reshape(y.shape)\n m = y.shape[0]\n m_0 = np.asscalar(np.sum(y_0))\n m_1 = np.asscalar(np.sum(y))\n # Find phi, mu_0, mu_1, and sigma\n phi = np.sum(y) / m\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\n # Write theta in terms of the parameters\n sigma_inv = np.linalg.inv(sigma)\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\n # Compute cost\n x_0 = np.zeros((x.shape[0], 1)) + 1\n x_train = np.concatenate((x_0.T, x.T))\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\n if self.verbose:\n print(\"Cost: \" + str(cost))\n # *** END CODE HERE ***","def linear_slope_fit(wf, mean_y, sigma_y, slope, intercept):\n\n sum_x = sum_x2 = sum_xy = sum_y = mean_y[0] = sigma_y[0] = 0\n isum = len(wf)\n\n for i,value in enumerate(wf):\n sum_x += i \n sum_x2 += i**2\n sum_xy += (value * i)\n sum_y += value\n mean_y += (value-mean_y) / (i+1)\n sigma_y += (value-mean_y)**2\n\n\n sigma_y /= (isum + 1)\n np.sqrt(sigma_y, sigma_y)\n\n\n slope[0] = (isum * sum_xy - sum_x * sum_y) / (isum * sum_x2 - sum_x * sum_x)\n intercept[0] = (sum_y - sum_x * slope[0])/isum","def fit_line(data, component=0): # fit 3d line to 3d data\n\n m = data.mean(0)\n max_val = np.round(2*abs(data - m).max()).astype(int)\n uu, dd, vv = np.linalg.svd(data - m)\n return vv[component]","def gauss(x, *p):\n A, mu, sigma = p\n\n return A*np.exp(-(x-mu)**2/(2.*sigma**2))","def scipy_smooth(img, sigma=5):\n return ndimage.gaussian_filter(img, sigma=sigma)","def GaussianFit(data, title=\"\"):\n y, binEdges = np.histogram(data, 50)\n x = (binEdges[:-1] + binEdges[1:]) / 2\n x_width = (x[-1] - x[0]) / len(x)\n y_err = np.sqrt(y) # items in a bin should follow the Poisson distribution\n\n # calculate optimal fit parameters and covariance matrix using least squares method\n popt, cov = curve_fit(Gaussian, x, y, [np.mean(data), np.std(data), 10])\n\n # plot data\n plt.bar(x, y, x_width, yerr=y_err, color=\"blue\", edgecolor=\"black\", capsize=3, ecolor=\"black\")\n \n text1 = \"Mean (GeV): \" + str( round_to(popt[0], cov[0, 0]) ) + \" $\\pm$ \" + str( round_to(cov[0, 0], cov[0, 0]) )\n\n text2 = \"Standard deviation (GeV): \" + str( round_to(popt[1], cov[1, 1]) ) + \" $\\pm$ \" + str( round_to(cov[1, 1], cov[1, 1]) )\n\n text = '\\n'.join((text1, text2))\n\n # plot gaussian fit\n x_int = np.linspace(x[0], x[-1], 10*len(x)) # interpolate data\n y_int = Gaussian(x_int, *popt)\n plt.plot(x_int, y_int, label=\"Gaussian fit\", color=\"red\")\n\n\n plt.annotate(text, xy=(0.025, 0.8), xycoords='axes fraction')\n\n # plot options\n plt.legend()\n plt.xlabel(\"Energy (GeV)\")\n plt.ylabel(\"Number of events (bin width=\" + str(round(x_width, 2)) + \" GeV)\")\n plt.title(title)\n #plt.title(\"Beam momentum 100GeV, magnetic field \" + str(geometry.B) + \"T.\")\n \n # return some results, mean, standard deviation, amplitude\n return [popt[0], cov[0, 0]], [popt[1], cov[1, 1]], [popt[2], cov[2, 2]]","def gaussfit(x, y, nterms=\"none\"):\n\n z = lambda x, A1, A2: (x - A1) / A2\n\n if nterms in [\"none\", 3]:\n gauss = lambda x, A0, A1, A2: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\n p0 = [max(y), 1, 1]\n elif nterms in [\"constant\", 4]:\n gauss = lambda x, A0, A1, A2, A3: A0 * np.exp(-z(x, A1, A2) ** 2 / 2) + A3\n p0 = [max(y), 1, 1, 0]\n elif nterms in [\"linear\", 5]:\n gauss = (\n lambda x, A0, A1, A2, A3, A4: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\n + A3\n + A4 * x\n )\n p0 = [max(y), 1, 1, 0, 0]\n\n elif nterms in [\"quadratic\", 6]:\n gauss = (\n lambda x, A0, A1, A2, A3, A4, A5: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\n + A3\n + A4 * x\n + A5 * x ** 2\n )\n p0 = [max(y), 1, 1, 0, 0, 0]\n\n popt, _ = curve_fit(gauss, x, y, p0=p0)\n return gauss(x, *popt), popt","def gaussian(x, amplitude=1.0, center=0.0, sigma=1.0):\n \n return (amplitude/(np.sqrt(2.*np.pi)*sigma)) * exp(-np.power((1.0*x-center)/(sigma), 2.)/2.)","def makeGaussian(size, fwhm, center=None):\n\n x = sp.arange(0, size, 1, float)\n y = x[:,sp.newaxis]\n\n if center is None:\n x0 = y0 = size // 2\n else:\n x0 = center[0]\n y0 = center[1]\n\n return sp.exp(-4*sp.log(2) * ((x-x0)**2 + (y-y0)**2) / fwhm**2)","def fit(self, x):\n x = np.asarray(x)\n _ = self.fit_transform(x)","def fit_gaussian(position, energy, dx=0.005, a=2, b=1.5, db=0.01, tolerance=0.05, max_iterations=1000):\n min_energy, max_energy = min(energy), max(energy)\n x_start, x_range = min(position), max(position) - min(position)\n x_gauss = np.arange(0, x_range, dx)\n f_gauss = np.exp(-a * (x_range / 2 - x_gauss) ** 2 + b)\n delta_energy = abs(max(f_gauss) - max_energy)\n b_direction = np.sign(max_energy - max(f_gauss))\n print('E_WHAM: %.3f | E_GAUSS: %.3f | b_direction: %i' % (max_energy, max(f_gauss), b_direction))\n for i in range(max_iterations):\n b = b + b_direction * db\n f_gauss_trial = np.exp(-a * (x_range / 2 - x_gauss) ** 2 + b)\n delta_energy_trial = abs(max(f_gauss_trial) - max_energy)\n if delta_energy_trial < tolerance:\n f_gauss = f_gauss_trial\n print('Found b value: %.2f with dE: %.3f within tolerance in %i iterations' % (b, delta_energy, i))\n break\n elif delta_energy_trial < delta_energy:\n f_gauss = f_gauss_trial\n delta_energy = delta_energy_trial\n print('Finished fitting. %i iterations | dE: %.3f | b_final: %.2f' % (i, delta_energy, b))\n return (x_gauss + x_start, f_gauss)","def gaussian2d_as1d(x, **kwargs):\n \n g = gaussian2d(x, **kwargs)\n \n return g.ravel()","def gaussian_likelihood(x, mu, log_std):\n std = tf.exp(log_std)\n pre_sum = tf.square((x - mu)/std) + 2*log_std + np.log(2*np.pi)\n return -0.5 * tf.reduce_sum(pre_sum, axis=1)","def _fit_function(self,x,a,b):\n return b + a*x","def addGaussian(self, xwidth=100., ywidth=100., xcen=None, ycen=None, value=1.0):\n if xcen == None:\n xcen = self.nx/2.0\n if ycen == None:\n ycen = self.ny/2.0\n self.fimage = None\n gaussian = numpy.exp(-(self.xx-xcen)**2/(2.0*xwidth**2) - (self.yy-ycen)**2/(2.0*ywidth**2))\n self.image += gaussian * value / gaussian.max()\n return","def gaussfit(x, y, peak=1., center=0., std=.1):\r\n def res(p, y, x):\r\n top1, m1, std1 = p\r\n y_fit = mm.gauss(x, top1, m1, std1)\r\n err = y - y_fit\r\n return err\r\n p = [peak, center, std] # Initial guesses for leastsq\r\n plsq = leastsq(res, p, args = (y, x), maxfev=2000)\r\n \r\n return plsq[0]","def fit(self, x):\n pass","def gaussian_fit(self):\r\n\r\n self.df5 = pd.DataFrame(columns=['Slit Number', 'Centre', 'Centre_err', 'Sigma', 'Sigma_err', 'FWHM', 'FWHM_err', 'Height', 'Height_err'])\r\n QDot_slits = self.QDot_detection()\r\n\r\n if len(QDot_slits) > 0: \r\n self.plot_data = pd.DataFrame(columns=[f\"{QDot_slits[0]}\"], index=self.energies)\r\n else:\r\n self.plot_data = pd.DataFrame(index=self.energies)\r\n\r\n for slit_number in QDot_slits:\r\n sel = self.df4[f'{slit_number}']\r\n self.plot_data[f'{slit_number}'] = sel\r\n \r\n # Makes a good first guess for the fit values of the gaussian\r\n max_intensity = max(sel)\r\n central_energy = sel[sel==max_intensity].index.values\r\n central_energy = central_energy[0]\r\n\r\n # Fits a gaussian model to the selected data and shows the output\r\n gauss = models.GaussianModel()\r\n fit = gauss.fit(sel, x=self.energies, weights=1 / np.sqrt(sel), center = central_energy, amplitude = max_intensity, sigma = 1, nan_policy= 'omit')\r\n \r\n self.plot_data[f'{slit_number} best fit'] = fit.best_fit\r\n\r\n # Appends the fit data for the variables to a new dataframe and shows the fit results with errors\r\n fit_variables = [slit_number]\r\n for key in fit.params:\r\n if key in ['center', 'sigma', 'fwhm', 'height']:\r\n fit_variables.append(fit.params[key].value)\r\n fit_variables.append(fit.params[key].stderr)\r\n \r\n self.df5 = self.df5.append({'Slit Number': fit_variables[0], 'Centre': fit_variables[1], 'Centre_err': fit_variables[2], 'Sigma': fit_variables[3], 'Sigma_err': fit_variables[4], 'FWHM': fit_variables[5], 'FWHM_err': fit_variables[6], 'Height': fit_variables[7], 'Height_err': fit_variables[8]}, ignore_index=True)\r\n \r\n return self.plot_data, self.df5"],"string":"[\n \"def line_fit(x,y):\\n\\t# clean\\n\\tx = np.squeeze(x)\\n\\ty = np.squeeze(y)\\n\\t# concatenate\\n\\txy = np.concatenate((x[:,np.newaxis],y[:,np.newaxis]),1)\\n\\t# sort by x values\\n\\txy = xy[xy[:,0].argsort()]\\n\\t#print(xy)\\n\\tf = lambda x,m,b : m*x+b\\n\\tpars,_ = opt.curve_fit(f,xy[:,0],xy[:,1])\\n\\tm = pars[0]\\n\\tb = pars[1]\\n\\tpts = np.zeros((2,2))\\n\\tpts[0,0] = xy[0,0]\\n\\tpts[1,0] = xy[-1,0]\\n\\tpts[:,1] = pts[:,0]*m+b\\n\\tsig = np.std((xy[:,1]-f(xy[:,0],m,b)))\\n\\treturn pts, sig\",\n \"def fitgaussian(self, data):\\n params = self.moments(data)\\n errorfunction = lambda p: ravel(self.Gauss(*p)(*indices(data.shape)) - data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: ravel(gaussian(*p)(*indices(data.shape)) -\\n data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def fit_gaussian(array):\\n\\n shape = array.shape\\n xmean, ymean = numpy.array(shape) / 2.\\n\\n xx, yy = numpy.mgrid[:shape[0], :shape[1]]\\n\\n g_init = astropy.modeling.models.Gaussian2D(amplitude=1., x_mean=xmean, y_mean=ymean,\\n x_stddev=1., y_stddev=1.)\\n\\n f2 = astropy.modeling.fitting.LevMarLSQFitter()\\n\\n gg = f2(g_init, xx, yy, array)\\n\\n return gg\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\\n data)\\n p, success = leastsq(errorfunction, params)\\n return p\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\\n data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\\n data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian(*p)(*np.indices(data.shape)) -\\n data)\\n #p, success = optimize.leastsq(errorfunction, params)\\n bnds = (0,30)\\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\\n #least square fitting(minimizes raw data and fit)\\n return p\",\n \"def gauss_fit(seld, data=''):\\n mean, std = norm.fit(data)\\n return mean, std\",\n \"def Gaussian(x, mu=0, sigma=26.4, A=1, y0=0):\\r\\n #width = sigma*(2*np.sqrt(2*np.log(2)))\\r\\n b = 1/(sigma*np.sqrt(2*np.pi))\\r\\n f = b*np.power(np.e, -(((x-mu)**2)/(2*sigma**2)))\\r\\n return A*f + y0\",\n \"def gaussian(mu, wid, x):\\n return np.exp(-((x - mu) / (0.6005612 * wid))**2)\",\n \"def fit_gauss(x, y):\\n nx = numpy.array(x)\\n ny = numpy.array(y)\\n ne = numpy.ones(len(ny))\\n#\\n#--- we need to give an initial guess\\n#\\n ymax = numpy.max(ny)\\n med = find_med(y)\\n p0 = [ymax, med, 10, 0]\\n\\n fitobj = kmpfit.Fitter(residuals=residualsG, data=(nx,ny,ne))\\n fitobj.fit(params0=p0)\\n [amp, cent, width, floor] = fitobj.params\\n\\n return [amp, cent, width]\",\n \"def gaussian(pars, x):\\n A, b, mu, sigma = pars\\n # return b + A/(np.sqrt(2*np.pi)*sigma**2) \\\\\\n return b + A \\\\\\n * np.exp(-.5*(x - mu)**2/sigma**2)\",\n \"def gaussian(x, *parameters):\\n position, sigma, amplitude, background = parameters\\n return amplitude * np.exp(-(x - position)**2 / (2.0 * sigma**2)) + background\",\n \"def fit_line(model,scaling):\\n\\treturn scaling*model\",\n \"def gaussian(amp, fwhm, mean, x):\\n return amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)\",\n \"def line_gaussian_activity(self, x_loc):\\n dist = np.abs(x_loc - self.pref_line_gaussian) # non_periodic boundary\\n dist /= self.sd_gaussianline # standard deviation\\n return np.exp(-dist ** 2 / 2)\",\n \"def line_gaussian_activity(self, x_loc):\\n dist = np.abs(x_loc - self.pref_line_gaussian) # non_periodic boundary\\n dist /= self.sd_gaussianline # standard deviation\\n return np.exp(-dist ** 2 / 2)\",\n \"def fit_gaussian(x, y, z):\\n\\n def sym_gaussian(p):\\n \\\"\\\"\\\"\\n Returns a Gaussian function:\\n a**2 * exp(-((x - x_0)**2 + (y - y_0)**2) / (2 * sigma**2))\\n p = [a, x_0, y_0, sigma]\\n \\\"\\\"\\\"\\n a, x_0, y_0, sigma = p\\n return a**2 \\\\\\n * np.exp(-((x - x_0)**2 + (y - y_0)**2) / (2.0 * sigma**2))\\n\\n def sym_gaussian_resids(p):\\n \\\"\\\"\\\"Residuals to be sent into leastsq\\\"\\\"\\\"\\n return z - sym_gaussian(p)\\n\\n def guess_fit_gaussian():\\n \\\"\\\"\\\"\\n return a, x_0, y_0, and sigma based on computing moments of data\\n \\\"\\\"\\\"\\n a = z.max()\\n\\n # Compute moments\\n total = z.sum()\\n x_0 = np.dot(x, z) / total\\n y_0 = np.dot(y, z) / total\\n\\n # Approximate sigmas\\n sigma_x = np.dot(x**2, z) / total\\n sigma_y = np.dot(y**2, z) / total\\n sigma = np.sqrt(sigma_x * sigma_y)\\n\\n # Return guess\\n return (a, x_0, y_0, sigma)\\n\\n # Get guess\\n p0 = guess_fit_gaussian()\\n\\n # Perform optimization using nonlinear least squares\\n popt, junk_output, info_dict, mesg, ier = \\\\\\n scipy.optimize.leastsq(sym_gaussian_resids, p0, full_output=True)\\n\\n # Check to make sure leastsq was successful. If not, return centroid\\n # estimate.\\n if ier in (1, 2, 3, 4):\\n return (popt[0]**2, popt[1], popt[2], popt[3])\\n else:\\n return p0\",\n \"def fitgaussian(data):\\n params = moments(data)\\n errorfunction = lambda p: np.ravel(gaussian_norot(*p)(*np.indices(data.shape)) -\\n data)\\n #scipy rihjt\\n # Levenberg-Marquadt algorithm -> leastsq\\n #bnds = None\\n height, x, y, width_x, width_y, he1, x1,y1, wi1, wi2 = params\\n #p, success = optimize.leastsq(errorfunction, params)\\n bnds = (0,30)\\n p = optimize.least_squares(errorfunction, params, bounds = bnds).x\\n \\n #least square fitting(minimizes raw data and fit)\\n\\n if(p[0] < 1 and p[5] < 1 and p[1] > 0 and p[1] < 30 and p[2] > 0 and p[2] < 30 and p[6] > 0 and p[6] < 30 and p[7] > 0 and p[7] < 30):\\n #print(\\\"pass case\\\")\\n return(p)\\n else:\\n print(\\\"failed case\\\")\\n print(\\\"height1\\\", p[0],\\\"height2\\\", p[5], \\\"X\\\", p[1],\\\"Y\\\", p[2],\\\"Y1\\\", p[6], \\\"Y2\\\", p[7])\\n print(\\\"bounding error\\\" + str(numero)) \\n\\n return p\",\n \"def fit_line(data, error_func):\\n\\n # Generate initial guess for line model\\n l = np.float32([0, np.mean(data[:, 1])]) # slope = 0, intercept = mean(y values)\\n\\n # Plot initial guess (optional)\\n x_ends = np.float32([-5, 5])\\n plt.plot(x_ends, l[0] * x_ends + l[1], 'm--', linewidth = 2.0, label = 'Initial guess')\\n\\n # Call optimizer to minimize error function\\n result = spo.minimize(error_func, l, args = (data, ), method = 'SLSQP', options = {'disp': True})\\n return result.x\",\n \"def gaussian(x, mu, sigma):\\n return (np.exp(-(x - mu)**2 / 2.0 / sigma**2) /\\n np.sqrt(2.0 * np.pi) / sigma)\",\n \"def fit_gaussian2d(image):\\n\\n # Estimate center of target\\n y_mean, x_mean = np.array(image.shape) // 2 # Center guess\\n\\n # Create model to fit\\n model = models.Gaussian2D(amplitude=image.max(),\\n x_mean=x_mean,\\n y_mean=y_mean,\\n fixed={}\\n )\\n\\n # Fit model to grid\\n fitted_model, fit = fit_model(image, model)\\n\\n return fitted_model\",\n \"def gaussian_k(x0, y0, sigma, height, width):\\n y = np.arange(0, width, 1, float)\\n x = np.arange(0, height, 1, float)[:, np.newaxis]\\n return np.exp(-((x - x0) ** 2 + (y - y0) ** 2) / (2 * sigma ** 2))\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit_gaussian(arr):\\n\\tif isinstance(arr, ac.kernels.Kernel):\\n\\t\\tarr = arr.array\\n\\telif isinstance(arr, np.ndarray):\\n\\t\\tpass\\n\\telse: \\n\\t\\traise Exception(\\\"[psfmatch] input needs to be a kernel or array\\\")\\n\\n\\tnx, ny = arr.shape\\n\\tx, y = get_xy_grid(nx, ny)\\n\\n\\tmodel_init = am.functional_models.Gaussian2D(amplitude=arr.max(), x_mean=0., y_mean=0., x_stddev=5., y_stddev=5., theta=0.)\\n\\tfitter = am.fitting.LevMarLSQFitter()\\n\\n\\t# with warnings.catch_warnings():\\n\\t\\t# warnings.simplefilter('ignore')\\n\\tmodel_best = fitter(model_init, x, y, arr)\\n\\n\\treturn model_best\",\n \"def gaussian(x, mean, sigma):\\n return np.exp(-np.square(x-mean)/(2*np.square(sigma))) / (np.sqrt(2*np.pi*sigma**2))\",\n \"def gaussian(self, amp_step, sigma_step):\\n l = len(self.overlaid_x_axis)\\n x = np.linspace(0, l, l) - l/2 # centre of data\\n\\n # This is new code to 'guess' the size of the Gaussian from the\\n # existing data rather than from hard-coded numbers.\\n # TODO: test this! Possibly link up to the get_windowed_data function\\n # as it uses a lot of the same functionality\\n trigger = self.pv_monitor.arrays[self.controls.Arrays.WAVEFORMS][0]\\n trace = self.pv_monitor.arrays[self.controls.Arrays.WAVEFORMS][1]\\n amplitude = max(trace) + amp_step\\n diff = np.diff(trigger)\\n stepvalue = 0.5\\n if min(diff) > -1 * stepvalue or max(diff) < stepvalue:\\n raise RangeError\\n else:\\n maxtrig = next(x for x in diff if x > stepvalue)\\n mintrig = next(x for x in diff if x < -1 * stepvalue)\\n edges = [np.where(diff == maxtrig)[0][0],\\n np.where(diff == mintrig)[0][0]]\\n half_trigger_length = (edges[1]-edges[0])\\n sigma = half_trigger_length/4 + sigma_step\\n\\n gauss = self.ax2.plot(amplitude * np.exp(-x**2 / (2 * sigma**2)), 'r')\\n self.overlaid_lines.append(gauss)\\n self.draw()\",\n \"def gaussian(height, center_x, center_y, width_x, width_y):\\n width_x = float(width_x)\\n width_y = float(width_y)\\n return lambda x,y: height*np.exp(\\n -(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)\",\n \"def gaussian(height, center_x, center_y, width_x, width_y):\\n width_x = float(width_x)\\n width_y = float(width_y)\\n return lambda x,y: height*np.exp(\\n -(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)\",\n \"def gaussian(height, center_x, center_y, width_x, width_y):\\n width_x = float(width_x)\\n width_y = float(width_y)\\n return lambda x,y: height*np.exp(\\n -(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)\",\n \"def gaussian(height, center_x, center_y, width_x, width_y):\\n width_x = float(width_x)\\n width_y = float(width_y)\\n return lambda x,y: height*exp(\\n -(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)\",\n \"def lin_gaus_2d(x, y, A, mu_x, sigma_x, mu_y, sigma_y, m, b):\\n return A * np.exp(-((x-mu_x)**2/(2.*sigma_x**2)+(y-mu_y)**2/(2.*sigma_y**2))) + y*m + b\",\n \"def gaussian(p, x):\\n #2008-09-11 15:11 IJC: Created for LINEPROFILE\\n # 2011-05-18 11:46 IJC: Moved to analysis.\\n # 2013-04-11 12:03 IJMC: Tried to speed things up slightly via copy=False\\n # 2013-05-06 21:42 IJMC: Tried to speed things up a little more.\\n\\n if not isinstance(x, np.ndarray):\\n x = array(x, dtype=float, copy=False)\\n\\n if len(p)==3:\\n p = array(p, copy=True)\\n p = concatenate((p, [0]))\\n #elif len(p)==4:\\n # p = array(p, copy=False)\\n\\n return p[3] + p[0]/(p[1]*sqrt(2*pi)) * exp(-(x-p[2])**2 / (2*p[1]**2))\",\n \"def fit(self, x):\\n self.alpha = np.mean(x)\\n self.is_fit = True\",\n \"def gaussian(x, amp, cen, wid):\\n return amp * exp (-(x-cen)**2/(2*wid**2))\",\n \"def _gaussian_distribution(self, x: ndarray, mu: float, sigma: float) -> ndarray:\\n return 1 / (np.sqrt(2 * np.pi) * sigma) * np.exp(\\n -np.power(\\n (x - mu) / sigma, 2) / 2)\",\n \"def fit_gaussian(self, mask=None):\\n data = self.data\\n mask = numpy.logical_or(mask, numpy.ma.getmaskarray(data))\\n fdata = data[~mask].data\\n xdata = numpy.asarray([cm[~mask]\\n for cm in self.bset.cmesh]).transpose()\\n scale, mean, cov = fit_ndgaussian(xdata, fdata)\\n return scale, mean, cov\",\n \"def gaussian(height, center_x, center_y, width_x, width_y):\\n width_x = float(width_x)\\n width_y = float(width_y)\\n return lambda x,y: height*np.exp(-(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)\",\n \"def gaussian(x, amp, wid, cen):\\n return amp*np.exp(-(x-cen)**2/(2*wid**2))\",\n \"def least_sqr_fit(self,x, y):\\n A = np.array([ x, np.ones(len(x))])\\n # linearly generated sequence\\n a,f,g,h = np.linalg.lstsq(A.T,y) # obtaining the parameters\\n print 'de gevonden rechte = %.10f x + %.10f' %(a[0], a[1])\\n lined = map(lambda g: a[0]*g +a[1],x) # regression line\\n return lined , a\",\n \"def gaussian(x, x0=0.0, fwhm=1.0, ampl=1.0):\\n return ampl * np.exp(-4 * np.log(2) * ((x - x0) / fwhm) ** 2)\",\n \"def gaussian(x, y, params):\\n\\n n = len(x)\\n mix = np.zeros((n,))\\n\\n ex = (((x - params[0])**2) / (2.*params[2]**2))\\n ey = (((y - params[1])**2) / (2.*params[2]**2))\\n mix = ex + ey\\n\\n pdf = np.sqrt((1. / (2*np.pi*params[2]**2))) * np.exp(-1*mix)\\n\\n return pdf\",\n \"def random_line(a, b, sigma, size=10,start=-1,end=1):\\n xdata = np.linspace(start,end,size)\\n errors = scipy.stats.norm.rvs(loc=0,scale=sigma, size=size)\\n ydata = a*xdata + b + errors\\n return xdata, ydata\",\n \"def gaussian(x, peak_x=.0, sigma=1.0, name=''):\\n x = x.astype(np.float)\\n variables = {'function': gaussian, 'peak_x': peak_x, 'sigma': sigma}\\n y = np.exp((-1 * (x - peak_x)**2) / (2 * sigma**2))\\n return packer(x, y, variables, name=name)\",\n \"def doubleGaussian(p, x):\\n # 2013-05-06 20:29 IJMC: Created\\n\\n x = array(x, dtype=float, copy=False)\\n return gaussian(p[0:3], x) + gaussian(p[3:], x)\",\n \"def gaussian(\\n self,\\n width=None,\\n mfreq=None,\\n chromaticity=None,\\n dtype=None,\\n power=True,\\n ):\\n widths, dtype = self._process_args(width, mfreq, chromaticity, dtype)\\n response = np.exp(-0.5 * (self.xs / np.sin(widths)) ** 2)\\n if power:\\n response = response ** 2\\n return response.astype(dtype)\",\n \"def gaussian2d(x, y, A, sigma, x0):\\n Z = A * np.exp(-( (x-x0[0])**2/(2*sigma[0]**2) + (y-x0[1])**2/(2*sigma[1]**2)))\\n return Z\",\n \"def expgaussian(mu, wid, timeconstant, x): \\n # Gaussian signal broadened by an exponetial signal\\n g = gaussian(mu, wid, x)\\n \\n hly = np.round( len(g) / 2.0 )\\n ey = np.r_[np.zeros(hly),g,np.zeros(hly)]\\n fy = np.fft.fft(ey)\\n a = np.exp(-(np.arange(len(fy))) / timeconstant )\\n fa = np.fft.fft(a)\\n fy1 = fy * fa\\n ybz = np.real(np.fft.ifft(fy1)) / np.sum(a)\\n yb = ybz[hly:len(ybz)-hly]\\n \\n return yb\",\n \"def fit_amplitudes(self, v=False):\\n\\n x = self.star.ds.mode_id['f0'].as_matrix()\\n height = self.star.ds.mode_id['A0'].as_matrix()\\n sd_height = self.star.ds.mode_id['A0_err'].as_matrix()\\n if v: print 'x:', x\\n if v: print 'height:', height\\n if v: print 'sd_height:', sd_height\\n\\n mean = sum(height*x) / sum(height) # weighted mean x value\\n sigma = np.sqrt(sum(height * (x - mean)**2) / sum(height)) # weighted Gaussian sd\\n\\n popt, pcov = curve_fit(self.Gauss, x, height,\\\\\\n p0=[max(height), mean, sigma], sigma=sd_height, absolute_sigma=True)\\n self.numax = popt[1]\\n # sd_numax = np.sqrt(np.diag(pcov))[1] # the uncertaintiy on numax\\n if v: print 'numax:', self.numax\",\n \"def gaussian_kernel(training_ex, landmark, sigma=0.1):\\n return np.exp(-(np.linalg.norm(training_ex - landmark) ** 2 / (2 * (sigma ** 2))))\",\n \"def gaussian(amp, fwhm, mean):\\n return lambda x: amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)\",\n \"def gaussian2d(x, amplitude=1.0, center_x=0.0, sigma_x=1.0, center_y=0.0, sigma_y=1.0, rota=0.0):\\n \\n if len(x) == 1:\\n y = x\\n else:\\n (x, y) = x\\n \\n if not sigma_y:\\n sigma_y = sigma_x\\n \\n if not center_y:\\n center_y = center_x\\n \\n if rota:\\n center_x = center_x*np.cos(np.deg2rad(rota)) - center_y*np.sin(np.deg2rad(rota))\\n center_y = center_x*np.sin(np.deg2rad(rota)) + center_y*np.cos(np.deg2rad(rota)) \\n \\n x = x*np.cos(np.deg2rad(rota)) - y*np.sin(np.deg2rad(rota))\\n y = x*np.sin(np.deg2rad(rota)) + y*np.cos(np.deg2rad(rota))\\n \\n norm = 2.*np.pi*sigma_x*sigma_y\\n #exp_x = np.power((x - center_x)/(sigma_x), 2.)\\n #exp_y = np.power((y - center_y)/(sigma_y), 2.)\\n g = amplitude*np.exp(-(((center_x - x)/sigma_x)**2 + \\\\\\n ((center_y - y)/sigma_y)**2)/2.)\\n \\n return g #(amplitude/norm)*np.exp(-(exp_x + exp_y)/2.)\",\n \"def lin_gaus(x,m,b,A,mu,sigma):\\n return m*x+b + gaus(x,A,mu,sigma)\",\n \"def gaussian(centre, k, intensity, xpos):\\r\\n\\treturn intensity * np.exp(- np.power(k * (xpos - centre), 2))\",\n \"def Gaussian(x, mu, sigma, a):\\n amplitude = a / ( sigma * np.sqrt(2 * np.pi) )\\n u = (x - mu) / sigma\\n return amplitude * np.exp( -0.5 * (u**2) )\",\n \"def gaussianise_series(self, train_x):\\n\\n n_batches = train_x.shape[0]\\n\\n for batch in range(n_batches):\\n train_x[batch, :, :] = gaussianise(train_x[batch, :, :], target_sigma=1.0)\\n\\n return train_x\",\n \"def gauss_rbins_fit(self, plotfig=False, plotrmax=50, normtype=1):\\n A0 = self.rbins.max()\\n sigmaArr = np.arange(200)*.2 + .2 # double check\\n # sigmaArr=np.array([30.])\\n sigma_min, rms, Amin = _gauss_rbins_fit(self.rArr, self.rbins, sigmaArr=sigmaArr, normtype=normtype)\\n self.rbins_pre = Amin/np.sqrt(2*np.pi)/sigma_min*np.exp(-(self.rArr)**2/2./(sigma_min**2))\\n self.Amin = Amin\\n self.sigma_rbins = sigma_min\\n self.rms = rms\\n if plotfig:\\n ax=plt.subplot()\\n plt.plot(self.rArr, self.rbins, 'o', ms=10, label='observed')\\n # plt.plot(self.rArr, self.rbins_pre_gauss, 'k--', lw=3, label='Best fit Gaussian distribution')\\n plt.plot(self.rArr, self.rbins_pre, 'k--', lw=3, label='Best fit Gaussian distribution')\\n plt.ylabel('PDF ', fontsize=30)\\n plt.xlabel('Radius (nm)', fontsize=30)\\n ax.tick_params(axis='x', labelsize=20)\\n ax.tick_params(axis='y', labelsize=20)\\n plt.legend(loc=0, fontsize=20, numpoints=1)\\n plt.yscale('log', nonposy='clip')\\n plt.xlim(0, plotrmax)\\n plt.ylim(1e-8, 0.1)\\n plt.show()\",\n \"def gaussian_prior(self):\\n self.prior = sps.multivariate_normal(self.m0,self.S0)\",\n \"def gauss_fit_2(self, s, bin1):\\n\\t\\tmean, std = sp.norm.fit(s)\\t\\t# Distribution fitting\\n\\t\\tcount, bins, ignored = plt.hist(s, bin1, normed=True)\\t# Extracting the parameters from the histogram\\n\\t\\tpdf_fitted = sp.norm.pdf(bins, loc=mean, scale=std)\\n\\t\\tprint \\\" \\\"\\n\\t\\tprint \\\"Gaussian Distribution Extraction\\\"\\n\\t\\tprint \\\"Extracted mean is :\\\", mean\\n\\t\\tprint \\\"Extracted standard deviation is :\\\",std\\n\\t\\tprint \\\" \\\"\\n\\t\\tplt.plot(bins, pdf_fitted, linewidth=2, color='k', label='Gaussian')\\n\\t\\tplt.title(\\\"Gaussian Distribution Estimation\\\")\\n\\t\\tplt.show()\\n\\t\\treturn pdf_fitted\",\n \"def _multivariate_gaussian(self, x, mu_k, sigma_k):\\n return multivariate_normal.pdf(x, mu_k, sigma_k)\",\n \"def gaussian(T, Y, X, t, y, x, sigma, sigma_t=1):\\n const_value = np.sqrt(2 * np.pi * sigma) ** 3\\n norm = np.exp(\\n -(\\n ((X - x) ** 2) / (2 * sigma ** 2)\\n + ((Y - y) ** 2) / (2 * sigma ** 2)\\n + ((T - t) ** 2) / (2 * sigma_t ** 2)\\n )\\n )\\n return norm / const_value\",\n \"def fit_line(x_data, y_data):\\n\\tslope, y_intercept, r_value, p_value, std_err = stats.linregress(x_data, y_data)\\n\\tr_squared = r_value * r_value\\n\\treturn slope, y_intercept, r_squared, p_value, std_err\",\n \"def fit(self, X):\",\n \"def doubleGaussian(x, m1, s1, a1, m2, s2, a2):\\n # primary peak\\n g1 = np.exp(-0.5*((x-m1)/s1)**2)\\n # secondary peak\\n g2 = np.exp(-0.5*((x-m2)/s2)**2)\\n # total model\\n mod1 = 1 - a1 * g1\\n mod2 = 1 - a2 * g2\\n modt = mod1 + mod2 - 1\\n return modt\",\n \"def Gaussian(x,t,sigma):\\n return np.exp(-(x-t)**2/(2*sigma**2))\",\n \"def fitbivarGaussian(data):\\n params = bivarParams(data)\\n errorfunction = lambda p: ravel(bivarGaussian(*p)(*indices(data.shape)) -\\n data)\\n p, success = optimize.leastsq(errorfunction, params)\\n return p\",\n \"def fit_line_Vo(x, y, n):\\n x1=x[0:n]\\n y1=y[0:n]\\n X = sm.add_constant(x1)\\n model = sm.OLS(y1, X, missing='drop') # ignores entires where x or y is NaN\\n fit = model.fit()\\n m=fit.params[1] \\n b=fit.params[0] \\n# stderr=fit.bse # could also return stderr in each via fit.bse\\n \\n N = 100 # could be just 2 if you are only drawing a straight line...\\n points = np.linspace(x.min(), x.max(), N)\\n \\n \\n fig=plt.figure(1) #PLOTING TOGETHER\\n \\n ax = fig.add_subplot(111)\\n ax.plot(x, y)\\n ax.plot(points, m*points + b)\\n \\n plt.legend(['data','fitt Vo'],fontsize=16)\\n \\n ax.set_yscale('linear',fontsize=16)\\n ax.tick_params(axis='x', labelsize=14)\\n ax.tick_params(axis='y', labelsize=14)\\n plt.ylabel('Abs',fontsize=16)\\n plt.xlabel('Time(sec)',fontsize=16)\\n ax.grid()\\n plt.grid()\\n plt.show()\\n \\n print(\\\"The Vo fitted model is: {0:2f}*x+{1:2f} \\\".format(m, b))\\n return m,b\",\n \"def _gaussian(self, c, sigma):\\n d = 2*sigma*sigma\\n ax = exp(-power(self._xx-self._xx.T[c], 2)/d)\\n ay = exp(-power(self._yy-self._yy.T[c], 2)/d)\\n return (ax * ay).T # the external product gives a matrix\",\n \"def onedgauss(x,H,A,dx,w):\\n #H,A,dx,w = params\\n return H+A*np.exp(-(x-dx)**2/(2*w**2))\",\n \"def gauss_smooth(data, sigma):\\n\\t\\t\\t# make the kernel 5 sigmas wide in each direction\\n\\t\\t\\tkernel = stats.norm.pdf(np.arange(-5*sigma, (5*sigma)+1), scale=sigma)\\n\\t\\t\\t\\n\\t\\t\\treturn sp.ndimage.convolve1d(data, kernel, axis=2)\",\n \"def gaussian(t, params):\\n DeprecationWarning(\\\"Using standard width. Better use gaussian_sigma.\\\")\\n params['sigma'] = Qty(\\n value=params['t_final'].get_value()/6,\\n min_val=params['t_final'].get_value()/8,\\n max_val=params['t_final'].get_value()/4,\\n unit=params['t_final'].unit\\n )\\n return gaussian_sigma(t, params)\",\n \"def regress(pts):\\n # split points in list of x- and y-values\\n xs, ys = split(pts)\\n # adjust x- and y-values (subtract the mean)\\n _, xsadj = adjust(xs)\\n _, ysadj = adjust(ys)\\n # calculate variances (spread) in x- and y-direction\\n # If one of the two variances is (nearly) 0,\\n # we short circuit our logic\\n # -> points then have to be on a straight line\\n # (either horizontal or vertical)\\n sx = variance(xsadj, m=0)\\n if near_zero(sx): # == 0\\n return ysadj, xsadj\\n sy = variance(ysadj, m=0)\\n if near_zero(sy): # == 0\\n return xsadj, ysadj\\n # calculate covariance\\n sxy = cov(xsadj, ysadj, 0, 0)\\n # get list of eigenvalues and vectors\\n # these are sorted based on size of eigenvalues\\n eig_sorted = sorted(zip(*eig_2x2(sx, sxy, sxy, sy)), reverse=True)\\n vecs = [vec for _, vec in eig_sorted]\\n newxs, newys = [], []\\n for pt in zip(xsadj, ysadj):\\n # no need to transpose the vectors as they are\\n xnew = vecs[0][0] * pt[0] + vecs[0][1] * pt[1]\\n ynew = vecs[1][0] * pt[0] + vecs[1][1] * pt[1]\\n newxs.append(xnew)\\n # residuals?!\\n # These should be squared distances to regression line that was fitted\\n newys.append(ynew)\\n return newxs, newys\",\n \"def gaussian(x, sigma):\\n try: r = np.exp(-0.5*(x/sigma)**2) \\n except: r = np.zeros(len(x))\\n return r\",\n \"def gaussian(mu, sigma, start, end):\\r\\n \\r\\n val = np.linspace(start, end, 100)\\r\\n a = 1/(sigma*np.pi)\\r\\n b = - 0.5 * np.power((mu - val)/sigma, 2)\\r\\n return a*np.exp(b)\",\n \"def bigaussian(mu, wid, x, m = 0.5):\\n lx = x.shape[0]\\n ix = np.where(x == mu)[0][0]\\n \\n y = np.ones(lx)\\n y[0:ix] = gaussian(mu, wid * m, x[0:ix])\\n y[ix+1:lx] = gaussian(mu, wid * (1 - m), x[ix+1:lx]) \\n \\n return y\",\n \"def fit_model(self):\\r\\n\\t\\tself.mu = np.mean(self.x, axis = 0)\\r\\n\\t\\tself.sig = np.std(self.x, axis = 0)\",\n \"def src_gauss(l, m, sigma_lm, A=1., i=0., pa=0., l0=0., m0=0.):\\n l = np.atleast_1d(l)\\n m = np.atleast_1d(m)\\n sigma_x = sigma_lm\\n sigma_y = sigma_lm * np.cos(i)\\n a = 0.5 * ((np.cos(pa) / sigma_x)**2. + (np.sin(pa) / sigma_y)**2.)\\n b = 0.5 * np.sin(2. * pa) * (sigma_x**-2. - sigma_y**-2.)\\n c = 0.5 * ((np.sin(pa) / sigma_x)**2. + (np.cos(pa) / sigma_y)**2.)\\n p = a * (l - l0)**2. + b * (l - l0) * (m - m0) + c * (m - m0)**2.\\n I = A * np.exp(-p) / (2. * pi * sigma_x * sigma_y)\\n return I\",\n \"def g_multivariate_normal(x,M):\\n return .5*np.dot(x,M+M.T)\",\n \"def y_model(self, x):\\n x = np.asanyarray(x, dtype=float)\\n parvals = self.parvals(x)\\n return Gaussian1D(**parvals)\",\n \"def gaussianDist(self, x, mu, var):\\n val = 1/(math.sqrt(2 * math.pi * var)) * math.exp(-1 * (x - mu)**2 / (2*var))\\n return val\",\n \"def fit(self, x, y): \\n # *** START CODE HERE ***\\n y = y.reshape(y.shape[0], 1)\\n y_0 = (1 - y).reshape(y.shape)\\n m = y.shape[0]\\n m_0 = np.asscalar(np.sum(y_0))\\n m_1 = np.asscalar(np.sum(y))\\n # Find phi, mu_0, mu_1, and sigma\\n phi = np.sum(y) / m\\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\\n # Write theta in terms of the parameters\\n sigma_inv = np.linalg.inv(sigma)\\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\\n # Compute cost\\n x_0 = np.zeros((x.shape[0], 1)) + 1\\n x_train = np.concatenate((x_0.T, x.T))\\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\\n if self.verbose:\\n print(\\\"Cost: \\\" + str(cost))\\n # *** END CODE HERE ***\",\n \"def linear_slope_fit(wf, mean_y, sigma_y, slope, intercept):\\n\\n sum_x = sum_x2 = sum_xy = sum_y = mean_y[0] = sigma_y[0] = 0\\n isum = len(wf)\\n\\n for i,value in enumerate(wf):\\n sum_x += i \\n sum_x2 += i**2\\n sum_xy += (value * i)\\n sum_y += value\\n mean_y += (value-mean_y) / (i+1)\\n sigma_y += (value-mean_y)**2\\n\\n\\n sigma_y /= (isum + 1)\\n np.sqrt(sigma_y, sigma_y)\\n\\n\\n slope[0] = (isum * sum_xy - sum_x * sum_y) / (isum * sum_x2 - sum_x * sum_x)\\n intercept[0] = (sum_y - sum_x * slope[0])/isum\",\n \"def fit_line(data, component=0): # fit 3d line to 3d data\\n\\n m = data.mean(0)\\n max_val = np.round(2*abs(data - m).max()).astype(int)\\n uu, dd, vv = np.linalg.svd(data - m)\\n return vv[component]\",\n \"def gauss(x, *p):\\n A, mu, sigma = p\\n\\n return A*np.exp(-(x-mu)**2/(2.*sigma**2))\",\n \"def scipy_smooth(img, sigma=5):\\n return ndimage.gaussian_filter(img, sigma=sigma)\",\n \"def GaussianFit(data, title=\\\"\\\"):\\n y, binEdges = np.histogram(data, 50)\\n x = (binEdges[:-1] + binEdges[1:]) / 2\\n x_width = (x[-1] - x[0]) / len(x)\\n y_err = np.sqrt(y) # items in a bin should follow the Poisson distribution\\n\\n # calculate optimal fit parameters and covariance matrix using least squares method\\n popt, cov = curve_fit(Gaussian, x, y, [np.mean(data), np.std(data), 10])\\n\\n # plot data\\n plt.bar(x, y, x_width, yerr=y_err, color=\\\"blue\\\", edgecolor=\\\"black\\\", capsize=3, ecolor=\\\"black\\\")\\n \\n text1 = \\\"Mean (GeV): \\\" + str( round_to(popt[0], cov[0, 0]) ) + \\\" $\\\\pm$ \\\" + str( round_to(cov[0, 0], cov[0, 0]) )\\n\\n text2 = \\\"Standard deviation (GeV): \\\" + str( round_to(popt[1], cov[1, 1]) ) + \\\" $\\\\pm$ \\\" + str( round_to(cov[1, 1], cov[1, 1]) )\\n\\n text = '\\\\n'.join((text1, text2))\\n\\n # plot gaussian fit\\n x_int = np.linspace(x[0], x[-1], 10*len(x)) # interpolate data\\n y_int = Gaussian(x_int, *popt)\\n plt.plot(x_int, y_int, label=\\\"Gaussian fit\\\", color=\\\"red\\\")\\n\\n\\n plt.annotate(text, xy=(0.025, 0.8), xycoords='axes fraction')\\n\\n # plot options\\n plt.legend()\\n plt.xlabel(\\\"Energy (GeV)\\\")\\n plt.ylabel(\\\"Number of events (bin width=\\\" + str(round(x_width, 2)) + \\\" GeV)\\\")\\n plt.title(title)\\n #plt.title(\\\"Beam momentum 100GeV, magnetic field \\\" + str(geometry.B) + \\\"T.\\\")\\n \\n # return some results, mean, standard deviation, amplitude\\n return [popt[0], cov[0, 0]], [popt[1], cov[1, 1]], [popt[2], cov[2, 2]]\",\n \"def gaussfit(x, y, nterms=\\\"none\\\"):\\n\\n z = lambda x, A1, A2: (x - A1) / A2\\n\\n if nterms in [\\\"none\\\", 3]:\\n gauss = lambda x, A0, A1, A2: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\\n p0 = [max(y), 1, 1]\\n elif nterms in [\\\"constant\\\", 4]:\\n gauss = lambda x, A0, A1, A2, A3: A0 * np.exp(-z(x, A1, A2) ** 2 / 2) + A3\\n p0 = [max(y), 1, 1, 0]\\n elif nterms in [\\\"linear\\\", 5]:\\n gauss = (\\n lambda x, A0, A1, A2, A3, A4: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\\n + A3\\n + A4 * x\\n )\\n p0 = [max(y), 1, 1, 0, 0]\\n\\n elif nterms in [\\\"quadratic\\\", 6]:\\n gauss = (\\n lambda x, A0, A1, A2, A3, A4, A5: A0 * np.exp(-z(x, A1, A2) ** 2 / 2)\\n + A3\\n + A4 * x\\n + A5 * x ** 2\\n )\\n p0 = [max(y), 1, 1, 0, 0, 0]\\n\\n popt, _ = curve_fit(gauss, x, y, p0=p0)\\n return gauss(x, *popt), popt\",\n \"def gaussian(x, amplitude=1.0, center=0.0, sigma=1.0):\\n \\n return (amplitude/(np.sqrt(2.*np.pi)*sigma)) * exp(-np.power((1.0*x-center)/(sigma), 2.)/2.)\",\n \"def makeGaussian(size, fwhm, center=None):\\n\\n x = sp.arange(0, size, 1, float)\\n y = x[:,sp.newaxis]\\n\\n if center is None:\\n x0 = y0 = size // 2\\n else:\\n x0 = center[0]\\n y0 = center[1]\\n\\n return sp.exp(-4*sp.log(2) * ((x-x0)**2 + (y-y0)**2) / fwhm**2)\",\n \"def fit(self, x):\\n x = np.asarray(x)\\n _ = self.fit_transform(x)\",\n \"def fit_gaussian(position, energy, dx=0.005, a=2, b=1.5, db=0.01, tolerance=0.05, max_iterations=1000):\\n min_energy, max_energy = min(energy), max(energy)\\n x_start, x_range = min(position), max(position) - min(position)\\n x_gauss = np.arange(0, x_range, dx)\\n f_gauss = np.exp(-a * (x_range / 2 - x_gauss) ** 2 + b)\\n delta_energy = abs(max(f_gauss) - max_energy)\\n b_direction = np.sign(max_energy - max(f_gauss))\\n print('E_WHAM: %.3f | E_GAUSS: %.3f | b_direction: %i' % (max_energy, max(f_gauss), b_direction))\\n for i in range(max_iterations):\\n b = b + b_direction * db\\n f_gauss_trial = np.exp(-a * (x_range / 2 - x_gauss) ** 2 + b)\\n delta_energy_trial = abs(max(f_gauss_trial) - max_energy)\\n if delta_energy_trial < tolerance:\\n f_gauss = f_gauss_trial\\n print('Found b value: %.2f with dE: %.3f within tolerance in %i iterations' % (b, delta_energy, i))\\n break\\n elif delta_energy_trial < delta_energy:\\n f_gauss = f_gauss_trial\\n delta_energy = delta_energy_trial\\n print('Finished fitting. %i iterations | dE: %.3f | b_final: %.2f' % (i, delta_energy, b))\\n return (x_gauss + x_start, f_gauss)\",\n \"def gaussian2d_as1d(x, **kwargs):\\n \\n g = gaussian2d(x, **kwargs)\\n \\n return g.ravel()\",\n \"def gaussian_likelihood(x, mu, log_std):\\n std = tf.exp(log_std)\\n pre_sum = tf.square((x - mu)/std) + 2*log_std + np.log(2*np.pi)\\n return -0.5 * tf.reduce_sum(pre_sum, axis=1)\",\n \"def _fit_function(self,x,a,b):\\n return b + a*x\",\n \"def addGaussian(self, xwidth=100., ywidth=100., xcen=None, ycen=None, value=1.0):\\n if xcen == None:\\n xcen = self.nx/2.0\\n if ycen == None:\\n ycen = self.ny/2.0\\n self.fimage = None\\n gaussian = numpy.exp(-(self.xx-xcen)**2/(2.0*xwidth**2) - (self.yy-ycen)**2/(2.0*ywidth**2))\\n self.image += gaussian * value / gaussian.max()\\n return\",\n \"def gaussfit(x, y, peak=1., center=0., std=.1):\\r\\n def res(p, y, x):\\r\\n top1, m1, std1 = p\\r\\n y_fit = mm.gauss(x, top1, m1, std1)\\r\\n err = y - y_fit\\r\\n return err\\r\\n p = [peak, center, std] # Initial guesses for leastsq\\r\\n plsq = leastsq(res, p, args = (y, x), maxfev=2000)\\r\\n \\r\\n return plsq[0]\",\n \"def fit(self, x):\\n pass\",\n \"def gaussian_fit(self):\\r\\n\\r\\n self.df5 = pd.DataFrame(columns=['Slit Number', 'Centre', 'Centre_err', 'Sigma', 'Sigma_err', 'FWHM', 'FWHM_err', 'Height', 'Height_err'])\\r\\n QDot_slits = self.QDot_detection()\\r\\n\\r\\n if len(QDot_slits) > 0: \\r\\n self.plot_data = pd.DataFrame(columns=[f\\\"{QDot_slits[0]}\\\"], index=self.energies)\\r\\n else:\\r\\n self.plot_data = pd.DataFrame(index=self.energies)\\r\\n\\r\\n for slit_number in QDot_slits:\\r\\n sel = self.df4[f'{slit_number}']\\r\\n self.plot_data[f'{slit_number}'] = sel\\r\\n \\r\\n # Makes a good first guess for the fit values of the gaussian\\r\\n max_intensity = max(sel)\\r\\n central_energy = sel[sel==max_intensity].index.values\\r\\n central_energy = central_energy[0]\\r\\n\\r\\n # Fits a gaussian model to the selected data and shows the output\\r\\n gauss = models.GaussianModel()\\r\\n fit = gauss.fit(sel, x=self.energies, weights=1 / np.sqrt(sel), center = central_energy, amplitude = max_intensity, sigma = 1, nan_policy= 'omit')\\r\\n \\r\\n self.plot_data[f'{slit_number} best fit'] = fit.best_fit\\r\\n\\r\\n # Appends the fit data for the variables to a new dataframe and shows the fit results with errors\\r\\n fit_variables = [slit_number]\\r\\n for key in fit.params:\\r\\n if key in ['center', 'sigma', 'fwhm', 'height']:\\r\\n fit_variables.append(fit.params[key].value)\\r\\n fit_variables.append(fit.params[key].stderr)\\r\\n \\r\\n self.df5 = self.df5.append({'Slit Number': fit_variables[0], 'Centre': fit_variables[1], 'Centre_err': fit_variables[2], 'Sigma': fit_variables[3], 'Sigma_err': fit_variables[4], 'FWHM': fit_variables[5], 'FWHM_err': fit_variables[6], 'Height': fit_variables[7], 'Height_err': fit_variables[8]}, ignore_index=True)\\r\\n \\r\\n return self.plot_data, self.df5\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7053034","0.6899664","0.66803604","0.6613913","0.66093487","0.655105","0.655105","0.6387049","0.63094246","0.62380975","0.622621","0.62161845","0.6191844","0.61702806","0.6145452","0.61285686","0.61094004","0.61094004","0.6043475","0.6034672","0.60221267","0.5960545","0.5956919","0.5944498","0.59433585","0.59433585","0.59433585","0.5942674","0.5938206","0.59284693","0.5904792","0.5904792","0.5904792","0.59044325","0.59003544","0.5877703","0.5862349","0.58532834","0.58336884","0.5817491","0.58157736","0.5809952","0.5795173","0.5789017","0.5741363","0.57318956","0.5712196","0.5711146","0.56879187","0.5684103","0.5682518","0.5678815","0.5672657","0.5671226","0.5663417","0.5662821","0.56611574","0.56455743","0.56271166","0.5622448","0.5613576","0.5603632","0.5602792","0.559884","0.5579348","0.5577101","0.5574968","0.5563285","0.5556081","0.5549053","0.5531355","0.55251867","0.55078256","0.5506033","0.5500303","0.54979146","0.54976726","0.5497502","0.5491213","0.5476237","0.5470085","0.54697526","0.5465142","0.54639435","0.54619086","0.54600775","0.5459155","0.544979","0.5449161","0.54466176","0.54445314","0.5444019","0.543906","0.5437564","0.54187536","0.54186684","0.5416192","0.5408648","0.5404909","0.5401572","0.53988045"],"string":"[\n \"0.7053034\",\n \"0.6899664\",\n \"0.66803604\",\n \"0.6613913\",\n \"0.66093487\",\n \"0.655105\",\n \"0.655105\",\n \"0.6387049\",\n \"0.63094246\",\n \"0.62380975\",\n \"0.622621\",\n \"0.62161845\",\n \"0.6191844\",\n \"0.61702806\",\n \"0.6145452\",\n \"0.61285686\",\n \"0.61094004\",\n \"0.61094004\",\n \"0.6043475\",\n \"0.6034672\",\n \"0.60221267\",\n \"0.5960545\",\n \"0.5956919\",\n \"0.5944498\",\n \"0.59433585\",\n \"0.59433585\",\n \"0.59433585\",\n \"0.5942674\",\n \"0.5938206\",\n \"0.59284693\",\n \"0.5904792\",\n \"0.5904792\",\n \"0.5904792\",\n \"0.59044325\",\n \"0.59003544\",\n \"0.5877703\",\n \"0.5862349\",\n \"0.58532834\",\n \"0.58336884\",\n \"0.5817491\",\n \"0.58157736\",\n \"0.5809952\",\n \"0.5795173\",\n \"0.5789017\",\n \"0.5741363\",\n \"0.57318956\",\n \"0.5712196\",\n \"0.5711146\",\n \"0.56879187\",\n \"0.5684103\",\n \"0.5682518\",\n \"0.5678815\",\n \"0.5672657\",\n \"0.5671226\",\n \"0.5663417\",\n \"0.5662821\",\n \"0.56611574\",\n \"0.56455743\",\n \"0.56271166\",\n \"0.5622448\",\n \"0.5613576\",\n \"0.5603632\",\n \"0.5602792\",\n \"0.559884\",\n \"0.5579348\",\n \"0.5577101\",\n \"0.5574968\",\n \"0.5563285\",\n \"0.5556081\",\n \"0.5549053\",\n \"0.5531355\",\n \"0.55251867\",\n \"0.55078256\",\n \"0.5506033\",\n \"0.5500303\",\n \"0.54979146\",\n \"0.54976726\",\n \"0.5497502\",\n \"0.5491213\",\n \"0.5476237\",\n \"0.5470085\",\n \"0.54697526\",\n \"0.5465142\",\n \"0.54639435\",\n \"0.54619086\",\n \"0.54600775\",\n \"0.5459155\",\n \"0.544979\",\n \"0.5449161\",\n \"0.54466176\",\n \"0.54445314\",\n \"0.5444019\",\n \"0.543906\",\n \"0.5437564\",\n \"0.54187536\",\n \"0.54186684\",\n \"0.5416192\",\n \"0.5408648\",\n \"0.5404909\",\n \"0.5401572\",\n \"0.53988045\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6387,"cells":{"query":{"kind":"string","value":"! Create ssh client. Create ssh client to run commands in host machine from inside container."},"document":{"kind":"string","value":"def create_client():\n hostname = \"localhost\"\n username = \"she393\"\n password = os.getenv(\"PASSWORD\")\n\n client = paramiko.SSHClient()\n client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n client.connect(hostname=hostname, username=username, password=password)\n return client"},"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 open_sshclient(host, user, port, secret):\n ssh_client = paramiko.SSHClient()\n ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n ssh_client.load_system_host_keys()\n if secret and port:\n ssh_client.connect(hostname=host, username=user, password=secret, port=port)\n elif secret and port==0:\n ssh_client.connect(hostname=host, username=user, password=secret)\n elif not secret and port:\n ssh_client.connect(hostname=host, username=user, port=port)\n else:\n ssh_client.connect(hostname=host, username=user)\n return ssh_client","def create_client(host, user, password):\n client = paramiko.client.SSHClient()\n client.set_missing_host_key_policy(paramiko.AutoAddPolicy)\n client.connect(hostname=host, username=user, password=password, timeout=60)\n return client","def create_ssh_client(self, hostname, username, password):\n if self.ssh_client is None:\n self.ssh_client = paramiko.SSHClient()\n self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n self.ssh_client.connect(hostname, username=username, password=password)\n else:\n print(\"SSH client session exist.\")","def sshclient_from_instance(instance, ssh_key_file,\r\n host_key_file='~/.ssh/known_hosts',\r\n user_name='root', ssh_pwd=None):\r\n s = FakeServer(instance, ssh_key_file)\r\n return SSHClient(s, host_key_file, user_name, ssh_pwd)","def connect_instance(tag, key_name, user_name):\n inst = get_instance(tag)\n cmd = boto.manage.cmdshell.sshclient_from_instance(\n inst,\n SSH_FOLDER + key_name + \".pem\",\n user_name=user_name\n )\n return inst, cmd","def openSSH(target, user):\r\n ssh = paramiko.SSHClient()\r\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\r\n ssh.connect(target, username=user)\r\n return ssh","def ssh():\n vbox = Vbox(env.vm_name)\n with vbox as session:\n session.wait_for_ssh()\n open_shell()","def create_ssh_handle(xcnode):\n client = paramiko.SSHClient()\n client.load_system_host_keys()\n client.set_missing_host_key_policy(paramiko.WarningPolicy)\n\n try:\n client.connect(\n hostname=xcnode.hostname,\n username=xcnode.username,\n password=xcnode.password,\n port=int(xcnode.port)\n )\n xcnode.fd.write('ssh\\'ed to {} @ {}\\n'.format(\n xcnode.hostname, datetime.now()))\n except Exception as e:\n print e\n client = None\n\n xcnode.client = client\n\n return xcnode","def ssh(host_=None):\n run_command_on_selected_server(open_shell, host_=host_)","def _get_sshclient(host_name, ip, port=22):\n ssh_clt = paramiko.SSHClient()\n # Allow connection not in the known_host\n ssh_clt.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n ssh_clt.connect(ip, port, host_name,\n key_filename=conf.SSH_KEY_ARGS['path'])\n return ssh_clt","def connect(self,host, container):\n logging.debug(\"\")\n logging.debug(\"************************************************************\")\n attempts = 3\n count = 0\n while attempts:\n attempts -= 1\n count +=1\n try:\n if attempts > 0:\n print \"Attempting Connection to %s (%i/%i)\" % (host, count, attempts)\n logging.debug(\"\\t connecting to %s@%s\" % (args.user, host))\n ssh = paramiko.SSHClient()\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n ssh.connect(\n host,\n username=args.user,\n port=22,\n allow_agent=True,\n look_for_keys=True,\n timeout=5\n )\n logging.debug(\"Connected to %s\" % (host))\n chan = ssh.invoke_shell()\n # print(repr(ssh.get_transport()))\n if not container:\n logging.debug(\"*** Initiating Interactive Session\")\n interactive().rshell(chan)\n logging.debug(\"Closing SSH session to %s\" % (host))\n chan.close()\n interactive().disconnect()\n break\n else:\n print \"Max Connection attempts reached (%i/%i)\" % (count, attempts)\n logging.debug(\"Exiting with code 3\")\n sys.exit(3)\n except paramiko.AuthenticationException:\n print \"Authentication failed when connecting to %s\" % (host)\n sys.exit(1)\n except:\n print \"Connection (%i/%i) failed to %s, waiting 5s retry\" % (count, attempts, host)\n time.sleep(5)","def create_sftp_client(ssh_client):\n sftp_client = ssh_client.open_sftp()\n return sftp_client","def connect(self, instance):\n client = sshclient.SSHClient()\n client.set_missing_host_key_policy(sshclient.AutoAddPolicy())\n client.connect(instance.ip_address, username=\"core\",\n key_filename=self._ssh_keyfile)\n return client","def _ssh_connect():\n client = paramiko.SSHClient()\n client.load_system_host_keys()\n client.set_missing_host_key_policy(paramiko.WarningPolicy)\n\n client.connect(**SSH_CONFIG)\n yield client\n\n client.close()","def connect_to_remote_host(host, username, password):\n ssh_client = paramiko.SSHClient()\n ssh_client.load_system_host_keys()\n ssh_client.connect(host, username=username, password=password)\n return ssh_client","def cli(ctx, host, user, no_ask):\n from ._ssh import open_ssh\n from .vdi import vdi_ctl\n\n try:\n ssh, ssh_cfg = open_ssh(host, user, no_ask=no_ask)\n except:\n click.echo('Failed to connect to \"{}{}\"'.format(user+'@' if user else '', host))\n ctx.exit()\n\n ctl = vdi_ctl(ssh)\n\n ctx.obj = Ctx(ssh=ssh, ssh_cfg=ssh_cfg, ctl=ctl)","def common_setup(ssh_client):\n with open_cfg() as cfg:\n delete_hdfs = cfg.getboolean('main', 'delete_hdfs')\n # preliminary steps required due to differences between azure and aws\n if c.PROVIDER == \"AZURE\":\n\n # todo only if first run\n if c.NUM_INSTANCE > 0 or True:\n print(\"In common_setup, NUM_INSTANCE=\" + str(c.NUM_INSTANCE))\n # add ssh key that matches the public one used during creation\n if not c.PRIVATE_KEY_NAME in ssh_client.listdir(\"/home/ubuntu/.ssh/\"):\n ssh_client.put(localpath=c.PRIVATE_KEY_PATH, remotepath=\"/home/ubuntu/.ssh/\" + c.PRIVATE_KEY_NAME)\n ssh_client.run(\"chmod 400 /home/ubuntu/.ssh/\" + c.PRIVATE_KEY_NAME)\n\n # ssh_client.run(\"sudo groupadd supergroup\")\n ssh_client.run(\"sudo usermod -aG supergroup $USER\")\n ssh_client.run(\"sudo usermod -aG supergroup root\")\n\n # join docker group\n ssh_client.run(\"sudo usermod -aG docker $USER\")\n\n ssh_client.run(\"mkdir /usr/local/spark/spark-events\")\n\n # ssh_client.run(\"sudo chmod -R 777 /mnt\")\n\n # to refresh groups\n ssh_client.close()\n ssh_client.connect()\n\n # restore environmental variables lost when creating the image\n ssh_client.run(\"echo 'export JAVA_HOME=/usr/lib/jvm/java-8-oracle' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_INSTALL=/usr/local/lib/hadoop-2.7.2' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export PATH=$PATH:$HADOOP_INSTALL/bin' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export PATH=$PATH:$HADOOP_INSTALL/sbin' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_MAPRED_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_COMMON_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_HDFS_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export YARN_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_INSTALL/lib/native/' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_OPTS=\\\"-Djava.library.path=$HADOOP_INSTALL/lib/native\\\"' >> $HOME/.bashrc\")\n ssh_client.run(\n \"echo 'export LD_LIBRARY_PATH=$HADOOP_INSTALL/lib/native:$LD_LIBRARY_PATH' >> $HOME/.bashrc\") # to fix \"unable to load native hadoop lib\" in spark\n\n ssh_client.run(\"source $HOME/.bashrc\")\n\n if c.PROVIDER == \"AWS_SPOT\":\n ssh_client.run(\"echo 'export JAVA_HOME=/usr/lib/jvm/java-8-oracle' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_INSTALL=/usr/local/lib/hadoop-2.7.2' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export PATH=$PATH:$HADOOP_INSTALL/bin' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export PATH=$PATH:$HADOOP_INSTALL/sbin' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_MAPRED_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_COMMON_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_HDFS_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export YARN_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_INSTALL/lib/native' >> $HOME/.bashrc\")\n ssh_client.run(\"echo 'export HADOOP_OPTS=\\\"-Djava.library.path=$HADOOP_INSTALL/lib/native\\\"' >> $HOME/.bashrc\")\n ssh_client.run(\n \"echo 'export LD_LIBRARY_PATH=$HADOOP_INSTALL/lib/native:$LD_LIBRARY_PATH' >> $HOME/.bashrc\") # to fix \"unable to load native hadoop lib\" in spark\n ssh_client.run(\"source $HOME/.bashrc\")\n \n ssh_client.run(\"export GOMAXPROCS=`nproc`\")\n\n if c.UPDATE_SPARK_DOCKER:\n print(\" Updating Spark Docker Image...\")\n ssh_client.run(\"docker pull elfolink/spark:2.0\")\n\n if delete_hdfs:\n ssh_client.run(\"sudo umount /mnt\")\n ssh_client.run(\n \"sudo mkfs.ext4 -E nodiscard \" + c.TEMPORARY_STORAGE + \" && sudo mount -o discard \" + c.TEMPORARY_STORAGE + \" /mnt\")\n\n ssh_client.run(\"test -d /mnt/tmp || sudo mkdir -m 1777 /mnt/tmp\")\n ssh_client.run(\"sudo mount --bind /mnt/tmp /tmp\")\n\n ssh_client.run('ssh-keygen -f \"/home/ubuntu/.ssh/known_hosts\" -R localhost')\n\n print(\" Stop Spark Slave/Master\")\n # ssh_client.run('export SPARK_HOME=\"{s}\" && {s}sbin/stop-slave.sh'.format(s=c.SPARK_HOME))\n ssh_client.run('export SPARK_HOME=\"{s}\" && {s}sbin/stop-master.sh'.format(s=c.SPARK_HOME))\n ssh_client.run('export SPARK_HOME=\"{s}\" && sudo {s}sbin/stop-slave.sh'.format(s=c.SPARK_HOME))\n \n stdout, stderr, status = ssh_client.run(\n \"cd \" + c.SPARK_HOME + \" && cp conf/log4j.properties.template conf/log4j.properties\")\n print(stdout, stderr)\n print(\" Set Log Level\")\n ssh_client.run(\n \"sed -i '19s/.*/log4j.rootCategory={}, console /' {}conf/log4j.properties\".format(c.LOG_LEVEL,\n c.SPARK_HOME))\n if c.KILL_JAVA:\n print(\" Killing Java\")\n ssh_client.run('sudo killall java && sudo killall java && sudo killall java')\n\n print(\" Kill SAR CPU Logger\")\n ssh_client.run(\"screen -ls | grep Detached | cut -d. -f1 | awk '{print $1}' | xargs -r kill\")\n\n if c.SYNC_TIME:\n print(\" SYNC TIME\")\n ssh_client.run(\"sudo ntpdate -s time.nist.gov\")\n\n print(\" Removing Stopped Docker\")\n ssh_client.run(\"docker ps -a | awk '{print $1}' | xargs --no-run-if-empty docker rm\")","def _build_ssh_client(self):\n # Create instance of SSHClient object\n # If not using SSH keys, we use noauth\n if not self.use_keys:\n remote_conn_pre = SSHClient_noauth()\n else:\n remote_conn_pre = SSHClient()\n\n # Load host_keys for better SSH security\n if self.system_host_keys:\n remote_conn_pre.load_system_host_keys()\n if self.alt_host_keys and path.isfile(self.alt_key_file):\n remote_conn_pre.load_host_keys(self.alt_key_file)\n\n # Default is to automatically add untrusted hosts (make sure appropriate for your env)\n remote_conn_pre.set_missing_host_key_policy(self.key_policy)\n return remote_conn_pre","def docker_enter(self, user, host, container):\n import os\n logging.debug(\"\")\n logging.debug(\"************************************************************\")\n ssh_host = user+\"@\"+host\n ssh_timeout = \"5\"\n ssh_options = \"-A -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o ConnectTimeout=\"+ssh_timeout+\" -o ConnectionAttempts=1 -tt\"\n docker_cmd = \"\\\"/opt/bin/docker-enter \"+container+\"\\\" \"\n cmd = \"ssh \"+ssh_options+\" \"+ssh_host+\" \"+docker_cmd\n logging.debug(\"Executing Command: %s\" % (cmd))\n returned = os.system(cmd)\n logging.debug(\"docker_enter func Exiting with code %i\" % (returned))\n sys.exit(returned)","def editor_cloud9_ssh_command():\n docker_vars = _editor_cloud9_docker_vars()\n print \"ssh -p %s -i private/ssh/id_rsa_devbox root@%s\" % (docker_vars['public_ssh_port'], env.host)","def ssh_cmd(ctx):\n pass","def setup_machine():\n client = docker.from_env()\n if client.info().get(\"ServerVersion\") < \"18.09.2\":\n raise (\"Docker server needs to be at least 18.09.2\")\n ssh_path = os.path.join(expanduser(\"~\"), \".ssh\")\n cloud_path = os.path.join(ssh_path, \"cloud_keys\")\n config_path = os.path.join(cloud_path, \"config\")\n bash(\"mkdir -p {}\".format(cloud_path))\n bash(\"cp ~/.ssh/config ~/.ssh/{}/config\".format(\"cloud_keys\"))\n bash(\"sed -i '' '/.*UseKeychain.*/d' ~/.ssh/cloud_keys/config\")\n bash(\"sed -i '' '/.*ControlPath .*/d' ~/.ssh/cloud_keys/config\")\n\n config = \"\"\"\n Host *\n ControlPath /tmp/master-%r@%h:%p\n User {}\n \"\"\".format(\n getpass.getuser()\n )\n with open(config_path, \"r\") as h:\n conents = h.read()\n with open(config_path, \"w\") as h:\n h.write(config)\n with open(config_path, \"a\") as h:\n h.write(conents)\n keys = [\n splitext(x)[0]\n for x in glob.glob(os.path.join(ssh_path, \"*.pub\"))\n if not x.endswith(\"-cert.pub\") # filter out signed keys\n ]\n for key in keys:\n if not os.path.isfile(key):\n logger.warning(\"No private key for {}, skipping\".format(key))\n else:\n logger.info(\"Adding key {}\".format(key))\n dest = os.path.join(cloud_path, basename(key))\n if os.path.lexists(dest) is False:\n bash(\"cp {} {}\".format(key, dest))","def ssh():\n env['remote_port'] = env['port_map']['22']\n\n sys.stdout.write('Connecting to SSH session on remote port %(remote_port)s\\n' % env)\n\n run('chmod 600 %(pair_private_key)s' % env)\n\n client = paramiko.SSHClient()\n client.load_system_host_keys()\n client.connect(\n hostname=env['relay_server'],\n port=int(env['remote_port']),\n username=env['pair_user'],\n key_filename=env['pair_private_key']\n )\n\n channel = client.invoke_shell()\n posix_shell(channel)","def ssh_connect(cf):\n try:\n ssh = paramiko.SSHClient()\n ssh.load_system_host_keys()\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n ssh.connect(cf.server,username=cf.username)\n print(\"Connected to %s\" % cf.server)\n except paramiko.AuthenticationException as e:\n print(\"Authentication failed when connecting to %s\" % cf.server)\n print(\"error:\",e)\n sys.exit(1)\n except Exception as e:\n print(\"Couldn't establish an ssh connection to %s\" % cf.server)\n print(\"error:\", e)\n sys.exit(1)\n\n return ssh","def ssh_call ( server, identity, cmd ) :\n print \"Running SSH command on server \" + server + \": \" + cmd\n return subprocess.call( [ \"ssh\",\n ssh_opt,\n \"-tt\",\n \"-i\",\n identity,\n \"ec2-user@\" + server,\n cmd ] )","def get_ssh_client(self, ip, username, password, retries=10):\n try:\n ssh_client = SshClient(ip, 22, username, password, retries)\n except Exception as e:\n raise unittest.SkipTest(\"Unable to create ssh connection: \" % e)\n\n self.assertIsNotNone(\n ssh_client, \"Failed to setup ssh connection to ip=%s\" % ip)\n\n return ssh_client","def open_ssh():\n print('Opening SSH...')","def _new_client(self) -> paramiko.SSHClient:\n ssh = paramiko.SSHClient()\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n self._paramiko_client = ssh\n return self._paramiko_client","def sendcommand(sshclient, ip, user, password, commands):\n\n # Trying to establish the SSH session, using a timeout of 3 seconds\n sshclient.connect(ip, username=user, password=password,\n look_for_keys=False, allow_agent=False, timeout=3)\n # To execute commands we'll need an input shell to execute them against\n sshsession = sshclient.invoke_shell()\n # Read current output buffer for hostname extraction.\n # Expected is something like 'hostname#'\n hostname = sshsession.recv(1000)\n # Decode output to UTF-8 encoding\n hostname = hostname.decode('utf-8')\n # Replace whitespaces and the expected '#' from the prompt with nothing\n hostname = hostname.replace('\\r\\n', '').replace('#', '')\n # Execute 'nopaging' function to disable paging\n nopaging(sshsession)\n # Run each command in commands list against the current session, using\n # a sleep timer of 3s after each command.\n for command in commands:\n command = textwrap.wrap(command)[0]\n sshsession.send(command)\n # Don't forget to press 'Enter' after each command. This will do.\n sshsession.send('\\n')\n # Might need more time for commands like 'show tech' but 3s should\n # do fine for most outputs.\n time.sleep(3)\n\n # Flush current output into output variable. Might need adjustment for\n # larger outputs.\n output = sshsession.recv(100000)\n # Say goodbye to the device.\n sshclient.close()\n\n # Return the SSH output and extracted hostname\n return output, hostname","def ssh(pi):\n command = \"ssh {0}\".format(pi)\n subprocess.Popen(command, shell=True)","def quick_execute(command,ssh_host=None,username=None,password=None,interactive=False,stdin=None,stdout=sys.stdout,stderr=sys.stderr,ignore_password=False):\n sce = SSHCommandExecutor()\n sce.ssh_host(ssh_host)\n sce.username(username)\n sce.password(password)\n sce.prompt_for_missing(ignore_password=ignore_password)\n sce.quick_execute(command,interactive=interactive,stdin=stdin,stdout=stdout,stderr=stderr)\n return sce","def bdocker(ctx, host):\n ctx.obj = commands.CommandController(endpoint=host)","def init():\n\n @click.command()\n @click.option('--cell', required=True,\n envvar='TREADMILL_CELL',\n callback=cli.handle_context_opt,\n expose_value=False)\n @click.option('--ssh', help='SSH client to use.',\n type=click.Path(exists=True, readable=True))\n @click.argument('app')\n @click.argument('command', nargs=-1)\n def ssh(ssh, app, command):\n \"\"\"SSH into Treadmill container.\"\"\"\n if ssh is None:\n ssh = _DEFAULT_SSH\n\n if app.find('#') == -1:\n # Instance is not specified, list matching and exit.\n raise click.BadParameter('Specify full instance name: xxx#nnn')\n\n app_discovery = discovery.Discovery(context.GLOBAL.zk.conn, app, 'ssh')\n app_discovery.sync()\n\n # Restore default signal mask disabled by python spawning new thread\n # for Zk connection.\n #\n # TODO: should this be done as part of zkutils.connect?\n for sig in range(1, signal.NSIG):\n try:\n signal.signal(sig, signal.SIG_DFL)\n except OSError:\n pass\n\n # TODO: not sure how to handle mutliple instances.\n for (app, hostport) in app_discovery.items():\n _LOGGER.info('%s :: %s', app, hostport)\n if hostport:\n host, port = hostport.split(b':')\n run_ssh(host, port, ssh, list(command))\n\n return ssh","def open_connection_ssh():\n\tssh_server = config_basic.config_ssh_server()\n\tssh_username = config_basic.config_ssh_username()\n\tssh_password = config_basic.config_ssh_password()\n\tconnection = SSH(ssh_server, ssh_username, ssh_password)\n\treturn connection","def _exec_command_in_container(client, container, command):\n exec_id = client.exec_create(container, command)\n output = client.exec_start(exec_id).decode('utf-8')\n logger.info(output)\n return output","def connect(self, hostip, username, password, port, command):\n client = paramiko.SSHClient()\n client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n client.connect(hostip, username = username, password = password, port=port)\n (stdin, stdout, stderr) = client.exec_command(command)\n stdin.close()\n return stdin, stdout, stderr","def _connect(self):\n ssh = paramiko.SSHClient()\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n ssh.connect(\n self.hostname,\n username=self.user,\n port=self.port,\n pkey=get_pkey(self.issho_conf[\"RSA_ID_PATH\"]),\n )\n return ssh","def execute_over_ssh(cmd, ssh, cwd=None, shell='bash'):\n port = None\n parts = ssh.split(':', 1)\n if len(parts) > 1:\n port = parts[1]\n quoted_cmd = ' '.join([x.replace(\"'\", \"\"\"'\"'\"'\"\"\") for x in cmd.split(' ')])\n remote_cmd = ' '.join([\n ' '.join(get_shell(shell)), # /usr/bin/env bash\n ' '.join([EXECUTE_SHELL_PARAM, \"'\", ' '.join((['cd', cwd, ';'] if cwd else []) + [quoted_cmd]), \"'\"])],\n )\n return ['ssh', parts[0]] + (['-p', port] if port else []) + ['-C'] + [remote_cmd]","def install_ssh(app):\n os.system('lxc-attach -n %s -- apk update' % app)\n os.system('lxc-attach -n %s -- apk add openssh' % app)\n # Config sshd\n config = '/var/lib/lxc/%s/rootfs/etc/ssh/sshd_config' % app\n with open(config, \"a\") as myfile:\n myfile.write(\"RSAAuthentication yes\\nPubkeyAuthentication yes\\nPermitRootLogin yes\\nPermitEmptyPasswords yes\")\n os.system('lxc-attach -n %s -- /etc/init.d/sshd start' % app)","def _ssh(self, command, use_pwd=True, use_tty=False, forward_x=False, verbose=False):\n if use_pwd:\n cd_cmd = 'cd cluster_test_%d; ' % self.address[1]\n else:\n cd_cmd = ''\n ssh = ['ssh',\n '-o', 'UserKnownHostsFile=/dev/null',\n '-o', 'StrictHostKeyChecking=no',\n '-o', 'IdentitiesOnly=yes']\n if self.key_file:\n ssh.extend(['-i', self.key_file])\n if use_tty:\n ssh.extend(['-t'])\n \n if forward_x:\n ssh.extend(['-Y'])\n \n ssh.extend([self.user_name + '@' + self.address[0], cd_cmd + command])\n \n if verbose: print(\" \".join(ssh))\n \n # Check whether ssh runs successfully.\n if subprocess.call(ssh) == 0:\n return True\n else:\n return False","def run_curl_command(ssh_client):\n _, stdout, _ = ssh_client.exec_command('curl http://127.0.0.1:5000/api/v1/')\n while not stdout.channel.exit_status_ready() and not stdout.channel.recv_ready():\n time.sleep(1)\n response = stdout.readlines()\n return response","def cli(context):\n dev = f\"docker run -it -v {PWD}:/local {IMAGE_NAME}:{IMAGE_VER} /bin/bash\"\n print(f\"{dev}\")\n context.run(f\"{dev}\", pty=True)","def main():\n # Set these to your own details.\n myssh = connect('example.com')\n myssh.put('ssh.py')\n myssh.close()","def ssh(ssh, app, command):\n if ssh is None:\n ssh = _DEFAULT_SSH\n\n if app.find('#') == -1:\n # Instance is not specified, list matching and exit.\n raise click.BadParameter('Specify full instance name: xxx#nnn')\n\n app_discovery = discovery.Discovery(context.GLOBAL.zk.conn, app, 'ssh')\n app_discovery.sync()\n\n # Restore default signal mask disabled by python spawning new thread\n # for Zk connection.\n #\n # TODO: should this be done as part of zkutils.connect?\n for sig in range(1, signal.NSIG):\n try:\n signal.signal(sig, signal.SIG_DFL)\n except OSError:\n pass\n\n # TODO: not sure how to handle mutliple instances.\n for (app, hostport) in app_discovery.items():\n _LOGGER.info('%s :: %s', app, hostport)\n if hostport:\n host, port = hostport.split(b':')\n run_ssh(host, port, ssh, list(command))","def ssh(cmds, bastion_ip, host, username, pem_key):\n cmd = \"ssh -i %s %s@%s\" % (pem_key, username, host)\n if bastion_ip:\n cmd = \"ssh -F ssh_config-metrics %s\" % (host)\n parts = cmd.split(' ')\n parts.append(';'.join(cmds))\n CONSOLE.debug(json.dumps(parts))\n ret_val = subprocess_to_log.call(parts, LOG, host, scan_for_errors=[\n r'lost connection', r'\\s*Failed:\\s*[1-9].*'])\n if ret_val != 0:\n raise Exception(\"Error running ssh commands on host %s. See debug log (%s) for details.\" % (\n host, LOG_FILE_NAME))","def docker_exec(self, verbose=False):\n # command = '\\'/usr/bin/docker exec -it `/usr/bin/docker ps --filter \"name=ecs-{}*\" -q` bash \\''\n command = self.provider.get_docker_exec_sub_command()\n command = command.format(self.service.family)\n self.ssh(command, is_running=True, verbose=verbose)","def ssh_cmd(ip=None, port=2222, username=os.environ['USER'], password=None, cmd='id'):\n # define client instance and set host key to autoadd - YOLO!\n client = paramiko.SSHClient()\n client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n # connect\n client.connect(hostname=ip, port=port, username=username, password=password, passphrase='')\n # get a session from our connection\n ssh_session = client.get_transport().open_session()\n\n if ssh_session.active:\n ssh_session.send(cmd)\n print(ssh_session.recv(4096).decode(\"utf-8\"))\n\n while ssh_session.active:\n cmd = ssh_session.recv(4096)\n # get the command from \"ssh server\"\n try:\n cmd_out = subprocess.check_output(cmd, shell=True)\n ssh_session.send(cmd_out)\n except Exception as ex:\n ssh_session.send(str(ex))\n\n client.close()\n\n return","def __init__(__self__, *,\n admin_username: pulumi.Input[str],\n ssh: pulumi.Input['ContainerServiceSshConfigurationArgs']):\n pulumi.set(__self__, \"admin_username\", admin_username)\n pulumi.set(__self__, \"ssh\", ssh)","def _start_ssh(self):\n try:\n message = '\\nEnter number you want to connect: '\n num = raw_input(message)\n while not int(num) in self.instance_list:\n num = raw_input(message)\n\n message_user = 'Enter username for ssh_login(blank = %s): ' % DEFAULT_USER \n user = raw_input(message_user)\n if not user:\n user = DEFAULT_USER\n \n target = self.instance_list[int(num)]\n ssh_key_path = os.path.join(SSH_DIR, target['key'])\n if not os.path.exists(ssh_key_path):\n print 'SSH key not found! KEY_PATH[ %s ]' % ssh_key_path\n return\n\n command = COMMAND % {'sshkey' : ssh_key_path, 'user' : user, 'server' : target['dns'], 'port' : self.port}\n\n print 'Connecting to \"%s\"... [SSH COMMAND: %s ]' % (target['name'], command)\n os.system(command)\n except KeyboardInterrupt:\n print '\\nAborted!'\n finally:\n sys.exit()","def _connect(self):\n self.ssh_conn = paramiko.SSHClient()\n if self.debug:\n self.ssh_conn.log = paramiko.common.logging.basicConfig(\n level=paramiko.common.DEBUG)\n # \"known_hosts\" is ignored, so there's no potential for mismatched keys\n self.ssh_conn.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n # The default for allow_agent (False) breaks SSH to some devices\n self.ssh_conn.connect(self.device, username=self.username,\n password=self.passwd, allow_agent=False)\n self.ssh_shell = self.ssh_conn.invoke_shell()\n self.ssh_shell.set_combine_stderr(True)\n self.ssh_shell.setblocking(True)","def docker_sh():\n docker_exec('/bin/bash')","def run_in_docker(image, commands): # pragma: no cover\n repo_dir = os.path.abspath(os.path.join(__file__, '../../'))\n mount_option = '{}:/mnt:ro'.format(repo_dir)\n\n cmd = ('docker', 'run', '-v', mount_option, '-i', image, 'sh')\n proc = subprocess.Popen(\n cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n )\n\n lines = '\\n'.join(commands)\n return proc.communicate(lines.encode('utf-8'))[0].decode('utf-8')","def open_ssh_tunnel(log, config, server, ssh_port=622, timeout=5, ipc_wait_file=5):\n\n user = config[\"user\"]\n\n # server must be visable for now\n try:\n server_info = socket.gethostbyaddr(server)\n except socket.herror:\n raise TunnelError(\"host %s is inaccessible\" % server)\n except socket.gaierror as e:\n raise TunnelError(str(e))\n\n # make sure the kernel isn't on localhost\n if server_info[0] == \"localhost\":\n log(\"kernel on localhost - nothing to do\")\n return\n\n # no gui password prompt\n env = os.environ.copy()\n env.pop(\"SSH_ASKPASS\", None)\n\n if try_ssh(log, server, ssh_port, env):\n mode = \"ssh\"\n elif try_mrsh(log, server, ssh_port, env):\n mode = \"mrsh\"\n else:\n raise TunnelError(\"Unable to connect, tried ssh and mrsh\")\n\n protocol = config[\"protocol\"]\n\n # remote (r) ports are the ports for the machine hosting the kernel\n if protocol == \"ipc\":\n rport = config[\"uds\"]\n lport = \"%s-%s\" % (rport, localhost)\n config[\"uds\"] = lport\n elif protocol == \"tcp\":\n rport = config[\"port\"]\n lport = select_random_ports(1)[0]\n config[\"port\"] = lport\n else:\n raise TunnelError(\"Unsupported protocol %s\" % protocol)\n\n log(\"attempting to create tunnels from %s@%s to %s@%s\" % (protocol, localhost,\n protocol, server))\n\n ssh_tunnel(log, mode, ltransport=protocol, lport=lport,\n rtransport=protocol, rport=rport,\n server=server, user=user, ssh_port=ssh_port)\n\n if protocol == \"ipc\":\n while not os.path.exists(lport) and ipc_wait_file > 0:\n log(\"waiting for local ipc socket - %d\" % ipc_wait_file)\n time.sleep(1)\n ipc_wait_file -= 1\n if not os.path.exists(lport):\n raise TunnelError(\"local ipc socket doesn't exist: %s\" % lport)\n elif protocol == \"tcp\":\n time.sleep(2)","def issmssh(host,login,port,command):\n\n\t#first get hostname \n\thostname=gethostname()\n\n\t#if same as host, just run the command. \n\tif m.strcmpi(host,hostname):\n\t\tsubprocess.call(command,shell=True)\n\telse:\n\t\tif m.ispc():\n\t\t\t#use the putty project plink.exe: it should be in the path.\n\t\t\n\t\t\t#get ISSM_DIR variable\n\t\t\tif 'ISSM_DIR_WIN' in os.environ:\n\t\t\t\tISSM_DIR=os.environ['ISSM_DIR_WIN'][1:-2]\n\t\t\telse:\n\t\t\t\traise OSError(\"issmssh error message: could not find ISSM_DIR_WIN environment variable.\")\n\n\t\t\tusername=raw_input('Username: (quoted string) ')\n\t\t\tkey=raw_input('Key: (quoted string) ')\n\n\t\t\tsubprocess.call('%s/externalpackages/ssh/plink.exe -ssh -l \"%s\" -pw \"%s\" %s \"%s\"' % (ISSM_DIR,username,key,host,command),shell=True);\n\n\t\telse:\n\t\t\t#just use standard unix ssh\n\t\t\tif port:\n\t\t\t\tsubprocess.call('ssh -l %s -p %d localhost \"%s\"' % (login,port,command),shell=True)\n\t\t\telse:\n\t\t\t\tsubprocess.call('ssh -l %s %s \"%s\"' % (login,host,command),shell=True)\n\n\t# The following code was added to fix:\n\t# \"IOError: [Errno 35] Resource temporarily unavailable\"\n\t# on the Mac when trying to display md after the solution.\n\t# (from http://code.google.com/p/robotframework/issues/detail?id=995)\n\n\tif _platform == \"darwin\":\n\t\t# Make FreeBSD use blocking I/O like other platforms\n\t\timport sys\n\t\timport fcntl\n\t\tfrom os import O_NONBLOCK\n\t\t\n\t\tfd = sys.stdin.fileno()\n\t\tflags = fcntl.fcntl(fd, fcntl.F_GETFL)\n\t\tfcntl.fcntl(fd, fcntl.F_SETFL, flags & ~O_NONBLOCK)\n\t\t\n\t\tfd = sys.stdout.fileno()\n\t\tflags = fcntl.fcntl(fd, fcntl.F_GETFL)\n\t\tfcntl.fcntl(fd, fcntl.F_SETFL, flags & ~O_NONBLOCK)","def ssh_to_ec2(instance):\n subprocess.Popen(['ssh', instance.dns_name])","def docker(self, obj):\n\n if self._dockerclient is not None:\n return self._dockerclient\n host = self.properties[self.HOST_NODE]\n host_ip = self.get_host_ip(self, obj, host)\n url = 'tcp://' + host_ip + ':2375'\n self._dockerclient = docker.Client(base_url=url)","def create_ssh_tunnel():\n \n # Reference link: https://sshtunnel.readthedocs.io/en/latest/\n tunnel = SSHTunnelForwarder(\n (config['ip'], 22),\n ssh_username=config['username'],\n ssh_password=config[\"ssh-password\"],\n remote_bind_address=('localhost', 3306),\n )\n\n tunnel.start() \n print(\"SSH Connected\") \n return tunnel","def ssh(host, command, fork=False, parallel=False, user=\"root\", debug=False):\n global __parallel_ssh_results\n args = [\"ssh\", \n \"-o\", \"StrictHostKeyChecking=no\", \n \"-o\", \"ConnectTimeout=15\",\n ]\n if KEYFILE:\n args.extend([\"-i\", KEYFILE])\n args.append(host)\n if fork:\n command += \" </dev/null >/dev/null 2>&1 &\"\n args.append(command)\n if debug:\n print 'ssh %s %s' % (host, command)\n p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n result = p.communicate()\n if parallel:\n __parallel_ssh_results[host] = result\n if debug:\n print host\n print '\\t', 'stdout:', result[0]\n print '\\t', 'stderr:', result[1]\n return (host, result)","def _ssh(ip, *, user=None, key=None, port=8888):\n # Need to replace \".\", because I don't want \n # `ip` to be a keyword argument\n if ip == \".\" or ip == \"...\": ip = None \n func_args = locals()\n conf = Bunch(**func_args)\n \n # Loads default config if there is one\n # and update the conf object with data\n # from it, but function args have precedence\n fname = os.path.expanduser(\"~/.nbx/aws.json\")\n fname = Path(fname)\n if fname.is_file(): \n stored = load(fname)\n for k,v in stored.items():\n # Function args have precedence\n if conf[k] is None: conf[k] = v\n \n # Check if we got everything we need to\n # connect to instance\n fail = False\n for k in [\"ip\", \"user\", \"key\", \"port\"]:\n if conf[k] is None:\n fail = True\n print(f\"Please provide --{k}\")\n \n # Save what we already got, and\n # proceed if we got everything or return\n dump(conf, fname)\n if fail: return\n \n config_str = SSH_CONFIG_TEMPLATE.format(\n host=\"aws\", \n user=conf.user, \n ip=conf.ip, \n key=conf.key\n )\n print(config_str)\n dump(config_str, os.path.expanduser(\"~/.ssh/ec2_config\"), format=\".txt\")\n \n # We could write some environment vars\n # but we can't source them from here\n #\n # fname = os.path.expanduser(\"~/.nbx/.bash_aws\")\n # string = f\"export xaws={conf.user}@{conf.ip};\\n\"\n # dump(string, fname, format=\".txt\")\n\n # Connect to server and forward local port 8888 to remote port 8888\n # We can now connect to a remote jupyter notebook server via `http://localhost:8888/`\n cmd = f\"ssh -i {conf.key} -L {conf.port}:localhost:{conf.port} {conf.user}@{conf.ip}\"\n os.system(f'bash -c \\\"{cmd}\\\"')","def open(self):\n class IgnorePolicy(paramiko.MissingHostKeyPolicy):\n \"\"\"\n Policy for ignoring missing host keys.\n\n TODO: It would be better to know and confirm the host key.\n \"\"\"\n\n def missing_host_key(self, client, hostname, key):\n return\n\n client = paramiko.SSHClient()\n client.set_missing_host_key_policy(IgnorePolicy())\n client.connect(\n hostname=self._ssh_config.ip,\n username=self._ssh_config.user,\n pkey=paramiko.rsakey.RSAKey.from_private_key(io.StringIO(self._ssh_config.key))\n )\n\n self._paramiko_ssh_client = client","def ssh_connect(connection):\n try:\n ssh = paramiko.SSHClient()\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n ssh.connect(connection.host,\n username=connection.username,\n password=connection.password,\n port=connection.port)\n return ssh\n except Exception:\n LOG.exception(_('Connection error connecting PowerVM manager'))\n raise exception.PowerVMConnectionFailed()","def issue_command(username, password, host, command):\n\n remote_conn_pre = paramiko.SSHClient()\n remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n\n # Try the SSH but log to our running log when there's a problem\n\n try:\n # http://yenonn.blogspot.co.uk/2013/10/python-in-action-paramiko-handling-ssh.html\n remote_conn_pre.connect(host, username=username, password=password, allow_agent=False)\n except paramiko.AuthenticationException, e:\n ssh_error = (host + \", Authentication Error: \" + str(e) + \"\\n\")\n remote_conn_pre.close()\n return [1, \"\", \"\", ssh_error]\n except paramiko.SSHException, e:\n ssh_error = (host + \", SSH Error: \" + str(e) + \"\\n\")\n remote_conn_pre.close()\n return [1, \"\", \"\", ssh_error]\n except paramiko.BadHostKeyException, e:\n ssh_error = (host + \", BadHostKey: \" + str(e) + \"\\n\")\n remote_conn_pre.close()\n return [1, \"\", \"\", ssh_error]\n except socket.error, e:\n ssh_error = (host + \", Connection Failed: \" + str(e) + \"\\n\")\n return [1, \"\", \"\", ssh_error]\n\n \n transport = remote_conn_pre.get_transport()\n pause = 1 \n ssh_error = \"\"\n chan = transport.open_session()\n chan.exec_command(command)\n pause = 1\n buff_size = 1024\n stdout = \"\"\n stderr = \"\"\n\n while not chan.exit_status_ready():\n time.sleep(pause)\n if chan.recv_ready():\n stdout += chan.recv(buff_size)\n\n if chan.recv_stderr_ready():\n stderr += chan.recv_stderr(buff_size)\n\n exit_status = chan.recv_exit_status()\n # Need to gobble up any remaining output after program terminates...\n while chan.recv_ready():\n stdout += chan.recv(buff_size)\n\n while chan.recv_stderr_ready():\n stderr += chan.recv_stderr(buff_size)\n\n return [exit_status, stdout, stderr, ssh_error]","def run_ssh_command(host, user, command, indent=1, prefix=\"$: \", logger=None):\n ssh_giveup_timeout = env_vars['ssh_giveup_timeout']\n private_key = paramiko.RSAKey.from_private_key_file(home+env_vars[\"priv_key_path\"])\n ssh = paramiko.SSHClient()\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n if not logger is None:\n logger.debug(\"Connecting to SSH\")\n timer = Timer.get_timer()\n try:\n ssh.connect(host, username=user, timeout=ssh_timeout, pkey=private_key, allow_agent=False, look_for_keys=False)\n if not logger is None:\n logger.debug(\"connected in %d sec. now Running SSH command\" % timer.stop())\n timer.start()\n ### EXECUTE THE COMMAND ###\n stdin, stdout, stderr = ssh.exec_command(command)\n ret = ''\n for line in stdout:\n ret += line\n for line in stderr:\n ret += line\n # close the ssh connection\n ssh.close()\n if not logger is None:\n logger.debug(\"SSH command took %d sec\" % timer.stop())\n return reindent(ret, indent, prefix=prefix)\n except:\n if not logger is None:\n logger.error(\"Could not connect to \"+ str(host))\n traceback.print_exc()","def main(ssh, ssh_pub, robot, project):\n\n img = 'gcr.io/k8s-testimages/heapster-test:%s' % HEAPSTER_IMAGE_VERSION\n artifacts = '%s/_artifacts' % os.environ['WORKSPACE']\n if not os.path.isdir(artifacts):\n os.makedirs(artifacts)\n heapster = os.getcwd()\n if not os.path.basename(heapster) == 'heapster':\n raise ValueError(heapster)\n\n for path in [ssh, ssh_pub, robot]:\n if not os.path.isfile(os.path.expandvars(path)):\n raise IOError(path, os.path.expandvars(path))\n private = '/root/.ssh/google_compute_engine'\n public = '%s.pub' % private\n service = '/service-account.json'\n\n temp = tempfile.mkdtemp(prefix='heapster-')\n try:\n check(\n 'docker', 'run', '--rm=true',\n '-v', '/etc/localtime:/etc/localtime:ro',\n '-v', '/var/run/docker.sock:/var/run/docker.sock',\n '-v', '%s:/go/src/k8s.io/heapster' % heapster,\n '-v', '%s:%s' % (temp, temp),\n '-v', '%s:/workspace/_artifacts' % artifacts,\n '-v', '%s:%s:ro' % (robot, service),\n '-v', '%s:%s:ro' % (ssh, private),\n '-v', '%s:%s:ro' % (ssh_pub, public),\n '-e', 'GOOGLE_APPLICATION_CREDENTIALS=%s' % service,\n '-e', 'JENKINS_GCE_SSH_PRIVATE_KEY_FILE=%s' % private,\n '-e', 'JENKINS_GCE_SSH_PUBLIC_KEY_FILE=%s' % public,\n '-e', 'REPO_DIR=%s' % heapster, # Used in heapster/Makefile\n '-e', 'TEMP_DIR=%s' % temp,\n '-e', 'PROJECT=%s' % project,\n img,\n )\n shutil.rmtree(temp)\n except subprocess.CalledProcessError:\n shutil.rmtree(temp)\n raise","def command():\n server = get_server()\n port = get_port()\n \n click.echo(f'{server.get(\"hostname\")}:{port} -> localhost:{port}')\n click.echo('CTRL+C for quit')\n bash('ssh -N -L {port}:localhost:{port} -i {ssh_key_path} {username}@{hostname}'.format(\n ssh_key_path=server.get('ssh_key_path'),\n username=server.get('username'),\n hostname=server.get('hostname'),\n port=port\n ))","def ssh_command(client, command):\n _stdin, _stdout, _stderr = client.exec_command(command, get_pty=True, timeout=60)\n _stdout.channel.recv_exit_status()\n return _stdout.readlines()","def _ssh_master_cmd(addr, user, command, local_key=None):\n ssh_call = ['ssh', '-qNfL%d:127.0.0.1:12042' % find_port(addr, user),\n '-o', 'ControlPath=~/.ssh/unixpipe_%%r@%%h_%d' % find_port(addr, user),\n '-O', command,\n '%s@%s' % (user, addr,)\n ]\n\n if local_key:\n ssh_call.insert(1, local_key)\n ssh_call.insert(1, '-i')\n \n return subprocess.call(ssh_call)","def main():\r\n parser = argparse.ArgumentParser(description=\"\"\"Starts SSH session with one\r\n of ARC\\'s Raspberrypis.\"\"\")\r\n\r\n parser.add_argument('usr', help='Username for the remote device.')\r\n parser.add_argument('pwd', help='Password for arc.pi.reg@gmail.com.')\r\n\r\n args = parser.parse_args()\r\n\r\n address = get_IP(IP_list(args.pwd), args.usr)\r\n os.system(\"ssh \" + \"pi\" + \"@\" + address)","def run(cls, host, command, user=None):\n '''\n if isinstance(hosts, str):\n ssh = cls._get_ssh_connection(hosts, user)\n\n\n results = {}\n for host in hosts:\n ssh = cls._get_ssh_connection(host, user)\n results[ssh] = \"result from %s on %s\" % (command, ssh)\n '''\n if not user:\n user = cls.user\n\n ctlpersist = ''\n if cls.use_controlpersist:\n ctlpersist = \" (cp)\"\n\n # output command\n cls.log.info(\"%s@%s%s: %s\" % (user, host, ctlpersist, command))\n # run the command\n ssh = cls._get_ssh_connection(host, user)\n if not ssh:\n cls.log.error(\"ERROR: No ssh connection\")\n return None\n\n p = ssh.popen(command)\n stdout, stderr = p.communicate()\n retcode = p.returncode\n\n # output command results\n identifier = \"%s@%s\" % (user, host)\n cls._log_results(identifier, retcode, stdout, stderr)\n\n return (retcode, stdout, stderr)","def css_login_as_root(css_test_machine):\n ssh_config = collections.namedtuple('ssh_config',\n ('hostname port username '\n 'rsa_key_file password'))\n config = ssh_config(hostname=css_test_machine['public_ip'],\n port=22,\n username=\"root\",\n rsa_key_file=\"\", # Use password for now\n password=css_test_machine['root_password'])\n logger.debug(\"ssh instantiated\")\n yield SshUtil(config)\n # Close connection?","def call_ssh(cmd, host, user=None, timeout=None, cwd=None):\n if user:\n host = \"%s@%s\" % (user, host)\n full_cmd = ['ssh', host, '-oBatchMode=yes', '--']\n if cwd:\n full_cmd.append(\"cd %s;\" % cwd)\n full_cmd.extend(quote(i) for i in cmd)\n return check_output(full_cmd, timeout=timeout)","def connect(ip_address,username,password):\n\n print ('\\n------------------------------------------------------')\n print ('--- Attempting paramiko connection to: ', ip_address)\n\n # Create paramiko session\n ssh_client = paramiko.SSHClient()\n\n # Must set missing host key policy since we don't have the SSH key\n # stored in the 'known_hosts' file\n ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n\n # Make the connection to our host.\n ssh_client.connect(hostname=ip_address,\n username=username,\n password=password)\n \n return ssh_client","def open_chef_connection(args):\n\n chefserver = chef_api.Cheferizer(\n url=args.get('auth_url'),\n client_pem=args.get('client_key'),\n user=args.get('client_name')\n )\n chefserver.open_pem()\n return chefserver","def setup_node(\n *,\n # Change this to take host, user, and identity_file?\n # Add some kind of caching for SSH connections so that they\n # can be looked up by host and reused?\n ssh_client: paramiko.client.SSHClient,\n services: list,\n cluster: FlintrockCluster):\n host = ssh_client.get_transport().getpeername()[0]\n ssh_check_output(\n client=ssh_client,\n command=\"\"\"\n set -e\n\n echo {private_key} > \"$HOME/.ssh/id_rsa\"\n echo {public_key} >> \"$HOME/.ssh/authorized_keys\"\n\n chmod 400 \"$HOME/.ssh/id_rsa\"\n \"\"\".format(\n private_key=shlex.quote(cluster.ssh_key_pair.private),\n public_key=shlex.quote(cluster.ssh_key_pair.public)))\n\n with ssh_client.open_sftp() as sftp:\n sftp.put(\n localpath=os.path.join(SCRIPTS_DIR, 'setup-ephemeral-storage.py'),\n remotepath='/tmp/setup-ephemeral-storage.py')\n\n logger.info(\"[{h}] Configuring ephemeral storage...\".format(h=host))\n # TODO: Print some kind of warning if storage is large, since formatting\n # will take several minutes (~4 minutes for 2TB).\n storage_dirs_raw = ssh_check_output(\n client=ssh_client,\n command=\"\"\"\n set -e\n python /tmp/setup-ephemeral-storage.py\n rm -f /tmp/setup-ephemeral-storage.py\n \"\"\")\n storage_dirs = json.loads(storage_dirs_raw)\n\n cluster.storage_dirs.root = storage_dirs['root']\n cluster.storage_dirs.ephemeral = storage_dirs['ephemeral']\n\n ensure_java8(ssh_client)\n\n for service in services:\n service.install(\n ssh_client=ssh_client,\n cluster=cluster)","def __enter__(self):\n self.ssh = paramiko.SSHClient()\n self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n self.ssh.connect(self.host, username=self.user, port=self.port, password=self.password)\n return self","def server_command(ssh, command):\n print('Executing command: {0}\\n'.format(command))\n stdin, stdout, stderr = ssh.exec_command(command)\n for line in stdout.readlines():\n print(line.strip())","def _connect(self):\n self.client = SSHClient()\n self.client.load_system_host_keys()\n self.client.set_missing_host_key_policy(AutoAddPolicy())\n self.client.connect(self.host,\n username=self.user,\n key_filename=self.filepath,\n look_for_keys=True,\n timeout=5000)\n self.scp = SCPClient(self.client.get_transport())","def docker_client():\n client = docker.from_env()\n return client","def _start_instance(self, resource_handler):\n log.debug('Starting container')\n cli = resource_handler.cli\n #host_config=cli.create_host_config(network_mode=self.network_mode)\n container = cli.create_container(\n image='{0.image}:{0.tag}'.format(self),\n command=self.command,\n #host_config=host_config,\n environment=self.env\n )\n\n cli.start(container.get('Id'))\n log.debug('Started container [%s]', container)\n return str(container)","def test_shell():\n platform = DockerPlatform(None, None)\n platform.pre_build()\n\n # Add node\n node1 = Node(identifier='host1', type='host')\n host1 = platform.add_node(node1)\n\n # Add ports\n p1 = BidirectionalPort(identifier='p1')\n platform.add_biport(host1, p1)\n p2 = BidirectionalPort(identifier='p2')\n platform.add_biport(host1, p2)\n p3 = BidirectionalPort(identifier='p3')\n platform.add_biport(host1, p3)\n\n platform.post_build()\n\n reply = host1('echo \"var\"')\n\n platform.destroy()\n\n assert 'var' in reply","def docker_client(request):\n client = docker.from_env()\n yield client\n client.close()","def cli_run(host_ip:str, linux_user:str, linux_password:str, cmd:str)->dict:\n try:\n c = Connection(linux_user + \"@\" + host_ip, connect_kwargs={'password':linux_password})\n return c.run(cmd, warn=True)\n except Exception as e:\n return {\"Error\": str(e)}","def connect_to_ssh_host(self, host, port = 22, user = \"omc\", passwd = \"omc\", prompt = \"\", timeout = \"60sec\"):\n if prompt == None or prompt == \"\":\n myprompt = '#'\n # myprompt = None\n else:\n myprompt = prompt\n\n conn = MySshLib(timeout, \"CR\", myprompt)\n conn.open_connection(host, port=port)\n conn.login(user, passwd)\n\n self._ssh_connections[conn] = 'Linux'\n self._current = conn\n self._current._prompt = myprompt\n\n return conn","def client():\n _, p, _ = docker_run_etcd_main()\n c = Client(host, p, protocol)\n yield c\n c.close()","def run_unix(host, port, ssh, command):\n if not host or not port:\n return -2\n\n ssh = [ssh,\n '-o', 'UserKnownHostsFile=/dev/null',\n '-o', 'StrictHostKeyChecking=no',\n '-p', port, host] + command\n\n _LOGGER.debug('Starting ssh: %s', ssh)\n os.execvp(ssh[0], ssh)","def ssh_to(srvname, srvport=22, srvuser='root'):\n xssh = subprocess.Popen(['/usr/bin/ssh', '-o', 'StrictHostKeyChecking=no', '-o',\n 'UserKnownHostsFile=/dev/null', '-p', str(srvport),\n '%s@%s' % (srvuser, srvname)])\n xssh.communicate()","def establish_connection(self):\r\n\r\n #creates SSH connection and adds SSH key to .known_hosts\r\n self.ssh_conn = paramiko.SSHClient()\r\n self.ssh_conn.set_missing_host_key_policy(paramiko.AutoAddPolicy())\r\n\r\n try:\r\n self.ssh_conn.connect(**self.conn_parm)\r\n print \"Connected to %s\" % self.conn_parm['hostname']\r\n #testing: self.ssh_conn.close()\r\n except socket.error:\r\n print \"Connection Failed on device %s\" % self.conn_parm['hostname']\r\n\r\n #find prompt\r\n open_session = self.ssh_conn.invoke_shell()\r\n output = open_session.recv(1000)\r\n\r\n #testing: print output\r\n\r\n #go into Enable-Mode if not already in it\r\n if '#' not in output:\r\n open_session.send('enable\\n')\r\n time.sleep(1)\r\n open_session.send(self.password)\r\n open_session.send('\\n')\r\n else:\r\n print \"In Enable-Mode\"\r\n\r\n #turn off paging\r\n open_session.send('terminal length 0\\n')\r\n time.sleep(3)\r\n \r\n return open_session","def getSSHConnection(host):\n try:\n ssh = SSHWrapper()\n ssh.connect(host.getID())\n return ssh\n except:\n return None","def connect_to_server(username, server='euler.ethz.ch'):\n ssh = SSHClient()\n ssh.set_missing_host_key_policy(AutoAddPolicy())\n try:\n ssh.connect(server, username=username)\n print('Connected to {0}\\n'.format(server))\n except:\n print('Connection failed\\n')\n return ssh","def ssh(self) -> pulumi.Input['ContainerServiceSshConfigurationArgs']:\n return pulumi.get(self, \"ssh\")","def sshtest():\n vbox = Vbox(env.vm_name)\n print vbox.ssh_up","def test_ssh(self):\n self._test_ssh(self.git_ssh_path)","def docker_client():\n return docker.from_env()","def salt_ssh_cli(\n self,\n factory_class=cli.ssh.SaltSsh,\n roster_file=None,\n target_host=None,\n client_key=None,\n ssh_user=None,\n **factory_class_kwargs,\n ):\n script_path = self.factories_manager.get_salt_script_path(\"salt-ssh\")\n return factory_class(\n script_name=script_path,\n config=self.config.copy(),\n roster_file=roster_file,\n target_host=target_host,\n client_key=client_key,\n ssh_user=ssh_user or running_username(),\n system_service=self.factories_manager.system_service,\n python_executable=self.python_executable,\n **factory_class_kwargs,\n )","def ssh(remoteAddress, remoteCommand, outputPrefix=\"ssh> \"):\n command = [\"ssh\", remoteAddress, \"-t\", \"-o\", \"StrictHostKeyChecking=no\", remoteCommand]\n\n proc = ProcessRunner(command)\n proc.mapLines(WriteOut(sys.stdout, outputPrefix=outputPrefix), procPipeName=\"stdout\")\n proc.mapLines(WriteOut(sys.stderr, outputPrefix=outputPrefix), procPipeName=\"stderr\")\n proc.wait()\n returnCode = proc.poll()\n\n # proc.terminate()\n # proc.shutdown()\n\n return returnCode","async def client_ssh_handler(process):\n log.debug(f\"clients.py:client_ssh_handler - SSH details are: {dir(process)}\")\n reader = process.stdin\n writer = process.stdout\n client_details = process.get_extra_info(\"peername\")\n addr, port, *rest = client_details\n\n connection = PlayerConnection(addr, port, \"ssh\")\n\n await register_client(connection)\n\n tasks = [\n asyncio.create_task(client_read(reader, connection), name=f\"{connection.uuid} read\"),\n asyncio.create_task(client_write(writer, connection), name=f\"{connection.uuid} write\"),\n ]\n\n asyncio.current_task().set_name(f\"{connection.uuid} handler\")\n\n # We want to .wait until the first task is completed. Completed could be an actual finishing\n # of execution or an exception. If either the read or writer \"completes\", we want to ensure\n # we move beyond this point and cleanup the tasks associated with this client.\n _, rest = await asyncio.wait(tasks, return_when=\"FIRST_COMPLETED\")\n\n await unregister_client(connection)\n\n process.close()\n process.exit(0)\n\n for task in rest:\n task.cancel()","def connect(self):\n try:\n self.connector = paramiko.SSHClient()\n self.connector.set_missing_host_key_policy(\n paramiko.AutoAddPolicy())\n self.connector.connect(\n hostname=self.host,\n username=self.username,\n password=self.password)\n\n channel = self.connector.invoke_shell()\n self.stdin_stream = channel.makefile(WRITE)\n self.stdout_stream = channel.makefile(READ)\n self.stderr_stream = channel.makefile(READ)\n\n except Exception as e:\n LOG.exception(_LE(\"Connect failed to switch %(host)s with error\"\n \" %(error)s\"),\n {'host': self.host, 'error': e.args})\n raise Exception(_(\"Connection Failed\"))","def get_ssh():\n\n ip = str(sc.sticky[\"SSH\"]['ip'])\n port = str(sc.sticky[\"SSH\"]['port'])\n user = str(sc.sticky[\"SSH\"]['user'])\n pw = str(sc.sticky[\"SSH\"]['password'])\n\n ssh_dict = {'ip': ip, 'port': port, 'user': user, 'password': pw}\n\n return ssh_dict","def run_cmd_on_the_nas_with_ssh(driver, cmd):\n global results\n results = ssh_cmd(cmd, 'root', 'testing', host)\n assert results['result'], f'STDOUT: {results[\"output\"]}, STDERR: {results[\"stderr\"]}'","def _getSshCmdAndSecrets(hostname, user, sshId, reuseCon):\n\n sshCmdSecrets = []\n\n if sshId:\n sshCmd = f'ssh -i {sshId}'\n\n elif user.password:\n sshCmd = 'sshpass -v -p :0: ssh'\n sshCmdSecrets += [user.password]\n\n else:\n sshCmd = 'ssh'\n\n sshCmd += ' -o StrictHostKeyChecking=no'\n\n if reuseCon:\n sshCmd += ' -o ControlMaster=auto'\n sshCmd += f' -o ControlPath={CmdSsh._getSocketPath()}'\n sshCmd += ' -o ControlPersist=600'\n\n # Need to separate login part for use with 'rsync -e'\n\n sshLogin = f'{user.name}@{hostname}'\n\n return sshCmd, sshLogin, sshCmdSecrets"],"string":"[\n \"def open_sshclient(host, user, port, secret):\\n ssh_client = paramiko.SSHClient()\\n ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n ssh_client.load_system_host_keys()\\n if secret and port:\\n ssh_client.connect(hostname=host, username=user, password=secret, port=port)\\n elif secret and port==0:\\n ssh_client.connect(hostname=host, username=user, password=secret)\\n elif not secret and port:\\n ssh_client.connect(hostname=host, username=user, port=port)\\n else:\\n ssh_client.connect(hostname=host, username=user)\\n return ssh_client\",\n \"def create_client(host, user, password):\\n client = paramiko.client.SSHClient()\\n client.set_missing_host_key_policy(paramiko.AutoAddPolicy)\\n client.connect(hostname=host, username=user, password=password, timeout=60)\\n return client\",\n \"def create_ssh_client(self, hostname, username, password):\\n if self.ssh_client is None:\\n self.ssh_client = paramiko.SSHClient()\\n self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n self.ssh_client.connect(hostname, username=username, password=password)\\n else:\\n print(\\\"SSH client session exist.\\\")\",\n \"def sshclient_from_instance(instance, ssh_key_file,\\r\\n host_key_file='~/.ssh/known_hosts',\\r\\n user_name='root', ssh_pwd=None):\\r\\n s = FakeServer(instance, ssh_key_file)\\r\\n return SSHClient(s, host_key_file, user_name, ssh_pwd)\",\n \"def connect_instance(tag, key_name, user_name):\\n inst = get_instance(tag)\\n cmd = boto.manage.cmdshell.sshclient_from_instance(\\n inst,\\n SSH_FOLDER + key_name + \\\".pem\\\",\\n user_name=user_name\\n )\\n return inst, cmd\",\n \"def openSSH(target, user):\\r\\n ssh = paramiko.SSHClient()\\r\\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\r\\n ssh.connect(target, username=user)\\r\\n return ssh\",\n \"def ssh():\\n vbox = Vbox(env.vm_name)\\n with vbox as session:\\n session.wait_for_ssh()\\n open_shell()\",\n \"def create_ssh_handle(xcnode):\\n client = paramiko.SSHClient()\\n client.load_system_host_keys()\\n client.set_missing_host_key_policy(paramiko.WarningPolicy)\\n\\n try:\\n client.connect(\\n hostname=xcnode.hostname,\\n username=xcnode.username,\\n password=xcnode.password,\\n port=int(xcnode.port)\\n )\\n xcnode.fd.write('ssh\\\\'ed to {} @ {}\\\\n'.format(\\n xcnode.hostname, datetime.now()))\\n except Exception as e:\\n print e\\n client = None\\n\\n xcnode.client = client\\n\\n return xcnode\",\n \"def ssh(host_=None):\\n run_command_on_selected_server(open_shell, host_=host_)\",\n \"def _get_sshclient(host_name, ip, port=22):\\n ssh_clt = paramiko.SSHClient()\\n # Allow connection not in the known_host\\n ssh_clt.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n ssh_clt.connect(ip, port, host_name,\\n key_filename=conf.SSH_KEY_ARGS['path'])\\n return ssh_clt\",\n \"def connect(self,host, container):\\n logging.debug(\\\"\\\")\\n logging.debug(\\\"************************************************************\\\")\\n attempts = 3\\n count = 0\\n while attempts:\\n attempts -= 1\\n count +=1\\n try:\\n if attempts > 0:\\n print \\\"Attempting Connection to %s (%i/%i)\\\" % (host, count, attempts)\\n logging.debug(\\\"\\\\t connecting to %s@%s\\\" % (args.user, host))\\n ssh = paramiko.SSHClient()\\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n ssh.connect(\\n host,\\n username=args.user,\\n port=22,\\n allow_agent=True,\\n look_for_keys=True,\\n timeout=5\\n )\\n logging.debug(\\\"Connected to %s\\\" % (host))\\n chan = ssh.invoke_shell()\\n # print(repr(ssh.get_transport()))\\n if not container:\\n logging.debug(\\\"*** Initiating Interactive Session\\\")\\n interactive().rshell(chan)\\n logging.debug(\\\"Closing SSH session to %s\\\" % (host))\\n chan.close()\\n interactive().disconnect()\\n break\\n else:\\n print \\\"Max Connection attempts reached (%i/%i)\\\" % (count, attempts)\\n logging.debug(\\\"Exiting with code 3\\\")\\n sys.exit(3)\\n except paramiko.AuthenticationException:\\n print \\\"Authentication failed when connecting to %s\\\" % (host)\\n sys.exit(1)\\n except:\\n print \\\"Connection (%i/%i) failed to %s, waiting 5s retry\\\" % (count, attempts, host)\\n time.sleep(5)\",\n \"def create_sftp_client(ssh_client):\\n sftp_client = ssh_client.open_sftp()\\n return sftp_client\",\n \"def connect(self, instance):\\n client = sshclient.SSHClient()\\n client.set_missing_host_key_policy(sshclient.AutoAddPolicy())\\n client.connect(instance.ip_address, username=\\\"core\\\",\\n key_filename=self._ssh_keyfile)\\n return client\",\n \"def _ssh_connect():\\n client = paramiko.SSHClient()\\n client.load_system_host_keys()\\n client.set_missing_host_key_policy(paramiko.WarningPolicy)\\n\\n client.connect(**SSH_CONFIG)\\n yield client\\n\\n client.close()\",\n \"def connect_to_remote_host(host, username, password):\\n ssh_client = paramiko.SSHClient()\\n ssh_client.load_system_host_keys()\\n ssh_client.connect(host, username=username, password=password)\\n return ssh_client\",\n \"def cli(ctx, host, user, no_ask):\\n from ._ssh import open_ssh\\n from .vdi import vdi_ctl\\n\\n try:\\n ssh, ssh_cfg = open_ssh(host, user, no_ask=no_ask)\\n except:\\n click.echo('Failed to connect to \\\"{}{}\\\"'.format(user+'@' if user else '', host))\\n ctx.exit()\\n\\n ctl = vdi_ctl(ssh)\\n\\n ctx.obj = Ctx(ssh=ssh, ssh_cfg=ssh_cfg, ctl=ctl)\",\n \"def common_setup(ssh_client):\\n with open_cfg() as cfg:\\n delete_hdfs = cfg.getboolean('main', 'delete_hdfs')\\n # preliminary steps required due to differences between azure and aws\\n if c.PROVIDER == \\\"AZURE\\\":\\n\\n # todo only if first run\\n if c.NUM_INSTANCE > 0 or True:\\n print(\\\"In common_setup, NUM_INSTANCE=\\\" + str(c.NUM_INSTANCE))\\n # add ssh key that matches the public one used during creation\\n if not c.PRIVATE_KEY_NAME in ssh_client.listdir(\\\"/home/ubuntu/.ssh/\\\"):\\n ssh_client.put(localpath=c.PRIVATE_KEY_PATH, remotepath=\\\"/home/ubuntu/.ssh/\\\" + c.PRIVATE_KEY_NAME)\\n ssh_client.run(\\\"chmod 400 /home/ubuntu/.ssh/\\\" + c.PRIVATE_KEY_NAME)\\n\\n # ssh_client.run(\\\"sudo groupadd supergroup\\\")\\n ssh_client.run(\\\"sudo usermod -aG supergroup $USER\\\")\\n ssh_client.run(\\\"sudo usermod -aG supergroup root\\\")\\n\\n # join docker group\\n ssh_client.run(\\\"sudo usermod -aG docker $USER\\\")\\n\\n ssh_client.run(\\\"mkdir /usr/local/spark/spark-events\\\")\\n\\n # ssh_client.run(\\\"sudo chmod -R 777 /mnt\\\")\\n\\n # to refresh groups\\n ssh_client.close()\\n ssh_client.connect()\\n\\n # restore environmental variables lost when creating the image\\n ssh_client.run(\\\"echo 'export JAVA_HOME=/usr/lib/jvm/java-8-oracle' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_INSTALL=/usr/local/lib/hadoop-2.7.2' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export PATH=$PATH:$HADOOP_INSTALL/bin' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export PATH=$PATH:$HADOOP_INSTALL/sbin' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_MAPRED_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_COMMON_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_HDFS_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export YARN_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_INSTALL/lib/native/' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_OPTS=\\\\\\\"-Djava.library.path=$HADOOP_INSTALL/lib/native\\\\\\\"' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\n \\\"echo 'export LD_LIBRARY_PATH=$HADOOP_INSTALL/lib/native:$LD_LIBRARY_PATH' >> $HOME/.bashrc\\\") # to fix \\\"unable to load native hadoop lib\\\" in spark\\n\\n ssh_client.run(\\\"source $HOME/.bashrc\\\")\\n\\n if c.PROVIDER == \\\"AWS_SPOT\\\":\\n ssh_client.run(\\\"echo 'export JAVA_HOME=/usr/lib/jvm/java-8-oracle' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_INSTALL=/usr/local/lib/hadoop-2.7.2' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export PATH=$PATH:$HADOOP_INSTALL/bin' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export PATH=$PATH:$HADOOP_INSTALL/sbin' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_MAPRED_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_COMMON_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_HDFS_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export YARN_HOME=$HADOOP_INSTALL' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_INSTALL/lib/native' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\\"echo 'export HADOOP_OPTS=\\\\\\\"-Djava.library.path=$HADOOP_INSTALL/lib/native\\\\\\\"' >> $HOME/.bashrc\\\")\\n ssh_client.run(\\n \\\"echo 'export LD_LIBRARY_PATH=$HADOOP_INSTALL/lib/native:$LD_LIBRARY_PATH' >> $HOME/.bashrc\\\") # to fix \\\"unable to load native hadoop lib\\\" in spark\\n ssh_client.run(\\\"source $HOME/.bashrc\\\")\\n \\n ssh_client.run(\\\"export GOMAXPROCS=`nproc`\\\")\\n\\n if c.UPDATE_SPARK_DOCKER:\\n print(\\\" Updating Spark Docker Image...\\\")\\n ssh_client.run(\\\"docker pull elfolink/spark:2.0\\\")\\n\\n if delete_hdfs:\\n ssh_client.run(\\\"sudo umount /mnt\\\")\\n ssh_client.run(\\n \\\"sudo mkfs.ext4 -E nodiscard \\\" + c.TEMPORARY_STORAGE + \\\" && sudo mount -o discard \\\" + c.TEMPORARY_STORAGE + \\\" /mnt\\\")\\n\\n ssh_client.run(\\\"test -d /mnt/tmp || sudo mkdir -m 1777 /mnt/tmp\\\")\\n ssh_client.run(\\\"sudo mount --bind /mnt/tmp /tmp\\\")\\n\\n ssh_client.run('ssh-keygen -f \\\"/home/ubuntu/.ssh/known_hosts\\\" -R localhost')\\n\\n print(\\\" Stop Spark Slave/Master\\\")\\n # ssh_client.run('export SPARK_HOME=\\\"{s}\\\" && {s}sbin/stop-slave.sh'.format(s=c.SPARK_HOME))\\n ssh_client.run('export SPARK_HOME=\\\"{s}\\\" && {s}sbin/stop-master.sh'.format(s=c.SPARK_HOME))\\n ssh_client.run('export SPARK_HOME=\\\"{s}\\\" && sudo {s}sbin/stop-slave.sh'.format(s=c.SPARK_HOME))\\n \\n stdout, stderr, status = ssh_client.run(\\n \\\"cd \\\" + c.SPARK_HOME + \\\" && cp conf/log4j.properties.template conf/log4j.properties\\\")\\n print(stdout, stderr)\\n print(\\\" Set Log Level\\\")\\n ssh_client.run(\\n \\\"sed -i '19s/.*/log4j.rootCategory={}, console /' {}conf/log4j.properties\\\".format(c.LOG_LEVEL,\\n c.SPARK_HOME))\\n if c.KILL_JAVA:\\n print(\\\" Killing Java\\\")\\n ssh_client.run('sudo killall java && sudo killall java && sudo killall java')\\n\\n print(\\\" Kill SAR CPU Logger\\\")\\n ssh_client.run(\\\"screen -ls | grep Detached | cut -d. -f1 | awk '{print $1}' | xargs -r kill\\\")\\n\\n if c.SYNC_TIME:\\n print(\\\" SYNC TIME\\\")\\n ssh_client.run(\\\"sudo ntpdate -s time.nist.gov\\\")\\n\\n print(\\\" Removing Stopped Docker\\\")\\n ssh_client.run(\\\"docker ps -a | awk '{print $1}' | xargs --no-run-if-empty docker rm\\\")\",\n \"def _build_ssh_client(self):\\n # Create instance of SSHClient object\\n # If not using SSH keys, we use noauth\\n if not self.use_keys:\\n remote_conn_pre = SSHClient_noauth()\\n else:\\n remote_conn_pre = SSHClient()\\n\\n # Load host_keys for better SSH security\\n if self.system_host_keys:\\n remote_conn_pre.load_system_host_keys()\\n if self.alt_host_keys and path.isfile(self.alt_key_file):\\n remote_conn_pre.load_host_keys(self.alt_key_file)\\n\\n # Default is to automatically add untrusted hosts (make sure appropriate for your env)\\n remote_conn_pre.set_missing_host_key_policy(self.key_policy)\\n return remote_conn_pre\",\n \"def docker_enter(self, user, host, container):\\n import os\\n logging.debug(\\\"\\\")\\n logging.debug(\\\"************************************************************\\\")\\n ssh_host = user+\\\"@\\\"+host\\n ssh_timeout = \\\"5\\\"\\n ssh_options = \\\"-A -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o ConnectTimeout=\\\"+ssh_timeout+\\\" -o ConnectionAttempts=1 -tt\\\"\\n docker_cmd = \\\"\\\\\\\"/opt/bin/docker-enter \\\"+container+\\\"\\\\\\\" \\\"\\n cmd = \\\"ssh \\\"+ssh_options+\\\" \\\"+ssh_host+\\\" \\\"+docker_cmd\\n logging.debug(\\\"Executing Command: %s\\\" % (cmd))\\n returned = os.system(cmd)\\n logging.debug(\\\"docker_enter func Exiting with code %i\\\" % (returned))\\n sys.exit(returned)\",\n \"def editor_cloud9_ssh_command():\\n docker_vars = _editor_cloud9_docker_vars()\\n print \\\"ssh -p %s -i private/ssh/id_rsa_devbox root@%s\\\" % (docker_vars['public_ssh_port'], env.host)\",\n \"def ssh_cmd(ctx):\\n pass\",\n \"def setup_machine():\\n client = docker.from_env()\\n if client.info().get(\\\"ServerVersion\\\") < \\\"18.09.2\\\":\\n raise (\\\"Docker server needs to be at least 18.09.2\\\")\\n ssh_path = os.path.join(expanduser(\\\"~\\\"), \\\".ssh\\\")\\n cloud_path = os.path.join(ssh_path, \\\"cloud_keys\\\")\\n config_path = os.path.join(cloud_path, \\\"config\\\")\\n bash(\\\"mkdir -p {}\\\".format(cloud_path))\\n bash(\\\"cp ~/.ssh/config ~/.ssh/{}/config\\\".format(\\\"cloud_keys\\\"))\\n bash(\\\"sed -i '' '/.*UseKeychain.*/d' ~/.ssh/cloud_keys/config\\\")\\n bash(\\\"sed -i '' '/.*ControlPath .*/d' ~/.ssh/cloud_keys/config\\\")\\n\\n config = \\\"\\\"\\\"\\n Host *\\n ControlPath /tmp/master-%r@%h:%p\\n User {}\\n \\\"\\\"\\\".format(\\n getpass.getuser()\\n )\\n with open(config_path, \\\"r\\\") as h:\\n conents = h.read()\\n with open(config_path, \\\"w\\\") as h:\\n h.write(config)\\n with open(config_path, \\\"a\\\") as h:\\n h.write(conents)\\n keys = [\\n splitext(x)[0]\\n for x in glob.glob(os.path.join(ssh_path, \\\"*.pub\\\"))\\n if not x.endswith(\\\"-cert.pub\\\") # filter out signed keys\\n ]\\n for key in keys:\\n if not os.path.isfile(key):\\n logger.warning(\\\"No private key for {}, skipping\\\".format(key))\\n else:\\n logger.info(\\\"Adding key {}\\\".format(key))\\n dest = os.path.join(cloud_path, basename(key))\\n if os.path.lexists(dest) is False:\\n bash(\\\"cp {} {}\\\".format(key, dest))\",\n \"def ssh():\\n env['remote_port'] = env['port_map']['22']\\n\\n sys.stdout.write('Connecting to SSH session on remote port %(remote_port)s\\\\n' % env)\\n\\n run('chmod 600 %(pair_private_key)s' % env)\\n\\n client = paramiko.SSHClient()\\n client.load_system_host_keys()\\n client.connect(\\n hostname=env['relay_server'],\\n port=int(env['remote_port']),\\n username=env['pair_user'],\\n key_filename=env['pair_private_key']\\n )\\n\\n channel = client.invoke_shell()\\n posix_shell(channel)\",\n \"def ssh_connect(cf):\\n try:\\n ssh = paramiko.SSHClient()\\n ssh.load_system_host_keys()\\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n ssh.connect(cf.server,username=cf.username)\\n print(\\\"Connected to %s\\\" % cf.server)\\n except paramiko.AuthenticationException as e:\\n print(\\\"Authentication failed when connecting to %s\\\" % cf.server)\\n print(\\\"error:\\\",e)\\n sys.exit(1)\\n except Exception as e:\\n print(\\\"Couldn't establish an ssh connection to %s\\\" % cf.server)\\n print(\\\"error:\\\", e)\\n sys.exit(1)\\n\\n return ssh\",\n \"def ssh_call ( server, identity, cmd ) :\\n print \\\"Running SSH command on server \\\" + server + \\\": \\\" + cmd\\n return subprocess.call( [ \\\"ssh\\\",\\n ssh_opt,\\n \\\"-tt\\\",\\n \\\"-i\\\",\\n identity,\\n \\\"ec2-user@\\\" + server,\\n cmd ] )\",\n \"def get_ssh_client(self, ip, username, password, retries=10):\\n try:\\n ssh_client = SshClient(ip, 22, username, password, retries)\\n except Exception as e:\\n raise unittest.SkipTest(\\\"Unable to create ssh connection: \\\" % e)\\n\\n self.assertIsNotNone(\\n ssh_client, \\\"Failed to setup ssh connection to ip=%s\\\" % ip)\\n\\n return ssh_client\",\n \"def open_ssh():\\n print('Opening SSH...')\",\n \"def _new_client(self) -> paramiko.SSHClient:\\n ssh = paramiko.SSHClient()\\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n self._paramiko_client = ssh\\n return self._paramiko_client\",\n \"def sendcommand(sshclient, ip, user, password, commands):\\n\\n # Trying to establish the SSH session, using a timeout of 3 seconds\\n sshclient.connect(ip, username=user, password=password,\\n look_for_keys=False, allow_agent=False, timeout=3)\\n # To execute commands we'll need an input shell to execute them against\\n sshsession = sshclient.invoke_shell()\\n # Read current output buffer for hostname extraction.\\n # Expected is something like 'hostname#'\\n hostname = sshsession.recv(1000)\\n # Decode output to UTF-8 encoding\\n hostname = hostname.decode('utf-8')\\n # Replace whitespaces and the expected '#' from the prompt with nothing\\n hostname = hostname.replace('\\\\r\\\\n', '').replace('#', '')\\n # Execute 'nopaging' function to disable paging\\n nopaging(sshsession)\\n # Run each command in commands list against the current session, using\\n # a sleep timer of 3s after each command.\\n for command in commands:\\n command = textwrap.wrap(command)[0]\\n sshsession.send(command)\\n # Don't forget to press 'Enter' after each command. This will do.\\n sshsession.send('\\\\n')\\n # Might need more time for commands like 'show tech' but 3s should\\n # do fine for most outputs.\\n time.sleep(3)\\n\\n # Flush current output into output variable. Might need adjustment for\\n # larger outputs.\\n output = sshsession.recv(100000)\\n # Say goodbye to the device.\\n sshclient.close()\\n\\n # Return the SSH output and extracted hostname\\n return output, hostname\",\n \"def ssh(pi):\\n command = \\\"ssh {0}\\\".format(pi)\\n subprocess.Popen(command, shell=True)\",\n \"def quick_execute(command,ssh_host=None,username=None,password=None,interactive=False,stdin=None,stdout=sys.stdout,stderr=sys.stderr,ignore_password=False):\\n sce = SSHCommandExecutor()\\n sce.ssh_host(ssh_host)\\n sce.username(username)\\n sce.password(password)\\n sce.prompt_for_missing(ignore_password=ignore_password)\\n sce.quick_execute(command,interactive=interactive,stdin=stdin,stdout=stdout,stderr=stderr)\\n return sce\",\n \"def bdocker(ctx, host):\\n ctx.obj = commands.CommandController(endpoint=host)\",\n \"def init():\\n\\n @click.command()\\n @click.option('--cell', required=True,\\n envvar='TREADMILL_CELL',\\n callback=cli.handle_context_opt,\\n expose_value=False)\\n @click.option('--ssh', help='SSH client to use.',\\n type=click.Path(exists=True, readable=True))\\n @click.argument('app')\\n @click.argument('command', nargs=-1)\\n def ssh(ssh, app, command):\\n \\\"\\\"\\\"SSH into Treadmill container.\\\"\\\"\\\"\\n if ssh is None:\\n ssh = _DEFAULT_SSH\\n\\n if app.find('#') == -1:\\n # Instance is not specified, list matching and exit.\\n raise click.BadParameter('Specify full instance name: xxx#nnn')\\n\\n app_discovery = discovery.Discovery(context.GLOBAL.zk.conn, app, 'ssh')\\n app_discovery.sync()\\n\\n # Restore default signal mask disabled by python spawning new thread\\n # for Zk connection.\\n #\\n # TODO: should this be done as part of zkutils.connect?\\n for sig in range(1, signal.NSIG):\\n try:\\n signal.signal(sig, signal.SIG_DFL)\\n except OSError:\\n pass\\n\\n # TODO: not sure how to handle mutliple instances.\\n for (app, hostport) in app_discovery.items():\\n _LOGGER.info('%s :: %s', app, hostport)\\n if hostport:\\n host, port = hostport.split(b':')\\n run_ssh(host, port, ssh, list(command))\\n\\n return ssh\",\n \"def open_connection_ssh():\\n\\tssh_server = config_basic.config_ssh_server()\\n\\tssh_username = config_basic.config_ssh_username()\\n\\tssh_password = config_basic.config_ssh_password()\\n\\tconnection = SSH(ssh_server, ssh_username, ssh_password)\\n\\treturn connection\",\n \"def _exec_command_in_container(client, container, command):\\n exec_id = client.exec_create(container, command)\\n output = client.exec_start(exec_id).decode('utf-8')\\n logger.info(output)\\n return output\",\n \"def connect(self, hostip, username, password, port, command):\\n client = paramiko.SSHClient()\\n client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n client.connect(hostip, username = username, password = password, port=port)\\n (stdin, stdout, stderr) = client.exec_command(command)\\n stdin.close()\\n return stdin, stdout, stderr\",\n \"def _connect(self):\\n ssh = paramiko.SSHClient()\\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n ssh.connect(\\n self.hostname,\\n username=self.user,\\n port=self.port,\\n pkey=get_pkey(self.issho_conf[\\\"RSA_ID_PATH\\\"]),\\n )\\n return ssh\",\n \"def execute_over_ssh(cmd, ssh, cwd=None, shell='bash'):\\n port = None\\n parts = ssh.split(':', 1)\\n if len(parts) > 1:\\n port = parts[1]\\n quoted_cmd = ' '.join([x.replace(\\\"'\\\", \\\"\\\"\\\"'\\\"'\\\"'\\\"\\\"\\\") for x in cmd.split(' ')])\\n remote_cmd = ' '.join([\\n ' '.join(get_shell(shell)), # /usr/bin/env bash\\n ' '.join([EXECUTE_SHELL_PARAM, \\\"'\\\", ' '.join((['cd', cwd, ';'] if cwd else []) + [quoted_cmd]), \\\"'\\\"])],\\n )\\n return ['ssh', parts[0]] + (['-p', port] if port else []) + ['-C'] + [remote_cmd]\",\n \"def install_ssh(app):\\n os.system('lxc-attach -n %s -- apk update' % app)\\n os.system('lxc-attach -n %s -- apk add openssh' % app)\\n # Config sshd\\n config = '/var/lib/lxc/%s/rootfs/etc/ssh/sshd_config' % app\\n with open(config, \\\"a\\\") as myfile:\\n myfile.write(\\\"RSAAuthentication yes\\\\nPubkeyAuthentication yes\\\\nPermitRootLogin yes\\\\nPermitEmptyPasswords yes\\\")\\n os.system('lxc-attach -n %s -- /etc/init.d/sshd start' % app)\",\n \"def _ssh(self, command, use_pwd=True, use_tty=False, forward_x=False, verbose=False):\\n if use_pwd:\\n cd_cmd = 'cd cluster_test_%d; ' % self.address[1]\\n else:\\n cd_cmd = ''\\n ssh = ['ssh',\\n '-o', 'UserKnownHostsFile=/dev/null',\\n '-o', 'StrictHostKeyChecking=no',\\n '-o', 'IdentitiesOnly=yes']\\n if self.key_file:\\n ssh.extend(['-i', self.key_file])\\n if use_tty:\\n ssh.extend(['-t'])\\n \\n if forward_x:\\n ssh.extend(['-Y'])\\n \\n ssh.extend([self.user_name + '@' + self.address[0], cd_cmd + command])\\n \\n if verbose: print(\\\" \\\".join(ssh))\\n \\n # Check whether ssh runs successfully.\\n if subprocess.call(ssh) == 0:\\n return True\\n else:\\n return False\",\n \"def run_curl_command(ssh_client):\\n _, stdout, _ = ssh_client.exec_command('curl http://127.0.0.1:5000/api/v1/')\\n while not stdout.channel.exit_status_ready() and not stdout.channel.recv_ready():\\n time.sleep(1)\\n response = stdout.readlines()\\n return response\",\n \"def cli(context):\\n dev = f\\\"docker run -it -v {PWD}:/local {IMAGE_NAME}:{IMAGE_VER} /bin/bash\\\"\\n print(f\\\"{dev}\\\")\\n context.run(f\\\"{dev}\\\", pty=True)\",\n \"def main():\\n # Set these to your own details.\\n myssh = connect('example.com')\\n myssh.put('ssh.py')\\n myssh.close()\",\n \"def ssh(ssh, app, command):\\n if ssh is None:\\n ssh = _DEFAULT_SSH\\n\\n if app.find('#') == -1:\\n # Instance is not specified, list matching and exit.\\n raise click.BadParameter('Specify full instance name: xxx#nnn')\\n\\n app_discovery = discovery.Discovery(context.GLOBAL.zk.conn, app, 'ssh')\\n app_discovery.sync()\\n\\n # Restore default signal mask disabled by python spawning new thread\\n # for Zk connection.\\n #\\n # TODO: should this be done as part of zkutils.connect?\\n for sig in range(1, signal.NSIG):\\n try:\\n signal.signal(sig, signal.SIG_DFL)\\n except OSError:\\n pass\\n\\n # TODO: not sure how to handle mutliple instances.\\n for (app, hostport) in app_discovery.items():\\n _LOGGER.info('%s :: %s', app, hostport)\\n if hostport:\\n host, port = hostport.split(b':')\\n run_ssh(host, port, ssh, list(command))\",\n \"def ssh(cmds, bastion_ip, host, username, pem_key):\\n cmd = \\\"ssh -i %s %s@%s\\\" % (pem_key, username, host)\\n if bastion_ip:\\n cmd = \\\"ssh -F ssh_config-metrics %s\\\" % (host)\\n parts = cmd.split(' ')\\n parts.append(';'.join(cmds))\\n CONSOLE.debug(json.dumps(parts))\\n ret_val = subprocess_to_log.call(parts, LOG, host, scan_for_errors=[\\n r'lost connection', r'\\\\s*Failed:\\\\s*[1-9].*'])\\n if ret_val != 0:\\n raise Exception(\\\"Error running ssh commands on host %s. See debug log (%s) for details.\\\" % (\\n host, LOG_FILE_NAME))\",\n \"def docker_exec(self, verbose=False):\\n # command = '\\\\'/usr/bin/docker exec -it `/usr/bin/docker ps --filter \\\"name=ecs-{}*\\\" -q` bash \\\\''\\n command = self.provider.get_docker_exec_sub_command()\\n command = command.format(self.service.family)\\n self.ssh(command, is_running=True, verbose=verbose)\",\n \"def ssh_cmd(ip=None, port=2222, username=os.environ['USER'], password=None, cmd='id'):\\n # define client instance and set host key to autoadd - YOLO!\\n client = paramiko.SSHClient()\\n client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n # connect\\n client.connect(hostname=ip, port=port, username=username, password=password, passphrase='')\\n # get a session from our connection\\n ssh_session = client.get_transport().open_session()\\n\\n if ssh_session.active:\\n ssh_session.send(cmd)\\n print(ssh_session.recv(4096).decode(\\\"utf-8\\\"))\\n\\n while ssh_session.active:\\n cmd = ssh_session.recv(4096)\\n # get the command from \\\"ssh server\\\"\\n try:\\n cmd_out = subprocess.check_output(cmd, shell=True)\\n ssh_session.send(cmd_out)\\n except Exception as ex:\\n ssh_session.send(str(ex))\\n\\n client.close()\\n\\n return\",\n \"def __init__(__self__, *,\\n admin_username: pulumi.Input[str],\\n ssh: pulumi.Input['ContainerServiceSshConfigurationArgs']):\\n pulumi.set(__self__, \\\"admin_username\\\", admin_username)\\n pulumi.set(__self__, \\\"ssh\\\", ssh)\",\n \"def _start_ssh(self):\\n try:\\n message = '\\\\nEnter number you want to connect: '\\n num = raw_input(message)\\n while not int(num) in self.instance_list:\\n num = raw_input(message)\\n\\n message_user = 'Enter username for ssh_login(blank = %s): ' % DEFAULT_USER \\n user = raw_input(message_user)\\n if not user:\\n user = DEFAULT_USER\\n \\n target = self.instance_list[int(num)]\\n ssh_key_path = os.path.join(SSH_DIR, target['key'])\\n if not os.path.exists(ssh_key_path):\\n print 'SSH key not found! KEY_PATH[ %s ]' % ssh_key_path\\n return\\n\\n command = COMMAND % {'sshkey' : ssh_key_path, 'user' : user, 'server' : target['dns'], 'port' : self.port}\\n\\n print 'Connecting to \\\"%s\\\"... [SSH COMMAND: %s ]' % (target['name'], command)\\n os.system(command)\\n except KeyboardInterrupt:\\n print '\\\\nAborted!'\\n finally:\\n sys.exit()\",\n \"def _connect(self):\\n self.ssh_conn = paramiko.SSHClient()\\n if self.debug:\\n self.ssh_conn.log = paramiko.common.logging.basicConfig(\\n level=paramiko.common.DEBUG)\\n # \\\"known_hosts\\\" is ignored, so there's no potential for mismatched keys\\n self.ssh_conn.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n # The default for allow_agent (False) breaks SSH to some devices\\n self.ssh_conn.connect(self.device, username=self.username,\\n password=self.passwd, allow_agent=False)\\n self.ssh_shell = self.ssh_conn.invoke_shell()\\n self.ssh_shell.set_combine_stderr(True)\\n self.ssh_shell.setblocking(True)\",\n \"def docker_sh():\\n docker_exec('/bin/bash')\",\n \"def run_in_docker(image, commands): # pragma: no cover\\n repo_dir = os.path.abspath(os.path.join(__file__, '../../'))\\n mount_option = '{}:/mnt:ro'.format(repo_dir)\\n\\n cmd = ('docker', 'run', '-v', mount_option, '-i', image, 'sh')\\n proc = subprocess.Popen(\\n cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,\\n )\\n\\n lines = '\\\\n'.join(commands)\\n return proc.communicate(lines.encode('utf-8'))[0].decode('utf-8')\",\n \"def open_ssh_tunnel(log, config, server, ssh_port=622, timeout=5, ipc_wait_file=5):\\n\\n user = config[\\\"user\\\"]\\n\\n # server must be visable for now\\n try:\\n server_info = socket.gethostbyaddr(server)\\n except socket.herror:\\n raise TunnelError(\\\"host %s is inaccessible\\\" % server)\\n except socket.gaierror as e:\\n raise TunnelError(str(e))\\n\\n # make sure the kernel isn't on localhost\\n if server_info[0] == \\\"localhost\\\":\\n log(\\\"kernel on localhost - nothing to do\\\")\\n return\\n\\n # no gui password prompt\\n env = os.environ.copy()\\n env.pop(\\\"SSH_ASKPASS\\\", None)\\n\\n if try_ssh(log, server, ssh_port, env):\\n mode = \\\"ssh\\\"\\n elif try_mrsh(log, server, ssh_port, env):\\n mode = \\\"mrsh\\\"\\n else:\\n raise TunnelError(\\\"Unable to connect, tried ssh and mrsh\\\")\\n\\n protocol = config[\\\"protocol\\\"]\\n\\n # remote (r) ports are the ports for the machine hosting the kernel\\n if protocol == \\\"ipc\\\":\\n rport = config[\\\"uds\\\"]\\n lport = \\\"%s-%s\\\" % (rport, localhost)\\n config[\\\"uds\\\"] = lport\\n elif protocol == \\\"tcp\\\":\\n rport = config[\\\"port\\\"]\\n lport = select_random_ports(1)[0]\\n config[\\\"port\\\"] = lport\\n else:\\n raise TunnelError(\\\"Unsupported protocol %s\\\" % protocol)\\n\\n log(\\\"attempting to create tunnels from %s@%s to %s@%s\\\" % (protocol, localhost,\\n protocol, server))\\n\\n ssh_tunnel(log, mode, ltransport=protocol, lport=lport,\\n rtransport=protocol, rport=rport,\\n server=server, user=user, ssh_port=ssh_port)\\n\\n if protocol == \\\"ipc\\\":\\n while not os.path.exists(lport) and ipc_wait_file > 0:\\n log(\\\"waiting for local ipc socket - %d\\\" % ipc_wait_file)\\n time.sleep(1)\\n ipc_wait_file -= 1\\n if not os.path.exists(lport):\\n raise TunnelError(\\\"local ipc socket doesn't exist: %s\\\" % lport)\\n elif protocol == \\\"tcp\\\":\\n time.sleep(2)\",\n \"def issmssh(host,login,port,command):\\n\\n\\t#first get hostname \\n\\thostname=gethostname()\\n\\n\\t#if same as host, just run the command. \\n\\tif m.strcmpi(host,hostname):\\n\\t\\tsubprocess.call(command,shell=True)\\n\\telse:\\n\\t\\tif m.ispc():\\n\\t\\t\\t#use the putty project plink.exe: it should be in the path.\\n\\t\\t\\n\\t\\t\\t#get ISSM_DIR variable\\n\\t\\t\\tif 'ISSM_DIR_WIN' in os.environ:\\n\\t\\t\\t\\tISSM_DIR=os.environ['ISSM_DIR_WIN'][1:-2]\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise OSError(\\\"issmssh error message: could not find ISSM_DIR_WIN environment variable.\\\")\\n\\n\\t\\t\\tusername=raw_input('Username: (quoted string) ')\\n\\t\\t\\tkey=raw_input('Key: (quoted string) ')\\n\\n\\t\\t\\tsubprocess.call('%s/externalpackages/ssh/plink.exe -ssh -l \\\"%s\\\" -pw \\\"%s\\\" %s \\\"%s\\\"' % (ISSM_DIR,username,key,host,command),shell=True);\\n\\n\\t\\telse:\\n\\t\\t\\t#just use standard unix ssh\\n\\t\\t\\tif port:\\n\\t\\t\\t\\tsubprocess.call('ssh -l %s -p %d localhost \\\"%s\\\"' % (login,port,command),shell=True)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tsubprocess.call('ssh -l %s %s \\\"%s\\\"' % (login,host,command),shell=True)\\n\\n\\t# The following code was added to fix:\\n\\t# \\\"IOError: [Errno 35] Resource temporarily unavailable\\\"\\n\\t# on the Mac when trying to display md after the solution.\\n\\t# (from http://code.google.com/p/robotframework/issues/detail?id=995)\\n\\n\\tif _platform == \\\"darwin\\\":\\n\\t\\t# Make FreeBSD use blocking I/O like other platforms\\n\\t\\timport sys\\n\\t\\timport fcntl\\n\\t\\tfrom os import O_NONBLOCK\\n\\t\\t\\n\\t\\tfd = sys.stdin.fileno()\\n\\t\\tflags = fcntl.fcntl(fd, fcntl.F_GETFL)\\n\\t\\tfcntl.fcntl(fd, fcntl.F_SETFL, flags & ~O_NONBLOCK)\\n\\t\\t\\n\\t\\tfd = sys.stdout.fileno()\\n\\t\\tflags = fcntl.fcntl(fd, fcntl.F_GETFL)\\n\\t\\tfcntl.fcntl(fd, fcntl.F_SETFL, flags & ~O_NONBLOCK)\",\n \"def ssh_to_ec2(instance):\\n subprocess.Popen(['ssh', instance.dns_name])\",\n \"def docker(self, obj):\\n\\n if self._dockerclient is not None:\\n return self._dockerclient\\n host = self.properties[self.HOST_NODE]\\n host_ip = self.get_host_ip(self, obj, host)\\n url = 'tcp://' + host_ip + ':2375'\\n self._dockerclient = docker.Client(base_url=url)\",\n \"def create_ssh_tunnel():\\n \\n # Reference link: https://sshtunnel.readthedocs.io/en/latest/\\n tunnel = SSHTunnelForwarder(\\n (config['ip'], 22),\\n ssh_username=config['username'],\\n ssh_password=config[\\\"ssh-password\\\"],\\n remote_bind_address=('localhost', 3306),\\n )\\n\\n tunnel.start() \\n print(\\\"SSH Connected\\\") \\n return tunnel\",\n \"def ssh(host, command, fork=False, parallel=False, user=\\\"root\\\", debug=False):\\n global __parallel_ssh_results\\n args = [\\\"ssh\\\", \\n \\\"-o\\\", \\\"StrictHostKeyChecking=no\\\", \\n \\\"-o\\\", \\\"ConnectTimeout=15\\\",\\n ]\\n if KEYFILE:\\n args.extend([\\\"-i\\\", KEYFILE])\\n args.append(host)\\n if fork:\\n command += \\\" </dev/null >/dev/null 2>&1 &\\\"\\n args.append(command)\\n if debug:\\n print 'ssh %s %s' % (host, command)\\n p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n result = p.communicate()\\n if parallel:\\n __parallel_ssh_results[host] = result\\n if debug:\\n print host\\n print '\\\\t', 'stdout:', result[0]\\n print '\\\\t', 'stderr:', result[1]\\n return (host, result)\",\n \"def _ssh(ip, *, user=None, key=None, port=8888):\\n # Need to replace \\\".\\\", because I don't want \\n # `ip` to be a keyword argument\\n if ip == \\\".\\\" or ip == \\\"...\\\": ip = None \\n func_args = locals()\\n conf = Bunch(**func_args)\\n \\n # Loads default config if there is one\\n # and update the conf object with data\\n # from it, but function args have precedence\\n fname = os.path.expanduser(\\\"~/.nbx/aws.json\\\")\\n fname = Path(fname)\\n if fname.is_file(): \\n stored = load(fname)\\n for k,v in stored.items():\\n # Function args have precedence\\n if conf[k] is None: conf[k] = v\\n \\n # Check if we got everything we need to\\n # connect to instance\\n fail = False\\n for k in [\\\"ip\\\", \\\"user\\\", \\\"key\\\", \\\"port\\\"]:\\n if conf[k] is None:\\n fail = True\\n print(f\\\"Please provide --{k}\\\")\\n \\n # Save what we already got, and\\n # proceed if we got everything or return\\n dump(conf, fname)\\n if fail: return\\n \\n config_str = SSH_CONFIG_TEMPLATE.format(\\n host=\\\"aws\\\", \\n user=conf.user, \\n ip=conf.ip, \\n key=conf.key\\n )\\n print(config_str)\\n dump(config_str, os.path.expanduser(\\\"~/.ssh/ec2_config\\\"), format=\\\".txt\\\")\\n \\n # We could write some environment vars\\n # but we can't source them from here\\n #\\n # fname = os.path.expanduser(\\\"~/.nbx/.bash_aws\\\")\\n # string = f\\\"export xaws={conf.user}@{conf.ip};\\\\n\\\"\\n # dump(string, fname, format=\\\".txt\\\")\\n\\n # Connect to server and forward local port 8888 to remote port 8888\\n # We can now connect to a remote jupyter notebook server via `http://localhost:8888/`\\n cmd = f\\\"ssh -i {conf.key} -L {conf.port}:localhost:{conf.port} {conf.user}@{conf.ip}\\\"\\n os.system(f'bash -c \\\\\\\"{cmd}\\\\\\\"')\",\n \"def open(self):\\n class IgnorePolicy(paramiko.MissingHostKeyPolicy):\\n \\\"\\\"\\\"\\n Policy for ignoring missing host keys.\\n\\n TODO: It would be better to know and confirm the host key.\\n \\\"\\\"\\\"\\n\\n def missing_host_key(self, client, hostname, key):\\n return\\n\\n client = paramiko.SSHClient()\\n client.set_missing_host_key_policy(IgnorePolicy())\\n client.connect(\\n hostname=self._ssh_config.ip,\\n username=self._ssh_config.user,\\n pkey=paramiko.rsakey.RSAKey.from_private_key(io.StringIO(self._ssh_config.key))\\n )\\n\\n self._paramiko_ssh_client = client\",\n \"def ssh_connect(connection):\\n try:\\n ssh = paramiko.SSHClient()\\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n ssh.connect(connection.host,\\n username=connection.username,\\n password=connection.password,\\n port=connection.port)\\n return ssh\\n except Exception:\\n LOG.exception(_('Connection error connecting PowerVM manager'))\\n raise exception.PowerVMConnectionFailed()\",\n \"def issue_command(username, password, host, command):\\n\\n remote_conn_pre = paramiko.SSHClient()\\n remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n\\n # Try the SSH but log to our running log when there's a problem\\n\\n try:\\n # http://yenonn.blogspot.co.uk/2013/10/python-in-action-paramiko-handling-ssh.html\\n remote_conn_pre.connect(host, username=username, password=password, allow_agent=False)\\n except paramiko.AuthenticationException, e:\\n ssh_error = (host + \\\", Authentication Error: \\\" + str(e) + \\\"\\\\n\\\")\\n remote_conn_pre.close()\\n return [1, \\\"\\\", \\\"\\\", ssh_error]\\n except paramiko.SSHException, e:\\n ssh_error = (host + \\\", SSH Error: \\\" + str(e) + \\\"\\\\n\\\")\\n remote_conn_pre.close()\\n return [1, \\\"\\\", \\\"\\\", ssh_error]\\n except paramiko.BadHostKeyException, e:\\n ssh_error = (host + \\\", BadHostKey: \\\" + str(e) + \\\"\\\\n\\\")\\n remote_conn_pre.close()\\n return [1, \\\"\\\", \\\"\\\", ssh_error]\\n except socket.error, e:\\n ssh_error = (host + \\\", Connection Failed: \\\" + str(e) + \\\"\\\\n\\\")\\n return [1, \\\"\\\", \\\"\\\", ssh_error]\\n\\n \\n transport = remote_conn_pre.get_transport()\\n pause = 1 \\n ssh_error = \\\"\\\"\\n chan = transport.open_session()\\n chan.exec_command(command)\\n pause = 1\\n buff_size = 1024\\n stdout = \\\"\\\"\\n stderr = \\\"\\\"\\n\\n while not chan.exit_status_ready():\\n time.sleep(pause)\\n if chan.recv_ready():\\n stdout += chan.recv(buff_size)\\n\\n if chan.recv_stderr_ready():\\n stderr += chan.recv_stderr(buff_size)\\n\\n exit_status = chan.recv_exit_status()\\n # Need to gobble up any remaining output after program terminates...\\n while chan.recv_ready():\\n stdout += chan.recv(buff_size)\\n\\n while chan.recv_stderr_ready():\\n stderr += chan.recv_stderr(buff_size)\\n\\n return [exit_status, stdout, stderr, ssh_error]\",\n \"def run_ssh_command(host, user, command, indent=1, prefix=\\\"$: \\\", logger=None):\\n ssh_giveup_timeout = env_vars['ssh_giveup_timeout']\\n private_key = paramiko.RSAKey.from_private_key_file(home+env_vars[\\\"priv_key_path\\\"])\\n ssh = paramiko.SSHClient()\\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n if not logger is None:\\n logger.debug(\\\"Connecting to SSH\\\")\\n timer = Timer.get_timer()\\n try:\\n ssh.connect(host, username=user, timeout=ssh_timeout, pkey=private_key, allow_agent=False, look_for_keys=False)\\n if not logger is None:\\n logger.debug(\\\"connected in %d sec. now Running SSH command\\\" % timer.stop())\\n timer.start()\\n ### EXECUTE THE COMMAND ###\\n stdin, stdout, stderr = ssh.exec_command(command)\\n ret = ''\\n for line in stdout:\\n ret += line\\n for line in stderr:\\n ret += line\\n # close the ssh connection\\n ssh.close()\\n if not logger is None:\\n logger.debug(\\\"SSH command took %d sec\\\" % timer.stop())\\n return reindent(ret, indent, prefix=prefix)\\n except:\\n if not logger is None:\\n logger.error(\\\"Could not connect to \\\"+ str(host))\\n traceback.print_exc()\",\n \"def main(ssh, ssh_pub, robot, project):\\n\\n img = 'gcr.io/k8s-testimages/heapster-test:%s' % HEAPSTER_IMAGE_VERSION\\n artifacts = '%s/_artifacts' % os.environ['WORKSPACE']\\n if not os.path.isdir(artifacts):\\n os.makedirs(artifacts)\\n heapster = os.getcwd()\\n if not os.path.basename(heapster) == 'heapster':\\n raise ValueError(heapster)\\n\\n for path in [ssh, ssh_pub, robot]:\\n if not os.path.isfile(os.path.expandvars(path)):\\n raise IOError(path, os.path.expandvars(path))\\n private = '/root/.ssh/google_compute_engine'\\n public = '%s.pub' % private\\n service = '/service-account.json'\\n\\n temp = tempfile.mkdtemp(prefix='heapster-')\\n try:\\n check(\\n 'docker', 'run', '--rm=true',\\n '-v', '/etc/localtime:/etc/localtime:ro',\\n '-v', '/var/run/docker.sock:/var/run/docker.sock',\\n '-v', '%s:/go/src/k8s.io/heapster' % heapster,\\n '-v', '%s:%s' % (temp, temp),\\n '-v', '%s:/workspace/_artifacts' % artifacts,\\n '-v', '%s:%s:ro' % (robot, service),\\n '-v', '%s:%s:ro' % (ssh, private),\\n '-v', '%s:%s:ro' % (ssh_pub, public),\\n '-e', 'GOOGLE_APPLICATION_CREDENTIALS=%s' % service,\\n '-e', 'JENKINS_GCE_SSH_PRIVATE_KEY_FILE=%s' % private,\\n '-e', 'JENKINS_GCE_SSH_PUBLIC_KEY_FILE=%s' % public,\\n '-e', 'REPO_DIR=%s' % heapster, # Used in heapster/Makefile\\n '-e', 'TEMP_DIR=%s' % temp,\\n '-e', 'PROJECT=%s' % project,\\n img,\\n )\\n shutil.rmtree(temp)\\n except subprocess.CalledProcessError:\\n shutil.rmtree(temp)\\n raise\",\n \"def command():\\n server = get_server()\\n port = get_port()\\n \\n click.echo(f'{server.get(\\\"hostname\\\")}:{port} -> localhost:{port}')\\n click.echo('CTRL+C for quit')\\n bash('ssh -N -L {port}:localhost:{port} -i {ssh_key_path} {username}@{hostname}'.format(\\n ssh_key_path=server.get('ssh_key_path'),\\n username=server.get('username'),\\n hostname=server.get('hostname'),\\n port=port\\n ))\",\n \"def ssh_command(client, command):\\n _stdin, _stdout, _stderr = client.exec_command(command, get_pty=True, timeout=60)\\n _stdout.channel.recv_exit_status()\\n return _stdout.readlines()\",\n \"def _ssh_master_cmd(addr, user, command, local_key=None):\\n ssh_call = ['ssh', '-qNfL%d:127.0.0.1:12042' % find_port(addr, user),\\n '-o', 'ControlPath=~/.ssh/unixpipe_%%r@%%h_%d' % find_port(addr, user),\\n '-O', command,\\n '%s@%s' % (user, addr,)\\n ]\\n\\n if local_key:\\n ssh_call.insert(1, local_key)\\n ssh_call.insert(1, '-i')\\n \\n return subprocess.call(ssh_call)\",\n \"def main():\\r\\n parser = argparse.ArgumentParser(description=\\\"\\\"\\\"Starts SSH session with one\\r\\n of ARC\\\\'s Raspberrypis.\\\"\\\"\\\")\\r\\n\\r\\n parser.add_argument('usr', help='Username for the remote device.')\\r\\n parser.add_argument('pwd', help='Password for arc.pi.reg@gmail.com.')\\r\\n\\r\\n args = parser.parse_args()\\r\\n\\r\\n address = get_IP(IP_list(args.pwd), args.usr)\\r\\n os.system(\\\"ssh \\\" + \\\"pi\\\" + \\\"@\\\" + address)\",\n \"def run(cls, host, command, user=None):\\n '''\\n if isinstance(hosts, str):\\n ssh = cls._get_ssh_connection(hosts, user)\\n\\n\\n results = {}\\n for host in hosts:\\n ssh = cls._get_ssh_connection(host, user)\\n results[ssh] = \\\"result from %s on %s\\\" % (command, ssh)\\n '''\\n if not user:\\n user = cls.user\\n\\n ctlpersist = ''\\n if cls.use_controlpersist:\\n ctlpersist = \\\" (cp)\\\"\\n\\n # output command\\n cls.log.info(\\\"%s@%s%s: %s\\\" % (user, host, ctlpersist, command))\\n # run the command\\n ssh = cls._get_ssh_connection(host, user)\\n if not ssh:\\n cls.log.error(\\\"ERROR: No ssh connection\\\")\\n return None\\n\\n p = ssh.popen(command)\\n stdout, stderr = p.communicate()\\n retcode = p.returncode\\n\\n # output command results\\n identifier = \\\"%s@%s\\\" % (user, host)\\n cls._log_results(identifier, retcode, stdout, stderr)\\n\\n return (retcode, stdout, stderr)\",\n \"def css_login_as_root(css_test_machine):\\n ssh_config = collections.namedtuple('ssh_config',\\n ('hostname port username '\\n 'rsa_key_file password'))\\n config = ssh_config(hostname=css_test_machine['public_ip'],\\n port=22,\\n username=\\\"root\\\",\\n rsa_key_file=\\\"\\\", # Use password for now\\n password=css_test_machine['root_password'])\\n logger.debug(\\\"ssh instantiated\\\")\\n yield SshUtil(config)\\n # Close connection?\",\n \"def call_ssh(cmd, host, user=None, timeout=None, cwd=None):\\n if user:\\n host = \\\"%s@%s\\\" % (user, host)\\n full_cmd = ['ssh', host, '-oBatchMode=yes', '--']\\n if cwd:\\n full_cmd.append(\\\"cd %s;\\\" % cwd)\\n full_cmd.extend(quote(i) for i in cmd)\\n return check_output(full_cmd, timeout=timeout)\",\n \"def connect(ip_address,username,password):\\n\\n print ('\\\\n------------------------------------------------------')\\n print ('--- Attempting paramiko connection to: ', ip_address)\\n\\n # Create paramiko session\\n ssh_client = paramiko.SSHClient()\\n\\n # Must set missing host key policy since we don't have the SSH key\\n # stored in the 'known_hosts' file\\n ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n\\n # Make the connection to our host.\\n ssh_client.connect(hostname=ip_address,\\n username=username,\\n password=password)\\n \\n return ssh_client\",\n \"def open_chef_connection(args):\\n\\n chefserver = chef_api.Cheferizer(\\n url=args.get('auth_url'),\\n client_pem=args.get('client_key'),\\n user=args.get('client_name')\\n )\\n chefserver.open_pem()\\n return chefserver\",\n \"def setup_node(\\n *,\\n # Change this to take host, user, and identity_file?\\n # Add some kind of caching for SSH connections so that they\\n # can be looked up by host and reused?\\n ssh_client: paramiko.client.SSHClient,\\n services: list,\\n cluster: FlintrockCluster):\\n host = ssh_client.get_transport().getpeername()[0]\\n ssh_check_output(\\n client=ssh_client,\\n command=\\\"\\\"\\\"\\n set -e\\n\\n echo {private_key} > \\\"$HOME/.ssh/id_rsa\\\"\\n echo {public_key} >> \\\"$HOME/.ssh/authorized_keys\\\"\\n\\n chmod 400 \\\"$HOME/.ssh/id_rsa\\\"\\n \\\"\\\"\\\".format(\\n private_key=shlex.quote(cluster.ssh_key_pair.private),\\n public_key=shlex.quote(cluster.ssh_key_pair.public)))\\n\\n with ssh_client.open_sftp() as sftp:\\n sftp.put(\\n localpath=os.path.join(SCRIPTS_DIR, 'setup-ephemeral-storage.py'),\\n remotepath='/tmp/setup-ephemeral-storage.py')\\n\\n logger.info(\\\"[{h}] Configuring ephemeral storage...\\\".format(h=host))\\n # TODO: Print some kind of warning if storage is large, since formatting\\n # will take several minutes (~4 minutes for 2TB).\\n storage_dirs_raw = ssh_check_output(\\n client=ssh_client,\\n command=\\\"\\\"\\\"\\n set -e\\n python /tmp/setup-ephemeral-storage.py\\n rm -f /tmp/setup-ephemeral-storage.py\\n \\\"\\\"\\\")\\n storage_dirs = json.loads(storage_dirs_raw)\\n\\n cluster.storage_dirs.root = storage_dirs['root']\\n cluster.storage_dirs.ephemeral = storage_dirs['ephemeral']\\n\\n ensure_java8(ssh_client)\\n\\n for service in services:\\n service.install(\\n ssh_client=ssh_client,\\n cluster=cluster)\",\n \"def __enter__(self):\\n self.ssh = paramiko.SSHClient()\\n self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n self.ssh.connect(self.host, username=self.user, port=self.port, password=self.password)\\n return self\",\n \"def server_command(ssh, command):\\n print('Executing command: {0}\\\\n'.format(command))\\n stdin, stdout, stderr = ssh.exec_command(command)\\n for line in stdout.readlines():\\n print(line.strip())\",\n \"def _connect(self):\\n self.client = SSHClient()\\n self.client.load_system_host_keys()\\n self.client.set_missing_host_key_policy(AutoAddPolicy())\\n self.client.connect(self.host,\\n username=self.user,\\n key_filename=self.filepath,\\n look_for_keys=True,\\n timeout=5000)\\n self.scp = SCPClient(self.client.get_transport())\",\n \"def docker_client():\\n client = docker.from_env()\\n return client\",\n \"def _start_instance(self, resource_handler):\\n log.debug('Starting container')\\n cli = resource_handler.cli\\n #host_config=cli.create_host_config(network_mode=self.network_mode)\\n container = cli.create_container(\\n image='{0.image}:{0.tag}'.format(self),\\n command=self.command,\\n #host_config=host_config,\\n environment=self.env\\n )\\n\\n cli.start(container.get('Id'))\\n log.debug('Started container [%s]', container)\\n return str(container)\",\n \"def test_shell():\\n platform = DockerPlatform(None, None)\\n platform.pre_build()\\n\\n # Add node\\n node1 = Node(identifier='host1', type='host')\\n host1 = platform.add_node(node1)\\n\\n # Add ports\\n p1 = BidirectionalPort(identifier='p1')\\n platform.add_biport(host1, p1)\\n p2 = BidirectionalPort(identifier='p2')\\n platform.add_biport(host1, p2)\\n p3 = BidirectionalPort(identifier='p3')\\n platform.add_biport(host1, p3)\\n\\n platform.post_build()\\n\\n reply = host1('echo \\\"var\\\"')\\n\\n platform.destroy()\\n\\n assert 'var' in reply\",\n \"def docker_client(request):\\n client = docker.from_env()\\n yield client\\n client.close()\",\n \"def cli_run(host_ip:str, linux_user:str, linux_password:str, cmd:str)->dict:\\n try:\\n c = Connection(linux_user + \\\"@\\\" + host_ip, connect_kwargs={'password':linux_password})\\n return c.run(cmd, warn=True)\\n except Exception as e:\\n return {\\\"Error\\\": str(e)}\",\n \"def connect_to_ssh_host(self, host, port = 22, user = \\\"omc\\\", passwd = \\\"omc\\\", prompt = \\\"\\\", timeout = \\\"60sec\\\"):\\n if prompt == None or prompt == \\\"\\\":\\n myprompt = '#'\\n # myprompt = None\\n else:\\n myprompt = prompt\\n\\n conn = MySshLib(timeout, \\\"CR\\\", myprompt)\\n conn.open_connection(host, port=port)\\n conn.login(user, passwd)\\n\\n self._ssh_connections[conn] = 'Linux'\\n self._current = conn\\n self._current._prompt = myprompt\\n\\n return conn\",\n \"def client():\\n _, p, _ = docker_run_etcd_main()\\n c = Client(host, p, protocol)\\n yield c\\n c.close()\",\n \"def run_unix(host, port, ssh, command):\\n if not host or not port:\\n return -2\\n\\n ssh = [ssh,\\n '-o', 'UserKnownHostsFile=/dev/null',\\n '-o', 'StrictHostKeyChecking=no',\\n '-p', port, host] + command\\n\\n _LOGGER.debug('Starting ssh: %s', ssh)\\n os.execvp(ssh[0], ssh)\",\n \"def ssh_to(srvname, srvport=22, srvuser='root'):\\n xssh = subprocess.Popen(['/usr/bin/ssh', '-o', 'StrictHostKeyChecking=no', '-o',\\n 'UserKnownHostsFile=/dev/null', '-p', str(srvport),\\n '%s@%s' % (srvuser, srvname)])\\n xssh.communicate()\",\n \"def establish_connection(self):\\r\\n\\r\\n #creates SSH connection and adds SSH key to .known_hosts\\r\\n self.ssh_conn = paramiko.SSHClient()\\r\\n self.ssh_conn.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\r\\n\\r\\n try:\\r\\n self.ssh_conn.connect(**self.conn_parm)\\r\\n print \\\"Connected to %s\\\" % self.conn_parm['hostname']\\r\\n #testing: self.ssh_conn.close()\\r\\n except socket.error:\\r\\n print \\\"Connection Failed on device %s\\\" % self.conn_parm['hostname']\\r\\n\\r\\n #find prompt\\r\\n open_session = self.ssh_conn.invoke_shell()\\r\\n output = open_session.recv(1000)\\r\\n\\r\\n #testing: print output\\r\\n\\r\\n #go into Enable-Mode if not already in it\\r\\n if '#' not in output:\\r\\n open_session.send('enable\\\\n')\\r\\n time.sleep(1)\\r\\n open_session.send(self.password)\\r\\n open_session.send('\\\\n')\\r\\n else:\\r\\n print \\\"In Enable-Mode\\\"\\r\\n\\r\\n #turn off paging\\r\\n open_session.send('terminal length 0\\\\n')\\r\\n time.sleep(3)\\r\\n \\r\\n return open_session\",\n \"def getSSHConnection(host):\\n try:\\n ssh = SSHWrapper()\\n ssh.connect(host.getID())\\n return ssh\\n except:\\n return None\",\n \"def connect_to_server(username, server='euler.ethz.ch'):\\n ssh = SSHClient()\\n ssh.set_missing_host_key_policy(AutoAddPolicy())\\n try:\\n ssh.connect(server, username=username)\\n print('Connected to {0}\\\\n'.format(server))\\n except:\\n print('Connection failed\\\\n')\\n return ssh\",\n \"def ssh(self) -> pulumi.Input['ContainerServiceSshConfigurationArgs']:\\n return pulumi.get(self, \\\"ssh\\\")\",\n \"def sshtest():\\n vbox = Vbox(env.vm_name)\\n print vbox.ssh_up\",\n \"def test_ssh(self):\\n self._test_ssh(self.git_ssh_path)\",\n \"def docker_client():\\n return docker.from_env()\",\n \"def salt_ssh_cli(\\n self,\\n factory_class=cli.ssh.SaltSsh,\\n roster_file=None,\\n target_host=None,\\n client_key=None,\\n ssh_user=None,\\n **factory_class_kwargs,\\n ):\\n script_path = self.factories_manager.get_salt_script_path(\\\"salt-ssh\\\")\\n return factory_class(\\n script_name=script_path,\\n config=self.config.copy(),\\n roster_file=roster_file,\\n target_host=target_host,\\n client_key=client_key,\\n ssh_user=ssh_user or running_username(),\\n system_service=self.factories_manager.system_service,\\n python_executable=self.python_executable,\\n **factory_class_kwargs,\\n )\",\n \"def ssh(remoteAddress, remoteCommand, outputPrefix=\\\"ssh> \\\"):\\n command = [\\\"ssh\\\", remoteAddress, \\\"-t\\\", \\\"-o\\\", \\\"StrictHostKeyChecking=no\\\", remoteCommand]\\n\\n proc = ProcessRunner(command)\\n proc.mapLines(WriteOut(sys.stdout, outputPrefix=outputPrefix), procPipeName=\\\"stdout\\\")\\n proc.mapLines(WriteOut(sys.stderr, outputPrefix=outputPrefix), procPipeName=\\\"stderr\\\")\\n proc.wait()\\n returnCode = proc.poll()\\n\\n # proc.terminate()\\n # proc.shutdown()\\n\\n return returnCode\",\n \"async def client_ssh_handler(process):\\n log.debug(f\\\"clients.py:client_ssh_handler - SSH details are: {dir(process)}\\\")\\n reader = process.stdin\\n writer = process.stdout\\n client_details = process.get_extra_info(\\\"peername\\\")\\n addr, port, *rest = client_details\\n\\n connection = PlayerConnection(addr, port, \\\"ssh\\\")\\n\\n await register_client(connection)\\n\\n tasks = [\\n asyncio.create_task(client_read(reader, connection), name=f\\\"{connection.uuid} read\\\"),\\n asyncio.create_task(client_write(writer, connection), name=f\\\"{connection.uuid} write\\\"),\\n ]\\n\\n asyncio.current_task().set_name(f\\\"{connection.uuid} handler\\\")\\n\\n # We want to .wait until the first task is completed. Completed could be an actual finishing\\n # of execution or an exception. If either the read or writer \\\"completes\\\", we want to ensure\\n # we move beyond this point and cleanup the tasks associated with this client.\\n _, rest = await asyncio.wait(tasks, return_when=\\\"FIRST_COMPLETED\\\")\\n\\n await unregister_client(connection)\\n\\n process.close()\\n process.exit(0)\\n\\n for task in rest:\\n task.cancel()\",\n \"def connect(self):\\n try:\\n self.connector = paramiko.SSHClient()\\n self.connector.set_missing_host_key_policy(\\n paramiko.AutoAddPolicy())\\n self.connector.connect(\\n hostname=self.host,\\n username=self.username,\\n password=self.password)\\n\\n channel = self.connector.invoke_shell()\\n self.stdin_stream = channel.makefile(WRITE)\\n self.stdout_stream = channel.makefile(READ)\\n self.stderr_stream = channel.makefile(READ)\\n\\n except Exception as e:\\n LOG.exception(_LE(\\\"Connect failed to switch %(host)s with error\\\"\\n \\\" %(error)s\\\"),\\n {'host': self.host, 'error': e.args})\\n raise Exception(_(\\\"Connection Failed\\\"))\",\n \"def get_ssh():\\n\\n ip = str(sc.sticky[\\\"SSH\\\"]['ip'])\\n port = str(sc.sticky[\\\"SSH\\\"]['port'])\\n user = str(sc.sticky[\\\"SSH\\\"]['user'])\\n pw = str(sc.sticky[\\\"SSH\\\"]['password'])\\n\\n ssh_dict = {'ip': ip, 'port': port, 'user': user, 'password': pw}\\n\\n return ssh_dict\",\n \"def run_cmd_on_the_nas_with_ssh(driver, cmd):\\n global results\\n results = ssh_cmd(cmd, 'root', 'testing', host)\\n assert results['result'], f'STDOUT: {results[\\\"output\\\"]}, STDERR: {results[\\\"stderr\\\"]}'\",\n \"def _getSshCmdAndSecrets(hostname, user, sshId, reuseCon):\\n\\n sshCmdSecrets = []\\n\\n if sshId:\\n sshCmd = f'ssh -i {sshId}'\\n\\n elif user.password:\\n sshCmd = 'sshpass -v -p :0: ssh'\\n sshCmdSecrets += [user.password]\\n\\n else:\\n sshCmd = 'ssh'\\n\\n sshCmd += ' -o StrictHostKeyChecking=no'\\n\\n if reuseCon:\\n sshCmd += ' -o ControlMaster=auto'\\n sshCmd += f' -o ControlPath={CmdSsh._getSocketPath()}'\\n sshCmd += ' -o ControlPersist=600'\\n\\n # Need to separate login part for use with 'rsync -e'\\n\\n sshLogin = f'{user.name}@{hostname}'\\n\\n return sshCmd, sshLogin, sshCmdSecrets\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69851446","0.6791386","0.6668736","0.6655599","0.6630987","0.65980434","0.6580812","0.65597147","0.655599","0.6490338","0.641064","0.6405131","0.6365197","0.63595355","0.6352704","0.6299737","0.62719107","0.62428546","0.6240554","0.6232706","0.6225897","0.6223149","0.6206834","0.6184578","0.6174426","0.6149093","0.6141177","0.613032","0.61184734","0.6107781","0.609916","0.60892653","0.6088627","0.60880053","0.6082431","0.6053214","0.6024003","0.59724706","0.5965873","0.59507936","0.5925471","0.59189516","0.59105426","0.5904977","0.5883835","0.58828074","0.58646065","0.5859606","0.58469003","0.58451873","0.5827282","0.5824499","0.58060867","0.5796046","0.5784086","0.5766102","0.5764298","0.5763806","0.57519794","0.5726136","0.57190126","0.5717289","0.57118535","0.5707339","0.56984216","0.5693081","0.56819105","0.5664456","0.5662329","0.56579846","0.5651996","0.56518483","0.5650986","0.56418097","0.56303126","0.5625344","0.5618112","0.5613647","0.56098264","0.5602325","0.55840075","0.5582942","0.55827624","0.5573266","0.55675685","0.55588394","0.55538327","0.5546077","0.5542106","0.5536355","0.5523212","0.55201536","0.5517027","0.55165696","0.5497976","0.54961514","0.5494187","0.5489807","0.5485009","0.5482838"],"string":"[\n \"0.69851446\",\n \"0.6791386\",\n \"0.6668736\",\n \"0.6655599\",\n \"0.6630987\",\n \"0.65980434\",\n \"0.6580812\",\n \"0.65597147\",\n \"0.655599\",\n \"0.6490338\",\n \"0.641064\",\n \"0.6405131\",\n \"0.6365197\",\n \"0.63595355\",\n \"0.6352704\",\n \"0.6299737\",\n \"0.62719107\",\n \"0.62428546\",\n \"0.6240554\",\n \"0.6232706\",\n \"0.6225897\",\n \"0.6223149\",\n \"0.6206834\",\n \"0.6184578\",\n \"0.6174426\",\n \"0.6149093\",\n \"0.6141177\",\n \"0.613032\",\n \"0.61184734\",\n \"0.6107781\",\n \"0.609916\",\n \"0.60892653\",\n \"0.6088627\",\n \"0.60880053\",\n \"0.6082431\",\n \"0.6053214\",\n \"0.6024003\",\n \"0.59724706\",\n \"0.5965873\",\n \"0.59507936\",\n \"0.5925471\",\n \"0.59189516\",\n \"0.59105426\",\n \"0.5904977\",\n \"0.5883835\",\n \"0.58828074\",\n \"0.58646065\",\n \"0.5859606\",\n \"0.58469003\",\n \"0.58451873\",\n \"0.5827282\",\n \"0.5824499\",\n \"0.58060867\",\n \"0.5796046\",\n \"0.5784086\",\n \"0.5766102\",\n \"0.5764298\",\n \"0.5763806\",\n \"0.57519794\",\n \"0.5726136\",\n \"0.57190126\",\n \"0.5717289\",\n \"0.57118535\",\n \"0.5707339\",\n \"0.56984216\",\n \"0.5693081\",\n \"0.56819105\",\n \"0.5664456\",\n \"0.5662329\",\n \"0.56579846\",\n \"0.5651996\",\n \"0.56518483\",\n \"0.5650986\",\n \"0.56418097\",\n \"0.56303126\",\n \"0.5625344\",\n \"0.5618112\",\n \"0.5613647\",\n \"0.56098264\",\n \"0.5602325\",\n \"0.55840075\",\n \"0.5582942\",\n \"0.55827624\",\n \"0.5573266\",\n \"0.55675685\",\n \"0.55588394\",\n \"0.55538327\",\n \"0.5546077\",\n \"0.5542106\",\n \"0.5536355\",\n \"0.5523212\",\n \"0.55201536\",\n \"0.5517027\",\n \"0.55165696\",\n \"0.5497976\",\n \"0.54961514\",\n \"0.5494187\",\n \"0.5489807\",\n \"0.5485009\",\n \"0.5482838\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7121306"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6388,"cells":{"query":{"kind":"string","value":"! Wrapper for HTTP responses. message The content of the successful (200) HTTP response. Flask HTTP response object with content of message from the argument and status code 200."},"document":{"kind":"string","value":"def response(message):\n res = Response(json.dumps(message))\n res.status_code = 200\n res.content_type = \"application/json\"\n return res"},"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 response(status, message, code):\n return make_response(jsonify({\n 'status': status,\n 'message': message\n })), code","def HandleResponse(data,message,success = True,err = 'no err',resp_status = status.HTTP_200_OK):\n return Response({\n 'success':success,\n \"error\":err,\n \"message\":message,\n \"data\":data\n },status = resp_status)","def _http_response(response, http_status_code):\n return make_response(jsonify(response), http_status_code)","def resp200(msg):\n return Resp({'message':msg, 'success':True})","def response(content=None, error_code='0', message=''):\n if error_code == '0':\n data = {\n 'success': True,\n 'errorCode': error_code,\n 'data': content\n }\n else:\n data = {\n 'success': False,\n 'errorCode': error_code,\n 'errorMsg': message,\n }\n resp = jsonify(data)\n\n return resp","def format_response(message, status, message_type=\"error\"):\n return make_response(\n jsonify({message_type: message}),\n status\n )","def build_response(message: str, status_code: int) -> str:\n response = current_app.response_class(\n response=json.dumps({\n 'code': status_code,\n 'message': message\n }, indent=2),\n status=status_code,\n mimetype='application/json'\n )\n return response","def build_response(http_status, message):\n return Response(data={'detail': message},\n status=http_status)","def create_response(data={}, status=200, message=''):\n response = {\n 'success': 200 <= status < 300,\n 'code': status,\n 'message': message,\n 'result': data\n }\n return jsonify(response), status","def make_success_response(status, content):\n return dict(status=status, content=content)","def assign_message_code(success: bool):\n return (HTTPStatus.OK.phrase, HTTPStatus.OK) if success\\\n else (HTTPStatus.INTERNAL_SERVER_ERROR.phrase, HTTPStatus.INTERNAL_SERVER_ERROR)","def ping_response():\n\n return Response(\"ok\", status=200)","def create_response(data={}, status=200, message=''):\n if type(data) is not dict:\n raise TypeError('Data should be a dictionary 😞')\n\n response = {\n 'success': 200 <= status < 300,\n 'code': status,\n 'message': message,\n 'result': data\n }\n return jsonify(response), status","def status(code=200):\n\treturn jsonify(server.status_data()), code","def error_response(status_code, message=None):\n payload = {'error': str(status_code)+\" : \"+HTTP_STATUS_CODES.get(status_code, \"Unknown Error\")}\n if message:\n payload['message'] = message\n response = jsonify(payload)\n response.status_code = status_code\n return response","def http501(message):\n response = HttpResponse(message)\n response.status_code = 501\n return response","def status(self, code, content_length=None):","def error_return(content, status):\n content = '{' + '\"status\":{},\"message\":\"{}\"'.format(status, content) + '}'\n return Response(content, status=status, mimetype='application/json')","def handle_error(self, message):\n data = {\n \"success\": False,\n \"error\": message\n }\n\n return JsonResponse(data, status=200)","def response_with(response, status=200):\n return make_response(jsonify(response), status)","def send_response(data: dict = None, error: str = None, status_code: int = 200):\n if data is None:\n data = {}\n\n response = {\"data\": data, \"error\": error}\n\n return jsonify(response), status_code","def custom_response(status, details):\n return app.response_class(status=status,\n mimetype='application/json',\n response=json.dumps({\"status\": status,\n \"details\": details}))","def httperror( status_code=500, message=b'' ):","def error_response(http_response_code: Union[HTTPStatus, int], message: Text) -> JSONResponse:\n\n if isinstance(http_response_code, HTTPStatus):\n http_response_code = http_response_code.value\n\n return JSONResponse(dict(\n code=str(http_response_code),\n message=message\n ), http_response_code)","def create_response(self, status, statusmsg, body):\n self.response.setStatus(status, statusmsg)\n return body","def return_payload(status_code: int, message: str):\n return {\n \"statusCode\": status_code,\n \"headers\": {\n \"Content-Type\": \"application/json\",\n \"Access-Control-Allow-Origin\": \"*\",\n },\n \"body\": message,\n }","def response(code):\n\n def decorator(func):\n func.wsgi_code = code\n return func\n return decorator","def make_json_response(data, status=True, code=200):\n\n to_serialize = {}\n if status:\n to_serialize['status'] = True\n if data is not None:\n to_serialize['result'] = data\n else:\n to_serialize['status'] = False\n to_serialize['error'] = data\n response = app.response_class(\n response=json.dumps(to_serialize),\n status=code,\n mimetype='application/json'\n )\n return response","def handle_status(message):\n\n status = _build_status()\n message.reply(status)","def get_500_response(message):\n headers = HTTPHeaders.HTTPHeaders()\n add_default_headers(headers)\n headers[\"Connection\"] = \"close\"\n headers[\"Content-Length\"] = str(len(message))\n headers[\"Content-Type\"] = \"text/plain\"\n\n return HTTPResponse.HTTPResponse(version=1.0, status_code=500, phrase=\"Internal Error\",\n headers=headers, data=message)","def _reply(self, success: bool, error_message: str, result: dict, **kwargs):\n return rest_response(\n success=success,\n message=error_message,\n result=result,\n convert_google_style=False,\n **kwargs,\n )","def _send_immediate_response(self, success, message=\"\"):\r\n\r\n # Send the response indicating success/failure\r\n response_str = json.dumps(\r\n {'return_code': 0 if success else 1, 'content': message}\r\n )\r\n\r\n if self._is_grade_request():\r\n self.send_response(\r\n 200, content=response_str, headers={'Content-type': 'text/plain'}\r\n )\r\n self.log_message(\"XQueue: sent response {0}\".format(response_str))\r\n\r\n else:\r\n self.send_response(500)","def _get_response_message(code=200, reason=None):\n return {'reason': reason}, code","def status_message(message):\n return StatusMessage(message)","def successRequest(data):\n\treturn Response(data, status=rest_status.HTTP_200_OK)","def msgStatus():\n return jsonify({\"status\": \"OK\"})","def fake_server_response(self, status_code: Optional[int] = None,\n content: Optional[str] = None,\n url: Optional[str] = None) -> Response:\n response = Response()\n\n if status_code:\n response.status_code = status_code\n if content:\n response._content = content.encode('utf-8')\n if url:\n response.url = url\n\n return response","def api_response():\n\n data = {\n 'hello': 'world',\n 'number': 12\n }\n\n js = json.dumps(data)\n # (@data, @status_code (200 by default), @data_type)\n resp = Response(response=js, status=200, mimetype='application/json')\n\n # Using jsonify to simplify syntax, returns exactly the same flask-Response object\n # from flask import jsonify\n # resp = jsonify(data)\n # resp.status_code = 200\n\n return resp","def status(_):\n return {\"status\": \"ok\"}","def create_response(\n data: dict = None, status: int = 200, message: str = \"\"\n) -> Tuple[Response, int]:\n if type(data) is not dict and data is not None:\n raise TypeError(\"Data should be a dictionary 😞\")\n\n response = {\n \"code\": status,\n \"success\": 200 <= status < 300,\n \"message\": message,\n \"result\": data,\n }\n return jsonify(response), status","def send_response(self, code, message=None):\n\t\tself.log_request(code)\n\t\tif message is None:\n\t\t\tif code in self.responses:\n\t\t\t\tmessage = self.responses[code][0]\n\t\t\telse:\n\t\t\t\tmessage = ''\n\t\tif self.request_version != 'HTTP/0.9':\n\t\t\tself.wfile.write(\"%s %d %s\\r\\n\" %\n\t\t\t\t\t\t\t (self.protocol_version, code, message))\n\t\t\t# print (self.protocol_version, code, message)\n\t\t# self.send_header('Server', self.version_string())\n\t\t# self.send_header('Date', self.date_time_string())\n\t\tself.send_header('Server', \"Captive Portal by MaMe82\")","def response_handling(self) -> global___Snippet.SimpleResponseHandling:","def response_handling(self) -> global___Snippet.SimpleResponseHandling:","def simple_response(self, status, msg=\"\"):\r\n status = str(status)\r\n buf = [\"%s %s\\r\\n\" % (self.environ['ACTUAL_SERVER_PROTOCOL'], status),\r\n \"Content-Length: %s\\r\\n\" % len(msg)]\r\n \r\n if status[:3] == \"413\" and self.response_protocol == 'HTTP/1.1':\r\n # Request Entity Too Large\r\n self.close_connection = True\r\n buf.append(\"Connection: close\\r\\n\")\r\n \r\n buf.append(\"\\r\\n\")\r\n if msg:\r\n buf.append(msg)\r\n self.sendall(\"\".join(buf))","def http_response(status_code: int) -> Tuple[dict, int]:\n return ({'message': HTTP_STATUS_CODES.get(status_code, '')}, status_code)","def json_response(f):\n \n def wrapped(*args, **kwargs):\n result = f(*args, **kwargs)\n \n response = HttpResponse(json.dumps(result))\n \n if type(result) == dict and \"error\" in result:\n response.status_code = 500\n \n \n return response","def setResponseCode(code, message=None):","def _return_200(response_body):\n return {\n \"statusCode\": 200,\n \"body\": response_body\n }","def send_response(self, code, message=None):\r\n\r\n # replace integrated loggers with conpot logger..\r\n # self.log_request(code)\r\n\r\n if message is None:\r\n if code in self.responses:\r\n message = self.responses[code][0]\r\n else:\r\n message = ''\r\n\r\n if self.request_version != 'HTTP/0.9':\r\n self.wfile.write(\"%s %d %s\\r\\n\" %\r\n (self.protocol_version, code, message))\r\n\r\n # the following two headers are omitted, which is why we override\r\n # send_response() at all. We do this one on our own...\r\n\r\n # - self.send_header('Server', self.version_string())\r\n # - self.send_header('Date', self.date_time_string())\r","def ping():\r\n return make_response(\"pong!\", 200)","def build_response(message, mimetype, code=\"OK 200\"):\n\n if not isinstance(message, bytes):\n message = message.encode('utf-8')\n bytelength = len(message)\n header_list = []\n header_list.append('HTTP/1.1 %s \\r\\n' % code)\n header_list.append('Date: %s \\r\\n' % str(formatdate(usegmt=True)))\n header_list.append('Server: Team Python\\r\\n')\n header_list.append('Content-Type: %s; char=UTF-8\\r\\n' % mimetype)\n header_list.append('Content-Length: %s \\r\\n' % bytelength)\n header_list.append('\\r\\n%s' % message)\n header = ''.join(header_list)\n return header","def process_response(response):\n # Print it and exit with 1 if operation wasn't successful\n print(response['message'])\n if response['status'] != 'success':\n sys.exit(1)","def http_response(code):\n def decorator(func):\n def wrapper(*args, **kwargs):\n def _http_response(response, http_status_code):\n \"\"\"\n Returns an API response for the client.\n\n Args:\n response (list/dict/serializable object): api response for the client.\n http_status_code (int): the http status code that the server should return.\n\n Returns:\n Response: a flask response object.\n \"\"\"\n return make_response(jsonify(response), http_status_code)\n try:\n response = func(*args, **kwargs)\n return _http_response(\n response=response if code != HttpCodes.NO_CONTENT else \"\", http_status_code=code\n )\n except BaseApiException as exc:\n return _http_response(response=exc.to_dict(), http_status_code=exc.status_code)\n return wrapper\n return decorator","def error_message(message: str, http_code: int = 400) -> JsonResponse:\n _error_message = {'message': message}\n return JsonResponse(_error_message, json_dumps_params=json_dumps_params, status=http_code)","def return_json_error(msg, status_code):\n return Response(response=json.dumps({'message': str(msg)}), status=status_code, mimetype=\"application/json\")","def status(self, request):\n return (200, 'OK')","def return_alb_response(status_code, response_code, message, headers=None, multi_value_headers=True,\n jsonrpc_response=False):\n if response_code == 0:\n response_body = {'response': 'ok', 'message': message}\n if jsonrpc_response:\n response_body = {\n 'jsonrpc': '2.0',\n 'id': message['id'] if 'id' in message else \"1\",\n 'result': message\n }\n return make_alb_response(status_code, response_body, headers, multi_value_headers)\n else:\n response_body = {'response': 'error', 'message': message}\n if jsonrpc_response:\n response_body = {\n 'jsonrpc': '2.0',\n 'id': message['id'] if 'id' in message else \"1\",\n 'error': {\n 'code': response_code,\n 'message': str(message)\n }\n }\n return make_alb_response(status_code, response_body, headers, multi_value_headers)","def send_response(self, code, message=None):\n self.log_request(code)\n if message is None:\n if code in self.responses:\n message = self.responses[code][0]\n else:\n message = ''\n if self.request_version != 'HTTP/0.9':\n self.wfile.write(\"%s %d %s\\r\\n\" %\n (self.protocol_version, code, message))\n # print (self.protocol_version, code, message)\n\n ##### Customization\n # origin\n \"\"\"\n self.send_header('Server', self.version_string())\n self.send_header('Date', self.date_time_string())\n \"\"\"\n # now (no additional headers)","def logging_response(response, status_code=200):\n if status_code != 200:\n log = app.logger.error\n else:\n log = app.logger.info\n log(response)\n return Response(response, status_code)","def response(self):\n try:\n (code, message) = self.route_request()\n except HTTPError as e:\n logger.exception(e.message)\n logger.error(e.message)\n code = e.code\n message = e.message\n except UserError as e:\n msg = str(e)\n logger.exception(msg)\n logger.error(msg)\n code = 500\n message = {'error': msg}\n except Exception as e:\n logger.exception(str(e))\n logger.error(\"Internal error\")\n # This is an unknown error. Just inform there is an internal error.\n code = 500\n message = {'error': \"Internal error.\"}\n\n try:\n # Try to send the response\n self.send_response(int(code))\n self.send_header('Access-Control-Allow-Origin', '*')\n self.send_header('Content-type', 'application/json')\n self.end_headers()\n self.wfile.write(json.dumps(message, cls=JSONEncoder)\n .encode('utf-8'))\n except Exception as e:\n logger.exception(str(e))\n logger.error(\"Could not send response\")","def _response(status_line):\n return b\"HTTP/1.1 \" + status_line + b\"\\nContent-length: 0\\n\\n\"","def _respond_message(self, msg):\n self.set_status(200)\n self.set_header(\"Content-Type\", \"application/x-mplane+json\")\n self.write(mplane.model.unparse_json(msg))\n self.finish()","async def echo(message):\n return Response(message.content)","def status():\n return jsonify({\"Status\": \"Ok\"})","def make_response(status=200, content=None):\n\n return current_app.response_class(json.dumps(content,\n indent=None if request.is_xhr else 2),\n mimetype='text/plain')","def respond(code, data):\n return {\n 'statusCode': code,\n 'headers': {\n 'Content-Type': 'application/json'\n },\n 'body': json.dumps(data)\n }","def status():\n return jsonify({\"status\": \"OK\"})","def get_status():\n return \"OK\" # defaults to a 200 HTML status return code","def status_ok_response(response_body):\n return '{header_top}{line_break}{header_fields}{line_break}{body}'.format(\n header_top=get_header_start(STATUS_OK),\n line_break=l_b,\n header_fields=get_header_fields({\n 'Content-Type': 'text/html; charset=utf-8',\n 'Connection': 'keep-alive'\n }),\n body=response_body\n )","def make_response(status=200, content=None):\n\n return current_app.response_class(json.dumps(content,\n indent=None if request.is_xhr else 2), mimetype='text/plain')","def response_handler(r_data, status_code):\n import json\n\n r_json = json.dumps(r_data)\n\n r = Response(\n response=r_json,\n status=status_code,\n content_type='application/json'\n )\n\n return r","def _err_response(self, msg):\r\n return {'success': False, 'error': msg}","def json_status():\n return jsonify({\"status\": \"OK\"})","def _error_response(self):\r\n response_dict = {'success': False, 'version': 1}\r\n self.send_response(\r\n 400, content=json.dumps(response_dict),\r\n headers={'Content-type': 'application/json'}\r\n )","def status(status_code, *args, **kwargs):\n return HttpResponseBehaviour(HttpResponse, status=status_code, *args, **kwargs)","def get_response_status(response_code):\n if is_success(response_code):\n return 'success'\n return 'error'","def service_status() -> Response:\n data, code, headers = controllers.service_status(request.args)\n response: Response = make_response(jsonify(data), code, headers)\n return response","def return_response(status_code, response_code, message, headers=None, multi_value_headers=False,\n jsonrpc_response=False):\n if response_code == 0:\n response_body = {'response': 'ok', 'message': message}\n if jsonrpc_response:\n response_body = {\n 'jsonrpc': '2.0',\n 'id': message['id'] if 'id' in message else \"1\",\n 'result': message\n }\n return make_proxy_response(status_code, response_body, headers, multi_value_headers)\n else:\n response_body = {'response': 'error', 'message': message}\n if jsonrpc_response:\n response_body = {\n 'jsonrpc': '2.0',\n 'id': message['id'] if 'id' in message else \"1\",\n 'error': {\n 'code': response_code,\n 'message': str(message)\n }\n }\n return make_proxy_response(status_code, response_body, headers, multi_value_headers)","def to_response(self):\n return make_response(self.res, self.status)","def to_response(self):\n return make_response(self.res, self.status)","def response_ok(body, content_type):\n headers = {\n \"Content-Length\": len(body),\n \"Content-Type\": content_type,\n }\n response = Response(200, \"OK\", body=body, headers=headers)\n\n return response.return_response_string()","def response_ok(body=b\"This is a minimal response\", mimetype=b\"text/plain\"):\n response_ok_string = f'HTTP/1.1 200 OK\\r\\nContent-Type:{mimetype.decode()}\\r\\n\\r\\n'\n response_ok_string = response_ok_string.encode() + body\n return response_ok_string","def wrapper(self, *args, **kwd):\n try:\n retval = function(self, *args, **kwd)\n except (ValueError, AttributeError), log:\n LOG('SlapTool', INFO, 'Converting ValueError to NotFound, real error:',\n error=True)\n raise NotFound(log)\n except SoftwareInstanceNotReady, log:\n self.REQUEST.response.setStatus(408)\n self.REQUEST.response.setHeader('Cache-Control', 'private')\n return self.REQUEST.response\n except ValidationFailed:\n LOG('SlapTool', INFO, 'Converting ValidationFailed to ValidationFailed,'\\\n ' real error:',\n error=True)\n raise ValidationFailed\n except Unauthorized:\n LOG('SlapTool', INFO, 'Converting Unauthorized to Unauthorized,'\\\n ' real error:',\n error=True)\n raise Unauthorized\n\n self.REQUEST.response.setHeader('Content-Type', 'text/xml; charset=utf-8')\n return '%s' % retval","def response(self, context, message):\r\n return True","def _get_json_message(msg, status_code):\n return (jsonify(status=msg), status_code)","def response_from_error(error_code, error_message=None):\n\terror = Error(error_code, error_message).__dict__\n\terror_response_code = error['response_code']\n\treturn Response(json.dumps(error), status=error_response_code, mimetype='application/json')","def _f_resp(self, error):\n if self.response is not None:\n return self.response()(self.formatter, error)\n\n if self.content_type == \"text/html\":\n return HTMLResponse()(self.formatter, error)\n\n return JSONResponse()(self.formatter, error)","def make_response(data, headers, url=None, code=200, msg=\"OK\"):\n mime_headers = make_headers(headers)\n if not isinstance(data, bytes):\n data = data.encode('utf-8')\n r = closeable_response(BytesIO(data), mime_headers, url, code, msg)\n return response_seek_wrapper(r)","def get_response(self, msg):\n if msg.notification:\n return None\n elif msg.error:\n return (msg.error.status, \n self._build_error(msg.error, msg.message_id))\n elif msg.result:\n return (200, self._build_result(msg))\n else: # pragma: no cover\n # Should never be reached\n logging.warn('Message neither contains an error nor a result')","def register_json_response(success, message):\n obj = {'success': success, 'message': message}\n return JsonResponse(obj)","def error(\n status=500,\n message=\"Internal Server Error\"\n):\n return make_response(\n jsonify(error=message),\n status,\n )","def __call__(self, environ, start_response):\n start_response(self.status, self.headers)\n return [self.message] if not isinstance(self.message, list) else self.message","def to_error_response(message, errors, status_code=500):\n data = {\n 'message': message,\n 'errors': errors\n }\n\n return Response(data, status_code)","def reply_with_code(self, code: int) -> None:","def default_response(self,response_msg='A pretty minimal response'):\n resp = []\n resp.append(\"Content-Type: text/plain\")\n resp.append(\"\")\n resp.append(response_msg)\n res_str = \"\\r\\n\".join(resp)\n return res_str","def json_error(message):\n return json_response(isError=True, message=message)","def create_error_response(data: Dict[str, str], status_code: int) -> Response:\n resp = jsonify(data)\n resp.status_code = status_code\n return resp","def error(status_code, status_message=None,\n content_type='text/plain; charset=utf-8',\n headers=None, content=None):\n if status_message is None:\n status_message = httplib.responses.get(status_code, 'Unknown Error')\n\n if content is None:\n content = status_message\n\n content = util.pad_string(content)\n\n return static_page(content,\n status=(status_code, status_message),\n content_type=content_type,\n headers=headers)","def status(self, value):\r\n if isinstance(value, (int, long)):\r\n if 100 <= value <= 999:\r\n st = _RESPONSE_STATUSES.get(value, '')\r\n if st:\r\n self._status = '%d %s' % (value, st)\r\n else:\r\n self._status = str(value)\r\n else:\r\n raise ValueError('Bad response code: %d' % value)\r\n elif isinstance(value, basestring):\r\n if isinstance(value, unicode):\r\n value = value.encode('utf-8')\r\n if _RE_RESPONSE_STATUS.match(value):\r\n self._status = value\r\n else:\r\n raise ValueError('Bad response code: %s' % value)\r\n else:\r\n raise TypeError('Bad type of response code.')","def to_response(japi_response):\n if japi_response.is_file:\n flask_response = flask.send_file(japi_response.file)\n elif japi_response.has_body:\n flask_response = flask.Response(japi_response.body)\n else:\n flask_response = flask.Response(\"\")\n\n for key, value in japi_response.headers.items():\n flask_response.headers[str(key)] = value\n flask_response.status_code = japi_response.status\n return flask_response"],"string":"[\n \"def response(status, message, code):\\n return make_response(jsonify({\\n 'status': status,\\n 'message': message\\n })), code\",\n \"def HandleResponse(data,message,success = True,err = 'no err',resp_status = status.HTTP_200_OK):\\n return Response({\\n 'success':success,\\n \\\"error\\\":err,\\n \\\"message\\\":message,\\n \\\"data\\\":data\\n },status = resp_status)\",\n \"def _http_response(response, http_status_code):\\n return make_response(jsonify(response), http_status_code)\",\n \"def resp200(msg):\\n return Resp({'message':msg, 'success':True})\",\n \"def response(content=None, error_code='0', message=''):\\n if error_code == '0':\\n data = {\\n 'success': True,\\n 'errorCode': error_code,\\n 'data': content\\n }\\n else:\\n data = {\\n 'success': False,\\n 'errorCode': error_code,\\n 'errorMsg': message,\\n }\\n resp = jsonify(data)\\n\\n return resp\",\n \"def format_response(message, status, message_type=\\\"error\\\"):\\n return make_response(\\n jsonify({message_type: message}),\\n status\\n )\",\n \"def build_response(message: str, status_code: int) -> str:\\n response = current_app.response_class(\\n response=json.dumps({\\n 'code': status_code,\\n 'message': message\\n }, indent=2),\\n status=status_code,\\n mimetype='application/json'\\n )\\n return response\",\n \"def build_response(http_status, message):\\n return Response(data={'detail': message},\\n status=http_status)\",\n \"def create_response(data={}, status=200, message=''):\\n response = {\\n 'success': 200 <= status < 300,\\n 'code': status,\\n 'message': message,\\n 'result': data\\n }\\n return jsonify(response), status\",\n \"def make_success_response(status, content):\\n return dict(status=status, content=content)\",\n \"def assign_message_code(success: bool):\\n return (HTTPStatus.OK.phrase, HTTPStatus.OK) if success\\\\\\n else (HTTPStatus.INTERNAL_SERVER_ERROR.phrase, HTTPStatus.INTERNAL_SERVER_ERROR)\",\n \"def ping_response():\\n\\n return Response(\\\"ok\\\", status=200)\",\n \"def create_response(data={}, status=200, message=''):\\n if type(data) is not dict:\\n raise TypeError('Data should be a dictionary 😞')\\n\\n response = {\\n 'success': 200 <= status < 300,\\n 'code': status,\\n 'message': message,\\n 'result': data\\n }\\n return jsonify(response), status\",\n \"def status(code=200):\\n\\treturn jsonify(server.status_data()), code\",\n \"def error_response(status_code, message=None):\\n payload = {'error': str(status_code)+\\\" : \\\"+HTTP_STATUS_CODES.get(status_code, \\\"Unknown Error\\\")}\\n if message:\\n payload['message'] = message\\n response = jsonify(payload)\\n response.status_code = status_code\\n return response\",\n \"def http501(message):\\n response = HttpResponse(message)\\n response.status_code = 501\\n return response\",\n \"def status(self, code, content_length=None):\",\n \"def error_return(content, status):\\n content = '{' + '\\\"status\\\":{},\\\"message\\\":\\\"{}\\\"'.format(status, content) + '}'\\n return Response(content, status=status, mimetype='application/json')\",\n \"def handle_error(self, message):\\n data = {\\n \\\"success\\\": False,\\n \\\"error\\\": message\\n }\\n\\n return JsonResponse(data, status=200)\",\n \"def response_with(response, status=200):\\n return make_response(jsonify(response), status)\",\n \"def send_response(data: dict = None, error: str = None, status_code: int = 200):\\n if data is None:\\n data = {}\\n\\n response = {\\\"data\\\": data, \\\"error\\\": error}\\n\\n return jsonify(response), status_code\",\n \"def custom_response(status, details):\\n return app.response_class(status=status,\\n mimetype='application/json',\\n response=json.dumps({\\\"status\\\": status,\\n \\\"details\\\": details}))\",\n \"def httperror( status_code=500, message=b'' ):\",\n \"def error_response(http_response_code: Union[HTTPStatus, int], message: Text) -> JSONResponse:\\n\\n if isinstance(http_response_code, HTTPStatus):\\n http_response_code = http_response_code.value\\n\\n return JSONResponse(dict(\\n code=str(http_response_code),\\n message=message\\n ), http_response_code)\",\n \"def create_response(self, status, statusmsg, body):\\n self.response.setStatus(status, statusmsg)\\n return body\",\n \"def return_payload(status_code: int, message: str):\\n return {\\n \\\"statusCode\\\": status_code,\\n \\\"headers\\\": {\\n \\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"Access-Control-Allow-Origin\\\": \\\"*\\\",\\n },\\n \\\"body\\\": message,\\n }\",\n \"def response(code):\\n\\n def decorator(func):\\n func.wsgi_code = code\\n return func\\n return decorator\",\n \"def make_json_response(data, status=True, code=200):\\n\\n to_serialize = {}\\n if status:\\n to_serialize['status'] = True\\n if data is not None:\\n to_serialize['result'] = data\\n else:\\n to_serialize['status'] = False\\n to_serialize['error'] = data\\n response = app.response_class(\\n response=json.dumps(to_serialize),\\n status=code,\\n mimetype='application/json'\\n )\\n return response\",\n \"def handle_status(message):\\n\\n status = _build_status()\\n message.reply(status)\",\n \"def get_500_response(message):\\n headers = HTTPHeaders.HTTPHeaders()\\n add_default_headers(headers)\\n headers[\\\"Connection\\\"] = \\\"close\\\"\\n headers[\\\"Content-Length\\\"] = str(len(message))\\n headers[\\\"Content-Type\\\"] = \\\"text/plain\\\"\\n\\n return HTTPResponse.HTTPResponse(version=1.0, status_code=500, phrase=\\\"Internal Error\\\",\\n headers=headers, data=message)\",\n \"def _reply(self, success: bool, error_message: str, result: dict, **kwargs):\\n return rest_response(\\n success=success,\\n message=error_message,\\n result=result,\\n convert_google_style=False,\\n **kwargs,\\n )\",\n \"def _send_immediate_response(self, success, message=\\\"\\\"):\\r\\n\\r\\n # Send the response indicating success/failure\\r\\n response_str = json.dumps(\\r\\n {'return_code': 0 if success else 1, 'content': message}\\r\\n )\\r\\n\\r\\n if self._is_grade_request():\\r\\n self.send_response(\\r\\n 200, content=response_str, headers={'Content-type': 'text/plain'}\\r\\n )\\r\\n self.log_message(\\\"XQueue: sent response {0}\\\".format(response_str))\\r\\n\\r\\n else:\\r\\n self.send_response(500)\",\n \"def _get_response_message(code=200, reason=None):\\n return {'reason': reason}, code\",\n \"def status_message(message):\\n return StatusMessage(message)\",\n \"def successRequest(data):\\n\\treturn Response(data, status=rest_status.HTTP_200_OK)\",\n \"def msgStatus():\\n return jsonify({\\\"status\\\": \\\"OK\\\"})\",\n \"def fake_server_response(self, status_code: Optional[int] = None,\\n content: Optional[str] = None,\\n url: Optional[str] = None) -> Response:\\n response = Response()\\n\\n if status_code:\\n response.status_code = status_code\\n if content:\\n response._content = content.encode('utf-8')\\n if url:\\n response.url = url\\n\\n return response\",\n \"def api_response():\\n\\n data = {\\n 'hello': 'world',\\n 'number': 12\\n }\\n\\n js = json.dumps(data)\\n # (@data, @status_code (200 by default), @data_type)\\n resp = Response(response=js, status=200, mimetype='application/json')\\n\\n # Using jsonify to simplify syntax, returns exactly the same flask-Response object\\n # from flask import jsonify\\n # resp = jsonify(data)\\n # resp.status_code = 200\\n\\n return resp\",\n \"def status(_):\\n return {\\\"status\\\": \\\"ok\\\"}\",\n \"def create_response(\\n data: dict = None, status: int = 200, message: str = \\\"\\\"\\n) -> Tuple[Response, int]:\\n if type(data) is not dict and data is not None:\\n raise TypeError(\\\"Data should be a dictionary 😞\\\")\\n\\n response = {\\n \\\"code\\\": status,\\n \\\"success\\\": 200 <= status < 300,\\n \\\"message\\\": message,\\n \\\"result\\\": data,\\n }\\n return jsonify(response), status\",\n \"def send_response(self, code, message=None):\\n\\t\\tself.log_request(code)\\n\\t\\tif message is None:\\n\\t\\t\\tif code in self.responses:\\n\\t\\t\\t\\tmessage = self.responses[code][0]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmessage = ''\\n\\t\\tif self.request_version != 'HTTP/0.9':\\n\\t\\t\\tself.wfile.write(\\\"%s %d %s\\\\r\\\\n\\\" %\\n\\t\\t\\t\\t\\t\\t\\t (self.protocol_version, code, message))\\n\\t\\t\\t# print (self.protocol_version, code, message)\\n\\t\\t# self.send_header('Server', self.version_string())\\n\\t\\t# self.send_header('Date', self.date_time_string())\\n\\t\\tself.send_header('Server', \\\"Captive Portal by MaMe82\\\")\",\n \"def response_handling(self) -> global___Snippet.SimpleResponseHandling:\",\n \"def response_handling(self) -> global___Snippet.SimpleResponseHandling:\",\n \"def simple_response(self, status, msg=\\\"\\\"):\\r\\n status = str(status)\\r\\n buf = [\\\"%s %s\\\\r\\\\n\\\" % (self.environ['ACTUAL_SERVER_PROTOCOL'], status),\\r\\n \\\"Content-Length: %s\\\\r\\\\n\\\" % len(msg)]\\r\\n \\r\\n if status[:3] == \\\"413\\\" and self.response_protocol == 'HTTP/1.1':\\r\\n # Request Entity Too Large\\r\\n self.close_connection = True\\r\\n buf.append(\\\"Connection: close\\\\r\\\\n\\\")\\r\\n \\r\\n buf.append(\\\"\\\\r\\\\n\\\")\\r\\n if msg:\\r\\n buf.append(msg)\\r\\n self.sendall(\\\"\\\".join(buf))\",\n \"def http_response(status_code: int) -> Tuple[dict, int]:\\n return ({'message': HTTP_STATUS_CODES.get(status_code, '')}, status_code)\",\n \"def json_response(f):\\n \\n def wrapped(*args, **kwargs):\\n result = f(*args, **kwargs)\\n \\n response = HttpResponse(json.dumps(result))\\n \\n if type(result) == dict and \\\"error\\\" in result:\\n response.status_code = 500\\n \\n \\n return response\",\n \"def setResponseCode(code, message=None):\",\n \"def _return_200(response_body):\\n return {\\n \\\"statusCode\\\": 200,\\n \\\"body\\\": response_body\\n }\",\n \"def send_response(self, code, message=None):\\r\\n\\r\\n # replace integrated loggers with conpot logger..\\r\\n # self.log_request(code)\\r\\n\\r\\n if message is None:\\r\\n if code in self.responses:\\r\\n message = self.responses[code][0]\\r\\n else:\\r\\n message = ''\\r\\n\\r\\n if self.request_version != 'HTTP/0.9':\\r\\n self.wfile.write(\\\"%s %d %s\\\\r\\\\n\\\" %\\r\\n (self.protocol_version, code, message))\\r\\n\\r\\n # the following two headers are omitted, which is why we override\\r\\n # send_response() at all. We do this one on our own...\\r\\n\\r\\n # - self.send_header('Server', self.version_string())\\r\\n # - self.send_header('Date', self.date_time_string())\\r\",\n \"def ping():\\r\\n return make_response(\\\"pong!\\\", 200)\",\n \"def build_response(message, mimetype, code=\\\"OK 200\\\"):\\n\\n if not isinstance(message, bytes):\\n message = message.encode('utf-8')\\n bytelength = len(message)\\n header_list = []\\n header_list.append('HTTP/1.1 %s \\\\r\\\\n' % code)\\n header_list.append('Date: %s \\\\r\\\\n' % str(formatdate(usegmt=True)))\\n header_list.append('Server: Team Python\\\\r\\\\n')\\n header_list.append('Content-Type: %s; char=UTF-8\\\\r\\\\n' % mimetype)\\n header_list.append('Content-Length: %s \\\\r\\\\n' % bytelength)\\n header_list.append('\\\\r\\\\n%s' % message)\\n header = ''.join(header_list)\\n return header\",\n \"def process_response(response):\\n # Print it and exit with 1 if operation wasn't successful\\n print(response['message'])\\n if response['status'] != 'success':\\n sys.exit(1)\",\n \"def http_response(code):\\n def decorator(func):\\n def wrapper(*args, **kwargs):\\n def _http_response(response, http_status_code):\\n \\\"\\\"\\\"\\n Returns an API response for the client.\\n\\n Args:\\n response (list/dict/serializable object): api response for the client.\\n http_status_code (int): the http status code that the server should return.\\n\\n Returns:\\n Response: a flask response object.\\n \\\"\\\"\\\"\\n return make_response(jsonify(response), http_status_code)\\n try:\\n response = func(*args, **kwargs)\\n return _http_response(\\n response=response if code != HttpCodes.NO_CONTENT else \\\"\\\", http_status_code=code\\n )\\n except BaseApiException as exc:\\n return _http_response(response=exc.to_dict(), http_status_code=exc.status_code)\\n return wrapper\\n return decorator\",\n \"def error_message(message: str, http_code: int = 400) -> JsonResponse:\\n _error_message = {'message': message}\\n return JsonResponse(_error_message, json_dumps_params=json_dumps_params, status=http_code)\",\n \"def return_json_error(msg, status_code):\\n return Response(response=json.dumps({'message': str(msg)}), status=status_code, mimetype=\\\"application/json\\\")\",\n \"def status(self, request):\\n return (200, 'OK')\",\n \"def return_alb_response(status_code, response_code, message, headers=None, multi_value_headers=True,\\n jsonrpc_response=False):\\n if response_code == 0:\\n response_body = {'response': 'ok', 'message': message}\\n if jsonrpc_response:\\n response_body = {\\n 'jsonrpc': '2.0',\\n 'id': message['id'] if 'id' in message else \\\"1\\\",\\n 'result': message\\n }\\n return make_alb_response(status_code, response_body, headers, multi_value_headers)\\n else:\\n response_body = {'response': 'error', 'message': message}\\n if jsonrpc_response:\\n response_body = {\\n 'jsonrpc': '2.0',\\n 'id': message['id'] if 'id' in message else \\\"1\\\",\\n 'error': {\\n 'code': response_code,\\n 'message': str(message)\\n }\\n }\\n return make_alb_response(status_code, response_body, headers, multi_value_headers)\",\n \"def send_response(self, code, message=None):\\n self.log_request(code)\\n if message is None:\\n if code in self.responses:\\n message = self.responses[code][0]\\n else:\\n message = ''\\n if self.request_version != 'HTTP/0.9':\\n self.wfile.write(\\\"%s %d %s\\\\r\\\\n\\\" %\\n (self.protocol_version, code, message))\\n # print (self.protocol_version, code, message)\\n\\n ##### Customization\\n # origin\\n \\\"\\\"\\\"\\n self.send_header('Server', self.version_string())\\n self.send_header('Date', self.date_time_string())\\n \\\"\\\"\\\"\\n # now (no additional headers)\",\n \"def logging_response(response, status_code=200):\\n if status_code != 200:\\n log = app.logger.error\\n else:\\n log = app.logger.info\\n log(response)\\n return Response(response, status_code)\",\n \"def response(self):\\n try:\\n (code, message) = self.route_request()\\n except HTTPError as e:\\n logger.exception(e.message)\\n logger.error(e.message)\\n code = e.code\\n message = e.message\\n except UserError as e:\\n msg = str(e)\\n logger.exception(msg)\\n logger.error(msg)\\n code = 500\\n message = {'error': msg}\\n except Exception as e:\\n logger.exception(str(e))\\n logger.error(\\\"Internal error\\\")\\n # This is an unknown error. Just inform there is an internal error.\\n code = 500\\n message = {'error': \\\"Internal error.\\\"}\\n\\n try:\\n # Try to send the response\\n self.send_response(int(code))\\n self.send_header('Access-Control-Allow-Origin', '*')\\n self.send_header('Content-type', 'application/json')\\n self.end_headers()\\n self.wfile.write(json.dumps(message, cls=JSONEncoder)\\n .encode('utf-8'))\\n except Exception as e:\\n logger.exception(str(e))\\n logger.error(\\\"Could not send response\\\")\",\n \"def _response(status_line):\\n return b\\\"HTTP/1.1 \\\" + status_line + b\\\"\\\\nContent-length: 0\\\\n\\\\n\\\"\",\n \"def _respond_message(self, msg):\\n self.set_status(200)\\n self.set_header(\\\"Content-Type\\\", \\\"application/x-mplane+json\\\")\\n self.write(mplane.model.unparse_json(msg))\\n self.finish()\",\n \"async def echo(message):\\n return Response(message.content)\",\n \"def status():\\n return jsonify({\\\"Status\\\": \\\"Ok\\\"})\",\n \"def make_response(status=200, content=None):\\n\\n return current_app.response_class(json.dumps(content,\\n indent=None if request.is_xhr else 2),\\n mimetype='text/plain')\",\n \"def respond(code, data):\\n return {\\n 'statusCode': code,\\n 'headers': {\\n 'Content-Type': 'application/json'\\n },\\n 'body': json.dumps(data)\\n }\",\n \"def status():\\n return jsonify({\\\"status\\\": \\\"OK\\\"})\",\n \"def get_status():\\n return \\\"OK\\\" # defaults to a 200 HTML status return code\",\n \"def status_ok_response(response_body):\\n return '{header_top}{line_break}{header_fields}{line_break}{body}'.format(\\n header_top=get_header_start(STATUS_OK),\\n line_break=l_b,\\n header_fields=get_header_fields({\\n 'Content-Type': 'text/html; charset=utf-8',\\n 'Connection': 'keep-alive'\\n }),\\n body=response_body\\n )\",\n \"def make_response(status=200, content=None):\\n\\n return current_app.response_class(json.dumps(content,\\n indent=None if request.is_xhr else 2), mimetype='text/plain')\",\n \"def response_handler(r_data, status_code):\\n import json\\n\\n r_json = json.dumps(r_data)\\n\\n r = Response(\\n response=r_json,\\n status=status_code,\\n content_type='application/json'\\n )\\n\\n return r\",\n \"def _err_response(self, msg):\\r\\n return {'success': False, 'error': msg}\",\n \"def json_status():\\n return jsonify({\\\"status\\\": \\\"OK\\\"})\",\n \"def _error_response(self):\\r\\n response_dict = {'success': False, 'version': 1}\\r\\n self.send_response(\\r\\n 400, content=json.dumps(response_dict),\\r\\n headers={'Content-type': 'application/json'}\\r\\n )\",\n \"def status(status_code, *args, **kwargs):\\n return HttpResponseBehaviour(HttpResponse, status=status_code, *args, **kwargs)\",\n \"def get_response_status(response_code):\\n if is_success(response_code):\\n return 'success'\\n return 'error'\",\n \"def service_status() -> Response:\\n data, code, headers = controllers.service_status(request.args)\\n response: Response = make_response(jsonify(data), code, headers)\\n return response\",\n \"def return_response(status_code, response_code, message, headers=None, multi_value_headers=False,\\n jsonrpc_response=False):\\n if response_code == 0:\\n response_body = {'response': 'ok', 'message': message}\\n if jsonrpc_response:\\n response_body = {\\n 'jsonrpc': '2.0',\\n 'id': message['id'] if 'id' in message else \\\"1\\\",\\n 'result': message\\n }\\n return make_proxy_response(status_code, response_body, headers, multi_value_headers)\\n else:\\n response_body = {'response': 'error', 'message': message}\\n if jsonrpc_response:\\n response_body = {\\n 'jsonrpc': '2.0',\\n 'id': message['id'] if 'id' in message else \\\"1\\\",\\n 'error': {\\n 'code': response_code,\\n 'message': str(message)\\n }\\n }\\n return make_proxy_response(status_code, response_body, headers, multi_value_headers)\",\n \"def to_response(self):\\n return make_response(self.res, self.status)\",\n \"def to_response(self):\\n return make_response(self.res, self.status)\",\n \"def response_ok(body, content_type):\\n headers = {\\n \\\"Content-Length\\\": len(body),\\n \\\"Content-Type\\\": content_type,\\n }\\n response = Response(200, \\\"OK\\\", body=body, headers=headers)\\n\\n return response.return_response_string()\",\n \"def response_ok(body=b\\\"This is a minimal response\\\", mimetype=b\\\"text/plain\\\"):\\n response_ok_string = f'HTTP/1.1 200 OK\\\\r\\\\nContent-Type:{mimetype.decode()}\\\\r\\\\n\\\\r\\\\n'\\n response_ok_string = response_ok_string.encode() + body\\n return response_ok_string\",\n \"def wrapper(self, *args, **kwd):\\n try:\\n retval = function(self, *args, **kwd)\\n except (ValueError, AttributeError), log:\\n LOG('SlapTool', INFO, 'Converting ValueError to NotFound, real error:',\\n error=True)\\n raise NotFound(log)\\n except SoftwareInstanceNotReady, log:\\n self.REQUEST.response.setStatus(408)\\n self.REQUEST.response.setHeader('Cache-Control', 'private')\\n return self.REQUEST.response\\n except ValidationFailed:\\n LOG('SlapTool', INFO, 'Converting ValidationFailed to ValidationFailed,'\\\\\\n ' real error:',\\n error=True)\\n raise ValidationFailed\\n except Unauthorized:\\n LOG('SlapTool', INFO, 'Converting Unauthorized to Unauthorized,'\\\\\\n ' real error:',\\n error=True)\\n raise Unauthorized\\n\\n self.REQUEST.response.setHeader('Content-Type', 'text/xml; charset=utf-8')\\n return '%s' % retval\",\n \"def response(self, context, message):\\r\\n return True\",\n \"def _get_json_message(msg, status_code):\\n return (jsonify(status=msg), status_code)\",\n \"def response_from_error(error_code, error_message=None):\\n\\terror = Error(error_code, error_message).__dict__\\n\\terror_response_code = error['response_code']\\n\\treturn Response(json.dumps(error), status=error_response_code, mimetype='application/json')\",\n \"def _f_resp(self, error):\\n if self.response is not None:\\n return self.response()(self.formatter, error)\\n\\n if self.content_type == \\\"text/html\\\":\\n return HTMLResponse()(self.formatter, error)\\n\\n return JSONResponse()(self.formatter, error)\",\n \"def make_response(data, headers, url=None, code=200, msg=\\\"OK\\\"):\\n mime_headers = make_headers(headers)\\n if not isinstance(data, bytes):\\n data = data.encode('utf-8')\\n r = closeable_response(BytesIO(data), mime_headers, url, code, msg)\\n return response_seek_wrapper(r)\",\n \"def get_response(self, msg):\\n if msg.notification:\\n return None\\n elif msg.error:\\n return (msg.error.status, \\n self._build_error(msg.error, msg.message_id))\\n elif msg.result:\\n return (200, self._build_result(msg))\\n else: # pragma: no cover\\n # Should never be reached\\n logging.warn('Message neither contains an error nor a result')\",\n \"def register_json_response(success, message):\\n obj = {'success': success, 'message': message}\\n return JsonResponse(obj)\",\n \"def error(\\n status=500,\\n message=\\\"Internal Server Error\\\"\\n):\\n return make_response(\\n jsonify(error=message),\\n status,\\n )\",\n \"def __call__(self, environ, start_response):\\n start_response(self.status, self.headers)\\n return [self.message] if not isinstance(self.message, list) else self.message\",\n \"def to_error_response(message, errors, status_code=500):\\n data = {\\n 'message': message,\\n 'errors': errors\\n }\\n\\n return Response(data, status_code)\",\n \"def reply_with_code(self, code: int) -> None:\",\n \"def default_response(self,response_msg='A pretty minimal response'):\\n resp = []\\n resp.append(\\\"Content-Type: text/plain\\\")\\n resp.append(\\\"\\\")\\n resp.append(response_msg)\\n res_str = \\\"\\\\r\\\\n\\\".join(resp)\\n return res_str\",\n \"def json_error(message):\\n return json_response(isError=True, message=message)\",\n \"def create_error_response(data: Dict[str, str], status_code: int) -> Response:\\n resp = jsonify(data)\\n resp.status_code = status_code\\n return resp\",\n \"def error(status_code, status_message=None,\\n content_type='text/plain; charset=utf-8',\\n headers=None, content=None):\\n if status_message is None:\\n status_message = httplib.responses.get(status_code, 'Unknown Error')\\n\\n if content is None:\\n content = status_message\\n\\n content = util.pad_string(content)\\n\\n return static_page(content,\\n status=(status_code, status_message),\\n content_type=content_type,\\n headers=headers)\",\n \"def status(self, value):\\r\\n if isinstance(value, (int, long)):\\r\\n if 100 <= value <= 999:\\r\\n st = _RESPONSE_STATUSES.get(value, '')\\r\\n if st:\\r\\n self._status = '%d %s' % (value, st)\\r\\n else:\\r\\n self._status = str(value)\\r\\n else:\\r\\n raise ValueError('Bad response code: %d' % value)\\r\\n elif isinstance(value, basestring):\\r\\n if isinstance(value, unicode):\\r\\n value = value.encode('utf-8')\\r\\n if _RE_RESPONSE_STATUS.match(value):\\r\\n self._status = value\\r\\n else:\\r\\n raise ValueError('Bad response code: %s' % value)\\r\\n else:\\r\\n raise TypeError('Bad type of response code.')\",\n \"def to_response(japi_response):\\n if japi_response.is_file:\\n flask_response = flask.send_file(japi_response.file)\\n elif japi_response.has_body:\\n flask_response = flask.Response(japi_response.body)\\n else:\\n flask_response = flask.Response(\\\"\\\")\\n\\n for key, value in japi_response.headers.items():\\n flask_response.headers[str(key)] = value\\n flask_response.status_code = japi_response.status\\n return flask_response\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8077968","0.7261069","0.7197937","0.71356225","0.7122571","0.7062746","0.70605296","0.70228976","0.7000634","0.69415414","0.6871562","0.67692024","0.6674502","0.6664123","0.65871406","0.65599144","0.6558028","0.65498847","0.6513427","0.6454303","0.6445546","0.6440139","0.6360144","0.63113296","0.628619","0.62825716","0.6280527","0.6280462","0.62779075","0.6227512","0.6221544","0.621967","0.62148774","0.6206032","0.6191989","0.6188051","0.6169249","0.61641914","0.616029","0.61595345","0.6157808","0.615242","0.615242","0.6151706","0.614196","0.6141284","0.6124326","0.6118434","0.6104723","0.6100291","0.60962623","0.60953194","0.6093812","0.60768163","0.6065126","0.6064421","0.6061521","0.6060095","0.6055996","0.605525","0.6054439","0.6054192","0.60534394","0.60488194","0.6048682","0.6042202","0.6042157","0.60392064","0.6037464","0.6037089","0.60369825","0.602318","0.6022892","0.60131854","0.60075134","0.59898657","0.59877604","0.5983577","0.5981331","0.5981331","0.59794235","0.59735215","0.5971959","0.59706223","0.5965144","0.5952556","0.59486234","0.594258","0.5930994","0.5930687","0.5922934","0.5912988","0.591267","0.5903874","0.5890443","0.5873804","0.58559054","0.583713","0.5834924","0.58314604"],"string":"[\n \"0.8077968\",\n \"0.7261069\",\n \"0.7197937\",\n \"0.71356225\",\n \"0.7122571\",\n \"0.7062746\",\n \"0.70605296\",\n \"0.70228976\",\n \"0.7000634\",\n \"0.69415414\",\n \"0.6871562\",\n \"0.67692024\",\n \"0.6674502\",\n \"0.6664123\",\n \"0.65871406\",\n \"0.65599144\",\n \"0.6558028\",\n \"0.65498847\",\n \"0.6513427\",\n \"0.6454303\",\n \"0.6445546\",\n \"0.6440139\",\n \"0.6360144\",\n \"0.63113296\",\n \"0.628619\",\n \"0.62825716\",\n \"0.6280527\",\n \"0.6280462\",\n \"0.62779075\",\n \"0.6227512\",\n \"0.6221544\",\n \"0.621967\",\n \"0.62148774\",\n \"0.6206032\",\n \"0.6191989\",\n \"0.6188051\",\n \"0.6169249\",\n \"0.61641914\",\n \"0.616029\",\n \"0.61595345\",\n \"0.6157808\",\n \"0.615242\",\n \"0.615242\",\n \"0.6151706\",\n \"0.614196\",\n \"0.6141284\",\n \"0.6124326\",\n \"0.6118434\",\n \"0.6104723\",\n \"0.6100291\",\n \"0.60962623\",\n \"0.60953194\",\n \"0.6093812\",\n \"0.60768163\",\n \"0.6065126\",\n \"0.6064421\",\n \"0.6061521\",\n \"0.6060095\",\n \"0.6055996\",\n \"0.605525\",\n \"0.6054439\",\n \"0.6054192\",\n \"0.60534394\",\n \"0.60488194\",\n \"0.6048682\",\n \"0.6042202\",\n \"0.6042157\",\n \"0.60392064\",\n \"0.6037464\",\n \"0.6037089\",\n \"0.60369825\",\n \"0.602318\",\n \"0.6022892\",\n \"0.60131854\",\n \"0.60075134\",\n \"0.59898657\",\n \"0.59877604\",\n \"0.5983577\",\n \"0.5981331\",\n \"0.5981331\",\n \"0.59794235\",\n \"0.59735215\",\n \"0.5971959\",\n \"0.59706223\",\n \"0.5965144\",\n \"0.5952556\",\n \"0.59486234\",\n \"0.594258\",\n \"0.5930994\",\n \"0.5930687\",\n \"0.5922934\",\n \"0.5912988\",\n \"0.591267\",\n \"0.5903874\",\n \"0.5890443\",\n \"0.5873804\",\n \"0.58559054\",\n \"0.583713\",\n \"0.5834924\",\n \"0.58314604\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7737896"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":6389,"cells":{"query":{"kind":"string","value":"! HTTP route '/' Returns 'OK' successful response to the user."},"document":{"kind":"string","value":"def home():\n return response(\"OK\")"},"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 root():\n return Response(\"It's alive!\", status=200)","def root():\n if request.headers['Accept'] == 'application/json':\n return \"Welcome\\n\\n\", 200\n else:\n return redirect(url_for('index'))","def index():\n return Response(\n \"Welcome to basic-http-server, you're ready to add some methods!\\n\" +\n str(request) + \"\\n\", mimetype='text/plain'\n )","def get(self):\n self.response.write('ok')","def home_page():\n return \"pong\", 201, {'Content-Type': 'text/html'}","def root():\n return 'Hello', 200","def test_index_route():\n response = client.get(\"/\")\n assert response.status_code == status.HTTP_200_OK\n assert response.raw != None","def index():\n return (jsonify(status=\"OK\")), 200","def root():\n return {}, 200","def index():\n return 'OK'","def simple_handler(request):\n logger.debug('')\n return Response(200, 'OK', {}, '')","def root(self):\n return self.app.get('/',headers=self.headers)","def do_GET(self):\n self.send_response(200)\n self.send_header('Content-type','text/html')\n self.end_headers()\n # Send the message to browser\n self.wfile.write(\"Hello from server!\")\n return","def app(environ, start_response):\n headers = [('Content-type', 'text/plain; charset=utf-8')]\n\n path = environ['PATH_INFO']\n\n if path in Routes.registry:\n status = '200 OK'\n resp = bytes(Routes.registry[path](), 'utf-8')\n else:\n status = '404 Not Found'\n resp = b'Not Found'\n\n start_response(status, headers)\n return [resp + b'\\n']","def test_home_route_is_status_ok(self):\n response = self.client.get(\"/\")\n self.assertTrue(response.status_code == 200)","def test_home_status_code(self):\n result = self.app.get('/')\n self.assertEqual(result.status_code, 200)","def test_home(self):\n result = self.app.get('/')\n self.assertEqual(result.status_code, 200)","def testindex(self):\n rv = self.app.get('/')\n self.assertEqual(rv.status_code, 302, \"homepage didnot load\")","def index():\n response = jsonify(\n {'message':'Hello, RESTful API development!'}\n )\n \n return response, 200","def do_GET(self):\n if not self.path.endswith(\"/\"): self.path += \"/\"\n if self.path == \"/ping/\":\n msg = \"pong\".encode(\"UTF-8\")\n\n self.send_response(HTTPStatus.OK)\n self.send_header(\"Content-Type\", \"text/application\")\n self.send_header(\"Content-Length\", len(msg))\n self.end_headers()\n self.wfile.write(msg)\n else:\n self.send_response(HTTPStatus.BAD_REQUEST)\n self.end_headers()","def test_home(self):\n response = self.app.get(\"/\")\n self.assertTrue(response.status_code, 200)","def index():\n response.flash = \"Welcome to Myapp!\"\n return dict(message=T('Hello World'))","def url_root():\n return \"OK\"","def ping():\n\treturn HTTPResponse(status=200)","def index():\n\n return redirect(api)","def index():\n return jsonify({\"redirect\": \"home\"})","def get(self, request):\n return redirect('http://localhost:3000/')","def welcome():\n print(\"Server received request for 'Home' page...\")\n return (\n f\"Available Routes:<br/>\"\n f\"/api/v1.0/names<br/>\"\n f\"/api/v1.0/passengers\"\n )","def ping_response():\n\n return Response(\"ok\", status=200)","async def hello(self) -> httpx.Response:\n return await self._client.get(\"/hello\")","def index():\n return (jsonify({\n 'code': '1',\n 'msg': 'success',\n 'timestamp': get_current_timestamp(),\n }), 200)","def ping():\r\n return make_response(\"pong!\", 200)","def index():\n # curl -k -X POST https://127.0.0.1:43210/api/v1.0 -H 'content-type: application/json' -d '{\"data\": \"exhaust\"}'\n return jsonify({'meta': {'success': True, 'code': 200}, 'result': {\"message\": request.get_json()}}), 200","def home_page():\n return redirect(url_for(_DEFAULT_ROUTE, _external=True))","def empty_app(env, resp):\r\n resp('200 OK', [('Content-Type', 'text/plain')])\r\n return [b\"Enforcing Prefix\"]","def respond(self):\n req = self.req\n req_uri = bton(req.uri)\n if req_uri == '/':\n req.status = b'200 OK'\n req.ensure_headers_sent()\n req.write(b'Hello world!')\n return\n if req_uri == '/env':\n req.status = b'200 OK'\n req.ensure_headers_sent()\n env = self.get_environ()\n # drop files so that it can be json dumped\n env.pop('wsgi.errors')\n env.pop('wsgi.input')\n print(env)\n req.write(json.dumps(env).encode('utf-8'))\n return\n return super(HelloWorldGateway, self).respond()","def test_home(client):\n rv = client.get('/')\n assert 200 == rv.status_code","async def index(request: Request, user: UserInfo) -> HTTPResponse:\n return redirect('home')","def do_GET(self):\r\n self._send_handler_response('GET')","def index():\n return redirect('/client/index.html')","def test_success(self):\n response = self.client.get('/')\n self.assertEqual(response.status_code, 200)","def home():\n return make_response(open('app/templates/index.html').read())","def do_GET(self):\n if not self.path or self.path == \"/\":\n self.redirect()\n elif self.is_viewvc():\n try:\n self.run_viewvc()\n except IOError:\n # ignore IOError: [Errno 32] Broken pipe\n pass\n else:\n self.send_error(404)","def get(self):\n self.response.out.write(\"There's nothing to see here. How 'bout a \"\n \"<a href='/'>puzzle</a>?\")","def home_view(request):\n message = 'Hello World'\n return Response(body=message, status=200)","def test_get_main_route():\n response = client.get(url)\n assert response.status_code == 200","def index_file():\n return redirect(\"/\")","def test_index_endpoint(client):\n\n result = client.get('/')\n\n assert result.status_code == 302\n\n assert result.headers['Location'] == 'http://localhost/index.html'","def do_GET(self):\n # Extract path components from the path, ignore leading '/' and\n # discard empty values coming from '/' at the end or multiple\n # contiguous '/'.\n path_parts = [x for x in self.path[1:].split(\"/\") if x]\n if not path_parts:\n self.post_response(\n 200,\n \"The server is alive\",\n HMTL_TEMPLATE % (\"The server is alive\", \"The server is alive\", \"\"),\n )\n return\n\n # Return a correct error for browser favicon requests in order to\n # reduce confusing log messages that look bad but aren't.\n if len(path_parts) == 1 and path_parts[0] == \"favicon.ico\":\n self.send_error(404)\n return\n\n if path_parts[0] == \"sg2jira\":\n title = \"Shotgun to Jira\"\n elif path_parts[0] == \"jira2sg\":\n title = \"Jira to Shotgun\"\n else:\n self.send_error(400, \"Invalid request path %s\" % self.path)\n return\n\n settings_name = path_parts[1]\n if six.ensure_text(settings_name) not in self.server.sync_settings_names:\n self.send_error(400, \"Invalid settings name %s\" % settings_name)\n return\n\n # Success, send a basic html page.\n self.post_response(\n 200,\n six.ensure_binary(\"Syncing with %s settings.\" % settings_name),\n six.ensure_binary(\n HMTL_TEMPLATE\n % (title, title, \"Syncing with %s settings.\" % settings_name)\n ),\n )","def do_GET(self):\n #if self.path.startswith('/api/'):\n # f = self.send_response_headers('api call')\n #else:\n f=self.route()\n if f==False:\n f = self.send_head()\n if f:\n try:\n self.copyfile(f, self.wfile)\n finally:\n f.close()","def get(self, request):\n return redirect('start:home')","def get(self, request):\n return redirect('start:home')","def get(self, request):\n return redirect('start:home')","def basicRequest(self):\n endpoint = \"/foo\"\n\n def verify(request):\n o(request.method).equals(\"GET\")(\"Checking basic request method.\")\n o(request.url).equals(endpoint)(\"Checking basic request url.\")\n request.respond(200)\n self.testServer.respondWith(verify)\n\n server.request(endpoint)\n self.testServer.respond()","def index():\n print('This is the root of the app, should have something better')\n return 'Root, this is where some front end would go on a server'","def index(request):\r\n badRequest(\"Url not found\")","def index():\n response.flash = T(\"Hello World\")\n return dict(message=T('Welcome to web2py!'))","def index():\n response.flash = T(\"Hello World\")\n return dict(message=T('Welcome to web2py!'))","def do_GET(self): # pylint:disable=invalid-name\n if not self.is_log_path_valid():\n self.report_404()\n return\n scheme = \"https\" if self.server.cert is not None else \"http\"\n resp = '<html>'\n resp += '<head>\\n'\n resp += ' <title>{0}</title>\\n'.format(self.app_name)\n resp += '</head>\\n'\n resp += '<body>\\n'\n resp += ' <center>\\n'\n resp += ' <h2>{0} is working via {1}</h2>\\n'.format(self.app_name,\n scheme.upper())\n resp += ' </center>\\n'\n resp += ' <p>Please point your APIC at:<br /><br />'\n ip_add = [(s.connect((self.client_address[0], 80)), s.getsockname()[0],\n s.close()) for s in [socket.socket(socket.AF_INET,\n socket.SOCK_DGRAM)]][0][1]\n resp += ' {0}://{1}:{2}{3}</p>'.format(scheme, ip_add,\n self.server.server_address[\n 1],\n self.path)\n resp += '</body>\\n'\n resp += '</html>'\n self.send_200_resp(resp, \"text/html\")","def index():\n return redirect(url_for(\"home\"))","def do_GET(self):\n self.log.debug('do_GET called')\n self.HeadGet('GET')","def index():\n response.flash = T(\"Welcome to web2py!\")\n return dict(message=T('Hello World'))","def index():\n resp = make_response(render_template(\"index.html\", title='Home'))\n return resp","def index():\n # Message to the user\n message = {\n 'api_version': 'v1.0',\n 'status': '200',\n 'message': 'Welcome to the Flask API'\n }\n # Making the message looks good\n resp = jsonify(message)\n\n # Returning the object\n return resp","def test_index(self):\n resp = self.app.get('/')\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\n data = json.loads(resp.data)\n self.assertEqual(data['status'], 'success')","def test_index(self):\n r = self.client.get('/')\n self.assertEqual(r.status_code, 302)","def goblin(request, path):\n print \"This endpoint is throwing a 404 error!\"","def get(self):\n\n # Return a plain text response\n return self.plain_text_response(\"Alive!\", 200)","def index():\n response.view_title = myconf.get('app.name') + ' Home Page'\n return dict(message='')","def index():\n return 'Your api is up and running!'","def test_index_view(self):\n response = self.client.get('/')\n eq_(response.status_code, 200)","def health_check(request):\n return Response(\"OK\",\n status=status.HTTP_200_OK)","async def index_handler(req: web.Request) -> web.Response:\n if req.app[\"client_path\"] is None:\n try:\n client_path = await virtool.utils.get_client_path()\n except FileNotFoundError:\n return await client_path_error()\n\n req.app[\"client_path\"] = client_path\n req.app.router.add_static(\"/static\", client_path)\n\n force_reset = req[\"client\"].force_reset\n\n if req[\"client\"].user_id and not force_reset:\n path = os.path.join(req.app[\"client_path\"], \"index.html\")\n\n html = mako.template.Template(filename=path).render()\n\n html = html.replace(\"VERSION\", req.app[\"version\"])\n\n html = html.replace('\"DEV\"', \"true\" if req.app[\"settings\"][\"dev\"] else \"false\")\n\n return web.Response(body=html, content_type=\"text/html\")\n\n path_base = \"login\"\n\n if force_reset:\n path_base = \"reset\"\n\n return_to = get_return_to_from_path(req)\n\n return web.Response(status=302, headers={\"Location\": f\"/{path_base}?return_to={return_to}\"})","async def handle_index(request):\n text = 'Sanic server running on {0} port.'.format(str('??????'))\n text2 = '\\nLoop is {}'.format(str(asyncio.get_event_loop()))\n return request.Response(text=text+text2)","def index():\n return (\n f\"Welcome to the Climate App API!<br/>\"\n f\"Available Routes:<br/>\"\n f\"/api/v1.0/precipitation<br/>\"\n f\"/api/v1.0/stations<br/>\"\n f\"/api/v1.0/tobs<br/>\"\n f\"/api/v1.0/<start><br/>\"\n f\"/api/v1.0/<start>/<end>\"\n )","def main():\n listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n listen_socket.bind(('', int(sys.argv[1])))\n listen_socket.listen(1)\n\n while True:\n connection, address = listen_socket.accept()\n request = connection.recv(1024)\n start_line = request.split('\\n')[0]\n method, uri, version = start_line.split()\n path = DOCUMENT_ROOT + uri\n if not os.path.exists(path):\n connection.sendall('HTTP/1.1 404 Not Found\\n')\n else:\n with open(path) as file_handle:\n file_contents = file_handle.read()\n response = RESPONSE_TEMPLATE.format(\n len(file_contents), file_contents)\n connection.sendall(response)\n connection.close()","def do_GET(self):\n try:\n \n # parse the requested page and see if it's valid\n parse_status, explanation_str = self.parse_header(self.path)\n \n # parse_status:\n # -1: error\n # 0: /log/* request\n # 1: /detailed/node/timestamp request\n print str(self.parse_header(self.path))\n \n explanation_str = str(explanation_str)\n \n # error\n if parse_status == -1:\n # invalid header, close the connection and die but notify user\n self.send_response(200)\n self.send_header('Content-type',\t'text/html')\n self.end_headers()\n self.wfile.write('Invalid request ('+explanation_str+')')\n print '-1'\n return\n \n # 1: /detailed/node/timestamp request\n elif parse_status == 1:\n print '1'\n # just need to respond with the file that's contained in explanation_str\n # and once we verify that it exists, we're golden\n \n # path to the \"detailed\" file\n file_path = explanation_str\n \n if os.path.isfile(file_path):\n try:\n # TODO: make HTML here to nav around previous node things\n detailed_file_handle = open(file_path, 'r')\n self.send_response(200)\n self.send_header('Content-type',\t'text/plain')\n self.end_headers() \n self.wfile.write(detailed_file_handle.read())\n detailed_file_handle.close()\n return\n except Exception, e:\n print 'Error while sending detailed log file'\n print e\n return\n else:\n self.send_response(200)\n self.send_header('Content-type',\t'text/html')\n self.end_headers()\n self.wfile.write('Invalid file request')\n return\n \n # 0: /log/* request\n elif parse_status == 0:\n print '0'\n # request was successfull, we just want the filename from index\n log_index = explanation_str\n \n success_status, log_filename = self.get_filename_from_index(log_index)\n \n if success_status == -1:\n # some kind of error of which the description is stored in log_filename\n #sockobj.send('The server encountered an error opening the file, please'+\\\n # ' try your request again')\n self.send_response(200)\n self.send_header('Content-type',\t'text/html')\n self.end_headers() \n self.wfile.write('The server encountered an error opening the file, please'+\\\n ' try your request again')\n return\n \n # the file exists!\n # just dump the file at this point, and then...\n \n # send the HTML file\n self.send_response(200)\n self.send_header('Content-type',\t'text/html')\n self.end_headers()\n self.send_html_file(log_filename, log_index)\n return\n\n # invalid type\n else:\n self.send_response(200)\n self.send_header('Content-type',\t'text/html')\n self.end_headers()\n self.wfile.write('Invalid request type 2')\n return\n \n except IOError:\n self.send_error(404,'File Not Found: %s' % self.path)\n \n return","def do_GET(self):\n sep = self.path.find('?')\n path = self.path if sep == -1 else self.path[:sep]\n if path == '/externalpolicydata':\n http_response, raw_reply = self.HandleExternalPolicyDataRequest()\n elif path == '/configuration/test/exit':\n # This is not part of the standard DM server protocol.\n # This extension is added to make the test server exit gracefully\n # when the test is complete.\n self.server.stop = True\n http_response = 200\n raw_reply = 'OK'\n elif path == '/test/ping':\n # This path and reply are used by the test setup of host-driven tests for\n # Android to determine if the server is up, and are not part of the\n # DM protocol.\n http_response = 200\n raw_reply = 'Policy server is up.'\n else:\n http_response = 404\n raw_reply = 'Invalid path'\n self.send_response(http_response)\n self.end_headers()\n self.wfile.write(raw_reply)","def index(_):\n template = loader.get_template('route/home.html')\n return HttpResponse(template.render(Context({})))","def welcome_page():\n return redirect(\"/static/welcome.html\")","def test_health(self) -> None:\n self._response = self._app.get('/health')\n\n self.assertEqual(self._response.status, '200 OK')","def index():\n return \"Hello!\"","def test_if_home_is_successful(client):\n\n url = reverse(\"home\")\n response = client.get(url)\n assert response.status_code == 200","def index():\n return \"Hello, world!\"","def _route_get(self):\n if self.path == '/status':\n self._create_status()\n else:\n self._create_method_not_allowed()","def test_home_word(self):\r\n result = self.app.get('/hello_world')\r\n self.assertTrue(result.data, 'Hello')","def index(request):\r\n return requests.get(DaemonServer._mock_url + '/')","def test_status_home(self):\n self.assertEqual(200, self.response.status_code)","def test_home_exists(self):\n response = self.app.get('/')\n self.assertEqual(response.status_code, 200)","def ping():\n return jsonify({'response': 'pong'}), 200","def hello():\n\n usage_msg = \"<br/>\\n\".join([\"Welcome to WildLife: The REST APIs for \"\n \"ZooKeeper!<br/>\",\n hello.__doc__.replace(\"\\n\", \"<br/>\\n\")])\n\n return make_response(usage_msg, 200)","async def handle(request):\n text = 'Japronto server running on {0} port. Hello, {1}'.format(\n str('??????'), str(request.match_dict['name']))\n return request.Response(text=text)","def test_root_response():\n request, response = app.test_client.get(\"/info.json\")\n assert response.status == 200","def homepage():\n return redirect('index.html')","def app(environ: t.Dict, start_response):\n # Print the request object details in environ.items()\n for k, v in environ.items():\n print(k, v)\n\n # Let's capture the request path\n path = environ.get(\"PATH_INFO\")\n\n # Handle our different routes. Render different templates.\n # Allow user to add \"/\" or not to URL string\n # NOTE: Don't use elif statement! It skips 'data' assignment!\n if path.endswith(\"/\"):\n path = path[:-1] # remove the trailing \"/\"\n if path == \"\": # the root / index\n data = home(environ)\n elif path == \"/contact\":\n data = contact_us(environ)\n elif path == \"/box-office\":\n data = read_box_office_data(environ)\n else:\n data = render_template(template_name=\"404.html\", context={\"path\": path})\n\n # Encode data to BYTE string\n data = data.encode(\"utf-8\")\n\n # Gunicorn's start_response to get a response going\n start_response(\n f\"200 OK\",\n [(\"Content-Type\", \"text/html\"), (\"Content-Length\", str(len(data)))],\n # You can remove these headers and the browser will still parse it.\n # Modern browsers are smart enough to infer how to parse the request\n )\n # Where does this print to? Server logs I bet... YES!\n # print(f\"{data=}\\n{iter([data])}\")\n return iter([data]) # <list_iterator object at 0x10f9f1340>","def health_check():\n app.logger.info(\"Health Check!\")\n return Response(\"All Good!\", status=200)","def url_health():\n return \"OK\"","def test_root(self):\n self.skipTest(\"\")\n response = self.fetch('/')\n self.assertEqual(response.code, 404)","def on_get(self, req, resp, account, container):\n with open('index.html') as fp:\n resp.body = fp.read()\n resp.content_type = 'text/html; charset=utf-8'\n resp.status = falcon.HTTP_200","def _healthcheck():\n return '', 200"],"string":"[\n \"def root():\\n return Response(\\\"It's alive!\\\", status=200)\",\n \"def root():\\n if request.headers['Accept'] == 'application/json':\\n return \\\"Welcome\\\\n\\\\n\\\", 200\\n else:\\n return redirect(url_for('index'))\",\n \"def index():\\n return Response(\\n \\\"Welcome to basic-http-server, you're ready to add some methods!\\\\n\\\" +\\n str(request) + \\\"\\\\n\\\", mimetype='text/plain'\\n )\",\n \"def get(self):\\n self.response.write('ok')\",\n \"def home_page():\\n return \\\"pong\\\", 201, {'Content-Type': 'text/html'}\",\n \"def root():\\n return 'Hello', 200\",\n \"def test_index_route():\\n response = client.get(\\\"/\\\")\\n assert response.status_code == status.HTTP_200_OK\\n assert response.raw != None\",\n \"def index():\\n return (jsonify(status=\\\"OK\\\")), 200\",\n \"def root():\\n return {}, 200\",\n \"def index():\\n return 'OK'\",\n \"def simple_handler(request):\\n logger.debug('')\\n return Response(200, 'OK', {}, '')\",\n \"def root(self):\\n return self.app.get('/',headers=self.headers)\",\n \"def do_GET(self):\\n self.send_response(200)\\n self.send_header('Content-type','text/html')\\n self.end_headers()\\n # Send the message to browser\\n self.wfile.write(\\\"Hello from server!\\\")\\n return\",\n \"def app(environ, start_response):\\n headers = [('Content-type', 'text/plain; charset=utf-8')]\\n\\n path = environ['PATH_INFO']\\n\\n if path in Routes.registry:\\n status = '200 OK'\\n resp = bytes(Routes.registry[path](), 'utf-8')\\n else:\\n status = '404 Not Found'\\n resp = b'Not Found'\\n\\n start_response(status, headers)\\n return [resp + b'\\\\n']\",\n \"def test_home_route_is_status_ok(self):\\n response = self.client.get(\\\"/\\\")\\n self.assertTrue(response.status_code == 200)\",\n \"def test_home_status_code(self):\\n result = self.app.get('/')\\n self.assertEqual(result.status_code, 200)\",\n \"def test_home(self):\\n result = self.app.get('/')\\n self.assertEqual(result.status_code, 200)\",\n \"def testindex(self):\\n rv = self.app.get('/')\\n self.assertEqual(rv.status_code, 302, \\\"homepage didnot load\\\")\",\n \"def index():\\n response = jsonify(\\n {'message':'Hello, RESTful API development!'}\\n )\\n \\n return response, 200\",\n \"def do_GET(self):\\n if not self.path.endswith(\\\"/\\\"): self.path += \\\"/\\\"\\n if self.path == \\\"/ping/\\\":\\n msg = \\\"pong\\\".encode(\\\"UTF-8\\\")\\n\\n self.send_response(HTTPStatus.OK)\\n self.send_header(\\\"Content-Type\\\", \\\"text/application\\\")\\n self.send_header(\\\"Content-Length\\\", len(msg))\\n self.end_headers()\\n self.wfile.write(msg)\\n else:\\n self.send_response(HTTPStatus.BAD_REQUEST)\\n self.end_headers()\",\n \"def test_home(self):\\n response = self.app.get(\\\"/\\\")\\n self.assertTrue(response.status_code, 200)\",\n \"def index():\\n response.flash = \\\"Welcome to Myapp!\\\"\\n return dict(message=T('Hello World'))\",\n \"def url_root():\\n return \\\"OK\\\"\",\n \"def ping():\\n\\treturn HTTPResponse(status=200)\",\n \"def index():\\n\\n return redirect(api)\",\n \"def index():\\n return jsonify({\\\"redirect\\\": \\\"home\\\"})\",\n \"def get(self, request):\\n return redirect('http://localhost:3000/')\",\n \"def welcome():\\n print(\\\"Server received request for 'Home' page...\\\")\\n return (\\n f\\\"Available Routes:<br/>\\\"\\n f\\\"/api/v1.0/names<br/>\\\"\\n f\\\"/api/v1.0/passengers\\\"\\n )\",\n \"def ping_response():\\n\\n return Response(\\\"ok\\\", status=200)\",\n \"async def hello(self) -> httpx.Response:\\n return await self._client.get(\\\"/hello\\\")\",\n \"def index():\\n return (jsonify({\\n 'code': '1',\\n 'msg': 'success',\\n 'timestamp': get_current_timestamp(),\\n }), 200)\",\n \"def ping():\\r\\n return make_response(\\\"pong!\\\", 200)\",\n \"def index():\\n # curl -k -X POST https://127.0.0.1:43210/api/v1.0 -H 'content-type: application/json' -d '{\\\"data\\\": \\\"exhaust\\\"}'\\n return jsonify({'meta': {'success': True, 'code': 200}, 'result': {\\\"message\\\": request.get_json()}}), 200\",\n \"def home_page():\\n return redirect(url_for(_DEFAULT_ROUTE, _external=True))\",\n \"def empty_app(env, resp):\\r\\n resp('200 OK', [('Content-Type', 'text/plain')])\\r\\n return [b\\\"Enforcing Prefix\\\"]\",\n \"def respond(self):\\n req = self.req\\n req_uri = bton(req.uri)\\n if req_uri == '/':\\n req.status = b'200 OK'\\n req.ensure_headers_sent()\\n req.write(b'Hello world!')\\n return\\n if req_uri == '/env':\\n req.status = b'200 OK'\\n req.ensure_headers_sent()\\n env = self.get_environ()\\n # drop files so that it can be json dumped\\n env.pop('wsgi.errors')\\n env.pop('wsgi.input')\\n print(env)\\n req.write(json.dumps(env).encode('utf-8'))\\n return\\n return super(HelloWorldGateway, self).respond()\",\n \"def test_home(client):\\n rv = client.get('/')\\n assert 200 == rv.status_code\",\n \"async def index(request: Request, user: UserInfo) -> HTTPResponse:\\n return redirect('home')\",\n \"def do_GET(self):\\r\\n self._send_handler_response('GET')\",\n \"def index():\\n return redirect('/client/index.html')\",\n \"def test_success(self):\\n response = self.client.get('/')\\n self.assertEqual(response.status_code, 200)\",\n \"def home():\\n return make_response(open('app/templates/index.html').read())\",\n \"def do_GET(self):\\n if not self.path or self.path == \\\"/\\\":\\n self.redirect()\\n elif self.is_viewvc():\\n try:\\n self.run_viewvc()\\n except IOError:\\n # ignore IOError: [Errno 32] Broken pipe\\n pass\\n else:\\n self.send_error(404)\",\n \"def get(self):\\n self.response.out.write(\\\"There's nothing to see here. How 'bout a \\\"\\n \\\"<a href='/'>puzzle</a>?\\\")\",\n \"def home_view(request):\\n message = 'Hello World'\\n return Response(body=message, status=200)\",\n \"def test_get_main_route():\\n response = client.get(url)\\n assert response.status_code == 200\",\n \"def index_file():\\n return redirect(\\\"/\\\")\",\n \"def test_index_endpoint(client):\\n\\n result = client.get('/')\\n\\n assert result.status_code == 302\\n\\n assert result.headers['Location'] == 'http://localhost/index.html'\",\n \"def do_GET(self):\\n # Extract path components from the path, ignore leading '/' and\\n # discard empty values coming from '/' at the end or multiple\\n # contiguous '/'.\\n path_parts = [x for x in self.path[1:].split(\\\"/\\\") if x]\\n if not path_parts:\\n self.post_response(\\n 200,\\n \\\"The server is alive\\\",\\n HMTL_TEMPLATE % (\\\"The server is alive\\\", \\\"The server is alive\\\", \\\"\\\"),\\n )\\n return\\n\\n # Return a correct error for browser favicon requests in order to\\n # reduce confusing log messages that look bad but aren't.\\n if len(path_parts) == 1 and path_parts[0] == \\\"favicon.ico\\\":\\n self.send_error(404)\\n return\\n\\n if path_parts[0] == \\\"sg2jira\\\":\\n title = \\\"Shotgun to Jira\\\"\\n elif path_parts[0] == \\\"jira2sg\\\":\\n title = \\\"Jira to Shotgun\\\"\\n else:\\n self.send_error(400, \\\"Invalid request path %s\\\" % self.path)\\n return\\n\\n settings_name = path_parts[1]\\n if six.ensure_text(settings_name) not in self.server.sync_settings_names:\\n self.send_error(400, \\\"Invalid settings name %s\\\" % settings_name)\\n return\\n\\n # Success, send a basic html page.\\n self.post_response(\\n 200,\\n six.ensure_binary(\\\"Syncing with %s settings.\\\" % settings_name),\\n six.ensure_binary(\\n HMTL_TEMPLATE\\n % (title, title, \\\"Syncing with %s settings.\\\" % settings_name)\\n ),\\n )\",\n \"def do_GET(self):\\n #if self.path.startswith('/api/'):\\n # f = self.send_response_headers('api call')\\n #else:\\n f=self.route()\\n if f==False:\\n f = self.send_head()\\n if f:\\n try:\\n self.copyfile(f, self.wfile)\\n finally:\\n f.close()\",\n \"def get(self, request):\\n return redirect('start:home')\",\n \"def get(self, request):\\n return redirect('start:home')\",\n \"def get(self, request):\\n return redirect('start:home')\",\n \"def basicRequest(self):\\n endpoint = \\\"/foo\\\"\\n\\n def verify(request):\\n o(request.method).equals(\\\"GET\\\")(\\\"Checking basic request method.\\\")\\n o(request.url).equals(endpoint)(\\\"Checking basic request url.\\\")\\n request.respond(200)\\n self.testServer.respondWith(verify)\\n\\n server.request(endpoint)\\n self.testServer.respond()\",\n \"def index():\\n print('This is the root of the app, should have something better')\\n return 'Root, this is where some front end would go on a server'\",\n \"def index(request):\\r\\n badRequest(\\\"Url not found\\\")\",\n \"def index():\\n response.flash = T(\\\"Hello World\\\")\\n return dict(message=T('Welcome to web2py!'))\",\n \"def index():\\n response.flash = T(\\\"Hello World\\\")\\n return dict(message=T('Welcome to web2py!'))\",\n \"def do_GET(self): # pylint:disable=invalid-name\\n if not self.is_log_path_valid():\\n self.report_404()\\n return\\n scheme = \\\"https\\\" if self.server.cert is not None else \\\"http\\\"\\n resp = '<html>'\\n resp += '<head>\\\\n'\\n resp += ' <title>{0}</title>\\\\n'.format(self.app_name)\\n resp += '</head>\\\\n'\\n resp += '<body>\\\\n'\\n resp += ' <center>\\\\n'\\n resp += ' <h2>{0} is working via {1}</h2>\\\\n'.format(self.app_name,\\n scheme.upper())\\n resp += ' </center>\\\\n'\\n resp += ' <p>Please point your APIC at:<br /><br />'\\n ip_add = [(s.connect((self.client_address[0], 80)), s.getsockname()[0],\\n s.close()) for s in [socket.socket(socket.AF_INET,\\n socket.SOCK_DGRAM)]][0][1]\\n resp += ' {0}://{1}:{2}{3}</p>'.format(scheme, ip_add,\\n self.server.server_address[\\n 1],\\n self.path)\\n resp += '</body>\\\\n'\\n resp += '</html>'\\n self.send_200_resp(resp, \\\"text/html\\\")\",\n \"def index():\\n return redirect(url_for(\\\"home\\\"))\",\n \"def do_GET(self):\\n self.log.debug('do_GET called')\\n self.HeadGet('GET')\",\n \"def index():\\n response.flash = T(\\\"Welcome to web2py!\\\")\\n return dict(message=T('Hello World'))\",\n \"def index():\\n resp = make_response(render_template(\\\"index.html\\\", title='Home'))\\n return resp\",\n \"def index():\\n # Message to the user\\n message = {\\n 'api_version': 'v1.0',\\n 'status': '200',\\n 'message': 'Welcome to the Flask API'\\n }\\n # Making the message looks good\\n resp = jsonify(message)\\n\\n # Returning the object\\n return resp\",\n \"def test_index(self):\\n resp = self.app.get('/')\\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\\n data = json.loads(resp.data)\\n self.assertEqual(data['status'], 'success')\",\n \"def test_index(self):\\n r = self.client.get('/')\\n self.assertEqual(r.status_code, 302)\",\n \"def goblin(request, path):\\n print \\\"This endpoint is throwing a 404 error!\\\"\",\n \"def get(self):\\n\\n # Return a plain text response\\n return self.plain_text_response(\\\"Alive!\\\", 200)\",\n \"def index():\\n response.view_title = myconf.get('app.name') + ' Home Page'\\n return dict(message='')\",\n \"def index():\\n return 'Your api is up and running!'\",\n \"def test_index_view(self):\\n response = self.client.get('/')\\n eq_(response.status_code, 200)\",\n \"def health_check(request):\\n return Response(\\\"OK\\\",\\n status=status.HTTP_200_OK)\",\n \"async def index_handler(req: web.Request) -> web.Response:\\n if req.app[\\\"client_path\\\"] is None:\\n try:\\n client_path = await virtool.utils.get_client_path()\\n except FileNotFoundError:\\n return await client_path_error()\\n\\n req.app[\\\"client_path\\\"] = client_path\\n req.app.router.add_static(\\\"/static\\\", client_path)\\n\\n force_reset = req[\\\"client\\\"].force_reset\\n\\n if req[\\\"client\\\"].user_id and not force_reset:\\n path = os.path.join(req.app[\\\"client_path\\\"], \\\"index.html\\\")\\n\\n html = mako.template.Template(filename=path).render()\\n\\n html = html.replace(\\\"VERSION\\\", req.app[\\\"version\\\"])\\n\\n html = html.replace('\\\"DEV\\\"', \\\"true\\\" if req.app[\\\"settings\\\"][\\\"dev\\\"] else \\\"false\\\")\\n\\n return web.Response(body=html, content_type=\\\"text/html\\\")\\n\\n path_base = \\\"login\\\"\\n\\n if force_reset:\\n path_base = \\\"reset\\\"\\n\\n return_to = get_return_to_from_path(req)\\n\\n return web.Response(status=302, headers={\\\"Location\\\": f\\\"/{path_base}?return_to={return_to}\\\"})\",\n \"async def handle_index(request):\\n text = 'Sanic server running on {0} port.'.format(str('??????'))\\n text2 = '\\\\nLoop is {}'.format(str(asyncio.get_event_loop()))\\n return request.Response(text=text+text2)\",\n \"def index():\\n return (\\n f\\\"Welcome to the Climate App API!<br/>\\\"\\n f\\\"Available Routes:<br/>\\\"\\n f\\\"/api/v1.0/precipitation<br/>\\\"\\n f\\\"/api/v1.0/stations<br/>\\\"\\n f\\\"/api/v1.0/tobs<br/>\\\"\\n f\\\"/api/v1.0/<start><br/>\\\"\\n f\\\"/api/v1.0/<start>/<end>\\\"\\n )\",\n \"def main():\\n listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n listen_socket.bind(('', int(sys.argv[1])))\\n listen_socket.listen(1)\\n\\n while True:\\n connection, address = listen_socket.accept()\\n request = connection.recv(1024)\\n start_line = request.split('\\\\n')[0]\\n method, uri, version = start_line.split()\\n path = DOCUMENT_ROOT + uri\\n if not os.path.exists(path):\\n connection.sendall('HTTP/1.1 404 Not Found\\\\n')\\n else:\\n with open(path) as file_handle:\\n file_contents = file_handle.read()\\n response = RESPONSE_TEMPLATE.format(\\n len(file_contents), file_contents)\\n connection.sendall(response)\\n connection.close()\",\n \"def do_GET(self):\\n try:\\n \\n # parse the requested page and see if it's valid\\n parse_status, explanation_str = self.parse_header(self.path)\\n \\n # parse_status:\\n # -1: error\\n # 0: /log/* request\\n # 1: /detailed/node/timestamp request\\n print str(self.parse_header(self.path))\\n \\n explanation_str = str(explanation_str)\\n \\n # error\\n if parse_status == -1:\\n # invalid header, close the connection and die but notify user\\n self.send_response(200)\\n self.send_header('Content-type',\\t'text/html')\\n self.end_headers()\\n self.wfile.write('Invalid request ('+explanation_str+')')\\n print '-1'\\n return\\n \\n # 1: /detailed/node/timestamp request\\n elif parse_status == 1:\\n print '1'\\n # just need to respond with the file that's contained in explanation_str\\n # and once we verify that it exists, we're golden\\n \\n # path to the \\\"detailed\\\" file\\n file_path = explanation_str\\n \\n if os.path.isfile(file_path):\\n try:\\n # TODO: make HTML here to nav around previous node things\\n detailed_file_handle = open(file_path, 'r')\\n self.send_response(200)\\n self.send_header('Content-type',\\t'text/plain')\\n self.end_headers() \\n self.wfile.write(detailed_file_handle.read())\\n detailed_file_handle.close()\\n return\\n except Exception, e:\\n print 'Error while sending detailed log file'\\n print e\\n return\\n else:\\n self.send_response(200)\\n self.send_header('Content-type',\\t'text/html')\\n self.end_headers()\\n self.wfile.write('Invalid file request')\\n return\\n \\n # 0: /log/* request\\n elif parse_status == 0:\\n print '0'\\n # request was successfull, we just want the filename from index\\n log_index = explanation_str\\n \\n success_status, log_filename = self.get_filename_from_index(log_index)\\n \\n if success_status == -1:\\n # some kind of error of which the description is stored in log_filename\\n #sockobj.send('The server encountered an error opening the file, please'+\\\\\\n # ' try your request again')\\n self.send_response(200)\\n self.send_header('Content-type',\\t'text/html')\\n self.end_headers() \\n self.wfile.write('The server encountered an error opening the file, please'+\\\\\\n ' try your request again')\\n return\\n \\n # the file exists!\\n # just dump the file at this point, and then...\\n \\n # send the HTML file\\n self.send_response(200)\\n self.send_header('Content-type',\\t'text/html')\\n self.end_headers()\\n self.send_html_file(log_filename, log_index)\\n return\\n\\n # invalid type\\n else:\\n self.send_response(200)\\n self.send_header('Content-type',\\t'text/html')\\n self.end_headers()\\n self.wfile.write('Invalid request type 2')\\n return\\n \\n except IOError:\\n self.send_error(404,'File Not Found: %s' % self.path)\\n \\n return\",\n \"def do_GET(self):\\n sep = self.path.find('?')\\n path = self.path if sep == -1 else self.path[:sep]\\n if path == '/externalpolicydata':\\n http_response, raw_reply = self.HandleExternalPolicyDataRequest()\\n elif path == '/configuration/test/exit':\\n # This is not part of the standard DM server protocol.\\n # This extension is added to make the test server exit gracefully\\n # when the test is complete.\\n self.server.stop = True\\n http_response = 200\\n raw_reply = 'OK'\\n elif path == '/test/ping':\\n # This path and reply are used by the test setup of host-driven tests for\\n # Android to determine if the server is up, and are not part of the\\n # DM protocol.\\n http_response = 200\\n raw_reply = 'Policy server is up.'\\n else:\\n http_response = 404\\n raw_reply = 'Invalid path'\\n self.send_response(http_response)\\n self.end_headers()\\n self.wfile.write(raw_reply)\",\n \"def index(_):\\n template = loader.get_template('route/home.html')\\n return HttpResponse(template.render(Context({})))\",\n \"def welcome_page():\\n return redirect(\\\"/static/welcome.html\\\")\",\n \"def test_health(self) -> None:\\n self._response = self._app.get('/health')\\n\\n self.assertEqual(self._response.status, '200 OK')\",\n \"def index():\\n return \\\"Hello!\\\"\",\n \"def test_if_home_is_successful(client):\\n\\n url = reverse(\\\"home\\\")\\n response = client.get(url)\\n assert response.status_code == 200\",\n \"def index():\\n return \\\"Hello, world!\\\"\",\n \"def _route_get(self):\\n if self.path == '/status':\\n self._create_status()\\n else:\\n self._create_method_not_allowed()\",\n \"def test_home_word(self):\\r\\n result = self.app.get('/hello_world')\\r\\n self.assertTrue(result.data, 'Hello')\",\n \"def index(request):\\r\\n return requests.get(DaemonServer._mock_url + '/')\",\n \"def test_status_home(self):\\n self.assertEqual(200, self.response.status_code)\",\n \"def test_home_exists(self):\\n response = self.app.get('/')\\n self.assertEqual(response.status_code, 200)\",\n \"def ping():\\n return jsonify({'response': 'pong'}), 200\",\n \"def hello():\\n\\n usage_msg = \\\"<br/>\\\\n\\\".join([\\\"Welcome to WildLife: The REST APIs for \\\"\\n \\\"ZooKeeper!<br/>\\\",\\n hello.__doc__.replace(\\\"\\\\n\\\", \\\"<br/>\\\\n\\\")])\\n\\n return make_response(usage_msg, 200)\",\n \"async def handle(request):\\n text = 'Japronto server running on {0} port. Hello, {1}'.format(\\n str('??????'), str(request.match_dict['name']))\\n return request.Response(text=text)\",\n \"def test_root_response():\\n request, response = app.test_client.get(\\\"/info.json\\\")\\n assert response.status == 200\",\n \"def homepage():\\n return redirect('index.html')\",\n \"def app(environ: t.Dict, start_response):\\n # Print the request object details in environ.items()\\n for k, v in environ.items():\\n print(k, v)\\n\\n # Let's capture the request path\\n path = environ.get(\\\"PATH_INFO\\\")\\n\\n # Handle our different routes. Render different templates.\\n # Allow user to add \\\"/\\\" or not to URL string\\n # NOTE: Don't use elif statement! It skips 'data' assignment!\\n if path.endswith(\\\"/\\\"):\\n path = path[:-1] # remove the trailing \\\"/\\\"\\n if path == \\\"\\\": # the root / index\\n data = home(environ)\\n elif path == \\\"/contact\\\":\\n data = contact_us(environ)\\n elif path == \\\"/box-office\\\":\\n data = read_box_office_data(environ)\\n else:\\n data = render_template(template_name=\\\"404.html\\\", context={\\\"path\\\": path})\\n\\n # Encode data to BYTE string\\n data = data.encode(\\\"utf-8\\\")\\n\\n # Gunicorn's start_response to get a response going\\n start_response(\\n f\\\"200 OK\\\",\\n [(\\\"Content-Type\\\", \\\"text/html\\\"), (\\\"Content-Length\\\", str(len(data)))],\\n # You can remove these headers and the browser will still parse it.\\n # Modern browsers are smart enough to infer how to parse the request\\n )\\n # Where does this print to? Server logs I bet... YES!\\n # print(f\\\"{data=}\\\\n{iter([data])}\\\")\\n return iter([data]) # <list_iterator object at 0x10f9f1340>\",\n \"def health_check():\\n app.logger.info(\\\"Health Check!\\\")\\n return Response(\\\"All Good!\\\", status=200)\",\n \"def url_health():\\n return \\\"OK\\\"\",\n \"def test_root(self):\\n self.skipTest(\\\"\\\")\\n response = self.fetch('/')\\n self.assertEqual(response.code, 404)\",\n \"def on_get(self, req, resp, account, container):\\n with open('index.html') as fp:\\n resp.body = fp.read()\\n resp.content_type = 'text/html; charset=utf-8'\\n resp.status = falcon.HTTP_200\",\n \"def _healthcheck():\\n return '', 200\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8000715","0.76302844","0.7217383","0.7034739","0.6969286","0.69551736","0.6937947","0.69072324","0.684836","0.6830389","0.68042636","0.67833495","0.6741848","0.6703643","0.66771775","0.6644887","0.6582273","0.6569342","0.65503997","0.6548875","0.65412045","0.65196544","0.6517131","0.65148467","0.65065587","0.65033567","0.64407283","0.643769","0.64214444","0.64202136","0.6369991","0.6358031","0.6352942","0.6347339","0.6321867","0.62992597","0.6285901","0.627118","0.62653875","0.62409335","0.62406105","0.62246954","0.62098634","0.6204047","0.6197562","0.61911035","0.6185126","0.6185082","0.6173225","0.6157244","0.6152998","0.6152998","0.6152998","0.6147368","0.61258453","0.61209947","0.6114092","0.6114092","0.6100233","0.6096737","0.60895956","0.60794264","0.6066802","0.6065027","0.6063968","0.60618764","0.6059956","0.6053361","0.60493314","0.60469407","0.60467017","0.60432583","0.60399127","0.60367143","0.6027488","0.6024074","0.6022693","0.6012777","0.5998046","0.59870523","0.5984757","0.59817886","0.5981714","0.5980094","0.5977861","0.5976768","0.59696835","0.59673166","0.5966775","0.596092","0.59602004","0.595675","0.59481347","0.59453547","0.59444183","0.59304184","0.5926461","0.5925454","0.59156036","0.59146196"],"string":"[\n \"0.8000715\",\n \"0.76302844\",\n \"0.7217383\",\n \"0.7034739\",\n \"0.6969286\",\n \"0.69551736\",\n \"0.6937947\",\n \"0.69072324\",\n \"0.684836\",\n \"0.6830389\",\n \"0.68042636\",\n \"0.67833495\",\n \"0.6741848\",\n \"0.6703643\",\n \"0.66771775\",\n \"0.6644887\",\n \"0.6582273\",\n \"0.6569342\",\n \"0.65503997\",\n \"0.6548875\",\n \"0.65412045\",\n \"0.65196544\",\n \"0.6517131\",\n \"0.65148467\",\n \"0.65065587\",\n \"0.65033567\",\n \"0.64407283\",\n \"0.643769\",\n \"0.64214444\",\n \"0.64202136\",\n \"0.6369991\",\n \"0.6358031\",\n \"0.6352942\",\n \"0.6347339\",\n \"0.6321867\",\n \"0.62992597\",\n \"0.6285901\",\n \"0.627118\",\n \"0.62653875\",\n \"0.62409335\",\n \"0.62406105\",\n \"0.62246954\",\n \"0.62098634\",\n \"0.6204047\",\n \"0.6197562\",\n \"0.61911035\",\n \"0.6185126\",\n \"0.6185082\",\n \"0.6173225\",\n \"0.6157244\",\n \"0.6152998\",\n \"0.6152998\",\n \"0.6152998\",\n \"0.6147368\",\n \"0.61258453\",\n \"0.61209947\",\n \"0.6114092\",\n \"0.6114092\",\n \"0.6100233\",\n \"0.6096737\",\n \"0.60895956\",\n \"0.60794264\",\n \"0.6066802\",\n \"0.6065027\",\n \"0.6063968\",\n \"0.60618764\",\n \"0.6059956\",\n \"0.6053361\",\n \"0.60493314\",\n \"0.60469407\",\n \"0.60467017\",\n \"0.60432583\",\n \"0.60399127\",\n \"0.60367143\",\n \"0.6027488\",\n \"0.6024074\",\n \"0.6022693\",\n \"0.6012777\",\n \"0.5998046\",\n \"0.59870523\",\n \"0.5984757\",\n \"0.59817886\",\n \"0.5981714\",\n \"0.5980094\",\n \"0.5977861\",\n \"0.5976768\",\n \"0.59696835\",\n \"0.59673166\",\n \"0.5966775\",\n \"0.596092\",\n \"0.59602004\",\n \"0.595675\",\n \"0.59481347\",\n \"0.59453547\",\n \"0.59444183\",\n \"0.59304184\",\n \"0.5926461\",\n \"0.5925454\",\n \"0.59156036\",\n \"0.59146196\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7412834"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":6390,"cells":{"query":{"kind":"string","value":"! HTTP route '/api/tasks/' API endpoint for manipulating tasks. Allows GET, POST and DELETE requests."},"document":{"kind":"string","value":"def kamel_get():\n client = create_client()\n task_name = request.args.get('name')\n\n if request.method == \"GET\":\n if task_name is not None:\n # describe behavior\n stdin, stdout, stderr = client.exec_command(f\"/usr/local/bin/kamel describe integration {task_name}\") # noqa\n body = stdout.read().decode(\"utf-8\")\n return response(body)\n\n stdin, stdout, stderr = client.exec_command(\"/usr/local/bin/kamel get\") # noqa\n body = stdout.read().decode(\"utf-8\")\n return response(body)\n\n if request.method == \"POST\":\n # get files from client\n file_name = request.form['name']\n f = request.files['file']\n content = f.read()\n\n # if file exists remove it\n if os.path.exists(f'/Users/she393/Documents/{file_name}'):\n os.remove(f'/Users/she393/Documents/{file_name}')\n\n # write file to remote\n sftp = client.open_sftp()\n f = sftp.file(f'/Users/she393/Documents/{file_name}', 'a', -1)\n f.write(content.decode('utf-8'))\n f.flush()\n sftp.close()\n\n # run and return output to client\n stdin, stdout, stderr = client.exec_command(f\"/usr/local/bin/kamel run /Users/she393/Documents/{file_name}\") # noqa\n body = stdout.read().decode(\"utf-8\")\n print(stderr)\n return response(body)\n\n if request.method == \"DELETE\":\n stdin, stdout, stderr = client.exec_command(f\"/usr/local/bin/kamel delete {task_name}\") # noqa\n body = stdout.read().decode(\"utf-8\")\n return response(body)"},"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 handle_tasks(self, request):\n \"\"\"\n @api {get} /tasks List tasks\n @apiName GetTasks\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Return a list of all configured tasks, along with their configuration.\n\n @apiSuccessExample {json} Example response:\n {\n \"021b2092ef4111e481a852540064e600\": {\n \"name\": \"task 1\",\n \"enabled\": true,\n \"mode\": \"all\",\n \"pools\": [\"web\"],\n \"schedules\": [\n {\"minute\": [\"*/5\"]}\n ],\n \"command\": \"/bin/task1\",\n },\n \"508b4b72e44611e49e76c81f66cd0cca\": {\n \"name\": \"task 2\",\n \"enabled\": false,\n \"mode\": \"all\",\n \"pools\": [\"pool2\"],\n \"schedules\": [\n {\"hours\": [15], \"minutes\": [0]}\n ],\n \"command\": \"/bin/task2\",\n }\n }\n \"\"\"\n \"\"\"\n @api {post} /tasks Create a new task\n @apiName PostTasks\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Add a new task, providing its configuration.\n\n @apiParam {String} name Name.\n @apiParam {String} description Description.\n @apiParam {String[]} tags Tags.\n @apiParam {Boolean} enabled Task is enabled.\n @apiParam {String} mode Task mode (\"any\" or \"all\").\n @apiParam {String[]} pools Pools on which the task should run.\n @apiParam {Object[]} schedules Schedules at which the task should run.\n @apiParam {String} command Command to run.\n @apiParam {String} workdir Working directory.\n @apiParam {String} user User which the task will be run.\n @apiParam {String} group Group which the task will be run.\n @apiParam {Object} env Environment variables to set.\n @apiParam {String} mailreport If the mailer plugin is enabled, condition to send a report (\"error\", \"stdout\", \"stderr\", \"output\", \"always\").\n @apiParam {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\n\n @apiParamExample {json} Example parameters:\n {\n \"name\": \"My task\",\n \"description\": \"Task description\",\n \"tags\": [\"tasg1\", \"tag2\"],\n \"enabled\": true,\n \"mode\": \"all\",\n \"pools\": [\"web\"],\n \"schedules\": [\n {\"minute\": [\"*/1\"]}\n ],\n \"command\": \"/bin/true\",\n \"workdir\": \"/tmp/\",\n \"user\": \"www-data\",\n \"group\": \"www-data\",\n \"env\": {\n \"MYENVVAR\": \"myvalue\"\n },\n \"mailreport\": \"output\",\n \"mailto\": [\"user@domain.org\"]\n }\n\n @apiSuccess {Boolean} created The task has been created.\n @apiSuccess {String} id ID of the newly created task.\n\n @apiSuccessExample {json} Example response:\n {\n \"created\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n \"\"\"\n @api {delete} /tasks Delete all tasks\n @apiName DeleteTasks\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Delete all tasks. Use with caution.\n\n @apiSuccess {Boolean} deleted The tasks have been deleted.\n\n @apiSuccessExample {json} Example response:\n {\n \"deleted\": true\n }\n \"\"\"\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n\n if request.method == \"GET\":\n tasks = self.cluster.config.get('tasks')\n\n if 'tag' in request.args and request.args['tag']:\n tasks = dict( (taskid, task) for taskid, task in tasks.items() if 'tags' in task and request.args['tag'] in task['tags'] )\n\n return HTTPReply(code = 200, body = json.dumps(tasks), headers = headers)\n\n elif request.method == \"DELETE\":\n oldtasks = self.cluster.config.get('tasks')\n self.cluster.config.set('tasks', {})\n\n for (task, taskconfig) in oldtasks.items():\n get_plugin_registry().call_hook('TaskDeleted', task, taskconfig)\n\n return HTTPReply(code = 200, body = json.dumps({\"deleted\": True}), headers = headers)\n\n elif request.method == \"POST\":\n task = uuid.uuid1().hex\n tasks = self.cluster.config.get('tasks')\n tasks[task] = json.loads(request.body)\n self.cluster.config.set('tasks', tasks)\n\n get_plugin_registry().call_hook('TaskCreated', task, tasks[task])\n\n return HTTPReply(code = 201, body = json.dumps({\"id\": task, \"created\": True}), headers = headers)","def handle_task(self, request):\n \"\"\"\n @api {get} /tasks/:id Get a task\n @apiName GetTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Returns the configuration of a task.\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {String} name Name.\n @apiSuccess {String} description Description.\n @apiSuccess {String[]} tags Tags.\n @apiSuccess {Boolean} enabled Task is enabled.\n @apiSuccess {String} mode Task mode (\"any\" or \"all\").\n @apiSuccess {String[]} pools Pools on which the task should run.\n @apiSuccess {Object[]} schedules Schedules at which the task should run.\n @apiSuccess {String} command Command to run.\n @apiSuccess {String} workdir Working directory.\n @apiSuccess {String} user User which the task will be run.\n @apiSuccess {String} group Group which the task will be run.\n @apiSuccess {Object} env Environment variables to set.\n @apiSuccess {String} mailreport If the mailer plugin is enabled, condition to send a report (\"error\", \"stdout\", \"stderr\", \"output\", \"always\").\n @apiSuccess {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\n\n @apiSuccessExample {json} Example response:\n {\n \"name\": \"My task\",\n \"description\": \"Task description\",\n \"tags\": [\"tasg1\", \"tag2\"],\n \"enabled\": true,\n \"mode\": \"all\",\n \"pools\": [\"web\"],\n \"schedules\": [\n {\"minute\": [\"*/1\"]}\n ],\n \"command\": \"/bin/true\",\n \"workdir\": \"/tmp/\",\n \"user\": \"www-data\",\n \"group\": \"www-data\",\n \"env\": {\n \"MYENVVAR\": \"myvalue\"\n },\n \"mailreport\": \"output\",\n \"mailto\": [\"user@domain.org\"]\n }\n \"\"\"\n \"\"\"\n @api {put} /task/:id Update a task\n @apiName PutTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Update a task. Can also be used to create a task with a specific ID.\n\n @apiParam {String} :id Task ID.\n\n @apiParam {String} name Name.\n @apiParam {String} description Description.\n @apiParam {String[]} tags Tags.\n @apiParam {Boolean} enabled Task is enabled.\n @apiParam {String} mode Task mode (\"any\" or \"all\").\n @apiParam {String[]} pools Pools on which the task should run.\n @apiParam {Object[]} schedules Schedules at which the task should run.\n @apiParam {String} command Command to run.\n @apiParam {String} workdir Working directory.\n @apiParam {String} user User which the task will be run.\n @apiParam {String} group Group which the task will be run.\n @apiParam {Object} env Environment variables to set.\n @apiParam {String} mailreport If the mailer plugin is enabled, condition to send a report (\"error\", \"stdout\", \"stderr\", \"output\", \"always\").\n @apiParam {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\n\n @apiParamExample {json} Example parameters:\n {\n \"name\": \"My task\",\n \"description\": \"Task description\",\n \"tags\": [\"tasg1\", \"tag2\"],\n \"enabled\": true,\n \"mode\": \"all\",\n \"pools\": [\"web\"],\n \"schedules\": [\n {\"minute\": [\"*/1\"]}\n ],\n \"command\": \"/bin/true\",\n \"workdir\": \"/tmp/\",\n \"user\": \"www-data\",\n \"group\": \"www-data\",\n \"env\": {\n \"MYENVVAR\": \"myvalue\"\n },\n \"mailreport\": \"output\",\n \"mailto\": [\"user@domain.org\"]\n }\n\n @apiSuccess {Boolean} updated The task has been updated.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"updated\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n \"\"\"\n @api {delete} /task/:id Delete a task\n @apiName DeleteTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Delete a task.\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} deleted The task has been deleted.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"deleted\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n \"\"\"\n @api {execute} /task/:id Execute a task\n @apiName ExecuteTask\n @apiGroup Tasks\n @apiVersion 1.1.0\n\n @apiDescription Execute a task.\n\n @apiParam {String} :id Task ID.\n @apiParam {String} :target Target for task execution (\"local\" to execute on the local node, otherwise execute on the nodes on which the task is configured to run).\n @apiParam {Boolean} :force Force the execution even if the concurrency limit is reached.\n\n @apiSuccess {Boolean} Executed The task has been executed.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"deleted\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n\n match = re.match('/tasks/([0-9a-z]+)', request.uri_path)\n task = match.group(1)\n\n tasks = self.cluster.config.get('tasks')\n\n if request.method == \"GET\":\n if task in tasks:\n return HTTPReply(code = 200, body = json.dumps(tasks[task]), headers = headers)\n else:\n return HTTPReply(code = 404, headers = {'Access-Control-Allow-Origin': '*'})\n\n elif request.method == \"PUT\":\n new = json.loads(request.body)\n if task in tasks:\n old = tasks[task]\n else:\n old = None\n\n tasks[task] = new\n self.cluster.config.set('tasks', tasks)\n\n if old:\n code = 200\n body = json.dumps({\"id\": task, \"updated\": True})\n get_plugin_registry().call_hook('TaskUpdated', task, old, new)\n else:\n code = 201\n body = json.dumps({\"id\": task, \"created\": True})\n get_plugin_registry().call_hook('TaskCreated', task, new)\n\n return HTTPReply(code = code, body = body, headers = headers)\n\n elif request.method == \"DELETE\":\n if task in tasks:\n old = tasks[task]\n del tasks[task]\n self.cluster.config.set('tasks', tasks)\n\n get_plugin_registry().call_hook('TaskDeleted', task, old)\n\n return HTTPReply(code = 200, body = json.dumps({\"id\": task, \"deleted\": True}), headers = headers)\n else:\n return HTTPReply(code = 404, headers = {'Access-Control-Allow-Origin': '*'})\n\n if request.method == \"EXECUTE\":\n try:\n if 'target' in request.args and request.args['target'] == 'local':\n self.manager.execute_task(task)\n else:\n self.cluster.scheduler.run_task(task, ignore_concurrency = 'force' in request.args)\n\n return HTTPReply(code = 200, body = json.dumps({\"id\": task, \"executed\": True}), headers = headers)\n except ExecutionDisabled:\n return HTTPReply(code = 503, body = json.dumps({\"id\": task, \"executed\": False}), headers = headers)","def task_action_router(request, section_id, task_id):\n\n if request.method == 'PUT':\n return update_task(request, task_id)\n elif request.method == 'DELETE':\n return delete_task(request, task_id)\n else:\n return HttpResponseNotAllowed('Method not allowed')","def tasks_rpc():\n # First check that this is a legitimate request from the coordinator\n authenticate_coordinator()\n action, task_id, release_id = validate_action(request.get_json(force=True))\n # Call into action\n return ROUTES[action](task_id, release_id)","def task_element(request, task_id):\n try:\n task = Task.objects.get(id=task_id)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == \"GET\":\n serializer = TaskSerializer(task)\n return Response(serializer.data)\n\n elif request.method == \"PUT\":\n data = json.loads(request.body)\n\n status = data.get(\"status\", \"\")\n task.status = status\n\n try:\n assignee = User.objects.get(username=data.get(\"assignee\", \"\"))\n task.assignee = assignee\n except:\n pass\n \n task.save()\n return JsonResponse({\"message\": \"Task updated successfully\"}, status=204)\n\n elif request.method == \"DELETE\":\n task.delete()\n return Response(status=status.HTTP_204_NO_CONTENT)","def task_detail(request, pk):\n try:\n task = Task.objects.get(pk=pk)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == 'GET':\n serializer = TaskSerializer(task)\n return Response(serializer.data)\n\n elif request.method == 'PUT':\n serializer = TaskSerializer(task, data=request.DATA)\n if serializer.is_valid():\n serializer.save()\n # returning the serializer data after saving it to the database\n return Response(serializer.data)\n\n else:\n # there were some validation errors with the data\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\n\n elif request.method == 'DELETE':\n # recall we already have the task present\n task.delete()\n return Response(status=status.HTTP_204_NO_CONTENT)","def on_get(self, req, resp):\n try:\n task_model_list = self.state_manager.get_tasks()\n task_list = [x.to_dict() for x in task_model_list]\n resp.text = json.dumps(task_list)\n resp.status = falcon.HTTP_200\n except Exception as ex:\n self.error(\n req.context,\n \"Unknown error: %s\\n%s\" % (str(ex), traceback.format_exc()))\n self.return_error(resp,\n falcon.HTTP_500,\n message=\"Unknown error\",\n retry=False)","def tasks_collection(request):\n if request.method == \"GET\":\n tasks = Task.objects.all().order_by(\"-timestamp\")\n serializer = TaskSerializer(tasks, many=True)\n return Response(serializer.data)\n\n elif request.method == \"POST\":\n data = json.loads(request.body)\n title = data.get(\"title\", \"\")\n description = data.get(\"description\", \"\")\n category = data.get(\"category\", \"\")\n budget = data.get(\"budget\", \"\")\n poster = User.objects.get(username=data.get(\"poster\", \"\"))\n due_date = parser.parse(data.get(\"dueDate\", \"\"))\n\n task = Task(\n title=title,\n description=description,\n poster=poster,\n due_date=due_date,\n budget=budget,\n category=category\n )\n task.save()\n return JsonResponse({\"message\": \"Task created successfully\"}, status=201)","def task_list(request):\n if request.method == \"GET\":\n tasks = Task.objects.all()\n\n # tasks here is a query set. So we are essentially passing the entire query set into the serializer\n # the many=True attribute here is super important. Without this attribute an error would be raised\n\n serializer = TaskSerializer(tasks, many=True)\n return Response(serializer.data)\n\n elif request.method == \"POST\":\n serializer = TaskSerializer(data=request.DATA)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data, status=status.HTTP_201_CREATED)\n\n else:\n # there is a validation error and hence there is a problem with the data in the request\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def run_tasks(request):\r\n import os\r\n if not os.environ['SERVER_SOFTWARE'].startswith('Development'):\r\n logging.error(\"This URL is only valid in a development environment.\")\r\n raise Http404\r\n else:\r\n from datetime import datetime\r\n from google.appengine.api import apiproxy_stub_map\r\n stub = apiproxy_stub_map.apiproxy.GetStub('taskqueue')\r\n \r\n #get all the tasks for all the queues\r\n tasks = []\r\n for queue in stub.GetQueues():\r\n tasks.extend( stub.GetTasks(queue['name']) )\r\n \r\n #keep only tasks that need to be executed\r\n now = datetime.now()\r\n fn = lambda t: datetime.strptime(t['eta'],'%Y/%m/%d %H:%M:%S') < now\r\n tasks = filter(fn, tasks)\r\n\r\n from django.utils import simplejson as json\r\n result = '\\n'.join([json.dumps(t) for t in tasks])\r\n \r\n #remove tasks from queues\r\n for queue in stub.GetQueues():\r\n stub.FlushQueue(queue['name'])\r\n \r\n return HttpResponse(result)","def post(self):\n task = self.params.task\n task.completed = not task.completed\n task.put()\n render_json(self, obj=task.as_json())","def handle_task_enable(self, request):\n \"\"\"\n @api {post} /task/:id/enable Enable a task\n @apiName EnableTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} updated The task has been updated.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"updated\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n \"\"\"\n @api {post} /task/:id/disable Disable a task\n @apiName DisableTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} updated The task has been updated.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"updated\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n\n match = re.match('/tasks/([0-9a-z]+)/(en|dis)able', request.uri_path)\n task = match.group(1)\n action = match.group(2)\n\n enabled = (action == 'en')\n\n tasks = self.cluster.config.get('tasks')\n\n if task in tasks:\n code = 200\n\n old = tasks[task].copy()\n tasks[task]['enabled'] = enabled\n self.cluster.config.set('tasks', tasks)\n\n get_plugin_registry().call_hook('TaskUpdated', task, old, tasks[task])\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n body = json.dumps({\"id\": task, \"updated\": True})\n\n return HTTPReply(code = code, body = body, headers = headers)\n else:\n headers = {\n 'Access-Control-Allow-Origin': '*'\n }\n return HTTPReply(code = 404, headers = headers)","def post(self, request):\n if not request.user.is_authenticated():\n return redirect(\"todo\")\n\n # _method contains the true verb the form want to use, if it's not POST.\n method = request.POST.get(\"_method\", \"\")\n if not method:\n return self._create_task(request)\n elif method == \"PUT\":\n completed = request.POST.get(\"completed\", \"\")\n title = request.POST.get(\"title\", \"\")\n description = request.POST.get(\"description\", \"\")\n if completed and not (title or description):\n return self._complete_task(request)\n else:\n return self._edit_task(request)\n elif method == \"DELETE\":\n return self._delete_task(request)\n\n return self._no_valid_action()","def system_ajax(request):\n type = request.GET.get('api', None)\n task_limit = getattr(settings, 'CELERYMON_TASK_LIMIT', 12)\n celery_monitoring = getattr(settings, 'CELERY_FLOWER_URL', None)\n if type == \"_active_tasks\":\n server = Server(settings.COUCH_DATABASE)\n try:\n tasks = [x for x in server.active_tasks() if x['type'] == \"indexer\"]\n except HTTPError as e:\n if e.response.status_code == 403:\n return JsonResponse({'error': \"Unable to access CouchDB Tasks (unauthorized).\"}, status=500)\n else:\n return JsonResponse({'error': \"Unable to access CouchDB Tasks.\"}, status=500)\n\n if not is_bigcouch():\n return JsonResponse(tasks, safe=False)\n else:\n # group tasks by design doc\n task_map = defaultdict(dict)\n for task in tasks:\n meta = task_map[task['design_document']]\n tasks = meta.get('tasks', [])\n tasks.append(task)\n meta['tasks'] = tasks\n\n design_docs = []\n for dd, meta in task_map.items():\n meta['design_document'] = dd[len('_design/'):]\n total_changes = sum(task['total_changes'] for task in meta['tasks'])\n for task in meta['tasks']:\n task['progress_contribution'] = task['changes_done'] * 100 // total_changes\n\n design_docs.append(meta)\n return JsonResponse(design_docs, safe=False)\n elif type == \"_stats\":\n return JsonResponse({})\n elif type == \"_logs\":\n pass\n elif type == 'pillowtop':\n pillow_meta = get_all_pillows_json()\n return JsonResponse(sorted(pillow_meta, key=lambda m: m['name'].lower()), safe=False)\n\n if celery_monitoring:\n if type == \"flower_poll\":\n ret = []\n try:\n all_tasks = requests.get(\n celery_monitoring + '/api/tasks',\n params={'limit': task_limit},\n timeout=3,\n ).json()\n except Exception as ex:\n return JsonResponse({'error': \"Error with getting from celery_flower: %s\" % ex}, status=500)\n\n for task_id, traw in all_tasks.items():\n # it's an array of arrays - looping through [<id>, {task_info_dict}]\n if 'name' in traw and traw['name']:\n traw['name'] = '.'.join(traw['name'].split('.')[-2:])\n else:\n traw['name'] = None\n ret.append(traw)\n ret = sorted(ret, key=lambda x: x['succeeded'], reverse=True)\n return HttpResponse(json.dumps(ret), content_type='application/json')\n return HttpResponse('{}', content_type='application/json')","def taskList(request):\n try:\n # if request.user.username == \"root\":\n # pass\n\n title = request.data.get(\"title\", None)\n desc = request.data.get(\"desc\", None)\n stat = request.data.get(\"status\", None)\n taskDueDate = request.data.get(\"taskDueDate\", None)\n sortby = request.data.get(\"sortby\", None)\n qs = Task.objects.filter(userID=request.user)\n if sortby:\n qs = qs.order_by(sortby)\n\n if title:\n qs = qs.filter(Q(title__exact=title))\n\n if desc:\n qs = qs.filter(Q(desc__exact=desc))\n\n if stat:\n qs = qs.filter(Q(status__exact=stat))\n\n if taskDueDate:\n qs = qs.filter(Q(taskDueDate__exact=taskDueDate))\n\n serializer = TaskSerializer(qs, many=True)\n if len(serializer.data) != 0:\n for i in range(len(serializer.data)):\n serializer.data[i]['userID'] = request.user.username\n\n return Response(serializer.data, status=status.HTTP_200_OK)\n\n\n except Exception as e:\n return Response(e.args[0], status.HTTP_400_BAD_REQUEST)","def handle_task_processes(self, request):\n \"\"\"\n @api {get} /task/:id/processes List running processes for a task\n @apiName ListTaskProcesses\n @apiGroup Tasks\n @apiVersion 1.1.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccessExample {json} Example response:\n {\n \"021b2092ef4111e481a852540064e600\" : {\n \"node\": \"node1\",\n \"start_time\": \"2018-03-29T15:01:13.465183+00:00\",\n \"task\": \"e4d07482e44711e49e76c81f66cd0cca\"\n },\n \"253a96e29868135d746989a6123f521e\" : {\n \"node\": \"node2\",\n \"start_time\": \"2018-03-29T14:01:13.352067+00:00\",\n \"task\": \"508b4b72e44611e49e76c81f66cd0cca\"\n },\n ...\n }\n \"\"\"\n\n match = re.match('/tasks/([0-9a-z]+)/processes', request.uri_path)\n task = match.group(1)\n\n processes = self.cluster.list_task_processes(task)\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n body = json.dumps(processes)\n\n return HTTPReply(code = 200, body = body, headers = headers)","def task_endponit():\n action, task, release = parse_request(request)\n\n # Determine what action to take\n if action == 'initialize':\n # Assert that the service is ready to start a new task\n tasks[task] = {\n 'state': 'pending',\n 'release_id': release,\n 'task_id': task,\n 'progress': 0\n }\n elif action == 'start':\n # Here is where the bulk of the processing will happen\n tasks[task] = {\n 'state': 'running',\n 'release_id': release,\n 'task_id': task,\n 'progress': 0\n }\n # Add to the queue\n process.delay(task, release)\n elif action == 'publish':\n # Make the changes live\n tasks[task] = {\n 'state': 'publishing',\n 'release_id': release,\n 'task_id': task,\n 'progress': 0\n }\n publish.delay(task, release)\n elif action == 'get_status':\n if task_id not in tasks:\n abort(404)\n return tasks[task]\n elif action == 'cancel':\n tasks[task] = {\n 'state': 'canceled',\n 'release_id': release,\n 'task_id': task,\n 'progress': 0\n }\n else:\n # Not a valid action\n abort(400)\n\n # Return current task state\n return jsonify(tasks[task])","def list(ctx, id, json):\n\n kargs={'host': c.cfg['host'], \"api_version\": c.cfg['api_version'], \"url_path\": \"/tasks\"}\n if id != None:\n return ctx.invoke(show, id=id, json=json)\n\n task = estask.Task(kargs)\n try:\n dict_resp= task.list()\n except Exception as e:\n sys.exit(\"Fail: %s\" %str(e))\n\n if dict_resp == None:\n click.echo(\"Fail: error response\")\n sys.exit(1)\n\n if json:\n print(jsn.dumps(dict_resp, sort_keys=True, indent=4))\n return\n try:\n task.print_list(dict_resp)\n except Exception as e:\n sys.exit(\"Fail: %s\" %str(e))","def post(self, dnzo_user):\n from google.appengine.ext import db\n from tasks_data.models import Task\n from tasks_data.tasks import update_task_with_params, save_task, task_list_can_add_task\n from tasks_data.task_lists import get_task_list\n \n task = Task(parent=dnzo_user)\n \n task_list = self.request.get('task_list', None) \n task_list = task_list and get_task_list(dnzo_user, task_list)\n if task_list:\n task.task_list = task_list\n else:\n self.bad_request(\"Could not find the specified task list.\")\n return\n \n update_task_with_params(dnzo_user, task, self.request)\n \n if not task_list_can_add_task(task_list, task):\n self.bad_request(\"Can not add task, too many active tasks in the list.\")\n return\n \n save_task(dnzo_user, task)\n\n if not task.is_saved():\n self.bad_request(\"Could not add the new task!\")\n return\n\n # reload task \n task = db.get(task.key())\n \n self.json_response(task=task.to_dict())","def update_tasks():\n response = \"\"\"\\\n<form action=\"\" method=post>\n<p>Category: <input type=text name=category></p>\n<p>Priority: <input type=text name=priority></p>\n<p>Description: <input type=text name=description></p>\n<p><input type=submit value=Add></p>\n</form>\n\n\n<table border=\"1\" cellpadding=\"3\">\n <tbody>\n <tr>\n <th>Category</th>\n <th>Priority</th>\n <th>Description</th>\n </tr>\n\"\"\"\n\n db_conn = DBConnection()\n db_conn.get_conn()\n\n #db_conn.query_db('delete from tasks')\n if request.method == 'POST':\n category = request.form['category']\n priority = request.form['priority']\n description = request.form['description']\n db_conn.add_task(category, priority, description)\n return redirect('/task')\n #return redirect(url_for('task')) # method name\n\n for single_task in db_conn.query_db('select * from tasks'):\n if single_task['category'] or single_task['priority'] or single_task['description']:\n response += \"<tr><td>%s</td>\" % (single_task['category'])\n response += \"<td>%s</td>\" % (single_task['priority'])\n response += \"<td>%s</td></tr>\" % (single_task['description'])\n response += \"</tbody></table>\"\n\n db_conn.close_conn()\n return response","def on_get(self, req, resp, task_id):\n task_result = AsyncResult(task_id)\n result = {'status': task_result.status, 'result': task_result.result}\n resp.status = falcon.HTTP_200\n resp.body = json.dumps(result)","def on_post(self, req, resp):\n # A map of supported actions to the handlers for tasks for those actions\n supported_actions = {\n 'validate_design': TasksResource.task_validate_design,\n 'verify_site': TasksResource.task_verify_site,\n 'prepare_site': TasksResource.task_prepare_site,\n 'verify_nodes': TasksResource.task_verify_nodes,\n 'prepare_nodes': TasksResource.task_prepare_nodes,\n 'deploy_nodes': TasksResource.task_deploy_nodes,\n 'destroy_nodes': TasksResource.task_destroy_nodes,\n 'relabel_nodes': TasksResource.task_relabel_nodes,\n }\n\n try:\n json_data = self.req_json(req)\n\n action = json_data.get('action', None)\n if supported_actions.get(action, None) is None:\n self.error(req.context, \"Unsupported action %s\" % action)\n self.return_error(resp,\n falcon.HTTP_400,\n message=\"Unsupported action %s\" % action,\n retry=False)\n else:\n supported_actions.get(action)(self, req, resp, json_data)\n except Exception as ex:\n self.error(\n req.context,\n \"Unknown error: %s\\n%s\" % (str(ex), traceback.format_exc()))\n self.return_error(resp,\n falcon.HTTP_500,\n message=\"Unknown error\",\n retry=False)","def task(sync=False, methods=('GET',), takes='document'):\n\n def wrap(f):\n global SYNC_TASKS, ASYNC_TASKS\n\n if takes == 'document':\n url = slashjoin(['/', f.__module__.rsplit('.', 1)[-1],\n '<index>/<doc_type>/<int:id>/<bodyfield>'])\n\n @wraps(f)\n def f_task(doc_type, id, index, bodyfield, config):\n es = getconf(config, 'main elasticsearch', error='raise')\n doc = requests.get(slashjoin([es, index, doc_type, str(id)]))\n content = doc.json()['_source'][bodyfield]\n\n return f(content, config)\n\n elif takes == None:\n url = '/' + f.__module__.rsplit('.', 1)[-1]\n f_task = f\n\n (SYNC_TASKS if sync else ASYNC_TASKS).append((f_task, url, methods))\n\n return f\n\n return wrap","def add(request):\n\tif request.method == 'GET':\n\t\tID = request.GET.get('id',False)\n\t\tstatus = request.GET.get('status',False)\n\t\ttaskname = request.GET.get('taskname',False)\n\t\tdescription = request.GET.get('description','')\n\n\t\tprint(taskname)\n\t\terror = {}\n\t\tif not ID:\n\t\t\terror['error'] = \"id not given\"\n\t\telif not status:\n\t\t\terror['error'] = \"status not given\"\n\t\telif not taskname:\n\t\t\terror['error'] = \"taskname not given\"\n\t\telif not description:\n\t\t\terror['error'] = \"description not given\"\n\t\telse:\n\t\t\ttodo['task'].append({\"id\":ID,\"status\":status,\"taskname\":taskname,\"description\":description})\n\n\t\tif len(error) != 0:\n\t\t\tresponse = error\n\t\telse:\n\t\t\tresponse = todo['task'][-1]\n\n\treturn JsonResponse(response)","def get_tasks(id):\n url = 'https://jsonplaceholder.typicode.com/'\n tasks = requests.get(url + 'todos', params={'userId': id}).json()\n return tasks","def view_task(self, task_id):\n api_url = self.server_url + self.METHOD_VIEW_TASK + str(task_id)\n\n request = Request(api_url)\n\n log.info(\"Request to \" + api_url)\n try:\n response = request.get()\n except HTTPError, e:\n log.error(\"Error in view_task: \" + str(e))\n raise CuckooError(str(e))\n except ConnectionError, e:\n log.error(\"Error in view_task: \" + str(e))\n raise CuckooError(str(e))\n\n log.info(\"Response: \" + str(response))\n\n return response","def edit_task(id):\n\n if not id:\n raise InvalidAPIUsage(\"id is required\")\n\n content = get_content_or_400(request)\n\n collection = get_db_collection()\n\n task = get_task_or_404(collection, id)\n\n collection.update_one({\"_id\": task[\"_id\"]}, {\"$set\": {\"content\": content}})\n\n response = jsonify()\n response.status_code = 200\n return response","def on_get(self, req, resp, task_id):\n task = celery_app.AsyncResult(task_id)\n\n resp.body = json.dumps(\n {'status': task.status, 'result': str(task.result)})\n resp.status = falcon.HTTP_200","def get_task(id):\n\n if not id:\n raise InvalidAPIUsage(\"id is required\")\n\n collection = get_db_collection()\n\n task = get_task_or_404(collection, id)\n\n response = jsonify(content=task['content'])\n response.status_code = 200\n return response","def get(self, dnzo_user, task_list):\n self.json_response(task_list=task_list.to_dict())","def task_offers_collection(request, task_id):\n try:\n task = Task.objects.get(id=task_id)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == \"GET\":\n offers = Offer.objects.filter(task=task).all().order_by(\"-timestamp\")\n serializer = OfferSerializer(offers, many=True)\n return Response(serializer.data)","def queue_cloud_task(request):\n project = os.environ.get(\"PROJECT_ID\")\n queue = os.environ.get(\"QUEUE_NAME\")\n location = os.environ.get(\"QUEUE_REGION_LOCATION\")\n service_account_email = os.environ.get(\"SERVICE_ACCOUNT_EMAIL\")\n\n request_json = request.get_json()\n\n # the http endpoint the task will send to\n url = request_json.get('url')\n # the post data that should be forwarded to the http endpoint\n payload = request_json.get('payload')\n # the time in seconds to delay task execution\n in_seconds = request_json.get('in_seconds')\n # the unique name of the task we are queueing\n task_name = request_json.get('task_name')\n\n try:\n # Create a client.\n client = tasks_v2.CloudTasksClient()\n # Construct the fully qualified queue name.\n parent = client.queue_path(project, location, queue)\n except Exception as e:\n print(e)\n return f\"{e}\", 500\n\n # Construct the request body.\n task = {\n \"http_request\": { # Specify the type of request.\n \"http_method\": tasks_v2.HttpMethod.POST,\n \"url\": url,\n \"oidc_token\": {\"service_account_email\": service_account_email},\n }\n }\n if payload is not None:\n if isinstance(payload, dict):\n # Convert dict to JSON string\n payload = json.dumps(payload)\n # specify http content-type to application/json\n task[\"http_request\"][\"headers\"] = {\"Content-type\": \"application/json\"}\n\n # The API expects a payload of type bytes.\n converted_payload = payload.encode()\n\n # Add the payload to the request.\n task[\"http_request\"][\"body\"] = converted_payload\n\n if in_seconds is not None:\n # Convert \"seconds from now\" into an rfc3339 datetime string.\n d = datetime.datetime.utcnow() + datetime.timedelta(seconds=in_seconds)\n\n # Create Timestamp protobuf.\n timestamp = timestamp_pb2.Timestamp()\n timestamp.FromDatetime(d)\n\n # Add the timestamp to the tasks.\n task[\"schedule_time\"] = timestamp\n\n if task_name is not None:\n # Add the name to tasks.\n name = f\"projects/{project}/locations/{location}/queues/{queue}/tasks{task_name}\"\n task[\"name\"] = name\n\n try:\n # Use the client to build and send the task.\n response = client.create_task(request={\"parent\": parent, \"task\": task})\n return f\"Created task {response.name}\", 200\n except Exception as e:\n print(e)\n return f\"{e}\", 500","def update_task_by_id(task_id):\n try:\n updated_task = get_task_from_request_form(request)\n tasks = mongo.db.tasks\n\n result = tasks.update_one(\n {\"_id\": ObjectId(task_id)},\n {\n \"$set\": {\n \"title\": updated_task['title'],\n \"reference\": updated_task['reference'],\n \"description\": updated_task['description'],\n \"status\": updated_task['status'],\n \"visible\": updated_task['visible']\n }\n })\n return json_util.dumps(get_task_by_id(task_id))\n except:\n abort(400)","def post(self, request):\n logger = Log.get_logger(__name__)\n logger.info(\"Framework:: execute API Hits with parameter %s\", request.data)\n global_context = request.data\n context = {}\n setup = None\n valid = TaskGroupExecutionValidation(request.data, request.FILES)\n if valid.is_valid():\n try:\n if request.data.get('taskGroupName'):\n tg_name = request.data['taskGroupName'][0]\n setup = TaskGroupExecuteView.getSetup(request)\n all_taskgroup_objects = Taskgroup.objects.get(name=tg_name)\n if all_taskgroup_objects:\n context = TaskGroupExecuteView.getTGTasksName(all_taskgroup_objects, tg_name)\n new_entry_response = ExecTasks.executeTasksList(\n context['tgList'],\n context['tasksList'],\n global_context,\n setup\n )\n return Response(new_entry_response)\n else:\n return Response(\"No TG with this name\")\n elif request.data.get('tasks'):\n is_exist = TaskGroupExecuteView.isTasksExists(request)\n if is_exist.get('taskResult'):\n setup = TaskGroupExecuteView.getSetup(request)\n datetime = TaskGroupExecuteView.getHumanReadableDateTime()\n tg = Taskgroup(\n name='TG-'+datetime\n )\n tg.save()\n all_taskgroup_objects = Taskgroup.objects.get(name=tg.name)\n tasks_ids = TaskGroupExecuteView.getTaskIdsFromName(request.data['tasks'])\n status = TaskGroupExecuteView.createRelationBetweenTGTasks(tg.id, tasks_ids)\n if status:\n context = TaskGroupExecuteView.getTGTasksName(all_taskgroup_objects, tg.name)\n new_entry_response = ExecTasks.executeTasksList(\n context['tgList'],\n context['tasksList'],\n global_context,\n setup\n )\n return Response(new_entry_response)\n else:\n return Response(\n is_exist['taskStatus'],\n status=HTTP_400_BAD_REQUEST\n )\n else:\n context['status'] = \"Task-Group Doesn't Exist.Pls create one.\"\n return Response(context, status=HTTP_400_BAD_REQUEST)\n except Exception as e:\n return Response(e)\n else:\n context['status'] = 'Invalid input'\n return Response(context, status=HTTP_400_BAD_REQUEST)","def get_current_user_tasks_route():\n user = current_user\n\n if user.get_id() is not None:\n return get_user_jobs_route(user.id)\n else:\n response_object = {'status': 'error'}\n return jsonify(response_object)","def run_tasks(self, url=None, queue_name=None, method='POST', response_status_code=200, **kwargs):\n from google.appengine.api import namespace_manager\n tasks = self.taskqueue_stub.get_filtered_tasks(url=url,\n queue_names=[queue_name])\n for task in tasks:\n namespace = task.headers.get('X-AppEngine-Current-Namespace', '')\n previous_namespace = namespace_manager.get_namespace()\n try:\n namespace_manager.set_namespace(namespace)\n headers = {\n k: v for k, v in task.headers.iteritems()\n if k.startswith('X-AppEngine')}\n if method == 'PUT':\n response = self.testapp.put(url, task.payload, headers=headers, status='*')\n else:\n response = self.testapp.post(url, task.payload, headers=headers, status='*')\n finally:\n namespace_manager.set_namespace(previous_namespace)","def test_list_tasks_no_args(self):\n rv = TEST_CLIENT.post(\"/tasks/list-tasks\", json={})\n result = rv.json()\n\n expected = util.MOCK_TASK_LIST\n self.assertEqual(result, expected)\n self.assertEqual(rv.status_code, 200)","def get(self):\n url = \"http://twitter.com/statuses/public_timeline.json\"\n task = taskqueue.Task(\n url='/tasks/fetch',\n params={'url': url}\n )\n task.add('fetch')","def get(self, dnzo_user):\n from tasks_data.models import Task\n \n updated_since = self.request.get('updated_since', None)\n if updated_since:\n from util.human_time import parse_datetime\n updated_since = parse_datetime(updated_since)\n if not updated_since:\n self.bad_request(\"Could not parse supplied date.\")\n return\n \n task_list_key = self.request.get('task_list', None) \n task_list = None\n if task_list_key:\n from tasks_data.task_lists import get_task_list\n task_list = get_task_list(dnzo_user, task_list_key)\n if not task_list:\n self.bad_request(\"Could not find task_list with key '%s'.\" % task_list_key)\n return\n \n if not (task_list or updated_since):\n self.bad_request(\"Must supply task_list or updated_since.\")\n return\n\n from tasks_data.tasks import get_tasks\n tasks = get_tasks(dnzo_user, updated_since=updated_since, task_list=task_list)\n \n data = { 'tasks': map(lambda t: t.to_dict(), tasks) }\n \n self.json_response(**data)","def list(self, _request):\n serializer = TaskSerializer(instance=TASKS.values(), many=True)\n return response.Response(serializer.data)","def do_task(self, task_type, upload_id, sys_config=1):\n response = self.do_request(\n self.base_url +\n \"/oasis/doTask\" + task_type + \"/\" +\n str(sys_config) + \"/\" +\n str(upload_id) + \"/\"\n )\n return response","def post(self):\n try:\n req = api.payload\n result = create_task(\n get_db(),\n req[\"task\"],\n date.fromisoformat(req[\"due_by\"]),\n Status[req[\"status\"]],\n )\n return task_to_dict(result), 201\n except ValueError:\n api.abort(422, \"Invalid request parameters\")","def running_celery_tasks(request):\n active_dict = CELERY_INSPECT.active()\n active_tasks = []\n if active_dict:\n for task_list in active_dict.values():\n active_tasks.extend(task_list)\n if active_tasks:\n active_tasks = [dikt.get(\"id\", \"\") for dikt in active_tasks]\n return Response({\"active_tasks\": active_tasks})","def get_tasks(data: dict) -> dict:\n status_code = http.HTTPStatus.OK\n body = {\"filters\": data}\n try:\n tasks = actions.get_tasks(data)\n body[\"tasks\"] = [task.to_dict() for task in tasks]\n except tskexc.TaskHTTPException as e:\n body = {\"error\": e.message}\n status_code = e.http_status\n return {\"statusCode\": status_code, \"body\": json.dumps(body)}","def fusion_api_get_task(self, param='', uri=None, api=None, headers=None):\n if uri is not None:\n # update fully qualified URL to relative URI\n uri = re.sub('^https://\\d*.\\d*.\\d*.\\d*', '', uri)\n return self.task.get(uri=uri, api=api, headers=headers, param=param)","def POST_task(self, task_data):\n\t\tif not self.room_id:\n\t\t\tself.POST_room()\n\t\trv = self.POST_data('/api/room/' + self.room_id + '/task', data=task_data)\n\t\tself.assertEqual(rv.status_code, 200)\n\t\treturn json.loads(rv.data)['_id']","def handle_task_running(self, request):\n \"\"\"\n @api {get} /task/:id/running Check if a task is running\n @apiName IsTaskRunning\n @apiGroup Tasks\n @apiVersion 1.1.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} running The task is running.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"running\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n\n match = re.match('/tasks/([0-9a-z]+)/running', request.uri_path)\n task = match.group(1)\n\n running = self.cluster.is_task_running(task)\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n body = json.dumps({\"id\": task, \"running\": running})\n\n return HTTPReply(code = 200, body = body, headers = headers)","def test_task_list():\n # Fake pyramid request, useful for testing.\n request = testing.DummyRequest()\n\n pytest.fail('Not implemented yet.')","def test_api_task_get_task(api, new_user, new_task):\n api.authenticate(new_user.username, new_user.password)\n task = api.get_task(new_task.id)\n assert new_task == task","def put(self, dnzo_user, task):\n from google.appengine.ext import db\n from tasks_data.tasks import update_task_with_params, save_task\n \n task_was_archived = task.archived\n\n try:\n # hack to allow form-encoded PUT bodies to be accessed by self.request.get()\n self.request.method = \"POST\"\n update_task_with_params(dnzo_user, task, self.request)\n \n except AssertionError, strerror:\n self.bad_request(strerror.message)\n return\n \n finally:\n self.request.method = \"PUT\"\n \n archived_status_changed = task_was_archived != task.archived\n if archived_status_changed and not task.archived:\n from tasks_data.tasks import task_list_can_add_task\n if not task_list_can_add_task(task.task_list, task):\n self.bad_request(\"Can not unarchive task, too many active tasks in the list.\")\n return\n \n save_task(dnzo_user, task, archived_status_changed)\n # reload task\n task = db.get(task.key())\n \n self.json_response(task=task.to_dict())","def task_start_parsing():\n add_task(url_for(\"task_queue_users\"))\n add_task(url_for(\"task_clean_tmp_files\"))\n return OK_RESPONSE","def test_resource_endpoint_returns_correct_data(self):\n self.add_tasks()\n response = self.app.get('api/v1/tasks/2', follow_redirects=True)\n self.assertEquals(response.status_code, 200)\n self.assertEquals(response.mimetype, 'application/json')\n self.assertNotIn(b'Test task 1.', response.data)\n self.assertIn(b'A totally different thing.', response.data)","def accept_todo(request):\n auth_token = request.META.get('HTTP_TOKEN', None)\n todoid = request.POST.get('todo_id', None)\n isaccepted = request.POST.get('is_accepted', None)\n result = Tasks(auth_token=auth_token).accept_task(todoid, isaccepted)\n return Response(\n {\n 'success': result\n }\n )","def get(self, dnzo_user):\n from tasks_data.models import Task\n from util.human_time import parse_datetime\n \n start_at = self.request.get('start_at', None)\n end_at = self.request.get('end_at', None)\n if not (start_at and end_at):\n self.bad_request(\"Must include start_at and end_at for archived tasks.\")\n return\n \n start_at = parse_datetime(start_at)\n if not start_at:\n self.bad_request(\"Could not parse supplied date 'start_at'.\")\n return\n \n end_at = parse_datetime(end_at)\n if not end_at:\n self.bad_request(\"Could not parse supplied date 'end_at'.\")\n return\n \n if (start_at > end_at):\n self.bad_request(\"Invalid range; start_at must come before end_at.\")\n return\n\n from tasks_data.tasks import get_archived_tasks\n tasks = get_archived_tasks(dnzo_user, start_at, end_at)\n \n data = { 'tasks': map(lambda t: t.to_dict(), tasks) }\n \n self.json_response(**data)","def new_task():\n req = request.json\n if 'cmd' in req:\n id = mongo.db.tasks.insert({\n 'cmd' : req['cmd'],\n 'status' : 'Not started'\n })\n\n response = {'id' : str(id)}\n return response","def put(self, guid):\n key = db.Key.from_path('Task', int(guid))\n task = db.get(key)\n if task != None:\n # cache current values before updates\n taskName = task.name\n taskType = task.type\n taskPriority = task.priority\n taskStatus = task.developmentStatus\n taskValidation = task.validation\n taskSubmitterId = task.submitterId\n taskAssigneeId = task.assigneeId\n taskEffort = task.effort\n taskProjectId = task.projectId\n taskDescription = task.description\n # collect the json from the request\n task_json = simplejson.loads(self.request.body)\n # if the user is a guest the project must be unallocated\n wantsNotifications = {\"true\": True, \"false\": False}.get(self.request.params['notify'].lower())\n currentUserId = self.request.params['UUID']\n cukey = db.Key.from_path('User', int(currentUserId))\n user = db.get(cukey)\n if str(user.role) != '_Guest' or (task_json.has_key('projectId') == False or task_json['projectId'] == None):\n # update the project record\n task = helpers.apply_json_to_model_instance(task, task_json)\n # save the updated data\n task.put()\n # Push notification email on the queue if we need to notify\n if notification.should_notify(currentUserId,task,\"updateTask\",wantsNotifications):\n taskqueue.add(url='/mailer', params={'taskId': int(guid), 'currentUUID': self.request.params['UUID'], 'action': \"updateTask\", 'name': taskName, 'type': taskType, 'priority': taskPriority, 'status': taskStatus, 'validation': taskValidation, 'submitterId': taskSubmitterId, 'assigneeId': taskAssigneeId, 'effort': taskEffort, 'projectId': taskProjectId, 'description': taskDescription})\n # return the same record...\n self.response.headers['Content-Type'] = 'application/json'\n self.response.out.write(simplejson.dumps(task_json))\n else:\n self.response.set_status(401, \"Not Authorized\")\n else:\n self.response.set_status(404, \"Task not found\")","def on_get(self, req, resp, task_id):\n try:\n builddata = req.get_param_as_bool('builddata')\n subtask_errors = req.get_param_as_bool('subtaskerrors')\n try:\n layers = int(req.params.get('layers', '0'))\n except Exception:\n layers = 0\n\n first_task = self.get_task(req, resp, task_id, builddata)\n\n if first_task is None:\n self.info(req.context, \"Task %s does not exist\" % task_id)\n self.return_error(resp,\n falcon.HTTP_404,\n message=\"Task %s does not exist\" % task_id,\n retry=False)\n else:\n # If layers is passed in then it returns a dict of tasks instead of the task dict.\n if layers:\n resp_data, errors = self.handle_layers(\n req, resp, task_id, builddata, subtask_errors, layers,\n first_task)\n # Includes subtask_errors if the query param 'subtaskerrors' is passed in as true.\n if (subtask_errors):\n resp_data['subtask_errors'] = errors\n else:\n resp_data = first_task\n # Includes subtask_errors if the query param 'subtaskerrors' is passed in as true.\n if (subtask_errors):\n _, errors = self.handle_layers(req, resp, task_id,\n False, subtask_errors,\n 1, first_task)\n resp_data['subtask_errors'] = errors\n\n resp.text = json.dumps(resp_data)\n resp.status = falcon.HTTP_200\n except Exception as ex:\n self.error(req.context, \"Unknown error: %s\" % (str(ex)))\n self.return_error(resp,\n falcon.HTTP_500,\n message=\"Unknown error\",\n retry=False)","def get(self, subresource, **kwargs):\n return getattr(RESTTask, subresource)(self, **kwargs)","def remove_task(id):\n\n if not id:\n raise InvalidAPIUsage(\"id is required\")\n\n collection = get_db_collection()\n\n task = get_task_or_404(collection, id)\n\n collection.delete_one({\"_id\": task[\"_id\"]})\n\n response = jsonify()\n response.status_code = 200\n return response","def task_questions_collection(request, task_id):\n try:\n task = Task.objects.get(id=task_id)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == \"GET\":\n questions = Question.objects.filter(task=task).all().order_by(\"-timestamp\")\n serializer = QuestionSerializer(questions, many=True)\n return Response(serializer.data)","def todo_list(request):\n if request.method == 'GET':\n todos = Todo.objects.all()\n serializer = TodoSerializer(todos, many=True)\n return Response(serializer.data)\n \n elif request.method == 'POST':\n serializer = TodoSerializer(data=request.data)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data, status=status.HTTP_201_CREATED)\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def process_task(params):\n params['task'](params)","def update_task(request, tid):\n try:\n slogger.task[tid].info(\"update task request\")\n labels = request.POST['labels']\n task.update(tid, labels)\n except Exception as e:\n slogger.task[tid].error(\"cannot update task\", exc_info=True)\n return HttpResponseBadRequest(str(e))\n\n return HttpResponse()","def remove(request):\n\tID = request.GET.get('id',False)\n\n\tif not ID:\n\t\tresponse = {\"error\":\"id not entered\"}\n\telse:\n\t\tID = str(ID)\n\t\tk = 0\n\t\tfor i,task in enumerate(todo['task']):\n\t\t\ttask_id = task.get('id',False)\n\t\t\tif ID == task_id:\n\t\t\t\tk += 1\n\t\t\t\tidx = i\n\t\tif k == 0:\n\t\t\tresponse = {\"error\":\"id not fount\"}\n\t\telse:\n\t\t\tresponse = todo['task'].pop(idx)\n\n\treturn JsonResponse(response)","def list(self, request, *args, **kwargs):\n return super(SubtaskViewSet, self).list(request, *args, **kwargs)","def edit_task_page(request):\n data = {}\n try:\n tasklist = request.GET.get(\"tasklist\")\n task = request.GET.get(\"task\")\n data[\"tasklist\"] = tasklist\n\n task_obj = Todo.objects.get(title=task)\n data[\"data\"] = task_obj\n\n return render(request, \"pages/update-task.html\", data)\n except Exception as ex:\n return HttpResponse(ex)","def update_task(self, task):\n create = task.id == 0\n\n xml = self._serialise_task(task)\n\n method = ['PUT','POST'][create]\n\n if create:\n url = \"%s/tasks?%s\" % \\\n (self._get_base_url(), self._get_url_params())\n else:\n url = \"%s/tasks/%s?%s\" % \\\n (self._get_base_url(), task.id, self._get_url_params())\n\n headers = { \"Accept\":\"application/xml\",\n \"Content-Type\":\"application/xml\" }\n self.__conn.request(method, url, xml, headers) \n response = self.__conn.getresponse()\n\n data = response.read()\n\n if not response.status == 200:\n raise Exception(\"Could not update/create task.\"\\\n \" Response was [%s]: %s\" % (response.status, data))\n\n return self._parse_task(ET.fromstring(data))","def test_04_new_task(self):\r\n url = '/api/app/1/newtask'\r\n self.check_limit(url, 'get', 'app')","def export(short_name, task_id):\r\n # Check if the app exists\r\n (app, owner, n_tasks, n_task_runs,\r\n overall_progress, last_activity) = app_by_shortname(short_name)\r\n try:\r\n require.app.read(app)\r\n except HTTPException:\r\n if app.hidden:\r\n raise abort(403)\r\n else: # pragma: no cover\r\n raise\r\n\r\n # Check if the task belongs to the app and exists\r\n task = db.session.query(model.task.Task).filter_by(app_id=app.id)\\\r\n .filter_by(id=task_id).first()\r\n if task:\r\n taskruns = db.session.query(model.task_run.TaskRun).filter_by(task_id=task_id)\\\r\n .filter_by(app_id=app.id).all()\r\n results = [tr.dictize() for tr in taskruns]\r\n return Response(json.dumps(results), mimetype='application/json')\r\n else:\r\n return abort(404)","def get(self, request):\n feedback = {\n 'permission': True\n }\n\n try:\n task_id = request.GET.get('task_id', None)\n if task_id is None:\n feedback['data'] = ErrorCode.parameter_missing('task_id')\n raise natrix_exception.ParameterMissingException(parameter='task_id')\n try:\n uuid.UUID(hex=task_id)\n except ValueError:\n feedback['data'] = ErrorCode.parameter_invalid('task_id', reason=u'must be a UUID')\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\n try:\n task = Task.objects.get(id=task_id, time_type='instant')\n # response_count = success + wrong\n res = command_dispatcher.get_task_data(task.id)\n success = len(res.get('success'))\n wrong = len(res.get('error'))\n response_count = success + wrong\n\n time_delta = timezone.now() - task.create_time\n\n if task.status and ( response_count == task.terminal_count or time_delta.seconds > 120):\n task.status = False\n task.result_snapshot = json.dumps(res)\n task.save()\n\n feedback['data'] = {\n 'code': 200,\n 'message': 'Instant Task Status',\n 'info': {\n 'finished': not task.status,\n 'total': task.terminal_count,\n 'responses': response_count,\n 'success': success,\n 'wrong': wrong\n }\n }\n\n except Task.DoesNotExist:\n feedback['data'] = ErrorCode.parameter_invalid(\n 'task_id', reason=u'Can not retrieve Instant Task: {}'.format(task_id))\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\n\n except natrix_exception.NatrixBaseException as e:\n logger.error(e.get_log())\n\n return JsonResponse(data=feedback)","def test_get_task(self):\n resp = self.app.get('/api/2/inf/esrs',\n headers={'X-Auth': self.token})\n\n task_id = resp.json['content']['task-id']\n expected = 'asdf-asdf-asdf'\n\n self.assertEqual(task_id, expected)","def test_task_query_without_params(self):\r\n app = AppFactory.create()\r\n TaskFactory.create_batch(10, app=app, info={'question': 'answer'})\r\n res = self.app.get('/api/task')\r\n tasks = json.loads(res.data)\r\n assert len(tasks) == 10, tasks\r\n task = tasks[0]\r\n assert task['info']['question'] == 'answer', task\r\n\r\n # The output should have a mime-type: application/json\r\n assert res.mimetype == 'application/json', res","def update_task(project_id,task_id):\n data = request.get_json()\n project = Project.query.filter_by(id=project_id).first()\n if not project:\n return {\n 'success': False,\n 'message': f\"No project with the specified id {project_id} found.\",\n }\n\n else:\n permission = has_project_permission(project, g.user)\n old_task = Task.query.filter_by(id=task_id)\n if not old_task:\n abort(404, f'There is no task with ID of {task_id}.')\n\n if old_task:\n db_session.delete(old_task)\n db_session.commit()\n name = data['name']\n project_id = data['project_id']\n description = data['description']\n completion_status = data['completion_status']\n created_date = data['created_date']\n deadline_date = data['deadline_date']\n new_task = Task(\n name=name, description=description, completion_status=completion_status,\n created_date = created_date, deadline_date = deadline_date, project_id=project_id, created_by=g.user)\n db_session.add(new_task)\n db_session.commit()\n return {\n 'success': True,\n 'result': task_schema.dump(new_task),\n 'message': \"Successfully Updated the Task.\",\n }","def post(self):\n\n from jinjamator.task.celery import run_jinjamator_task\n from jinjamator.daemon.database import db\n\n relative_task_path = request.endpoint.replace(\n \"api.\", \"\"\n )\n data = request.get_json()\n job_id = str(uuid.uuid4())\n user_id = g._user[\"id\"]\n\n job = run_jinjamator_task.apply_async(\n [\n relative_task_path,\n data,\n data.get(\"output_plugin\", \"console\"),\n user_id,\n ],\n task_id=job_id,\n created_by_user_id=user_id,\n )\n\n db_job = list(\n db.session.query(DB_Job).filter(\n DB_Job.task_id == job.id\n )\n )\n db_job = db_job and db_job[0]\n if not db_job:\n db_job = DB_Job(job.id)\n db_job.status = \"SCHEDULED\"\n db_job.configuration = data\n db_job.jinjamator_task = relative_task_path\n db_job.created_by_user_id = user_id\n db.session.add(db_job)\n db.session.flush()\n db.session.commit()\n\n return jsonify({\"job_id\": job.id})","def get_tasks(self, *args, **kwargs):\n tasks_endpoint = furl(self.ENDPOINT) / self.id / \"tasks\"\n return self._client.list(Task, endpoint=tasks_endpoint.url, *args, **kwargs)","def Product_detail(request, pk):\n try:\n task = Product.objects.get(pk=pk)\n except Product.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == 'GET':\n serializer = ProductSerializer(task)\n print(serializer.data)\n return Response(serializer.data)\n\n elif request.method == 'PUT':\n serializer = ProductSerializer(task, data=request.DATA)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data)\n else:\n return Response(\n serializer.errors, status=status.HTTP_400_BAD_REQUEST)\n\n elif request.method == 'DELETE':\n task.delete()\n return Response(status=status.HTTP_204_NO_CONTENT)","def test_newtask(self):\r\n app = AppFactory.create()\r\n TaskFactory.create_batch(2, app=app)\r\n user = UserFactory.create()\r\n\r\n # anonymous\r\n # test getting a new task\r\n res = self.app.get('/api/app/%s/newtask' % app.id)\r\n assert res, res\r\n task = json.loads(res.data)\r\n assert_equal(task['app_id'], app.id)\r\n\r\n # The output should have a mime-type: application/json\r\n assert res.mimetype == 'application/json', res\r\n\r\n # as a real user\r\n url = '/api/app/%s/newtask?api_key=%s' % (app.id, user.api_key)\r\n res = self.app.get(url)\r\n assert res, res\r\n task = json.loads(res.data)\r\n assert_equal(task['app_id'], app.id)\r\n\r\n # Get NotFound for an non-existing app\r\n url = '/api/app/5000/newtask'\r\n res = self.app.get(url)\r\n err = json.loads(res.data)\r\n err_msg = \"The app does not exist\"\r\n assert err['status'] == 'failed', err_msg\r\n assert err['status_code'] == 404, err_msg\r\n assert err['exception_cls'] == 'NotFound', err_msg\r\n assert err['target'] == 'app', err_msg\r\n\r\n # Get an empty task\r\n url = '/api/app/%s/newtask?offset=1000' % app.id\r\n res = self.app.get(url)\r\n assert res.data == '{}', res.data","def process_project_route(id):\n response_object = {'status': 'success'}\n if request.method == 'POST':\n with database.engine.begin() as connection:\n app = flask.current_app\n params = request.get_json()['params']\n task = current_user.launch_task('morphocut_server.api.process_project',\n 'Processing project...', id, id, params)\n response_object['job_id'] = task.id\n print(\"return process\")\n return jsonify(response_object), 202","def add_task(id):\n\n content = get_content_or_400(request)\n\n collection = get_db_collection()\n\n object_id = None\n if id:\n object_id = ObjectId(id)\n object = collection.find({\"_id\": object_id})\n if object:\n response = jsonify(errormsg=\"id already exists\")\n response.status_code = 400\n return response\n\n new_object = {\"content\": content}\n if id:\n new_object[\"_id\"] = id\n new_object_id = collection.insert_one(new_object).inserted_id\n\n response = jsonify(id=str(new_object_id))\n response.status_code = 201\n response.headers[\"Location\"] = url_for('get_task', id=new_object_id)\n return response","def insert_task():\n try:\n task = get_task_from_request_form(request)\n result = mongo.db.tasks.insert_one(task)\n return json_util.dumps(get_task_by_id(result.inserted_id))\n except Exception as err:\n abort(400)","def test_incremental_tasks(self):\r\n self.create_2(sched='incremental')\r\n\r\n # Del previous TaskRuns\r\n self.del_task_runs()\r\n\r\n # Register\r\n self.register(fullname=self.user.fullname, name=self.user.username,\r\n password=self.user.password)\r\n self.register(fullname=\"Marie Doe\", name=\"mariedoe\", password=\"dr0wss4p\")\r\n self.signin()\r\n\r\n # Get the only task with no runs!\r\n res = self.app.get('api/app/1/newtask')\r\n data = json.loads(res.data)\r\n # Check that we received a clean Task\r\n assert data.get('info'), data\r\n assert not data.get('info').get('last_answer')\r\n\r\n # Submit an Answer for the assigned task\r\n tr = dict(app_id=data['app_id'], task_id=data['id'], info={'answer': 'No'})\r\n tr = json.dumps(tr)\r\n\r\n self.app.post('/api/taskrun', data=tr)\r\n # No more tasks available for this user!\r\n res = self.app.get('api/app/1/newtask')\r\n data = json.loads(res.data)\r\n assert not data\r\n\r\n #### Get the only task now with an answer as Anonimous!\r\n self.signout()\r\n res = self.app.get('api/app/1/newtask')\r\n data = json.loads(res.data)\r\n\r\n # Check that we received a Task with answer\r\n assert data.get('info'), data\r\n assert data.get('info').get('last_answer').get('answer') == 'No'\r\n\r\n # Submit a second Answer as Anonimous\r\n tr = dict(app_id=data['app_id'], task_id=data['id'],\r\n info={'answer': 'No No'})\r\n tr = json.dumps(tr)\r\n\r\n self.app.post('/api/taskrun', data=tr)\r\n\r\n #### Get the only task now with an answer as User2!\r\n self.signin(email=\"mariedoe@example.com\", password=\"dr0wss4p\")\r\n res = self.app.get('api/app/1/newtask')\r\n data = json.loads(res.data)\r\n\r\n # Check that we received a Task with answer\r\n assert data.get('info'), data\r\n assert data.get('info').get('last_answer').get('answer') == 'No No'","def test_my_tasks(self):\n url, parsed = self.prepare_urls(\n 'v1:activity-my-tasks', subdomain=self.company.subdomain)\n \n response = self.client.get(url, HTTP_HOST=parsed.netloc)\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)\n\n self.authenticate_user()\n response = self.client.get(url, HTTP_HOST=parsed.netloc)\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n \n content = json.loads(response.content)\n self.assertTrue(content.has_key('count'))\n self.assertTrue(content.has_key('next'))\n self.assertTrue(content.has_key('previous'))\n self.assertTrue(content.has_key('results'))","def test_update_task(self):\n rv = TEST_CLIENT.patch(\n \"/tasks/foo\",\n json={\n \"name\": \"foo 2\",\n },\n )\n result = rv.json()\n expected = {\n \"message\": \"The specified task does not exist\",\n \"code\": \"TaskNotFound\",\n }\n self.assertDictEqual(expected, result)\n self.assertEqual(rv.status_code, 404)","def product_detail(request, pk):\n try:\n task = Product.objects.get(pk=pk)\n except Product.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == 'GET':\n serializer = ProductSerializer(task)\n return Response(serializer.data)\n\n elif request.method == 'PUT':\n serializer = ProductSerializer(task, data=request.DATA)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data)\n else:\n return Response(\n serilizer.errors, status=status.HTTP_400_BAD_REQUEST)\n\n elif request.method == 'DELETE':\n task.delete()\n return Response(status=status.HTTP_204_NO_CONTENT)","def post(self):\n params = json.loads(self.request.body.decode())\n gid = params.get('gid')\n\n if gid: # apply an action on a specified task\n action = params.get('action')\n if action == 'pause':\n self.write(self._rpc.aria2.pause(self._token, gid))\n elif action == 'resume':\n self.write(self._rpc.aria2.unpause(self._token, gid))\n else: # invalid action\n self.send_error(400)\n\n else: # create a task\n url = params.get('url')\n self.write(self._rpc.aria2.addUri(\n self._token, [url], {'dir': self._download_file_dir}))","def edit_task(request):\n data = {\"success\": False}\n try:\n title = request.POST.get(\"title\")\n col = request.POST.get(\"col\")\n value = request.POST.get(\"value\")\n qs = Todo.objects.get(title=title)\n res = False\n if col == \"title\":\n res = qs.update_title(title=value, user=request.user)\n elif col == \"description\":\n res = qs.update_description(description=value, user=request.user)\n elif col == \"status\":\n res = qs.update_status(status=value, user=request.user)\n if res:\n data[\"success\"] = True\n data[\"message\"] = \"%s updated successfully\" % col\n else:\n data[\"message\"] = \"Failed to update %s\" % col\n except Exception as ex:\n data[\"message\"] = \"Failed to update %s\" % [ex]\n finally:\n return JsonResponse(data)","def test_create_task(self):\n response =self.client.post(reverse('todos'),self.data,format=\"json\")\n self.assertEqual(201,response.status_code)","def task_update_stats(request):\n tasks = json.loads(request.POST.get('tasks'))\n date_str = request.POST.get('date')\n cursor = ndb.Cursor(urlsafe=request.POST.get('cursor'))\n countdown = 15\n if not tasks:\n msg = 'Nothing to execute!?'\n logging.warning(msg)\n out = HttpTextResponse(msg)\n else:\n # Dispatch the task to execute.\n task = tasks.pop(0)\n logging.info('Running %s.', task)\n if task.count('-') == 2:\n out, cursor = update_daily_stats(\n cursor, datetime.datetime.strptime(task, DATE_FORMAT))\n elif task == 'monthly':\n # The only reason day is used is in case a task queue spills over the next\n # day.\n day = datetime.datetime.strptime(date_str, DATE_FORMAT)\n out, cursor = update_monthly_stats(cursor, day)\n elif task == '30':\n yesterday = (\n datetime.datetime.strptime(date_str, DATE_FORMAT)\n - datetime.timedelta(days=1)).date()\n out, cursor = update_rolling_stats(cursor, yesterday)\n else:\n msg = 'Unknown task %s, ignoring.' % task\n cursor = ''\n logging.error(msg)\n out = HttpTextResponse(msg)\n\n if cursor:\n # Not done yet!\n tasks.insert(0, task)\n countdown = 0\n\n if out.status_code == 200 and tasks:\n logging.info('%d tasks to go!\\n%s', len(tasks), ', '.join(tasks))\n # Space out the task queue execution by 15s to reduce the risk of\n # datastore inconsistency to get in the way, since no transaction is used.\n # This means to process a full month, it'll include 31*15s = 7:45 minutes\n # delay. 15s is not a lot but we are in an hurry!\n taskqueue.add(\n url=reverse(task_update_stats),\n params={\n 'tasks': json.dumps(tasks),\n 'date': date_str,\n 'cursor': cursor.urlsafe() if cursor else ''},\n queue_name='update-stats',\n countdown=countdown)\n return out","def update_task(request):\n task_id = request.POST.get('task_id', 0)\n modal_description = request.POST.get('description')\n modal_due_date = request.POST.get('dueDate')\n modal_name = request.POST.get('name')\n modal_priority = request.POST.get('priority')\n\n try:\n search_task = task_models.Task.query.filter(task_models.Task.id == task_id).first()\n except NoResultFound:\n return HttpResponse(simplejson.dumps({'success': False}))\n\n search_task.update(user=request.user, lastModifiedBy=request.user.id, lastModified=str(datetime.utcnow()),\n description=modal_description, dueDate=modal_due_date, name=modal_name, priority=modal_priority)\n\n return JsonResponse({\n 'lastModifiedBy': request.user.id,\n 'lastModified': str(datetime.utcnow())\n })","def test_task_post(self):\r\n admin = UserFactory.create()\r\n user = UserFactory.create()\r\n non_owner = UserFactory.create()\r\n app = AppFactory.create(owner=user)\r\n data = dict(app_id=app.id, state='0', info='my task data')\r\n root_data = dict(app_id=app.id, state='0', info='my root task data')\r\n\r\n # anonymous user\r\n # no api-key\r\n res = self.app.post('/api/task', data=json.dumps(data))\r\n error_msg = 'Should not be allowed to create'\r\n assert_equal(res.status, '401 UNAUTHORIZED', error_msg)\r\n\r\n ### real user but not allowed as not owner!\r\n res = self.app.post('/api/task?api_key=' + non_owner.api_key,\r\n data=json.dumps(data))\r\n\r\n error_msg = 'Should not be able to post tasks for apps of others'\r\n assert_equal(res.status, '403 FORBIDDEN', error_msg)\r\n\r\n # now a real user\r\n res = self.app.post('/api/task?api_key=' + user.api_key,\r\n data=json.dumps(data))\r\n assert res.data, res\r\n datajson = json.loads(res.data)\r\n out = db.session.query(Task)\\\r\n .filter_by(id=datajson['id'])\\\r\n .one()\r\n assert out, out\r\n assert_equal(out.info, 'my task data'), out\r\n assert_equal(out.app_id, app.id)\r\n\r\n # now the root user\r\n res = self.app.post('/api/task?api_key=' + admin.api_key,\r\n data=json.dumps(root_data))\r\n assert res.data, res\r\n datajson = json.loads(res.data)\r\n out = db.session.query(Task)\\\r\n .filter_by(id=datajson['id'])\\\r\n .one()\r\n assert out, out\r\n assert_equal(out.info, 'my root task data'), out\r\n assert_equal(out.app_id, app.id)\r\n\r\n # POST with not JSON data\r\n url = '/api/task?api_key=%s' % user.api_key\r\n res = self.app.post(url, data=data)\r\n err = json.loads(res.data)\r\n assert res.status_code == 415, err\r\n assert err['status'] == 'failed', err\r\n assert err['target'] == 'task', err\r\n assert err['action'] == 'POST', err\r\n assert err['exception_cls'] == 'ValueError', err\r\n\r\n # POST with not allowed args\r\n res = self.app.post(url + '&foo=bar', data=json.dumps(data))\r\n err = json.loads(res.data)\r\n assert res.status_code == 415, err\r\n assert err['status'] == 'failed', err\r\n assert err['target'] == 'task', err\r\n assert err['action'] == 'POST', err\r\n assert err['exception_cls'] == 'AttributeError', err\r\n\r\n # POST with fake data\r\n data['wrongfield'] = 13\r\n res = self.app.post(url, data=json.dumps(data))\r\n err = json.loads(res.data)\r\n assert res.status_code == 415, err\r\n assert err['status'] == 'failed', err\r\n assert err['target'] == 'task', err\r\n assert err['action'] == 'POST', err\r\n assert err['exception_cls'] == 'TypeError', err","def test_update_task_docs(self, mock_api, mock_custom_objects_api, mock_kube_config):\n task_id = util.MOCK_UUID_5\n rv = TEST_CLIENT.patch(\n f\"/tasks/{task_id}\",\n json={\"docs\": \"https://www.google.com.br\"},\n )\n self.assertEqual(rv.status_code, 200)","def get_tasks(self, task_id=None):\n # Recover all config from OpenVAS\n if task_id:\n return self.make_xml_request('<get_tasks id=\"%s\"/>' % name, xml_result=True)\n else:\n return self.make_xml_request(\"<get_tasks />\", xml_result=True)","def test_task(self, mocker):\n\n tid = 289466\n site = \"mysite\"\n json = self.generate_task_dictionary(tid, state=\"error\")\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, json=json)\n\n task = self.client.site(site).task(tid)\n self.assertEqual(task[\"id\"], tid)\n self.assertEqual(task[\"state\"], \"error\")","def test_anonymous_01_newtask(self):\r\n # Del previous TaskRuns\r\n self.create()\r\n self.del_task_runs()\r\n\r\n res = self.app.get('api/app/1/newtask')\r\n print res.data\r\n data = json.loads(res.data)\r\n assert data['info'], data","def test_get(self):\n task_types = [1, 2]\n\n for task_type in task_types:\n self.john_gamer.tasks.start(task_type)\n\n self.client.force_login(self.john)\n resp = self.client.get(self.URL)\n\n self.assertListEqual(\n resp.json(),\n ['Type: 1, time left: 42s', 'Type: 2, time left: 42s'],\n \"Gamer can't get list of task via API!\"\n )","def get(self, project_id, task_id):\n try:\n task = backend.get(Task, {'project.pk': request.project.pk, 'pk': task_id},\n only=self.export_fields, include=('project',), raw=True)\n except Task.DoesNotExist:\n return {'message': \"unknown task\"}, 404\n return {'task': self.export(task)}, 200","def create_task(self, unused_parent, task, **kwargs):\n self.uri = task.get('app_engine_http_request').get('relative_uri')\n self.body = task.get('app_engine_http_request').get('body')\n logging.info('Task uri: %r', self.uri)\n logging.info('Task body: %r', self.body)\n return 'fake task'","def post(self):\n\n headers = ''\n for key, value in self.request.headers.iteritems():\n headers += '%s: %s' % (key, value)\n headers += '\\r\\n'\n InboundRequest.add_record(datetime.utcnow(), self.request.host_url,\n self.request.path, headers, self.request.query_string, self.request.body)\n\n taskqueue.add(url='/check_wipe_task')","def command(task_id, tail, wip, limit):\n if task_id:\n task = storage.get_by_id(task_id)\n\n if not task:\n click.echo(f\"Task {task_id} not found.\")\n sys.exit(1)\n\n tasks = [task]\n else:\n tasks = storage.all(limit=limit, reverse=tail, wip=wip)\n\n print_header()\n for task in tasks:\n show_task(task)","def scheduled_tasks(request):\n\n # TODO: RYAN, here call schedule 1 (gameboard cleaner), don't forget to import it above\n # ryan_code.destroy_games()\n # IF ERROR EXAMPLE:\n # return Response({'error': 'Did not work because_!'},\n # status=status.HTTP_500_INTERNAL_SERVER_ERROR)\n\n # TODO: RYAN, here call schedule 2 (scores sorter to assign ranking to each user), don't forget to import it above\n # ryan_code2.set_rankings()\n\n # TODO: RYAN, no code here but need to setup the CI on github to have URL to this API call\n return Response({'Done'})","def post(self, *args, **kwargs):\n # Add some task debug information.\n headers = []\n for key, value in self.request.headers.items():\n k = key.lower()\n if k.startswith(\"x-appengine-\") and k not in self._SKIP_HEADERS:\n headers.append(\"%s:%s\" % (key, value))\n logging.debug(\", \".join(headers))\n\n # Make sure all modules are loaded\n if WARMUP_MODULE:\n importlib.import_module(WARMUP_MODULE)\n\n # Make sure we are called from the Task Queue (security)\n if isFromTaskQueue(self.request):\n try:\n _run(self.request.body)\n except deferred.SingularTaskFailure as e:\n msg = \"Failure executing task, task retry forced\"\n if e.message:\n msg += \": %s\" % e.message\n logging.debug(msg)\n self.response.set_status(408)\n except deferred.PermanentTaskFailure:\n logging.exception(\"Permanent failure attempting to execute task\")\n\n else:\n logging.critical('Detected an attempted XSRF attack: we are not executing from a task queue.')\n self.response.set_status(403)"],"string":"[\n \"def handle_tasks(self, request):\\n \\\"\\\"\\\"\\n @api {get} /tasks List tasks\\n @apiName GetTasks\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Return a list of all configured tasks, along with their configuration.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"021b2092ef4111e481a852540064e600\\\": {\\n \\\"name\\\": \\\"task 1\\\",\\n \\\"enabled\\\": true,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"web\\\"],\\n \\\"schedules\\\": [\\n {\\\"minute\\\": [\\\"*/5\\\"]}\\n ],\\n \\\"command\\\": \\\"/bin/task1\\\",\\n },\\n \\\"508b4b72e44611e49e76c81f66cd0cca\\\": {\\n \\\"name\\\": \\\"task 2\\\",\\n \\\"enabled\\\": false,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"pool2\\\"],\\n \\\"schedules\\\": [\\n {\\\"hours\\\": [15], \\\"minutes\\\": [0]}\\n ],\\n \\\"command\\\": \\\"/bin/task2\\\",\\n }\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {post} /tasks Create a new task\\n @apiName PostTasks\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Add a new task, providing its configuration.\\n\\n @apiParam {String} name Name.\\n @apiParam {String} description Description.\\n @apiParam {String[]} tags Tags.\\n @apiParam {Boolean} enabled Task is enabled.\\n @apiParam {String} mode Task mode (\\\"any\\\" or \\\"all\\\").\\n @apiParam {String[]} pools Pools on which the task should run.\\n @apiParam {Object[]} schedules Schedules at which the task should run.\\n @apiParam {String} command Command to run.\\n @apiParam {String} workdir Working directory.\\n @apiParam {String} user User which the task will be run.\\n @apiParam {String} group Group which the task will be run.\\n @apiParam {Object} env Environment variables to set.\\n @apiParam {String} mailreport If the mailer plugin is enabled, condition to send a report (\\\"error\\\", \\\"stdout\\\", \\\"stderr\\\", \\\"output\\\", \\\"always\\\").\\n @apiParam {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\\n\\n @apiParamExample {json} Example parameters:\\n {\\n \\\"name\\\": \\\"My task\\\",\\n \\\"description\\\": \\\"Task description\\\",\\n \\\"tags\\\": [\\\"tasg1\\\", \\\"tag2\\\"],\\n \\\"enabled\\\": true,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"web\\\"],\\n \\\"schedules\\\": [\\n {\\\"minute\\\": [\\\"*/1\\\"]}\\n ],\\n \\\"command\\\": \\\"/bin/true\\\",\\n \\\"workdir\\\": \\\"/tmp/\\\",\\n \\\"user\\\": \\\"www-data\\\",\\n \\\"group\\\": \\\"www-data\\\",\\n \\\"env\\\": {\\n \\\"MYENVVAR\\\": \\\"myvalue\\\"\\n },\\n \\\"mailreport\\\": \\\"output\\\",\\n \\\"mailto\\\": [\\\"user@domain.org\\\"]\\n }\\n\\n @apiSuccess {Boolean} created The task has been created.\\n @apiSuccess {String} id ID of the newly created task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"created\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {delete} /tasks Delete all tasks\\n @apiName DeleteTasks\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Delete all tasks. Use with caution.\\n\\n @apiSuccess {Boolean} deleted The tasks have been deleted.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"deleted\\\": true\\n }\\n \\\"\\\"\\\"\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n\\n if request.method == \\\"GET\\\":\\n tasks = self.cluster.config.get('tasks')\\n\\n if 'tag' in request.args and request.args['tag']:\\n tasks = dict( (taskid, task) for taskid, task in tasks.items() if 'tags' in task and request.args['tag'] in task['tags'] )\\n\\n return HTTPReply(code = 200, body = json.dumps(tasks), headers = headers)\\n\\n elif request.method == \\\"DELETE\\\":\\n oldtasks = self.cluster.config.get('tasks')\\n self.cluster.config.set('tasks', {})\\n\\n for (task, taskconfig) in oldtasks.items():\\n get_plugin_registry().call_hook('TaskDeleted', task, taskconfig)\\n\\n return HTTPReply(code = 200, body = json.dumps({\\\"deleted\\\": True}), headers = headers)\\n\\n elif request.method == \\\"POST\\\":\\n task = uuid.uuid1().hex\\n tasks = self.cluster.config.get('tasks')\\n tasks[task] = json.loads(request.body)\\n self.cluster.config.set('tasks', tasks)\\n\\n get_plugin_registry().call_hook('TaskCreated', task, tasks[task])\\n\\n return HTTPReply(code = 201, body = json.dumps({\\\"id\\\": task, \\\"created\\\": True}), headers = headers)\",\n \"def handle_task(self, request):\\n \\\"\\\"\\\"\\n @api {get} /tasks/:id Get a task\\n @apiName GetTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Returns the configuration of a task.\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {String} name Name.\\n @apiSuccess {String} description Description.\\n @apiSuccess {String[]} tags Tags.\\n @apiSuccess {Boolean} enabled Task is enabled.\\n @apiSuccess {String} mode Task mode (\\\"any\\\" or \\\"all\\\").\\n @apiSuccess {String[]} pools Pools on which the task should run.\\n @apiSuccess {Object[]} schedules Schedules at which the task should run.\\n @apiSuccess {String} command Command to run.\\n @apiSuccess {String} workdir Working directory.\\n @apiSuccess {String} user User which the task will be run.\\n @apiSuccess {String} group Group which the task will be run.\\n @apiSuccess {Object} env Environment variables to set.\\n @apiSuccess {String} mailreport If the mailer plugin is enabled, condition to send a report (\\\"error\\\", \\\"stdout\\\", \\\"stderr\\\", \\\"output\\\", \\\"always\\\").\\n @apiSuccess {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"name\\\": \\\"My task\\\",\\n \\\"description\\\": \\\"Task description\\\",\\n \\\"tags\\\": [\\\"tasg1\\\", \\\"tag2\\\"],\\n \\\"enabled\\\": true,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"web\\\"],\\n \\\"schedules\\\": [\\n {\\\"minute\\\": [\\\"*/1\\\"]}\\n ],\\n \\\"command\\\": \\\"/bin/true\\\",\\n \\\"workdir\\\": \\\"/tmp/\\\",\\n \\\"user\\\": \\\"www-data\\\",\\n \\\"group\\\": \\\"www-data\\\",\\n \\\"env\\\": {\\n \\\"MYENVVAR\\\": \\\"myvalue\\\"\\n },\\n \\\"mailreport\\\": \\\"output\\\",\\n \\\"mailto\\\": [\\\"user@domain.org\\\"]\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {put} /task/:id Update a task\\n @apiName PutTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Update a task. Can also be used to create a task with a specific ID.\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiParam {String} name Name.\\n @apiParam {String} description Description.\\n @apiParam {String[]} tags Tags.\\n @apiParam {Boolean} enabled Task is enabled.\\n @apiParam {String} mode Task mode (\\\"any\\\" or \\\"all\\\").\\n @apiParam {String[]} pools Pools on which the task should run.\\n @apiParam {Object[]} schedules Schedules at which the task should run.\\n @apiParam {String} command Command to run.\\n @apiParam {String} workdir Working directory.\\n @apiParam {String} user User which the task will be run.\\n @apiParam {String} group Group which the task will be run.\\n @apiParam {Object} env Environment variables to set.\\n @apiParam {String} mailreport If the mailer plugin is enabled, condition to send a report (\\\"error\\\", \\\"stdout\\\", \\\"stderr\\\", \\\"output\\\", \\\"always\\\").\\n @apiParam {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\\n\\n @apiParamExample {json} Example parameters:\\n {\\n \\\"name\\\": \\\"My task\\\",\\n \\\"description\\\": \\\"Task description\\\",\\n \\\"tags\\\": [\\\"tasg1\\\", \\\"tag2\\\"],\\n \\\"enabled\\\": true,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"web\\\"],\\n \\\"schedules\\\": [\\n {\\\"minute\\\": [\\\"*/1\\\"]}\\n ],\\n \\\"command\\\": \\\"/bin/true\\\",\\n \\\"workdir\\\": \\\"/tmp/\\\",\\n \\\"user\\\": \\\"www-data\\\",\\n \\\"group\\\": \\\"www-data\\\",\\n \\\"env\\\": {\\n \\\"MYENVVAR\\\": \\\"myvalue\\\"\\n },\\n \\\"mailreport\\\": \\\"output\\\",\\n \\\"mailto\\\": [\\\"user@domain.org\\\"]\\n }\\n\\n @apiSuccess {Boolean} updated The task has been updated.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"updated\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {delete} /task/:id Delete a task\\n @apiName DeleteTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Delete a task.\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} deleted The task has been deleted.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"deleted\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {execute} /task/:id Execute a task\\n @apiName ExecuteTask\\n @apiGroup Tasks\\n @apiVersion 1.1.0\\n\\n @apiDescription Execute a task.\\n\\n @apiParam {String} :id Task ID.\\n @apiParam {String} :target Target for task execution (\\\"local\\\" to execute on the local node, otherwise execute on the nodes on which the task is configured to run).\\n @apiParam {Boolean} :force Force the execution even if the concurrency limit is reached.\\n\\n @apiSuccess {Boolean} Executed The task has been executed.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"deleted\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n\\n match = re.match('/tasks/([0-9a-z]+)', request.uri_path)\\n task = match.group(1)\\n\\n tasks = self.cluster.config.get('tasks')\\n\\n if request.method == \\\"GET\\\":\\n if task in tasks:\\n return HTTPReply(code = 200, body = json.dumps(tasks[task]), headers = headers)\\n else:\\n return HTTPReply(code = 404, headers = {'Access-Control-Allow-Origin': '*'})\\n\\n elif request.method == \\\"PUT\\\":\\n new = json.loads(request.body)\\n if task in tasks:\\n old = tasks[task]\\n else:\\n old = None\\n\\n tasks[task] = new\\n self.cluster.config.set('tasks', tasks)\\n\\n if old:\\n code = 200\\n body = json.dumps({\\\"id\\\": task, \\\"updated\\\": True})\\n get_plugin_registry().call_hook('TaskUpdated', task, old, new)\\n else:\\n code = 201\\n body = json.dumps({\\\"id\\\": task, \\\"created\\\": True})\\n get_plugin_registry().call_hook('TaskCreated', task, new)\\n\\n return HTTPReply(code = code, body = body, headers = headers)\\n\\n elif request.method == \\\"DELETE\\\":\\n if task in tasks:\\n old = tasks[task]\\n del tasks[task]\\n self.cluster.config.set('tasks', tasks)\\n\\n get_plugin_registry().call_hook('TaskDeleted', task, old)\\n\\n return HTTPReply(code = 200, body = json.dumps({\\\"id\\\": task, \\\"deleted\\\": True}), headers = headers)\\n else:\\n return HTTPReply(code = 404, headers = {'Access-Control-Allow-Origin': '*'})\\n\\n if request.method == \\\"EXECUTE\\\":\\n try:\\n if 'target' in request.args and request.args['target'] == 'local':\\n self.manager.execute_task(task)\\n else:\\n self.cluster.scheduler.run_task(task, ignore_concurrency = 'force' in request.args)\\n\\n return HTTPReply(code = 200, body = json.dumps({\\\"id\\\": task, \\\"executed\\\": True}), headers = headers)\\n except ExecutionDisabled:\\n return HTTPReply(code = 503, body = json.dumps({\\\"id\\\": task, \\\"executed\\\": False}), headers = headers)\",\n \"def task_action_router(request, section_id, task_id):\\n\\n if request.method == 'PUT':\\n return update_task(request, task_id)\\n elif request.method == 'DELETE':\\n return delete_task(request, task_id)\\n else:\\n return HttpResponseNotAllowed('Method not allowed')\",\n \"def tasks_rpc():\\n # First check that this is a legitimate request from the coordinator\\n authenticate_coordinator()\\n action, task_id, release_id = validate_action(request.get_json(force=True))\\n # Call into action\\n return ROUTES[action](task_id, release_id)\",\n \"def task_element(request, task_id):\\n try:\\n task = Task.objects.get(id=task_id)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == \\\"GET\\\":\\n serializer = TaskSerializer(task)\\n return Response(serializer.data)\\n\\n elif request.method == \\\"PUT\\\":\\n data = json.loads(request.body)\\n\\n status = data.get(\\\"status\\\", \\\"\\\")\\n task.status = status\\n\\n try:\\n assignee = User.objects.get(username=data.get(\\\"assignee\\\", \\\"\\\"))\\n task.assignee = assignee\\n except:\\n pass\\n \\n task.save()\\n return JsonResponse({\\\"message\\\": \\\"Task updated successfully\\\"}, status=204)\\n\\n elif request.method == \\\"DELETE\\\":\\n task.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def task_detail(request, pk):\\n try:\\n task = Task.objects.get(pk=pk)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == 'GET':\\n serializer = TaskSerializer(task)\\n return Response(serializer.data)\\n\\n elif request.method == 'PUT':\\n serializer = TaskSerializer(task, data=request.DATA)\\n if serializer.is_valid():\\n serializer.save()\\n # returning the serializer data after saving it to the database\\n return Response(serializer.data)\\n\\n else:\\n # there were some validation errors with the data\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\n\\n elif request.method == 'DELETE':\\n # recall we already have the task present\\n task.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def on_get(self, req, resp):\\n try:\\n task_model_list = self.state_manager.get_tasks()\\n task_list = [x.to_dict() for x in task_model_list]\\n resp.text = json.dumps(task_list)\\n resp.status = falcon.HTTP_200\\n except Exception as ex:\\n self.error(\\n req.context,\\n \\\"Unknown error: %s\\\\n%s\\\" % (str(ex), traceback.format_exc()))\\n self.return_error(resp,\\n falcon.HTTP_500,\\n message=\\\"Unknown error\\\",\\n retry=False)\",\n \"def tasks_collection(request):\\n if request.method == \\\"GET\\\":\\n tasks = Task.objects.all().order_by(\\\"-timestamp\\\")\\n serializer = TaskSerializer(tasks, many=True)\\n return Response(serializer.data)\\n\\n elif request.method == \\\"POST\\\":\\n data = json.loads(request.body)\\n title = data.get(\\\"title\\\", \\\"\\\")\\n description = data.get(\\\"description\\\", \\\"\\\")\\n category = data.get(\\\"category\\\", \\\"\\\")\\n budget = data.get(\\\"budget\\\", \\\"\\\")\\n poster = User.objects.get(username=data.get(\\\"poster\\\", \\\"\\\"))\\n due_date = parser.parse(data.get(\\\"dueDate\\\", \\\"\\\"))\\n\\n task = Task(\\n title=title,\\n description=description,\\n poster=poster,\\n due_date=due_date,\\n budget=budget,\\n category=category\\n )\\n task.save()\\n return JsonResponse({\\\"message\\\": \\\"Task created successfully\\\"}, status=201)\",\n \"def task_list(request):\\n if request.method == \\\"GET\\\":\\n tasks = Task.objects.all()\\n\\n # tasks here is a query set. So we are essentially passing the entire query set into the serializer\\n # the many=True attribute here is super important. Without this attribute an error would be raised\\n\\n serializer = TaskSerializer(tasks, many=True)\\n return Response(serializer.data)\\n\\n elif request.method == \\\"POST\\\":\\n serializer = TaskSerializer(data=request.DATA)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data, status=status.HTTP_201_CREATED)\\n\\n else:\\n # there is a validation error and hence there is a problem with the data in the request\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def run_tasks(request):\\r\\n import os\\r\\n if not os.environ['SERVER_SOFTWARE'].startswith('Development'):\\r\\n logging.error(\\\"This URL is only valid in a development environment.\\\")\\r\\n raise Http404\\r\\n else:\\r\\n from datetime import datetime\\r\\n from google.appengine.api import apiproxy_stub_map\\r\\n stub = apiproxy_stub_map.apiproxy.GetStub('taskqueue')\\r\\n \\r\\n #get all the tasks for all the queues\\r\\n tasks = []\\r\\n for queue in stub.GetQueues():\\r\\n tasks.extend( stub.GetTasks(queue['name']) )\\r\\n \\r\\n #keep only tasks that need to be executed\\r\\n now = datetime.now()\\r\\n fn = lambda t: datetime.strptime(t['eta'],'%Y/%m/%d %H:%M:%S') < now\\r\\n tasks = filter(fn, tasks)\\r\\n\\r\\n from django.utils import simplejson as json\\r\\n result = '\\\\n'.join([json.dumps(t) for t in tasks])\\r\\n \\r\\n #remove tasks from queues\\r\\n for queue in stub.GetQueues():\\r\\n stub.FlushQueue(queue['name'])\\r\\n \\r\\n return HttpResponse(result)\",\n \"def post(self):\\n task = self.params.task\\n task.completed = not task.completed\\n task.put()\\n render_json(self, obj=task.as_json())\",\n \"def handle_task_enable(self, request):\\n \\\"\\\"\\\"\\n @api {post} /task/:id/enable Enable a task\\n @apiName EnableTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} updated The task has been updated.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"updated\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {post} /task/:id/disable Disable a task\\n @apiName DisableTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} updated The task has been updated.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"updated\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n\\n match = re.match('/tasks/([0-9a-z]+)/(en|dis)able', request.uri_path)\\n task = match.group(1)\\n action = match.group(2)\\n\\n enabled = (action == 'en')\\n\\n tasks = self.cluster.config.get('tasks')\\n\\n if task in tasks:\\n code = 200\\n\\n old = tasks[task].copy()\\n tasks[task]['enabled'] = enabled\\n self.cluster.config.set('tasks', tasks)\\n\\n get_plugin_registry().call_hook('TaskUpdated', task, old, tasks[task])\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n body = json.dumps({\\\"id\\\": task, \\\"updated\\\": True})\\n\\n return HTTPReply(code = code, body = body, headers = headers)\\n else:\\n headers = {\\n 'Access-Control-Allow-Origin': '*'\\n }\\n return HTTPReply(code = 404, headers = headers)\",\n \"def post(self, request):\\n if not request.user.is_authenticated():\\n return redirect(\\\"todo\\\")\\n\\n # _method contains the true verb the form want to use, if it's not POST.\\n method = request.POST.get(\\\"_method\\\", \\\"\\\")\\n if not method:\\n return self._create_task(request)\\n elif method == \\\"PUT\\\":\\n completed = request.POST.get(\\\"completed\\\", \\\"\\\")\\n title = request.POST.get(\\\"title\\\", \\\"\\\")\\n description = request.POST.get(\\\"description\\\", \\\"\\\")\\n if completed and not (title or description):\\n return self._complete_task(request)\\n else:\\n return self._edit_task(request)\\n elif method == \\\"DELETE\\\":\\n return self._delete_task(request)\\n\\n return self._no_valid_action()\",\n \"def system_ajax(request):\\n type = request.GET.get('api', None)\\n task_limit = getattr(settings, 'CELERYMON_TASK_LIMIT', 12)\\n celery_monitoring = getattr(settings, 'CELERY_FLOWER_URL', None)\\n if type == \\\"_active_tasks\\\":\\n server = Server(settings.COUCH_DATABASE)\\n try:\\n tasks = [x for x in server.active_tasks() if x['type'] == \\\"indexer\\\"]\\n except HTTPError as e:\\n if e.response.status_code == 403:\\n return JsonResponse({'error': \\\"Unable to access CouchDB Tasks (unauthorized).\\\"}, status=500)\\n else:\\n return JsonResponse({'error': \\\"Unable to access CouchDB Tasks.\\\"}, status=500)\\n\\n if not is_bigcouch():\\n return JsonResponse(tasks, safe=False)\\n else:\\n # group tasks by design doc\\n task_map = defaultdict(dict)\\n for task in tasks:\\n meta = task_map[task['design_document']]\\n tasks = meta.get('tasks', [])\\n tasks.append(task)\\n meta['tasks'] = tasks\\n\\n design_docs = []\\n for dd, meta in task_map.items():\\n meta['design_document'] = dd[len('_design/'):]\\n total_changes = sum(task['total_changes'] for task in meta['tasks'])\\n for task in meta['tasks']:\\n task['progress_contribution'] = task['changes_done'] * 100 // total_changes\\n\\n design_docs.append(meta)\\n return JsonResponse(design_docs, safe=False)\\n elif type == \\\"_stats\\\":\\n return JsonResponse({})\\n elif type == \\\"_logs\\\":\\n pass\\n elif type == 'pillowtop':\\n pillow_meta = get_all_pillows_json()\\n return JsonResponse(sorted(pillow_meta, key=lambda m: m['name'].lower()), safe=False)\\n\\n if celery_monitoring:\\n if type == \\\"flower_poll\\\":\\n ret = []\\n try:\\n all_tasks = requests.get(\\n celery_monitoring + '/api/tasks',\\n params={'limit': task_limit},\\n timeout=3,\\n ).json()\\n except Exception as ex:\\n return JsonResponse({'error': \\\"Error with getting from celery_flower: %s\\\" % ex}, status=500)\\n\\n for task_id, traw in all_tasks.items():\\n # it's an array of arrays - looping through [<id>, {task_info_dict}]\\n if 'name' in traw and traw['name']:\\n traw['name'] = '.'.join(traw['name'].split('.')[-2:])\\n else:\\n traw['name'] = None\\n ret.append(traw)\\n ret = sorted(ret, key=lambda x: x['succeeded'], reverse=True)\\n return HttpResponse(json.dumps(ret), content_type='application/json')\\n return HttpResponse('{}', content_type='application/json')\",\n \"def taskList(request):\\n try:\\n # if request.user.username == \\\"root\\\":\\n # pass\\n\\n title = request.data.get(\\\"title\\\", None)\\n desc = request.data.get(\\\"desc\\\", None)\\n stat = request.data.get(\\\"status\\\", None)\\n taskDueDate = request.data.get(\\\"taskDueDate\\\", None)\\n sortby = request.data.get(\\\"sortby\\\", None)\\n qs = Task.objects.filter(userID=request.user)\\n if sortby:\\n qs = qs.order_by(sortby)\\n\\n if title:\\n qs = qs.filter(Q(title__exact=title))\\n\\n if desc:\\n qs = qs.filter(Q(desc__exact=desc))\\n\\n if stat:\\n qs = qs.filter(Q(status__exact=stat))\\n\\n if taskDueDate:\\n qs = qs.filter(Q(taskDueDate__exact=taskDueDate))\\n\\n serializer = TaskSerializer(qs, many=True)\\n if len(serializer.data) != 0:\\n for i in range(len(serializer.data)):\\n serializer.data[i]['userID'] = request.user.username\\n\\n return Response(serializer.data, status=status.HTTP_200_OK)\\n\\n\\n except Exception as e:\\n return Response(e.args[0], status.HTTP_400_BAD_REQUEST)\",\n \"def handle_task_processes(self, request):\\n \\\"\\\"\\\"\\n @api {get} /task/:id/processes List running processes for a task\\n @apiName ListTaskProcesses\\n @apiGroup Tasks\\n @apiVersion 1.1.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"021b2092ef4111e481a852540064e600\\\" : {\\n \\\"node\\\": \\\"node1\\\",\\n \\\"start_time\\\": \\\"2018-03-29T15:01:13.465183+00:00\\\",\\n \\\"task\\\": \\\"e4d07482e44711e49e76c81f66cd0cca\\\"\\n },\\n \\\"253a96e29868135d746989a6123f521e\\\" : {\\n \\\"node\\\": \\\"node2\\\",\\n \\\"start_time\\\": \\\"2018-03-29T14:01:13.352067+00:00\\\",\\n \\\"task\\\": \\\"508b4b72e44611e49e76c81f66cd0cca\\\"\\n },\\n ...\\n }\\n \\\"\\\"\\\"\\n\\n match = re.match('/tasks/([0-9a-z]+)/processes', request.uri_path)\\n task = match.group(1)\\n\\n processes = self.cluster.list_task_processes(task)\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n body = json.dumps(processes)\\n\\n return HTTPReply(code = 200, body = body, headers = headers)\",\n \"def task_endponit():\\n action, task, release = parse_request(request)\\n\\n # Determine what action to take\\n if action == 'initialize':\\n # Assert that the service is ready to start a new task\\n tasks[task] = {\\n 'state': 'pending',\\n 'release_id': release,\\n 'task_id': task,\\n 'progress': 0\\n }\\n elif action == 'start':\\n # Here is where the bulk of the processing will happen\\n tasks[task] = {\\n 'state': 'running',\\n 'release_id': release,\\n 'task_id': task,\\n 'progress': 0\\n }\\n # Add to the queue\\n process.delay(task, release)\\n elif action == 'publish':\\n # Make the changes live\\n tasks[task] = {\\n 'state': 'publishing',\\n 'release_id': release,\\n 'task_id': task,\\n 'progress': 0\\n }\\n publish.delay(task, release)\\n elif action == 'get_status':\\n if task_id not in tasks:\\n abort(404)\\n return tasks[task]\\n elif action == 'cancel':\\n tasks[task] = {\\n 'state': 'canceled',\\n 'release_id': release,\\n 'task_id': task,\\n 'progress': 0\\n }\\n else:\\n # Not a valid action\\n abort(400)\\n\\n # Return current task state\\n return jsonify(tasks[task])\",\n \"def list(ctx, id, json):\\n\\n kargs={'host': c.cfg['host'], \\\"api_version\\\": c.cfg['api_version'], \\\"url_path\\\": \\\"/tasks\\\"}\\n if id != None:\\n return ctx.invoke(show, id=id, json=json)\\n\\n task = estask.Task(kargs)\\n try:\\n dict_resp= task.list()\\n except Exception as e:\\n sys.exit(\\\"Fail: %s\\\" %str(e))\\n\\n if dict_resp == None:\\n click.echo(\\\"Fail: error response\\\")\\n sys.exit(1)\\n\\n if json:\\n print(jsn.dumps(dict_resp, sort_keys=True, indent=4))\\n return\\n try:\\n task.print_list(dict_resp)\\n except Exception as e:\\n sys.exit(\\\"Fail: %s\\\" %str(e))\",\n \"def post(self, dnzo_user):\\n from google.appengine.ext import db\\n from tasks_data.models import Task\\n from tasks_data.tasks import update_task_with_params, save_task, task_list_can_add_task\\n from tasks_data.task_lists import get_task_list\\n \\n task = Task(parent=dnzo_user)\\n \\n task_list = self.request.get('task_list', None) \\n task_list = task_list and get_task_list(dnzo_user, task_list)\\n if task_list:\\n task.task_list = task_list\\n else:\\n self.bad_request(\\\"Could not find the specified task list.\\\")\\n return\\n \\n update_task_with_params(dnzo_user, task, self.request)\\n \\n if not task_list_can_add_task(task_list, task):\\n self.bad_request(\\\"Can not add task, too many active tasks in the list.\\\")\\n return\\n \\n save_task(dnzo_user, task)\\n\\n if not task.is_saved():\\n self.bad_request(\\\"Could not add the new task!\\\")\\n return\\n\\n # reload task \\n task = db.get(task.key())\\n \\n self.json_response(task=task.to_dict())\",\n \"def update_tasks():\\n response = \\\"\\\"\\\"\\\\\\n<form action=\\\"\\\" method=post>\\n<p>Category: <input type=text name=category></p>\\n<p>Priority: <input type=text name=priority></p>\\n<p>Description: <input type=text name=description></p>\\n<p><input type=submit value=Add></p>\\n</form>\\n\\n\\n<table border=\\\"1\\\" cellpadding=\\\"3\\\">\\n <tbody>\\n <tr>\\n <th>Category</th>\\n <th>Priority</th>\\n <th>Description</th>\\n </tr>\\n\\\"\\\"\\\"\\n\\n db_conn = DBConnection()\\n db_conn.get_conn()\\n\\n #db_conn.query_db('delete from tasks')\\n if request.method == 'POST':\\n category = request.form['category']\\n priority = request.form['priority']\\n description = request.form['description']\\n db_conn.add_task(category, priority, description)\\n return redirect('/task')\\n #return redirect(url_for('task')) # method name\\n\\n for single_task in db_conn.query_db('select * from tasks'):\\n if single_task['category'] or single_task['priority'] or single_task['description']:\\n response += \\\"<tr><td>%s</td>\\\" % (single_task['category'])\\n response += \\\"<td>%s</td>\\\" % (single_task['priority'])\\n response += \\\"<td>%s</td></tr>\\\" % (single_task['description'])\\n response += \\\"</tbody></table>\\\"\\n\\n db_conn.close_conn()\\n return response\",\n \"def on_get(self, req, resp, task_id):\\n task_result = AsyncResult(task_id)\\n result = {'status': task_result.status, 'result': task_result.result}\\n resp.status = falcon.HTTP_200\\n resp.body = json.dumps(result)\",\n \"def on_post(self, req, resp):\\n # A map of supported actions to the handlers for tasks for those actions\\n supported_actions = {\\n 'validate_design': TasksResource.task_validate_design,\\n 'verify_site': TasksResource.task_verify_site,\\n 'prepare_site': TasksResource.task_prepare_site,\\n 'verify_nodes': TasksResource.task_verify_nodes,\\n 'prepare_nodes': TasksResource.task_prepare_nodes,\\n 'deploy_nodes': TasksResource.task_deploy_nodes,\\n 'destroy_nodes': TasksResource.task_destroy_nodes,\\n 'relabel_nodes': TasksResource.task_relabel_nodes,\\n }\\n\\n try:\\n json_data = self.req_json(req)\\n\\n action = json_data.get('action', None)\\n if supported_actions.get(action, None) is None:\\n self.error(req.context, \\\"Unsupported action %s\\\" % action)\\n self.return_error(resp,\\n falcon.HTTP_400,\\n message=\\\"Unsupported action %s\\\" % action,\\n retry=False)\\n else:\\n supported_actions.get(action)(self, req, resp, json_data)\\n except Exception as ex:\\n self.error(\\n req.context,\\n \\\"Unknown error: %s\\\\n%s\\\" % (str(ex), traceback.format_exc()))\\n self.return_error(resp,\\n falcon.HTTP_500,\\n message=\\\"Unknown error\\\",\\n retry=False)\",\n \"def task(sync=False, methods=('GET',), takes='document'):\\n\\n def wrap(f):\\n global SYNC_TASKS, ASYNC_TASKS\\n\\n if takes == 'document':\\n url = slashjoin(['/', f.__module__.rsplit('.', 1)[-1],\\n '<index>/<doc_type>/<int:id>/<bodyfield>'])\\n\\n @wraps(f)\\n def f_task(doc_type, id, index, bodyfield, config):\\n es = getconf(config, 'main elasticsearch', error='raise')\\n doc = requests.get(slashjoin([es, index, doc_type, str(id)]))\\n content = doc.json()['_source'][bodyfield]\\n\\n return f(content, config)\\n\\n elif takes == None:\\n url = '/' + f.__module__.rsplit('.', 1)[-1]\\n f_task = f\\n\\n (SYNC_TASKS if sync else ASYNC_TASKS).append((f_task, url, methods))\\n\\n return f\\n\\n return wrap\",\n \"def add(request):\\n\\tif request.method == 'GET':\\n\\t\\tID = request.GET.get('id',False)\\n\\t\\tstatus = request.GET.get('status',False)\\n\\t\\ttaskname = request.GET.get('taskname',False)\\n\\t\\tdescription = request.GET.get('description','')\\n\\n\\t\\tprint(taskname)\\n\\t\\terror = {}\\n\\t\\tif not ID:\\n\\t\\t\\terror['error'] = \\\"id not given\\\"\\n\\t\\telif not status:\\n\\t\\t\\terror['error'] = \\\"status not given\\\"\\n\\t\\telif not taskname:\\n\\t\\t\\terror['error'] = \\\"taskname not given\\\"\\n\\t\\telif not description:\\n\\t\\t\\terror['error'] = \\\"description not given\\\"\\n\\t\\telse:\\n\\t\\t\\ttodo['task'].append({\\\"id\\\":ID,\\\"status\\\":status,\\\"taskname\\\":taskname,\\\"description\\\":description})\\n\\n\\t\\tif len(error) != 0:\\n\\t\\t\\tresponse = error\\n\\t\\telse:\\n\\t\\t\\tresponse = todo['task'][-1]\\n\\n\\treturn JsonResponse(response)\",\n \"def get_tasks(id):\\n url = 'https://jsonplaceholder.typicode.com/'\\n tasks = requests.get(url + 'todos', params={'userId': id}).json()\\n return tasks\",\n \"def view_task(self, task_id):\\n api_url = self.server_url + self.METHOD_VIEW_TASK + str(task_id)\\n\\n request = Request(api_url)\\n\\n log.info(\\\"Request to \\\" + api_url)\\n try:\\n response = request.get()\\n except HTTPError, e:\\n log.error(\\\"Error in view_task: \\\" + str(e))\\n raise CuckooError(str(e))\\n except ConnectionError, e:\\n log.error(\\\"Error in view_task: \\\" + str(e))\\n raise CuckooError(str(e))\\n\\n log.info(\\\"Response: \\\" + str(response))\\n\\n return response\",\n \"def edit_task(id):\\n\\n if not id:\\n raise InvalidAPIUsage(\\\"id is required\\\")\\n\\n content = get_content_or_400(request)\\n\\n collection = get_db_collection()\\n\\n task = get_task_or_404(collection, id)\\n\\n collection.update_one({\\\"_id\\\": task[\\\"_id\\\"]}, {\\\"$set\\\": {\\\"content\\\": content}})\\n\\n response = jsonify()\\n response.status_code = 200\\n return response\",\n \"def on_get(self, req, resp, task_id):\\n task = celery_app.AsyncResult(task_id)\\n\\n resp.body = json.dumps(\\n {'status': task.status, 'result': str(task.result)})\\n resp.status = falcon.HTTP_200\",\n \"def get_task(id):\\n\\n if not id:\\n raise InvalidAPIUsage(\\\"id is required\\\")\\n\\n collection = get_db_collection()\\n\\n task = get_task_or_404(collection, id)\\n\\n response = jsonify(content=task['content'])\\n response.status_code = 200\\n return response\",\n \"def get(self, dnzo_user, task_list):\\n self.json_response(task_list=task_list.to_dict())\",\n \"def task_offers_collection(request, task_id):\\n try:\\n task = Task.objects.get(id=task_id)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == \\\"GET\\\":\\n offers = Offer.objects.filter(task=task).all().order_by(\\\"-timestamp\\\")\\n serializer = OfferSerializer(offers, many=True)\\n return Response(serializer.data)\",\n \"def queue_cloud_task(request):\\n project = os.environ.get(\\\"PROJECT_ID\\\")\\n queue = os.environ.get(\\\"QUEUE_NAME\\\")\\n location = os.environ.get(\\\"QUEUE_REGION_LOCATION\\\")\\n service_account_email = os.environ.get(\\\"SERVICE_ACCOUNT_EMAIL\\\")\\n\\n request_json = request.get_json()\\n\\n # the http endpoint the task will send to\\n url = request_json.get('url')\\n # the post data that should be forwarded to the http endpoint\\n payload = request_json.get('payload')\\n # the time in seconds to delay task execution\\n in_seconds = request_json.get('in_seconds')\\n # the unique name of the task we are queueing\\n task_name = request_json.get('task_name')\\n\\n try:\\n # Create a client.\\n client = tasks_v2.CloudTasksClient()\\n # Construct the fully qualified queue name.\\n parent = client.queue_path(project, location, queue)\\n except Exception as e:\\n print(e)\\n return f\\\"{e}\\\", 500\\n\\n # Construct the request body.\\n task = {\\n \\\"http_request\\\": { # Specify the type of request.\\n \\\"http_method\\\": tasks_v2.HttpMethod.POST,\\n \\\"url\\\": url,\\n \\\"oidc_token\\\": {\\\"service_account_email\\\": service_account_email},\\n }\\n }\\n if payload is not None:\\n if isinstance(payload, dict):\\n # Convert dict to JSON string\\n payload = json.dumps(payload)\\n # specify http content-type to application/json\\n task[\\\"http_request\\\"][\\\"headers\\\"] = {\\\"Content-type\\\": \\\"application/json\\\"}\\n\\n # The API expects a payload of type bytes.\\n converted_payload = payload.encode()\\n\\n # Add the payload to the request.\\n task[\\\"http_request\\\"][\\\"body\\\"] = converted_payload\\n\\n if in_seconds is not None:\\n # Convert \\\"seconds from now\\\" into an rfc3339 datetime string.\\n d = datetime.datetime.utcnow() + datetime.timedelta(seconds=in_seconds)\\n\\n # Create Timestamp protobuf.\\n timestamp = timestamp_pb2.Timestamp()\\n timestamp.FromDatetime(d)\\n\\n # Add the timestamp to the tasks.\\n task[\\\"schedule_time\\\"] = timestamp\\n\\n if task_name is not None:\\n # Add the name to tasks.\\n name = f\\\"projects/{project}/locations/{location}/queues/{queue}/tasks{task_name}\\\"\\n task[\\\"name\\\"] = name\\n\\n try:\\n # Use the client to build and send the task.\\n response = client.create_task(request={\\\"parent\\\": parent, \\\"task\\\": task})\\n return f\\\"Created task {response.name}\\\", 200\\n except Exception as e:\\n print(e)\\n return f\\\"{e}\\\", 500\",\n \"def update_task_by_id(task_id):\\n try:\\n updated_task = get_task_from_request_form(request)\\n tasks = mongo.db.tasks\\n\\n result = tasks.update_one(\\n {\\\"_id\\\": ObjectId(task_id)},\\n {\\n \\\"$set\\\": {\\n \\\"title\\\": updated_task['title'],\\n \\\"reference\\\": updated_task['reference'],\\n \\\"description\\\": updated_task['description'],\\n \\\"status\\\": updated_task['status'],\\n \\\"visible\\\": updated_task['visible']\\n }\\n })\\n return json_util.dumps(get_task_by_id(task_id))\\n except:\\n abort(400)\",\n \"def post(self, request):\\n logger = Log.get_logger(__name__)\\n logger.info(\\\"Framework:: execute API Hits with parameter %s\\\", request.data)\\n global_context = request.data\\n context = {}\\n setup = None\\n valid = TaskGroupExecutionValidation(request.data, request.FILES)\\n if valid.is_valid():\\n try:\\n if request.data.get('taskGroupName'):\\n tg_name = request.data['taskGroupName'][0]\\n setup = TaskGroupExecuteView.getSetup(request)\\n all_taskgroup_objects = Taskgroup.objects.get(name=tg_name)\\n if all_taskgroup_objects:\\n context = TaskGroupExecuteView.getTGTasksName(all_taskgroup_objects, tg_name)\\n new_entry_response = ExecTasks.executeTasksList(\\n context['tgList'],\\n context['tasksList'],\\n global_context,\\n setup\\n )\\n return Response(new_entry_response)\\n else:\\n return Response(\\\"No TG with this name\\\")\\n elif request.data.get('tasks'):\\n is_exist = TaskGroupExecuteView.isTasksExists(request)\\n if is_exist.get('taskResult'):\\n setup = TaskGroupExecuteView.getSetup(request)\\n datetime = TaskGroupExecuteView.getHumanReadableDateTime()\\n tg = Taskgroup(\\n name='TG-'+datetime\\n )\\n tg.save()\\n all_taskgroup_objects = Taskgroup.objects.get(name=tg.name)\\n tasks_ids = TaskGroupExecuteView.getTaskIdsFromName(request.data['tasks'])\\n status = TaskGroupExecuteView.createRelationBetweenTGTasks(tg.id, tasks_ids)\\n if status:\\n context = TaskGroupExecuteView.getTGTasksName(all_taskgroup_objects, tg.name)\\n new_entry_response = ExecTasks.executeTasksList(\\n context['tgList'],\\n context['tasksList'],\\n global_context,\\n setup\\n )\\n return Response(new_entry_response)\\n else:\\n return Response(\\n is_exist['taskStatus'],\\n status=HTTP_400_BAD_REQUEST\\n )\\n else:\\n context['status'] = \\\"Task-Group Doesn't Exist.Pls create one.\\\"\\n return Response(context, status=HTTP_400_BAD_REQUEST)\\n except Exception as e:\\n return Response(e)\\n else:\\n context['status'] = 'Invalid input'\\n return Response(context, status=HTTP_400_BAD_REQUEST)\",\n \"def get_current_user_tasks_route():\\n user = current_user\\n\\n if user.get_id() is not None:\\n return get_user_jobs_route(user.id)\\n else:\\n response_object = {'status': 'error'}\\n return jsonify(response_object)\",\n \"def run_tasks(self, url=None, queue_name=None, method='POST', response_status_code=200, **kwargs):\\n from google.appengine.api import namespace_manager\\n tasks = self.taskqueue_stub.get_filtered_tasks(url=url,\\n queue_names=[queue_name])\\n for task in tasks:\\n namespace = task.headers.get('X-AppEngine-Current-Namespace', '')\\n previous_namespace = namespace_manager.get_namespace()\\n try:\\n namespace_manager.set_namespace(namespace)\\n headers = {\\n k: v for k, v in task.headers.iteritems()\\n if k.startswith('X-AppEngine')}\\n if method == 'PUT':\\n response = self.testapp.put(url, task.payload, headers=headers, status='*')\\n else:\\n response = self.testapp.post(url, task.payload, headers=headers, status='*')\\n finally:\\n namespace_manager.set_namespace(previous_namespace)\",\n \"def test_list_tasks_no_args(self):\\n rv = TEST_CLIENT.post(\\\"/tasks/list-tasks\\\", json={})\\n result = rv.json()\\n\\n expected = util.MOCK_TASK_LIST\\n self.assertEqual(result, expected)\\n self.assertEqual(rv.status_code, 200)\",\n \"def get(self):\\n url = \\\"http://twitter.com/statuses/public_timeline.json\\\"\\n task = taskqueue.Task(\\n url='/tasks/fetch',\\n params={'url': url}\\n )\\n task.add('fetch')\",\n \"def get(self, dnzo_user):\\n from tasks_data.models import Task\\n \\n updated_since = self.request.get('updated_since', None)\\n if updated_since:\\n from util.human_time import parse_datetime\\n updated_since = parse_datetime(updated_since)\\n if not updated_since:\\n self.bad_request(\\\"Could not parse supplied date.\\\")\\n return\\n \\n task_list_key = self.request.get('task_list', None) \\n task_list = None\\n if task_list_key:\\n from tasks_data.task_lists import get_task_list\\n task_list = get_task_list(dnzo_user, task_list_key)\\n if not task_list:\\n self.bad_request(\\\"Could not find task_list with key '%s'.\\\" % task_list_key)\\n return\\n \\n if not (task_list or updated_since):\\n self.bad_request(\\\"Must supply task_list or updated_since.\\\")\\n return\\n\\n from tasks_data.tasks import get_tasks\\n tasks = get_tasks(dnzo_user, updated_since=updated_since, task_list=task_list)\\n \\n data = { 'tasks': map(lambda t: t.to_dict(), tasks) }\\n \\n self.json_response(**data)\",\n \"def list(self, _request):\\n serializer = TaskSerializer(instance=TASKS.values(), many=True)\\n return response.Response(serializer.data)\",\n \"def do_task(self, task_type, upload_id, sys_config=1):\\n response = self.do_request(\\n self.base_url +\\n \\\"/oasis/doTask\\\" + task_type + \\\"/\\\" +\\n str(sys_config) + \\\"/\\\" +\\n str(upload_id) + \\\"/\\\"\\n )\\n return response\",\n \"def post(self):\\n try:\\n req = api.payload\\n result = create_task(\\n get_db(),\\n req[\\\"task\\\"],\\n date.fromisoformat(req[\\\"due_by\\\"]),\\n Status[req[\\\"status\\\"]],\\n )\\n return task_to_dict(result), 201\\n except ValueError:\\n api.abort(422, \\\"Invalid request parameters\\\")\",\n \"def running_celery_tasks(request):\\n active_dict = CELERY_INSPECT.active()\\n active_tasks = []\\n if active_dict:\\n for task_list in active_dict.values():\\n active_tasks.extend(task_list)\\n if active_tasks:\\n active_tasks = [dikt.get(\\\"id\\\", \\\"\\\") for dikt in active_tasks]\\n return Response({\\\"active_tasks\\\": active_tasks})\",\n \"def get_tasks(data: dict) -> dict:\\n status_code = http.HTTPStatus.OK\\n body = {\\\"filters\\\": data}\\n try:\\n tasks = actions.get_tasks(data)\\n body[\\\"tasks\\\"] = [task.to_dict() for task in tasks]\\n except tskexc.TaskHTTPException as e:\\n body = {\\\"error\\\": e.message}\\n status_code = e.http_status\\n return {\\\"statusCode\\\": status_code, \\\"body\\\": json.dumps(body)}\",\n \"def fusion_api_get_task(self, param='', uri=None, api=None, headers=None):\\n if uri is not None:\\n # update fully qualified URL to relative URI\\n uri = re.sub('^https://\\\\d*.\\\\d*.\\\\d*.\\\\d*', '', uri)\\n return self.task.get(uri=uri, api=api, headers=headers, param=param)\",\n \"def POST_task(self, task_data):\\n\\t\\tif not self.room_id:\\n\\t\\t\\tself.POST_room()\\n\\t\\trv = self.POST_data('/api/room/' + self.room_id + '/task', data=task_data)\\n\\t\\tself.assertEqual(rv.status_code, 200)\\n\\t\\treturn json.loads(rv.data)['_id']\",\n \"def handle_task_running(self, request):\\n \\\"\\\"\\\"\\n @api {get} /task/:id/running Check if a task is running\\n @apiName IsTaskRunning\\n @apiGroup Tasks\\n @apiVersion 1.1.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} running The task is running.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"running\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n\\n match = re.match('/tasks/([0-9a-z]+)/running', request.uri_path)\\n task = match.group(1)\\n\\n running = self.cluster.is_task_running(task)\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n body = json.dumps({\\\"id\\\": task, \\\"running\\\": running})\\n\\n return HTTPReply(code = 200, body = body, headers = headers)\",\n \"def test_task_list():\\n # Fake pyramid request, useful for testing.\\n request = testing.DummyRequest()\\n\\n pytest.fail('Not implemented yet.')\",\n \"def test_api_task_get_task(api, new_user, new_task):\\n api.authenticate(new_user.username, new_user.password)\\n task = api.get_task(new_task.id)\\n assert new_task == task\",\n \"def put(self, dnzo_user, task):\\n from google.appengine.ext import db\\n from tasks_data.tasks import update_task_with_params, save_task\\n \\n task_was_archived = task.archived\\n\\n try:\\n # hack to allow form-encoded PUT bodies to be accessed by self.request.get()\\n self.request.method = \\\"POST\\\"\\n update_task_with_params(dnzo_user, task, self.request)\\n \\n except AssertionError, strerror:\\n self.bad_request(strerror.message)\\n return\\n \\n finally:\\n self.request.method = \\\"PUT\\\"\\n \\n archived_status_changed = task_was_archived != task.archived\\n if archived_status_changed and not task.archived:\\n from tasks_data.tasks import task_list_can_add_task\\n if not task_list_can_add_task(task.task_list, task):\\n self.bad_request(\\\"Can not unarchive task, too many active tasks in the list.\\\")\\n return\\n \\n save_task(dnzo_user, task, archived_status_changed)\\n # reload task\\n task = db.get(task.key())\\n \\n self.json_response(task=task.to_dict())\",\n \"def task_start_parsing():\\n add_task(url_for(\\\"task_queue_users\\\"))\\n add_task(url_for(\\\"task_clean_tmp_files\\\"))\\n return OK_RESPONSE\",\n \"def test_resource_endpoint_returns_correct_data(self):\\n self.add_tasks()\\n response = self.app.get('api/v1/tasks/2', follow_redirects=True)\\n self.assertEquals(response.status_code, 200)\\n self.assertEquals(response.mimetype, 'application/json')\\n self.assertNotIn(b'Test task 1.', response.data)\\n self.assertIn(b'A totally different thing.', response.data)\",\n \"def accept_todo(request):\\n auth_token = request.META.get('HTTP_TOKEN', None)\\n todoid = request.POST.get('todo_id', None)\\n isaccepted = request.POST.get('is_accepted', None)\\n result = Tasks(auth_token=auth_token).accept_task(todoid, isaccepted)\\n return Response(\\n {\\n 'success': result\\n }\\n )\",\n \"def get(self, dnzo_user):\\n from tasks_data.models import Task\\n from util.human_time import parse_datetime\\n \\n start_at = self.request.get('start_at', None)\\n end_at = self.request.get('end_at', None)\\n if not (start_at and end_at):\\n self.bad_request(\\\"Must include start_at and end_at for archived tasks.\\\")\\n return\\n \\n start_at = parse_datetime(start_at)\\n if not start_at:\\n self.bad_request(\\\"Could not parse supplied date 'start_at'.\\\")\\n return\\n \\n end_at = parse_datetime(end_at)\\n if not end_at:\\n self.bad_request(\\\"Could not parse supplied date 'end_at'.\\\")\\n return\\n \\n if (start_at > end_at):\\n self.bad_request(\\\"Invalid range; start_at must come before end_at.\\\")\\n return\\n\\n from tasks_data.tasks import get_archived_tasks\\n tasks = get_archived_tasks(dnzo_user, start_at, end_at)\\n \\n data = { 'tasks': map(lambda t: t.to_dict(), tasks) }\\n \\n self.json_response(**data)\",\n \"def new_task():\\n req = request.json\\n if 'cmd' in req:\\n id = mongo.db.tasks.insert({\\n 'cmd' : req['cmd'],\\n 'status' : 'Not started'\\n })\\n\\n response = {'id' : str(id)}\\n return response\",\n \"def put(self, guid):\\n key = db.Key.from_path('Task', int(guid))\\n task = db.get(key)\\n if task != None:\\n # cache current values before updates\\n taskName = task.name\\n taskType = task.type\\n taskPriority = task.priority\\n taskStatus = task.developmentStatus\\n taskValidation = task.validation\\n taskSubmitterId = task.submitterId\\n taskAssigneeId = task.assigneeId\\n taskEffort = task.effort\\n taskProjectId = task.projectId\\n taskDescription = task.description\\n # collect the json from the request\\n task_json = simplejson.loads(self.request.body)\\n # if the user is a guest the project must be unallocated\\n wantsNotifications = {\\\"true\\\": True, \\\"false\\\": False}.get(self.request.params['notify'].lower())\\n currentUserId = self.request.params['UUID']\\n cukey = db.Key.from_path('User', int(currentUserId))\\n user = db.get(cukey)\\n if str(user.role) != '_Guest' or (task_json.has_key('projectId') == False or task_json['projectId'] == None):\\n # update the project record\\n task = helpers.apply_json_to_model_instance(task, task_json)\\n # save the updated data\\n task.put()\\n # Push notification email on the queue if we need to notify\\n if notification.should_notify(currentUserId,task,\\\"updateTask\\\",wantsNotifications):\\n taskqueue.add(url='/mailer', params={'taskId': int(guid), 'currentUUID': self.request.params['UUID'], 'action': \\\"updateTask\\\", 'name': taskName, 'type': taskType, 'priority': taskPriority, 'status': taskStatus, 'validation': taskValidation, 'submitterId': taskSubmitterId, 'assigneeId': taskAssigneeId, 'effort': taskEffort, 'projectId': taskProjectId, 'description': taskDescription})\\n # return the same record...\\n self.response.headers['Content-Type'] = 'application/json'\\n self.response.out.write(simplejson.dumps(task_json))\\n else:\\n self.response.set_status(401, \\\"Not Authorized\\\")\\n else:\\n self.response.set_status(404, \\\"Task not found\\\")\",\n \"def on_get(self, req, resp, task_id):\\n try:\\n builddata = req.get_param_as_bool('builddata')\\n subtask_errors = req.get_param_as_bool('subtaskerrors')\\n try:\\n layers = int(req.params.get('layers', '0'))\\n except Exception:\\n layers = 0\\n\\n first_task = self.get_task(req, resp, task_id, builddata)\\n\\n if first_task is None:\\n self.info(req.context, \\\"Task %s does not exist\\\" % task_id)\\n self.return_error(resp,\\n falcon.HTTP_404,\\n message=\\\"Task %s does not exist\\\" % task_id,\\n retry=False)\\n else:\\n # If layers is passed in then it returns a dict of tasks instead of the task dict.\\n if layers:\\n resp_data, errors = self.handle_layers(\\n req, resp, task_id, builddata, subtask_errors, layers,\\n first_task)\\n # Includes subtask_errors if the query param 'subtaskerrors' is passed in as true.\\n if (subtask_errors):\\n resp_data['subtask_errors'] = errors\\n else:\\n resp_data = first_task\\n # Includes subtask_errors if the query param 'subtaskerrors' is passed in as true.\\n if (subtask_errors):\\n _, errors = self.handle_layers(req, resp, task_id,\\n False, subtask_errors,\\n 1, first_task)\\n resp_data['subtask_errors'] = errors\\n\\n resp.text = json.dumps(resp_data)\\n resp.status = falcon.HTTP_200\\n except Exception as ex:\\n self.error(req.context, \\\"Unknown error: %s\\\" % (str(ex)))\\n self.return_error(resp,\\n falcon.HTTP_500,\\n message=\\\"Unknown error\\\",\\n retry=False)\",\n \"def get(self, subresource, **kwargs):\\n return getattr(RESTTask, subresource)(self, **kwargs)\",\n \"def remove_task(id):\\n\\n if not id:\\n raise InvalidAPIUsage(\\\"id is required\\\")\\n\\n collection = get_db_collection()\\n\\n task = get_task_or_404(collection, id)\\n\\n collection.delete_one({\\\"_id\\\": task[\\\"_id\\\"]})\\n\\n response = jsonify()\\n response.status_code = 200\\n return response\",\n \"def task_questions_collection(request, task_id):\\n try:\\n task = Task.objects.get(id=task_id)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == \\\"GET\\\":\\n questions = Question.objects.filter(task=task).all().order_by(\\\"-timestamp\\\")\\n serializer = QuestionSerializer(questions, many=True)\\n return Response(serializer.data)\",\n \"def todo_list(request):\\n if request.method == 'GET':\\n todos = Todo.objects.all()\\n serializer = TodoSerializer(todos, many=True)\\n return Response(serializer.data)\\n \\n elif request.method == 'POST':\\n serializer = TodoSerializer(data=request.data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data, status=status.HTTP_201_CREATED)\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def process_task(params):\\n params['task'](params)\",\n \"def update_task(request, tid):\\n try:\\n slogger.task[tid].info(\\\"update task request\\\")\\n labels = request.POST['labels']\\n task.update(tid, labels)\\n except Exception as e:\\n slogger.task[tid].error(\\\"cannot update task\\\", exc_info=True)\\n return HttpResponseBadRequest(str(e))\\n\\n return HttpResponse()\",\n \"def remove(request):\\n\\tID = request.GET.get('id',False)\\n\\n\\tif not ID:\\n\\t\\tresponse = {\\\"error\\\":\\\"id not entered\\\"}\\n\\telse:\\n\\t\\tID = str(ID)\\n\\t\\tk = 0\\n\\t\\tfor i,task in enumerate(todo['task']):\\n\\t\\t\\ttask_id = task.get('id',False)\\n\\t\\t\\tif ID == task_id:\\n\\t\\t\\t\\tk += 1\\n\\t\\t\\t\\tidx = i\\n\\t\\tif k == 0:\\n\\t\\t\\tresponse = {\\\"error\\\":\\\"id not fount\\\"}\\n\\t\\telse:\\n\\t\\t\\tresponse = todo['task'].pop(idx)\\n\\n\\treturn JsonResponse(response)\",\n \"def list(self, request, *args, **kwargs):\\n return super(SubtaskViewSet, self).list(request, *args, **kwargs)\",\n \"def edit_task_page(request):\\n data = {}\\n try:\\n tasklist = request.GET.get(\\\"tasklist\\\")\\n task = request.GET.get(\\\"task\\\")\\n data[\\\"tasklist\\\"] = tasklist\\n\\n task_obj = Todo.objects.get(title=task)\\n data[\\\"data\\\"] = task_obj\\n\\n return render(request, \\\"pages/update-task.html\\\", data)\\n except Exception as ex:\\n return HttpResponse(ex)\",\n \"def update_task(self, task):\\n create = task.id == 0\\n\\n xml = self._serialise_task(task)\\n\\n method = ['PUT','POST'][create]\\n\\n if create:\\n url = \\\"%s/tasks?%s\\\" % \\\\\\n (self._get_base_url(), self._get_url_params())\\n else:\\n url = \\\"%s/tasks/%s?%s\\\" % \\\\\\n (self._get_base_url(), task.id, self._get_url_params())\\n\\n headers = { \\\"Accept\\\":\\\"application/xml\\\",\\n \\\"Content-Type\\\":\\\"application/xml\\\" }\\n self.__conn.request(method, url, xml, headers) \\n response = self.__conn.getresponse()\\n\\n data = response.read()\\n\\n if not response.status == 200:\\n raise Exception(\\\"Could not update/create task.\\\"\\\\\\n \\\" Response was [%s]: %s\\\" % (response.status, data))\\n\\n return self._parse_task(ET.fromstring(data))\",\n \"def test_04_new_task(self):\\r\\n url = '/api/app/1/newtask'\\r\\n self.check_limit(url, 'get', 'app')\",\n \"def export(short_name, task_id):\\r\\n # Check if the app exists\\r\\n (app, owner, n_tasks, n_task_runs,\\r\\n overall_progress, last_activity) = app_by_shortname(short_name)\\r\\n try:\\r\\n require.app.read(app)\\r\\n except HTTPException:\\r\\n if app.hidden:\\r\\n raise abort(403)\\r\\n else: # pragma: no cover\\r\\n raise\\r\\n\\r\\n # Check if the task belongs to the app and exists\\r\\n task = db.session.query(model.task.Task).filter_by(app_id=app.id)\\\\\\r\\n .filter_by(id=task_id).first()\\r\\n if task:\\r\\n taskruns = db.session.query(model.task_run.TaskRun).filter_by(task_id=task_id)\\\\\\r\\n .filter_by(app_id=app.id).all()\\r\\n results = [tr.dictize() for tr in taskruns]\\r\\n return Response(json.dumps(results), mimetype='application/json')\\r\\n else:\\r\\n return abort(404)\",\n \"def get(self, request):\\n feedback = {\\n 'permission': True\\n }\\n\\n try:\\n task_id = request.GET.get('task_id', None)\\n if task_id is None:\\n feedback['data'] = ErrorCode.parameter_missing('task_id')\\n raise natrix_exception.ParameterMissingException(parameter='task_id')\\n try:\\n uuid.UUID(hex=task_id)\\n except ValueError:\\n feedback['data'] = ErrorCode.parameter_invalid('task_id', reason=u'must be a UUID')\\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\\n try:\\n task = Task.objects.get(id=task_id, time_type='instant')\\n # response_count = success + wrong\\n res = command_dispatcher.get_task_data(task.id)\\n success = len(res.get('success'))\\n wrong = len(res.get('error'))\\n response_count = success + wrong\\n\\n time_delta = timezone.now() - task.create_time\\n\\n if task.status and ( response_count == task.terminal_count or time_delta.seconds > 120):\\n task.status = False\\n task.result_snapshot = json.dumps(res)\\n task.save()\\n\\n feedback['data'] = {\\n 'code': 200,\\n 'message': 'Instant Task Status',\\n 'info': {\\n 'finished': not task.status,\\n 'total': task.terminal_count,\\n 'responses': response_count,\\n 'success': success,\\n 'wrong': wrong\\n }\\n }\\n\\n except Task.DoesNotExist:\\n feedback['data'] = ErrorCode.parameter_invalid(\\n 'task_id', reason=u'Can not retrieve Instant Task: {}'.format(task_id))\\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\\n\\n except natrix_exception.NatrixBaseException as e:\\n logger.error(e.get_log())\\n\\n return JsonResponse(data=feedback)\",\n \"def test_get_task(self):\\n resp = self.app.get('/api/2/inf/esrs',\\n headers={'X-Auth': self.token})\\n\\n task_id = resp.json['content']['task-id']\\n expected = 'asdf-asdf-asdf'\\n\\n self.assertEqual(task_id, expected)\",\n \"def test_task_query_without_params(self):\\r\\n app = AppFactory.create()\\r\\n TaskFactory.create_batch(10, app=app, info={'question': 'answer'})\\r\\n res = self.app.get('/api/task')\\r\\n tasks = json.loads(res.data)\\r\\n assert len(tasks) == 10, tasks\\r\\n task = tasks[0]\\r\\n assert task['info']['question'] == 'answer', task\\r\\n\\r\\n # The output should have a mime-type: application/json\\r\\n assert res.mimetype == 'application/json', res\",\n \"def update_task(project_id,task_id):\\n data = request.get_json()\\n project = Project.query.filter_by(id=project_id).first()\\n if not project:\\n return {\\n 'success': False,\\n 'message': f\\\"No project with the specified id {project_id} found.\\\",\\n }\\n\\n else:\\n permission = has_project_permission(project, g.user)\\n old_task = Task.query.filter_by(id=task_id)\\n if not old_task:\\n abort(404, f'There is no task with ID of {task_id}.')\\n\\n if old_task:\\n db_session.delete(old_task)\\n db_session.commit()\\n name = data['name']\\n project_id = data['project_id']\\n description = data['description']\\n completion_status = data['completion_status']\\n created_date = data['created_date']\\n deadline_date = data['deadline_date']\\n new_task = Task(\\n name=name, description=description, completion_status=completion_status,\\n created_date = created_date, deadline_date = deadline_date, project_id=project_id, created_by=g.user)\\n db_session.add(new_task)\\n db_session.commit()\\n return {\\n 'success': True,\\n 'result': task_schema.dump(new_task),\\n 'message': \\\"Successfully Updated the Task.\\\",\\n }\",\n \"def post(self):\\n\\n from jinjamator.task.celery import run_jinjamator_task\\n from jinjamator.daemon.database import db\\n\\n relative_task_path = request.endpoint.replace(\\n \\\"api.\\\", \\\"\\\"\\n )\\n data = request.get_json()\\n job_id = str(uuid.uuid4())\\n user_id = g._user[\\\"id\\\"]\\n\\n job = run_jinjamator_task.apply_async(\\n [\\n relative_task_path,\\n data,\\n data.get(\\\"output_plugin\\\", \\\"console\\\"),\\n user_id,\\n ],\\n task_id=job_id,\\n created_by_user_id=user_id,\\n )\\n\\n db_job = list(\\n db.session.query(DB_Job).filter(\\n DB_Job.task_id == job.id\\n )\\n )\\n db_job = db_job and db_job[0]\\n if not db_job:\\n db_job = DB_Job(job.id)\\n db_job.status = \\\"SCHEDULED\\\"\\n db_job.configuration = data\\n db_job.jinjamator_task = relative_task_path\\n db_job.created_by_user_id = user_id\\n db.session.add(db_job)\\n db.session.flush()\\n db.session.commit()\\n\\n return jsonify({\\\"job_id\\\": job.id})\",\n \"def get_tasks(self, *args, **kwargs):\\n tasks_endpoint = furl(self.ENDPOINT) / self.id / \\\"tasks\\\"\\n return self._client.list(Task, endpoint=tasks_endpoint.url, *args, **kwargs)\",\n \"def Product_detail(request, pk):\\n try:\\n task = Product.objects.get(pk=pk)\\n except Product.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == 'GET':\\n serializer = ProductSerializer(task)\\n print(serializer.data)\\n return Response(serializer.data)\\n\\n elif request.method == 'PUT':\\n serializer = ProductSerializer(task, data=request.DATA)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data)\\n else:\\n return Response(\\n serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\n\\n elif request.method == 'DELETE':\\n task.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def test_newtask(self):\\r\\n app = AppFactory.create()\\r\\n TaskFactory.create_batch(2, app=app)\\r\\n user = UserFactory.create()\\r\\n\\r\\n # anonymous\\r\\n # test getting a new task\\r\\n res = self.app.get('/api/app/%s/newtask' % app.id)\\r\\n assert res, res\\r\\n task = json.loads(res.data)\\r\\n assert_equal(task['app_id'], app.id)\\r\\n\\r\\n # The output should have a mime-type: application/json\\r\\n assert res.mimetype == 'application/json', res\\r\\n\\r\\n # as a real user\\r\\n url = '/api/app/%s/newtask?api_key=%s' % (app.id, user.api_key)\\r\\n res = self.app.get(url)\\r\\n assert res, res\\r\\n task = json.loads(res.data)\\r\\n assert_equal(task['app_id'], app.id)\\r\\n\\r\\n # Get NotFound for an non-existing app\\r\\n url = '/api/app/5000/newtask'\\r\\n res = self.app.get(url)\\r\\n err = json.loads(res.data)\\r\\n err_msg = \\\"The app does not exist\\\"\\r\\n assert err['status'] == 'failed', err_msg\\r\\n assert err['status_code'] == 404, err_msg\\r\\n assert err['exception_cls'] == 'NotFound', err_msg\\r\\n assert err['target'] == 'app', err_msg\\r\\n\\r\\n # Get an empty task\\r\\n url = '/api/app/%s/newtask?offset=1000' % app.id\\r\\n res = self.app.get(url)\\r\\n assert res.data == '{}', res.data\",\n \"def process_project_route(id):\\n response_object = {'status': 'success'}\\n if request.method == 'POST':\\n with database.engine.begin() as connection:\\n app = flask.current_app\\n params = request.get_json()['params']\\n task = current_user.launch_task('morphocut_server.api.process_project',\\n 'Processing project...', id, id, params)\\n response_object['job_id'] = task.id\\n print(\\\"return process\\\")\\n return jsonify(response_object), 202\",\n \"def add_task(id):\\n\\n content = get_content_or_400(request)\\n\\n collection = get_db_collection()\\n\\n object_id = None\\n if id:\\n object_id = ObjectId(id)\\n object = collection.find({\\\"_id\\\": object_id})\\n if object:\\n response = jsonify(errormsg=\\\"id already exists\\\")\\n response.status_code = 400\\n return response\\n\\n new_object = {\\\"content\\\": content}\\n if id:\\n new_object[\\\"_id\\\"] = id\\n new_object_id = collection.insert_one(new_object).inserted_id\\n\\n response = jsonify(id=str(new_object_id))\\n response.status_code = 201\\n response.headers[\\\"Location\\\"] = url_for('get_task', id=new_object_id)\\n return response\",\n \"def insert_task():\\n try:\\n task = get_task_from_request_form(request)\\n result = mongo.db.tasks.insert_one(task)\\n return json_util.dumps(get_task_by_id(result.inserted_id))\\n except Exception as err:\\n abort(400)\",\n \"def test_incremental_tasks(self):\\r\\n self.create_2(sched='incremental')\\r\\n\\r\\n # Del previous TaskRuns\\r\\n self.del_task_runs()\\r\\n\\r\\n # Register\\r\\n self.register(fullname=self.user.fullname, name=self.user.username,\\r\\n password=self.user.password)\\r\\n self.register(fullname=\\\"Marie Doe\\\", name=\\\"mariedoe\\\", password=\\\"dr0wss4p\\\")\\r\\n self.signin()\\r\\n\\r\\n # Get the only task with no runs!\\r\\n res = self.app.get('api/app/1/newtask')\\r\\n data = json.loads(res.data)\\r\\n # Check that we received a clean Task\\r\\n assert data.get('info'), data\\r\\n assert not data.get('info').get('last_answer')\\r\\n\\r\\n # Submit an Answer for the assigned task\\r\\n tr = dict(app_id=data['app_id'], task_id=data['id'], info={'answer': 'No'})\\r\\n tr = json.dumps(tr)\\r\\n\\r\\n self.app.post('/api/taskrun', data=tr)\\r\\n # No more tasks available for this user!\\r\\n res = self.app.get('api/app/1/newtask')\\r\\n data = json.loads(res.data)\\r\\n assert not data\\r\\n\\r\\n #### Get the only task now with an answer as Anonimous!\\r\\n self.signout()\\r\\n res = self.app.get('api/app/1/newtask')\\r\\n data = json.loads(res.data)\\r\\n\\r\\n # Check that we received a Task with answer\\r\\n assert data.get('info'), data\\r\\n assert data.get('info').get('last_answer').get('answer') == 'No'\\r\\n\\r\\n # Submit a second Answer as Anonimous\\r\\n tr = dict(app_id=data['app_id'], task_id=data['id'],\\r\\n info={'answer': 'No No'})\\r\\n tr = json.dumps(tr)\\r\\n\\r\\n self.app.post('/api/taskrun', data=tr)\\r\\n\\r\\n #### Get the only task now with an answer as User2!\\r\\n self.signin(email=\\\"mariedoe@example.com\\\", password=\\\"dr0wss4p\\\")\\r\\n res = self.app.get('api/app/1/newtask')\\r\\n data = json.loads(res.data)\\r\\n\\r\\n # Check that we received a Task with answer\\r\\n assert data.get('info'), data\\r\\n assert data.get('info').get('last_answer').get('answer') == 'No No'\",\n \"def test_my_tasks(self):\\n url, parsed = self.prepare_urls(\\n 'v1:activity-my-tasks', subdomain=self.company.subdomain)\\n \\n response = self.client.get(url, HTTP_HOST=parsed.netloc)\\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)\\n\\n self.authenticate_user()\\n response = self.client.get(url, HTTP_HOST=parsed.netloc)\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n \\n content = json.loads(response.content)\\n self.assertTrue(content.has_key('count'))\\n self.assertTrue(content.has_key('next'))\\n self.assertTrue(content.has_key('previous'))\\n self.assertTrue(content.has_key('results'))\",\n \"def test_update_task(self):\\n rv = TEST_CLIENT.patch(\\n \\\"/tasks/foo\\\",\\n json={\\n \\\"name\\\": \\\"foo 2\\\",\\n },\\n )\\n result = rv.json()\\n expected = {\\n \\\"message\\\": \\\"The specified task does not exist\\\",\\n \\\"code\\\": \\\"TaskNotFound\\\",\\n }\\n self.assertDictEqual(expected, result)\\n self.assertEqual(rv.status_code, 404)\",\n \"def product_detail(request, pk):\\n try:\\n task = Product.objects.get(pk=pk)\\n except Product.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == 'GET':\\n serializer = ProductSerializer(task)\\n return Response(serializer.data)\\n\\n elif request.method == 'PUT':\\n serializer = ProductSerializer(task, data=request.DATA)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data)\\n else:\\n return Response(\\n serilizer.errors, status=status.HTTP_400_BAD_REQUEST)\\n\\n elif request.method == 'DELETE':\\n task.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def post(self):\\n params = json.loads(self.request.body.decode())\\n gid = params.get('gid')\\n\\n if gid: # apply an action on a specified task\\n action = params.get('action')\\n if action == 'pause':\\n self.write(self._rpc.aria2.pause(self._token, gid))\\n elif action == 'resume':\\n self.write(self._rpc.aria2.unpause(self._token, gid))\\n else: # invalid action\\n self.send_error(400)\\n\\n else: # create a task\\n url = params.get('url')\\n self.write(self._rpc.aria2.addUri(\\n self._token, [url], {'dir': self._download_file_dir}))\",\n \"def edit_task(request):\\n data = {\\\"success\\\": False}\\n try:\\n title = request.POST.get(\\\"title\\\")\\n col = request.POST.get(\\\"col\\\")\\n value = request.POST.get(\\\"value\\\")\\n qs = Todo.objects.get(title=title)\\n res = False\\n if col == \\\"title\\\":\\n res = qs.update_title(title=value, user=request.user)\\n elif col == \\\"description\\\":\\n res = qs.update_description(description=value, user=request.user)\\n elif col == \\\"status\\\":\\n res = qs.update_status(status=value, user=request.user)\\n if res:\\n data[\\\"success\\\"] = True\\n data[\\\"message\\\"] = \\\"%s updated successfully\\\" % col\\n else:\\n data[\\\"message\\\"] = \\\"Failed to update %s\\\" % col\\n except Exception as ex:\\n data[\\\"message\\\"] = \\\"Failed to update %s\\\" % [ex]\\n finally:\\n return JsonResponse(data)\",\n \"def test_create_task(self):\\n response =self.client.post(reverse('todos'),self.data,format=\\\"json\\\")\\n self.assertEqual(201,response.status_code)\",\n \"def task_update_stats(request):\\n tasks = json.loads(request.POST.get('tasks'))\\n date_str = request.POST.get('date')\\n cursor = ndb.Cursor(urlsafe=request.POST.get('cursor'))\\n countdown = 15\\n if not tasks:\\n msg = 'Nothing to execute!?'\\n logging.warning(msg)\\n out = HttpTextResponse(msg)\\n else:\\n # Dispatch the task to execute.\\n task = tasks.pop(0)\\n logging.info('Running %s.', task)\\n if task.count('-') == 2:\\n out, cursor = update_daily_stats(\\n cursor, datetime.datetime.strptime(task, DATE_FORMAT))\\n elif task == 'monthly':\\n # The only reason day is used is in case a task queue spills over the next\\n # day.\\n day = datetime.datetime.strptime(date_str, DATE_FORMAT)\\n out, cursor = update_monthly_stats(cursor, day)\\n elif task == '30':\\n yesterday = (\\n datetime.datetime.strptime(date_str, DATE_FORMAT)\\n - datetime.timedelta(days=1)).date()\\n out, cursor = update_rolling_stats(cursor, yesterday)\\n else:\\n msg = 'Unknown task %s, ignoring.' % task\\n cursor = ''\\n logging.error(msg)\\n out = HttpTextResponse(msg)\\n\\n if cursor:\\n # Not done yet!\\n tasks.insert(0, task)\\n countdown = 0\\n\\n if out.status_code == 200 and tasks:\\n logging.info('%d tasks to go!\\\\n%s', len(tasks), ', '.join(tasks))\\n # Space out the task queue execution by 15s to reduce the risk of\\n # datastore inconsistency to get in the way, since no transaction is used.\\n # This means to process a full month, it'll include 31*15s = 7:45 minutes\\n # delay. 15s is not a lot but we are in an hurry!\\n taskqueue.add(\\n url=reverse(task_update_stats),\\n params={\\n 'tasks': json.dumps(tasks),\\n 'date': date_str,\\n 'cursor': cursor.urlsafe() if cursor else ''},\\n queue_name='update-stats',\\n countdown=countdown)\\n return out\",\n \"def update_task(request):\\n task_id = request.POST.get('task_id', 0)\\n modal_description = request.POST.get('description')\\n modal_due_date = request.POST.get('dueDate')\\n modal_name = request.POST.get('name')\\n modal_priority = request.POST.get('priority')\\n\\n try:\\n search_task = task_models.Task.query.filter(task_models.Task.id == task_id).first()\\n except NoResultFound:\\n return HttpResponse(simplejson.dumps({'success': False}))\\n\\n search_task.update(user=request.user, lastModifiedBy=request.user.id, lastModified=str(datetime.utcnow()),\\n description=modal_description, dueDate=modal_due_date, name=modal_name, priority=modal_priority)\\n\\n return JsonResponse({\\n 'lastModifiedBy': request.user.id,\\n 'lastModified': str(datetime.utcnow())\\n })\",\n \"def test_task_post(self):\\r\\n admin = UserFactory.create()\\r\\n user = UserFactory.create()\\r\\n non_owner = UserFactory.create()\\r\\n app = AppFactory.create(owner=user)\\r\\n data = dict(app_id=app.id, state='0', info='my task data')\\r\\n root_data = dict(app_id=app.id, state='0', info='my root task data')\\r\\n\\r\\n # anonymous user\\r\\n # no api-key\\r\\n res = self.app.post('/api/task', data=json.dumps(data))\\r\\n error_msg = 'Should not be allowed to create'\\r\\n assert_equal(res.status, '401 UNAUTHORIZED', error_msg)\\r\\n\\r\\n ### real user but not allowed as not owner!\\r\\n res = self.app.post('/api/task?api_key=' + non_owner.api_key,\\r\\n data=json.dumps(data))\\r\\n\\r\\n error_msg = 'Should not be able to post tasks for apps of others'\\r\\n assert_equal(res.status, '403 FORBIDDEN', error_msg)\\r\\n\\r\\n # now a real user\\r\\n res = self.app.post('/api/task?api_key=' + user.api_key,\\r\\n data=json.dumps(data))\\r\\n assert res.data, res\\r\\n datajson = json.loads(res.data)\\r\\n out = db.session.query(Task)\\\\\\r\\n .filter_by(id=datajson['id'])\\\\\\r\\n .one()\\r\\n assert out, out\\r\\n assert_equal(out.info, 'my task data'), out\\r\\n assert_equal(out.app_id, app.id)\\r\\n\\r\\n # now the root user\\r\\n res = self.app.post('/api/task?api_key=' + admin.api_key,\\r\\n data=json.dumps(root_data))\\r\\n assert res.data, res\\r\\n datajson = json.loads(res.data)\\r\\n out = db.session.query(Task)\\\\\\r\\n .filter_by(id=datajson['id'])\\\\\\r\\n .one()\\r\\n assert out, out\\r\\n assert_equal(out.info, 'my root task data'), out\\r\\n assert_equal(out.app_id, app.id)\\r\\n\\r\\n # POST with not JSON data\\r\\n url = '/api/task?api_key=%s' % user.api_key\\r\\n res = self.app.post(url, data=data)\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 415, err\\r\\n assert err['status'] == 'failed', err\\r\\n assert err['target'] == 'task', err\\r\\n assert err['action'] == 'POST', err\\r\\n assert err['exception_cls'] == 'ValueError', err\\r\\n\\r\\n # POST with not allowed args\\r\\n res = self.app.post(url + '&foo=bar', data=json.dumps(data))\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 415, err\\r\\n assert err['status'] == 'failed', err\\r\\n assert err['target'] == 'task', err\\r\\n assert err['action'] == 'POST', err\\r\\n assert err['exception_cls'] == 'AttributeError', err\\r\\n\\r\\n # POST with fake data\\r\\n data['wrongfield'] = 13\\r\\n res = self.app.post(url, data=json.dumps(data))\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 415, err\\r\\n assert err['status'] == 'failed', err\\r\\n assert err['target'] == 'task', err\\r\\n assert err['action'] == 'POST', err\\r\\n assert err['exception_cls'] == 'TypeError', err\",\n \"def test_update_task_docs(self, mock_api, mock_custom_objects_api, mock_kube_config):\\n task_id = util.MOCK_UUID_5\\n rv = TEST_CLIENT.patch(\\n f\\\"/tasks/{task_id}\\\",\\n json={\\\"docs\\\": \\\"https://www.google.com.br\\\"},\\n )\\n self.assertEqual(rv.status_code, 200)\",\n \"def get_tasks(self, task_id=None):\\n # Recover all config from OpenVAS\\n if task_id:\\n return self.make_xml_request('<get_tasks id=\\\"%s\\\"/>' % name, xml_result=True)\\n else:\\n return self.make_xml_request(\\\"<get_tasks />\\\", xml_result=True)\",\n \"def test_task(self, mocker):\\n\\n tid = 289466\\n site = \\\"mysite\\\"\\n json = self.generate_task_dictionary(tid, state=\\\"error\\\")\\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, json=json)\\n\\n task = self.client.site(site).task(tid)\\n self.assertEqual(task[\\\"id\\\"], tid)\\n self.assertEqual(task[\\\"state\\\"], \\\"error\\\")\",\n \"def test_anonymous_01_newtask(self):\\r\\n # Del previous TaskRuns\\r\\n self.create()\\r\\n self.del_task_runs()\\r\\n\\r\\n res = self.app.get('api/app/1/newtask')\\r\\n print res.data\\r\\n data = json.loads(res.data)\\r\\n assert data['info'], data\",\n \"def test_get(self):\\n task_types = [1, 2]\\n\\n for task_type in task_types:\\n self.john_gamer.tasks.start(task_type)\\n\\n self.client.force_login(self.john)\\n resp = self.client.get(self.URL)\\n\\n self.assertListEqual(\\n resp.json(),\\n ['Type: 1, time left: 42s', 'Type: 2, time left: 42s'],\\n \\\"Gamer can't get list of task via API!\\\"\\n )\",\n \"def get(self, project_id, task_id):\\n try:\\n task = backend.get(Task, {'project.pk': request.project.pk, 'pk': task_id},\\n only=self.export_fields, include=('project',), raw=True)\\n except Task.DoesNotExist:\\n return {'message': \\\"unknown task\\\"}, 404\\n return {'task': self.export(task)}, 200\",\n \"def create_task(self, unused_parent, task, **kwargs):\\n self.uri = task.get('app_engine_http_request').get('relative_uri')\\n self.body = task.get('app_engine_http_request').get('body')\\n logging.info('Task uri: %r', self.uri)\\n logging.info('Task body: %r', self.body)\\n return 'fake task'\",\n \"def post(self):\\n\\n headers = ''\\n for key, value in self.request.headers.iteritems():\\n headers += '%s: %s' % (key, value)\\n headers += '\\\\r\\\\n'\\n InboundRequest.add_record(datetime.utcnow(), self.request.host_url,\\n self.request.path, headers, self.request.query_string, self.request.body)\\n\\n taskqueue.add(url='/check_wipe_task')\",\n \"def command(task_id, tail, wip, limit):\\n if task_id:\\n task = storage.get_by_id(task_id)\\n\\n if not task:\\n click.echo(f\\\"Task {task_id} not found.\\\")\\n sys.exit(1)\\n\\n tasks = [task]\\n else:\\n tasks = storage.all(limit=limit, reverse=tail, wip=wip)\\n\\n print_header()\\n for task in tasks:\\n show_task(task)\",\n \"def scheduled_tasks(request):\\n\\n # TODO: RYAN, here call schedule 1 (gameboard cleaner), don't forget to import it above\\n # ryan_code.destroy_games()\\n # IF ERROR EXAMPLE:\\n # return Response({'error': 'Did not work because_!'},\\n # status=status.HTTP_500_INTERNAL_SERVER_ERROR)\\n\\n # TODO: RYAN, here call schedule 2 (scores sorter to assign ranking to each user), don't forget to import it above\\n # ryan_code2.set_rankings()\\n\\n # TODO: RYAN, no code here but need to setup the CI on github to have URL to this API call\\n return Response({'Done'})\",\n \"def post(self, *args, **kwargs):\\n # Add some task debug information.\\n headers = []\\n for key, value in self.request.headers.items():\\n k = key.lower()\\n if k.startswith(\\\"x-appengine-\\\") and k not in self._SKIP_HEADERS:\\n headers.append(\\\"%s:%s\\\" % (key, value))\\n logging.debug(\\\", \\\".join(headers))\\n\\n # Make sure all modules are loaded\\n if WARMUP_MODULE:\\n importlib.import_module(WARMUP_MODULE)\\n\\n # Make sure we are called from the Task Queue (security)\\n if isFromTaskQueue(self.request):\\n try:\\n _run(self.request.body)\\n except deferred.SingularTaskFailure as e:\\n msg = \\\"Failure executing task, task retry forced\\\"\\n if e.message:\\n msg += \\\": %s\\\" % e.message\\n logging.debug(msg)\\n self.response.set_status(408)\\n except deferred.PermanentTaskFailure:\\n logging.exception(\\\"Permanent failure attempting to execute task\\\")\\n\\n else:\\n logging.critical('Detected an attempted XSRF attack: we are not executing from a task queue.')\\n self.response.set_status(403)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7414974","0.73624206","0.72924006","0.7080843","0.6978864","0.68153924","0.67486525","0.667285","0.65907764","0.64850056","0.645972","0.6416525","0.6354801","0.6345557","0.62794614","0.6248126","0.62155837","0.61991686","0.61804813","0.61286545","0.6125478","0.60562253","0.60551846","0.60397017","0.60062665","0.6001998","0.599977","0.599745","0.59749603","0.59603924","0.5906325","0.5889295","0.5869331","0.5840461","0.5840117","0.583846","0.5828425","0.5819398","0.5818534","0.58111995","0.57779413","0.57667804","0.57438433","0.57165533","0.57104087","0.570923","0.5702866","0.5691789","0.5683771","0.5675929","0.5671925","0.56715083","0.5667288","0.5666554","0.5664934","0.56627065","0.56522524","0.5635659","0.5626067","0.56143534","0.5609215","0.5607119","0.5593606","0.55919623","0.5590727","0.55832833","0.5581212","0.55810076","0.55805194","0.55750674","0.5570715","0.55462974","0.5545351","0.5545205","0.5540692","0.5514337","0.55130273","0.5507127","0.5499348","0.54928756","0.5480842","0.54643464","0.54627734","0.5459933","0.54526246","0.5444629","0.5443816","0.5442803","0.5440173","0.5439066","0.543424","0.5429114","0.5423765","0.5422422","0.5418763","0.54111946","0.5410409","0.5402576","0.540097","0.5391894","0.5390271"],"string":"[\n \"0.7414974\",\n \"0.73624206\",\n \"0.72924006\",\n \"0.7080843\",\n \"0.6978864\",\n \"0.68153924\",\n \"0.67486525\",\n \"0.667285\",\n \"0.65907764\",\n \"0.64850056\",\n \"0.645972\",\n \"0.6416525\",\n \"0.6354801\",\n \"0.6345557\",\n \"0.62794614\",\n \"0.6248126\",\n \"0.62155837\",\n \"0.61991686\",\n \"0.61804813\",\n \"0.61286545\",\n \"0.6125478\",\n \"0.60562253\",\n \"0.60551846\",\n \"0.60397017\",\n \"0.60062665\",\n \"0.6001998\",\n \"0.599977\",\n \"0.599745\",\n \"0.59749603\",\n \"0.59603924\",\n \"0.5906325\",\n \"0.5889295\",\n \"0.5869331\",\n \"0.5840461\",\n \"0.5840117\",\n \"0.583846\",\n \"0.5828425\",\n \"0.5819398\",\n \"0.5818534\",\n \"0.58111995\",\n \"0.57779413\",\n \"0.57667804\",\n \"0.57438433\",\n \"0.57165533\",\n \"0.57104087\",\n \"0.570923\",\n \"0.5702866\",\n \"0.5691789\",\n \"0.5683771\",\n \"0.5675929\",\n \"0.5671925\",\n \"0.56715083\",\n \"0.5667288\",\n \"0.5666554\",\n \"0.5664934\",\n \"0.56627065\",\n \"0.56522524\",\n \"0.5635659\",\n \"0.5626067\",\n \"0.56143534\",\n \"0.5609215\",\n \"0.5607119\",\n \"0.5593606\",\n \"0.55919623\",\n \"0.5590727\",\n \"0.55832833\",\n \"0.5581212\",\n \"0.55810076\",\n \"0.55805194\",\n \"0.55750674\",\n \"0.5570715\",\n \"0.55462974\",\n \"0.5545351\",\n \"0.5545205\",\n \"0.5540692\",\n \"0.5514337\",\n \"0.55130273\",\n \"0.5507127\",\n \"0.5499348\",\n \"0.54928756\",\n \"0.5480842\",\n \"0.54643464\",\n \"0.54627734\",\n \"0.5459933\",\n \"0.54526246\",\n \"0.5444629\",\n \"0.5443816\",\n \"0.5442803\",\n \"0.5440173\",\n \"0.5439066\",\n \"0.543424\",\n \"0.5429114\",\n \"0.5423765\",\n \"0.5422422\",\n \"0.5418763\",\n \"0.54111946\",\n \"0.5410409\",\n \"0.5402576\",\n \"0.540097\",\n \"0.5391894\",\n \"0.5390271\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6391,"cells":{"query":{"kind":"string","value":"! HTTP route '/api/logs/tasks/' API endpoint for manipulating logs. Allows only GET requests."},"document":{"kind":"string","value":"def kamel_logs():\n task_name = request.args.get('name')\n if task_name is None:\n return response(\"Need to specify task name!\")\n client = create_client()\n stdin, stdout, stderr = client.exec_command(f\"/usr/local/bin/kamel logs {task_name}\") # noqa\n time.sleep(1)\n stdout.channel.close()\n body = stdout.read().decode(\"utf-8\")\n return response(body)"},"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 on_get(self, req, resp):\n try:\n task_model_list = self.state_manager.get_tasks()\n task_list = [x.to_dict() for x in task_model_list]\n resp.text = json.dumps(task_list)\n resp.status = falcon.HTTP_200\n except Exception as ex:\n self.error(\n req.context,\n \"Unknown error: %s\\n%s\" % (str(ex), traceback.format_exc()))\n self.return_error(resp,\n falcon.HTTP_500,\n message=\"Unknown error\",\n retry=False)","def get(self, project_id, task_id):\n\n form = TaskLogForm(request.args)\n\n if not form.validate():\n return {'message' : 'please correct the errors mentioned below.'}, 400\n\n data = form.data\n\n from_chr = data['from_chr']\n\n try:\n task = backend.get(Task, {'project.pk': request.project.pk, 'pk': task_id}, raw=True)\n except Task.DoesNotExist:\n return {'message': \"unknown task\"}, 404\n\n log_path = os.path.join(settings.get('backend.path'),\n settings.get('backend.paths.tasks'),\n \"{}.log\".format(task['pk']))\n\n try:\n with open(log_path, \"r\") as task_log:\n task_log.seek(from_chr)\n content = task_log.read()\n\n data = {\n 'task_log': content,\n 'len': len(content),\n 'from': from_chr,\n 'task_status': task['status'] if 'status' in task else \"unknown\"\n }\n return data, 200\n except IOError:\n return {'message': \"no log found {}\".format(log_path)}, 404","async def log_detail(request, job_id=None, task_name=None, log_id=None):\n jobs = dagobah._serialize().get('jobs', {})\n job = [job for job in jobs if str(job['job_id']) == job_id][0]\n return template('log_detail.html',\n job=job,\n task_name=task_name,\n task=[task for task in job['tasks']\n if task['name'] == task_name][0],\n log_id=log_id)","def handle_task(self, request):\n \"\"\"\n @api {get} /tasks/:id Get a task\n @apiName GetTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Returns the configuration of a task.\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {String} name Name.\n @apiSuccess {String} description Description.\n @apiSuccess {String[]} tags Tags.\n @apiSuccess {Boolean} enabled Task is enabled.\n @apiSuccess {String} mode Task mode (\"any\" or \"all\").\n @apiSuccess {String[]} pools Pools on which the task should run.\n @apiSuccess {Object[]} schedules Schedules at which the task should run.\n @apiSuccess {String} command Command to run.\n @apiSuccess {String} workdir Working directory.\n @apiSuccess {String} user User which the task will be run.\n @apiSuccess {String} group Group which the task will be run.\n @apiSuccess {Object} env Environment variables to set.\n @apiSuccess {String} mailreport If the mailer plugin is enabled, condition to send a report (\"error\", \"stdout\", \"stderr\", \"output\", \"always\").\n @apiSuccess {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\n\n @apiSuccessExample {json} Example response:\n {\n \"name\": \"My task\",\n \"description\": \"Task description\",\n \"tags\": [\"tasg1\", \"tag2\"],\n \"enabled\": true,\n \"mode\": \"all\",\n \"pools\": [\"web\"],\n \"schedules\": [\n {\"minute\": [\"*/1\"]}\n ],\n \"command\": \"/bin/true\",\n \"workdir\": \"/tmp/\",\n \"user\": \"www-data\",\n \"group\": \"www-data\",\n \"env\": {\n \"MYENVVAR\": \"myvalue\"\n },\n \"mailreport\": \"output\",\n \"mailto\": [\"user@domain.org\"]\n }\n \"\"\"\n \"\"\"\n @api {put} /task/:id Update a task\n @apiName PutTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Update a task. Can also be used to create a task with a specific ID.\n\n @apiParam {String} :id Task ID.\n\n @apiParam {String} name Name.\n @apiParam {String} description Description.\n @apiParam {String[]} tags Tags.\n @apiParam {Boolean} enabled Task is enabled.\n @apiParam {String} mode Task mode (\"any\" or \"all\").\n @apiParam {String[]} pools Pools on which the task should run.\n @apiParam {Object[]} schedules Schedules at which the task should run.\n @apiParam {String} command Command to run.\n @apiParam {String} workdir Working directory.\n @apiParam {String} user User which the task will be run.\n @apiParam {String} group Group which the task will be run.\n @apiParam {Object} env Environment variables to set.\n @apiParam {String} mailreport If the mailer plugin is enabled, condition to send a report (\"error\", \"stdout\", \"stderr\", \"output\", \"always\").\n @apiParam {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\n\n @apiParamExample {json} Example parameters:\n {\n \"name\": \"My task\",\n \"description\": \"Task description\",\n \"tags\": [\"tasg1\", \"tag2\"],\n \"enabled\": true,\n \"mode\": \"all\",\n \"pools\": [\"web\"],\n \"schedules\": [\n {\"minute\": [\"*/1\"]}\n ],\n \"command\": \"/bin/true\",\n \"workdir\": \"/tmp/\",\n \"user\": \"www-data\",\n \"group\": \"www-data\",\n \"env\": {\n \"MYENVVAR\": \"myvalue\"\n },\n \"mailreport\": \"output\",\n \"mailto\": [\"user@domain.org\"]\n }\n\n @apiSuccess {Boolean} updated The task has been updated.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"updated\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n \"\"\"\n @api {delete} /task/:id Delete a task\n @apiName DeleteTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Delete a task.\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} deleted The task has been deleted.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"deleted\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n \"\"\"\n @api {execute} /task/:id Execute a task\n @apiName ExecuteTask\n @apiGroup Tasks\n @apiVersion 1.1.0\n\n @apiDescription Execute a task.\n\n @apiParam {String} :id Task ID.\n @apiParam {String} :target Target for task execution (\"local\" to execute on the local node, otherwise execute on the nodes on which the task is configured to run).\n @apiParam {Boolean} :force Force the execution even if the concurrency limit is reached.\n\n @apiSuccess {Boolean} Executed The task has been executed.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"deleted\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n\n match = re.match('/tasks/([0-9a-z]+)', request.uri_path)\n task = match.group(1)\n\n tasks = self.cluster.config.get('tasks')\n\n if request.method == \"GET\":\n if task in tasks:\n return HTTPReply(code = 200, body = json.dumps(tasks[task]), headers = headers)\n else:\n return HTTPReply(code = 404, headers = {'Access-Control-Allow-Origin': '*'})\n\n elif request.method == \"PUT\":\n new = json.loads(request.body)\n if task in tasks:\n old = tasks[task]\n else:\n old = None\n\n tasks[task] = new\n self.cluster.config.set('tasks', tasks)\n\n if old:\n code = 200\n body = json.dumps({\"id\": task, \"updated\": True})\n get_plugin_registry().call_hook('TaskUpdated', task, old, new)\n else:\n code = 201\n body = json.dumps({\"id\": task, \"created\": True})\n get_plugin_registry().call_hook('TaskCreated', task, new)\n\n return HTTPReply(code = code, body = body, headers = headers)\n\n elif request.method == \"DELETE\":\n if task in tasks:\n old = tasks[task]\n del tasks[task]\n self.cluster.config.set('tasks', tasks)\n\n get_plugin_registry().call_hook('TaskDeleted', task, old)\n\n return HTTPReply(code = 200, body = json.dumps({\"id\": task, \"deleted\": True}), headers = headers)\n else:\n return HTTPReply(code = 404, headers = {'Access-Control-Allow-Origin': '*'})\n\n if request.method == \"EXECUTE\":\n try:\n if 'target' in request.args and request.args['target'] == 'local':\n self.manager.execute_task(task)\n else:\n self.cluster.scheduler.run_task(task, ignore_concurrency = 'force' in request.args)\n\n return HTTPReply(code = 200, body = json.dumps({\"id\": task, \"executed\": True}), headers = headers)\n except ExecutionDisabled:\n return HTTPReply(code = 503, body = json.dumps({\"id\": task, \"executed\": False}), headers = headers)","def handle_tasks(self, request):\n \"\"\"\n @api {get} /tasks List tasks\n @apiName GetTasks\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Return a list of all configured tasks, along with their configuration.\n\n @apiSuccessExample {json} Example response:\n {\n \"021b2092ef4111e481a852540064e600\": {\n \"name\": \"task 1\",\n \"enabled\": true,\n \"mode\": \"all\",\n \"pools\": [\"web\"],\n \"schedules\": [\n {\"minute\": [\"*/5\"]}\n ],\n \"command\": \"/bin/task1\",\n },\n \"508b4b72e44611e49e76c81f66cd0cca\": {\n \"name\": \"task 2\",\n \"enabled\": false,\n \"mode\": \"all\",\n \"pools\": [\"pool2\"],\n \"schedules\": [\n {\"hours\": [15], \"minutes\": [0]}\n ],\n \"command\": \"/bin/task2\",\n }\n }\n \"\"\"\n \"\"\"\n @api {post} /tasks Create a new task\n @apiName PostTasks\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Add a new task, providing its configuration.\n\n @apiParam {String} name Name.\n @apiParam {String} description Description.\n @apiParam {String[]} tags Tags.\n @apiParam {Boolean} enabled Task is enabled.\n @apiParam {String} mode Task mode (\"any\" or \"all\").\n @apiParam {String[]} pools Pools on which the task should run.\n @apiParam {Object[]} schedules Schedules at which the task should run.\n @apiParam {String} command Command to run.\n @apiParam {String} workdir Working directory.\n @apiParam {String} user User which the task will be run.\n @apiParam {String} group Group which the task will be run.\n @apiParam {Object} env Environment variables to set.\n @apiParam {String} mailreport If the mailer plugin is enabled, condition to send a report (\"error\", \"stdout\", \"stderr\", \"output\", \"always\").\n @apiParam {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\n\n @apiParamExample {json} Example parameters:\n {\n \"name\": \"My task\",\n \"description\": \"Task description\",\n \"tags\": [\"tasg1\", \"tag2\"],\n \"enabled\": true,\n \"mode\": \"all\",\n \"pools\": [\"web\"],\n \"schedules\": [\n {\"minute\": [\"*/1\"]}\n ],\n \"command\": \"/bin/true\",\n \"workdir\": \"/tmp/\",\n \"user\": \"www-data\",\n \"group\": \"www-data\",\n \"env\": {\n \"MYENVVAR\": \"myvalue\"\n },\n \"mailreport\": \"output\",\n \"mailto\": [\"user@domain.org\"]\n }\n\n @apiSuccess {Boolean} created The task has been created.\n @apiSuccess {String} id ID of the newly created task.\n\n @apiSuccessExample {json} Example response:\n {\n \"created\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n \"\"\"\n @api {delete} /tasks Delete all tasks\n @apiName DeleteTasks\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Delete all tasks. Use with caution.\n\n @apiSuccess {Boolean} deleted The tasks have been deleted.\n\n @apiSuccessExample {json} Example response:\n {\n \"deleted\": true\n }\n \"\"\"\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n\n if request.method == \"GET\":\n tasks = self.cluster.config.get('tasks')\n\n if 'tag' in request.args and request.args['tag']:\n tasks = dict( (taskid, task) for taskid, task in tasks.items() if 'tags' in task and request.args['tag'] in task['tags'] )\n\n return HTTPReply(code = 200, body = json.dumps(tasks), headers = headers)\n\n elif request.method == \"DELETE\":\n oldtasks = self.cluster.config.get('tasks')\n self.cluster.config.set('tasks', {})\n\n for (task, taskconfig) in oldtasks.items():\n get_plugin_registry().call_hook('TaskDeleted', task, taskconfig)\n\n return HTTPReply(code = 200, body = json.dumps({\"deleted\": True}), headers = headers)\n\n elif request.method == \"POST\":\n task = uuid.uuid1().hex\n tasks = self.cluster.config.get('tasks')\n tasks[task] = json.loads(request.body)\n self.cluster.config.set('tasks', tasks)\n\n get_plugin_registry().call_hook('TaskCreated', task, tasks[task])\n\n return HTTPReply(code = 201, body = json.dumps({\"id\": task, \"created\": True}), headers = headers)","def _app(ctx, logfile, verbose):\n log_levels = {\n 0: logging.WARNING,\n 1: logging.INFO,\n 2: logging.DEBUG,\n }\n loglevel = log_levels.get(verbose, logging.DEBUG)\n # TODO more flexible logging config\n logging.basicConfig(format='%(name)s: %(levelname)s: %(message)s',\n level=loglevel, filename=logfile)\n\n tasks = ctx.obj['tasks']\n tasks.context = ctx","def log_request(task_request, request):\n msg = \"{0.method} {0.url}: {0.body}\".format(request)\n log_info(task_request, msg)","def task_action_router(request, section_id, task_id):\n\n if request.method == 'PUT':\n return update_task(request, task_id)\n elif request.method == 'DELETE':\n return delete_task(request, task_id)\n else:\n return HttpResponseNotAllowed('Method not allowed')","def on_get(self, req, resp, task_id):\n task_result = AsyncResult(task_id)\n result = {'status': task_result.status, 'result': task_result.result}\n resp.status = falcon.HTTP_200\n resp.body = json.dumps(result)","def api_list_logs():\n if 'POST' == request.method:\n per_page = get_safe_int(request.form.get('per_page'))\n page_num = get_safe_int(request.form.get('page_num'))\n else:\n per_page = get_safe_int(request.args.get('per_page'))\n page_num = get_safe_int(request.args.get('page_num'))\n\n \"\"\"\n pagination = LogEntity.query.paginate(page_num, per_page, False)\n items = [i.serialize() for i in pagination.items]\n app.logger.debug(\"per_page: {}, page_num: {}\".format(per_page, page_num))\n return jsonify_success(dict(total_pages=pagination.pages,\n list_of_events=items))\n \"\"\"\n logs, total_pages = log_manager.get_logs(per_page, page_num)\n # logs_list = [x.to_visible() for x in logs]\n return jsonify_success(dict(list_of_events=logs, total_pages=total_pages))","def on_get(self, req, resp, task_id):\n task = celery_app.AsyncResult(task_id)\n\n resp.body = json.dumps(\n {'status': task.status, 'result': str(task.result)})\n resp.status = falcon.HTTP_200","def system_ajax(request):\n type = request.GET.get('api', None)\n task_limit = getattr(settings, 'CELERYMON_TASK_LIMIT', 12)\n celery_monitoring = getattr(settings, 'CELERY_FLOWER_URL', None)\n if type == \"_active_tasks\":\n server = Server(settings.COUCH_DATABASE)\n try:\n tasks = [x for x in server.active_tasks() if x['type'] == \"indexer\"]\n except HTTPError as e:\n if e.response.status_code == 403:\n return JsonResponse({'error': \"Unable to access CouchDB Tasks (unauthorized).\"}, status=500)\n else:\n return JsonResponse({'error': \"Unable to access CouchDB Tasks.\"}, status=500)\n\n if not is_bigcouch():\n return JsonResponse(tasks, safe=False)\n else:\n # group tasks by design doc\n task_map = defaultdict(dict)\n for task in tasks:\n meta = task_map[task['design_document']]\n tasks = meta.get('tasks', [])\n tasks.append(task)\n meta['tasks'] = tasks\n\n design_docs = []\n for dd, meta in task_map.items():\n meta['design_document'] = dd[len('_design/'):]\n total_changes = sum(task['total_changes'] for task in meta['tasks'])\n for task in meta['tasks']:\n task['progress_contribution'] = task['changes_done'] * 100 // total_changes\n\n design_docs.append(meta)\n return JsonResponse(design_docs, safe=False)\n elif type == \"_stats\":\n return JsonResponse({})\n elif type == \"_logs\":\n pass\n elif type == 'pillowtop':\n pillow_meta = get_all_pillows_json()\n return JsonResponse(sorted(pillow_meta, key=lambda m: m['name'].lower()), safe=False)\n\n if celery_monitoring:\n if type == \"flower_poll\":\n ret = []\n try:\n all_tasks = requests.get(\n celery_monitoring + '/api/tasks',\n params={'limit': task_limit},\n timeout=3,\n ).json()\n except Exception as ex:\n return JsonResponse({'error': \"Error with getting from celery_flower: %s\" % ex}, status=500)\n\n for task_id, traw in all_tasks.items():\n # it's an array of arrays - looping through [<id>, {task_info_dict}]\n if 'name' in traw and traw['name']:\n traw['name'] = '.'.join(traw['name'].split('.')[-2:])\n else:\n traw['name'] = None\n ret.append(traw)\n ret = sorted(ret, key=lambda x: x['succeeded'], reverse=True)\n return HttpResponse(json.dumps(ret), content_type='application/json')\n return HttpResponse('{}', content_type='application/json')","def task1():\n logger.info(\"In API3 task1 function\")\n return \"task1 success!\"","def tasks_rpc():\n # First check that this is a legitimate request from the coordinator\n authenticate_coordinator()\n action, task_id, release_id = validate_action(request.get_json(force=True))\n # Call into action\n return ROUTES[action](task_id, release_id)","def logs(self, task: RemoteTask) -> Iterable[str]:\n raise NotImplementedError()","def run_tasks(request):\r\n import os\r\n if not os.environ['SERVER_SOFTWARE'].startswith('Development'):\r\n logging.error(\"This URL is only valid in a development environment.\")\r\n raise Http404\r\n else:\r\n from datetime import datetime\r\n from google.appengine.api import apiproxy_stub_map\r\n stub = apiproxy_stub_map.apiproxy.GetStub('taskqueue')\r\n \r\n #get all the tasks for all the queues\r\n tasks = []\r\n for queue in stub.GetQueues():\r\n tasks.extend( stub.GetTasks(queue['name']) )\r\n \r\n #keep only tasks that need to be executed\r\n now = datetime.now()\r\n fn = lambda t: datetime.strptime(t['eta'],'%Y/%m/%d %H:%M:%S') < now\r\n tasks = filter(fn, tasks)\r\n\r\n from django.utils import simplejson as json\r\n result = '\\n'.join([json.dumps(t) for t in tasks])\r\n \r\n #remove tasks from queues\r\n for queue in stub.GetQueues():\r\n stub.FlushQueue(queue['name'])\r\n \r\n return HttpResponse(result)","def ocsaudit_rest_log_command(method, url, url_args, username):\n \n try:\n if method == \"GET\":\n type = cmd_type.type_get\n elif method == \"POST\":\n type = cmd_type.type_post\n elif method == \"PATCH\":\n type = cmd_type.type_patch\n elif method == \"DELETE\":\n type = cmd_type.type_delete\n else:\n type = cmd_type.type_unknown\n print \"Unidentified command type {0}\".format(method)\n \n url = url.split(\"/v1/\",1)[1]\n args = \" \".join(url_args)\n \n ocsaudit_log_command(username, type, cmd_interface.interface_rest, \n url, args)\n except Exception as e:\n print \"ocsaudit_rest_log_command Exception {0}\".format(e)","def GetLogs(self):\n raise NotImplementedError()","def task_element(request, task_id):\n try:\n task = Task.objects.get(id=task_id)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == \"GET\":\n serializer = TaskSerializer(task)\n return Response(serializer.data)\n\n elif request.method == \"PUT\":\n data = json.loads(request.body)\n\n status = data.get(\"status\", \"\")\n task.status = status\n\n try:\n assignee = User.objects.get(username=data.get(\"assignee\", \"\"))\n task.assignee = assignee\n except:\n pass\n \n task.save()\n return JsonResponse({\"message\": \"Task updated successfully\"}, status=204)\n\n elif request.method == \"DELETE\":\n task.delete()\n return Response(status=status.HTTP_204_NO_CONTENT)","def log_api():\n try:\n redis.zincrby(REDIS_LOG_KEY_NAME, 1, request.path)\n except RedisError as exc:\n return exc","def log_route():\n return send_file(path.join('..', 'app.log'), as_attachment=True)","def task_detail(request, pk):\n try:\n task = Task.objects.get(pk=pk)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == 'GET':\n serializer = TaskSerializer(task)\n return Response(serializer.data)\n\n elif request.method == 'PUT':\n serializer = TaskSerializer(task, data=request.DATA)\n if serializer.is_valid():\n serializer.save()\n # returning the serializer data after saving it to the database\n return Response(serializer.data)\n\n else:\n # there were some validation errors with the data\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\n\n elif request.method == 'DELETE':\n # recall we already have the task present\n task.delete()\n return Response(status=status.HTTP_204_NO_CONTENT)","def handle_task_processes(self, request):\n \"\"\"\n @api {get} /task/:id/processes List running processes for a task\n @apiName ListTaskProcesses\n @apiGroup Tasks\n @apiVersion 1.1.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccessExample {json} Example response:\n {\n \"021b2092ef4111e481a852540064e600\" : {\n \"node\": \"node1\",\n \"start_time\": \"2018-03-29T15:01:13.465183+00:00\",\n \"task\": \"e4d07482e44711e49e76c81f66cd0cca\"\n },\n \"253a96e29868135d746989a6123f521e\" : {\n \"node\": \"node2\",\n \"start_time\": \"2018-03-29T14:01:13.352067+00:00\",\n \"task\": \"508b4b72e44611e49e76c81f66cd0cca\"\n },\n ...\n }\n \"\"\"\n\n match = re.match('/tasks/([0-9a-z]+)/processes', request.uri_path)\n task = match.group(1)\n\n processes = self.cluster.list_task_processes(task)\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n body = json.dumps(processes)\n\n return HTTPReply(code = 200, body = body, headers = headers)","def taskList(request):\n try:\n # if request.user.username == \"root\":\n # pass\n\n title = request.data.get(\"title\", None)\n desc = request.data.get(\"desc\", None)\n stat = request.data.get(\"status\", None)\n taskDueDate = request.data.get(\"taskDueDate\", None)\n sortby = request.data.get(\"sortby\", None)\n qs = Task.objects.filter(userID=request.user)\n if sortby:\n qs = qs.order_by(sortby)\n\n if title:\n qs = qs.filter(Q(title__exact=title))\n\n if desc:\n qs = qs.filter(Q(desc__exact=desc))\n\n if stat:\n qs = qs.filter(Q(status__exact=stat))\n\n if taskDueDate:\n qs = qs.filter(Q(taskDueDate__exact=taskDueDate))\n\n serializer = TaskSerializer(qs, many=True)\n if len(serializer.data) != 0:\n for i in range(len(serializer.data)):\n serializer.data[i]['userID'] = request.user.username\n\n return Response(serializer.data, status=status.HTTP_200_OK)\n\n\n except Exception as e:\n return Response(e.args[0], status.HTTP_400_BAD_REQUEST)","def task_list(request):\n if request.method == \"GET\":\n tasks = Task.objects.all()\n\n # tasks here is a query set. So we are essentially passing the entire query set into the serializer\n # the many=True attribute here is super important. Without this attribute an error would be raised\n\n serializer = TaskSerializer(tasks, many=True)\n return Response(serializer.data)\n\n elif request.method == \"POST\":\n serializer = TaskSerializer(data=request.DATA)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data, status=status.HTTP_201_CREATED)\n\n else:\n # there is a validation error and hence there is a problem with the data in the request\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def view_task(self, task_id):\n api_url = self.server_url + self.METHOD_VIEW_TASK + str(task_id)\n\n request = Request(api_url)\n\n log.info(\"Request to \" + api_url)\n try:\n response = request.get()\n except HTTPError, e:\n log.error(\"Error in view_task: \" + str(e))\n raise CuckooError(str(e))\n except ConnectionError, e:\n log.error(\"Error in view_task: \" + str(e))\n raise CuckooError(str(e))\n\n log.info(\"Response: \" + str(response))\n\n return response","def log_request_response(task_request, response):\n log_request(task_request, response.request)\n log_response(task_request, response)","def list(ctx, id, json):\n\n kargs={'host': c.cfg['host'], \"api_version\": c.cfg['api_version'], \"url_path\": \"/tasks\"}\n if id != None:\n return ctx.invoke(show, id=id, json=json)\n\n task = estask.Task(kargs)\n try:\n dict_resp= task.list()\n except Exception as e:\n sys.exit(\"Fail: %s\" %str(e))\n\n if dict_resp == None:\n click.echo(\"Fail: error response\")\n sys.exit(1)\n\n if json:\n print(jsn.dumps(dict_resp, sort_keys=True, indent=4))\n return\n try:\n task.print_list(dict_resp)\n except Exception as e:\n sys.exit(\"Fail: %s\" %str(e))","def status():\n _request('worklog/status/')","def tasks_collection(request):\n if request.method == \"GET\":\n tasks = Task.objects.all().order_by(\"-timestamp\")\n serializer = TaskSerializer(tasks, many=True)\n return Response(serializer.data)\n\n elif request.method == \"POST\":\n data = json.loads(request.body)\n title = data.get(\"title\", \"\")\n description = data.get(\"description\", \"\")\n category = data.get(\"category\", \"\")\n budget = data.get(\"budget\", \"\")\n poster = User.objects.get(username=data.get(\"poster\", \"\"))\n due_date = parser.parse(data.get(\"dueDate\", \"\"))\n\n task = Task(\n title=title,\n description=description,\n poster=poster,\n due_date=due_date,\n budget=budget,\n category=category\n )\n task.save()\n return JsonResponse({\"message\": \"Task created successfully\"}, status=201)","def dinghy_get_pod_logs(req, resp):\n resp.content = api.template(\n 'pod_logs.html'\n )","def get_log(request, **kwargs):\n\n #Creating the command for the logs \n try:\n\tprint(kwargs)\n\tprint(request.GET['project_id'])\n\toutputStr = sidecar.events.test_logs(project_id=request.GET['project_id'])\n\tlog_data = outputStr.log_data\n\toutputStr = \" <br>\".join(log_data.split(\"\\n\"))\n except Exception, e:\n outputStr = \"Updating the logs...\"\t\n #Making the output\n context = {\n \"page_title\": _(\"Test Details\"),\n \"test_lists\": 'report_list', #tests_list\n \"log_data\": outputStr\n }\n return render(request, 'rally_dashboard/events/test_logs.html', context)","def task_offers_collection(request, task_id):\n try:\n task = Task.objects.get(id=task_id)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == \"GET\":\n offers = Offer.objects.filter(task=task).all().order_by(\"-timestamp\")\n serializer = OfferSerializer(offers, many=True)\n return Response(serializer.data)","def log_response(task_request, response):\n msg = \"{0.status_code} {0.reason} for {0.url}: {0.content}\".format(response)\n log_info(task_request, msg)","def list_all_tasks(var):\n init_dao(client_id, client_secret, tenant_id, refresh_token) \n \n if var.lower() == \"tasks\":\n app.logger.info(f'Requesting {var} from the graph API')\n return Response(stream_as_json(get_tasks(get_plans(get_all_objects('/groups/')))), content_type='application/json')\n elif var.lower() == \"plans\":\n app.logger.info(f'Requesting {var} from the graph API')\n return Response(stream_as_json(get_plans(get_all_objects('/groups/'))), request.args.get('since'), content_type='application/json')\n elif var.lower() == \"conversations\":\n app.logger.info(f'Requesting {var} from the graph API')\n return Response(stream_as_json(get_conversations(get_all_objects('/groups/'))), request.args.get('since'), content_type='application/json')\n elif var.lower() == \"threads\":\n app.logger.info(f'Requesting {var} from the graph API')\n return Response(stream_as_json(get_threads(get_conversations(get_all_objects('/groups/')))), request.args.get('since'),\n content_type='application/json')\n elif var.lower() == \"posts\":\n app.logger.info(f'Requesting {var} from the graph API')\n return Response(stream_as_json(get_posts(get_threads(get_conversations(get_all_objects('/groups/'))))),\n request.args.get('since'),\n content_type='application/json')\n elif var.lower() == \"groups\":\n app.logger.info(f'Requesting {var} from the graph API')\n return Response(get_all_groups(request.args.get('since')), content_type='application/json')\n elif var.lower() == \"users\":\n app.logger.info(f'Requesting {var} from the graph API')\n return Response(get_all_users(request.args.get('since')), content_type='application/json')\n elif var.lower() == \"create_tasks\":\n app.logger.info(f'Requesting {var} from the graph API')\n request_data = request.get_data()\n return create_tasks(json.loads(str(request_data.decode(\"utf-8\"))))\n elif var.lower() == \"update_tasks\":\n app.logger.info(f'Requesting {var} from the graph API')\n request_data = request.get_data()\n return update_tasks(json.loads(str(request_data.decode(\"utf-8\"))))\n elif var.lower() == \"create_buckets\":\n app.logger.info(f'Requesting {var} from the graph API')\n elif var.lower() == \"create_plans\":\n request_data = request.get_data()\n return create_plans(json.loads(str(request_data.decode(\"utf-8\"))))\n else:\n app.logger.warning(f'The following request value : {var} \\n - does not comply with what is currently configured backend')\n return Response(json.dumps({\"You need to choose a configured <value> in the path '/planner/<value>'\" : \"I.e. : 'tasks', 'plans', 'groups' or 'users'\"}), content_type='application/json')","def task2():\n logger.info(\"In API3 task2 function\")\n return \"task2 success!\"","def task_log(self, task_id, subtask=None, workunit_id=None):\n\n if subtask:\n dir, logfile = task_log_path(task_id, subtask, workunit_id)\n else:\n dir, logfile = task_log_path(task_id)\n\n fp = open(logfile, 'r')\n log = fp.read()\n fp.close()\n return log","def _log(log_fn, task_request, message):\n log_fn(\"{}: {}\".format(task_request.id, message))","def on_get(self, req, resp, task_id):\n try:\n builddata = req.get_param_as_bool('builddata')\n subtask_errors = req.get_param_as_bool('subtaskerrors')\n try:\n layers = int(req.params.get('layers', '0'))\n except Exception:\n layers = 0\n\n first_task = self.get_task(req, resp, task_id, builddata)\n\n if first_task is None:\n self.info(req.context, \"Task %s does not exist\" % task_id)\n self.return_error(resp,\n falcon.HTTP_404,\n message=\"Task %s does not exist\" % task_id,\n retry=False)\n else:\n # If layers is passed in then it returns a dict of tasks instead of the task dict.\n if layers:\n resp_data, errors = self.handle_layers(\n req, resp, task_id, builddata, subtask_errors, layers,\n first_task)\n # Includes subtask_errors if the query param 'subtaskerrors' is passed in as true.\n if (subtask_errors):\n resp_data['subtask_errors'] = errors\n else:\n resp_data = first_task\n # Includes subtask_errors if the query param 'subtaskerrors' is passed in as true.\n if (subtask_errors):\n _, errors = self.handle_layers(req, resp, task_id,\n False, subtask_errors,\n 1, first_task)\n resp_data['subtask_errors'] = errors\n\n resp.text = json.dumps(resp_data)\n resp.status = falcon.HTTP_200\n except Exception as ex:\n self.error(req.context, \"Unknown error: %s\" % (str(ex)))\n self.return_error(resp,\n falcon.HTTP_500,\n message=\"Unknown error\",\n retry=False)","def api_record(path):\n exception = log_api()\n if exception:\n return jsonify({'error': exception}), HTTPStatus.INTERNAL_SERVER_ERROR\n return '', HTTPStatus.OK","def start_task_manager(params):\n logname = \"%s.task\" % params['api_id']\n frmt = u'[%(asctime)s: %(levelname)s/%(processName)s] ' \\\n u'%(name)s:%(funcName)s:%(lineno)d - %(message)s'\n \n frmt = u'[%(asctime)s: %(levelname)s/%(task_name)s:%(task_id)s] '\\\n u'%(name)s:%(funcName)s:%(lineno)d - %(message)s' \n \n log_path = u'/var/log/%s/%s' % (params[u'api_package'], \n params[u'api_env'])\n run_path = u'/var/run/%s/%s' % (params[u'api_package'], \n params[u'api_env']) \n \n #loggers = [logging.getLogger('beehive.common.event')]\n #LoggerHelper.rotatingfile_handler(loggers, logger_level, \n # '%s/%s.event.log' % (log_path, logname),\n # frmt=frmt) \n \n # base logging\n loggers = [\n logging.getLogger(u'beehive'),\n logging.getLogger(u'beehive.db'),\n logging.getLogger(u'beecell'),\n logging.getLogger(u'beedrones'),\n logging.getLogger(u'celery'),\n logging.getLogger(u'proxmoxer'),\n logging.getLogger(u'requests')]\n LoggerHelper.rotatingfile_handler(loggers, logger_level, \n u'%s/%s.log' % (log_path, logname),\n frmt=frmt, formatter=ExtTaskFormatter)\n\n # transaction and db logging\n loggers = [\n logging.getLogger('beehive.util.data'),\n logging.getLogger('sqlalchemy.engine'),\n logging.getLogger('sqlalchemy.pool')]\n LoggerHelper.rotatingfile_handler(loggers, logger_level, \n '%s/%s.db.log' % (log_path, logname))\n \n # performance logging\n loggers = [\n logging.getLogger('beecell.perf')]\n LoggerHelper.rotatingfile_handler(loggers, logger_level, \n '%s/%s.watch' % (log_path, params[u'api_id']), \n frmt='%(asctime)s - %(message)s')\n\n api_manager = ApiManager(params, hostname=gethostname())\n api_manager.configure()\n api_manager.register_modules()\n #worker = ProcessEventConsumerRedis(api_manager)\n #from beehive.module.tasks import task_manager\n task_manager.api_manager = api_manager\n\n logger_file = '%s/%s.log' % (log_path, logname)\n\n configure_task_manager(params['broker_url'], params['result_backend'],\n tasks=params['task_module'], expire=params['expire'],\n logger_file=logger_file)\n \n argv = [u'',\n u'--loglevel=%s' % logging.getLevelName(logger_level),\n #u'--pool=prefork',\n u'--pool=gevent',\n u'--purge',\n #'--time-limit=600',\n #'--soft-time-limit=300',\n u'--concurrency=100',\n u'--maxtasksperchild=100',\n #u'--autoscale=100,10',\n u'--logfile=%s' % logger_file,\n u'--pidfile=%s/%s.task.pid' % (run_path, logname)]\n \n def terminate(*args):\n #run_command(['celery', 'multi', 'stopwait', 'worker1', \n # '--pidfile=\"run/celery-%n.pid\"'])\n task_manager.stop()\n \n #for sig in (SIGHUP, SIGABRT, SIGILL, SIGINT, SIGSEGV, SIGTERM, SIGQUIT):\n # signal(sig, terminate)\n \n task_manager.worker_main(argv)","def task(ctx, config):\n log.info('{config}'.format(config=config))","def view(self, _type, task_id):\n try:\n return self._super.do(**{\n \"method\": \"GET\",\n \"url\": \"{}/tasks/report/{}\".format(self.baseurl, task_id)\n })\n except AnalyserUpstreamError as e:\n if \"404\" in str(e.code):\n return None","def get(self):\n url = \"http://twitter.com/statuses/public_timeline.json\"\n task = taskqueue.Task(\n url='/tasks/fetch',\n params={'url': url}\n )\n task.add('fetch')","def log_schedule(self):\n self.logger.log_schedule(self.params.schedule)","def getLog(request):\n # TODO: GET\n data = {}\n return data","def task_logger(self, handler: Handler, msg: str) -> None:\n handler(\"HacsTask<%s> %s\", self.slug, msg)","def rest_api_log(self):\n with self.resource_lock:\n pass","def get_tasks(id):\n url = 'https://jsonplaceholder.typicode.com/'\n tasks = requests.get(url + 'todos', params={'userId': id}).json()\n return tasks","def getLogs():","def getLogs():","def getNodeTaskLogByUPID(self,node,upid):\n data = self.connect('get','nodes/%s/tasks/%s/log' % (node,upid),None)\n return data","def get_tasks(data: dict) -> dict:\n status_code = http.HTTPStatus.OK\n body = {\"filters\": data}\n try:\n tasks = actions.get_tasks(data)\n body[\"tasks\"] = [task.to_dict() for task in tasks]\n except tskexc.TaskHTTPException as e:\n body = {\"error\": e.message}\n status_code = e.http_status\n return {\"statusCode\": status_code, \"body\": json.dumps(body)}","def upload_logs():\n return {\n 'page': 'upload_logs',\n 'raw_logs': '',\n }","def get(self, request):\n feedback = {\n 'permission': True\n }\n\n try:\n task_id = request.GET.get('task_id', None)\n if task_id is None:\n feedback['data'] = ErrorCode.parameter_missing('task_id')\n raise natrix_exception.ParameterMissingException(parameter='task_id')\n try:\n uuid.UUID(hex=task_id)\n except ValueError:\n feedback['data'] = ErrorCode.parameter_invalid('task_id', reason=u'must be a UUID')\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\n try:\n task = Task.objects.get(id=task_id, time_type='instant')\n # response_count = success + wrong\n res = command_dispatcher.get_task_data(task.id)\n success = len(res.get('success'))\n wrong = len(res.get('error'))\n response_count = success + wrong\n\n time_delta = timezone.now() - task.create_time\n\n if task.status and ( response_count == task.terminal_count or time_delta.seconds > 120):\n task.status = False\n task.result_snapshot = json.dumps(res)\n task.save()\n\n feedback['data'] = {\n 'code': 200,\n 'message': 'Instant Task Status',\n 'info': {\n 'finished': not task.status,\n 'total': task.terminal_count,\n 'responses': response_count,\n 'success': success,\n 'wrong': wrong\n }\n }\n\n except Task.DoesNotExist:\n feedback['data'] = ErrorCode.parameter_invalid(\n 'task_id', reason=u'Can not retrieve Instant Task: {}'.format(task_id))\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\n\n except natrix_exception.NatrixBaseException as e:\n logger.error(e.get_log())\n\n return JsonResponse(data=feedback)","def list(self, _request):\n serializer = TaskSerializer(instance=TASKS.values(), many=True)\n return response.Response(serializer.data)","def get(self, dnzo_user, task_list):\n self.json_response(task_list=task_list.to_dict())","def handle_task_enable(self, request):\n \"\"\"\n @api {post} /task/:id/enable Enable a task\n @apiName EnableTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} updated The task has been updated.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"updated\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n \"\"\"\n @api {post} /task/:id/disable Disable a task\n @apiName DisableTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} updated The task has been updated.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"updated\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n\n match = re.match('/tasks/([0-9a-z]+)/(en|dis)able', request.uri_path)\n task = match.group(1)\n action = match.group(2)\n\n enabled = (action == 'en')\n\n tasks = self.cluster.config.get('tasks')\n\n if task in tasks:\n code = 200\n\n old = tasks[task].copy()\n tasks[task]['enabled'] = enabled\n self.cluster.config.set('tasks', tasks)\n\n get_plugin_registry().call_hook('TaskUpdated', task, old, tasks[task])\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n body = json.dumps({\"id\": task, \"updated\": True})\n\n return HTTPReply(code = code, body = body, headers = headers)\n else:\n headers = {\n 'Access-Control-Allow-Origin': '*'\n }\n return HTTPReply(code = 404, headers = headers)","def get_formatted_task_log(self):\n try:\n log = requests.get(self.gs_base_url + \"/out.log\").content\n except:\n return [f\"####-##-## ##:##:## Task ID: {self.name}\\n\"]\n return (f\"####-##-## ##:##:## Task ID: {self.name}\\n\" + log.decode('utf-8')).splitlines()","def api():\n query = dict(request.args)\n socket_io.emit('log', dict(data=str(query)), broadcast=True)\n return jsonify(dict(success=True, message='Received'))","def log(request, tag=''):\n tvents = Tvent.objects\n if tag:\n if tag.startswith(\"~\"):\n tvents = tvents.filter(user=tag[1:])\n elif tag.startswith(\"@\"):\n tvents = tvents.filter(target=tag[1:])\n else:\n # TODO: other log types?\n pass\n try:\n until = to_datetime(request.GET['until'])\n tvents = tvents.filter(datetime__lte=until)\n except (KeyError, ValueError):\n until = ''\n\n tvents = tvents.order_by('-datetime')\n tvents.select_related('target')\n # output = '\\n\\n'.join([tv.uniqey + '\\n'.join([str(s) for s in tv.tags]) for tv in tvents])\n return render_to_response('log.html',{'tvents':tvents, 'until':until, 'tag':tag})","def log(msg):\n\tfrom http_request import req\n\tif not req: return\n\t\t\n\tif not req.out.get('_log'):\n\t\treq.out['_log'] = []\n\treq.out['_log'].append(msg)","def user_tasks(request, user_id):\n if request.method == 'GET':\n records = HmmerQueryRecord.objects.filter(user__id=user_id, result_date__gt=(localtime(now())+ timedelta(days=-7)))\n serializer = UserHmmerQueryRecordSerializer(records, many=True)\n return JSONResponse(serializer.data)","def admin_applog(request):\r\n rdict = request.GET\r\n\r\n # Support optional filter parameters\r\n days = int(rdict.get('days', 1))\r\n status = rdict.get('status', None)\r\n message = rdict.get('message', None)\r\n\r\n log_list = AppLogMgr.find(\r\n days=days,\r\n message_filter=message,\r\n status=status,\r\n )\r\n\r\n ret = {\r\n 'count': len(log_list),\r\n 'logs': [dict(l) for l in log_list],\r\n }\r\n return _api_response(request, ret)","def get_current_user_tasks_route():\n user = current_user\n\n if user.get_id() is not None:\n return get_user_jobs_route(user.id)\n else:\n response_object = {'status': 'error'}\n return jsonify(response_object)","def test_get_event_logs(event_log_api_setup):\n api_response = event_log_api_setup.get_event_logs(limit=100, offset=0)\n logging.getLogger().info(\"%s\", api_response)\n print(f\"{BCOLORS.OKGREEN}OK{BCOLORS.ENDC}\")","def task_records_to_log(self, records: List[Any]) -> None:\n for r in records:\n self._logger.info(\n \"[%s]: %s - %s - %s/%s\",\n r[\"createdDateTime\"],\n r[\"userPrincipalName\"],\n r[\"ipAddress\"],\n r[\"location\"][\"countryOrRegion\"],\n r[\"location\"][\"city\"],\n )","def running_celery_tasks(request):\n active_dict = CELERY_INSPECT.active()\n active_tasks = []\n if active_dict:\n for task_list in active_dict.values():\n active_tasks.extend(task_list)\n if active_tasks:\n active_tasks = [dikt.get(\"id\", \"\") for dikt in active_tasks]\n return Response({\"active_tasks\": active_tasks})","def handle_task_running(self, request):\n \"\"\"\n @api {get} /task/:id/running Check if a task is running\n @apiName IsTaskRunning\n @apiGroup Tasks\n @apiVersion 1.1.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} running The task is running.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"running\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n\n match = re.match('/tasks/([0-9a-z]+)/running', request.uri_path)\n task = match.group(1)\n\n running = self.cluster.is_task_running(task)\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n body = json.dumps({\"id\": task, \"running\": running})\n\n return HTTPReply(code = 200, body = body, headers = headers)","def get_run_log():\r\n params=request.values\r\n result = ExecRunLog.query.filter(ExecRunLog.exec_id==params['exec_id']).all()\r\n return json_response(result=result)","def get_task(id):\n\n if not id:\n raise InvalidAPIUsage(\"id is required\")\n\n collection = get_db_collection()\n\n task = get_task_or_404(collection, id)\n\n response = jsonify(content=task['content'])\n response.status_code = 200\n return response","def get_eventlogs_detail(self, conn, id):\n path = urlJoin(urls.EVENT_LOG[\"GET\"], id)\n resp = conn.command(apiMethod=\"GET\", apiPath=path)\n return resp","def dinghy_post_pod_logs(req, resp, namespace=\"default\", tail_lines=TAIL_LINES_DEFAULT):\n if 'namespace' in req.params.keys():\n namespace = req.params['namespace']\n\n if 'tail_lines' in req.params.keys():\n tail_lines = req.params['tail_lines']\n\n resp.content = api.template(\n 'pod_logs_input.html',\n all_pods=_get_all_pods(namespace=namespace),\n tail_lines=tail_lines\n )","def fusion_api_get_task(self, param='', uri=None, api=None, headers=None):\n if uri is not None:\n # update fully qualified URL to relative URI\n uri = re.sub('^https://\\d*.\\d*.\\d*.\\d*', '', uri)\n return self.task.get(uri=uri, api=api, headers=headers, param=param)","def task(sync=False, methods=('GET',), takes='document'):\n\n def wrap(f):\n global SYNC_TASKS, ASYNC_TASKS\n\n if takes == 'document':\n url = slashjoin(['/', f.__module__.rsplit('.', 1)[-1],\n '<index>/<doc_type>/<int:id>/<bodyfield>'])\n\n @wraps(f)\n def f_task(doc_type, id, index, bodyfield, config):\n es = getconf(config, 'main elasticsearch', error='raise')\n doc = requests.get(slashjoin([es, index, doc_type, str(id)]))\n content = doc.json()['_source'][bodyfield]\n\n return f(content, config)\n\n elif takes == None:\n url = '/' + f.__module__.rsplit('.', 1)[-1]\n f_task = f\n\n (SYNC_TASKS if sync else ASYNC_TASKS).append((f_task, url, methods))\n\n return f\n\n return wrap","def command(task_id, tail, wip, limit):\n if task_id:\n task = storage.get_by_id(task_id)\n\n if not task:\n click.echo(f\"Task {task_id} not found.\")\n sys.exit(1)\n\n tasks = [task]\n else:\n tasks = storage.all(limit=limit, reverse=tail, wip=wip)\n\n print_header()\n for task in tasks:\n show_task(task)","async def logs(id: UUID):\n page_size = 200\n offset = 0\n more_logs = True\n log_filter = LogFilter(flow_run_id={\"any_\": [id]})\n\n async with get_client() as client:\n # Get the flow run\n try:\n flow_run = await client.read_flow_run(id)\n except ObjectNotFound as exc:\n exit_with_error(f\"Flow run {str(id)!r} not found!\")\n\n while more_logs:\n # Get the next page of logs\n page_logs = await client.read_logs(\n log_filter=log_filter, limit=page_size, offset=offset\n )\n\n # Print the logs\n for log in page_logs:\n app.console.print(\n # Print following the flow run format (declared in logging.yml)\n f\"{pendulum.instance(log.timestamp).to_datetime_string()}.{log.timestamp.microsecond // 1000:03d} | {logging.getLevelName(log.level):7s} | Flow run {flow_run.name!r} - {log.message}\",\n soft_wrap=True,\n )\n\n if len(page_logs) == page_size:\n offset += page_size\n else:\n # No more logs to show, exit\n more_logs = False","def getLog():\n with open(webapp.config['LOGFILE'], 'r') as logfile:\n output = logfile.read()\n if request.headers['Accept'] == 'application/json':\n return output, 200\n else:\n return render_template(\"output.html\", output=output)","def on_get(self, req, resp):\n try:\n n_reqs = int(req.params.get('n', self.default_reqs))\n except ValueError:\n error_response(resp, 'ERROR: Incorrect number of requests')\n return\n\n urls = self.scheduler.requests(n_reqs)\n resp.data = json.dumps(urls, ensure_ascii=True)\n resp.content_type = \"application/json\"\n resp.status = falcon.HTTP_200","def on_get(self, req, resp):\n task = get_median_for_last_min.delay(time.time())\n\n result_url = os.path.join(\n os.environ['MEDIAN_API_URL'], 'result', task.id)\n resp.body = json.dumps({'result_url': result_url})\n resp.status = falcon.HTTP_200","def check_task(request, tid):\n try:\n slogger.glob.info(\"check task #{}\".format(tid))\n response = task.check(tid)\n except Exception as e:\n slogger.glob.error(\"cannot check task #{}\".format(tid), exc_info=True)\n return HttpResponseBadRequest(str(e))\n\n return JsonResponse(response)","def top_task_element(request):\n if request.method == \"GET\":\n task = Task.objects.filter(status=\"Open\").order_by(\"-timestamp\").first()\n serializer = TaskSerializer(task)\n return Response(serializer.data)","def task_questions_collection(request, task_id):\n try:\n task = Task.objects.get(id=task_id)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == \"GET\":\n questions = Question.objects.filter(task=task).all().order_by(\"-timestamp\")\n serializer = QuestionSerializer(questions, many=True)\n return Response(serializer.data)","def endpoint_log(self, endpoint_name=None, since=None):\n if endpoint_name is None:\n url = '/v1.1/endpoint/log'\n else:\n url = '/v1.1/endpoints/%s/log' % endpoint_name\n if since is not None:\n url += '?since=%f' % float(since)\n _, body = self.request(url, 'GET')\n return body","def debug_logs_get():\n try:\n return flask.Response(debug_logs.collect(), mimetype='text/plain')\n except debug_logs.Error as e:\n return flask.Response('Failed to retrieve debug logs: %s' % str(e),\n status=500)","def task_endponit():\n action, task, release = parse_request(request)\n\n # Determine what action to take\n if action == 'initialize':\n # Assert that the service is ready to start a new task\n tasks[task] = {\n 'state': 'pending',\n 'release_id': release,\n 'task_id': task,\n 'progress': 0\n }\n elif action == 'start':\n # Here is where the bulk of the processing will happen\n tasks[task] = {\n 'state': 'running',\n 'release_id': release,\n 'task_id': task,\n 'progress': 0\n }\n # Add to the queue\n process.delay(task, release)\n elif action == 'publish':\n # Make the changes live\n tasks[task] = {\n 'state': 'publishing',\n 'release_id': release,\n 'task_id': task,\n 'progress': 0\n }\n publish.delay(task, release)\n elif action == 'get_status':\n if task_id not in tasks:\n abort(404)\n return tasks[task]\n elif action == 'cancel':\n tasks[task] = {\n 'state': 'canceled',\n 'release_id': release,\n 'task_id': task,\n 'progress': 0\n }\n else:\n # Not a valid action\n abort(400)\n\n # Return current task state\n return jsonify(tasks[task])","def get(self, controller, data, *args, **kwargs): \n task_manager = controller.get_task_manager()\n res = task_manager.get_all_tasks(details=True)\n resp = {\n u'task-instances':res,\n u'count':len(res)\n } \n return resp","def _route_get(self):\n if self.path == '/status':\n self._create_status()\n else:\n self._create_method_not_allowed()","def test_05d_get_nonexistant_app_task(self):\r\n res = self.app.get('/app/noapp/task', follow_redirects=True)\r\n assert res.status == '404 NOT FOUND', res.status\r\n # Pagination\r\n res = self.app.get('/app/noapp/task/25', follow_redirects=True)\r\n assert res.status == '404 NOT FOUND', res.status","def task_view(request, task_id):\n\n # retrieve the task, raise an error if the task does not exist\n task = get_object_or_404(Task, id=task_id)\n project = task.projet\n # Check if the logged in user is allowed to see this task\n if request.user.has_perm('taskmanager.{}_project_permission'.format(project.id)):\n # Check if a form has been submitted\n if request.method == \"POST\":\n\n # Build the form and verify it\n form = JournalForm(request.POST)\n if form.is_valid():\n # Save the Journal and set the project and author fields\n journal = form.save(commit=False) # Does not save the Journal in the database\n journal.task = task\n journal.author = request.user\n journal.save()\n\n # update the last modification DateTime of the Task instance\n task.last_modification = datetime.datetime.now()\n task.save()\n else:\n # initialize a new form\n form = JournalForm()\n # Get the Journal entries linked with the task\n entries = Journal.objects.filter(task__id=task_id).order_by('-date')\n return render(request, \"task.html\", locals())\n else:\n # redirect to the linked project to the project list page if the user is not allowed to see the task\n return redirect(\"projects\")","def log_requests(response):\n ts = strftime('[%Y-%b-%d %H:%M-%S]')\n\n logger.info('Flask: {0} {1} {2} {3} {4} {5}'.\n format(ts, request.remote_addr, request.method, request.scheme, request.full_path, response.status))\n\n return response","def log(self):\n resp = requests.get(\"%s/api/log\"%self.urlbase, verify=False)\n return resp.json[\"log\"]","def emit(self, record):\n log_entry = self.format(record)\n try: \n requests.post(self.host+self.url, log_entry,headers={\"Content-type\": \"application/json\"}).content\n except Exception as e:\n if self.debug:\n print(e)","def task_update_stats(request):\n tasks = json.loads(request.POST.get('tasks'))\n date_str = request.POST.get('date')\n cursor = ndb.Cursor(urlsafe=request.POST.get('cursor'))\n countdown = 15\n if not tasks:\n msg = 'Nothing to execute!?'\n logging.warning(msg)\n out = HttpTextResponse(msg)\n else:\n # Dispatch the task to execute.\n task = tasks.pop(0)\n logging.info('Running %s.', task)\n if task.count('-') == 2:\n out, cursor = update_daily_stats(\n cursor, datetime.datetime.strptime(task, DATE_FORMAT))\n elif task == 'monthly':\n # The only reason day is used is in case a task queue spills over the next\n # day.\n day = datetime.datetime.strptime(date_str, DATE_FORMAT)\n out, cursor = update_monthly_stats(cursor, day)\n elif task == '30':\n yesterday = (\n datetime.datetime.strptime(date_str, DATE_FORMAT)\n - datetime.timedelta(days=1)).date()\n out, cursor = update_rolling_stats(cursor, yesterday)\n else:\n msg = 'Unknown task %s, ignoring.' % task\n cursor = ''\n logging.error(msg)\n out = HttpTextResponse(msg)\n\n if cursor:\n # Not done yet!\n tasks.insert(0, task)\n countdown = 0\n\n if out.status_code == 200 and tasks:\n logging.info('%d tasks to go!\\n%s', len(tasks), ', '.join(tasks))\n # Space out the task queue execution by 15s to reduce the risk of\n # datastore inconsistency to get in the way, since no transaction is used.\n # This means to process a full month, it'll include 31*15s = 7:45 minutes\n # delay. 15s is not a lot but we are in an hurry!\n taskqueue.add(\n url=reverse(task_update_stats),\n params={\n 'tasks': json.dumps(tasks),\n 'date': date_str,\n 'cursor': cursor.urlsafe() if cursor else ''},\n queue_name='update-stats',\n countdown=countdown)\n return out","def handler(context, event):\n\n if _ensure_str(event.trigger.kind) != 'http' or _invoked_by_cron(event):\n body = event.body.decode('utf-8')\n context.logger.info('Received event body: {0}'.format(body))\n\n # serialized record\n serialized_record = json.dumps({\n 'body': body,\n 'headers': {\n _ensure_str(header): _ensure_str(value)\n for header, value in event.headers.items()\n },\n 'timestamp': datetime.datetime.utcnow().isoformat(),\n })\n\n # store in log file\n with open(events_log_file_path, 'a') as events_log_file:\n events_log_file.write(serialized_record + ', ')\n\n else:\n\n # read the log file\n try:\n with open(events_log_file_path, 'r') as events_log_file:\n events_log_file_contents = events_log_file.read()\n except IOError:\n events_log_file_contents = ''\n\n # make this valid JSON by removing last two chars (, ) and enclosing in [ ]\n encoded_event_log = '[' + events_log_file_contents[:-2] + ']'\n\n context.logger.info('Returning events: {0}'.format(encoded_event_log))\n\n # return json.loads(encoded_event_log)\n return encoded_event_log","def __call__(self, request):\n request.start_time = time.time()\n\n response = self.get_response(request)\n\n log_data = self.extract_log_info(request=request, response=response)\n logger.info(log_data)\n\n return response","def get(self, request):\n feedback = {\n 'permission': True\n }\n try:\n task_id = request.GET.get('task_id', None)\n if task_id is None:\n feedback['data'] = ErrorCode.parameter_missing('task_id')\n raise natrix_exception.ParameterMissingException(parameter='task_id')\n try:\n uuid.UUID(hex=task_id)\n task = Task.objects.get(id=task_id, time_type='instant')\n\n serializer = task_serializer.InstantTaskSerializer(instance=task)\n feedback['data'] = {\n 'code': 200,\n 'message': u'Instant Task Info!',\n 'info': serializer.data\n }\n except ValueError:\n feedback['data'] = ErrorCode.parameter_invalid('task_id', reason=u'must be a UUID')\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\n except Task.DoesNotExist:\n feedback['data'] = ErrorCode.parameter_invalid(\n 'task_id', reason=u'Can not retrieve Instant Task: {}'.format(task_id))\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\n except natrix_exception.NatrixBaseException as e:\n logger.error(e.get_log())\n feedback['data'] = ErrorCode.sp_code_bug('Serializer error: {}'.format(e.get_log()))\n except Exception as e:\n logger.error(e)\n feedback['data'] = ErrorCode.sp_code_bug('Unknow error: {}'.format(e))\n\n except natrix_exception.NatrixBaseException as e:\n logger.info(e.get_log())\n\n return JsonResponse(data=feedback)","def log():\n data = {}\n log = {}\n log['dia'] = date.today().strftime(\"%d/%m/%Y\")\n log['info'] = ('Rooms IP: %s %s %s')%(request.remote_addr,request.method, request.url)\n data['data'] = log\n try:\n r = requests.post(uri, json=data)\n except requests.exceptions.RequestException as e:\n print(e)\n print(\"\\n\\nThe microservice Log is unvailable. The Log is %s.\"%(log['info']))\n else:\n if r.status_code == 200:\n print(\"Register Log was a success\")\n else:\n print(\"Register Log was an unsuccess\")","def logs(filename):\n\n if not re.search(\".log\",filename):\n print(\"ERROR: API (log): file requested was not a log file: {}\".format(filename))\n return jsonify([])\n\n log_dir = os.path.join(\".\",\"logs\")\n if not os.path.isdir(log_dir):\n print(\"ERROR: API (log): cannot find log dir\")\n return jsonify([])\n\n file_path = os.path.join(log_dir,filename)\n if not os.path.exists(file_path):\n print(\"ERROR: API (log): file requested could not be found: {}\".format(filename))\n return jsonify([])\n \n return send_from_directory(log_dir, filename, as_attachment=True)","def post(self):\n required_keys = [\"event_name\", \"timestamp\"]\n\n verify_log_request(request, required_keys)\n\n args = request.json\n\n # The event log API should enforce the player_id to the current player, unless\n # the user has role \"service\" in which case it should only set the player_id if\n # it's not passed in the event.\n player_id = current_user[\"player_id\"]\n is_service = \"service\" in current_user[\"roles\"]\n\n for event in args:\n if is_service:\n event.setdefault(\"player_id\", player_id)\n else:\n event[\"player_id\"] = player_id # Always override!\n eventlogger.info(\"eventlog\", extra={\"extra\": event})\n\n if request.headers.get(\"Accept\") == \"application/json\":\n return jsonify(status=\"OK\"), http_client.CREATED\n else:\n return \"OK\", http_client.CREATED"],"string":"[\n \"def on_get(self, req, resp):\\n try:\\n task_model_list = self.state_manager.get_tasks()\\n task_list = [x.to_dict() for x in task_model_list]\\n resp.text = json.dumps(task_list)\\n resp.status = falcon.HTTP_200\\n except Exception as ex:\\n self.error(\\n req.context,\\n \\\"Unknown error: %s\\\\n%s\\\" % (str(ex), traceback.format_exc()))\\n self.return_error(resp,\\n falcon.HTTP_500,\\n message=\\\"Unknown error\\\",\\n retry=False)\",\n \"def get(self, project_id, task_id):\\n\\n form = TaskLogForm(request.args)\\n\\n if not form.validate():\\n return {'message' : 'please correct the errors mentioned below.'}, 400\\n\\n data = form.data\\n\\n from_chr = data['from_chr']\\n\\n try:\\n task = backend.get(Task, {'project.pk': request.project.pk, 'pk': task_id}, raw=True)\\n except Task.DoesNotExist:\\n return {'message': \\\"unknown task\\\"}, 404\\n\\n log_path = os.path.join(settings.get('backend.path'),\\n settings.get('backend.paths.tasks'),\\n \\\"{}.log\\\".format(task['pk']))\\n\\n try:\\n with open(log_path, \\\"r\\\") as task_log:\\n task_log.seek(from_chr)\\n content = task_log.read()\\n\\n data = {\\n 'task_log': content,\\n 'len': len(content),\\n 'from': from_chr,\\n 'task_status': task['status'] if 'status' in task else \\\"unknown\\\"\\n }\\n return data, 200\\n except IOError:\\n return {'message': \\\"no log found {}\\\".format(log_path)}, 404\",\n \"async def log_detail(request, job_id=None, task_name=None, log_id=None):\\n jobs = dagobah._serialize().get('jobs', {})\\n job = [job for job in jobs if str(job['job_id']) == job_id][0]\\n return template('log_detail.html',\\n job=job,\\n task_name=task_name,\\n task=[task for task in job['tasks']\\n if task['name'] == task_name][0],\\n log_id=log_id)\",\n \"def handle_task(self, request):\\n \\\"\\\"\\\"\\n @api {get} /tasks/:id Get a task\\n @apiName GetTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Returns the configuration of a task.\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {String} name Name.\\n @apiSuccess {String} description Description.\\n @apiSuccess {String[]} tags Tags.\\n @apiSuccess {Boolean} enabled Task is enabled.\\n @apiSuccess {String} mode Task mode (\\\"any\\\" or \\\"all\\\").\\n @apiSuccess {String[]} pools Pools on which the task should run.\\n @apiSuccess {Object[]} schedules Schedules at which the task should run.\\n @apiSuccess {String} command Command to run.\\n @apiSuccess {String} workdir Working directory.\\n @apiSuccess {String} user User which the task will be run.\\n @apiSuccess {String} group Group which the task will be run.\\n @apiSuccess {Object} env Environment variables to set.\\n @apiSuccess {String} mailreport If the mailer plugin is enabled, condition to send a report (\\\"error\\\", \\\"stdout\\\", \\\"stderr\\\", \\\"output\\\", \\\"always\\\").\\n @apiSuccess {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"name\\\": \\\"My task\\\",\\n \\\"description\\\": \\\"Task description\\\",\\n \\\"tags\\\": [\\\"tasg1\\\", \\\"tag2\\\"],\\n \\\"enabled\\\": true,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"web\\\"],\\n \\\"schedules\\\": [\\n {\\\"minute\\\": [\\\"*/1\\\"]}\\n ],\\n \\\"command\\\": \\\"/bin/true\\\",\\n \\\"workdir\\\": \\\"/tmp/\\\",\\n \\\"user\\\": \\\"www-data\\\",\\n \\\"group\\\": \\\"www-data\\\",\\n \\\"env\\\": {\\n \\\"MYENVVAR\\\": \\\"myvalue\\\"\\n },\\n \\\"mailreport\\\": \\\"output\\\",\\n \\\"mailto\\\": [\\\"user@domain.org\\\"]\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {put} /task/:id Update a task\\n @apiName PutTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Update a task. Can also be used to create a task with a specific ID.\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiParam {String} name Name.\\n @apiParam {String} description Description.\\n @apiParam {String[]} tags Tags.\\n @apiParam {Boolean} enabled Task is enabled.\\n @apiParam {String} mode Task mode (\\\"any\\\" or \\\"all\\\").\\n @apiParam {String[]} pools Pools on which the task should run.\\n @apiParam {Object[]} schedules Schedules at which the task should run.\\n @apiParam {String} command Command to run.\\n @apiParam {String} workdir Working directory.\\n @apiParam {String} user User which the task will be run.\\n @apiParam {String} group Group which the task will be run.\\n @apiParam {Object} env Environment variables to set.\\n @apiParam {String} mailreport If the mailer plugin is enabled, condition to send a report (\\\"error\\\", \\\"stdout\\\", \\\"stderr\\\", \\\"output\\\", \\\"always\\\").\\n @apiParam {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\\n\\n @apiParamExample {json} Example parameters:\\n {\\n \\\"name\\\": \\\"My task\\\",\\n \\\"description\\\": \\\"Task description\\\",\\n \\\"tags\\\": [\\\"tasg1\\\", \\\"tag2\\\"],\\n \\\"enabled\\\": true,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"web\\\"],\\n \\\"schedules\\\": [\\n {\\\"minute\\\": [\\\"*/1\\\"]}\\n ],\\n \\\"command\\\": \\\"/bin/true\\\",\\n \\\"workdir\\\": \\\"/tmp/\\\",\\n \\\"user\\\": \\\"www-data\\\",\\n \\\"group\\\": \\\"www-data\\\",\\n \\\"env\\\": {\\n \\\"MYENVVAR\\\": \\\"myvalue\\\"\\n },\\n \\\"mailreport\\\": \\\"output\\\",\\n \\\"mailto\\\": [\\\"user@domain.org\\\"]\\n }\\n\\n @apiSuccess {Boolean} updated The task has been updated.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"updated\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {delete} /task/:id Delete a task\\n @apiName DeleteTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Delete a task.\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} deleted The task has been deleted.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"deleted\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {execute} /task/:id Execute a task\\n @apiName ExecuteTask\\n @apiGroup Tasks\\n @apiVersion 1.1.0\\n\\n @apiDescription Execute a task.\\n\\n @apiParam {String} :id Task ID.\\n @apiParam {String} :target Target for task execution (\\\"local\\\" to execute on the local node, otherwise execute on the nodes on which the task is configured to run).\\n @apiParam {Boolean} :force Force the execution even if the concurrency limit is reached.\\n\\n @apiSuccess {Boolean} Executed The task has been executed.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"deleted\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n\\n match = re.match('/tasks/([0-9a-z]+)', request.uri_path)\\n task = match.group(1)\\n\\n tasks = self.cluster.config.get('tasks')\\n\\n if request.method == \\\"GET\\\":\\n if task in tasks:\\n return HTTPReply(code = 200, body = json.dumps(tasks[task]), headers = headers)\\n else:\\n return HTTPReply(code = 404, headers = {'Access-Control-Allow-Origin': '*'})\\n\\n elif request.method == \\\"PUT\\\":\\n new = json.loads(request.body)\\n if task in tasks:\\n old = tasks[task]\\n else:\\n old = None\\n\\n tasks[task] = new\\n self.cluster.config.set('tasks', tasks)\\n\\n if old:\\n code = 200\\n body = json.dumps({\\\"id\\\": task, \\\"updated\\\": True})\\n get_plugin_registry().call_hook('TaskUpdated', task, old, new)\\n else:\\n code = 201\\n body = json.dumps({\\\"id\\\": task, \\\"created\\\": True})\\n get_plugin_registry().call_hook('TaskCreated', task, new)\\n\\n return HTTPReply(code = code, body = body, headers = headers)\\n\\n elif request.method == \\\"DELETE\\\":\\n if task in tasks:\\n old = tasks[task]\\n del tasks[task]\\n self.cluster.config.set('tasks', tasks)\\n\\n get_plugin_registry().call_hook('TaskDeleted', task, old)\\n\\n return HTTPReply(code = 200, body = json.dumps({\\\"id\\\": task, \\\"deleted\\\": True}), headers = headers)\\n else:\\n return HTTPReply(code = 404, headers = {'Access-Control-Allow-Origin': '*'})\\n\\n if request.method == \\\"EXECUTE\\\":\\n try:\\n if 'target' in request.args and request.args['target'] == 'local':\\n self.manager.execute_task(task)\\n else:\\n self.cluster.scheduler.run_task(task, ignore_concurrency = 'force' in request.args)\\n\\n return HTTPReply(code = 200, body = json.dumps({\\\"id\\\": task, \\\"executed\\\": True}), headers = headers)\\n except ExecutionDisabled:\\n return HTTPReply(code = 503, body = json.dumps({\\\"id\\\": task, \\\"executed\\\": False}), headers = headers)\",\n \"def handle_tasks(self, request):\\n \\\"\\\"\\\"\\n @api {get} /tasks List tasks\\n @apiName GetTasks\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Return a list of all configured tasks, along with their configuration.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"021b2092ef4111e481a852540064e600\\\": {\\n \\\"name\\\": \\\"task 1\\\",\\n \\\"enabled\\\": true,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"web\\\"],\\n \\\"schedules\\\": [\\n {\\\"minute\\\": [\\\"*/5\\\"]}\\n ],\\n \\\"command\\\": \\\"/bin/task1\\\",\\n },\\n \\\"508b4b72e44611e49e76c81f66cd0cca\\\": {\\n \\\"name\\\": \\\"task 2\\\",\\n \\\"enabled\\\": false,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"pool2\\\"],\\n \\\"schedules\\\": [\\n {\\\"hours\\\": [15], \\\"minutes\\\": [0]}\\n ],\\n \\\"command\\\": \\\"/bin/task2\\\",\\n }\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {post} /tasks Create a new task\\n @apiName PostTasks\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Add a new task, providing its configuration.\\n\\n @apiParam {String} name Name.\\n @apiParam {String} description Description.\\n @apiParam {String[]} tags Tags.\\n @apiParam {Boolean} enabled Task is enabled.\\n @apiParam {String} mode Task mode (\\\"any\\\" or \\\"all\\\").\\n @apiParam {String[]} pools Pools on which the task should run.\\n @apiParam {Object[]} schedules Schedules at which the task should run.\\n @apiParam {String} command Command to run.\\n @apiParam {String} workdir Working directory.\\n @apiParam {String} user User which the task will be run.\\n @apiParam {String} group Group which the task will be run.\\n @apiParam {Object} env Environment variables to set.\\n @apiParam {String} mailreport If the mailer plugin is enabled, condition to send a report (\\\"error\\\", \\\"stdout\\\", \\\"stderr\\\", \\\"output\\\", \\\"always\\\").\\n @apiParam {String[]} mailto If the mailer plugin is enabled, email addresses to send the reports to.\\n\\n @apiParamExample {json} Example parameters:\\n {\\n \\\"name\\\": \\\"My task\\\",\\n \\\"description\\\": \\\"Task description\\\",\\n \\\"tags\\\": [\\\"tasg1\\\", \\\"tag2\\\"],\\n \\\"enabled\\\": true,\\n \\\"mode\\\": \\\"all\\\",\\n \\\"pools\\\": [\\\"web\\\"],\\n \\\"schedules\\\": [\\n {\\\"minute\\\": [\\\"*/1\\\"]}\\n ],\\n \\\"command\\\": \\\"/bin/true\\\",\\n \\\"workdir\\\": \\\"/tmp/\\\",\\n \\\"user\\\": \\\"www-data\\\",\\n \\\"group\\\": \\\"www-data\\\",\\n \\\"env\\\": {\\n \\\"MYENVVAR\\\": \\\"myvalue\\\"\\n },\\n \\\"mailreport\\\": \\\"output\\\",\\n \\\"mailto\\\": [\\\"user@domain.org\\\"]\\n }\\n\\n @apiSuccess {Boolean} created The task has been created.\\n @apiSuccess {String} id ID of the newly created task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"created\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {delete} /tasks Delete all tasks\\n @apiName DeleteTasks\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiDescription Delete all tasks. Use with caution.\\n\\n @apiSuccess {Boolean} deleted The tasks have been deleted.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"deleted\\\": true\\n }\\n \\\"\\\"\\\"\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n\\n if request.method == \\\"GET\\\":\\n tasks = self.cluster.config.get('tasks')\\n\\n if 'tag' in request.args and request.args['tag']:\\n tasks = dict( (taskid, task) for taskid, task in tasks.items() if 'tags' in task and request.args['tag'] in task['tags'] )\\n\\n return HTTPReply(code = 200, body = json.dumps(tasks), headers = headers)\\n\\n elif request.method == \\\"DELETE\\\":\\n oldtasks = self.cluster.config.get('tasks')\\n self.cluster.config.set('tasks', {})\\n\\n for (task, taskconfig) in oldtasks.items():\\n get_plugin_registry().call_hook('TaskDeleted', task, taskconfig)\\n\\n return HTTPReply(code = 200, body = json.dumps({\\\"deleted\\\": True}), headers = headers)\\n\\n elif request.method == \\\"POST\\\":\\n task = uuid.uuid1().hex\\n tasks = self.cluster.config.get('tasks')\\n tasks[task] = json.loads(request.body)\\n self.cluster.config.set('tasks', tasks)\\n\\n get_plugin_registry().call_hook('TaskCreated', task, tasks[task])\\n\\n return HTTPReply(code = 201, body = json.dumps({\\\"id\\\": task, \\\"created\\\": True}), headers = headers)\",\n \"def _app(ctx, logfile, verbose):\\n log_levels = {\\n 0: logging.WARNING,\\n 1: logging.INFO,\\n 2: logging.DEBUG,\\n }\\n loglevel = log_levels.get(verbose, logging.DEBUG)\\n # TODO more flexible logging config\\n logging.basicConfig(format='%(name)s: %(levelname)s: %(message)s',\\n level=loglevel, filename=logfile)\\n\\n tasks = ctx.obj['tasks']\\n tasks.context = ctx\",\n \"def log_request(task_request, request):\\n msg = \\\"{0.method} {0.url}: {0.body}\\\".format(request)\\n log_info(task_request, msg)\",\n \"def task_action_router(request, section_id, task_id):\\n\\n if request.method == 'PUT':\\n return update_task(request, task_id)\\n elif request.method == 'DELETE':\\n return delete_task(request, task_id)\\n else:\\n return HttpResponseNotAllowed('Method not allowed')\",\n \"def on_get(self, req, resp, task_id):\\n task_result = AsyncResult(task_id)\\n result = {'status': task_result.status, 'result': task_result.result}\\n resp.status = falcon.HTTP_200\\n resp.body = json.dumps(result)\",\n \"def api_list_logs():\\n if 'POST' == request.method:\\n per_page = get_safe_int(request.form.get('per_page'))\\n page_num = get_safe_int(request.form.get('page_num'))\\n else:\\n per_page = get_safe_int(request.args.get('per_page'))\\n page_num = get_safe_int(request.args.get('page_num'))\\n\\n \\\"\\\"\\\"\\n pagination = LogEntity.query.paginate(page_num, per_page, False)\\n items = [i.serialize() for i in pagination.items]\\n app.logger.debug(\\\"per_page: {}, page_num: {}\\\".format(per_page, page_num))\\n return jsonify_success(dict(total_pages=pagination.pages,\\n list_of_events=items))\\n \\\"\\\"\\\"\\n logs, total_pages = log_manager.get_logs(per_page, page_num)\\n # logs_list = [x.to_visible() for x in logs]\\n return jsonify_success(dict(list_of_events=logs, total_pages=total_pages))\",\n \"def on_get(self, req, resp, task_id):\\n task = celery_app.AsyncResult(task_id)\\n\\n resp.body = json.dumps(\\n {'status': task.status, 'result': str(task.result)})\\n resp.status = falcon.HTTP_200\",\n \"def system_ajax(request):\\n type = request.GET.get('api', None)\\n task_limit = getattr(settings, 'CELERYMON_TASK_LIMIT', 12)\\n celery_monitoring = getattr(settings, 'CELERY_FLOWER_URL', None)\\n if type == \\\"_active_tasks\\\":\\n server = Server(settings.COUCH_DATABASE)\\n try:\\n tasks = [x for x in server.active_tasks() if x['type'] == \\\"indexer\\\"]\\n except HTTPError as e:\\n if e.response.status_code == 403:\\n return JsonResponse({'error': \\\"Unable to access CouchDB Tasks (unauthorized).\\\"}, status=500)\\n else:\\n return JsonResponse({'error': \\\"Unable to access CouchDB Tasks.\\\"}, status=500)\\n\\n if not is_bigcouch():\\n return JsonResponse(tasks, safe=False)\\n else:\\n # group tasks by design doc\\n task_map = defaultdict(dict)\\n for task in tasks:\\n meta = task_map[task['design_document']]\\n tasks = meta.get('tasks', [])\\n tasks.append(task)\\n meta['tasks'] = tasks\\n\\n design_docs = []\\n for dd, meta in task_map.items():\\n meta['design_document'] = dd[len('_design/'):]\\n total_changes = sum(task['total_changes'] for task in meta['tasks'])\\n for task in meta['tasks']:\\n task['progress_contribution'] = task['changes_done'] * 100 // total_changes\\n\\n design_docs.append(meta)\\n return JsonResponse(design_docs, safe=False)\\n elif type == \\\"_stats\\\":\\n return JsonResponse({})\\n elif type == \\\"_logs\\\":\\n pass\\n elif type == 'pillowtop':\\n pillow_meta = get_all_pillows_json()\\n return JsonResponse(sorted(pillow_meta, key=lambda m: m['name'].lower()), safe=False)\\n\\n if celery_monitoring:\\n if type == \\\"flower_poll\\\":\\n ret = []\\n try:\\n all_tasks = requests.get(\\n celery_monitoring + '/api/tasks',\\n params={'limit': task_limit},\\n timeout=3,\\n ).json()\\n except Exception as ex:\\n return JsonResponse({'error': \\\"Error with getting from celery_flower: %s\\\" % ex}, status=500)\\n\\n for task_id, traw in all_tasks.items():\\n # it's an array of arrays - looping through [<id>, {task_info_dict}]\\n if 'name' in traw and traw['name']:\\n traw['name'] = '.'.join(traw['name'].split('.')[-2:])\\n else:\\n traw['name'] = None\\n ret.append(traw)\\n ret = sorted(ret, key=lambda x: x['succeeded'], reverse=True)\\n return HttpResponse(json.dumps(ret), content_type='application/json')\\n return HttpResponse('{}', content_type='application/json')\",\n \"def task1():\\n logger.info(\\\"In API3 task1 function\\\")\\n return \\\"task1 success!\\\"\",\n \"def tasks_rpc():\\n # First check that this is a legitimate request from the coordinator\\n authenticate_coordinator()\\n action, task_id, release_id = validate_action(request.get_json(force=True))\\n # Call into action\\n return ROUTES[action](task_id, release_id)\",\n \"def logs(self, task: RemoteTask) -> Iterable[str]:\\n raise NotImplementedError()\",\n \"def run_tasks(request):\\r\\n import os\\r\\n if not os.environ['SERVER_SOFTWARE'].startswith('Development'):\\r\\n logging.error(\\\"This URL is only valid in a development environment.\\\")\\r\\n raise Http404\\r\\n else:\\r\\n from datetime import datetime\\r\\n from google.appengine.api import apiproxy_stub_map\\r\\n stub = apiproxy_stub_map.apiproxy.GetStub('taskqueue')\\r\\n \\r\\n #get all the tasks for all the queues\\r\\n tasks = []\\r\\n for queue in stub.GetQueues():\\r\\n tasks.extend( stub.GetTasks(queue['name']) )\\r\\n \\r\\n #keep only tasks that need to be executed\\r\\n now = datetime.now()\\r\\n fn = lambda t: datetime.strptime(t['eta'],'%Y/%m/%d %H:%M:%S') < now\\r\\n tasks = filter(fn, tasks)\\r\\n\\r\\n from django.utils import simplejson as json\\r\\n result = '\\\\n'.join([json.dumps(t) for t in tasks])\\r\\n \\r\\n #remove tasks from queues\\r\\n for queue in stub.GetQueues():\\r\\n stub.FlushQueue(queue['name'])\\r\\n \\r\\n return HttpResponse(result)\",\n \"def ocsaudit_rest_log_command(method, url, url_args, username):\\n \\n try:\\n if method == \\\"GET\\\":\\n type = cmd_type.type_get\\n elif method == \\\"POST\\\":\\n type = cmd_type.type_post\\n elif method == \\\"PATCH\\\":\\n type = cmd_type.type_patch\\n elif method == \\\"DELETE\\\":\\n type = cmd_type.type_delete\\n else:\\n type = cmd_type.type_unknown\\n print \\\"Unidentified command type {0}\\\".format(method)\\n \\n url = url.split(\\\"/v1/\\\",1)[1]\\n args = \\\" \\\".join(url_args)\\n \\n ocsaudit_log_command(username, type, cmd_interface.interface_rest, \\n url, args)\\n except Exception as e:\\n print \\\"ocsaudit_rest_log_command Exception {0}\\\".format(e)\",\n \"def GetLogs(self):\\n raise NotImplementedError()\",\n \"def task_element(request, task_id):\\n try:\\n task = Task.objects.get(id=task_id)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == \\\"GET\\\":\\n serializer = TaskSerializer(task)\\n return Response(serializer.data)\\n\\n elif request.method == \\\"PUT\\\":\\n data = json.loads(request.body)\\n\\n status = data.get(\\\"status\\\", \\\"\\\")\\n task.status = status\\n\\n try:\\n assignee = User.objects.get(username=data.get(\\\"assignee\\\", \\\"\\\"))\\n task.assignee = assignee\\n except:\\n pass\\n \\n task.save()\\n return JsonResponse({\\\"message\\\": \\\"Task updated successfully\\\"}, status=204)\\n\\n elif request.method == \\\"DELETE\\\":\\n task.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def log_api():\\n try:\\n redis.zincrby(REDIS_LOG_KEY_NAME, 1, request.path)\\n except RedisError as exc:\\n return exc\",\n \"def log_route():\\n return send_file(path.join('..', 'app.log'), as_attachment=True)\",\n \"def task_detail(request, pk):\\n try:\\n task = Task.objects.get(pk=pk)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == 'GET':\\n serializer = TaskSerializer(task)\\n return Response(serializer.data)\\n\\n elif request.method == 'PUT':\\n serializer = TaskSerializer(task, data=request.DATA)\\n if serializer.is_valid():\\n serializer.save()\\n # returning the serializer data after saving it to the database\\n return Response(serializer.data)\\n\\n else:\\n # there were some validation errors with the data\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\n\\n elif request.method == 'DELETE':\\n # recall we already have the task present\\n task.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def handle_task_processes(self, request):\\n \\\"\\\"\\\"\\n @api {get} /task/:id/processes List running processes for a task\\n @apiName ListTaskProcesses\\n @apiGroup Tasks\\n @apiVersion 1.1.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"021b2092ef4111e481a852540064e600\\\" : {\\n \\\"node\\\": \\\"node1\\\",\\n \\\"start_time\\\": \\\"2018-03-29T15:01:13.465183+00:00\\\",\\n \\\"task\\\": \\\"e4d07482e44711e49e76c81f66cd0cca\\\"\\n },\\n \\\"253a96e29868135d746989a6123f521e\\\" : {\\n \\\"node\\\": \\\"node2\\\",\\n \\\"start_time\\\": \\\"2018-03-29T14:01:13.352067+00:00\\\",\\n \\\"task\\\": \\\"508b4b72e44611e49e76c81f66cd0cca\\\"\\n },\\n ...\\n }\\n \\\"\\\"\\\"\\n\\n match = re.match('/tasks/([0-9a-z]+)/processes', request.uri_path)\\n task = match.group(1)\\n\\n processes = self.cluster.list_task_processes(task)\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n body = json.dumps(processes)\\n\\n return HTTPReply(code = 200, body = body, headers = headers)\",\n \"def taskList(request):\\n try:\\n # if request.user.username == \\\"root\\\":\\n # pass\\n\\n title = request.data.get(\\\"title\\\", None)\\n desc = request.data.get(\\\"desc\\\", None)\\n stat = request.data.get(\\\"status\\\", None)\\n taskDueDate = request.data.get(\\\"taskDueDate\\\", None)\\n sortby = request.data.get(\\\"sortby\\\", None)\\n qs = Task.objects.filter(userID=request.user)\\n if sortby:\\n qs = qs.order_by(sortby)\\n\\n if title:\\n qs = qs.filter(Q(title__exact=title))\\n\\n if desc:\\n qs = qs.filter(Q(desc__exact=desc))\\n\\n if stat:\\n qs = qs.filter(Q(status__exact=stat))\\n\\n if taskDueDate:\\n qs = qs.filter(Q(taskDueDate__exact=taskDueDate))\\n\\n serializer = TaskSerializer(qs, many=True)\\n if len(serializer.data) != 0:\\n for i in range(len(serializer.data)):\\n serializer.data[i]['userID'] = request.user.username\\n\\n return Response(serializer.data, status=status.HTTP_200_OK)\\n\\n\\n except Exception as e:\\n return Response(e.args[0], status.HTTP_400_BAD_REQUEST)\",\n \"def task_list(request):\\n if request.method == \\\"GET\\\":\\n tasks = Task.objects.all()\\n\\n # tasks here is a query set. So we are essentially passing the entire query set into the serializer\\n # the many=True attribute here is super important. Without this attribute an error would be raised\\n\\n serializer = TaskSerializer(tasks, many=True)\\n return Response(serializer.data)\\n\\n elif request.method == \\\"POST\\\":\\n serializer = TaskSerializer(data=request.DATA)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data, status=status.HTTP_201_CREATED)\\n\\n else:\\n # there is a validation error and hence there is a problem with the data in the request\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def view_task(self, task_id):\\n api_url = self.server_url + self.METHOD_VIEW_TASK + str(task_id)\\n\\n request = Request(api_url)\\n\\n log.info(\\\"Request to \\\" + api_url)\\n try:\\n response = request.get()\\n except HTTPError, e:\\n log.error(\\\"Error in view_task: \\\" + str(e))\\n raise CuckooError(str(e))\\n except ConnectionError, e:\\n log.error(\\\"Error in view_task: \\\" + str(e))\\n raise CuckooError(str(e))\\n\\n log.info(\\\"Response: \\\" + str(response))\\n\\n return response\",\n \"def log_request_response(task_request, response):\\n log_request(task_request, response.request)\\n log_response(task_request, response)\",\n \"def list(ctx, id, json):\\n\\n kargs={'host': c.cfg['host'], \\\"api_version\\\": c.cfg['api_version'], \\\"url_path\\\": \\\"/tasks\\\"}\\n if id != None:\\n return ctx.invoke(show, id=id, json=json)\\n\\n task = estask.Task(kargs)\\n try:\\n dict_resp= task.list()\\n except Exception as e:\\n sys.exit(\\\"Fail: %s\\\" %str(e))\\n\\n if dict_resp == None:\\n click.echo(\\\"Fail: error response\\\")\\n sys.exit(1)\\n\\n if json:\\n print(jsn.dumps(dict_resp, sort_keys=True, indent=4))\\n return\\n try:\\n task.print_list(dict_resp)\\n except Exception as e:\\n sys.exit(\\\"Fail: %s\\\" %str(e))\",\n \"def status():\\n _request('worklog/status/')\",\n \"def tasks_collection(request):\\n if request.method == \\\"GET\\\":\\n tasks = Task.objects.all().order_by(\\\"-timestamp\\\")\\n serializer = TaskSerializer(tasks, many=True)\\n return Response(serializer.data)\\n\\n elif request.method == \\\"POST\\\":\\n data = json.loads(request.body)\\n title = data.get(\\\"title\\\", \\\"\\\")\\n description = data.get(\\\"description\\\", \\\"\\\")\\n category = data.get(\\\"category\\\", \\\"\\\")\\n budget = data.get(\\\"budget\\\", \\\"\\\")\\n poster = User.objects.get(username=data.get(\\\"poster\\\", \\\"\\\"))\\n due_date = parser.parse(data.get(\\\"dueDate\\\", \\\"\\\"))\\n\\n task = Task(\\n title=title,\\n description=description,\\n poster=poster,\\n due_date=due_date,\\n budget=budget,\\n category=category\\n )\\n task.save()\\n return JsonResponse({\\\"message\\\": \\\"Task created successfully\\\"}, status=201)\",\n \"def dinghy_get_pod_logs(req, resp):\\n resp.content = api.template(\\n 'pod_logs.html'\\n )\",\n \"def get_log(request, **kwargs):\\n\\n #Creating the command for the logs \\n try:\\n\\tprint(kwargs)\\n\\tprint(request.GET['project_id'])\\n\\toutputStr = sidecar.events.test_logs(project_id=request.GET['project_id'])\\n\\tlog_data = outputStr.log_data\\n\\toutputStr = \\\" <br>\\\".join(log_data.split(\\\"\\\\n\\\"))\\n except Exception, e:\\n outputStr = \\\"Updating the logs...\\\"\\t\\n #Making the output\\n context = {\\n \\\"page_title\\\": _(\\\"Test Details\\\"),\\n \\\"test_lists\\\": 'report_list', #tests_list\\n \\\"log_data\\\": outputStr\\n }\\n return render(request, 'rally_dashboard/events/test_logs.html', context)\",\n \"def task_offers_collection(request, task_id):\\n try:\\n task = Task.objects.get(id=task_id)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == \\\"GET\\\":\\n offers = Offer.objects.filter(task=task).all().order_by(\\\"-timestamp\\\")\\n serializer = OfferSerializer(offers, many=True)\\n return Response(serializer.data)\",\n \"def log_response(task_request, response):\\n msg = \\\"{0.status_code} {0.reason} for {0.url}: {0.content}\\\".format(response)\\n log_info(task_request, msg)\",\n \"def list_all_tasks(var):\\n init_dao(client_id, client_secret, tenant_id, refresh_token) \\n \\n if var.lower() == \\\"tasks\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n return Response(stream_as_json(get_tasks(get_plans(get_all_objects('/groups/')))), content_type='application/json')\\n elif var.lower() == \\\"plans\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n return Response(stream_as_json(get_plans(get_all_objects('/groups/'))), request.args.get('since'), content_type='application/json')\\n elif var.lower() == \\\"conversations\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n return Response(stream_as_json(get_conversations(get_all_objects('/groups/'))), request.args.get('since'), content_type='application/json')\\n elif var.lower() == \\\"threads\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n return Response(stream_as_json(get_threads(get_conversations(get_all_objects('/groups/')))), request.args.get('since'),\\n content_type='application/json')\\n elif var.lower() == \\\"posts\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n return Response(stream_as_json(get_posts(get_threads(get_conversations(get_all_objects('/groups/'))))),\\n request.args.get('since'),\\n content_type='application/json')\\n elif var.lower() == \\\"groups\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n return Response(get_all_groups(request.args.get('since')), content_type='application/json')\\n elif var.lower() == \\\"users\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n return Response(get_all_users(request.args.get('since')), content_type='application/json')\\n elif var.lower() == \\\"create_tasks\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n request_data = request.get_data()\\n return create_tasks(json.loads(str(request_data.decode(\\\"utf-8\\\"))))\\n elif var.lower() == \\\"update_tasks\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n request_data = request.get_data()\\n return update_tasks(json.loads(str(request_data.decode(\\\"utf-8\\\"))))\\n elif var.lower() == \\\"create_buckets\\\":\\n app.logger.info(f'Requesting {var} from the graph API')\\n elif var.lower() == \\\"create_plans\\\":\\n request_data = request.get_data()\\n return create_plans(json.loads(str(request_data.decode(\\\"utf-8\\\"))))\\n else:\\n app.logger.warning(f'The following request value : {var} \\\\n - does not comply with what is currently configured backend')\\n return Response(json.dumps({\\\"You need to choose a configured <value> in the path '/planner/<value>'\\\" : \\\"I.e. : 'tasks', 'plans', 'groups' or 'users'\\\"}), content_type='application/json')\",\n \"def task2():\\n logger.info(\\\"In API3 task2 function\\\")\\n return \\\"task2 success!\\\"\",\n \"def task_log(self, task_id, subtask=None, workunit_id=None):\\n\\n if subtask:\\n dir, logfile = task_log_path(task_id, subtask, workunit_id)\\n else:\\n dir, logfile = task_log_path(task_id)\\n\\n fp = open(logfile, 'r')\\n log = fp.read()\\n fp.close()\\n return log\",\n \"def _log(log_fn, task_request, message):\\n log_fn(\\\"{}: {}\\\".format(task_request.id, message))\",\n \"def on_get(self, req, resp, task_id):\\n try:\\n builddata = req.get_param_as_bool('builddata')\\n subtask_errors = req.get_param_as_bool('subtaskerrors')\\n try:\\n layers = int(req.params.get('layers', '0'))\\n except Exception:\\n layers = 0\\n\\n first_task = self.get_task(req, resp, task_id, builddata)\\n\\n if first_task is None:\\n self.info(req.context, \\\"Task %s does not exist\\\" % task_id)\\n self.return_error(resp,\\n falcon.HTTP_404,\\n message=\\\"Task %s does not exist\\\" % task_id,\\n retry=False)\\n else:\\n # If layers is passed in then it returns a dict of tasks instead of the task dict.\\n if layers:\\n resp_data, errors = self.handle_layers(\\n req, resp, task_id, builddata, subtask_errors, layers,\\n first_task)\\n # Includes subtask_errors if the query param 'subtaskerrors' is passed in as true.\\n if (subtask_errors):\\n resp_data['subtask_errors'] = errors\\n else:\\n resp_data = first_task\\n # Includes subtask_errors if the query param 'subtaskerrors' is passed in as true.\\n if (subtask_errors):\\n _, errors = self.handle_layers(req, resp, task_id,\\n False, subtask_errors,\\n 1, first_task)\\n resp_data['subtask_errors'] = errors\\n\\n resp.text = json.dumps(resp_data)\\n resp.status = falcon.HTTP_200\\n except Exception as ex:\\n self.error(req.context, \\\"Unknown error: %s\\\" % (str(ex)))\\n self.return_error(resp,\\n falcon.HTTP_500,\\n message=\\\"Unknown error\\\",\\n retry=False)\",\n \"def api_record(path):\\n exception = log_api()\\n if exception:\\n return jsonify({'error': exception}), HTTPStatus.INTERNAL_SERVER_ERROR\\n return '', HTTPStatus.OK\",\n \"def start_task_manager(params):\\n logname = \\\"%s.task\\\" % params['api_id']\\n frmt = u'[%(asctime)s: %(levelname)s/%(processName)s] ' \\\\\\n u'%(name)s:%(funcName)s:%(lineno)d - %(message)s'\\n \\n frmt = u'[%(asctime)s: %(levelname)s/%(task_name)s:%(task_id)s] '\\\\\\n u'%(name)s:%(funcName)s:%(lineno)d - %(message)s' \\n \\n log_path = u'/var/log/%s/%s' % (params[u'api_package'], \\n params[u'api_env'])\\n run_path = u'/var/run/%s/%s' % (params[u'api_package'], \\n params[u'api_env']) \\n \\n #loggers = [logging.getLogger('beehive.common.event')]\\n #LoggerHelper.rotatingfile_handler(loggers, logger_level, \\n # '%s/%s.event.log' % (log_path, logname),\\n # frmt=frmt) \\n \\n # base logging\\n loggers = [\\n logging.getLogger(u'beehive'),\\n logging.getLogger(u'beehive.db'),\\n logging.getLogger(u'beecell'),\\n logging.getLogger(u'beedrones'),\\n logging.getLogger(u'celery'),\\n logging.getLogger(u'proxmoxer'),\\n logging.getLogger(u'requests')]\\n LoggerHelper.rotatingfile_handler(loggers, logger_level, \\n u'%s/%s.log' % (log_path, logname),\\n frmt=frmt, formatter=ExtTaskFormatter)\\n\\n # transaction and db logging\\n loggers = [\\n logging.getLogger('beehive.util.data'),\\n logging.getLogger('sqlalchemy.engine'),\\n logging.getLogger('sqlalchemy.pool')]\\n LoggerHelper.rotatingfile_handler(loggers, logger_level, \\n '%s/%s.db.log' % (log_path, logname))\\n \\n # performance logging\\n loggers = [\\n logging.getLogger('beecell.perf')]\\n LoggerHelper.rotatingfile_handler(loggers, logger_level, \\n '%s/%s.watch' % (log_path, params[u'api_id']), \\n frmt='%(asctime)s - %(message)s')\\n\\n api_manager = ApiManager(params, hostname=gethostname())\\n api_manager.configure()\\n api_manager.register_modules()\\n #worker = ProcessEventConsumerRedis(api_manager)\\n #from beehive.module.tasks import task_manager\\n task_manager.api_manager = api_manager\\n\\n logger_file = '%s/%s.log' % (log_path, logname)\\n\\n configure_task_manager(params['broker_url'], params['result_backend'],\\n tasks=params['task_module'], expire=params['expire'],\\n logger_file=logger_file)\\n \\n argv = [u'',\\n u'--loglevel=%s' % logging.getLevelName(logger_level),\\n #u'--pool=prefork',\\n u'--pool=gevent',\\n u'--purge',\\n #'--time-limit=600',\\n #'--soft-time-limit=300',\\n u'--concurrency=100',\\n u'--maxtasksperchild=100',\\n #u'--autoscale=100,10',\\n u'--logfile=%s' % logger_file,\\n u'--pidfile=%s/%s.task.pid' % (run_path, logname)]\\n \\n def terminate(*args):\\n #run_command(['celery', 'multi', 'stopwait', 'worker1', \\n # '--pidfile=\\\"run/celery-%n.pid\\\"'])\\n task_manager.stop()\\n \\n #for sig in (SIGHUP, SIGABRT, SIGILL, SIGINT, SIGSEGV, SIGTERM, SIGQUIT):\\n # signal(sig, terminate)\\n \\n task_manager.worker_main(argv)\",\n \"def task(ctx, config):\\n log.info('{config}'.format(config=config))\",\n \"def view(self, _type, task_id):\\n try:\\n return self._super.do(**{\\n \\\"method\\\": \\\"GET\\\",\\n \\\"url\\\": \\\"{}/tasks/report/{}\\\".format(self.baseurl, task_id)\\n })\\n except AnalyserUpstreamError as e:\\n if \\\"404\\\" in str(e.code):\\n return None\",\n \"def get(self):\\n url = \\\"http://twitter.com/statuses/public_timeline.json\\\"\\n task = taskqueue.Task(\\n url='/tasks/fetch',\\n params={'url': url}\\n )\\n task.add('fetch')\",\n \"def log_schedule(self):\\n self.logger.log_schedule(self.params.schedule)\",\n \"def getLog(request):\\n # TODO: GET\\n data = {}\\n return data\",\n \"def task_logger(self, handler: Handler, msg: str) -> None:\\n handler(\\\"HacsTask<%s> %s\\\", self.slug, msg)\",\n \"def rest_api_log(self):\\n with self.resource_lock:\\n pass\",\n \"def get_tasks(id):\\n url = 'https://jsonplaceholder.typicode.com/'\\n tasks = requests.get(url + 'todos', params={'userId': id}).json()\\n return tasks\",\n \"def getLogs():\",\n \"def getLogs():\",\n \"def getNodeTaskLogByUPID(self,node,upid):\\n data = self.connect('get','nodes/%s/tasks/%s/log' % (node,upid),None)\\n return data\",\n \"def get_tasks(data: dict) -> dict:\\n status_code = http.HTTPStatus.OK\\n body = {\\\"filters\\\": data}\\n try:\\n tasks = actions.get_tasks(data)\\n body[\\\"tasks\\\"] = [task.to_dict() for task in tasks]\\n except tskexc.TaskHTTPException as e:\\n body = {\\\"error\\\": e.message}\\n status_code = e.http_status\\n return {\\\"statusCode\\\": status_code, \\\"body\\\": json.dumps(body)}\",\n \"def upload_logs():\\n return {\\n 'page': 'upload_logs',\\n 'raw_logs': '',\\n }\",\n \"def get(self, request):\\n feedback = {\\n 'permission': True\\n }\\n\\n try:\\n task_id = request.GET.get('task_id', None)\\n if task_id is None:\\n feedback['data'] = ErrorCode.parameter_missing('task_id')\\n raise natrix_exception.ParameterMissingException(parameter='task_id')\\n try:\\n uuid.UUID(hex=task_id)\\n except ValueError:\\n feedback['data'] = ErrorCode.parameter_invalid('task_id', reason=u'must be a UUID')\\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\\n try:\\n task = Task.objects.get(id=task_id, time_type='instant')\\n # response_count = success + wrong\\n res = command_dispatcher.get_task_data(task.id)\\n success = len(res.get('success'))\\n wrong = len(res.get('error'))\\n response_count = success + wrong\\n\\n time_delta = timezone.now() - task.create_time\\n\\n if task.status and ( response_count == task.terminal_count or time_delta.seconds > 120):\\n task.status = False\\n task.result_snapshot = json.dumps(res)\\n task.save()\\n\\n feedback['data'] = {\\n 'code': 200,\\n 'message': 'Instant Task Status',\\n 'info': {\\n 'finished': not task.status,\\n 'total': task.terminal_count,\\n 'responses': response_count,\\n 'success': success,\\n 'wrong': wrong\\n }\\n }\\n\\n except Task.DoesNotExist:\\n feedback['data'] = ErrorCode.parameter_invalid(\\n 'task_id', reason=u'Can not retrieve Instant Task: {}'.format(task_id))\\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\\n\\n except natrix_exception.NatrixBaseException as e:\\n logger.error(e.get_log())\\n\\n return JsonResponse(data=feedback)\",\n \"def list(self, _request):\\n serializer = TaskSerializer(instance=TASKS.values(), many=True)\\n return response.Response(serializer.data)\",\n \"def get(self, dnzo_user, task_list):\\n self.json_response(task_list=task_list.to_dict())\",\n \"def handle_task_enable(self, request):\\n \\\"\\\"\\\"\\n @api {post} /task/:id/enable Enable a task\\n @apiName EnableTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} updated The task has been updated.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"updated\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {post} /task/:id/disable Disable a task\\n @apiName DisableTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} updated The task has been updated.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"updated\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n\\n match = re.match('/tasks/([0-9a-z]+)/(en|dis)able', request.uri_path)\\n task = match.group(1)\\n action = match.group(2)\\n\\n enabled = (action == 'en')\\n\\n tasks = self.cluster.config.get('tasks')\\n\\n if task in tasks:\\n code = 200\\n\\n old = tasks[task].copy()\\n tasks[task]['enabled'] = enabled\\n self.cluster.config.set('tasks', tasks)\\n\\n get_plugin_registry().call_hook('TaskUpdated', task, old, tasks[task])\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n body = json.dumps({\\\"id\\\": task, \\\"updated\\\": True})\\n\\n return HTTPReply(code = code, body = body, headers = headers)\\n else:\\n headers = {\\n 'Access-Control-Allow-Origin': '*'\\n }\\n return HTTPReply(code = 404, headers = headers)\",\n \"def get_formatted_task_log(self):\\n try:\\n log = requests.get(self.gs_base_url + \\\"/out.log\\\").content\\n except:\\n return [f\\\"####-##-## ##:##:## Task ID: {self.name}\\\\n\\\"]\\n return (f\\\"####-##-## ##:##:## Task ID: {self.name}\\\\n\\\" + log.decode('utf-8')).splitlines()\",\n \"def api():\\n query = dict(request.args)\\n socket_io.emit('log', dict(data=str(query)), broadcast=True)\\n return jsonify(dict(success=True, message='Received'))\",\n \"def log(request, tag=''):\\n tvents = Tvent.objects\\n if tag:\\n if tag.startswith(\\\"~\\\"):\\n tvents = tvents.filter(user=tag[1:])\\n elif tag.startswith(\\\"@\\\"):\\n tvents = tvents.filter(target=tag[1:])\\n else:\\n # TODO: other log types?\\n pass\\n try:\\n until = to_datetime(request.GET['until'])\\n tvents = tvents.filter(datetime__lte=until)\\n except (KeyError, ValueError):\\n until = ''\\n\\n tvents = tvents.order_by('-datetime')\\n tvents.select_related('target')\\n # output = '\\\\n\\\\n'.join([tv.uniqey + '\\\\n'.join([str(s) for s in tv.tags]) for tv in tvents])\\n return render_to_response('log.html',{'tvents':tvents, 'until':until, 'tag':tag})\",\n \"def log(msg):\\n\\tfrom http_request import req\\n\\tif not req: return\\n\\t\\t\\n\\tif not req.out.get('_log'):\\n\\t\\treq.out['_log'] = []\\n\\treq.out['_log'].append(msg)\",\n \"def user_tasks(request, user_id):\\n if request.method == 'GET':\\n records = HmmerQueryRecord.objects.filter(user__id=user_id, result_date__gt=(localtime(now())+ timedelta(days=-7)))\\n serializer = UserHmmerQueryRecordSerializer(records, many=True)\\n return JSONResponse(serializer.data)\",\n \"def admin_applog(request):\\r\\n rdict = request.GET\\r\\n\\r\\n # Support optional filter parameters\\r\\n days = int(rdict.get('days', 1))\\r\\n status = rdict.get('status', None)\\r\\n message = rdict.get('message', None)\\r\\n\\r\\n log_list = AppLogMgr.find(\\r\\n days=days,\\r\\n message_filter=message,\\r\\n status=status,\\r\\n )\\r\\n\\r\\n ret = {\\r\\n 'count': len(log_list),\\r\\n 'logs': [dict(l) for l in log_list],\\r\\n }\\r\\n return _api_response(request, ret)\",\n \"def get_current_user_tasks_route():\\n user = current_user\\n\\n if user.get_id() is not None:\\n return get_user_jobs_route(user.id)\\n else:\\n response_object = {'status': 'error'}\\n return jsonify(response_object)\",\n \"def test_get_event_logs(event_log_api_setup):\\n api_response = event_log_api_setup.get_event_logs(limit=100, offset=0)\\n logging.getLogger().info(\\\"%s\\\", api_response)\\n print(f\\\"{BCOLORS.OKGREEN}OK{BCOLORS.ENDC}\\\")\",\n \"def task_records_to_log(self, records: List[Any]) -> None:\\n for r in records:\\n self._logger.info(\\n \\\"[%s]: %s - %s - %s/%s\\\",\\n r[\\\"createdDateTime\\\"],\\n r[\\\"userPrincipalName\\\"],\\n r[\\\"ipAddress\\\"],\\n r[\\\"location\\\"][\\\"countryOrRegion\\\"],\\n r[\\\"location\\\"][\\\"city\\\"],\\n )\",\n \"def running_celery_tasks(request):\\n active_dict = CELERY_INSPECT.active()\\n active_tasks = []\\n if active_dict:\\n for task_list in active_dict.values():\\n active_tasks.extend(task_list)\\n if active_tasks:\\n active_tasks = [dikt.get(\\\"id\\\", \\\"\\\") for dikt in active_tasks]\\n return Response({\\\"active_tasks\\\": active_tasks})\",\n \"def handle_task_running(self, request):\\n \\\"\\\"\\\"\\n @api {get} /task/:id/running Check if a task is running\\n @apiName IsTaskRunning\\n @apiGroup Tasks\\n @apiVersion 1.1.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} running The task is running.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"running\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n\\n match = re.match('/tasks/([0-9a-z]+)/running', request.uri_path)\\n task = match.group(1)\\n\\n running = self.cluster.is_task_running(task)\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n body = json.dumps({\\\"id\\\": task, \\\"running\\\": running})\\n\\n return HTTPReply(code = 200, body = body, headers = headers)\",\n \"def get_run_log():\\r\\n params=request.values\\r\\n result = ExecRunLog.query.filter(ExecRunLog.exec_id==params['exec_id']).all()\\r\\n return json_response(result=result)\",\n \"def get_task(id):\\n\\n if not id:\\n raise InvalidAPIUsage(\\\"id is required\\\")\\n\\n collection = get_db_collection()\\n\\n task = get_task_or_404(collection, id)\\n\\n response = jsonify(content=task['content'])\\n response.status_code = 200\\n return response\",\n \"def get_eventlogs_detail(self, conn, id):\\n path = urlJoin(urls.EVENT_LOG[\\\"GET\\\"], id)\\n resp = conn.command(apiMethod=\\\"GET\\\", apiPath=path)\\n return resp\",\n \"def dinghy_post_pod_logs(req, resp, namespace=\\\"default\\\", tail_lines=TAIL_LINES_DEFAULT):\\n if 'namespace' in req.params.keys():\\n namespace = req.params['namespace']\\n\\n if 'tail_lines' in req.params.keys():\\n tail_lines = req.params['tail_lines']\\n\\n resp.content = api.template(\\n 'pod_logs_input.html',\\n all_pods=_get_all_pods(namespace=namespace),\\n tail_lines=tail_lines\\n )\",\n \"def fusion_api_get_task(self, param='', uri=None, api=None, headers=None):\\n if uri is not None:\\n # update fully qualified URL to relative URI\\n uri = re.sub('^https://\\\\d*.\\\\d*.\\\\d*.\\\\d*', '', uri)\\n return self.task.get(uri=uri, api=api, headers=headers, param=param)\",\n \"def task(sync=False, methods=('GET',), takes='document'):\\n\\n def wrap(f):\\n global SYNC_TASKS, ASYNC_TASKS\\n\\n if takes == 'document':\\n url = slashjoin(['/', f.__module__.rsplit('.', 1)[-1],\\n '<index>/<doc_type>/<int:id>/<bodyfield>'])\\n\\n @wraps(f)\\n def f_task(doc_type, id, index, bodyfield, config):\\n es = getconf(config, 'main elasticsearch', error='raise')\\n doc = requests.get(slashjoin([es, index, doc_type, str(id)]))\\n content = doc.json()['_source'][bodyfield]\\n\\n return f(content, config)\\n\\n elif takes == None:\\n url = '/' + f.__module__.rsplit('.', 1)[-1]\\n f_task = f\\n\\n (SYNC_TASKS if sync else ASYNC_TASKS).append((f_task, url, methods))\\n\\n return f\\n\\n return wrap\",\n \"def command(task_id, tail, wip, limit):\\n if task_id:\\n task = storage.get_by_id(task_id)\\n\\n if not task:\\n click.echo(f\\\"Task {task_id} not found.\\\")\\n sys.exit(1)\\n\\n tasks = [task]\\n else:\\n tasks = storage.all(limit=limit, reverse=tail, wip=wip)\\n\\n print_header()\\n for task in tasks:\\n show_task(task)\",\n \"async def logs(id: UUID):\\n page_size = 200\\n offset = 0\\n more_logs = True\\n log_filter = LogFilter(flow_run_id={\\\"any_\\\": [id]})\\n\\n async with get_client() as client:\\n # Get the flow run\\n try:\\n flow_run = await client.read_flow_run(id)\\n except ObjectNotFound as exc:\\n exit_with_error(f\\\"Flow run {str(id)!r} not found!\\\")\\n\\n while more_logs:\\n # Get the next page of logs\\n page_logs = await client.read_logs(\\n log_filter=log_filter, limit=page_size, offset=offset\\n )\\n\\n # Print the logs\\n for log in page_logs:\\n app.console.print(\\n # Print following the flow run format (declared in logging.yml)\\n f\\\"{pendulum.instance(log.timestamp).to_datetime_string()}.{log.timestamp.microsecond // 1000:03d} | {logging.getLevelName(log.level):7s} | Flow run {flow_run.name!r} - {log.message}\\\",\\n soft_wrap=True,\\n )\\n\\n if len(page_logs) == page_size:\\n offset += page_size\\n else:\\n # No more logs to show, exit\\n more_logs = False\",\n \"def getLog():\\n with open(webapp.config['LOGFILE'], 'r') as logfile:\\n output = logfile.read()\\n if request.headers['Accept'] == 'application/json':\\n return output, 200\\n else:\\n return render_template(\\\"output.html\\\", output=output)\",\n \"def on_get(self, req, resp):\\n try:\\n n_reqs = int(req.params.get('n', self.default_reqs))\\n except ValueError:\\n error_response(resp, 'ERROR: Incorrect number of requests')\\n return\\n\\n urls = self.scheduler.requests(n_reqs)\\n resp.data = json.dumps(urls, ensure_ascii=True)\\n resp.content_type = \\\"application/json\\\"\\n resp.status = falcon.HTTP_200\",\n \"def on_get(self, req, resp):\\n task = get_median_for_last_min.delay(time.time())\\n\\n result_url = os.path.join(\\n os.environ['MEDIAN_API_URL'], 'result', task.id)\\n resp.body = json.dumps({'result_url': result_url})\\n resp.status = falcon.HTTP_200\",\n \"def check_task(request, tid):\\n try:\\n slogger.glob.info(\\\"check task #{}\\\".format(tid))\\n response = task.check(tid)\\n except Exception as e:\\n slogger.glob.error(\\\"cannot check task #{}\\\".format(tid), exc_info=True)\\n return HttpResponseBadRequest(str(e))\\n\\n return JsonResponse(response)\",\n \"def top_task_element(request):\\n if request.method == \\\"GET\\\":\\n task = Task.objects.filter(status=\\\"Open\\\").order_by(\\\"-timestamp\\\").first()\\n serializer = TaskSerializer(task)\\n return Response(serializer.data)\",\n \"def task_questions_collection(request, task_id):\\n try:\\n task = Task.objects.get(id=task_id)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == \\\"GET\\\":\\n questions = Question.objects.filter(task=task).all().order_by(\\\"-timestamp\\\")\\n serializer = QuestionSerializer(questions, many=True)\\n return Response(serializer.data)\",\n \"def endpoint_log(self, endpoint_name=None, since=None):\\n if endpoint_name is None:\\n url = '/v1.1/endpoint/log'\\n else:\\n url = '/v1.1/endpoints/%s/log' % endpoint_name\\n if since is not None:\\n url += '?since=%f' % float(since)\\n _, body = self.request(url, 'GET')\\n return body\",\n \"def debug_logs_get():\\n try:\\n return flask.Response(debug_logs.collect(), mimetype='text/plain')\\n except debug_logs.Error as e:\\n return flask.Response('Failed to retrieve debug logs: %s' % str(e),\\n status=500)\",\n \"def task_endponit():\\n action, task, release = parse_request(request)\\n\\n # Determine what action to take\\n if action == 'initialize':\\n # Assert that the service is ready to start a new task\\n tasks[task] = {\\n 'state': 'pending',\\n 'release_id': release,\\n 'task_id': task,\\n 'progress': 0\\n }\\n elif action == 'start':\\n # Here is where the bulk of the processing will happen\\n tasks[task] = {\\n 'state': 'running',\\n 'release_id': release,\\n 'task_id': task,\\n 'progress': 0\\n }\\n # Add to the queue\\n process.delay(task, release)\\n elif action == 'publish':\\n # Make the changes live\\n tasks[task] = {\\n 'state': 'publishing',\\n 'release_id': release,\\n 'task_id': task,\\n 'progress': 0\\n }\\n publish.delay(task, release)\\n elif action == 'get_status':\\n if task_id not in tasks:\\n abort(404)\\n return tasks[task]\\n elif action == 'cancel':\\n tasks[task] = {\\n 'state': 'canceled',\\n 'release_id': release,\\n 'task_id': task,\\n 'progress': 0\\n }\\n else:\\n # Not a valid action\\n abort(400)\\n\\n # Return current task state\\n return jsonify(tasks[task])\",\n \"def get(self, controller, data, *args, **kwargs): \\n task_manager = controller.get_task_manager()\\n res = task_manager.get_all_tasks(details=True)\\n resp = {\\n u'task-instances':res,\\n u'count':len(res)\\n } \\n return resp\",\n \"def _route_get(self):\\n if self.path == '/status':\\n self._create_status()\\n else:\\n self._create_method_not_allowed()\",\n \"def test_05d_get_nonexistant_app_task(self):\\r\\n res = self.app.get('/app/noapp/task', follow_redirects=True)\\r\\n assert res.status == '404 NOT FOUND', res.status\\r\\n # Pagination\\r\\n res = self.app.get('/app/noapp/task/25', follow_redirects=True)\\r\\n assert res.status == '404 NOT FOUND', res.status\",\n \"def task_view(request, task_id):\\n\\n # retrieve the task, raise an error if the task does not exist\\n task = get_object_or_404(Task, id=task_id)\\n project = task.projet\\n # Check if the logged in user is allowed to see this task\\n if request.user.has_perm('taskmanager.{}_project_permission'.format(project.id)):\\n # Check if a form has been submitted\\n if request.method == \\\"POST\\\":\\n\\n # Build the form and verify it\\n form = JournalForm(request.POST)\\n if form.is_valid():\\n # Save the Journal and set the project and author fields\\n journal = form.save(commit=False) # Does not save the Journal in the database\\n journal.task = task\\n journal.author = request.user\\n journal.save()\\n\\n # update the last modification DateTime of the Task instance\\n task.last_modification = datetime.datetime.now()\\n task.save()\\n else:\\n # initialize a new form\\n form = JournalForm()\\n # Get the Journal entries linked with the task\\n entries = Journal.objects.filter(task__id=task_id).order_by('-date')\\n return render(request, \\\"task.html\\\", locals())\\n else:\\n # redirect to the linked project to the project list page if the user is not allowed to see the task\\n return redirect(\\\"projects\\\")\",\n \"def log_requests(response):\\n ts = strftime('[%Y-%b-%d %H:%M-%S]')\\n\\n logger.info('Flask: {0} {1} {2} {3} {4} {5}'.\\n format(ts, request.remote_addr, request.method, request.scheme, request.full_path, response.status))\\n\\n return response\",\n \"def log(self):\\n resp = requests.get(\\\"%s/api/log\\\"%self.urlbase, verify=False)\\n return resp.json[\\\"log\\\"]\",\n \"def emit(self, record):\\n log_entry = self.format(record)\\n try: \\n requests.post(self.host+self.url, log_entry,headers={\\\"Content-type\\\": \\\"application/json\\\"}).content\\n except Exception as e:\\n if self.debug:\\n print(e)\",\n \"def task_update_stats(request):\\n tasks = json.loads(request.POST.get('tasks'))\\n date_str = request.POST.get('date')\\n cursor = ndb.Cursor(urlsafe=request.POST.get('cursor'))\\n countdown = 15\\n if not tasks:\\n msg = 'Nothing to execute!?'\\n logging.warning(msg)\\n out = HttpTextResponse(msg)\\n else:\\n # Dispatch the task to execute.\\n task = tasks.pop(0)\\n logging.info('Running %s.', task)\\n if task.count('-') == 2:\\n out, cursor = update_daily_stats(\\n cursor, datetime.datetime.strptime(task, DATE_FORMAT))\\n elif task == 'monthly':\\n # The only reason day is used is in case a task queue spills over the next\\n # day.\\n day = datetime.datetime.strptime(date_str, DATE_FORMAT)\\n out, cursor = update_monthly_stats(cursor, day)\\n elif task == '30':\\n yesterday = (\\n datetime.datetime.strptime(date_str, DATE_FORMAT)\\n - datetime.timedelta(days=1)).date()\\n out, cursor = update_rolling_stats(cursor, yesterday)\\n else:\\n msg = 'Unknown task %s, ignoring.' % task\\n cursor = ''\\n logging.error(msg)\\n out = HttpTextResponse(msg)\\n\\n if cursor:\\n # Not done yet!\\n tasks.insert(0, task)\\n countdown = 0\\n\\n if out.status_code == 200 and tasks:\\n logging.info('%d tasks to go!\\\\n%s', len(tasks), ', '.join(tasks))\\n # Space out the task queue execution by 15s to reduce the risk of\\n # datastore inconsistency to get in the way, since no transaction is used.\\n # This means to process a full month, it'll include 31*15s = 7:45 minutes\\n # delay. 15s is not a lot but we are in an hurry!\\n taskqueue.add(\\n url=reverse(task_update_stats),\\n params={\\n 'tasks': json.dumps(tasks),\\n 'date': date_str,\\n 'cursor': cursor.urlsafe() if cursor else ''},\\n queue_name='update-stats',\\n countdown=countdown)\\n return out\",\n \"def handler(context, event):\\n\\n if _ensure_str(event.trigger.kind) != 'http' or _invoked_by_cron(event):\\n body = event.body.decode('utf-8')\\n context.logger.info('Received event body: {0}'.format(body))\\n\\n # serialized record\\n serialized_record = json.dumps({\\n 'body': body,\\n 'headers': {\\n _ensure_str(header): _ensure_str(value)\\n for header, value in event.headers.items()\\n },\\n 'timestamp': datetime.datetime.utcnow().isoformat(),\\n })\\n\\n # store in log file\\n with open(events_log_file_path, 'a') as events_log_file:\\n events_log_file.write(serialized_record + ', ')\\n\\n else:\\n\\n # read the log file\\n try:\\n with open(events_log_file_path, 'r') as events_log_file:\\n events_log_file_contents = events_log_file.read()\\n except IOError:\\n events_log_file_contents = ''\\n\\n # make this valid JSON by removing last two chars (, ) and enclosing in [ ]\\n encoded_event_log = '[' + events_log_file_contents[:-2] + ']'\\n\\n context.logger.info('Returning events: {0}'.format(encoded_event_log))\\n\\n # return json.loads(encoded_event_log)\\n return encoded_event_log\",\n \"def __call__(self, request):\\n request.start_time = time.time()\\n\\n response = self.get_response(request)\\n\\n log_data = self.extract_log_info(request=request, response=response)\\n logger.info(log_data)\\n\\n return response\",\n \"def get(self, request):\\n feedback = {\\n 'permission': True\\n }\\n try:\\n task_id = request.GET.get('task_id', None)\\n if task_id is None:\\n feedback['data'] = ErrorCode.parameter_missing('task_id')\\n raise natrix_exception.ParameterMissingException(parameter='task_id')\\n try:\\n uuid.UUID(hex=task_id)\\n task = Task.objects.get(id=task_id, time_type='instant')\\n\\n serializer = task_serializer.InstantTaskSerializer(instance=task)\\n feedback['data'] = {\\n 'code': 200,\\n 'message': u'Instant Task Info!',\\n 'info': serializer.data\\n }\\n except ValueError:\\n feedback['data'] = ErrorCode.parameter_invalid('task_id', reason=u'must be a UUID')\\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\\n except Task.DoesNotExist:\\n feedback['data'] = ErrorCode.parameter_invalid(\\n 'task_id', reason=u'Can not retrieve Instant Task: {}'.format(task_id))\\n raise natrix_exception.ParameterInvalidException(parameter='task_id')\\n except natrix_exception.NatrixBaseException as e:\\n logger.error(e.get_log())\\n feedback['data'] = ErrorCode.sp_code_bug('Serializer error: {}'.format(e.get_log()))\\n except Exception as e:\\n logger.error(e)\\n feedback['data'] = ErrorCode.sp_code_bug('Unknow error: {}'.format(e))\\n\\n except natrix_exception.NatrixBaseException as e:\\n logger.info(e.get_log())\\n\\n return JsonResponse(data=feedback)\",\n \"def log():\\n data = {}\\n log = {}\\n log['dia'] = date.today().strftime(\\\"%d/%m/%Y\\\")\\n log['info'] = ('Rooms IP: %s %s %s')%(request.remote_addr,request.method, request.url)\\n data['data'] = log\\n try:\\n r = requests.post(uri, json=data)\\n except requests.exceptions.RequestException as e:\\n print(e)\\n print(\\\"\\\\n\\\\nThe microservice Log is unvailable. The Log is %s.\\\"%(log['info']))\\n else:\\n if r.status_code == 200:\\n print(\\\"Register Log was a success\\\")\\n else:\\n print(\\\"Register Log was an unsuccess\\\")\",\n \"def logs(filename):\\n\\n if not re.search(\\\".log\\\",filename):\\n print(\\\"ERROR: API (log): file requested was not a log file: {}\\\".format(filename))\\n return jsonify([])\\n\\n log_dir = os.path.join(\\\".\\\",\\\"logs\\\")\\n if not os.path.isdir(log_dir):\\n print(\\\"ERROR: API (log): cannot find log dir\\\")\\n return jsonify([])\\n\\n file_path = os.path.join(log_dir,filename)\\n if not os.path.exists(file_path):\\n print(\\\"ERROR: API (log): file requested could not be found: {}\\\".format(filename))\\n return jsonify([])\\n \\n return send_from_directory(log_dir, filename, as_attachment=True)\",\n \"def post(self):\\n required_keys = [\\\"event_name\\\", \\\"timestamp\\\"]\\n\\n verify_log_request(request, required_keys)\\n\\n args = request.json\\n\\n # The event log API should enforce the player_id to the current player, unless\\n # the user has role \\\"service\\\" in which case it should only set the player_id if\\n # it's not passed in the event.\\n player_id = current_user[\\\"player_id\\\"]\\n is_service = \\\"service\\\" in current_user[\\\"roles\\\"]\\n\\n for event in args:\\n if is_service:\\n event.setdefault(\\\"player_id\\\", player_id)\\n else:\\n event[\\\"player_id\\\"] = player_id # Always override!\\n eventlogger.info(\\\"eventlog\\\", extra={\\\"extra\\\": event})\\n\\n if request.headers.get(\\\"Accept\\\") == \\\"application/json\\\":\\n return jsonify(status=\\\"OK\\\"), http_client.CREATED\\n else:\\n return \\\"OK\\\", http_client.CREATED\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6197851","0.607282","0.5970462","0.59704053","0.5964452","0.59584445","0.58986974","0.581812","0.5806979","0.57502735","0.5739828","0.5729748","0.56855357","0.5676162","0.56016225","0.5558941","0.55346864","0.5530376","0.5528069","0.5521597","0.55141115","0.55043185","0.5489925","0.54873353","0.5477448","0.54721117","0.5465144","0.5452415","0.5424725","0.54232985","0.5389935","0.5370344","0.53666204","0.53617585","0.53460264","0.5327624","0.5315801","0.5313515","0.5305091","0.53029543","0.52972245","0.52858084","0.52809507","0.52331847","0.5219855","0.5206898","0.5198591","0.5182325","0.5179032","0.5176933","0.5176933","0.5176145","0.51651084","0.51641816","0.51618576","0.5157578","0.5155968","0.51275575","0.5125544","0.51201457","0.51027304","0.50943387","0.5091336","0.50828934","0.50817466","0.5077471","0.5071326","0.50679433","0.50478995","0.5042177","0.5040857","0.50269663","0.50210786","0.5020316","0.5018856","0.5002045","0.49890888","0.49874264","0.4978943","0.4974672","0.49729383","0.49699292","0.49689648","0.4963783","0.49617487","0.49606404","0.49575412","0.49564022","0.49553105","0.49543998","0.49532443","0.49526498","0.49459982","0.49380606","0.493154","0.49290428","0.49182305","0.49178123","0.49167195","0.49166927"],"string":"[\n \"0.6197851\",\n \"0.607282\",\n \"0.5970462\",\n \"0.59704053\",\n \"0.5964452\",\n \"0.59584445\",\n \"0.58986974\",\n \"0.581812\",\n \"0.5806979\",\n \"0.57502735\",\n \"0.5739828\",\n \"0.5729748\",\n \"0.56855357\",\n \"0.5676162\",\n \"0.56016225\",\n \"0.5558941\",\n \"0.55346864\",\n \"0.5530376\",\n \"0.5528069\",\n \"0.5521597\",\n \"0.55141115\",\n \"0.55043185\",\n \"0.5489925\",\n \"0.54873353\",\n \"0.5477448\",\n \"0.54721117\",\n \"0.5465144\",\n \"0.5452415\",\n \"0.5424725\",\n \"0.54232985\",\n \"0.5389935\",\n \"0.5370344\",\n \"0.53666204\",\n \"0.53617585\",\n \"0.53460264\",\n \"0.5327624\",\n \"0.5315801\",\n \"0.5313515\",\n \"0.5305091\",\n \"0.53029543\",\n \"0.52972245\",\n \"0.52858084\",\n \"0.52809507\",\n \"0.52331847\",\n \"0.5219855\",\n \"0.5206898\",\n \"0.5198591\",\n \"0.5182325\",\n \"0.5179032\",\n \"0.5176933\",\n \"0.5176933\",\n \"0.5176145\",\n \"0.51651084\",\n \"0.51641816\",\n \"0.51618576\",\n \"0.5157578\",\n \"0.5155968\",\n \"0.51275575\",\n \"0.5125544\",\n \"0.51201457\",\n \"0.51027304\",\n \"0.50943387\",\n \"0.5091336\",\n \"0.50828934\",\n \"0.50817466\",\n \"0.5077471\",\n \"0.5071326\",\n \"0.50679433\",\n \"0.50478995\",\n \"0.5042177\",\n \"0.5040857\",\n \"0.50269663\",\n \"0.50210786\",\n \"0.5020316\",\n \"0.5018856\",\n \"0.5002045\",\n \"0.49890888\",\n \"0.49874264\",\n \"0.4978943\",\n \"0.4974672\",\n \"0.49729383\",\n \"0.49699292\",\n \"0.49689648\",\n \"0.4963783\",\n \"0.49617487\",\n \"0.49606404\",\n \"0.49575412\",\n \"0.49564022\",\n \"0.49553105\",\n \"0.49543998\",\n \"0.49532443\",\n \"0.49526498\",\n \"0.49459982\",\n \"0.49380606\",\n \"0.493154\",\n \"0.49290428\",\n \"0.49182305\",\n \"0.49178123\",\n \"0.49167195\",\n \"0.49166927\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60648406"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":6392,"cells":{"query":{"kind":"string","value":"Access token auth logic."},"document":{"kind":"string","value":"def authenticate(self, request=None, **kwargs):\n if request is None:\n return None\n\n access_token = jwt_utils.get_access_token_by_request(request)\n\n if access_token is None:\n return None\n\n try:\n payload = jwt_utils.jwt_decode(access_token)\n\n except DecodeError:\n raise PermissionDenied()\n\n user = User.objects.get_user_or_none(pk=payload.get('sub'))\n\n if not user:\n return None\n\n access_token_is_active = user.refresh_tokens.access_token_is_active(jti=payload['jti'])\n return user if access_token_is_active else None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def auth_token(self):","def do_auth(self, access_token, *args, **kwargs):\n data = self.user_data(access_token)\n data['access_token'] = access_token\n kwargs.update(data)\n kwargs.update({'response': data, 'backend': self})\n return self.strategy.authenticate(*args, **kwargs)","def get_access_token():\n if request.method == \"GET\":\n return render_template(\"index.html\")\n elif request.method == \"POST\":\n # Authenticate\n auth = Authorization()\n response = auth.post()\n return render_template(\"index.html\", data=response[0])","def authenticate( self ):\n\n print(\"Getting new token\")\n self.getFrob()\n self.getAuthKey()\n self.getToken()\n self.cacheToken()","def authorize_access_token(self, request, **kwargs):\n params = self.retrieve_access_token_params(request)\n params.update(kwargs)\n return self.fetch_access_token(**params)","def get_access_token(self):\n logger.info('Try to get access token via OAuth')\n\n if self.user_login and not self.user_password:\n # Need user password\n pass\n\n if not self.user_login and self.user_password:\n # Need user login\n pass\n\n auth_session = requests.Session()\n\n login_form_response = auth_session.get(self.LOGIN_URL)\n\n login_form_action = re.findall(r'<form ?.* action=\"(.+)\"', login_form_response.text)\n if not login_form_action:\n raise VkAuthorizationError('vk.com changed login flow')\n\n # Login\n login_form_data = {\n 'email': self.user_login,\n 'pass': self.user_password,\n }\n\n response = auth_session.post(login_form_action[0], login_form_data)\n\n logger.info('Cookies %s', auth_session.cookies)\n logger.info('Login response url %s', response.url)\n\n if 'remixsid' in auth_session.cookies or 'remixsid6' in auth_session.cookies:\n pass\n elif 'sid=' in response.url:\n self.auth_captcha_is_needed(response.content, auth_session)\n elif 'act=authcheck' in response.url:\n self.auth_code_is_needed(response.content, auth_session)\n elif 'security_check' in response.url:\n self.phone_number_is_needed(response.content, auth_session)\n else:\n raise VkAuthorizationError('Authorization error (bad password)')\n\n # OAuth2\n oauth_data = {\n 'response_type': 'token',\n 'client_id': self.app_id,\n 'scope': self.scope,\n 'display': 'mobile',\n }\n response = auth_session.post('https://oauth.vk.com/authorize', oauth_data)\n logger.info('OAuth URL: %s %s', response.request.url, oauth_data)\n\n if 'access_token' not in response.url:\n form_action = re.findall(u'<form method=\"post\" action=\"(.+?)\">', response.text)\n if form_action:\n response = auth_session.get(form_action[0])\n else:\n try:\n json_data = response.json()\n except ValueError: # not json in response\n error_message = 'OAuth2 grant access error'\n else:\n error_message = 'VK error: [{0}] {1}'.format(\n json_data['error'],\n json_data['error_description']\n )\n auth_session.close()\n raise VkAuthorizationError(error_message)\n\n auth_session.close()\n\n parsed_url = urlparse(response.url)\n logger.info('Parsed URL: %s', parsed_url)\n\n token_dict = dict(parse_qsl(parsed_url.fragment))\n if 'access_token' in token_dict:\n self.access_token = token_dict['access_token']\n self.access_token_expires_in = token_dict['expires_in']\n else:\n raise VkAuthorizationError('OAuth2 authorization error')","def accessCheck(self) -> None:\n\n if self.access_token:\n return\n self.access_token = self.login()","def auth(self):\n ok = False\n if self.private_token:\n ok = self.token_auth()\n if not ok:\n self.credentials_auth()","def do_auth(self, access_token, *args, **kwargs):\n data = self.user_data(access_token, *args, **kwargs)\n response = kwargs.get('response') or {}\n response.update(data or {})\n if 'access_token' not in response:\n response['access_token'] = access_token\n kwargs.update({'response': response, 'backend': self})\n return self.strategy.authenticate(*args, **kwargs)","def do_auth(self, access_token, *args, **kwargs):\n data = self.user_data(access_token, *args, **kwargs)\n response = kwargs.get('response') or {}\n response.update(data or {})\n if 'access_token' not in response:\n response['access_token'] = access_token\n kwargs.update({'response': response, 'backend': self})\n return self.strategy.authenticate(*args, **kwargs)","def _authenticate(self):\n if self.creds().consumer_key() is None or \\\n self.creds().app_secret() is None:\n self.logger.error(\"You need a consumer key and app secret, yo\")\n else:\n self._access_token = self._request_access_token()","def test_read_o_auth_access_token(self):\n pass","def authenticate(self):\n try:\n self._token = self._lookup_token()\n except:\n raise HTTPError(\n \"Unable to get short-lived access token for cyberark storage\"\n )","def _validate_token(self):\n if not self.token:\n self.login()\n if not self.token:\n # TODO: create exception for this\n # Access is denied!!\n raise Exception(\"AccessDenied\")","def __call__(self, access_token):","def authenticate(self):\n # Check if we already have access token and secret\n if not os.path.exists(self.sTOKEN_FILE):\n # 1) Obtain Request token\n oauth = OAuth1(self.apiKey, client_secret=self.apiKeySecret, callback_uri='oob')\n r = requests.post(url=self.sREQUEST_TOKEN_URL, auth=oauth)\n credentials = parse_qs(r.content)\n resource_owner_key = credentials.get('oauth_token')[0]\n resource_owner_secret = credentials.get('oauth_token_secret')[0]\n\n # 2) Obtain authorization for the user to access resources\n # Redirect the user to /authorize and get the callback\n authorize_url = self.sAUTHORIZE_URL + '?oauth_token=' + resource_owner_key + \\\n '&oauth_consumer_key=' + self.apiKey + \\\n '&Access=Full&Permissions=Modify'\n\n print 'Please go here and authorize,', authorize_url\n verifier = raw_input('Please enter the six-digit PIN code: ')\n\n # 3) Obtain final access token\n oauth = OAuth1(self.apiKey, client_secret = self.apiKeySecret,\n resource_owner_key = resource_owner_key,\n resource_owner_secret = resource_owner_secret,\n verifier=verifier)\n r = requests.post(url=self.sACCESS_TOKEN_URL, auth=oauth)\n\n credentials = parse_qs(r.content)\n access_token = credentials.get('oauth_token')[0]\n access_token_secret = credentials.get('oauth_token_secret')[0]\n\n # Store access token so we can use it later\n with open(self.sTOKEN_FILE, 'w') as f:\n json.dump({'access_token': access_token,\n 'access_token_secret': access_token_secret}, f)\n\n else:\n with open(self.sTOKEN_FILE, 'r') as f:\n tokens = json.load(f)\n access_token = tokens.get('access_token')\n access_token_secret = tokens.get('access_token_secret')\n\n # store the file access token details for use in other methods\n self.accessToken = access_token\n self.accessTokenSecret = access_token_secret","def Access(self):\n if datetime.now() < self.access_exp:\n pass\n elif datetime.now() > self.access_exp and datetime.now() < self.refresh_exp:\n grant = 'refresh_token'\n self._postRequest(grant=grant)\n elif datetime.now() > self.refresh_exp:\n grant = 'authorization_code'\n self._getURLcode()\n self._postRequest(grant=grant)","def authenticate(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n access_token = request.headers.get('token', '')\n if access_token.strip(' '):\n decoded = decode_token(access_token)\n if decoded['status']:\n return func(*args, **kwargs)\n abort(http_status_code=401, message='Invalid token.Please login')\n abort(http_status_code=401,\n message='Token is missing')\n return wrapper","def _authenticate(self):\n url = self.endpoint + \"/tokens\"\n h = httplib2.Http()\n response, rawcontent = h.request(\n url, \n method=\"POST\",\n headers={ \"Content-Type\":\"application/json\" },\n body=json.dumps(self.credentials()))\n content = json.loads(rawcontent)\n self.token = content['access']['token']['id']\n #TODO: this needs to convert the ISO8601 string to a timestamp\n self.expiration = content['access']['token']['expires']\n self.catalog = content['access']['serviceCatalog']","def auth():\n pass","def auth():\n pass","def authenticate(self, request):\n if 'credentials' not in request.session:\n raise LoginRequired()\n self.credentials = client.OAuth2Credentials.from_json(\n request.session['credentials'])\n if self.credentials.access_token_expired:\n raise LoginRequired()","def check_auth():","async def login_access_token(\n form_data: OAuth2PasswordRequestForm = Depends()\n):\n user = await crud.user.authenticate(\n username=form_data.username, password=form_data.password\n )\n if not user:\n raise HTTPException(status_code=HTTP_404_NOT_FOUND, detail=\"Incorrect credentials\")\n elif not user.is_active:\n raise HTTPException(status_code=HTTP_403_FORBIDDEN, detail=\"Inactive user\")\n elif not user.is_email_verified:\n raise HTTPException(status_code=HTTP_403_FORBIDDEN, detail=\"Please verify your account via email\")\n access_token_expires = timedelta(minutes=config.ACCESS_TOKEN_EXPIRE_MINUTES)\n return {\n \"access_token\": create_access_token(\n data={\"user_id\": user.id}, expires_delta=access_token_expires\n ),\n \"token_type\": \"bearer\",\n }","def auth(self):\n return self.api(self.token)","def authenticate(self):\n #it's weird i have to do this here, but the code makes this not simple\n auth_json={'email':self.user, 'password':self.password}\n #send a post with no auth. prevents an infinite loop\n auth_response = self.post('/auth', data = json.dumps(auth_json), auth =\n None)\n\n _token = auth_response.json['token']\n\n self._token = _token\n self._wrapped.auth = SpringAuth(_token)","async def authorize(self):\n # TODO: make several attempts for each step\n html = await self.get_auth_page()\n url, html = await self.process_auth_form(html)\n q = urllib.parse.urlparse(url)\n if q.path == '/authorize': # invalid login or password\n url, html = await self.process_auth_form(html)\n q = urllib.parse.urlparse(url)\n if q.path == '/login':\n url, html = await self.process_2auth_form(html)\n q = urllib.parse.urlparse(url)\n if q.path == '/login':\n url, html = await self.process_2auth_form(html)\n q = urllib.parse.urlparse(url)\n if q.path == '/authorize': # give rights for app\n url, html = await self.process_access_form(html)\n q = urllib.parse.urlparse(url)\n if q.path == '/blank.html':\n qs = dict(urllib.parse.parse_qsl(q.fragment))\n self.access_token = qs['access_token']","def _authorize(self, token=None, store_token=False, reenter_token=False): # pragma: no cover\n\n if token is None and \"MAST_API_TOKEN\" in os.environ:\n token = os.environ[\"MAST_API_TOKEN\"]\n\n if token is None:\n token = keyring.get_password(\"astroquery:mast.stsci.edu.token\", \"masttoken\")\n\n if token is None or reenter_token:\n auth_server = conf.server.replace(\"mast\", \"auth.mast\")\n auth_link = auth_server + \"/token?suggested_name=Astroquery&suggested_scope=mast:exclusive_access\"\n info_msg = \"If you do not have an API token already, visit the following link to create one: \"\n log.info(info_msg + auth_link)\n token = getpass(\"Enter MAST API Token: \")\n\n # store password if desired\n if store_token:\n keyring.set_password(\"astroquery:mast.stsci.edu.token\", \"masttoken\", token)\n\n self._session.headers[\"Accept\"] = \"application/json\"\n self._session.cookies[\"mast_token\"] = token\n info = self.session_info(silent=True)\n\n if not info[\"anon\"]:\n log.info(\"MAST API token accepted, welcome %s\" % info[\"attrib\"].get(\"display_name\"))\n else:\n log.warn(\"MAST API token invalid!\")\n\n return not info[\"anon\"]","def getAccessToken(self):\r\n\r\n #lets see if we have an oauth code\r\n if self.oauthToken is None:\r\n self.oauthToken = self.createAccessToken\r\n\r\n if self.oauthToken.isExpired(): #check to see if its expired if so refresh it\r\n self.oauthToken = self.refreshAccessToken()\r\n\r\n return self.oauthToken #return out access token\r","def authorize(self):\n login_data = {\n 'username': self.username,\n 'password': self.password,\n }\n r = requests.post(f'{self.api_host}/auth', json=login_data)\n\n if r.status_code == 200:\n CentralStorageClient.token = r.json()['access_token']\n\n return True\n\n return False","def auth(request):\n\n if('username' in request.POST and 'password' in request.POST):\n user = authenticate(\n username=request.POST['username'],\n password=request.POST['password'],\n )\n if(user):\n token = Token(user = user)\n token.generateToken()\n token.save()\n data = {}\n data['token'] = token.value\n data['expiry'] = token.expiry\n data['valid'] = token.isValid()\n return JsonResponse(data) \n \n return HttpResponseBadRequest('Username and password must be supplied')","def post(self):\r\n try:\r\n\r\n data = request.get_json()\r\n user = user_login.find_by_username(data['username'])\r\n if user and safe_str_cmp(user.password, data['password']):\r\n access_token = create_access_token(\r\n identity=user.id, fresh=True)\r\n return {\r\n 'access_token': \"Bearer \" + access_token,\r\n }, 200\r\n return {\"message\": \"Invalid Credentials!\"}, 401\r\n except Exception as e:\r\n return {\"message\": str(e)}","def auth_user():\n global token\n app.logger.info(\"Microsoft Planner Service running on /auth port as expected\")\n try:\n request_count = 0\n if request_count == 0:\n token = get_tokens_as_app(client_id, user_code_info, tenant_id)\n request_count = 1 \n if 'access_token' in token:\n app.logger.info('Adding access token to cache...')\n add_token_to_cache(client_id, tenant_id, token)\n return_object = (f\"{token['refresh_token']}\")\n return render_template('token.html', return_object=return_object)\n else:\n return_error = (\"Token response did not result in a proper response. Athenticate again please.\")\n return render_template('token.html', return_error=return_error)\n except AttributeError or TypeError:\n return_error = ('Authentification failed. Please pull and restart your system and authenticate again.')\n return render_template('token.html', return_error=return_error)\n except adal.AdalError as err:\n return_error = (\"You're logged in with the wrong user. Please log out and authenticate again.\")\n return render_template('token.html', return_error=return_error)","def test_list_o_auth_access_token(self):\n pass","async def login_for_access_token(\n form_data: OAuth2PasswordRequestForm = Depends()\n):\n user = authenticate_user(form_data.username, form_data.password)\n if not user:\n raise HTTPException(\n status_code=status.HTTP_401_UNAUTHORIZED,\n detail=\"Incorrect username or password\",\n headers={\"WWW-Authenticate\": \"Bearer\"},\n )\n access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)\n access_token = create_access_token(\n data={\"sub\": user.username}, expires_delta=access_token_expires\n )\n return {\"access_token\": access_token, \"token_type\": \"bearer\"}","def _get_auth_value(self):\n if not self._access_token:\n try:\n # get the local access token using gcloud\n cmd = ['gcloud', 'auth', 'print-access-token']\n if self._user_email:\n cmd.append(self._user_email)\n\n self._logger.debug(f\"get gcloud_access_token {cmd}\")\n p = Popen(cmd, stdout=PIPE, stderr=PIPE)\n gcloud_access_token, stderr = p.communicate()\n gcloud_access_token = gcloud_access_token.decode(\"utf-8\").rstrip()\n assert len(gcloud_access_token) > 0, f'get gcloud_access_token MUST have an access token {stderr}'\n self._logger.debug(f\"gcloud_access_token {gcloud_access_token}\")\n # authenticate to terra, ask for fence/accesstoken\n headers = {'Authorization': f'Bearer {gcloud_access_token}'}\n r = requests.get(self._terra_auth_url, headers=headers)\n assert r.status_code == 200, f'MUST respond with 200 {self._terra_auth_url} {r.text}'\n self._logger.debug(r.text)\n terra_access_token = r.json()\n assert len(terra_access_token['token']) > 0, 'MUST have an access token'\n assert len(terra_access_token['expires_at']) > 0, 'MUST have an expires_at '\n\n expires_at = datetime.fromisoformat(terra_access_token['expires_at'])\n now = datetime.now()\n assert expires_at > now, 'expires_at MUST be in the future'\n\n self._access_token = terra_access_token['token']\n\n if self._logger.level == logging.DEBUG:\n self._logger.debug(f'Terra access token expires in {str(expires_at - now)}')\n self._logger.debug(self._access_token)\n # add padding\n self._logger.debug(base64.b64decode(self._access_token.split('.')[1] + \"===\"))\n\n except Exception as e:\n raise AnVILAuthError(\n \"Failed to authenticate to {}\\n{}\".format(self._terra_auth_url, str(e))\n )\n\n return \"Bearer \" + self._access_token","async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):\n user = example_user_validator(form_data.username, form_data.password)\n if not user:\n raise HTTPException(\n status_code=status.HTTP_401_UNAUTHORIZED,\n detail=\"Incorrect username or password\",\n headers={\"WWW-Authenticate\": \"Bearer\"},\n )\n access_token_data = jwt_claims.copy()\n access_token_data[\"sub\"] = user[\"username\"]\n access_token_data[\"exp\"] = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)\n access_token_data[\"jti\"] = str(uuid.uuid4())\n\n refresh_token_data = jwt_claims.copy()\n refresh_token_data[\"sub\"] = user[\"username\"]\n refresh_token_data[\"exp\"] = datetime.utcnow() + timedelta(days=REFRESH_TOKEN_EXPIRE_DAYS)\n refresh_token_data[\"type\"] = \"refresh\"\n refresh_token_data[\"jti\"] = str(uuid.uuid4())\n\n return AccessRefreshToken(\n access_token=jwt.encode(access_token_data, SECRET_KEY, algorithm=ALGORITHM),\n refresh_token=jwt.encode(refresh_token_data, SECRET_KEY, algorithm=ALGORITHM)\n )","def auth(self):\n if self.get_saved_token():\n return\n self.oauth2()\n self.save_token()","def get_access_token(self):\n\n token_work = time.time() < self.expires\n\n if token_work:\n # No need update token\n return self.access_token\n\n data = {\n 'client_id': self.client_id,\n 'grant_type': 'implicit'\n }\n\n response = requests.post('https://api.moltin.com/oauth/access_token', data=data)\n raise_response_errors(response)\n\n response_json = response.json()\n\n self.access_token = response_json['access_token']\n self.expires = response_json['expires']\n\n logger.debug('elasticpathh access token was updated')\n\n return self.access_token","def _require_login(self):\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + str(self.token))","def get_access_token(request):\n user = request.user\n flow = _create_flow(request)\n\n flow.params['state'] = _build_state_value(request, user)\n credentials = StorageByKeyName(\n CredentialsNDBModel, user.user_id(), 'credentials').get()\n\n authorize_url = flow.step1_get_authorize_url()\n redirect_response_object = HttpResponseRedirect(authorize_url)\n if credentials is None or credentials.invalid:\n return redirect_response_object\n\n # Find out if credentials is expired\n refresh_failed = False\n if credentials.access_token is None or credentials.access_token_expired:\n try:\n credentials.refresh(httplib2.Http())\n except AccessTokenRefreshError:\n return redirect_response_object\n except Exception:\n refresh_failed = True\n\n port_value = _validate_port(request.GET.get('port'))\n if port_value is None:\n return HttpTextResponse('Access Token: %s' % (credentials.access_token,))\n\n # Send access token along to localhost client\n redirect_template_args = {'port': port_value}\n if refresh_failed:\n quoted_error = urllib.quote(OAUTH_DEFAULT_ERROR_MESSAGE)\n redirect_template_args['error'] = quoted_error\n client_uri = ACCESS_TOKEN_FAIL_REDIRECT_TEMPLATE % redirect_template_args\n else:\n quoted_access_token = urllib.quote(credentials.access_token)\n redirect_template_args['token'] = quoted_access_token\n client_uri = ACCESS_TOKEN_REDIRECT_TEMPLATE % redirect_template_args\n\n return HttpResponseRedirect(client_uri)","def login_access_token(\n db: Session = Depends(get_db),\n form_data: OAuth2PasswordRequestForm = Depends()\n) -> Any:\n user = crud.user.authenticate(\n db, email=form_data.username, password=form_data.password\n )\n if not user:\n raise HTTPException(\n status_code=400, detail=\"Incorrect email or password\")\n elif not crud.user.is_active(user):\n raise HTTPException(status_code=400, detail=\"Inactive user\")\n access_token_expires = timedelta(\n minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)\n return {\n \"access_token\": security.create_access_token(\n user.id, expires_delta=access_token_expires\n ),\n \"token_type\": \"bearer\",\n }","def access_token(*args, **kwargs):\n return None","def get_access_token(request):\n user = request.user\n flow = _create_flow(request)\n\n flow.params['state'] = _build_state_value(request, user)\n credentials = StorageByKeyName(\n CredentialsNDBModel, user.user_id(), 'credentials').get()\n\n authorize_url = flow.step1_get_authorize_url()\n redirect_response_object = HttpResponseRedirect(authorize_url)\n if credentials is None or credentials.invalid:\n return redirect_response_object\n\n # Find out if credentials is expired\n refresh_failed = False\n if credentials.access_token is None or credentials.access_token_expired:\n try:\n credentials.refresh(httplib2.Http())\n except AccessTokenRefreshError:\n return redirect_response_object\n except:\n refresh_failed = True\n\n port_value = _validate_port(request.GET.get('port'))\n if port_value is None:\n return HttpTextResponse('Access Token: %s' % (credentials.access_token,))\n\n # Send access token along to localhost client\n redirect_template_args = {'port': port_value}\n if refresh_failed:\n quoted_error = urllib.quote(OAUTH_DEFAULT_ERROR_MESSAGE)\n redirect_template_args['error'] = quoted_error\n client_uri = ACCESS_TOKEN_FAIL_REDIRECT_TEMPLATE % redirect_template_args\n else:\n quoted_access_token = urllib.quote(credentials.access_token)\n redirect_template_args['token'] = quoted_access_token\n client_uri = ACCESS_TOKEN_REDIRECT_TEMPLATE % redirect_template_args\n\n return HttpResponseRedirect(client_uri)","def test_valid_access_request(self):\n\n # Generate a valid auth token\n with base.HybridSessionManager():\n authorization_code = auth_api.authorization_code_save({\n 'user_id': 2,\n 'state': 'test_state',\n 'code': 'test_valid_code'\n })\n\n content_type = 'application/x-www-form-urlencoded'\n # POST with content: application/x-www-form-urlencoded\n response = self.app.post('/v1/openid/token',\n params={\n 'code': authorization_code.code,\n 'grant_type': 'authorization_code'\n },\n content_type=content_type,\n expect_errors=True)\n\n # Assert that this is a successful response\n self.assertEqual(200, response.status_code)\n\n # Assert that the token came back in the response\n token = response.json\n self.assertIsNotNone(token['access_token'])\n self.assertIsNotNone(token['expires_in'])\n self.assertIsNotNone(token['id_token'])\n self.assertIsNotNone(token['refresh_token'])\n self.assertIsNotNone(token['token_type'])\n self.assertEqual('Bearer', token['token_type'])\n\n # Assert that the access token is in the database\n with base.HybridSessionManager():\n access_token = \\\n token_api.access_token_get_by_token(token['access_token'])\n self.assertIsNotNone(access_token)\n\n # Assert that system configured values is owned by the correct user.\n self.assertEqual(2, access_token.user_id)\n self.assertEqual(token['id_token'], access_token.user_id)\n self.assertEqual(token['expires_in'], CONF.oauth.access_token_ttl)\n self.assertEqual(token['expires_in'], access_token.expires_in)\n self.assertEqual(token['access_token'], access_token.access_token)\n\n # Assert that the refresh token is in the database\n with base.HybridSessionManager():\n refresh_token = \\\n refresh_tokens.refresh_token_get_by_token(\n token['refresh_token'])\n\n self.assertIsNotNone(refresh_token)\n\n # Assert that system configured values is owned by the correct user.\n self.assertEqual(2, refresh_token.user_id)\n self.assertEqual(CONF.oauth.refresh_token_ttl,\n refresh_token.expires_in)\n self.assertEqual(token['refresh_token'], refresh_token.refresh_token)\n\n # Assert that the authorization code is no longer in the database.\n with base.HybridSessionManager():\n none_code = \\\n auth_api.authorization_code_get(authorization_code.code)\n self.assertIsNone(none_code)","def authentication_request():\n # Get the access token from the header\n auth_header = request.headers.get('Authorization')\n if auth_header:\n try:\n access_token = auth_header.split(' ')[1]\n except IndexError:\n return {\"message\": \"Token is malformed\"}, status.HTTP_401_UNAUTHORIZED\n else:\n access_token = ''\n\n return access_token","def authn_and_authz():\n authentication()\n authorization()","def authenticate(self, request):\n\n return self._validate_token(request)","def auth_token_api():\n data = request.get_json()\n if not data:\n response = jsonify({\n 'success': False,\n 'message': 'Missing request body'\n })\n response.status_code = 422\n return response\n\n # process argument\n login_type = data.get('auth_type')\n email = data.get('email').strip().lower()\n password = data.get('password')\n\n if not login_type or login_type not in ['email']:\n response = jsonify({\n 'success': False,\n 'message': 'Invalid auth_type'\n })\n response.status_code = 422\n return response\n\n # email authentication\n elif login_type == 'email':\n if not email:\n response = jsonify({\n 'success': False,\n 'message': 'Must provide email when auth_type is \"email\"'\n })\n response.status_code = 422\n return response\n user = db.session.query(User).filter(User.email == email, User.deleted == False).one_or_none()\n if not user:\n response = jsonify({\n 'success': False,\n 'message': 'Not Authorized: invalid email'\n })\n response.status_code = 403\n return response\n # check the user's password\n password_valid = check_password_hash(user.password, password)\n if not password_valid:\n response = jsonify({\n 'success': False,\n 'message': 'Not Authorized: invalid password'\n })\n response.status_code = 403\n return response\n\n token = generate_auth_token(user_id=user.user_id)\n response = jsonify({\n 'success': True,\n 'token': token\n })\n response.status_code == '200'\n return response","def authenticate():\n return Response(\n 'Could not verify your access level for that URL, need token.\\n', 403,\n {'WWW-Authenticate': 'Basic realm=\"token Required\"'})","def login_required(view):\n def check_login(request,*args,**kwds):\n if not request.user.is_authenticated():\n api = FlattrAPI(secrets.FLATTR_API_KEY,secrets.FLATTR_API_SECRET)\n callback = reverse(oauth_callback)\n callback += \"?next=\" + urllib.quote(request.get_full_path(),\"\")\n callback = request.build_absolute_uri(callback)\n (token,url) = api.request_access_token(callback,\"click\")\n print \"OBTAINING REQ TOKEN\", token.key, token.secret\n t = APIToken.objects.create(id=token.key,secret=token.secret)\n t.save()\n print \"REDIRECTING TO\", url\n return HttpResponseRedirect(url)\n return view(request,*args,**kwds)\n return check_login","def auth(request):\n\n service = get_model_instance(request.user, MODULE_NAME)\n if service and request.method == 'POST':\n username = request.POST['username']\n\n # Delete existing token\n AccessToken.objects.filter(service=service).delete()\n # Before creating a new one\n AccessToken.objects.create(\n service=service,\n username=username,\n created=datetime.now(),\n api_token=service.app.oauth.consumer_key\n )\n\n service.setup = True\n service.public = True\n service.save()\n\n return redirect(settings_redirect(request))","def authorize(self) -> None:\n\n if not self.login_secret:\n #TODO trigger error\n self.login()\n \n\n sObj = Splitwise(self.consumer_key, self.consumer_secret)\n self.access_token = sObj.getAccessToken(\n self.oauth_token,\n self.login_secret,\n self.oauth_verifier\n )","def authenticate(self, request=None):\r\n try:\r\n token = request.META.get('HTTP_AUTHORIZATION') or request.REQUEST['key']\r\n accesskey = AccessKey.objects.select_related('user').get(key=token)\r\n request.user = accesskey.user\r\n return request.user and request.user.is_active\r\n\r\n except(KeyError, AccessKey.DoesNotExist):\r\n return False","def test_create_o_auth_access_token(self):\n pass","def request_access_token(self, *args, **kwargs):\n response = super().request_access_token(*args, **kwargs)\n if \"access_token\" not in response:\n response[\"access_token\"] = response[\"id_token\"]\n return response","def auth_code_handler(self, request, pk=None):\n try:\n # Get xero auth access information form xero connection\n stored_values = OAUTH_PERSISTENT_SERVER_STORAGE\n\n\n if len(stored_values) == 0:\n return Utils.dispatch_failure(request, 'NO_TOKEN_AUTHENTICATION')\n\n secret_keys = Utils.get_access_keys(pk)\n if AccountingConfiguration.PRIVATE == secret_keys.type:\n exists = AccountingOauth2.objects.filter(company=pk).first()\n if not exists:\n auth = AccountingOauth2(accessToken=stored_values['consumer_key'],\n accessSecretKey=stored_values['rsa_key'],\n company_id=pk)\n auth.save()\n else:\n exists.accessToken = stored_values['consumer_key']\n exists.accessSecretKey = stored_values['rsa_key']\n exists.save()\n else:\n auth_verifier_uri = settings.XERO_AUTH_VERIFIER_URI\n oauth_verifier = request.GET.get('oauth_verifier')\n credentials = Utils.get_xero_public_credentials(stored_values)\n\n if credentials.expired():\n return Utils.dispatch_failure(request, 'NO_TOKEN_AUTHENTICATION')\n\n # Verify the auth verifier for establish the connection\n\n credentials.verify(oauth_verifier)\n # Resave our verified credentials\n for key, value in credentials.state.items():\n OAUTH_PERSISTENT_SERVER_STORAGE.update({key: value})\n\n stored_values = OAUTH_PERSISTENT_SERVER_STORAGE\n exists = AccountingOauth2.objects.filter(company=pk).first()\n\n if exists:\n exists.accessToken = stored_values['oauth_token']\n exists.realmId = oauth_verifier\n exists.accessSecretKey = stored_values['oauth_token_secret']\n exists.tokenAcitvatedOn = stored_values['oauth_expires_at']\n exists.tokenExpiryON = stored_values['oauth_authorization_expires_at']\n exists.save()\n else:\n auth = AccountingOauth2(accessToken=stored_values['oauth_token'],\n refreshToken='',\n realmId=oauth_verifier,\n accessSecretKey=stored_values['oauth_token_secret'],\n tokenAcitvatedOn=stored_values['oauth_expires_at'],\n tokenExpiryON=stored_values['oauth_authorization_expires_at'],\n company_id=pk)\n auth.save()\n # auth_redirect_url = os.environ.get ('QBO_AUTH_REDIRECT_URL',\n # 'http://localhost:4200/coa-match/quickbooks')\n\n # auth_redirect_url = os.environ.get ('QBO_AUTH_REDIRECT_URL','http://ec2-52-207-28-114.compute-1.amazonaws.com/ix/coa-match/quickbooks')\n\n # return redirect(auth_redirect_url)\n\n except Exception as e:\n auth_cancel_url = settings.QBO_AUTH_CANCEL_URL\n Utils.send_company_misconfig(pk, e)\n return redirect(auth_cancel_url + '/error')\n #return Utils.dispatch_success(request, 'TOKEN_ALREADY_VALIDATED')\n\n auth_redirect_url = settings.XERO_AUTH_REDIRECT_URL\n return redirect(auth_redirect_url)\n # return Utils.dispatch_success(request, stored_values)","def request_access_token():\n\n # For Private application authentication, you must specifiy\n # grant_type=client_credentials and the service scope. For the \n # Content API, scope=contentapi\n post_data = {\"grant_type\": APP_CONFIG['GRANT_TYPE'],\n \"scope\": APP_CONFIG['SCOPE']}\n post_data_string = json.dumps(post_data)\n\n # Construct authentication string:\n # 1. Concatenate the client id, a colon character \":\", and the client secret into a single string\n # 2. URL encode the string from step 1\n # 3. Base64 encode the string from step 2\n authstr = to_native_string(\n b64encode(('%s:%s' % (APP_CONFIG['CLIENT_ID'], APP_CONFIG['CLIENT_SECRET'])).encode('utf-8'))).strip()\n\n # Construct an Authorization header with the value of 'Basic <base64 encoded auth string>'\n headers = {\n \"Content-Type\": \"application/json;charset=UTF-8\",\n \"Accept\": \"application/json\",\n \"Authorization\": \"Basic \" + authstr\n }\n\n r = s.post(APP_CONFIG['OAUTH_TOKEN_URL'], data=post_data_string, headers=headers, verify=(app.config['SSLVERIFY'] == 'True'))\n\n if r.status_code in (400,500):\n\n # Handle known error\n result = r.json() \n return jsonify(result)\n\n elif r.status_code == 200:\n\n result = r.json() \n access_token = result['access_token']\n token_type = result['token_type']\n timestamp = result.get('timestamp', None)\n expires_in = result.get('expires_in', None)\n token_expiry = None\n if expires_in is not None:\n token_expiry = datetime.datetime.strptime(timestamp, '%Y-%m-%dT%H:%M:%S')\n token_expiry = token_expiry + datetime.timedelta(seconds=expires_in)\n token_expiry = token_expiry.isoformat()\n\n html = '<pre>';\n html += '<h3>Successfully retrieved access token!</h3>' \n html += '<pre>';\n html += 'access_token : ' + access_token\n html += '<pre>';\n html += 'token_type : ' + token_type\n html += '<pre>';\n html += 'expires_in (sec) : ' + str(expires_in)\n html += '<pre>';\n html += 'token_expiry : ' + token_expiry\n html += '<pre>';\n html += 'timestamp : ' + timestamp\n\n html += '<pre>';\n html += '<h3>Query Content API with Access Token</h3>'\n html += '<pre>';\n html += '<a href=\"/query-collection-myhuman?access_token='+access_token+'\">Query Collection: myhuman</a>'\n\n return html\n\n else:\n # Handle unknown error\n return (r.text, r.status_code, r.headers.items())","def login_require(request):\n\n if request.method == \"GET\":\n data = request.GET\n else:\n data = request.POST\n user = authenticate(username=data[\"username\"], password=data[\"password\"])\n if user and user.is_active:\n ret = Response(SUCCESS, error_code[SUCCESS])\n else: \n ret = Response(AUTHENTICATION_FAIL, error_code[AUTHENTICATION_FAIL])\n return HttpResponse(ret.serialize(f))\n\n # Generate a token for authentication\n token = token_generator(30)\n try:\n user_token = Token.objects.get(username=data[\"username\"])\n user_token.token = token\n user_token.start_time = datetime.now()\n except: \n user_token = Token(token=token, username=data[\"username\"])\n user_token.save()\n ret.set_ret(\"auth_token\", token) \n user = User.objects.get(username=data[\"username\"])\n ret.set_ret(\"data\", UserSerializer(user.appuser).serialize())\n return HttpResponse(ret.serialize(f))","def add_auth(self, http_request):\r\n pass","def auth(access_token, access_token_secret, consumer_key, consumer_secret):\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token,access_token_secret)\n return auth","def access_token(global_config, existing_user, id_api):\n yield id_api.get_access_token_for_user(existing_user.email, existing_user.password)","def auth_required(handler_method):\n\n def check_auth(self, *args):\n self.userid, self.credentials = load_session_credentials(self)\n self.mirror_service = create_service('mirror', 'v1', self.credentials)\n # TODO: Also check that credentials are still valid.\n if self.credentials:\n try:\n self.credentials.refresh(httplib2.Http())\n return handler_method(self, *args)\n except AccessTokenRefreshError:\n # Access has been revoked.\n store_userid(self, '')\n credentials_entity = Credentials.get_by_key_name(self.userid)\n if credentials_entity:\n credentials_entity.delete()\n self.redirect('/auth')\n return check_auth","def callback__access_token(req, test_env=test_env):\n assert \"Authorization\" in req.headers\n assert req.headers[\"Authorization\"].decode(\"utf-8\").startswith(\"OAuth \")\n assert \"User-Agent\" in req.headers\n assert req.headers[\"User-Agent\"].decode(\"utf-8\") == \"CustomApiClient v0\"\n assert req.url == oauth1_utils.CustomApiClient.OAUTH1_SERVER_ACCESS_TOKEN\n\n # request as SERVER, no cookies\n with IsolatedTestapp(test_env[\"testapp_authority\"]) as testapp:\n _headers = string_headers(\n req.headers\n ) # these can end up being unicode in tests\n res = testapp.get(\n \"/authority/oauth1/access_token\",\n headers=_headers,\n extra_environ=test_env[\"extra_environ_authority\"],\n status=200,\n )\n\n # status is '200 OK'\n # return in a format tailored for `requests`\n return (int(res.status.split(\" \")[0]), res.headers, res.body)","def login(request):\n if request.method != 'POST':\n return JsonResponse(\n {\"detail\": 'Method {} not allowed.'.format(request.method)}, status=status.HTTP_405_METHOD_NOT_ALLOWED\n )\n username = request.POST['username']\n password = request.POST['password']\n if username == 'admin' and password == 'admin':\n payload = {\n \"username\": username,\n \"exp\": time.time() + 300,\n\n }\n token = encode(payload, JWT_KEY, algorithm=\"HS256\")\n return JsonResponse({\"access_token\": token}, status=status.HTTP_200_OK)\n else:\n return JsonResponse({\"detail\": 'Invalid username or password'}, status=status.HTTP_401_UNAUTHORIZED)","def authenticate(self):\n\n headers = {\n 'Authorization': 'Bearer ' + self.access_token,\n 'ClientId': self.client_id,\n }\n self.headers.update(headers)","def validate_auth():\n try:\n token = oidc.get_access_token()\n except TypeError:\n # raised when the token isn't accessible to the oidc lib\n raise Unauthorized(\"missing auth token\")\n\n if not oidc.validate_token(token):\n terminate_session()\n raise Unauthorized(\"invalid auth token\")\n return token","async def login_for_access_token(email: str = Form(...), password: str = Form(...)):\n user = await authenticate_user(email, password)\n if not user:\n raise HTTPException(\n status_code=status.HTTP_401_UNAUTHORIZED,\n detail=\"Incorrect email or password\",\n headers={\"WWW-Authenticate\": \"Bearer\"},\n )\n if user.disabled:\n raise HTTPException(\n status_code=status.HTTP_401_UNAUTHORIZED,\n detail=\"User is disabled\",\n headers={\"WWW-Authenticate\": \"Bearer\"},\n )\n else:\n access_token_expires = datetime.timedelta(minutes=TOKEN_EXPIRE)\n access_token = create_access_token(\n data={\"sub\": user.email}, expires_delta=access_token_expires\n )\n return {\"credentials\": access_token, \"scheme\": \"Bearer\"}","def __init__(self, access_token=None):\r\n self.access_token = access_token\r\n\r\n self.add_filter(self.add_auth)","def get_access_token(self, request) -> str or Exception:\n pass","def authenticated(func):\n\n def check_access_token(alexafied_request):\n \"\"\" :type alexafied_request AlexaRequest\"\"\"\n try:\n access_token = alexafied_request.access_token()\n except KeyError as e:\n print(\"User is probably not authenticated. error: \" + str(e) + \"missing\")\n return handle_error_states \\\n .handle_not_authenticated(alexafied_request)\n\n _remember_user_id(alexafied_request, access_token)\n return func(alexafied_request)\n\n return check_access_token","def login_access_token(form_data: OAuth2PasswordRequestForm = Depends()):\n user = auth_handler.authenticate_user(\n username=form_data.username, password=form_data.password\n )\n if user is None:\n raise HTTPException(\n detail=\"Incorrect username and/or password\", status_code=400\n )\n\n return APIResponse(\n msg=TokenResponse(\n access_token=auth_handler.encode_token(user.id), token_type=\"bearer\"\n )\n )","def auth_access_token_request(self, auth_access_token_request):\n\n self._auth_access_token_request = auth_access_token_request","def __oauth_login(self):\n\n token = self.accessToken()\n if not token:\n session.redirect_uri = self.__redirect_uri()\n data = dict(redirect_uri=session.redirect_uri,\n response_type='code',\n client_id=self.env.client_id)\n auth_request_url = self.env.auth_url + \"?\" + urlencode(data)\n redirect(auth_request_url)\n return","def _get_token(self):\n if self._access_token is None or self._is_expired():\n self._refresh_token()\n return self._access_token","def _authenticate(self):\n # Check if token expired\n if self._token_expire and self._token_expire < _time():\n self._token = ''\n\n # Get OAuth2 token\n if not self._token:\n # Get user credentials\n credentials = json_read(get_accelize_cred())\n client_id = credentials['client_id']\n client_secret = credentials['client_secret']\n\n # Endpoint override in credentials file\n self._endpoint = credentials.get('endpoint', self._ENDPOINT)\n\n # Try to get CLI cached token\n try:\n self._token, self._token_expire = get_cli_cache(client_id)\n\n # Try to get token from web service\n except TypeError:\n response = self._request(\n 'post', f'{self._endpoint}/o/token/',\n data={\"grant_type\": \"client_credentials\"},\n auth=(client_id, client_secret),\n timeout=self._TIMEOUT)\n\n if response.status_code >= 300:\n raise _AuthenticationException(\n 'Unable to authenticate client ID starting by '\n f'\"{client_id[:10]}\": '\n f'{self._get_error_message(response)}')\n\n access = response.json()\n self._token = access['access_token']\n self._token_expire = int(_time()) + access['expires_in'] - 1\n\n # Cache token value for future CLI usage\n set_cli_cache(client_id, [self._token, self._token_expire],\n self._token_expire)","def auth(self, user):","def auth():\n\tcode = request.query.code\n\tauth = 'https://foursquare.com/oauth2/access_token'\n\tparams = dict(\n\t\tclient_id=CLIENT_ID,\n\t\tclient_secret=CLIENT_SECRET,\n\t\tgrant_type='authorization_code',\n\t\tredirect_uri=REDIRECT_URI,\n\t\tcode=code\n\t)\n\tauth_says = fetch('%s?%s'%(auth, urlencode(params)))\n\tauth_response = json.loads(auth_says.content)\n\tif 'access_token' in auth_response:\n\t\toauth_token=auth_response['access_token']\n\t\tresponse.set_cookie('user', oauth_token, secret=CLIENT_SECRET)\n\t\tlogging.info('new oauth_token:%s'%oauth_token)\n\t\tredirect('/')\n\telse:\n\t\tlogging.error(auth_response)\n\t\tabort()","def _auth_via_token(self) -> Auth.contextmgr:\n warnings.warn(\n \"Authentication via personal access token is deprecated. \"\n \"Please, use the password authentication to avoid inconsistencies.\",\n AirflowProviderDeprecationWarning,\n )\n tableau_auth = PersonalAccessTokenAuth(\n token_name=self.conn.extra_dejson[\"token_name\"],\n personal_access_token=self.conn.extra_dejson[\"personal_access_token\"],\n site_id=self.site_id,\n )\n return self.server.auth.sign_in_with_personal_access_token(tableau_auth)","def handler(self):\r\n credentials = self.get_credentials()\r\n return credentials.authorize(httplib2.Http())","def authenticate_from_server(self, registered_provider):\n return eval(f\"registered_provider.{self.name}.authorize_access_token()\")","def _get_access_token(self):\n\n self._access_token = None\n if not self._refresh_token:\n raise ValueError(\"Refresh Token not set\")\n\n doc = minidom.Document()\n root = doc.createElement('tokenAuthRequest')\n doc.appendChild(root)\n aki = doc.createElement('accessKeyId')\n aki.appendChild(doc.createTextNode(self.publicAccessKey))\n root.appendChild(aki)\n pak = doc.createElement('privateAccessKey')\n pak.appendChild(doc.createTextNode(self.privateAccessKey))\n root.appendChild(pak)\n rt = doc.createElement('refreshToken')\n rt.appendChild(doc.createTextNode(self._refresh_token))\n root.appendChild(rt)\n data = doc.toprettyxml()\n\n resp = requests.post(BASE_URL + \"authorization\", data=data, headers=self._default_headers, verify=False)\n if resp.status_code >= 300:\n raise Exception(\"Failed to claim access token: {}\".format(resp))\n\n vals = etree_to_dict(ET.XML(resp.content.decode('utf-8')))\n\n self._access_token = resp.headers.get('Location', None)\n if not self._access_token:\n raise ValueError(\"Unable to get access token\")\n\n self._user_id = os.path.basename(vals.get('authorization').get('user'))\n\n # Always set the expiry 30 minutes from now so we dont have to deal with parsing timezones\n # self._access_token_expiry = dateutil_parser.parse(vals.get('authorization').get('expiration'))\n self._access_token_expiry = datetime.datetime.utcnow() + datetime.timedelta(minutes=30)","def __init__(self):\n self.authurl = Config().auth\n self.baseurl = Config().api\n self.s = Session()\n self.s.headers = {'Accept': 'application/json'}\n data = {\"grant_type\": \"client_credentials\", \"scope\": \"/read-public\", \"client_id\": Config().client_id,\n \"client_secret\": Config().client_secret}\n r = self.s.request(method=\"post\", url=self.authurl, data=data)\n self.s.headers = {'Accept': 'application/json', \"Access token\": r.json()[\"access_token\"]}","def _get_access_token(self):\n if self._service_token:\n logger.info('Use service token: %s',\n 5 * '*' + self._service_token[50:])\n return self._service_token\n\n if not all([self.app_id, self._login, self._password]):\n raise ValueError(\n 'app_id=%s, login=%s password=%s (masked) must be given'\n % (self.app_id, self._login,\n '*' * len(self._password) if self._password else 'None'))\n\n logger.info(\"Getting access token for user '%s'\" % self._login)\n with self.http_session as s:\n if self._client_secret:\n url_query_params = self.do_direct_authorization(session=s)\n else:\n self.do_login(http_session=s)\n url_query_params = self.do_implicit_flow_authorization(session=s)\n logger.debug('url_query_params: %s', url_query_params)\n\n if 'access_token' in url_query_params:\n logger.info('Access token has been gotten')\n return url_query_params['access_token']\n else:\n raise VkAuthError('OAuth2 authorization error. Url params: %s'\n % url_query_params)","def __enter__(self):\r\n if not AuthHelper.check_login(self.request, self.username):\r\n raise HTTPForbidden('Invalid Authorization')","def test_access_token_get(self):\n client = oauth.Client(self.consumer, None)\n resp, content = client.request(self._uri('request_token'), \"GET\")\n\n self.assertEqual(int(resp['status']), 200)","def get_access_token(self, path='/oauth/token', data={}):\n if data.keys():\n data.update(self.data)\n else:\n data = self.data.copy()\n data.update({\n 'grant_type': 'password',\n 'email': self.env.get('TESLA_EMAIL'),\n 'password': self.env.get('TESLA_PASSWORD')\n })\n try:\n req = requests.post(url='%s%s' % (self.url, path), data=data)\n # print(req.status_code)\n # print(req.content)\n self.token.update(req.json())\n except:\n raise 'invalid credentials'\n return self.token","def _on_access_token(self, future, response):\n if response.error:\n future.set_exception(AuthError('Github auth error: %s' % str(response)))\n return\n \n args = tornado.escape.parse_qs_bytes(\n tornado.escape.native_str(response.body))\n\n future.set_result(args)","def token_auth(self):\n self.client = APIClient()\n self.user = User.objects.create_user(username='testuser', email='test@test.com', password='testpassword')\n self.token = Token.objects.create(user=self.user)\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token.key)","def auth_check():\n try:\n access_token = session_get('access_token')\n access_token_secret = session_get('access_token_secret')\n\n if access_token and access_token_secret:\n tk = get_twitter_keys()\n client = UserClient(\n tk.consumer_key,\n tk.consumer_secret,\n access_token=access_token,\n access_token_secret=access_token_secret)\n \"\"\"\n We need to make a call to verify_credentials in case the user\n has revoked access for this application. This is a rate-limited\n call and so this approach might not be ideal. If we end up\n having rate-limiting problems, we might try giving each user\n a unique application ID that is kept in local storage and used\n as a lookup for Twitter creds (vs. session data which is domain-\n specific and thus problematic for our extension-approach). This\n might allow us to consolidate Twitter creds per user rather than\n storing them for each domain visited.\"\"\"\n verif = client.api.account.verify_credentials.get()\n if verif.headers['status'].split()[0] == '200':\n return jsonify({'is_auth': 1})\n else:\n # possibly revoked access, although this will probably\n # get handled by the TwitterAuthError catch\n remove_session_credentials()\n return jsonify({'is_auth': 0})\n tk = get_twitter_keys()\n client = UserClient(tk.consumer_key, tk.consumer_secret)\n callback = 'http://'+request.host+url_for('auth_verify')\n token = client.get_authorize_token(callback)\n session_set('auth_token', token.oauth_token)\n session_set('auth_token_secret', token.oauth_token_secret)\n session_set('auth_redirect',\n request.args.get('redirect') or '')\n if (\n 'html' in request.headers['Accept']\n and request.args.get('_format') != 'json'):\n return redirect(token.auth_url)\n else:\n data = {'is_auth': 0, 'auth_url': token.auth_url}\n return jsonify(data)\n except TwitterAuthError:\n remove_session_credentials()\n return jsonify({'is_auth': 0})\n except Exception, e:\n traceback.print_exc()\n return jsonify({'error': str(e)})","def login():\n req = request.get_json(force=True)\n username = req.get('username', None)\n password = req.get('password', None)\n user = guard.authenticate(username, password)\n ret = {'access_token': guard.encode_jwt_token(user)}\n return ret, 200","def get_access_token(self):\n payload = {\n 'grant_type': 'client_credentials',\n 'client_id': self.client_id,\n 'client_secret': self.client_secret,\n 'resource': self.resource\n }\n res = requests.post(self.auth_url, data=payload)\n data = res.json()\n if res.status_code == 200:\n return data['access_token'], res\n\n return False, res","def authorize():\n token = oauth.tapkey.authorize_access_token()\n session['auth'] = token\n return redirect(url_for('owner_account_chooser'))","def access_token(self):\n access_token = self.session.get('component_access_token')\n if access_token:\n if not self.expires_at:\n # user provided access_token, just return it\n return access_token\n\n timestamp = time.time()\n if self.expires_at - timestamp > 60:\n return access_token\n\n self.fetch_access_token()\n return self.session.get('component_access_token')","async def _fetch_access_token(session: ClientSession) -> dict:\n LOGGER.debug('fetching access token...')\n password = config.get('WFWX_SECRET')\n user = config.get('WFWX_USER')\n auth_url = config.get('WFWX_AUTH_URL')\n async with session.get(auth_url, auth=BasicAuth(login=user, password=password)) as response:\n return await response.json()","def login():\n data = request.get_json()\n if 'username' in data and 'password' in data:\n username = data['username']\n password = data['password']\n access_token = authenticate(username, password)\n if access_token is not None:\n print('access token: ' + access_token)\n return jsonify({'access_token': access_token})\n else:\n abort(403)\n else:\n abort(400)","def __call__(self, context, callback):\r\n\r\n callback((('authorization', 'Bearer ' + self.token_hash ),), None)","def authenticate(user, request):","def test_replace_o_auth_access_token(self):\n pass","def authenticate_for_token(auth=None):\n try:\n auth_info = core.AuthInfo.create(auth=auth)\n auth_context = core.AuthContext(method_names=[],\n bind={})\n authenticate(auth_info, auth_context)\n if auth_context.get('access_token_id'):\n auth_info.set_scope(None, auth_context['project_id'], None)\n _check_and_set_default_scoping(auth_info, auth_context)\n (domain_id, project_id, trust, unscoped, system) = (\n auth_info.get_scope()\n )\n trust_id = trust.get('id') if trust else None\n\n receipt = receipt_handlers.extract_receipt(auth_context)\n\n # NOTE(notmorgan): only methods that actually run and succeed will\n # be in the auth_context['method_names'] list. Do not blindly take\n # the values from auth_info, look at the authoritative values. Make\n # sure the set is unique.\n # NOTE(adriant): The set of methods will also include any methods from\n # the given receipt.\n if receipt:\n method_names_set = set(\n auth_context.get('method_names', []) + receipt.methods)\n else:\n method_names_set = set(auth_context.get('method_names', []))\n method_names = list(method_names_set)\n\n app_cred_id = None\n if 'application_credential' in method_names:\n token_auth = auth_info.auth['identity']\n app_cred_id = token_auth['application_credential']['id']\n\n # Do MFA Rule Validation for the user\n if not core.UserMFARulesValidator.check_auth_methods_against_rules(\n auth_context['user_id'], method_names_set):\n raise exception.InsufficientAuthMethods(\n user_id=auth_context['user_id'],\n methods=method_names)\n\n expires_at = auth_context.get('expires_at')\n token_audit_id = auth_context.get('audit_id')\n\n token = PROVIDERS.token_provider_api.issue_token(\n auth_context['user_id'], method_names, expires_at=expires_at,\n system=system, project_id=project_id, domain_id=domain_id,\n auth_context=auth_context, trust_id=trust_id,\n app_cred_id=app_cred_id, parent_audit_id=token_audit_id)\n\n # NOTE(wanghong): We consume a trust use only when we are using\n # trusts and have successfully issued a token.\n if trust:\n PROVIDERS.trust_api.consume_use(token.trust_id)\n\n return token\n except exception.TrustNotFound as e:\n LOG.warning(six.text_type(e))\n raise exception.Unauthorized(e)","def get_access_token(self, *args, **kwargs):\n raise NotImplementedError('Subclasses must implement this method.')"],"string":"[\n \"def auth_token(self):\",\n \"def do_auth(self, access_token, *args, **kwargs):\\n data = self.user_data(access_token)\\n data['access_token'] = access_token\\n kwargs.update(data)\\n kwargs.update({'response': data, 'backend': self})\\n return self.strategy.authenticate(*args, **kwargs)\",\n \"def get_access_token():\\n if request.method == \\\"GET\\\":\\n return render_template(\\\"index.html\\\")\\n elif request.method == \\\"POST\\\":\\n # Authenticate\\n auth = Authorization()\\n response = auth.post()\\n return render_template(\\\"index.html\\\", data=response[0])\",\n \"def authenticate( self ):\\n\\n print(\\\"Getting new token\\\")\\n self.getFrob()\\n self.getAuthKey()\\n self.getToken()\\n self.cacheToken()\",\n \"def authorize_access_token(self, request, **kwargs):\\n params = self.retrieve_access_token_params(request)\\n params.update(kwargs)\\n return self.fetch_access_token(**params)\",\n \"def get_access_token(self):\\n logger.info('Try to get access token via OAuth')\\n\\n if self.user_login and not self.user_password:\\n # Need user password\\n pass\\n\\n if not self.user_login and self.user_password:\\n # Need user login\\n pass\\n\\n auth_session = requests.Session()\\n\\n login_form_response = auth_session.get(self.LOGIN_URL)\\n\\n login_form_action = re.findall(r'<form ?.* action=\\\"(.+)\\\"', login_form_response.text)\\n if not login_form_action:\\n raise VkAuthorizationError('vk.com changed login flow')\\n\\n # Login\\n login_form_data = {\\n 'email': self.user_login,\\n 'pass': self.user_password,\\n }\\n\\n response = auth_session.post(login_form_action[0], login_form_data)\\n\\n logger.info('Cookies %s', auth_session.cookies)\\n logger.info('Login response url %s', response.url)\\n\\n if 'remixsid' in auth_session.cookies or 'remixsid6' in auth_session.cookies:\\n pass\\n elif 'sid=' in response.url:\\n self.auth_captcha_is_needed(response.content, auth_session)\\n elif 'act=authcheck' in response.url:\\n self.auth_code_is_needed(response.content, auth_session)\\n elif 'security_check' in response.url:\\n self.phone_number_is_needed(response.content, auth_session)\\n else:\\n raise VkAuthorizationError('Authorization error (bad password)')\\n\\n # OAuth2\\n oauth_data = {\\n 'response_type': 'token',\\n 'client_id': self.app_id,\\n 'scope': self.scope,\\n 'display': 'mobile',\\n }\\n response = auth_session.post('https://oauth.vk.com/authorize', oauth_data)\\n logger.info('OAuth URL: %s %s', response.request.url, oauth_data)\\n\\n if 'access_token' not in response.url:\\n form_action = re.findall(u'<form method=\\\"post\\\" action=\\\"(.+?)\\\">', response.text)\\n if form_action:\\n response = auth_session.get(form_action[0])\\n else:\\n try:\\n json_data = response.json()\\n except ValueError: # not json in response\\n error_message = 'OAuth2 grant access error'\\n else:\\n error_message = 'VK error: [{0}] {1}'.format(\\n json_data['error'],\\n json_data['error_description']\\n )\\n auth_session.close()\\n raise VkAuthorizationError(error_message)\\n\\n auth_session.close()\\n\\n parsed_url = urlparse(response.url)\\n logger.info('Parsed URL: %s', parsed_url)\\n\\n token_dict = dict(parse_qsl(parsed_url.fragment))\\n if 'access_token' in token_dict:\\n self.access_token = token_dict['access_token']\\n self.access_token_expires_in = token_dict['expires_in']\\n else:\\n raise VkAuthorizationError('OAuth2 authorization error')\",\n \"def accessCheck(self) -> None:\\n\\n if self.access_token:\\n return\\n self.access_token = self.login()\",\n \"def auth(self):\\n ok = False\\n if self.private_token:\\n ok = self.token_auth()\\n if not ok:\\n self.credentials_auth()\",\n \"def do_auth(self, access_token, *args, **kwargs):\\n data = self.user_data(access_token, *args, **kwargs)\\n response = kwargs.get('response') or {}\\n response.update(data or {})\\n if 'access_token' not in response:\\n response['access_token'] = access_token\\n kwargs.update({'response': response, 'backend': self})\\n return self.strategy.authenticate(*args, **kwargs)\",\n \"def do_auth(self, access_token, *args, **kwargs):\\n data = self.user_data(access_token, *args, **kwargs)\\n response = kwargs.get('response') or {}\\n response.update(data or {})\\n if 'access_token' not in response:\\n response['access_token'] = access_token\\n kwargs.update({'response': response, 'backend': self})\\n return self.strategy.authenticate(*args, **kwargs)\",\n \"def _authenticate(self):\\n if self.creds().consumer_key() is None or \\\\\\n self.creds().app_secret() is None:\\n self.logger.error(\\\"You need a consumer key and app secret, yo\\\")\\n else:\\n self._access_token = self._request_access_token()\",\n \"def test_read_o_auth_access_token(self):\\n pass\",\n \"def authenticate(self):\\n try:\\n self._token = self._lookup_token()\\n except:\\n raise HTTPError(\\n \\\"Unable to get short-lived access token for cyberark storage\\\"\\n )\",\n \"def _validate_token(self):\\n if not self.token:\\n self.login()\\n if not self.token:\\n # TODO: create exception for this\\n # Access is denied!!\\n raise Exception(\\\"AccessDenied\\\")\",\n \"def __call__(self, access_token):\",\n \"def authenticate(self):\\n # Check if we already have access token and secret\\n if not os.path.exists(self.sTOKEN_FILE):\\n # 1) Obtain Request token\\n oauth = OAuth1(self.apiKey, client_secret=self.apiKeySecret, callback_uri='oob')\\n r = requests.post(url=self.sREQUEST_TOKEN_URL, auth=oauth)\\n credentials = parse_qs(r.content)\\n resource_owner_key = credentials.get('oauth_token')[0]\\n resource_owner_secret = credentials.get('oauth_token_secret')[0]\\n\\n # 2) Obtain authorization for the user to access resources\\n # Redirect the user to /authorize and get the callback\\n authorize_url = self.sAUTHORIZE_URL + '?oauth_token=' + resource_owner_key + \\\\\\n '&oauth_consumer_key=' + self.apiKey + \\\\\\n '&Access=Full&Permissions=Modify'\\n\\n print 'Please go here and authorize,', authorize_url\\n verifier = raw_input('Please enter the six-digit PIN code: ')\\n\\n # 3) Obtain final access token\\n oauth = OAuth1(self.apiKey, client_secret = self.apiKeySecret,\\n resource_owner_key = resource_owner_key,\\n resource_owner_secret = resource_owner_secret,\\n verifier=verifier)\\n r = requests.post(url=self.sACCESS_TOKEN_URL, auth=oauth)\\n\\n credentials = parse_qs(r.content)\\n access_token = credentials.get('oauth_token')[0]\\n access_token_secret = credentials.get('oauth_token_secret')[0]\\n\\n # Store access token so we can use it later\\n with open(self.sTOKEN_FILE, 'w') as f:\\n json.dump({'access_token': access_token,\\n 'access_token_secret': access_token_secret}, f)\\n\\n else:\\n with open(self.sTOKEN_FILE, 'r') as f:\\n tokens = json.load(f)\\n access_token = tokens.get('access_token')\\n access_token_secret = tokens.get('access_token_secret')\\n\\n # store the file access token details for use in other methods\\n self.accessToken = access_token\\n self.accessTokenSecret = access_token_secret\",\n \"def Access(self):\\n if datetime.now() < self.access_exp:\\n pass\\n elif datetime.now() > self.access_exp and datetime.now() < self.refresh_exp:\\n grant = 'refresh_token'\\n self._postRequest(grant=grant)\\n elif datetime.now() > self.refresh_exp:\\n grant = 'authorization_code'\\n self._getURLcode()\\n self._postRequest(grant=grant)\",\n \"def authenticate(func):\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n access_token = request.headers.get('token', '')\\n if access_token.strip(' '):\\n decoded = decode_token(access_token)\\n if decoded['status']:\\n return func(*args, **kwargs)\\n abort(http_status_code=401, message='Invalid token.Please login')\\n abort(http_status_code=401,\\n message='Token is missing')\\n return wrapper\",\n \"def _authenticate(self):\\n url = self.endpoint + \\\"/tokens\\\"\\n h = httplib2.Http()\\n response, rawcontent = h.request(\\n url, \\n method=\\\"POST\\\",\\n headers={ \\\"Content-Type\\\":\\\"application/json\\\" },\\n body=json.dumps(self.credentials()))\\n content = json.loads(rawcontent)\\n self.token = content['access']['token']['id']\\n #TODO: this needs to convert the ISO8601 string to a timestamp\\n self.expiration = content['access']['token']['expires']\\n self.catalog = content['access']['serviceCatalog']\",\n \"def auth():\\n pass\",\n \"def auth():\\n pass\",\n \"def authenticate(self, request):\\n if 'credentials' not in request.session:\\n raise LoginRequired()\\n self.credentials = client.OAuth2Credentials.from_json(\\n request.session['credentials'])\\n if self.credentials.access_token_expired:\\n raise LoginRequired()\",\n \"def check_auth():\",\n \"async def login_access_token(\\n form_data: OAuth2PasswordRequestForm = Depends()\\n):\\n user = await crud.user.authenticate(\\n username=form_data.username, password=form_data.password\\n )\\n if not user:\\n raise HTTPException(status_code=HTTP_404_NOT_FOUND, detail=\\\"Incorrect credentials\\\")\\n elif not user.is_active:\\n raise HTTPException(status_code=HTTP_403_FORBIDDEN, detail=\\\"Inactive user\\\")\\n elif not user.is_email_verified:\\n raise HTTPException(status_code=HTTP_403_FORBIDDEN, detail=\\\"Please verify your account via email\\\")\\n access_token_expires = timedelta(minutes=config.ACCESS_TOKEN_EXPIRE_MINUTES)\\n return {\\n \\\"access_token\\\": create_access_token(\\n data={\\\"user_id\\\": user.id}, expires_delta=access_token_expires\\n ),\\n \\\"token_type\\\": \\\"bearer\\\",\\n }\",\n \"def auth(self):\\n return self.api(self.token)\",\n \"def authenticate(self):\\n #it's weird i have to do this here, but the code makes this not simple\\n auth_json={'email':self.user, 'password':self.password}\\n #send a post with no auth. prevents an infinite loop\\n auth_response = self.post('/auth', data = json.dumps(auth_json), auth =\\n None)\\n\\n _token = auth_response.json['token']\\n\\n self._token = _token\\n self._wrapped.auth = SpringAuth(_token)\",\n \"async def authorize(self):\\n # TODO: make several attempts for each step\\n html = await self.get_auth_page()\\n url, html = await self.process_auth_form(html)\\n q = urllib.parse.urlparse(url)\\n if q.path == '/authorize': # invalid login or password\\n url, html = await self.process_auth_form(html)\\n q = urllib.parse.urlparse(url)\\n if q.path == '/login':\\n url, html = await self.process_2auth_form(html)\\n q = urllib.parse.urlparse(url)\\n if q.path == '/login':\\n url, html = await self.process_2auth_form(html)\\n q = urllib.parse.urlparse(url)\\n if q.path == '/authorize': # give rights for app\\n url, html = await self.process_access_form(html)\\n q = urllib.parse.urlparse(url)\\n if q.path == '/blank.html':\\n qs = dict(urllib.parse.parse_qsl(q.fragment))\\n self.access_token = qs['access_token']\",\n \"def _authorize(self, token=None, store_token=False, reenter_token=False): # pragma: no cover\\n\\n if token is None and \\\"MAST_API_TOKEN\\\" in os.environ:\\n token = os.environ[\\\"MAST_API_TOKEN\\\"]\\n\\n if token is None:\\n token = keyring.get_password(\\\"astroquery:mast.stsci.edu.token\\\", \\\"masttoken\\\")\\n\\n if token is None or reenter_token:\\n auth_server = conf.server.replace(\\\"mast\\\", \\\"auth.mast\\\")\\n auth_link = auth_server + \\\"/token?suggested_name=Astroquery&suggested_scope=mast:exclusive_access\\\"\\n info_msg = \\\"If you do not have an API token already, visit the following link to create one: \\\"\\n log.info(info_msg + auth_link)\\n token = getpass(\\\"Enter MAST API Token: \\\")\\n\\n # store password if desired\\n if store_token:\\n keyring.set_password(\\\"astroquery:mast.stsci.edu.token\\\", \\\"masttoken\\\", token)\\n\\n self._session.headers[\\\"Accept\\\"] = \\\"application/json\\\"\\n self._session.cookies[\\\"mast_token\\\"] = token\\n info = self.session_info(silent=True)\\n\\n if not info[\\\"anon\\\"]:\\n log.info(\\\"MAST API token accepted, welcome %s\\\" % info[\\\"attrib\\\"].get(\\\"display_name\\\"))\\n else:\\n log.warn(\\\"MAST API token invalid!\\\")\\n\\n return not info[\\\"anon\\\"]\",\n \"def getAccessToken(self):\\r\\n\\r\\n #lets see if we have an oauth code\\r\\n if self.oauthToken is None:\\r\\n self.oauthToken = self.createAccessToken\\r\\n\\r\\n if self.oauthToken.isExpired(): #check to see if its expired if so refresh it\\r\\n self.oauthToken = self.refreshAccessToken()\\r\\n\\r\\n return self.oauthToken #return out access token\\r\",\n \"def authorize(self):\\n login_data = {\\n 'username': self.username,\\n 'password': self.password,\\n }\\n r = requests.post(f'{self.api_host}/auth', json=login_data)\\n\\n if r.status_code == 200:\\n CentralStorageClient.token = r.json()['access_token']\\n\\n return True\\n\\n return False\",\n \"def auth(request):\\n\\n if('username' in request.POST and 'password' in request.POST):\\n user = authenticate(\\n username=request.POST['username'],\\n password=request.POST['password'],\\n )\\n if(user):\\n token = Token(user = user)\\n token.generateToken()\\n token.save()\\n data = {}\\n data['token'] = token.value\\n data['expiry'] = token.expiry\\n data['valid'] = token.isValid()\\n return JsonResponse(data) \\n \\n return HttpResponseBadRequest('Username and password must be supplied')\",\n \"def post(self):\\r\\n try:\\r\\n\\r\\n data = request.get_json()\\r\\n user = user_login.find_by_username(data['username'])\\r\\n if user and safe_str_cmp(user.password, data['password']):\\r\\n access_token = create_access_token(\\r\\n identity=user.id, fresh=True)\\r\\n return {\\r\\n 'access_token': \\\"Bearer \\\" + access_token,\\r\\n }, 200\\r\\n return {\\\"message\\\": \\\"Invalid Credentials!\\\"}, 401\\r\\n except Exception as e:\\r\\n return {\\\"message\\\": str(e)}\",\n \"def auth_user():\\n global token\\n app.logger.info(\\\"Microsoft Planner Service running on /auth port as expected\\\")\\n try:\\n request_count = 0\\n if request_count == 0:\\n token = get_tokens_as_app(client_id, user_code_info, tenant_id)\\n request_count = 1 \\n if 'access_token' in token:\\n app.logger.info('Adding access token to cache...')\\n add_token_to_cache(client_id, tenant_id, token)\\n return_object = (f\\\"{token['refresh_token']}\\\")\\n return render_template('token.html', return_object=return_object)\\n else:\\n return_error = (\\\"Token response did not result in a proper response. Athenticate again please.\\\")\\n return render_template('token.html', return_error=return_error)\\n except AttributeError or TypeError:\\n return_error = ('Authentification failed. Please pull and restart your system and authenticate again.')\\n return render_template('token.html', return_error=return_error)\\n except adal.AdalError as err:\\n return_error = (\\\"You're logged in with the wrong user. Please log out and authenticate again.\\\")\\n return render_template('token.html', return_error=return_error)\",\n \"def test_list_o_auth_access_token(self):\\n pass\",\n \"async def login_for_access_token(\\n form_data: OAuth2PasswordRequestForm = Depends()\\n):\\n user = authenticate_user(form_data.username, form_data.password)\\n if not user:\\n raise HTTPException(\\n status_code=status.HTTP_401_UNAUTHORIZED,\\n detail=\\\"Incorrect username or password\\\",\\n headers={\\\"WWW-Authenticate\\\": \\\"Bearer\\\"},\\n )\\n access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)\\n access_token = create_access_token(\\n data={\\\"sub\\\": user.username}, expires_delta=access_token_expires\\n )\\n return {\\\"access_token\\\": access_token, \\\"token_type\\\": \\\"bearer\\\"}\",\n \"def _get_auth_value(self):\\n if not self._access_token:\\n try:\\n # get the local access token using gcloud\\n cmd = ['gcloud', 'auth', 'print-access-token']\\n if self._user_email:\\n cmd.append(self._user_email)\\n\\n self._logger.debug(f\\\"get gcloud_access_token {cmd}\\\")\\n p = Popen(cmd, stdout=PIPE, stderr=PIPE)\\n gcloud_access_token, stderr = p.communicate()\\n gcloud_access_token = gcloud_access_token.decode(\\\"utf-8\\\").rstrip()\\n assert len(gcloud_access_token) > 0, f'get gcloud_access_token MUST have an access token {stderr}'\\n self._logger.debug(f\\\"gcloud_access_token {gcloud_access_token}\\\")\\n # authenticate to terra, ask for fence/accesstoken\\n headers = {'Authorization': f'Bearer {gcloud_access_token}'}\\n r = requests.get(self._terra_auth_url, headers=headers)\\n assert r.status_code == 200, f'MUST respond with 200 {self._terra_auth_url} {r.text}'\\n self._logger.debug(r.text)\\n terra_access_token = r.json()\\n assert len(terra_access_token['token']) > 0, 'MUST have an access token'\\n assert len(terra_access_token['expires_at']) > 0, 'MUST have an expires_at '\\n\\n expires_at = datetime.fromisoformat(terra_access_token['expires_at'])\\n now = datetime.now()\\n assert expires_at > now, 'expires_at MUST be in the future'\\n\\n self._access_token = terra_access_token['token']\\n\\n if self._logger.level == logging.DEBUG:\\n self._logger.debug(f'Terra access token expires in {str(expires_at - now)}')\\n self._logger.debug(self._access_token)\\n # add padding\\n self._logger.debug(base64.b64decode(self._access_token.split('.')[1] + \\\"===\\\"))\\n\\n except Exception as e:\\n raise AnVILAuthError(\\n \\\"Failed to authenticate to {}\\\\n{}\\\".format(self._terra_auth_url, str(e))\\n )\\n\\n return \\\"Bearer \\\" + self._access_token\",\n \"async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):\\n user = example_user_validator(form_data.username, form_data.password)\\n if not user:\\n raise HTTPException(\\n status_code=status.HTTP_401_UNAUTHORIZED,\\n detail=\\\"Incorrect username or password\\\",\\n headers={\\\"WWW-Authenticate\\\": \\\"Bearer\\\"},\\n )\\n access_token_data = jwt_claims.copy()\\n access_token_data[\\\"sub\\\"] = user[\\\"username\\\"]\\n access_token_data[\\\"exp\\\"] = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)\\n access_token_data[\\\"jti\\\"] = str(uuid.uuid4())\\n\\n refresh_token_data = jwt_claims.copy()\\n refresh_token_data[\\\"sub\\\"] = user[\\\"username\\\"]\\n refresh_token_data[\\\"exp\\\"] = datetime.utcnow() + timedelta(days=REFRESH_TOKEN_EXPIRE_DAYS)\\n refresh_token_data[\\\"type\\\"] = \\\"refresh\\\"\\n refresh_token_data[\\\"jti\\\"] = str(uuid.uuid4())\\n\\n return AccessRefreshToken(\\n access_token=jwt.encode(access_token_data, SECRET_KEY, algorithm=ALGORITHM),\\n refresh_token=jwt.encode(refresh_token_data, SECRET_KEY, algorithm=ALGORITHM)\\n )\",\n \"def auth(self):\\n if self.get_saved_token():\\n return\\n self.oauth2()\\n self.save_token()\",\n \"def get_access_token(self):\\n\\n token_work = time.time() < self.expires\\n\\n if token_work:\\n # No need update token\\n return self.access_token\\n\\n data = {\\n 'client_id': self.client_id,\\n 'grant_type': 'implicit'\\n }\\n\\n response = requests.post('https://api.moltin.com/oauth/access_token', data=data)\\n raise_response_errors(response)\\n\\n response_json = response.json()\\n\\n self.access_token = response_json['access_token']\\n self.expires = response_json['expires']\\n\\n logger.debug('elasticpathh access token was updated')\\n\\n return self.access_token\",\n \"def _require_login(self):\\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + str(self.token))\",\n \"def get_access_token(request):\\n user = request.user\\n flow = _create_flow(request)\\n\\n flow.params['state'] = _build_state_value(request, user)\\n credentials = StorageByKeyName(\\n CredentialsNDBModel, user.user_id(), 'credentials').get()\\n\\n authorize_url = flow.step1_get_authorize_url()\\n redirect_response_object = HttpResponseRedirect(authorize_url)\\n if credentials is None or credentials.invalid:\\n return redirect_response_object\\n\\n # Find out if credentials is expired\\n refresh_failed = False\\n if credentials.access_token is None or credentials.access_token_expired:\\n try:\\n credentials.refresh(httplib2.Http())\\n except AccessTokenRefreshError:\\n return redirect_response_object\\n except Exception:\\n refresh_failed = True\\n\\n port_value = _validate_port(request.GET.get('port'))\\n if port_value is None:\\n return HttpTextResponse('Access Token: %s' % (credentials.access_token,))\\n\\n # Send access token along to localhost client\\n redirect_template_args = {'port': port_value}\\n if refresh_failed:\\n quoted_error = urllib.quote(OAUTH_DEFAULT_ERROR_MESSAGE)\\n redirect_template_args['error'] = quoted_error\\n client_uri = ACCESS_TOKEN_FAIL_REDIRECT_TEMPLATE % redirect_template_args\\n else:\\n quoted_access_token = urllib.quote(credentials.access_token)\\n redirect_template_args['token'] = quoted_access_token\\n client_uri = ACCESS_TOKEN_REDIRECT_TEMPLATE % redirect_template_args\\n\\n return HttpResponseRedirect(client_uri)\",\n \"def login_access_token(\\n db: Session = Depends(get_db),\\n form_data: OAuth2PasswordRequestForm = Depends()\\n) -> Any:\\n user = crud.user.authenticate(\\n db, email=form_data.username, password=form_data.password\\n )\\n if not user:\\n raise HTTPException(\\n status_code=400, detail=\\\"Incorrect email or password\\\")\\n elif not crud.user.is_active(user):\\n raise HTTPException(status_code=400, detail=\\\"Inactive user\\\")\\n access_token_expires = timedelta(\\n minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)\\n return {\\n \\\"access_token\\\": security.create_access_token(\\n user.id, expires_delta=access_token_expires\\n ),\\n \\\"token_type\\\": \\\"bearer\\\",\\n }\",\n \"def access_token(*args, **kwargs):\\n return None\",\n \"def get_access_token(request):\\n user = request.user\\n flow = _create_flow(request)\\n\\n flow.params['state'] = _build_state_value(request, user)\\n credentials = StorageByKeyName(\\n CredentialsNDBModel, user.user_id(), 'credentials').get()\\n\\n authorize_url = flow.step1_get_authorize_url()\\n redirect_response_object = HttpResponseRedirect(authorize_url)\\n if credentials is None or credentials.invalid:\\n return redirect_response_object\\n\\n # Find out if credentials is expired\\n refresh_failed = False\\n if credentials.access_token is None or credentials.access_token_expired:\\n try:\\n credentials.refresh(httplib2.Http())\\n except AccessTokenRefreshError:\\n return redirect_response_object\\n except:\\n refresh_failed = True\\n\\n port_value = _validate_port(request.GET.get('port'))\\n if port_value is None:\\n return HttpTextResponse('Access Token: %s' % (credentials.access_token,))\\n\\n # Send access token along to localhost client\\n redirect_template_args = {'port': port_value}\\n if refresh_failed:\\n quoted_error = urllib.quote(OAUTH_DEFAULT_ERROR_MESSAGE)\\n redirect_template_args['error'] = quoted_error\\n client_uri = ACCESS_TOKEN_FAIL_REDIRECT_TEMPLATE % redirect_template_args\\n else:\\n quoted_access_token = urllib.quote(credentials.access_token)\\n redirect_template_args['token'] = quoted_access_token\\n client_uri = ACCESS_TOKEN_REDIRECT_TEMPLATE % redirect_template_args\\n\\n return HttpResponseRedirect(client_uri)\",\n \"def test_valid_access_request(self):\\n\\n # Generate a valid auth token\\n with base.HybridSessionManager():\\n authorization_code = auth_api.authorization_code_save({\\n 'user_id': 2,\\n 'state': 'test_state',\\n 'code': 'test_valid_code'\\n })\\n\\n content_type = 'application/x-www-form-urlencoded'\\n # POST with content: application/x-www-form-urlencoded\\n response = self.app.post('/v1/openid/token',\\n params={\\n 'code': authorization_code.code,\\n 'grant_type': 'authorization_code'\\n },\\n content_type=content_type,\\n expect_errors=True)\\n\\n # Assert that this is a successful response\\n self.assertEqual(200, response.status_code)\\n\\n # Assert that the token came back in the response\\n token = response.json\\n self.assertIsNotNone(token['access_token'])\\n self.assertIsNotNone(token['expires_in'])\\n self.assertIsNotNone(token['id_token'])\\n self.assertIsNotNone(token['refresh_token'])\\n self.assertIsNotNone(token['token_type'])\\n self.assertEqual('Bearer', token['token_type'])\\n\\n # Assert that the access token is in the database\\n with base.HybridSessionManager():\\n access_token = \\\\\\n token_api.access_token_get_by_token(token['access_token'])\\n self.assertIsNotNone(access_token)\\n\\n # Assert that system configured values is owned by the correct user.\\n self.assertEqual(2, access_token.user_id)\\n self.assertEqual(token['id_token'], access_token.user_id)\\n self.assertEqual(token['expires_in'], CONF.oauth.access_token_ttl)\\n self.assertEqual(token['expires_in'], access_token.expires_in)\\n self.assertEqual(token['access_token'], access_token.access_token)\\n\\n # Assert that the refresh token is in the database\\n with base.HybridSessionManager():\\n refresh_token = \\\\\\n refresh_tokens.refresh_token_get_by_token(\\n token['refresh_token'])\\n\\n self.assertIsNotNone(refresh_token)\\n\\n # Assert that system configured values is owned by the correct user.\\n self.assertEqual(2, refresh_token.user_id)\\n self.assertEqual(CONF.oauth.refresh_token_ttl,\\n refresh_token.expires_in)\\n self.assertEqual(token['refresh_token'], refresh_token.refresh_token)\\n\\n # Assert that the authorization code is no longer in the database.\\n with base.HybridSessionManager():\\n none_code = \\\\\\n auth_api.authorization_code_get(authorization_code.code)\\n self.assertIsNone(none_code)\",\n \"def authentication_request():\\n # Get the access token from the header\\n auth_header = request.headers.get('Authorization')\\n if auth_header:\\n try:\\n access_token = auth_header.split(' ')[1]\\n except IndexError:\\n return {\\\"message\\\": \\\"Token is malformed\\\"}, status.HTTP_401_UNAUTHORIZED\\n else:\\n access_token = ''\\n\\n return access_token\",\n \"def authn_and_authz():\\n authentication()\\n authorization()\",\n \"def authenticate(self, request):\\n\\n return self._validate_token(request)\",\n \"def auth_token_api():\\n data = request.get_json()\\n if not data:\\n response = jsonify({\\n 'success': False,\\n 'message': 'Missing request body'\\n })\\n response.status_code = 422\\n return response\\n\\n # process argument\\n login_type = data.get('auth_type')\\n email = data.get('email').strip().lower()\\n password = data.get('password')\\n\\n if not login_type or login_type not in ['email']:\\n response = jsonify({\\n 'success': False,\\n 'message': 'Invalid auth_type'\\n })\\n response.status_code = 422\\n return response\\n\\n # email authentication\\n elif login_type == 'email':\\n if not email:\\n response = jsonify({\\n 'success': False,\\n 'message': 'Must provide email when auth_type is \\\"email\\\"'\\n })\\n response.status_code = 422\\n return response\\n user = db.session.query(User).filter(User.email == email, User.deleted == False).one_or_none()\\n if not user:\\n response = jsonify({\\n 'success': False,\\n 'message': 'Not Authorized: invalid email'\\n })\\n response.status_code = 403\\n return response\\n # check the user's password\\n password_valid = check_password_hash(user.password, password)\\n if not password_valid:\\n response = jsonify({\\n 'success': False,\\n 'message': 'Not Authorized: invalid password'\\n })\\n response.status_code = 403\\n return response\\n\\n token = generate_auth_token(user_id=user.user_id)\\n response = jsonify({\\n 'success': True,\\n 'token': token\\n })\\n response.status_code == '200'\\n return response\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL, need token.\\\\n', 403,\\n {'WWW-Authenticate': 'Basic realm=\\\"token Required\\\"'})\",\n \"def login_required(view):\\n def check_login(request,*args,**kwds):\\n if not request.user.is_authenticated():\\n api = FlattrAPI(secrets.FLATTR_API_KEY,secrets.FLATTR_API_SECRET)\\n callback = reverse(oauth_callback)\\n callback += \\\"?next=\\\" + urllib.quote(request.get_full_path(),\\\"\\\")\\n callback = request.build_absolute_uri(callback)\\n (token,url) = api.request_access_token(callback,\\\"click\\\")\\n print \\\"OBTAINING REQ TOKEN\\\", token.key, token.secret\\n t = APIToken.objects.create(id=token.key,secret=token.secret)\\n t.save()\\n print \\\"REDIRECTING TO\\\", url\\n return HttpResponseRedirect(url)\\n return view(request,*args,**kwds)\\n return check_login\",\n \"def auth(request):\\n\\n service = get_model_instance(request.user, MODULE_NAME)\\n if service and request.method == 'POST':\\n username = request.POST['username']\\n\\n # Delete existing token\\n AccessToken.objects.filter(service=service).delete()\\n # Before creating a new one\\n AccessToken.objects.create(\\n service=service,\\n username=username,\\n created=datetime.now(),\\n api_token=service.app.oauth.consumer_key\\n )\\n\\n service.setup = True\\n service.public = True\\n service.save()\\n\\n return redirect(settings_redirect(request))\",\n \"def authorize(self) -> None:\\n\\n if not self.login_secret:\\n #TODO trigger error\\n self.login()\\n \\n\\n sObj = Splitwise(self.consumer_key, self.consumer_secret)\\n self.access_token = sObj.getAccessToken(\\n self.oauth_token,\\n self.login_secret,\\n self.oauth_verifier\\n )\",\n \"def authenticate(self, request=None):\\r\\n try:\\r\\n token = request.META.get('HTTP_AUTHORIZATION') or request.REQUEST['key']\\r\\n accesskey = AccessKey.objects.select_related('user').get(key=token)\\r\\n request.user = accesskey.user\\r\\n return request.user and request.user.is_active\\r\\n\\r\\n except(KeyError, AccessKey.DoesNotExist):\\r\\n return False\",\n \"def test_create_o_auth_access_token(self):\\n pass\",\n \"def request_access_token(self, *args, **kwargs):\\n response = super().request_access_token(*args, **kwargs)\\n if \\\"access_token\\\" not in response:\\n response[\\\"access_token\\\"] = response[\\\"id_token\\\"]\\n return response\",\n \"def auth_code_handler(self, request, pk=None):\\n try:\\n # Get xero auth access information form xero connection\\n stored_values = OAUTH_PERSISTENT_SERVER_STORAGE\\n\\n\\n if len(stored_values) == 0:\\n return Utils.dispatch_failure(request, 'NO_TOKEN_AUTHENTICATION')\\n\\n secret_keys = Utils.get_access_keys(pk)\\n if AccountingConfiguration.PRIVATE == secret_keys.type:\\n exists = AccountingOauth2.objects.filter(company=pk).first()\\n if not exists:\\n auth = AccountingOauth2(accessToken=stored_values['consumer_key'],\\n accessSecretKey=stored_values['rsa_key'],\\n company_id=pk)\\n auth.save()\\n else:\\n exists.accessToken = stored_values['consumer_key']\\n exists.accessSecretKey = stored_values['rsa_key']\\n exists.save()\\n else:\\n auth_verifier_uri = settings.XERO_AUTH_VERIFIER_URI\\n oauth_verifier = request.GET.get('oauth_verifier')\\n credentials = Utils.get_xero_public_credentials(stored_values)\\n\\n if credentials.expired():\\n return Utils.dispatch_failure(request, 'NO_TOKEN_AUTHENTICATION')\\n\\n # Verify the auth verifier for establish the connection\\n\\n credentials.verify(oauth_verifier)\\n # Resave our verified credentials\\n for key, value in credentials.state.items():\\n OAUTH_PERSISTENT_SERVER_STORAGE.update({key: value})\\n\\n stored_values = OAUTH_PERSISTENT_SERVER_STORAGE\\n exists = AccountingOauth2.objects.filter(company=pk).first()\\n\\n if exists:\\n exists.accessToken = stored_values['oauth_token']\\n exists.realmId = oauth_verifier\\n exists.accessSecretKey = stored_values['oauth_token_secret']\\n exists.tokenAcitvatedOn = stored_values['oauth_expires_at']\\n exists.tokenExpiryON = stored_values['oauth_authorization_expires_at']\\n exists.save()\\n else:\\n auth = AccountingOauth2(accessToken=stored_values['oauth_token'],\\n refreshToken='',\\n realmId=oauth_verifier,\\n accessSecretKey=stored_values['oauth_token_secret'],\\n tokenAcitvatedOn=stored_values['oauth_expires_at'],\\n tokenExpiryON=stored_values['oauth_authorization_expires_at'],\\n company_id=pk)\\n auth.save()\\n # auth_redirect_url = os.environ.get ('QBO_AUTH_REDIRECT_URL',\\n # 'http://localhost:4200/coa-match/quickbooks')\\n\\n # auth_redirect_url = os.environ.get ('QBO_AUTH_REDIRECT_URL','http://ec2-52-207-28-114.compute-1.amazonaws.com/ix/coa-match/quickbooks')\\n\\n # return redirect(auth_redirect_url)\\n\\n except Exception as e:\\n auth_cancel_url = settings.QBO_AUTH_CANCEL_URL\\n Utils.send_company_misconfig(pk, e)\\n return redirect(auth_cancel_url + '/error')\\n #return Utils.dispatch_success(request, 'TOKEN_ALREADY_VALIDATED')\\n\\n auth_redirect_url = settings.XERO_AUTH_REDIRECT_URL\\n return redirect(auth_redirect_url)\\n # return Utils.dispatch_success(request, stored_values)\",\n \"def request_access_token():\\n\\n # For Private application authentication, you must specifiy\\n # grant_type=client_credentials and the service scope. For the \\n # Content API, scope=contentapi\\n post_data = {\\\"grant_type\\\": APP_CONFIG['GRANT_TYPE'],\\n \\\"scope\\\": APP_CONFIG['SCOPE']}\\n post_data_string = json.dumps(post_data)\\n\\n # Construct authentication string:\\n # 1. Concatenate the client id, a colon character \\\":\\\", and the client secret into a single string\\n # 2. URL encode the string from step 1\\n # 3. Base64 encode the string from step 2\\n authstr = to_native_string(\\n b64encode(('%s:%s' % (APP_CONFIG['CLIENT_ID'], APP_CONFIG['CLIENT_SECRET'])).encode('utf-8'))).strip()\\n\\n # Construct an Authorization header with the value of 'Basic <base64 encoded auth string>'\\n headers = {\\n \\\"Content-Type\\\": \\\"application/json;charset=UTF-8\\\",\\n \\\"Accept\\\": \\\"application/json\\\",\\n \\\"Authorization\\\": \\\"Basic \\\" + authstr\\n }\\n\\n r = s.post(APP_CONFIG['OAUTH_TOKEN_URL'], data=post_data_string, headers=headers, verify=(app.config['SSLVERIFY'] == 'True'))\\n\\n if r.status_code in (400,500):\\n\\n # Handle known error\\n result = r.json() \\n return jsonify(result)\\n\\n elif r.status_code == 200:\\n\\n result = r.json() \\n access_token = result['access_token']\\n token_type = result['token_type']\\n timestamp = result.get('timestamp', None)\\n expires_in = result.get('expires_in', None)\\n token_expiry = None\\n if expires_in is not None:\\n token_expiry = datetime.datetime.strptime(timestamp, '%Y-%m-%dT%H:%M:%S')\\n token_expiry = token_expiry + datetime.timedelta(seconds=expires_in)\\n token_expiry = token_expiry.isoformat()\\n\\n html = '<pre>';\\n html += '<h3>Successfully retrieved access token!</h3>' \\n html += '<pre>';\\n html += 'access_token : ' + access_token\\n html += '<pre>';\\n html += 'token_type : ' + token_type\\n html += '<pre>';\\n html += 'expires_in (sec) : ' + str(expires_in)\\n html += '<pre>';\\n html += 'token_expiry : ' + token_expiry\\n html += '<pre>';\\n html += 'timestamp : ' + timestamp\\n\\n html += '<pre>';\\n html += '<h3>Query Content API with Access Token</h3>'\\n html += '<pre>';\\n html += '<a href=\\\"/query-collection-myhuman?access_token='+access_token+'\\\">Query Collection: myhuman</a>'\\n\\n return html\\n\\n else:\\n # Handle unknown error\\n return (r.text, r.status_code, r.headers.items())\",\n \"def login_require(request):\\n\\n if request.method == \\\"GET\\\":\\n data = request.GET\\n else:\\n data = request.POST\\n user = authenticate(username=data[\\\"username\\\"], password=data[\\\"password\\\"])\\n if user and user.is_active:\\n ret = Response(SUCCESS, error_code[SUCCESS])\\n else: \\n ret = Response(AUTHENTICATION_FAIL, error_code[AUTHENTICATION_FAIL])\\n return HttpResponse(ret.serialize(f))\\n\\n # Generate a token for authentication\\n token = token_generator(30)\\n try:\\n user_token = Token.objects.get(username=data[\\\"username\\\"])\\n user_token.token = token\\n user_token.start_time = datetime.now()\\n except: \\n user_token = Token(token=token, username=data[\\\"username\\\"])\\n user_token.save()\\n ret.set_ret(\\\"auth_token\\\", token) \\n user = User.objects.get(username=data[\\\"username\\\"])\\n ret.set_ret(\\\"data\\\", UserSerializer(user.appuser).serialize())\\n return HttpResponse(ret.serialize(f))\",\n \"def add_auth(self, http_request):\\r\\n pass\",\n \"def auth(access_token, access_token_secret, consumer_key, consumer_secret):\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token,access_token_secret)\\n return auth\",\n \"def access_token(global_config, existing_user, id_api):\\n yield id_api.get_access_token_for_user(existing_user.email, existing_user.password)\",\n \"def auth_required(handler_method):\\n\\n def check_auth(self, *args):\\n self.userid, self.credentials = load_session_credentials(self)\\n self.mirror_service = create_service('mirror', 'v1', self.credentials)\\n # TODO: Also check that credentials are still valid.\\n if self.credentials:\\n try:\\n self.credentials.refresh(httplib2.Http())\\n return handler_method(self, *args)\\n except AccessTokenRefreshError:\\n # Access has been revoked.\\n store_userid(self, '')\\n credentials_entity = Credentials.get_by_key_name(self.userid)\\n if credentials_entity:\\n credentials_entity.delete()\\n self.redirect('/auth')\\n return check_auth\",\n \"def callback__access_token(req, test_env=test_env):\\n assert \\\"Authorization\\\" in req.headers\\n assert req.headers[\\\"Authorization\\\"].decode(\\\"utf-8\\\").startswith(\\\"OAuth \\\")\\n assert \\\"User-Agent\\\" in req.headers\\n assert req.headers[\\\"User-Agent\\\"].decode(\\\"utf-8\\\") == \\\"CustomApiClient v0\\\"\\n assert req.url == oauth1_utils.CustomApiClient.OAUTH1_SERVER_ACCESS_TOKEN\\n\\n # request as SERVER, no cookies\\n with IsolatedTestapp(test_env[\\\"testapp_authority\\\"]) as testapp:\\n _headers = string_headers(\\n req.headers\\n ) # these can end up being unicode in tests\\n res = testapp.get(\\n \\\"/authority/oauth1/access_token\\\",\\n headers=_headers,\\n extra_environ=test_env[\\\"extra_environ_authority\\\"],\\n status=200,\\n )\\n\\n # status is '200 OK'\\n # return in a format tailored for `requests`\\n return (int(res.status.split(\\\" \\\")[0]), res.headers, res.body)\",\n \"def login(request):\\n if request.method != 'POST':\\n return JsonResponse(\\n {\\\"detail\\\": 'Method {} not allowed.'.format(request.method)}, status=status.HTTP_405_METHOD_NOT_ALLOWED\\n )\\n username = request.POST['username']\\n password = request.POST['password']\\n if username == 'admin' and password == 'admin':\\n payload = {\\n \\\"username\\\": username,\\n \\\"exp\\\": time.time() + 300,\\n\\n }\\n token = encode(payload, JWT_KEY, algorithm=\\\"HS256\\\")\\n return JsonResponse({\\\"access_token\\\": token}, status=status.HTTP_200_OK)\\n else:\\n return JsonResponse({\\\"detail\\\": 'Invalid username or password'}, status=status.HTTP_401_UNAUTHORIZED)\",\n \"def authenticate(self):\\n\\n headers = {\\n 'Authorization': 'Bearer ' + self.access_token,\\n 'ClientId': self.client_id,\\n }\\n self.headers.update(headers)\",\n \"def validate_auth():\\n try:\\n token = oidc.get_access_token()\\n except TypeError:\\n # raised when the token isn't accessible to the oidc lib\\n raise Unauthorized(\\\"missing auth token\\\")\\n\\n if not oidc.validate_token(token):\\n terminate_session()\\n raise Unauthorized(\\\"invalid auth token\\\")\\n return token\",\n \"async def login_for_access_token(email: str = Form(...), password: str = Form(...)):\\n user = await authenticate_user(email, password)\\n if not user:\\n raise HTTPException(\\n status_code=status.HTTP_401_UNAUTHORIZED,\\n detail=\\\"Incorrect email or password\\\",\\n headers={\\\"WWW-Authenticate\\\": \\\"Bearer\\\"},\\n )\\n if user.disabled:\\n raise HTTPException(\\n status_code=status.HTTP_401_UNAUTHORIZED,\\n detail=\\\"User is disabled\\\",\\n headers={\\\"WWW-Authenticate\\\": \\\"Bearer\\\"},\\n )\\n else:\\n access_token_expires = datetime.timedelta(minutes=TOKEN_EXPIRE)\\n access_token = create_access_token(\\n data={\\\"sub\\\": user.email}, expires_delta=access_token_expires\\n )\\n return {\\\"credentials\\\": access_token, \\\"scheme\\\": \\\"Bearer\\\"}\",\n \"def __init__(self, access_token=None):\\r\\n self.access_token = access_token\\r\\n\\r\\n self.add_filter(self.add_auth)\",\n \"def get_access_token(self, request) -> str or Exception:\\n pass\",\n \"def authenticated(func):\\n\\n def check_access_token(alexafied_request):\\n \\\"\\\"\\\" :type alexafied_request AlexaRequest\\\"\\\"\\\"\\n try:\\n access_token = alexafied_request.access_token()\\n except KeyError as e:\\n print(\\\"User is probably not authenticated. error: \\\" + str(e) + \\\"missing\\\")\\n return handle_error_states \\\\\\n .handle_not_authenticated(alexafied_request)\\n\\n _remember_user_id(alexafied_request, access_token)\\n return func(alexafied_request)\\n\\n return check_access_token\",\n \"def login_access_token(form_data: OAuth2PasswordRequestForm = Depends()):\\n user = auth_handler.authenticate_user(\\n username=form_data.username, password=form_data.password\\n )\\n if user is None:\\n raise HTTPException(\\n detail=\\\"Incorrect username and/or password\\\", status_code=400\\n )\\n\\n return APIResponse(\\n msg=TokenResponse(\\n access_token=auth_handler.encode_token(user.id), token_type=\\\"bearer\\\"\\n )\\n )\",\n \"def auth_access_token_request(self, auth_access_token_request):\\n\\n self._auth_access_token_request = auth_access_token_request\",\n \"def __oauth_login(self):\\n\\n token = self.accessToken()\\n if not token:\\n session.redirect_uri = self.__redirect_uri()\\n data = dict(redirect_uri=session.redirect_uri,\\n response_type='code',\\n client_id=self.env.client_id)\\n auth_request_url = self.env.auth_url + \\\"?\\\" + urlencode(data)\\n redirect(auth_request_url)\\n return\",\n \"def _get_token(self):\\n if self._access_token is None or self._is_expired():\\n self._refresh_token()\\n return self._access_token\",\n \"def _authenticate(self):\\n # Check if token expired\\n if self._token_expire and self._token_expire < _time():\\n self._token = ''\\n\\n # Get OAuth2 token\\n if not self._token:\\n # Get user credentials\\n credentials = json_read(get_accelize_cred())\\n client_id = credentials['client_id']\\n client_secret = credentials['client_secret']\\n\\n # Endpoint override in credentials file\\n self._endpoint = credentials.get('endpoint', self._ENDPOINT)\\n\\n # Try to get CLI cached token\\n try:\\n self._token, self._token_expire = get_cli_cache(client_id)\\n\\n # Try to get token from web service\\n except TypeError:\\n response = self._request(\\n 'post', f'{self._endpoint}/o/token/',\\n data={\\\"grant_type\\\": \\\"client_credentials\\\"},\\n auth=(client_id, client_secret),\\n timeout=self._TIMEOUT)\\n\\n if response.status_code >= 300:\\n raise _AuthenticationException(\\n 'Unable to authenticate client ID starting by '\\n f'\\\"{client_id[:10]}\\\": '\\n f'{self._get_error_message(response)}')\\n\\n access = response.json()\\n self._token = access['access_token']\\n self._token_expire = int(_time()) + access['expires_in'] - 1\\n\\n # Cache token value for future CLI usage\\n set_cli_cache(client_id, [self._token, self._token_expire],\\n self._token_expire)\",\n \"def auth(self, user):\",\n \"def auth():\\n\\tcode = request.query.code\\n\\tauth = 'https://foursquare.com/oauth2/access_token'\\n\\tparams = dict(\\n\\t\\tclient_id=CLIENT_ID,\\n\\t\\tclient_secret=CLIENT_SECRET,\\n\\t\\tgrant_type='authorization_code',\\n\\t\\tredirect_uri=REDIRECT_URI,\\n\\t\\tcode=code\\n\\t)\\n\\tauth_says = fetch('%s?%s'%(auth, urlencode(params)))\\n\\tauth_response = json.loads(auth_says.content)\\n\\tif 'access_token' in auth_response:\\n\\t\\toauth_token=auth_response['access_token']\\n\\t\\tresponse.set_cookie('user', oauth_token, secret=CLIENT_SECRET)\\n\\t\\tlogging.info('new oauth_token:%s'%oauth_token)\\n\\t\\tredirect('/')\\n\\telse:\\n\\t\\tlogging.error(auth_response)\\n\\t\\tabort()\",\n \"def _auth_via_token(self) -> Auth.contextmgr:\\n warnings.warn(\\n \\\"Authentication via personal access token is deprecated. \\\"\\n \\\"Please, use the password authentication to avoid inconsistencies.\\\",\\n AirflowProviderDeprecationWarning,\\n )\\n tableau_auth = PersonalAccessTokenAuth(\\n token_name=self.conn.extra_dejson[\\\"token_name\\\"],\\n personal_access_token=self.conn.extra_dejson[\\\"personal_access_token\\\"],\\n site_id=self.site_id,\\n )\\n return self.server.auth.sign_in_with_personal_access_token(tableau_auth)\",\n \"def handler(self):\\r\\n credentials = self.get_credentials()\\r\\n return credentials.authorize(httplib2.Http())\",\n \"def authenticate_from_server(self, registered_provider):\\n return eval(f\\\"registered_provider.{self.name}.authorize_access_token()\\\")\",\n \"def _get_access_token(self):\\n\\n self._access_token = None\\n if not self._refresh_token:\\n raise ValueError(\\\"Refresh Token not set\\\")\\n\\n doc = minidom.Document()\\n root = doc.createElement('tokenAuthRequest')\\n doc.appendChild(root)\\n aki = doc.createElement('accessKeyId')\\n aki.appendChild(doc.createTextNode(self.publicAccessKey))\\n root.appendChild(aki)\\n pak = doc.createElement('privateAccessKey')\\n pak.appendChild(doc.createTextNode(self.privateAccessKey))\\n root.appendChild(pak)\\n rt = doc.createElement('refreshToken')\\n rt.appendChild(doc.createTextNode(self._refresh_token))\\n root.appendChild(rt)\\n data = doc.toprettyxml()\\n\\n resp = requests.post(BASE_URL + \\\"authorization\\\", data=data, headers=self._default_headers, verify=False)\\n if resp.status_code >= 300:\\n raise Exception(\\\"Failed to claim access token: {}\\\".format(resp))\\n\\n vals = etree_to_dict(ET.XML(resp.content.decode('utf-8')))\\n\\n self._access_token = resp.headers.get('Location', None)\\n if not self._access_token:\\n raise ValueError(\\\"Unable to get access token\\\")\\n\\n self._user_id = os.path.basename(vals.get('authorization').get('user'))\\n\\n # Always set the expiry 30 minutes from now so we dont have to deal with parsing timezones\\n # self._access_token_expiry = dateutil_parser.parse(vals.get('authorization').get('expiration'))\\n self._access_token_expiry = datetime.datetime.utcnow() + datetime.timedelta(minutes=30)\",\n \"def __init__(self):\\n self.authurl = Config().auth\\n self.baseurl = Config().api\\n self.s = Session()\\n self.s.headers = {'Accept': 'application/json'}\\n data = {\\\"grant_type\\\": \\\"client_credentials\\\", \\\"scope\\\": \\\"/read-public\\\", \\\"client_id\\\": Config().client_id,\\n \\\"client_secret\\\": Config().client_secret}\\n r = self.s.request(method=\\\"post\\\", url=self.authurl, data=data)\\n self.s.headers = {'Accept': 'application/json', \\\"Access token\\\": r.json()[\\\"access_token\\\"]}\",\n \"def _get_access_token(self):\\n if self._service_token:\\n logger.info('Use service token: %s',\\n 5 * '*' + self._service_token[50:])\\n return self._service_token\\n\\n if not all([self.app_id, self._login, self._password]):\\n raise ValueError(\\n 'app_id=%s, login=%s password=%s (masked) must be given'\\n % (self.app_id, self._login,\\n '*' * len(self._password) if self._password else 'None'))\\n\\n logger.info(\\\"Getting access token for user '%s'\\\" % self._login)\\n with self.http_session as s:\\n if self._client_secret:\\n url_query_params = self.do_direct_authorization(session=s)\\n else:\\n self.do_login(http_session=s)\\n url_query_params = self.do_implicit_flow_authorization(session=s)\\n logger.debug('url_query_params: %s', url_query_params)\\n\\n if 'access_token' in url_query_params:\\n logger.info('Access token has been gotten')\\n return url_query_params['access_token']\\n else:\\n raise VkAuthError('OAuth2 authorization error. Url params: %s'\\n % url_query_params)\",\n \"def __enter__(self):\\r\\n if not AuthHelper.check_login(self.request, self.username):\\r\\n raise HTTPForbidden('Invalid Authorization')\",\n \"def test_access_token_get(self):\\n client = oauth.Client(self.consumer, None)\\n resp, content = client.request(self._uri('request_token'), \\\"GET\\\")\\n\\n self.assertEqual(int(resp['status']), 200)\",\n \"def get_access_token(self, path='/oauth/token', data={}):\\n if data.keys():\\n data.update(self.data)\\n else:\\n data = self.data.copy()\\n data.update({\\n 'grant_type': 'password',\\n 'email': self.env.get('TESLA_EMAIL'),\\n 'password': self.env.get('TESLA_PASSWORD')\\n })\\n try:\\n req = requests.post(url='%s%s' % (self.url, path), data=data)\\n # print(req.status_code)\\n # print(req.content)\\n self.token.update(req.json())\\n except:\\n raise 'invalid credentials'\\n return self.token\",\n \"def _on_access_token(self, future, response):\\n if response.error:\\n future.set_exception(AuthError('Github auth error: %s' % str(response)))\\n return\\n \\n args = tornado.escape.parse_qs_bytes(\\n tornado.escape.native_str(response.body))\\n\\n future.set_result(args)\",\n \"def token_auth(self):\\n self.client = APIClient()\\n self.user = User.objects.create_user(username='testuser', email='test@test.com', password='testpassword')\\n self.token = Token.objects.create(user=self.user)\\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token.key)\",\n \"def auth_check():\\n try:\\n access_token = session_get('access_token')\\n access_token_secret = session_get('access_token_secret')\\n\\n if access_token and access_token_secret:\\n tk = get_twitter_keys()\\n client = UserClient(\\n tk.consumer_key,\\n tk.consumer_secret,\\n access_token=access_token,\\n access_token_secret=access_token_secret)\\n \\\"\\\"\\\"\\n We need to make a call to verify_credentials in case the user\\n has revoked access for this application. This is a rate-limited\\n call and so this approach might not be ideal. If we end up\\n having rate-limiting problems, we might try giving each user\\n a unique application ID that is kept in local storage and used\\n as a lookup for Twitter creds (vs. session data which is domain-\\n specific and thus problematic for our extension-approach). This\\n might allow us to consolidate Twitter creds per user rather than\\n storing them for each domain visited.\\\"\\\"\\\"\\n verif = client.api.account.verify_credentials.get()\\n if verif.headers['status'].split()[0] == '200':\\n return jsonify({'is_auth': 1})\\n else:\\n # possibly revoked access, although this will probably\\n # get handled by the TwitterAuthError catch\\n remove_session_credentials()\\n return jsonify({'is_auth': 0})\\n tk = get_twitter_keys()\\n client = UserClient(tk.consumer_key, tk.consumer_secret)\\n callback = 'http://'+request.host+url_for('auth_verify')\\n token = client.get_authorize_token(callback)\\n session_set('auth_token', token.oauth_token)\\n session_set('auth_token_secret', token.oauth_token_secret)\\n session_set('auth_redirect',\\n request.args.get('redirect') or '')\\n if (\\n 'html' in request.headers['Accept']\\n and request.args.get('_format') != 'json'):\\n return redirect(token.auth_url)\\n else:\\n data = {'is_auth': 0, 'auth_url': token.auth_url}\\n return jsonify(data)\\n except TwitterAuthError:\\n remove_session_credentials()\\n return jsonify({'is_auth': 0})\\n except Exception, e:\\n traceback.print_exc()\\n return jsonify({'error': str(e)})\",\n \"def login():\\n req = request.get_json(force=True)\\n username = req.get('username', None)\\n password = req.get('password', None)\\n user = guard.authenticate(username, password)\\n ret = {'access_token': guard.encode_jwt_token(user)}\\n return ret, 200\",\n \"def get_access_token(self):\\n payload = {\\n 'grant_type': 'client_credentials',\\n 'client_id': self.client_id,\\n 'client_secret': self.client_secret,\\n 'resource': self.resource\\n }\\n res = requests.post(self.auth_url, data=payload)\\n data = res.json()\\n if res.status_code == 200:\\n return data['access_token'], res\\n\\n return False, res\",\n \"def authorize():\\n token = oauth.tapkey.authorize_access_token()\\n session['auth'] = token\\n return redirect(url_for('owner_account_chooser'))\",\n \"def access_token(self):\\n access_token = self.session.get('component_access_token')\\n if access_token:\\n if not self.expires_at:\\n # user provided access_token, just return it\\n return access_token\\n\\n timestamp = time.time()\\n if self.expires_at - timestamp > 60:\\n return access_token\\n\\n self.fetch_access_token()\\n return self.session.get('component_access_token')\",\n \"async def _fetch_access_token(session: ClientSession) -> dict:\\n LOGGER.debug('fetching access token...')\\n password = config.get('WFWX_SECRET')\\n user = config.get('WFWX_USER')\\n auth_url = config.get('WFWX_AUTH_URL')\\n async with session.get(auth_url, auth=BasicAuth(login=user, password=password)) as response:\\n return await response.json()\",\n \"def login():\\n data = request.get_json()\\n if 'username' in data and 'password' in data:\\n username = data['username']\\n password = data['password']\\n access_token = authenticate(username, password)\\n if access_token is not None:\\n print('access token: ' + access_token)\\n return jsonify({'access_token': access_token})\\n else:\\n abort(403)\\n else:\\n abort(400)\",\n \"def __call__(self, context, callback):\\r\\n\\r\\n callback((('authorization', 'Bearer ' + self.token_hash ),), None)\",\n \"def authenticate(user, request):\",\n \"def test_replace_o_auth_access_token(self):\\n pass\",\n \"def authenticate_for_token(auth=None):\\n try:\\n auth_info = core.AuthInfo.create(auth=auth)\\n auth_context = core.AuthContext(method_names=[],\\n bind={})\\n authenticate(auth_info, auth_context)\\n if auth_context.get('access_token_id'):\\n auth_info.set_scope(None, auth_context['project_id'], None)\\n _check_and_set_default_scoping(auth_info, auth_context)\\n (domain_id, project_id, trust, unscoped, system) = (\\n auth_info.get_scope()\\n )\\n trust_id = trust.get('id') if trust else None\\n\\n receipt = receipt_handlers.extract_receipt(auth_context)\\n\\n # NOTE(notmorgan): only methods that actually run and succeed will\\n # be in the auth_context['method_names'] list. Do not blindly take\\n # the values from auth_info, look at the authoritative values. Make\\n # sure the set is unique.\\n # NOTE(adriant): The set of methods will also include any methods from\\n # the given receipt.\\n if receipt:\\n method_names_set = set(\\n auth_context.get('method_names', []) + receipt.methods)\\n else:\\n method_names_set = set(auth_context.get('method_names', []))\\n method_names = list(method_names_set)\\n\\n app_cred_id = None\\n if 'application_credential' in method_names:\\n token_auth = auth_info.auth['identity']\\n app_cred_id = token_auth['application_credential']['id']\\n\\n # Do MFA Rule Validation for the user\\n if not core.UserMFARulesValidator.check_auth_methods_against_rules(\\n auth_context['user_id'], method_names_set):\\n raise exception.InsufficientAuthMethods(\\n user_id=auth_context['user_id'],\\n methods=method_names)\\n\\n expires_at = auth_context.get('expires_at')\\n token_audit_id = auth_context.get('audit_id')\\n\\n token = PROVIDERS.token_provider_api.issue_token(\\n auth_context['user_id'], method_names, expires_at=expires_at,\\n system=system, project_id=project_id, domain_id=domain_id,\\n auth_context=auth_context, trust_id=trust_id,\\n app_cred_id=app_cred_id, parent_audit_id=token_audit_id)\\n\\n # NOTE(wanghong): We consume a trust use only when we are using\\n # trusts and have successfully issued a token.\\n if trust:\\n PROVIDERS.trust_api.consume_use(token.trust_id)\\n\\n return token\\n except exception.TrustNotFound as e:\\n LOG.warning(six.text_type(e))\\n raise exception.Unauthorized(e)\",\n \"def get_access_token(self, *args, **kwargs):\\n raise NotImplementedError('Subclasses must implement this method.')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7375866","0.7111791","0.7054406","0.70490533","0.70432705","0.7001905","0.6994722","0.6989808","0.6969049","0.6969049","0.69665104","0.69614655","0.6938845","0.68905526","0.6871101","0.67952436","0.6786014","0.6768033","0.6756323","0.67161775","0.67161775","0.6711557","0.6699602","0.6691872","0.66901547","0.66637635","0.6646128","0.66447806","0.664213","0.66311157","0.65839195","0.6571867","0.65665334","0.65633935","0.65581745","0.6557639","0.6551968","0.6551321","0.65375996","0.6526483","0.65078235","0.6506761","0.65039474","0.65007526","0.64962506","0.64883846","0.6480366","0.6478434","0.6475755","0.6473726","0.6472999","0.6457752","0.64444375","0.6433204","0.64262044","0.64141864","0.64109993","0.6400112","0.64000386","0.6395648","0.6392346","0.63812715","0.6375559","0.6357743","0.6354459","0.63475066","0.63434535","0.63343936","0.63324594","0.6327363","0.6324626","0.63238055","0.6320932","0.6306408","0.6297211","0.62930965","0.62767816","0.62737894","0.62720406","0.62707055","0.62702435","0.62658274","0.62555134","0.62549174","0.6244994","0.623934","0.62331","0.62280107","0.62272316","0.62268436","0.6224116","0.621492","0.6206744","0.62039554","0.6203335","0.62029195","0.6201378","0.6199767","0.61952376","0.61844724","0.61838984"],"string":"[\n \"0.7375866\",\n \"0.7111791\",\n \"0.7054406\",\n \"0.70490533\",\n \"0.70432705\",\n \"0.7001905\",\n \"0.6994722\",\n \"0.6989808\",\n \"0.6969049\",\n \"0.6969049\",\n \"0.69665104\",\n \"0.69614655\",\n \"0.6938845\",\n \"0.68905526\",\n \"0.6871101\",\n \"0.67952436\",\n \"0.6786014\",\n \"0.6768033\",\n \"0.6756323\",\n \"0.67161775\",\n \"0.67161775\",\n \"0.6711557\",\n \"0.6699602\",\n \"0.6691872\",\n \"0.66901547\",\n \"0.66637635\",\n \"0.6646128\",\n \"0.66447806\",\n \"0.664213\",\n \"0.66311157\",\n \"0.65839195\",\n \"0.6571867\",\n \"0.65665334\",\n \"0.65633935\",\n \"0.65581745\",\n \"0.6557639\",\n \"0.6551968\",\n \"0.6551321\",\n \"0.65375996\",\n \"0.6526483\",\n \"0.65078235\",\n \"0.6506761\",\n \"0.65039474\",\n \"0.65007526\",\n \"0.64962506\",\n \"0.64883846\",\n \"0.6480366\",\n \"0.6478434\",\n \"0.6475755\",\n \"0.6473726\",\n \"0.6472999\",\n \"0.6457752\",\n \"0.64444375\",\n \"0.6433204\",\n \"0.64262044\",\n \"0.64141864\",\n \"0.64109993\",\n \"0.6400112\",\n \"0.64000386\",\n \"0.6395648\",\n \"0.6392346\",\n \"0.63812715\",\n \"0.6375559\",\n \"0.6357743\",\n \"0.6354459\",\n \"0.63475066\",\n \"0.63434535\",\n \"0.63343936\",\n \"0.63324594\",\n \"0.6327363\",\n \"0.6324626\",\n \"0.63238055\",\n \"0.6320932\",\n \"0.6306408\",\n \"0.6297211\",\n \"0.62930965\",\n \"0.62767816\",\n \"0.62737894\",\n \"0.62720406\",\n \"0.62707055\",\n \"0.62702435\",\n \"0.62658274\",\n \"0.62555134\",\n \"0.62549174\",\n \"0.6244994\",\n \"0.623934\",\n \"0.62331\",\n \"0.62280107\",\n \"0.62272316\",\n \"0.62268436\",\n \"0.6224116\",\n \"0.621492\",\n \"0.6206744\",\n \"0.62039554\",\n \"0.6203335\",\n \"0.62029195\",\n \"0.6201378\",\n \"0.6199767\",\n \"0.61952376\",\n \"0.61844724\",\n \"0.61838984\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6393,"cells":{"query":{"kind":"string","value":"Used by django auth system. We don`t need this method implementation."},"document":{"kind":"string","value":"def get_user(self, user_id):\n return None # noqa: WPS324"},"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 authentication_hook(self):\n pass","def auth(self, user):","def _get_auth_string(self):","def authenticate_user(self):\n raise NotImplementedError(\n \"\"\"\n authenticate_user must be implemented by a child class\n \"\"\"\n )","def auth():\n pass","def auth():\n pass","def requires_auth(self):\n return True","def authenticate(self, request):\n return None","def is_authenticated(self):\n return True","def authorized(self):\n pass","def auth(self):\n return auth.get_auth()","def login(self):\n #raise NotImplementedError(\"This method must be overridden\")","def get_authenticated_denied(self):","def add_auth(self, http_request):\r\n pass","def get_authenticated_granted(self):","def authenticate(user, request):","def _check_auth(self, group_id):\n return","def get_auth(self, username, password):\n raise NotImplementedError()","def __init__(self):\n self.auth()","def test_not_authenticated(self):\n pass # lint-amnesty, pylint: disable=unnecessary-pass","def test_not_authenticated(self):\n pass # lint-amnesty, pylint: disable=unnecessary-pass","def get_auth_state(self):\n raise NotImplementedError()","def get_auth(self):\n return {'method': yeti_config.core.auth}","def is_authenticated(self):\n return False","def authorization():\n pass","def auth_token(self):","def user(self):\n pass","def is_authenticated(self):\n return True","def is_authenticated(self):\n return True","def is_authenticated(self):\n return True","def is_authenticated(self):\n return True","def is_authenticated(self):\n return True","def is_authenticated(self):\n return True","def is_authenticated(self):\n return True","def auth(self):\n return self._auth","def check_auth():","def is_authenticated(self):\n return True #self.authenticated","def auth(self):\n return auth.get_auth()","def is_authenticated(self, request, **kwargs):\r\n return True","def auth(self):\n return self.user.get('current')","def log_in(self):\n\t\tpass","def get_auth(self):\n return self._auth","def _login(self, *args, **kwargs):\n pass","def user(self):","def authenticator():","def __init__(self):\n\n self._authorize()","def login(self):","def setUpAuth(self):\n self.user, self.user_headers = self.authUser()\n self.admin, self.admin_headers = self.authAdmin()","def get_user(self):\n return None","def get_authorization():\n return True","def auth(self):\n return dict(page='auth')","def auth(self):\n return dict(page='auth')","def _set_authenticator(self):\n pass","def post_setup(cls):\n super().post_setup()\n cls.REST_FRAMEWORK[\"DEFAULT_AUTHENTICATION_CLASSES\"] = (\n \"magnify.apps.core.authentication.DelegatedJWTAuthentication\",\n \"rest_framework.authentication.SessionAuthentication\",\n )","def lesson_auth(request):","def authenticate(self):\n #it's weird i have to do this here, but the code makes this not simple\n auth_json={'email':self.user, 'password':self.password}\n #send a post with no auth. prevents an infinite loop\n auth_response = self.post('/auth', data = json.dumps(auth_json), auth =\n None)\n\n _token = auth_response.json['token']\n\n self._token = _token\n self._wrapped.auth = SpringAuth(_token)","def auth(self):\n ok = False\n if self.private_token:\n ok = self.token_auth()\n if not ok:\n self.credentials_auth()","def auth_required(self, cls):\n assert cls.authentication_classes == [JWTKeyAuthentication]","def Login(self):\n raise NotImplementedError()","def login(self):\n\t\treturn","def __init__(self, username, password, email, authenticator):\n super().__init__(username, password, email)\n if password != \"superpassword\":\n raise NotAdminError\n self.authenticator = authenticator\n self.permissions = {}","def __init__(self, request=None, *args, **kwargs):\n self.request = request\n self.user_cache = None\n super(AuthenticationFormCustom, self).__init__(*args, **kwargs)","def authn_and_authz():\n authentication()\n authorization()","def auth(self):\n if self.get_saved_token():\n return\n self.oauth2()\n self.save_token()","def auth(self):\n return AuthManager(self)","def get_user(self):\n raise NotImplementedError","def get_request_auth_app(self):\n pass","def __enter__(self):\r\n if not AuthHelper.check_login(self.request, self.username):\r\n raise HTTPForbidden('Invalid Authorization')","def on_user_create(self, user):","def dispatch(self, request, *args, **kwargs):\n if request.user.is_authenticated:\n return HttpResponseRedirect(reverse(\"home\"))\n return super(RegisterView, self).dispatch(request, *args, **kwargs)","def test_replace_o_auth_client_authorization(self):\n pass","def get_auth(self, name = \"memory\", *args, **kwargs):\r\n\r\n name_f = name.title() + \"Auth\"\r\n auth_c = getattr(netius.auth, name_f)\r\n return auth_c","def for_authenticate_only(self):\n self.token['type'] = 'auth'\n\n return self","def authenticate(self):\n\n def decorate(func, *args, **kws):\n \"\"\"\n A function returned as a object in load time,\n which returns inner function do_decorate().\n \"\"\"\n def do_authenticate():\n \"\"\"\n A function to perform authentication\n every time decorated function is called.\n \"\"\"\n #try:\n if 1:\n if 'referer' not in self.session:\n path = urlsplit(self.request.url)[2]\n self.session['referer'] = path\n self.session.put()\n #except:\n # pass\n aobj = self.config.auth_obj()\n self.get_controller()\n auth_res = aobj.auth(self.controller, *args, **kws)\n if auth_res:\n return func(*args, **kws)\n aobj.auth_redirect(self.controller, *args, **kws)\n # clear controller for development environment.\n\n return do_authenticate\n\n return decorate","def get_current_user(self):\n return None","def authenticate(request):\n if not current_user.is_authenticated:\n raise NoAuthProvided()\n if current_user.is_locked or not current_user.active:\n raise UnauthorizedError(\n 'Authentication failed for <User '\n f'username=`{current_user.username}`>. '\n 'Wrong credentials or locked account')\n return current_user","def before_request ():\n try:\n g.user = current_user\n except NameError:\n pass","def user_logged_in(self, sender, request, user, **kwargs):","def user_model(self): \n return self.auth.store.user_model","def get_authorization(self):\n raise NotImplemented()","def authenticated_user(self):\r\n return AuthenticatedUser(self)","def auth(self, username, password):\n return False","def authorization_url(self): # pragma: no cover\n raise NotImplementedError()","def is_authenticated(self):\r\n return self.authenticated","def check_authentication(self, request):\n if not self.request.user.is_authenticated:\n raise NotAuthenticated()","def get_authenticate_header(self):\n pass","def authenticated(self):\n # We don't support authentication yet\n return False","async def authenticate(self, request: Request):\n\n pass","def __init__(self, request=None, *args, **kwargs):\n self.request = request\n self.user_cache = None\n super(AuthForm, self).__init__(*args, **kwargs)","def user_init(self):\n pass","def _before_request():\n\n g.user = current_user","def __init__(self, request=None, *args, **kwargs):\r\n self.request = request\r\n self.user_cache = None\r\n super(ShortAuthenticationForm, self).__init__(*args, **kwargs)","def user_context(request): # pragma: no cover\n # Disabled; this is bad practice\n raise NotImplementedError","def _apply_auth(self, view_func):\n @functools.wraps(view_func)\n def decorated(*args, **kwargs):\n if not self.auth:\n return view_func(*args, **kwargs)\n\n auth_data = self.auth.get_authorization()\n\n if auth_data is None:\n return self._handle_authentication_error()\n\n if not self._authentication_callback or not self._authentication_callback(auth_data):\n return self._handle_authentication_error()\n\n return view_func(*args, **kwargs)\n\n return decorated","def _get_user_password(self):\n return self.__user_password","def user(self):\n return self.create_user","def user_auth(request):\n if request.user.is_authenticated:\n user = User.objects.get(email=request.user.email)\n if UserInformation.objects.filter(user=user).exists():\n return True\n return False","def authenticate(cls, handler):\n return None","def before(self):\n access_token = self.request.header(\"HTTP_AUTHORIZATION\")\n\n if utils.validate_token(access_token) is True:\n token = re.sub(\"Bearer \", \"\", access_token)\n creator_info = utils.decode_token(token)\n if creator_info != False:\n creator_user = User.find(creator_info.get(\"id\"))\n self.request.set_user(creator_user)\n else:\n self.response.json({\"error\": \"Unauthorized access\"})\n \n if utils.validate_token(access_token) is not True:\n self.response.json({\"error\": \"Unauthorized access\"})","def authenticate( self ):\n\n print(\"Getting new token\")\n self.getFrob()\n self.getAuthKey()\n self.getToken()\n self.cacheToken()","def before_request():\n g.user = get_user()"],"string":"[\n \"def authentication_hook(self):\\n pass\",\n \"def auth(self, user):\",\n \"def _get_auth_string(self):\",\n \"def authenticate_user(self):\\n raise NotImplementedError(\\n \\\"\\\"\\\"\\n authenticate_user must be implemented by a child class\\n \\\"\\\"\\\"\\n )\",\n \"def auth():\\n pass\",\n \"def auth():\\n pass\",\n \"def requires_auth(self):\\n return True\",\n \"def authenticate(self, request):\\n return None\",\n \"def is_authenticated(self):\\n return True\",\n \"def authorized(self):\\n pass\",\n \"def auth(self):\\n return auth.get_auth()\",\n \"def login(self):\\n #raise NotImplementedError(\\\"This method must be overridden\\\")\",\n \"def get_authenticated_denied(self):\",\n \"def add_auth(self, http_request):\\r\\n pass\",\n \"def get_authenticated_granted(self):\",\n \"def authenticate(user, request):\",\n \"def _check_auth(self, group_id):\\n return\",\n \"def get_auth(self, username, password):\\n raise NotImplementedError()\",\n \"def __init__(self):\\n self.auth()\",\n \"def test_not_authenticated(self):\\n pass # lint-amnesty, pylint: disable=unnecessary-pass\",\n \"def test_not_authenticated(self):\\n pass # lint-amnesty, pylint: disable=unnecessary-pass\",\n \"def get_auth_state(self):\\n raise NotImplementedError()\",\n \"def get_auth(self):\\n return {'method': yeti_config.core.auth}\",\n \"def is_authenticated(self):\\n return False\",\n \"def authorization():\\n pass\",\n \"def auth_token(self):\",\n \"def user(self):\\n pass\",\n \"def is_authenticated(self):\\n return True\",\n \"def is_authenticated(self):\\n return True\",\n \"def is_authenticated(self):\\n return True\",\n \"def is_authenticated(self):\\n return True\",\n \"def is_authenticated(self):\\n return True\",\n \"def is_authenticated(self):\\n return True\",\n \"def is_authenticated(self):\\n return True\",\n \"def auth(self):\\n return self._auth\",\n \"def check_auth():\",\n \"def is_authenticated(self):\\n return True #self.authenticated\",\n \"def auth(self):\\n return auth.get_auth()\",\n \"def is_authenticated(self, request, **kwargs):\\r\\n return True\",\n \"def auth(self):\\n return self.user.get('current')\",\n \"def log_in(self):\\n\\t\\tpass\",\n \"def get_auth(self):\\n return self._auth\",\n \"def _login(self, *args, **kwargs):\\n pass\",\n \"def user(self):\",\n \"def authenticator():\",\n \"def __init__(self):\\n\\n self._authorize()\",\n \"def login(self):\",\n \"def setUpAuth(self):\\n self.user, self.user_headers = self.authUser()\\n self.admin, self.admin_headers = self.authAdmin()\",\n \"def get_user(self):\\n return None\",\n \"def get_authorization():\\n return True\",\n \"def auth(self):\\n return dict(page='auth')\",\n \"def auth(self):\\n return dict(page='auth')\",\n \"def _set_authenticator(self):\\n pass\",\n \"def post_setup(cls):\\n super().post_setup()\\n cls.REST_FRAMEWORK[\\\"DEFAULT_AUTHENTICATION_CLASSES\\\"] = (\\n \\\"magnify.apps.core.authentication.DelegatedJWTAuthentication\\\",\\n \\\"rest_framework.authentication.SessionAuthentication\\\",\\n )\",\n \"def lesson_auth(request):\",\n \"def authenticate(self):\\n #it's weird i have to do this here, but the code makes this not simple\\n auth_json={'email':self.user, 'password':self.password}\\n #send a post with no auth. prevents an infinite loop\\n auth_response = self.post('/auth', data = json.dumps(auth_json), auth =\\n None)\\n\\n _token = auth_response.json['token']\\n\\n self._token = _token\\n self._wrapped.auth = SpringAuth(_token)\",\n \"def auth(self):\\n ok = False\\n if self.private_token:\\n ok = self.token_auth()\\n if not ok:\\n self.credentials_auth()\",\n \"def auth_required(self, cls):\\n assert cls.authentication_classes == [JWTKeyAuthentication]\",\n \"def Login(self):\\n raise NotImplementedError()\",\n \"def login(self):\\n\\t\\treturn\",\n \"def __init__(self, username, password, email, authenticator):\\n super().__init__(username, password, email)\\n if password != \\\"superpassword\\\":\\n raise NotAdminError\\n self.authenticator = authenticator\\n self.permissions = {}\",\n \"def __init__(self, request=None, *args, **kwargs):\\n self.request = request\\n self.user_cache = None\\n super(AuthenticationFormCustom, self).__init__(*args, **kwargs)\",\n \"def authn_and_authz():\\n authentication()\\n authorization()\",\n \"def auth(self):\\n if self.get_saved_token():\\n return\\n self.oauth2()\\n self.save_token()\",\n \"def auth(self):\\n return AuthManager(self)\",\n \"def get_user(self):\\n raise NotImplementedError\",\n \"def get_request_auth_app(self):\\n pass\",\n \"def __enter__(self):\\r\\n if not AuthHelper.check_login(self.request, self.username):\\r\\n raise HTTPForbidden('Invalid Authorization')\",\n \"def on_user_create(self, user):\",\n \"def dispatch(self, request, *args, **kwargs):\\n if request.user.is_authenticated:\\n return HttpResponseRedirect(reverse(\\\"home\\\"))\\n return super(RegisterView, self).dispatch(request, *args, **kwargs)\",\n \"def test_replace_o_auth_client_authorization(self):\\n pass\",\n \"def get_auth(self, name = \\\"memory\\\", *args, **kwargs):\\r\\n\\r\\n name_f = name.title() + \\\"Auth\\\"\\r\\n auth_c = getattr(netius.auth, name_f)\\r\\n return auth_c\",\n \"def for_authenticate_only(self):\\n self.token['type'] = 'auth'\\n\\n return self\",\n \"def authenticate(self):\\n\\n def decorate(func, *args, **kws):\\n \\\"\\\"\\\"\\n A function returned as a object in load time,\\n which returns inner function do_decorate().\\n \\\"\\\"\\\"\\n def do_authenticate():\\n \\\"\\\"\\\"\\n A function to perform authentication\\n every time decorated function is called.\\n \\\"\\\"\\\"\\n #try:\\n if 1:\\n if 'referer' not in self.session:\\n path = urlsplit(self.request.url)[2]\\n self.session['referer'] = path\\n self.session.put()\\n #except:\\n # pass\\n aobj = self.config.auth_obj()\\n self.get_controller()\\n auth_res = aobj.auth(self.controller, *args, **kws)\\n if auth_res:\\n return func(*args, **kws)\\n aobj.auth_redirect(self.controller, *args, **kws)\\n # clear controller for development environment.\\n\\n return do_authenticate\\n\\n return decorate\",\n \"def get_current_user(self):\\n return None\",\n \"def authenticate(request):\\n if not current_user.is_authenticated:\\n raise NoAuthProvided()\\n if current_user.is_locked or not current_user.active:\\n raise UnauthorizedError(\\n 'Authentication failed for <User '\\n f'username=`{current_user.username}`>. '\\n 'Wrong credentials or locked account')\\n return current_user\",\n \"def before_request ():\\n try:\\n g.user = current_user\\n except NameError:\\n pass\",\n \"def user_logged_in(self, sender, request, user, **kwargs):\",\n \"def user_model(self): \\n return self.auth.store.user_model\",\n \"def get_authorization(self):\\n raise NotImplemented()\",\n \"def authenticated_user(self):\\r\\n return AuthenticatedUser(self)\",\n \"def auth(self, username, password):\\n return False\",\n \"def authorization_url(self): # pragma: no cover\\n raise NotImplementedError()\",\n \"def is_authenticated(self):\\r\\n return self.authenticated\",\n \"def check_authentication(self, request):\\n if not self.request.user.is_authenticated:\\n raise NotAuthenticated()\",\n \"def get_authenticate_header(self):\\n pass\",\n \"def authenticated(self):\\n # We don't support authentication yet\\n return False\",\n \"async def authenticate(self, request: Request):\\n\\n pass\",\n \"def __init__(self, request=None, *args, **kwargs):\\n self.request = request\\n self.user_cache = None\\n super(AuthForm, self).__init__(*args, **kwargs)\",\n \"def user_init(self):\\n pass\",\n \"def _before_request():\\n\\n g.user = current_user\",\n \"def __init__(self, request=None, *args, **kwargs):\\r\\n self.request = request\\r\\n self.user_cache = None\\r\\n super(ShortAuthenticationForm, self).__init__(*args, **kwargs)\",\n \"def user_context(request): # pragma: no cover\\n # Disabled; this is bad practice\\n raise NotImplementedError\",\n \"def _apply_auth(self, view_func):\\n @functools.wraps(view_func)\\n def decorated(*args, **kwargs):\\n if not self.auth:\\n return view_func(*args, **kwargs)\\n\\n auth_data = self.auth.get_authorization()\\n\\n if auth_data is None:\\n return self._handle_authentication_error()\\n\\n if not self._authentication_callback or not self._authentication_callback(auth_data):\\n return self._handle_authentication_error()\\n\\n return view_func(*args, **kwargs)\\n\\n return decorated\",\n \"def _get_user_password(self):\\n return self.__user_password\",\n \"def user(self):\\n return self.create_user\",\n \"def user_auth(request):\\n if request.user.is_authenticated:\\n user = User.objects.get(email=request.user.email)\\n if UserInformation.objects.filter(user=user).exists():\\n return True\\n return False\",\n \"def authenticate(cls, handler):\\n return None\",\n \"def before(self):\\n access_token = self.request.header(\\\"HTTP_AUTHORIZATION\\\")\\n\\n if utils.validate_token(access_token) is True:\\n token = re.sub(\\\"Bearer \\\", \\\"\\\", access_token)\\n creator_info = utils.decode_token(token)\\n if creator_info != False:\\n creator_user = User.find(creator_info.get(\\\"id\\\"))\\n self.request.set_user(creator_user)\\n else:\\n self.response.json({\\\"error\\\": \\\"Unauthorized access\\\"})\\n \\n if utils.validate_token(access_token) is not True:\\n self.response.json({\\\"error\\\": \\\"Unauthorized access\\\"})\",\n \"def authenticate( self ):\\n\\n print(\\\"Getting new token\\\")\\n self.getFrob()\\n self.getAuthKey()\\n self.getToken()\\n self.cacheToken()\",\n \"def before_request():\\n g.user = get_user()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7454468","0.7185157","0.7009156","0.688985","0.6836429","0.6836429","0.6824741","0.68042165","0.66339934","0.66053426","0.65637714","0.6532335","0.64916205","0.643852","0.63844854","0.6349493","0.6346315","0.6337269","0.6337102","0.63232756","0.63232756","0.63152874","0.6286801","0.62865573","0.6265758","0.622676","0.6221091","0.6212239","0.6212239","0.6212239","0.6212239","0.6212239","0.6212239","0.6212239","0.6200137","0.6194481","0.6147063","0.614454","0.61140156","0.6111437","0.6095134","0.6057075","0.6042581","0.60232806","0.6010686","0.6007514","0.6004853","0.5996986","0.59888","0.59837127","0.59624714","0.59624714","0.5960065","0.5954466","0.59370095","0.5935487","0.5920194","0.5917907","0.59092855","0.5909183","0.59090286","0.5903354","0.59030885","0.58716977","0.5866924","0.58629787","0.5860049","0.58510756","0.5845535","0.5826121","0.5820877","0.581491","0.58147687","0.581084","0.58081424","0.5793453","0.57908505","0.5785397","0.5778863","0.5773933","0.5771996","0.5765054","0.5747631","0.57472974","0.5744378","0.57384336","0.5735909","0.57298315","0.57287174","0.57229954","0.5719511","0.5717017","0.57020086","0.5694991","0.5691541","0.5686339","0.56855005","0.5681297","0.5678889","0.56585675","0.5654945"],"string":"[\n \"0.7454468\",\n \"0.7185157\",\n \"0.7009156\",\n \"0.688985\",\n \"0.6836429\",\n \"0.6836429\",\n \"0.6824741\",\n \"0.68042165\",\n \"0.66339934\",\n \"0.66053426\",\n \"0.65637714\",\n \"0.6532335\",\n \"0.64916205\",\n \"0.643852\",\n \"0.63844854\",\n \"0.6349493\",\n \"0.6346315\",\n \"0.6337269\",\n \"0.6337102\",\n \"0.63232756\",\n \"0.63232756\",\n \"0.63152874\",\n \"0.6286801\",\n \"0.62865573\",\n \"0.6265758\",\n \"0.622676\",\n \"0.6221091\",\n \"0.6212239\",\n \"0.6212239\",\n \"0.6212239\",\n \"0.6212239\",\n \"0.6212239\",\n \"0.6212239\",\n \"0.6212239\",\n \"0.6200137\",\n \"0.6194481\",\n \"0.6147063\",\n \"0.614454\",\n \"0.61140156\",\n \"0.6111437\",\n \"0.6095134\",\n \"0.6057075\",\n \"0.6042581\",\n \"0.60232806\",\n \"0.6010686\",\n \"0.6007514\",\n \"0.6004853\",\n \"0.5996986\",\n \"0.59888\",\n \"0.59837127\",\n \"0.59624714\",\n \"0.59624714\",\n \"0.5960065\",\n \"0.5954466\",\n \"0.59370095\",\n \"0.5935487\",\n \"0.5920194\",\n \"0.5917907\",\n \"0.59092855\",\n \"0.5909183\",\n \"0.59090286\",\n \"0.5903354\",\n \"0.59030885\",\n \"0.58716977\",\n \"0.5866924\",\n \"0.58629787\",\n \"0.5860049\",\n \"0.58510756\",\n \"0.5845535\",\n \"0.5826121\",\n \"0.5820877\",\n \"0.581491\",\n \"0.58147687\",\n \"0.581084\",\n \"0.58081424\",\n \"0.5793453\",\n \"0.57908505\",\n \"0.5785397\",\n \"0.5778863\",\n \"0.5773933\",\n \"0.5771996\",\n \"0.5765054\",\n \"0.5747631\",\n \"0.57472974\",\n \"0.5744378\",\n \"0.57384336\",\n \"0.5735909\",\n \"0.57298315\",\n \"0.57287174\",\n \"0.57229954\",\n \"0.5719511\",\n \"0.5717017\",\n \"0.57020086\",\n \"0.5694991\",\n \"0.5691541\",\n \"0.5686339\",\n \"0.56855005\",\n \"0.5681297\",\n \"0.5678889\",\n \"0.56585675\",\n \"0.5654945\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6394,"cells":{"query":{"kind":"string","value":"Wraps the function, so that the id's it gets will always be strings"},"document":{"kind":"string","value":"def string_ids(f):\n\n\t@functools.wraps(f)\n\tdef wrapper(self, *args):\n\t\treturn f(self, *[str(arg) for arg in args])\n\n\treturn wrapper"},"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 getId(*args):","def getId(*args):","def getId(*args):","def getId(*args):","def getId(*args):","def getId(*args):","def getId(*args):","def getId(*args):","def getId(*args):","def getId(*args):","def getId(*args):","def getId(*args):","def id_(x: Any) -> Any:\n return x","def get_id_args(func, arg):\n\n return \"{} {}\".format(func.__name__, arg)","def id(self, *args, **kwargs) -> Any:\n pass","def id(obj):\n return obj","def getID():","def test_convert_id():","def getEventIDValueString(*args, **kwargs):\n pass","def id_func(param):\n if isinstance(param, dict) and \":name:\" in param:\n return param[\":name:\"]\n\n retval = str(param)\n if len(retval) > 25:\n retval = retval[:20] + \"...\" + retval[-2:]\n return retval","def id_func(param):\n if isinstance(param, dict) and \":name:\" in param:\n return param[\":name:\"]\n\n retval = str(param)\n if len(retval) > 25:\n retval = retval[:20] + \"...\" + retval[-2:]\n return retval","def replaceIDWithFunction(self, *args):\n return _libsbml.ASTBasePlugin_replaceIDWithFunction(self, *args)","def test_solareclipses_id_get(self):\n pass","def getId(self):","def build_id():\n return \"test123\"","def get_identifier(self):","def get_id(self): # real signature unknown; restored from __doc__\n return \"\"","def replaceIDWithFunction(self, *args):\n return _libsbml.ASTNode_replaceIDWithFunction(self, *args)","def function_uuid():\r\n yield uuid.uuid4()","def check_id(self, id):","def identifier(self):","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _id(self):\n pass","def id(self) -> str:\n pass","def getIDs():","def identify(func):\n def identified(arg):\n func(arg)\n return arg\n return identified","def get_id(self):\n pass","def get_id(self):\n pass","def get_id(self):\n pass","def get_id(self):\n pass","def id_str(self):\n if hasattr(self, 'id'):\n return str(self.id)\n else:\n return 'obj%s' % id(self)","def string_id(self):\n id = self.id()\n if not isinstance(id, basestring):\n id = None\n return id","def uuidize(f):\n @functools.wraps(f)\n def wrapper(*args, **kwargs):\n if 'instance_id' in kwargs and 'instance_uuid' in kwargs:\n kwargs['instance_id'] = kwargs['instance_uuid']\n del kwargs['instance_uuid']\n return f(*args, **kwargs)\n return wrapper","def getEventIDName(*args, **kwargs):\n pass","def get_title_by_id(id):\n\n # your code","def id(self):\n raise NotImplementedError()","def getid(obj):\n try:\n return obj.id\n except AttributeError:\n return obj","def getID(self) -> int:\n ...","def get_id(obj):\n\n id = callable(obj.id) and obj.id() or obj.id\n assert obj.getId() == id, \"expected identical ids: '%s' != '%s'\" \\\n % (obj.getId(), id)\n return id","def get_actual_id(translated):","def get_id(self): # pragma: no cover\n pass","def get_id(self):\n \"\"\"Requires use of Python 3\"\"\"\n return str(self.id)","def _get_uuid(self, *args: Any, **kwargs: Any) -> str:\n return \"lane_invasions\"","def giveId(what,string):\n if what == \"characters\":\n return list(engine.execute(f\"SELECT char_id FROM characters WHERE name ='{string}';\"))[0][0]\n elif what == \"episodes\":\n return list(engine.execute(f\"SELECT ep_id FROM episodes WHERE episode ='{string}';\"))[0][0]","def replaceSIDWithFunction(self, *args):\n return _libsbml.Delay_replaceSIDWithFunction(self, *args)","def getid(obj):\n\n try:\n return obj.id\n except AttributeError:\n return obj","def GenId(self, func=None, *param):\n\tcurrent_count = 0\n\told_time = self.GenerateTime()\n\twhile True:\t\n\t current_count += 1\n\t if self.GenerateTime() != old_time:\n\t\tcurrent_count = 0\n\t old_time = self.GenerateTime()\n\t CurrentId = format(current_count, 11)\n\t #id = str(int(self.GenerateTime(), 2) + int(self.GenDistinctId(), 2) + int(CurrentId, 2))\n\t id = str(int(self.GenerateTime(), 2)) + str(int(self.GenDistinctId(), 2)) + str(int(CurrentId, 2))\n\t yield(func(id, *param))","def get_object(id):","def xpathIdFunction(self, nargs):\n libxml2mod.xmlXPathIdFunction(self._o, nargs)","def get(self, _id):","def replaceSIDWithFunction(self, *args):\n return _libsbml.SBase_replaceSIDWithFunction(self, *args)","def _set_id(self, value):\n pass","def userDocumentId(self, id: str) -> str:","def simplify_IDs(self, IDs):\n raise NotImplementedError","def id(self):\n # Might also be a first 12-characters shortcut.\n return self._id"],"string":"[\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def getId(*args):\",\n \"def id_(x: Any) -> Any:\\n return x\",\n \"def get_id_args(func, arg):\\n\\n return \\\"{} {}\\\".format(func.__name__, arg)\",\n \"def id(self, *args, **kwargs) -> Any:\\n pass\",\n \"def id(obj):\\n return obj\",\n \"def getID():\",\n \"def test_convert_id():\",\n \"def getEventIDValueString(*args, **kwargs):\\n pass\",\n \"def id_func(param):\\n if isinstance(param, dict) and \\\":name:\\\" in param:\\n return param[\\\":name:\\\"]\\n\\n retval = str(param)\\n if len(retval) > 25:\\n retval = retval[:20] + \\\"...\\\" + retval[-2:]\\n return retval\",\n \"def id_func(param):\\n if isinstance(param, dict) and \\\":name:\\\" in param:\\n return param[\\\":name:\\\"]\\n\\n retval = str(param)\\n if len(retval) > 25:\\n retval = retval[:20] + \\\"...\\\" + retval[-2:]\\n return retval\",\n \"def replaceIDWithFunction(self, *args):\\n return _libsbml.ASTBasePlugin_replaceIDWithFunction(self, *args)\",\n \"def test_solareclipses_id_get(self):\\n pass\",\n \"def getId(self):\",\n \"def build_id():\\n return \\\"test123\\\"\",\n \"def get_identifier(self):\",\n \"def get_id(self): # real signature unknown; restored from __doc__\\n return \\\"\\\"\",\n \"def replaceIDWithFunction(self, *args):\\n return _libsbml.ASTNode_replaceIDWithFunction(self, *args)\",\n \"def function_uuid():\\r\\n yield uuid.uuid4()\",\n \"def check_id(self, id):\",\n \"def identifier(self):\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _id(self):\\n pass\",\n \"def id(self) -> str:\\n pass\",\n \"def getIDs():\",\n \"def identify(func):\\n def identified(arg):\\n func(arg)\\n return arg\\n return identified\",\n \"def get_id(self):\\n pass\",\n \"def get_id(self):\\n pass\",\n \"def get_id(self):\\n pass\",\n \"def get_id(self):\\n pass\",\n \"def id_str(self):\\n if hasattr(self, 'id'):\\n return str(self.id)\\n else:\\n return 'obj%s' % id(self)\",\n \"def string_id(self):\\n id = self.id()\\n if not isinstance(id, basestring):\\n id = None\\n return id\",\n \"def uuidize(f):\\n @functools.wraps(f)\\n def wrapper(*args, **kwargs):\\n if 'instance_id' in kwargs and 'instance_uuid' in kwargs:\\n kwargs['instance_id'] = kwargs['instance_uuid']\\n del kwargs['instance_uuid']\\n return f(*args, **kwargs)\\n return wrapper\",\n \"def getEventIDName(*args, **kwargs):\\n pass\",\n \"def get_title_by_id(id):\\n\\n # your code\",\n \"def id(self):\\n raise NotImplementedError()\",\n \"def getid(obj):\\n try:\\n return obj.id\\n except AttributeError:\\n return obj\",\n \"def getID(self) -> int:\\n ...\",\n \"def get_id(obj):\\n\\n id = callable(obj.id) and obj.id() or obj.id\\n assert obj.getId() == id, \\\"expected identical ids: '%s' != '%s'\\\" \\\\\\n % (obj.getId(), id)\\n return id\",\n \"def get_actual_id(translated):\",\n \"def get_id(self): # pragma: no cover\\n pass\",\n \"def get_id(self):\\n \\\"\\\"\\\"Requires use of Python 3\\\"\\\"\\\"\\n return str(self.id)\",\n \"def _get_uuid(self, *args: Any, **kwargs: Any) -> str:\\n return \\\"lane_invasions\\\"\",\n \"def giveId(what,string):\\n if what == \\\"characters\\\":\\n return list(engine.execute(f\\\"SELECT char_id FROM characters WHERE name ='{string}';\\\"))[0][0]\\n elif what == \\\"episodes\\\":\\n return list(engine.execute(f\\\"SELECT ep_id FROM episodes WHERE episode ='{string}';\\\"))[0][0]\",\n \"def replaceSIDWithFunction(self, *args):\\n return _libsbml.Delay_replaceSIDWithFunction(self, *args)\",\n \"def getid(obj):\\n\\n try:\\n return obj.id\\n except AttributeError:\\n return obj\",\n \"def GenId(self, func=None, *param):\\n\\tcurrent_count = 0\\n\\told_time = self.GenerateTime()\\n\\twhile True:\\t\\n\\t current_count += 1\\n\\t if self.GenerateTime() != old_time:\\n\\t\\tcurrent_count = 0\\n\\t old_time = self.GenerateTime()\\n\\t CurrentId = format(current_count, 11)\\n\\t #id = str(int(self.GenerateTime(), 2) + int(self.GenDistinctId(), 2) + int(CurrentId, 2))\\n\\t id = str(int(self.GenerateTime(), 2)) + str(int(self.GenDistinctId(), 2)) + str(int(CurrentId, 2))\\n\\t yield(func(id, *param))\",\n \"def get_object(id):\",\n \"def xpathIdFunction(self, nargs):\\n libxml2mod.xmlXPathIdFunction(self._o, nargs)\",\n \"def get(self, _id):\",\n \"def replaceSIDWithFunction(self, *args):\\n return _libsbml.SBase_replaceSIDWithFunction(self, *args)\",\n \"def _set_id(self, value):\\n pass\",\n \"def userDocumentId(self, id: str) -> str:\",\n \"def simplify_IDs(self, IDs):\\n raise NotImplementedError\",\n \"def id(self):\\n # Might also be a first 12-characters shortcut.\\n return self._id\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72658205","0.72658205","0.72658205","0.72658205","0.72658205","0.72658205","0.72658205","0.72658205","0.72658205","0.72658205","0.72658205","0.72658205","0.7023903","0.6685517","0.6608628","0.6440895","0.64001304","0.63244265","0.6252984","0.6210254","0.6210254","0.6106699","0.6066109","0.60233027","0.59804165","0.5932905","0.5915975","0.58940583","0.586065","0.58582413","0.58306557","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.58153147","0.5803242","0.57819253","0.57538295","0.571672","0.5714062","0.5714062","0.5714062","0.5714062","0.57058203","0.56927794","0.5644569","0.5628935","0.56208664","0.5574305","0.55575484","0.55487746","0.5547815","0.55311453","0.5511344","0.54909146","0.54759693","0.5462679","0.5431401","0.54268837","0.54218876","0.54175544","0.5412469","0.5409666","0.53963476","0.5396238","0.5390335","0.5383493","0.5376938"],"string":"[\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.72658205\",\n \"0.7023903\",\n \"0.6685517\",\n \"0.6608628\",\n \"0.6440895\",\n \"0.64001304\",\n \"0.63244265\",\n \"0.6252984\",\n \"0.6210254\",\n \"0.6210254\",\n \"0.6106699\",\n \"0.6066109\",\n \"0.60233027\",\n \"0.59804165\",\n \"0.5932905\",\n \"0.5915975\",\n \"0.58940583\",\n \"0.586065\",\n \"0.58582413\",\n \"0.58306557\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.58153147\",\n \"0.5803242\",\n \"0.57819253\",\n \"0.57538295\",\n \"0.571672\",\n \"0.5714062\",\n \"0.5714062\",\n \"0.5714062\",\n \"0.5714062\",\n \"0.57058203\",\n \"0.56927794\",\n \"0.5644569\",\n \"0.5628935\",\n \"0.56208664\",\n \"0.5574305\",\n \"0.55575484\",\n \"0.55487746\",\n \"0.5547815\",\n \"0.55311453\",\n \"0.5511344\",\n \"0.54909146\",\n \"0.54759693\",\n \"0.5462679\",\n \"0.5431401\",\n \"0.54268837\",\n \"0.54218876\",\n \"0.54175544\",\n \"0.5412469\",\n \"0.5409666\",\n \"0.53963476\",\n \"0.5396238\",\n \"0.5390335\",\n \"0.5383493\",\n \"0.5376938\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66786057"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":6395,"cells":{"query":{"kind":"string","value":"Saves user to database"},"document":{"kind":"string","value":"def save_user(self, user: dict):\n\t\tlogger.debug('Inserting new user....')\n\t\tusers = self.db.users\n\t\tusers.update(self.user_identification(user), user, upsert=True)\n\t\tlogger.debug('New user inserted')"},"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 save_user(user):\n User.save_user(user)","def save_users(user):\n user.save_user()","def save_user(self):\n db.session.add(self)\n db.session.commit()","def save(self, context=None):\n updates = self.obj_get_changes()\n self.dbapi.update_user(context, self.id, updates)\n self.obj_reset_changes()","def save_user(self):\n args = parser.parse_args()\n data = {\n 'firstname': request.json.get('firstname').capitalize(),\n 'lastname': request.json.get('lastname').capitalize(),\n 'othernames': request.json.get('othernames', '').capitalize(),\n 'email': request.json.get('email').lower(),\n 'phoneNumber': request.json.get('phoneNumber'),\n 'username': request.json.get('username').lower(),\n 'registered': datetime.datetime.utcnow(),\n 'password': self.set_password(request.json.get('password')),\n 'isAdmin': self.isAdmin, 'public_id': self.public_id\n }\n userByEmail = self.get_user(data['email'])\n userByUsername = self.get_user(data['username'])\n if userByEmail is not None:\n return 'email exists'\n elif userByUsername is not None:\n return 'username exists'\n\n query = \"\"\"INSERT INTO users (firstname,lastname,othernames,email,phoneNumber,username,registered,password,isAdmin,public_id) VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)\"\"\"\n values = data['firstname'], data['lastname'], data['othernames'], data['email'], data['phoneNumber'], data[\n 'username'], data['registered'], data['password'], data['isAdmin'], data['public_id']\n\n conn = self.db\n cursor = conn.cursor()\n cursor.execute(query, values)\n conn.commit()\n return data","def save(self)->None:\n database.cursor.execute(\n \"INSERT INTO users(firstname,lastname,othernames,email,phone,username,password,role) VALUES (%s,%s,%s,%s,%s,%s,%s,%s) RETURNING id\", (\n self.first_name,\n self.last_name,\n self.other_name,\n self.email,\n self.phone_number,\n self.user_name,\n self.password,\n self.is_admin\n ))\n super().save()","def test_saving_user_to_db(self):\n self.user.save()\n db_user = User.query.filter_by(email='seni@andela.com').first()\n self.assertIs(self.user, db_user)\n self.assertIsInstance(db_user, User)","def saveNewUser(self, userID):\n self.db.insert_new_user(userID)","def save_to_db(self):\n # update\n if self.user_db:\n self.db.session.query(UserDB).filter(UserDB.login == self.params['login']).\\\n update({'access_token': self.params['access_token'],\n# 'social_net': self.params['social_net'] or 'social_net',\n 'profile_url': self.params.get('profile_url', None),\n 'fio': self.params.get('name', None),\n 'email': self.params.get('email', None)},\n synchronize_session='fetch')\n self.db.commit()\n log.debug('Updated social user: %s', self.params['login'],)\n # create\n else:\n user = UserDB(self.params['login'],\n self.params['email'],\n fio = self.params['name'],\n avatar = '',\n access_token = self.params['access_token'],\n social_net = self.params['social_net'],\n profile_url = self.params['link']\n )\n\n self.db.create(user)\n log.debug('Social user <%s> created', self.params['login'])\n return {'success': True}","def save_user(self):\n User.user_list.append(self)\n\n # finding a user's credentials","def _save_user(self, user):\n self.firebase.patch(f'/{self.USERS_KEY}', {str(user.id): user.username})","def save(self, commit=True):\n\t\tprint('save django.user ')\n\t\tprint(self.cleaned_data)\n\t\tusr = User.objects.create_user(self.cleaned_data['username'], self.cleaned_data['email'], self.cleaned_data['pass1'])\n\t\tkuser = users.models.KUser()\n\t\tkuser.user = usr\n\t\tkuser.realName = self.cleaned_data['realName']\n\t\tkuser.job = self.cleaned_data['job']\n\t\tkuser.privilege = self.cleaned_data['privilege']\n\t\tkuser.employeeId = self.cleaned_data['employeeId']\n\t\tkuser.isManager = self.cleaned_data['isManager']\n\t\tkuser.gender = self.cleaned_data['gender']\n\t\tprint('create kuser:')\n\t\tprint(kuser)\n\n\t\tif commit:\n\t\t\tkuser.save()\n\t\treturn kuser","def save(self):\n users = User.getall()\n users[self.username] = dict(self)\n return self.db().put(self.udb, users)","def save_user(self):\n User.user_list.append(self)","def save_user(self):\n User.user_list.append(self)","def add_new_user_to_db():\n first_name = request.form['first_name']\n last_name = request.form['last_name']\n img_url = request.form['img_url']\n\n new_user = User(first_name=first_name,last_name=last_name, img_url=img_url)\n db.session.add(new_user)\n db.session.commit()\n\n return redirect('/users')","def save_user(self):\n\n User.user_list.append(self)","def save(self):\n payload = self.context['payload']\n user = User.objects.get(username=payload['user'])\n user.is_verified = True\n user.save()","def save(self):\n payload = self.context['payload']\n user = User.objects.get(username=payload['user'])\n user.is_verified = True\n user.save()","def write_user(self, _user):\n try:\n self.conn_cursor.execute(\"INSERT INTO users (id,bank) VALUES (?, ?)\", (_user.id, _user.bank))\n except sqlite3.IntegrityError:\n pass\n self.conn_cursor.execute(\"UPDATE users SET bank=? WHERE id=?\", (_user.bank, _user.id ))","def save_to_users(self):\n Data.add_data(self.user_data())","def commit(self):\n\t\t#firstly, get all variables and values of this model\n\t\tcontent = self.__dict__.copy() \n\t\t#if '_rev' is one of the variables of this model instance,\n\t\t#it means this user is retrived from database. \n\t\t#We are actually going to update the model document in database\n\t\t#instead of creating a new user document.\n\t\tres = dbop.update_create_user_in_database(self._id, content) \n\t\tself._id = res['id']\n\t\tself._rev = res['rev']","def test_save_user(self):\n self.new_user.save_user()\n self.assertEqual(len(User.user_list), 1)","def test_save_user(self):\n self.new_user.save_user()\n self.assertEqual(len(User.user_list), 1)","def save(self, **kwargs):\n payload = self.context['payload']\n user = User.objects.get(username=payload['user'])\n user.is_verified = True\n user.save()","def post(self):\n data = request.json\n return save_new_user(data=data)","def save_user(self):\n\n User.user_list.append(self)","def post(self):\n data = request.json\n return save_new_user(data)","def save_user(cls,username,password):\n cls.users[username] = password","def save(self, *args):\n self.firstname, self.lastname, self.othername, self.email, self.phonenumber, self.passporturl, self.roles, self.nationalid, self.county, self.password, self.date_created, self.date_modified = args\n format_str = f\"\"\"\n INSERT INTO public.users (firstname,lastname,othername,email,phonenumber,passporturl,roles,nationalid,county,password,date_created,date_modified)\n VALUES ('{args[0]}','{args[1]}','{args[2]}','{args[3]}','{args[4]}','{args[5]}','{args[6]}','{args[\n 7]}','{args[8]}','{args[9]}','{(datetime.now())}','{(datetime.now())}');\n \"\"\"\n cursor.execute(format_str)","def insert_user(user):\n\n try:\n session.add(user)\n session.commit()\n except Exception as e:\n logger.error(e)","def save_user():\n user = request.json\n user[\"password\"] = encrypt_password(user[\"password\"])\n if not user_service.add_user(user):\n response = {\n \"status\": False,\n \"message\": \"No se pudo guardar el usuario en la base de datos\",\n }\n resp = make_response(jsonify(response), 500)\n else:\n new_user = user_service.get_user({\"name\": user[\"name\"], \"email\": user[\"email\"]})\n if config_service.add({\"user\": str(new_user[\"_id\"]), \"wizzard\": True}):\n response = {\"status\": True, \"id\": \"Se guardo correctamente el usuario\"}\n resp = make_response(jsonify(response), 200)\n\n resp.headers[\"Content-Type\"] = \"application/json\"\n return resp","def handle_add_user():\n new_user = User(first_name=request.form['first_name'], last_name=request.form['last_name'], image_url=request.form['image_url'])\n db.session.add(new_user)\n db.session.commit()\n\n return redirect('/')","def save(self):\n self.db.commit()","def save_model(self, request, obj, form, change):\n if not change:\n if form.is_valid():\n user = form.save()\n user.identity = Users.SALESMAN\n user.set_password(form.data.get('password'))\n user.iCode = InviteCls.encode_invite_code(user.id)\n user.save()\n UserExtra.objects.create(uid=user)\n UserBase.objects.create(\n uid=user,\n phone=user.username\n )\n leader = Team.objects.get(id=form.data.get('team')).leader\n inviter_queryset = InviteRelationManager.objects.filter(invitee=leader)\n if inviter_queryset.exists():\n inviter_obj = inviter_queryset.first()\n superior = f'{inviter_obj.superior}|{leader.id}'\n else:\n superior = f'{leader.id}'\n InviteRelationManager.objects.create(inviter=leader, invitee=user, level=1, superior=superior)\n UserBusiness.objects.create(uid=user)\n super().save_model(request, obj, form, change)","def update_db_with_user_edits(user_id):\n user = User.query.get_or_404(user_id)\n user.first_name = request.form['first_name']\n user.last_name = request.form['last_name']\n user.img_url = request.form['img_url']\n\n db.session.add(user)\n db.session.commit()\n\n return redirect('/users')","def save_user(user, save_torn_data=False, save_credentials=False, save_settings=False) -> None:\n args = [save_torn_data, save_credentials, save_credentials]\n\n if all(args) or all(not arg for arg in args):\n # save everything\n users_ref.child(str(user.id)).child('user').set(user.to_dict())\n logging.debug(f\"Saved all data for user {user.id}\")\n\n else:\n if save_torn_data:\n Database.save_field_for_user(user, 'torn_data')\n if save_credentials:\n Database.save_field_for_user(user, 'credentials')\n if save_settings:\n Database.save_field_for_user(user, 'settings')","def post(self):\n data = flask.request.json\n user_dao.create_user(data)\n return None, 201","def save(self, request):\n user = get_user_model()()\n cleaned_data = self.get_cleaned_data()\n email = cleaned_data.get('email')\n nickname = cleaned_data.get('nickname')\n\n user.email = email\n user.nickname = nickname\n\n if 'password1' in cleaned_data:\n user.set_password(cleaned_data[\"password1\"])\n else:\n user.set_unusable_password()\n\n user.save()\n\n return user","def post(self):\n data = UserRegister.parser.parse_args()\n\n if UserModel.find_by_id(data['username']):\n print(\"Failed\", file=sys.stderr)\n return {\n 'message':\n \"A user with name '{}' already exists.\"\n .format(data['username'])\n }, 400\n\n\n user = UserModel(**data) # data['username'], data['details'].......\n user.save_to_db()\n\n return {\"message\": \"User created successfully.\"}, 201","def save_model(self, request, obj, form, change):\n if not change:\n if form.is_valid():\n user = form.save()\n user.identity = Users.SUPERVISOR\n user.set_password(form.data.get('password'))\n user.iCode = InviteCls.encode_invite_code(user.id)\n user.save()\n UserExtra.objects.create(uid=user)\n UserBase.objects.create(\n uid=user,\n phone=user.username\n )\n UserBusiness.objects.create(uid=user)\n else:\n super().save_model(request, obj, form, change)","def test_user_save(self):\n app = create_app('mathsonmars.settings.TestConfig')\n db.app = app\n db.drop_all()\n db.create_all()\n with app.app_context():\n admin_role = Role(role_name = RoleTypes.ADMIN)\n db.session.add(admin_role)\n db.session.flush()\n admin = User(role_id = admin_role.id, user_name='admin', password='supersafepassword')\n db.session.add(admin)\n db.session.commit()\n\n user = db.session.query(User).filter(User.user_name == \"admin\").first()\n self.assertNotEqual(None, user)","def save(self):\n self.__db.commit()","def save(self):\n data = self.cleaned_data\n # Como este metodo no nos sirve para nada por eso tenemos que sacarlo,\n # se saca ya que solo es con el proposito de tener una contraseña con\n # su respectiva confirmacion. el modelo User no tiene ese campo por eso\n # se lo saca con el metodo *pop*\n data.pop('password_confirmation')\n # Los asteriscos lo que hacen es enviar la estructura desvaratada\n user = User.objects.create_user(**data)\n profile = Profile(user=user)\n profile.save()","def add_user(self):\n query = \"INSERT INTO users (first_name, last_name, email, password) VALUES (%s, %s, %s, %s)\"\n self.cursor.execute(query,(\n self.first_name, \n self.last_name, \n self.email, \n self.password))","def update_user():","def _saveUser(self, cursor):\n user_tablename = \"_users_\"\n if not self.exists(user_tablename, cursor):\n sql = f\"CREATE TABLE {user_tablename}(id INTEGER PRIMARY KEY, user_code TEXT, firstname TEXT, lastname TEXT)\"\n cursor.executescript(sql)\n sql = f\" INSERT INTO {user_tablename}(id,user_code,firstname,lastname)\"\n sql += f\" SELECT {self.client_session.userCompanyId},?,?,? \"\n sql += f\" WHERE NOT EXISTS( SELECT 1 FROM {user_tablename} WHERE id = {self.client_session.userCompanyId} )\"\n params = (self.current_user.username, self.client_session.userFirstName,\n self.client_session.userLastName)\n cursor.execute(sql, params)","def save_user(self, request, user, form, commit=True):\n from allauth.account.utils import user_username, user_email, user_field\n\n data = form.cleaned_data\n first_name = data.get('first_name')\n last_name = data.get('last_name')\n email = data.get('email')\n username = data.get('username')\n birth_date = data.get('birth_date')\n gender = data.get('gender')\n timezone = data.get('timezone')\n user_email(user, email)\n user_username(user, username)\n user.all_fields_completed = True\n if first_name:\n user_field(user, 'first_name', first_name)\n if last_name:\n user_field(user, 'last_name', last_name)\n if birth_date:\n user_field(user, 'birth_date', birth_date)\n if gender:\n user_field(user, 'gender', gender)\n if timezone:\n user_field(user, 'timezone', timezone)\n if 'password1' in data:\n user.set_password(data[\"password1\"])\n else:\n user.set_unusable_password()\n self.populate_username(request, user)\n if commit:\n # Ability not to commit makes it easier to derive from\n # this adapter by adding\n user.save()\n return user","def addUsertoDatabase(self):\r\n self.c.execute(\"\"\"INSERT INTO student_information VALUES (?,?,?)\"\"\",(self.name,self.password,self.budget,))\r\n self.con.commit()\r\n print(\"Added to Database Student..\")","def save(self):\n self.session.commit()","def save(self):\n db.session.commit()","def add_user():\n\n email = request.form.get(\"email\")\n password = request.form.get(\"password\")\n fname = request.form.get(\"fname\")\n lname = request.form.get(\"lname\")\n language = request.form.get(\"language\")\n\n new_user = User(email=email, password=password,fname=fname,\n lname=lname,language=language)\n\n db.session.add(new_user)\n db.session.commit()\n\n return redirect(\"/\")","def insert_to_db(self) -> None:\n query = \"\"\"INSERT INTO Users(Username, Password, Firstname, Surname, Currency_id,\n Has_First_Sign_In, Account_Created, Last_Sign_In)\n VALUES(?,?,?,?,?,?,?,?);\"\"\"\n self.db.commit(query, values=self.to_tuple())","def on_user_create(self, user):","def save(self):\n payload = self.context['payload']\n user = User.objects.get(username=payload['user'])\n user.is_verified = True\n user.save()","def test_save_user(self):\n self.new_user.save_user()\n self.assertEqual(len(User.UserDetails), 1)","def post(self):\n return userDao.create(api.payload), 201","def save_user(message):\n uid = message.chat.id\n username = message.chat.username\n first_name = message.chat.first_name\n\n all_users = db.all_users\n user_data = {\n 'uid': uid,\n 'username': username,\n 'first_name': first_name\n }\n result = all_users.update_one({'uid': uid}, {'$setOnInsert': user_data}, upsert=True)\n logging.info(f'{username} started answering.')\n\n return user_data","def register_user(self):\n User.add_user(User(self.email.data, self.password.data))","def userForm():\n \"\"\"If form criteria met, add and commit to the DB\"\"\"\n if request.method=='POST':\n username=request.form['username']\n userfname =request.form['fname']\n userlname=request.form['lname']\n userage=request.form['age']\n usergender=request.form['gender']\n userbio=request.form['bio']\n usertime=datetime.now()\n file = request.files['file']\n if file and allowed_file(file.filename):\n filename = secure_filename(file.filename)\n file.save(os.path.join(file_folder, filename))\n userimage=filename = secure_filename(file.filename)\n #init_db()\n \n db.Model.metadata.reflect(db.engine) \n user=User(userimage,username,userfname,userlname,userage,usergender,userbio,usertime)\n db.session.add(user)\n db.session.commit()\n\n\n return redirect(url_for('home'))\n\n \n \n return render_template('userForm.html')","def insert_user(self, userid, username, phone):\n try:\n query = \"insert into user(userId,userName,phone)values({},'{}','{}')\".format(userid, username, phone)\n print(query)\n cur = self.con.cursor()\n cur.execute(query)\n self.con.commit()\n logger.info(\"user saved to db\")\n except Exception as e:\n logger.error(\"Error occured at data insertion \", e)","def save(self):\n data = self.cleaned_data\n data.pop('password_confirmation')\n user = User.objects.create_user(**data)\n profile = Profile(user=user)\n profile.save()","def post_user():\n\tuser = User.add(request.json)\n\tif user == None:\n\t\tabort(404)\n\treturn jsonify({'user': user.output()})","def saveDatabase(database,user):\n pickle.dump(user, open(\"Users/\"+user.key, \"wb\"))","def signup(self, request, user):\n pass","def create_user():\n first_name = request.form['first_name'].capitalize()\n last_name = request.form['last_name'].capitalize()\n image_url = request.form['image_url']\n\n new_user = User(first_name=first_name, last_name=last_name, image_url=image_url)\n db.session.add(new_user)\n db.session.commit()\n\n return redirect(\"/users\")","def save(self):\n data = self.cleaned_data\n del data['password_confirmation']\n return User.objects.create_user(**data)","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def add_user():\n first_name = request.form.get('first_name')\n last_name = request.form.get('last_name')\n image_url = request.form.get('image_url')\n\n new_user = User(\n first_name=first_name, last_name=last_name, image_url=image_url)\n db.session.add(new_user)\n db.session.commit()\n flash(f'Added new user: {first_name} {last_name}')\n return redirect('/users')","def register():\n insert_user(json_body())\n try:\n db.session.commit()\n except IntegrityError:\n raise exc.CouldNotCreateEntry()\n\n return jsonify({'message': 'Created user.'}), 200","def signup(self, request, user):\n user.first_name = self.cleaned_data['first_name']\n user.last_name = self.cleaned_data['last_name']\n user.save()\n\n return user","def update_user(user_id):\n\n user = User.query.get_or_404(user_id)\n user.first_name = request.form[\"edit_first_name\"]\n user.last_name = request.form[\"edit_last_name\"]\n user.image_url = request.form[\"edit_image_url\"]\n\n db.session.add(user)\n db.session.commit()\n return redirect(\"/users\")","def save(self):\n\n self.__session.commit()","def save(self):\n\n self.__session.commit()","def update_user(user_id):\n user = User.query.get_or_404(user_id)\n user.first_name = request.form['first_name']\n user.last_name = request.form['last_name']\n user.image_url = request.form['image_url']\n\n\n db.session.add(user)\n db.session.commit()\n flash(f\"{user.full_name} user has been edited.\")\n\n return redirect(\"/users\")","def save(self):\n # First save the parent form and get the user.\n new_user = super(SignupFormExtra, self).save()\n\n new_user.first_name = self.cleaned_data['first_name']\n new_user.last_name = self.cleaned_data['last_name']\n new_user.save()\n\n # Userena expects to get the new user from this form, so return the new\n # user.\n return new_user","def update_user(user_id):\n user = User.query.get_or_404(user_id)\n user.first_name = request.form['first_name']\n user.last_name = request.form['last_name']\n user.image_url = request.form['image_url']\n\n db.session.add(user)\n db.session.commit()\n\n return redirect(\"/users\")","def register_user():\n\n form = UserForm()\n\n if form.validate_on_submit():\n username = form.username.data\n password = form.password.data\n email = form.email.data\n first_name = form.first_name.data\n last_name = form.last_name.data\n new_user = User.register(username, password, email, first_name, last_name)\n\n db.session.add(new_user)\n db.session.commit()\n session['username'] = new_user.username\n\n flash(f'Created {username} user.')\n return redirect('/users/<username>')\n\n else:\n return render_template('users/register.html', form=form)","def insert_user(self, post_data):\n con = self.connect()\n cursor = con.cursor()\n sql = \"\"\"INSERT INTO users(firstname, lastname, othername, email,\n phoneNumber, username, password, isAdmin) VALUES(%s, %s, %s,\n %s, %s, %s, %s, %s)\"\"\"\n cursor.execute(sql, post_data)\n cursor.close()\n con.commit()\n con.close()","def users_create():","def add_new_user(self, user):\n # print(\"Saving new user\")\n self.execute(TABELLE['id_users']['insert']['complete_user'],\n (user['id'], False, False, True, False, False))\n\n self.execute(TABELLE['users']['insert'],\n (user['id'], user['username']))","def save_user(self, user, path=None):\n # Check if this user already exists in elasticsearch\n index = ''.join(['gh_user-', self.timestamp])\n\n self._write_to_datastore(index=index,\n doc_type='GithubUser',\n document=user.response,\n login=user.login,\n path=path)\n\n return True","def _post(self, data):\n new_user_id = DB_USER_TABLE.insert(data)\n return new_user_id","def register():\n if request.method == 'POST' and request.form['username'] and request.form['password']: \n user = Storage.save_user(request.form['username'],request.form['password'])\n first_name = request.form['first_name']\n last_name = request.form['last_name']\n email = request.form['email']\n\n Storage.save_profile(user=ObjectId(user), first_name=first_name, last_name=last_name,email=email)\n # alter the redirect\n return \"Success\"\n else:\n abort(401)","def save_new_user(data):\n user = User.query.filter_by(email=data[\"email\"]).first()\n new_user = User(\n public_id=str(uuid.uuid4()),\n email=data[\"email\"],\n username=data[\"username\"],\n password=data[\"password\"],\n registered_on=datetime.datetime.utcnow(),\n )\n\n if not user:\n save_changes(new_user)\n return generate_token(new_user)\n\n else:\n response_object = {\n \"status\": \"fail\",\n \"message\": \"User already exists. Please Log in.\",\n }\n return response_object, 409","def new_user():\n new_user = User(first_name=request.form['first_name'], last_name=request.form['last_name'], image_url=request.form['image_url'] or None)\n\n db.session.add(new_user)\n db.session.commit()\n\n return redirect(\"/users\")","def save_user(username, data):\n\n hashed_username = base64.b64encode(Cryptography.hash(username).digest()).decode()\n\n file = open(getcwd() + Database.__DB_FILENAME, 'a')\n iv, ciphered_data = Cryptography.cipher(Cryptography.get_passphrase(), data)\n file.write(hashed_username + ':' + ciphered_data.hex() + '.' + iv.hex() + '\\n')\n file.flush()\n file.close()","def register_user():\n pass","def new_user():\n success = True\n try:\n usr = User(request.json['username'], request.json['email'])\n db.session.add(usr)\n db.session.commit()\n except:\n success = False\n return jsonify(success=success)","def save_user_profile(instance, **_):\n instance.profile.save()","def test_save_users(self):\n\n self.new_users.save_users() # saving the new user\n self.assertEqual(len(User.user_list), 1)","def post(self, name):\n user = User.find_user_by_name(name).first_or_404()\n form = UserForm()\n if user == current_user and form.validate_on_submit(): \n old_name = current_user.name\n if form.email.data != '': \n user.email = form.email.data\n user.name = form.name.data\n user.twitter_handle = form.twitter.data\n db.session.commit()\n\n key = make_template_fragment_key(\"user\", vary_on=[old_name])\n cache.delete(key)\n\n flash('Your edits are saved, thanks.', category = 'info')\n return redirect(url_for('.user', name=form.name.data))","def save(self, commit=True):\n user = super(UserCreationForm, self).save(commit=False)\n user.set_password(self.cleaned_data['password1'])\n\n user.save()\n\n # Making user profile and assigning to CPCESU\n # CPCESU\n #group = Organization.objects.get(name='Colorado Plateau')\n\n # New profile with group\n profile = UserProfile(user=user, first_name=self.cleaned_data.get('first_name'),\n last_name=self.cleaned_data.get('last_name'))\n profile.save()\n\n return user"],"string":"[\n \"def save_user(user):\\n User.save_user(user)\",\n \"def save_users(user):\\n user.save_user()\",\n \"def save_user(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self, context=None):\\n updates = self.obj_get_changes()\\n self.dbapi.update_user(context, self.id, updates)\\n self.obj_reset_changes()\",\n \"def save_user(self):\\n args = parser.parse_args()\\n data = {\\n 'firstname': request.json.get('firstname').capitalize(),\\n 'lastname': request.json.get('lastname').capitalize(),\\n 'othernames': request.json.get('othernames', '').capitalize(),\\n 'email': request.json.get('email').lower(),\\n 'phoneNumber': request.json.get('phoneNumber'),\\n 'username': request.json.get('username').lower(),\\n 'registered': datetime.datetime.utcnow(),\\n 'password': self.set_password(request.json.get('password')),\\n 'isAdmin': self.isAdmin, 'public_id': self.public_id\\n }\\n userByEmail = self.get_user(data['email'])\\n userByUsername = self.get_user(data['username'])\\n if userByEmail is not None:\\n return 'email exists'\\n elif userByUsername is not None:\\n return 'username exists'\\n\\n query = \\\"\\\"\\\"INSERT INTO users (firstname,lastname,othernames,email,phoneNumber,username,registered,password,isAdmin,public_id) VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)\\\"\\\"\\\"\\n values = data['firstname'], data['lastname'], data['othernames'], data['email'], data['phoneNumber'], data[\\n 'username'], data['registered'], data['password'], data['isAdmin'], data['public_id']\\n\\n conn = self.db\\n cursor = conn.cursor()\\n cursor.execute(query, values)\\n conn.commit()\\n return data\",\n \"def save(self)->None:\\n database.cursor.execute(\\n \\\"INSERT INTO users(firstname,lastname,othernames,email,phone,username,password,role) VALUES (%s,%s,%s,%s,%s,%s,%s,%s) RETURNING id\\\", (\\n self.first_name,\\n self.last_name,\\n self.other_name,\\n self.email,\\n self.phone_number,\\n self.user_name,\\n self.password,\\n self.is_admin\\n ))\\n super().save()\",\n \"def test_saving_user_to_db(self):\\n self.user.save()\\n db_user = User.query.filter_by(email='seni@andela.com').first()\\n self.assertIs(self.user, db_user)\\n self.assertIsInstance(db_user, User)\",\n \"def saveNewUser(self, userID):\\n self.db.insert_new_user(userID)\",\n \"def save_to_db(self):\\n # update\\n if self.user_db:\\n self.db.session.query(UserDB).filter(UserDB.login == self.params['login']).\\\\\\n update({'access_token': self.params['access_token'],\\n# 'social_net': self.params['social_net'] or 'social_net',\\n 'profile_url': self.params.get('profile_url', None),\\n 'fio': self.params.get('name', None),\\n 'email': self.params.get('email', None)},\\n synchronize_session='fetch')\\n self.db.commit()\\n log.debug('Updated social user: %s', self.params['login'],)\\n # create\\n else:\\n user = UserDB(self.params['login'],\\n self.params['email'],\\n fio = self.params['name'],\\n avatar = '',\\n access_token = self.params['access_token'],\\n social_net = self.params['social_net'],\\n profile_url = self.params['link']\\n )\\n\\n self.db.create(user)\\n log.debug('Social user <%s> created', self.params['login'])\\n return {'success': True}\",\n \"def save_user(self):\\n User.user_list.append(self)\\n\\n # finding a user's credentials\",\n \"def _save_user(self, user):\\n self.firebase.patch(f'/{self.USERS_KEY}', {str(user.id): user.username})\",\n \"def save(self, commit=True):\\n\\t\\tprint('save django.user ')\\n\\t\\tprint(self.cleaned_data)\\n\\t\\tusr = User.objects.create_user(self.cleaned_data['username'], self.cleaned_data['email'], self.cleaned_data['pass1'])\\n\\t\\tkuser = users.models.KUser()\\n\\t\\tkuser.user = usr\\n\\t\\tkuser.realName = self.cleaned_data['realName']\\n\\t\\tkuser.job = self.cleaned_data['job']\\n\\t\\tkuser.privilege = self.cleaned_data['privilege']\\n\\t\\tkuser.employeeId = self.cleaned_data['employeeId']\\n\\t\\tkuser.isManager = self.cleaned_data['isManager']\\n\\t\\tkuser.gender = self.cleaned_data['gender']\\n\\t\\tprint('create kuser:')\\n\\t\\tprint(kuser)\\n\\n\\t\\tif commit:\\n\\t\\t\\tkuser.save()\\n\\t\\treturn kuser\",\n \"def save(self):\\n users = User.getall()\\n users[self.username] = dict(self)\\n return self.db().put(self.udb, users)\",\n \"def save_user(self):\\n User.user_list.append(self)\",\n \"def save_user(self):\\n User.user_list.append(self)\",\n \"def add_new_user_to_db():\\n first_name = request.form['first_name']\\n last_name = request.form['last_name']\\n img_url = request.form['img_url']\\n\\n new_user = User(first_name=first_name,last_name=last_name, img_url=img_url)\\n db.session.add(new_user)\\n db.session.commit()\\n\\n return redirect('/users')\",\n \"def save_user(self):\\n\\n User.user_list.append(self)\",\n \"def save(self):\\n payload = self.context['payload']\\n user = User.objects.get(username=payload['user'])\\n user.is_verified = True\\n user.save()\",\n \"def save(self):\\n payload = self.context['payload']\\n user = User.objects.get(username=payload['user'])\\n user.is_verified = True\\n user.save()\",\n \"def write_user(self, _user):\\n try:\\n self.conn_cursor.execute(\\\"INSERT INTO users (id,bank) VALUES (?, ?)\\\", (_user.id, _user.bank))\\n except sqlite3.IntegrityError:\\n pass\\n self.conn_cursor.execute(\\\"UPDATE users SET bank=? WHERE id=?\\\", (_user.bank, _user.id ))\",\n \"def save_to_users(self):\\n Data.add_data(self.user_data())\",\n \"def commit(self):\\n\\t\\t#firstly, get all variables and values of this model\\n\\t\\tcontent = self.__dict__.copy() \\n\\t\\t#if '_rev' is one of the variables of this model instance,\\n\\t\\t#it means this user is retrived from database. \\n\\t\\t#We are actually going to update the model document in database\\n\\t\\t#instead of creating a new user document.\\n\\t\\tres = dbop.update_create_user_in_database(self._id, content) \\n\\t\\tself._id = res['id']\\n\\t\\tself._rev = res['rev']\",\n \"def test_save_user(self):\\n self.new_user.save_user()\\n self.assertEqual(len(User.user_list), 1)\",\n \"def test_save_user(self):\\n self.new_user.save_user()\\n self.assertEqual(len(User.user_list), 1)\",\n \"def save(self, **kwargs):\\n payload = self.context['payload']\\n user = User.objects.get(username=payload['user'])\\n user.is_verified = True\\n user.save()\",\n \"def post(self):\\n data = request.json\\n return save_new_user(data=data)\",\n \"def save_user(self):\\n\\n User.user_list.append(self)\",\n \"def post(self):\\n data = request.json\\n return save_new_user(data)\",\n \"def save_user(cls,username,password):\\n cls.users[username] = password\",\n \"def save(self, *args):\\n self.firstname, self.lastname, self.othername, self.email, self.phonenumber, self.passporturl, self.roles, self.nationalid, self.county, self.password, self.date_created, self.date_modified = args\\n format_str = f\\\"\\\"\\\"\\n INSERT INTO public.users (firstname,lastname,othername,email,phonenumber,passporturl,roles,nationalid,county,password,date_created,date_modified)\\n VALUES ('{args[0]}','{args[1]}','{args[2]}','{args[3]}','{args[4]}','{args[5]}','{args[6]}','{args[\\n 7]}','{args[8]}','{args[9]}','{(datetime.now())}','{(datetime.now())}');\\n \\\"\\\"\\\"\\n cursor.execute(format_str)\",\n \"def insert_user(user):\\n\\n try:\\n session.add(user)\\n session.commit()\\n except Exception as e:\\n logger.error(e)\",\n \"def save_user():\\n user = request.json\\n user[\\\"password\\\"] = encrypt_password(user[\\\"password\\\"])\\n if not user_service.add_user(user):\\n response = {\\n \\\"status\\\": False,\\n \\\"message\\\": \\\"No se pudo guardar el usuario en la base de datos\\\",\\n }\\n resp = make_response(jsonify(response), 500)\\n else:\\n new_user = user_service.get_user({\\\"name\\\": user[\\\"name\\\"], \\\"email\\\": user[\\\"email\\\"]})\\n if config_service.add({\\\"user\\\": str(new_user[\\\"_id\\\"]), \\\"wizzard\\\": True}):\\n response = {\\\"status\\\": True, \\\"id\\\": \\\"Se guardo correctamente el usuario\\\"}\\n resp = make_response(jsonify(response), 200)\\n\\n resp.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n return resp\",\n \"def handle_add_user():\\n new_user = User(first_name=request.form['first_name'], last_name=request.form['last_name'], image_url=request.form['image_url'])\\n db.session.add(new_user)\\n db.session.commit()\\n\\n return redirect('/')\",\n \"def save(self):\\n self.db.commit()\",\n \"def save_model(self, request, obj, form, change):\\n if not change:\\n if form.is_valid():\\n user = form.save()\\n user.identity = Users.SALESMAN\\n user.set_password(form.data.get('password'))\\n user.iCode = InviteCls.encode_invite_code(user.id)\\n user.save()\\n UserExtra.objects.create(uid=user)\\n UserBase.objects.create(\\n uid=user,\\n phone=user.username\\n )\\n leader = Team.objects.get(id=form.data.get('team')).leader\\n inviter_queryset = InviteRelationManager.objects.filter(invitee=leader)\\n if inviter_queryset.exists():\\n inviter_obj = inviter_queryset.first()\\n superior = f'{inviter_obj.superior}|{leader.id}'\\n else:\\n superior = f'{leader.id}'\\n InviteRelationManager.objects.create(inviter=leader, invitee=user, level=1, superior=superior)\\n UserBusiness.objects.create(uid=user)\\n super().save_model(request, obj, form, change)\",\n \"def update_db_with_user_edits(user_id):\\n user = User.query.get_or_404(user_id)\\n user.first_name = request.form['first_name']\\n user.last_name = request.form['last_name']\\n user.img_url = request.form['img_url']\\n\\n db.session.add(user)\\n db.session.commit()\\n\\n return redirect('/users')\",\n \"def save_user(user, save_torn_data=False, save_credentials=False, save_settings=False) -> None:\\n args = [save_torn_data, save_credentials, save_credentials]\\n\\n if all(args) or all(not arg for arg in args):\\n # save everything\\n users_ref.child(str(user.id)).child('user').set(user.to_dict())\\n logging.debug(f\\\"Saved all data for user {user.id}\\\")\\n\\n else:\\n if save_torn_data:\\n Database.save_field_for_user(user, 'torn_data')\\n if save_credentials:\\n Database.save_field_for_user(user, 'credentials')\\n if save_settings:\\n Database.save_field_for_user(user, 'settings')\",\n \"def post(self):\\n data = flask.request.json\\n user_dao.create_user(data)\\n return None, 201\",\n \"def save(self, request):\\n user = get_user_model()()\\n cleaned_data = self.get_cleaned_data()\\n email = cleaned_data.get('email')\\n nickname = cleaned_data.get('nickname')\\n\\n user.email = email\\n user.nickname = nickname\\n\\n if 'password1' in cleaned_data:\\n user.set_password(cleaned_data[\\\"password1\\\"])\\n else:\\n user.set_unusable_password()\\n\\n user.save()\\n\\n return user\",\n \"def post(self):\\n data = UserRegister.parser.parse_args()\\n\\n if UserModel.find_by_id(data['username']):\\n print(\\\"Failed\\\", file=sys.stderr)\\n return {\\n 'message':\\n \\\"A user with name '{}' already exists.\\\"\\n .format(data['username'])\\n }, 400\\n\\n\\n user = UserModel(**data) # data['username'], data['details'].......\\n user.save_to_db()\\n\\n return {\\\"message\\\": \\\"User created successfully.\\\"}, 201\",\n \"def save_model(self, request, obj, form, change):\\n if not change:\\n if form.is_valid():\\n user = form.save()\\n user.identity = Users.SUPERVISOR\\n user.set_password(form.data.get('password'))\\n user.iCode = InviteCls.encode_invite_code(user.id)\\n user.save()\\n UserExtra.objects.create(uid=user)\\n UserBase.objects.create(\\n uid=user,\\n phone=user.username\\n )\\n UserBusiness.objects.create(uid=user)\\n else:\\n super().save_model(request, obj, form, change)\",\n \"def test_user_save(self):\\n app = create_app('mathsonmars.settings.TestConfig')\\n db.app = app\\n db.drop_all()\\n db.create_all()\\n with app.app_context():\\n admin_role = Role(role_name = RoleTypes.ADMIN)\\n db.session.add(admin_role)\\n db.session.flush()\\n admin = User(role_id = admin_role.id, user_name='admin', password='supersafepassword')\\n db.session.add(admin)\\n db.session.commit()\\n\\n user = db.session.query(User).filter(User.user_name == \\\"admin\\\").first()\\n self.assertNotEqual(None, user)\",\n \"def save(self):\\n self.__db.commit()\",\n \"def save(self):\\n data = self.cleaned_data\\n # Como este metodo no nos sirve para nada por eso tenemos que sacarlo,\\n # se saca ya que solo es con el proposito de tener una contraseña con\\n # su respectiva confirmacion. el modelo User no tiene ese campo por eso\\n # se lo saca con el metodo *pop*\\n data.pop('password_confirmation')\\n # Los asteriscos lo que hacen es enviar la estructura desvaratada\\n user = User.objects.create_user(**data)\\n profile = Profile(user=user)\\n profile.save()\",\n \"def add_user(self):\\n query = \\\"INSERT INTO users (first_name, last_name, email, password) VALUES (%s, %s, %s, %s)\\\"\\n self.cursor.execute(query,(\\n self.first_name, \\n self.last_name, \\n self.email, \\n self.password))\",\n \"def update_user():\",\n \"def _saveUser(self, cursor):\\n user_tablename = \\\"_users_\\\"\\n if not self.exists(user_tablename, cursor):\\n sql = f\\\"CREATE TABLE {user_tablename}(id INTEGER PRIMARY KEY, user_code TEXT, firstname TEXT, lastname TEXT)\\\"\\n cursor.executescript(sql)\\n sql = f\\\" INSERT INTO {user_tablename}(id,user_code,firstname,lastname)\\\"\\n sql += f\\\" SELECT {self.client_session.userCompanyId},?,?,? \\\"\\n sql += f\\\" WHERE NOT EXISTS( SELECT 1 FROM {user_tablename} WHERE id = {self.client_session.userCompanyId} )\\\"\\n params = (self.current_user.username, self.client_session.userFirstName,\\n self.client_session.userLastName)\\n cursor.execute(sql, params)\",\n \"def save_user(self, request, user, form, commit=True):\\n from allauth.account.utils import user_username, user_email, user_field\\n\\n data = form.cleaned_data\\n first_name = data.get('first_name')\\n last_name = data.get('last_name')\\n email = data.get('email')\\n username = data.get('username')\\n birth_date = data.get('birth_date')\\n gender = data.get('gender')\\n timezone = data.get('timezone')\\n user_email(user, email)\\n user_username(user, username)\\n user.all_fields_completed = True\\n if first_name:\\n user_field(user, 'first_name', first_name)\\n if last_name:\\n user_field(user, 'last_name', last_name)\\n if birth_date:\\n user_field(user, 'birth_date', birth_date)\\n if gender:\\n user_field(user, 'gender', gender)\\n if timezone:\\n user_field(user, 'timezone', timezone)\\n if 'password1' in data:\\n user.set_password(data[\\\"password1\\\"])\\n else:\\n user.set_unusable_password()\\n self.populate_username(request, user)\\n if commit:\\n # Ability not to commit makes it easier to derive from\\n # this adapter by adding\\n user.save()\\n return user\",\n \"def addUsertoDatabase(self):\\r\\n self.c.execute(\\\"\\\"\\\"INSERT INTO student_information VALUES (?,?,?)\\\"\\\"\\\",(self.name,self.password,self.budget,))\\r\\n self.con.commit()\\r\\n print(\\\"Added to Database Student..\\\")\",\n \"def save(self):\\n self.session.commit()\",\n \"def save(self):\\n db.session.commit()\",\n \"def add_user():\\n\\n email = request.form.get(\\\"email\\\")\\n password = request.form.get(\\\"password\\\")\\n fname = request.form.get(\\\"fname\\\")\\n lname = request.form.get(\\\"lname\\\")\\n language = request.form.get(\\\"language\\\")\\n\\n new_user = User(email=email, password=password,fname=fname,\\n lname=lname,language=language)\\n\\n db.session.add(new_user)\\n db.session.commit()\\n\\n return redirect(\\\"/\\\")\",\n \"def insert_to_db(self) -> None:\\n query = \\\"\\\"\\\"INSERT INTO Users(Username, Password, Firstname, Surname, Currency_id,\\n Has_First_Sign_In, Account_Created, Last_Sign_In)\\n VALUES(?,?,?,?,?,?,?,?);\\\"\\\"\\\"\\n self.db.commit(query, values=self.to_tuple())\",\n \"def on_user_create(self, user):\",\n \"def save(self):\\n payload = self.context['payload']\\n user = User.objects.get(username=payload['user'])\\n user.is_verified = True\\n user.save()\",\n \"def test_save_user(self):\\n self.new_user.save_user()\\n self.assertEqual(len(User.UserDetails), 1)\",\n \"def post(self):\\n return userDao.create(api.payload), 201\",\n \"def save_user(message):\\n uid = message.chat.id\\n username = message.chat.username\\n first_name = message.chat.first_name\\n\\n all_users = db.all_users\\n user_data = {\\n 'uid': uid,\\n 'username': username,\\n 'first_name': first_name\\n }\\n result = all_users.update_one({'uid': uid}, {'$setOnInsert': user_data}, upsert=True)\\n logging.info(f'{username} started answering.')\\n\\n return user_data\",\n \"def register_user(self):\\n User.add_user(User(self.email.data, self.password.data))\",\n \"def userForm():\\n \\\"\\\"\\\"If form criteria met, add and commit to the DB\\\"\\\"\\\"\\n if request.method=='POST':\\n username=request.form['username']\\n userfname =request.form['fname']\\n userlname=request.form['lname']\\n userage=request.form['age']\\n usergender=request.form['gender']\\n userbio=request.form['bio']\\n usertime=datetime.now()\\n file = request.files['file']\\n if file and allowed_file(file.filename):\\n filename = secure_filename(file.filename)\\n file.save(os.path.join(file_folder, filename))\\n userimage=filename = secure_filename(file.filename)\\n #init_db()\\n \\n db.Model.metadata.reflect(db.engine) \\n user=User(userimage,username,userfname,userlname,userage,usergender,userbio,usertime)\\n db.session.add(user)\\n db.session.commit()\\n\\n\\n return redirect(url_for('home'))\\n\\n \\n \\n return render_template('userForm.html')\",\n \"def insert_user(self, userid, username, phone):\\n try:\\n query = \\\"insert into user(userId,userName,phone)values({},'{}','{}')\\\".format(userid, username, phone)\\n print(query)\\n cur = self.con.cursor()\\n cur.execute(query)\\n self.con.commit()\\n logger.info(\\\"user saved to db\\\")\\n except Exception as e:\\n logger.error(\\\"Error occured at data insertion \\\", e)\",\n \"def save(self):\\n data = self.cleaned_data\\n data.pop('password_confirmation')\\n user = User.objects.create_user(**data)\\n profile = Profile(user=user)\\n profile.save()\",\n \"def post_user():\\n\\tuser = User.add(request.json)\\n\\tif user == None:\\n\\t\\tabort(404)\\n\\treturn jsonify({'user': user.output()})\",\n \"def saveDatabase(database,user):\\n pickle.dump(user, open(\\\"Users/\\\"+user.key, \\\"wb\\\"))\",\n \"def signup(self, request, user):\\n pass\",\n \"def create_user():\\n first_name = request.form['first_name'].capitalize()\\n last_name = request.form['last_name'].capitalize()\\n image_url = request.form['image_url']\\n\\n new_user = User(first_name=first_name, last_name=last_name, image_url=image_url)\\n db.session.add(new_user)\\n db.session.commit()\\n\\n return redirect(\\\"/users\\\")\",\n \"def save(self):\\n data = self.cleaned_data\\n del data['password_confirmation']\\n return User.objects.create_user(**data)\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def add_user():\\n first_name = request.form.get('first_name')\\n last_name = request.form.get('last_name')\\n image_url = request.form.get('image_url')\\n\\n new_user = User(\\n first_name=first_name, last_name=last_name, image_url=image_url)\\n db.session.add(new_user)\\n db.session.commit()\\n flash(f'Added new user: {first_name} {last_name}')\\n return redirect('/users')\",\n \"def register():\\n insert_user(json_body())\\n try:\\n db.session.commit()\\n except IntegrityError:\\n raise exc.CouldNotCreateEntry()\\n\\n return jsonify({'message': 'Created user.'}), 200\",\n \"def signup(self, request, user):\\n user.first_name = self.cleaned_data['first_name']\\n user.last_name = self.cleaned_data['last_name']\\n user.save()\\n\\n return user\",\n \"def update_user(user_id):\\n\\n user = User.query.get_or_404(user_id)\\n user.first_name = request.form[\\\"edit_first_name\\\"]\\n user.last_name = request.form[\\\"edit_last_name\\\"]\\n user.image_url = request.form[\\\"edit_image_url\\\"]\\n\\n db.session.add(user)\\n db.session.commit()\\n return redirect(\\\"/users\\\")\",\n \"def save(self):\\n\\n self.__session.commit()\",\n \"def save(self):\\n\\n self.__session.commit()\",\n \"def update_user(user_id):\\n user = User.query.get_or_404(user_id)\\n user.first_name = request.form['first_name']\\n user.last_name = request.form['last_name']\\n user.image_url = request.form['image_url']\\n\\n\\n db.session.add(user)\\n db.session.commit()\\n flash(f\\\"{user.full_name} user has been edited.\\\")\\n\\n return redirect(\\\"/users\\\")\",\n \"def save(self):\\n # First save the parent form and get the user.\\n new_user = super(SignupFormExtra, self).save()\\n\\n new_user.first_name = self.cleaned_data['first_name']\\n new_user.last_name = self.cleaned_data['last_name']\\n new_user.save()\\n\\n # Userena expects to get the new user from this form, so return the new\\n # user.\\n return new_user\",\n \"def update_user(user_id):\\n user = User.query.get_or_404(user_id)\\n user.first_name = request.form['first_name']\\n user.last_name = request.form['last_name']\\n user.image_url = request.form['image_url']\\n\\n db.session.add(user)\\n db.session.commit()\\n\\n return redirect(\\\"/users\\\")\",\n \"def register_user():\\n\\n form = UserForm()\\n\\n if form.validate_on_submit():\\n username = form.username.data\\n password = form.password.data\\n email = form.email.data\\n first_name = form.first_name.data\\n last_name = form.last_name.data\\n new_user = User.register(username, password, email, first_name, last_name)\\n\\n db.session.add(new_user)\\n db.session.commit()\\n session['username'] = new_user.username\\n\\n flash(f'Created {username} user.')\\n return redirect('/users/<username>')\\n\\n else:\\n return render_template('users/register.html', form=form)\",\n \"def insert_user(self, post_data):\\n con = self.connect()\\n cursor = con.cursor()\\n sql = \\\"\\\"\\\"INSERT INTO users(firstname, lastname, othername, email,\\n phoneNumber, username, password, isAdmin) VALUES(%s, %s, %s,\\n %s, %s, %s, %s, %s)\\\"\\\"\\\"\\n cursor.execute(sql, post_data)\\n cursor.close()\\n con.commit()\\n con.close()\",\n \"def users_create():\",\n \"def add_new_user(self, user):\\n # print(\\\"Saving new user\\\")\\n self.execute(TABELLE['id_users']['insert']['complete_user'],\\n (user['id'], False, False, True, False, False))\\n\\n self.execute(TABELLE['users']['insert'],\\n (user['id'], user['username']))\",\n \"def save_user(self, user, path=None):\\n # Check if this user already exists in elasticsearch\\n index = ''.join(['gh_user-', self.timestamp])\\n\\n self._write_to_datastore(index=index,\\n doc_type='GithubUser',\\n document=user.response,\\n login=user.login,\\n path=path)\\n\\n return True\",\n \"def _post(self, data):\\n new_user_id = DB_USER_TABLE.insert(data)\\n return new_user_id\",\n \"def register():\\n if request.method == 'POST' and request.form['username'] and request.form['password']: \\n user = Storage.save_user(request.form['username'],request.form['password'])\\n first_name = request.form['first_name']\\n last_name = request.form['last_name']\\n email = request.form['email']\\n\\n Storage.save_profile(user=ObjectId(user), first_name=first_name, last_name=last_name,email=email)\\n # alter the redirect\\n return \\\"Success\\\"\\n else:\\n abort(401)\",\n \"def save_new_user(data):\\n user = User.query.filter_by(email=data[\\\"email\\\"]).first()\\n new_user = User(\\n public_id=str(uuid.uuid4()),\\n email=data[\\\"email\\\"],\\n username=data[\\\"username\\\"],\\n password=data[\\\"password\\\"],\\n registered_on=datetime.datetime.utcnow(),\\n )\\n\\n if not user:\\n save_changes(new_user)\\n return generate_token(new_user)\\n\\n else:\\n response_object = {\\n \\\"status\\\": \\\"fail\\\",\\n \\\"message\\\": \\\"User already exists. Please Log in.\\\",\\n }\\n return response_object, 409\",\n \"def new_user():\\n new_user = User(first_name=request.form['first_name'], last_name=request.form['last_name'], image_url=request.form['image_url'] or None)\\n\\n db.session.add(new_user)\\n db.session.commit()\\n\\n return redirect(\\\"/users\\\")\",\n \"def save_user(username, data):\\n\\n hashed_username = base64.b64encode(Cryptography.hash(username).digest()).decode()\\n\\n file = open(getcwd() + Database.__DB_FILENAME, 'a')\\n iv, ciphered_data = Cryptography.cipher(Cryptography.get_passphrase(), data)\\n file.write(hashed_username + ':' + ciphered_data.hex() + '.' + iv.hex() + '\\\\n')\\n file.flush()\\n file.close()\",\n \"def register_user():\\n pass\",\n \"def new_user():\\n success = True\\n try:\\n usr = User(request.json['username'], request.json['email'])\\n db.session.add(usr)\\n db.session.commit()\\n except:\\n success = False\\n return jsonify(success=success)\",\n \"def save_user_profile(instance, **_):\\n instance.profile.save()\",\n \"def test_save_users(self):\\n\\n self.new_users.save_users() # saving the new user\\n self.assertEqual(len(User.user_list), 1)\",\n \"def post(self, name):\\n user = User.find_user_by_name(name).first_or_404()\\n form = UserForm()\\n if user == current_user and form.validate_on_submit(): \\n old_name = current_user.name\\n if form.email.data != '': \\n user.email = form.email.data\\n user.name = form.name.data\\n user.twitter_handle = form.twitter.data\\n db.session.commit()\\n\\n key = make_template_fragment_key(\\\"user\\\", vary_on=[old_name])\\n cache.delete(key)\\n\\n flash('Your edits are saved, thanks.', category = 'info')\\n return redirect(url_for('.user', name=form.name.data))\",\n \"def save(self, commit=True):\\n user = super(UserCreationForm, self).save(commit=False)\\n user.set_password(self.cleaned_data['password1'])\\n\\n user.save()\\n\\n # Making user profile and assigning to CPCESU\\n # CPCESU\\n #group = Organization.objects.get(name='Colorado Plateau')\\n\\n # New profile with group\\n profile = UserProfile(user=user, first_name=self.cleaned_data.get('first_name'),\\n last_name=self.cleaned_data.get('last_name'))\\n profile.save()\\n\\n return user\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8537059","0.8319131","0.8278781","0.7453417","0.73806924","0.7328633","0.7308185","0.72789395","0.7239284","0.723523","0.7180633","0.71803653","0.7159296","0.71304476","0.71304476","0.7122661","0.711703","0.71088237","0.71088237","0.7087179","0.7080573","0.70776594","0.703529","0.703529","0.701797","0.70102465","0.69963586","0.6987024","0.6985983","0.6959762","0.6952062","0.69243205","0.6901856","0.6882247","0.6866934","0.68656254","0.68637353","0.6863023","0.685062","0.684786","0.67917156","0.6782099","0.676182","0.67616314","0.67557013","0.67528474","0.67434126","0.6742232","0.67385244","0.6726338","0.67247385","0.67142844","0.67038083","0.6666964","0.6666072","0.6660802","0.6644744","0.6640606","0.66382575","0.66353166","0.66321987","0.6613689","0.6604482","0.6602192","0.6597276","0.6594511","0.65781343","0.65472203","0.65472203","0.65472203","0.65472203","0.65472203","0.65472203","0.65472203","0.65472203","0.65421987","0.6527219","0.6526361","0.65124404","0.6500105","0.6500105","0.649982","0.6499087","0.64917547","0.6486987","0.64844626","0.6472334","0.6464809","0.6454455","0.643958","0.6433894","0.6419848","0.64150214","0.6413212","0.64108336","0.63965154","0.6395971","0.6391673","0.638922","0.63738996"],"string":"[\n \"0.8537059\",\n \"0.8319131\",\n \"0.8278781\",\n \"0.7453417\",\n \"0.73806924\",\n \"0.7328633\",\n \"0.7308185\",\n \"0.72789395\",\n \"0.7239284\",\n \"0.723523\",\n \"0.7180633\",\n \"0.71803653\",\n \"0.7159296\",\n \"0.71304476\",\n \"0.71304476\",\n \"0.7122661\",\n \"0.711703\",\n \"0.71088237\",\n \"0.71088237\",\n \"0.7087179\",\n \"0.7080573\",\n \"0.70776594\",\n \"0.703529\",\n \"0.703529\",\n \"0.701797\",\n \"0.70102465\",\n \"0.69963586\",\n \"0.6987024\",\n \"0.6985983\",\n \"0.6959762\",\n \"0.6952062\",\n \"0.69243205\",\n \"0.6901856\",\n \"0.6882247\",\n \"0.6866934\",\n \"0.68656254\",\n \"0.68637353\",\n \"0.6863023\",\n \"0.685062\",\n \"0.684786\",\n \"0.67917156\",\n \"0.6782099\",\n \"0.676182\",\n \"0.67616314\",\n \"0.67557013\",\n \"0.67528474\",\n \"0.67434126\",\n \"0.6742232\",\n \"0.67385244\",\n \"0.6726338\",\n \"0.67247385\",\n \"0.67142844\",\n \"0.67038083\",\n \"0.6666964\",\n \"0.6666072\",\n \"0.6660802\",\n \"0.6644744\",\n \"0.6640606\",\n \"0.66382575\",\n \"0.66353166\",\n \"0.66321987\",\n \"0.6613689\",\n \"0.6604482\",\n \"0.6602192\",\n \"0.6597276\",\n \"0.6594511\",\n \"0.65781343\",\n \"0.65472203\",\n \"0.65472203\",\n \"0.65472203\",\n \"0.65472203\",\n \"0.65472203\",\n \"0.65472203\",\n \"0.65472203\",\n \"0.65472203\",\n \"0.65421987\",\n \"0.6527219\",\n \"0.6526361\",\n \"0.65124404\",\n \"0.6500105\",\n \"0.6500105\",\n \"0.649982\",\n \"0.6499087\",\n \"0.64917547\",\n \"0.6486987\",\n \"0.64844626\",\n \"0.6472334\",\n \"0.6464809\",\n \"0.6454455\",\n \"0.643958\",\n \"0.6433894\",\n \"0.6419848\",\n \"0.64150214\",\n \"0.6413212\",\n \"0.64108336\",\n \"0.63965154\",\n \"0.6395971\",\n \"0.6391673\",\n \"0.638922\",\n \"0.63738996\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7518099"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":6396,"cells":{"query":{"kind":"string","value":"One to one identification of the snapshots."},"document":{"kind":"string","value":"def snapshot_identification(snapshot):\n\t\treturn {\n\t\t\t'user_id': snapshot['user_id'],\n\t\t\t'timestamp': snapshot['timestamp'],\n\t\t\t'snapshot_id': snapshot['snapshot_id']}"},"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 unique_id(self):\n return f\"{DOMAIN}_{self._cam_name}_{self._obj_name}_snapshot\"","def snapshot_id(self) -> Optional[str]:\n return pulumi.get(self, \"snapshot_id\")","def snapshot_id(self) -> Optional[str]:\n return pulumi.get(self, \"snapshot_id\")","def snapshot_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"snapshot_id\")","def snapshot_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"snapshot_id\")","def snapshot_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"snapshot_id\")","def identity(self):\n return self.id","def source_instant_snapshot_id(self) -> str:\n return pulumi.get(self, \"source_instant_snapshot_id\")","def get_from_snap_id(self):\n return self.from_snapshot_id","def get_snapshot_uuid(self) -> str:\n return self._snapshot_uuid","def get_image(self):\n logging.debug(\"%s get_image entered\" % str(self.machine_name))\n snapshots = cs.list_snapshots()\n # find the one for this server\n if self.cloudserver:\n server_id = self.cloudserver.id\n else:\n return self.image_id\n\n for snapshot in snapshots:\n img = snapshot.metadata.get(\"instance_uuid\", None)\n # print \"XXX:\", img\n\n if img == server_id:\n print \"Server %s has snapshot %s\" % (server_id, img)\n return img\n\n print \"Server %s has no snapshots\" % (server_id)\n return None","def get_snapshots_of(image):\n snapshot_ids = []\n device_mapping = image.block_device_mapping # dict of devices\n devices = device_mapping.keys()\n for device in devices:\n if device_mapping[device].snapshot_id is not None:\n snapshot_ids.append(device_mapping[device].snapshot_id.encode()) # do I need to have 'encode' here?\n return snapshot_ids","def identity(self, *args, **kwargs):\n return {\n 'id': self.drone_id,\n }","def get_primary_id(self):","def get_from_snap_id(self):\n raise NotImplementedError()","def getIdent (self) :\n return self.id","def getID():","def identifier(self):\r\n return self.id","def get_snapshot(self, name=None, snapshot_id=None):\n if snapshot_id:\n return self._search_snapshot(key=\"snapshot_id\", value=snapshot_id)\n elif name:\n return self._search_snapshot(key=\"name\", value=name)\n else:\n raise ValueError(\"name or snapshot_id must be provided\")","def snapshot(self, snapshot_id):\r\n return self.connection.create_dbsnapshot(snapshot_id, self.id)","def image_reference(self, image_id):\n info = self.image_info[image_id]\n if info['source'] == self.dataset_name:\n return info['id']\n else:\n super.image_reference(image_id)","def getSnapshotsOf(image):\n snapshotIds = []\n deviceMapping = image.block_device_mapping # dict of devices\n devices = deviceMapping.keys()\n for d in devices:\n snapshotId = deviceMapping[d].snapshot_id\n if snapshotId is not None:\n snapshotIds.append(snapshotId.encode())\n return snapshotIds","def snapshot_by_id(self, snapshot_id: int) -> Optional[Snapshot]:\n try:\n return next(snapshot for snapshot in self.metadata.snapshots if snapshot.snapshot_id == snapshot_id)\n except StopIteration:\n return None","def getId(self):","def test_reservation_id_one_instance(self):\n (refs, resv_id) = self.compute_api.create(self.context,\n self.default_flavor,\n image_href=uuids.image_href_id)\n self.assertEqual(len(refs), 1)\n self.assertEqual(refs[0]['reservation_id'], resv_id)","def identify(self):\r\n if \"signature\" in self or \"signatures\" in self:\r\n if len(self._multisignature):\r\n missings = \\\r\n self._multisignature[\"min\"] - \\\r\n len(self.get(\"signatures\", []))\r\n if missings:\r\n raise Exception(\"owner signature missing (%d)\" % missings)\r\n elif self._secondPublicKey:\r\n if \"signSignature\" not in self:\r\n raise Exception(\"second signature is missing\")\r\n dict.pop(self, \"id\", False)\r\n self[\"id\"] = dposlib.core.crypto.getIdFromBytes(\r\n serialize(self, exclude_multi_sig=False)\r\n )\r\n else:\r\n raise Exception(\"transaction not signed\")","def image_reference(self, image_id):\n info = self.image_info[image_id]\n if info[\"source\"] == \"tampers\":\n return info[\"id\"]\n else:\n super(self.__class__, self).image_reference(image_id)","def image_reference(self, image_id):\n\n info = self.image_info[image_id]\n if info[\"source\"] == \"openimage\":\n return info[\"id\"]\n else:\n super(self.__class__, self).image_reference(image_id)","def identifier(self):\n ident = self._json['coredata']['dc:identifier'].split(\":\")[-1]\n if ident != self._id:\n text = \"Profile with ID {} has been merged and the new ID is \"\\\n \"{}. Please update your records manually. Files have \"\\\n \"been cached with the old ID.\".format(self._id, ident)\n warn(text, UserWarning)\n return ident","def current_snapshot(self) -> Optional[Snapshot]:\n if snapshot_id := self.metadata.current_snapshot_id:\n return self.snapshot_by_id(snapshot_id)\n return None","def test_rename_snapshot_by_snap_id(self):\n snapshot_info, sg_name = self.create_sg_snapshot()\n old_name = snapshot_info.get('name')\n snap_id = snapshot_info.get('snapid')\n new_name = self.generate_name(object_type='ss')\n self.replication.rename_snapshot_by_snap_id(\n sg_name, old_name, new_name, snap_id)\n snap_list = self.replication.get_storage_group_snapshot_list(\n sg_name)\n self.assertEqual(new_name, snap_list[0])\n # change name back so clean up will work automatically\n self.replication.rename_snapshot_by_snap_id(\n sg_name, new_name, old_name, snap_id)","def id(self):\n raise NotImplementedError()","def id(self): # type: () -> str\n return self.inspection['Id']","def find_identity(frame, x1, y1, x2, y2):\n height, width, channels = frame.shape\n # The padding is necessary since the OpenCV face detector creates the bounding box around the face and not the head\n part_image = frame[max(0, y1):min(height, y2), max(0, x1):min(width, x2)]\n \n return who_is_it(part_image, database, FRmodel)","def snapshot_name_to_id(name, snap_name, strict=False, runas=None):\n # Validate VM and snapshot names\n name = salt.utils.data.decode(name)\n snap_name = salt.utils.data.decode(snap_name)\n\n # Get a multiline string containing all the snapshot GUIDs\n info = prlctl(\"snapshot-list\", name, runas=runas)\n\n # Get a set of all snapshot GUIDs in the string\n snap_ids = _find_guids(info)\n\n # Try to match the snapshot name to an ID\n named_ids = []\n for snap_id in snap_ids:\n if snapshot_id_to_name(name, snap_id, runas=runas) == snap_name:\n named_ids.append(snap_id)\n\n # Return one or more IDs having snap_name or raise an error upon\n # non-singular names\n if not named_ids:\n raise SaltInvocationError(\n 'No snapshots for VM \"{}\" have name \"{}\"'.format(name, snap_name)\n )\n elif len(named_ids) == 1:\n return named_ids[0]\n else:\n multi_msg = 'Multiple snapshots for VM \"{}\" have name \"{}\"'.format(\n name, snap_name\n )\n if strict:\n raise SaltInvocationError(multi_msg)\n else:\n log.warning(multi_msg)\n return named_ids","def __get_image_id(self):\n return self.__get_multi_images_ids(1)","def identifier(self):\n return self.__id","def _id(self):\n pass","def identifier(self):\n return self._id","def next_identity(self) -> PublicationId:\n ...","def get_uuid(self, obj):\n if \"opensim\" in obj.properties:\n if \"uuid\" in obj.properties[\"opensim\"]:\n return obj.properties['opensim']['uuid']","def created_from_snapshot_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"created_from_snapshot_id\")","def id(self):\n return self.gene_id","def detect_person(snap):\n pass","def unique_id(self):\n return f\"{DOMAIN}_{self._name}_camera\"","def do_id (self, line) :\n\t\tprint \"\tuid=%s(%s)\tgid=%s\"\t% (self.__image['meta']['UID'], self.__image['meta']['user'], self.__image['meta']['GID'] )","def identity(self):\n from sqlalchemy.orm import object_session\n from identity import PartitionIdentity\n\n if self.dataset is None:\n # The relationship will be null until the object is committed\n s = object_session(self)\n\n ds = s.query(Dataset).filter(Dataset.id_ == self.d_id).one()\n else:\n ds = self.dataset\n\n d = {\n 'id': self.id_,\n 'vid': self.vid,\n 'name': self.name,\n 'vname': self.vname,\n 'ref': self.ref,\n 'space': self.space,\n 'time': self.time,\n 'table': self.table.name if self.t_vid is not None else None,\n 'grain': self.grain,\n 'segment': self.segment,\n 'format': self.format if self.format else 'db'\n }\n\n return PartitionIdentity.from_dict(dict(ds.dict.items() + d.items()))","def snapshot(self):\n pass","def name(cls):\n return 'Snapshot'","def id(self):\n\t\treturn self.__id","def get_identifier(self, object):\n try:\n identifier = object[\"uri\"]\n except KeyError:\n identifier = object[\"ref\"]\n return identifier","def get_id(self):\n pass","def get_id(self):\n pass","def get_id(self):\n pass","def get_id(self):\n pass","def snapshot_name(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"snapshot_name\")","def identifier(self):\n raise NotImplementedError","def get_uniqueId(rentalList, id):\n for i in rentalList:\n if id==i.get_id():\n raise RepositoryExceptionRent(\"\\n The given id exists.\\n\".upper())","def snapshot(self):\n snapshot = super(VirtualMachineDAO, self).snapshot()\n for entry in snapshot:\n vm = entry.get(VirtualMachineDAO.INNER_OBJ)\n vm['network'] = VMNetworkDAO(self.session, vm.get(VirtualMachineDAO.FOREIGN_KEY)).snapshot()\n return snapshot","def identifier(self):","def __hash__(self):\n return self['id'].__hash__()","def getIdentity(cls):\n l = []\n for i in range(0,len(cls.id2items)):\n item = (cls.id2items[i],cls.id2items[i])\n l.append(item)\n return Relation(*l)","def __hash__(self):\n return self._id","def get_identifier(self):","def search_id(self,obj):\r\n ##### create the new id ###########\r\n #for x in self.objectValues('Image'):\r\n for x in obj:\r\n liste_id.append(str(x.id())[0:6])\r\n for digit0 in liste_digit:\r\n for digit1 in liste_digit:\r\n for digit2 in liste_digit:\r\n for digit3 in liste_digit:\r\n for digit4 in liste_digit:\r\n for digit5 in liste_digit:\r\n searched_dict=0\r\n searched=str(digit0)+str(digit1)+str(digit2)+str(digit3)+str(digit4)+str(digit5)\r\n if(self.toolbox.hasProperty('eigene_formate')):\r\n self_val=self.toolbox.getProperty('eigene_formate').split(',')\r\n for x in self_val:\r\n liste_val.append('_'+x+'.jpeg')\r\n for extension in liste_val:\r\n searched_extension=str(searched)\r\n if searched_extension in liste_id:\r\n searched_dict=searched_dict+1\r\n if searched_dict==0:\r\n return searched\r\n return ''","def test_link_snapshot_by_snap_id(self):\n snapshot_info, sg_name = self.create_sg_snapshot()\n target_sg = \"{sg}_lnk\".format(sg=sg_name)\n snap_name = snapshot_info.get('name')\n snap_id = snapshot_info.get('snapid')\n self.assertIsNotNone(snap_id)\n self.replication.link_snapshot_by_snap_id(\n sg_name, target_sg, snap_name, snap_id)\n snap_details = self._test_get_ss_snapid_detail(\n sg_name, snap_name, snap_id, check_linked=True)\n self.assertTrue(snap_details.get('linked'))\n self.replication.modify_storage_group_snapshot_by_snap_id(\n sg_name, target_sg, snap_name, snap_id, unlink=True)\n snap_details = self._test_get_ss_snapid_detail(\n sg_name, snap_name, snap_id, check_unlinked=True)\n self.assertFalse(snap_details.get('linked'))\n self.provisioning.delete_storage_group(target_sg)","def ID(self):\n if hasattr(self, 'currentID'):\n return self.currentID\n if hasattr(self, 'callDict'):\n thisID = hashIt(self.callDict)\n if hasattr(self, 'pastInfo'):\n self.pastInfo[thisID] = {'callDict': self.callDict}\n else:\n thisID = None\n self.currentID = thisID\n return thisID","def created_from_snapshot_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"created_from_snapshot_id\")","def ivoid(self):\n return self.get(\"identifier\")","def image_id(cls):\n return str(uuid.uuid4())","def getIdentifiedObject(self):\n return self._IdentifiedObject","def _id(self, document):\n pass","def identity(self) -> Optional[pulumi.Input['IdentityInfoArgs']]:\n return pulumi.get(self, \"identity\")","def fingerprint(self):\n return self.identifier[:4]","def snapshot_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"snapshot_name\")","def snapshot_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"snapshot_name\")","def snapshot_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"snapshot_name\")","def id(self):\n return super().id()","def test_create_storage_group_snapshot_by_snap_id(self):\n snapshot_info, sg_name = self.create_sg_snapshot()\n ss_name = self.generate_name(object_type='ss')\n self.replication.create_storage_group_snapshot(\n sg_name, ss_name, ttl=1, hours=True)\n snapshot_info = self.replication.get_storage_group_snapshot_list(\n sg_name)\n snapshot_details = (\n self.replication.get_storage_group_snapshot_snap_id_list(\n sg_name, ss_name))\n self.replication.delete_storage_group_snapshot_by_snap_id(\n sg_name, ss_name, snapshot_details[0])\n self.assertIn(ss_name, snapshot_info)","def id(self):\n return self.__id","def unique_id(self):\n return '{}-{}-{}'.format(self.airly.latitude, self.airly.longitude,\n self.type)","def __index__(self):\n return self.id","def _get_clone_snapshot_name(self, volume):\n return 'cinder-clone-snapshot-%(id)s' % volume","def id(self):\n return self.__pairs[-1][1]","def identify(self):\n if self.cur_uid is None:\n return\n self.ola_thread.rdm_set(self.universe.get(), self.cur_uid, 0, \n \"IDENTIFY_DEVICE\", \n lambda b, s, uid = self.cur_uid:self._rdm_set_complete(uid, b, s), \n [self.id_state.get()])","def identify_primary_reference_datasets(conn, log):\n\n primary_ref = {}\n\n primary_ref['refimg_id_ip'] = phot_db.find_primary_reference_image_for_field(conn)\n\n query = 'SELECT facility, filter, software FROM reference_images WHERE refimg_id=\"'+str(primary_ref['refimg_id_ip'])+'\"'\n t = phot_db.query_to_astropy_table(conn, query, args=())\n\n primary_ref['facility_id'] = t['facility'][0]\n primary_ref['software_id'] = t['software'][0]\n\n query = 'SELECT filter_id, filter_name FROM filters WHERE filter_name=\"ip\"'\n t = phot_db.query_to_astropy_table(conn, query, args=())\n primary_ref['ip'] = t['filter_id'][0]\n\n for f in ['rp', 'gp']:\n query = 'SELECT filter_id, filter_name FROM filters WHERE filter_name=\"'+f+'\"'\n t = phot_db.query_to_astropy_table(conn, query, args=())\n primary_ref[f] = t['filter_id'][0]\n\n query = 'SELECT refimg_id FROM reference_images WHERE facility=\"'+str(primary_ref['facility_id'])+\\\n '\" AND software=\"'+str(primary_ref['software_id'])+\\\n '\" AND filter=\"'+str(t['filter_id'][0])+'\"'\n qs = phot_db.query_to_astropy_table(conn, query, args=())\n\n if len(qs) > 0:\n primary_ref['refimg_id_'+f] = qs['refimg_id'][0]\n else:\n log.info('WARNING: Database contains no primary reference image data in filter '+f)\n\n log.info('Identified the primary reference datasets for this field as:')\n for key, value in primary_ref.items():\n log.info(str(key)+' = '+str(value))\n\n return primary_ref","def match_id(self):\n return self._id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id","def _get_id(self):\n return self.__id"],"string":"[\n \"def unique_id(self):\\n return f\\\"{DOMAIN}_{self._cam_name}_{self._obj_name}_snapshot\\\"\",\n \"def snapshot_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"snapshot_id\\\")\",\n \"def snapshot_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"snapshot_id\\\")\",\n \"def snapshot_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"snapshot_id\\\")\",\n \"def snapshot_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"snapshot_id\\\")\",\n \"def snapshot_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"snapshot_id\\\")\",\n \"def identity(self):\\n return self.id\",\n \"def source_instant_snapshot_id(self) -> str:\\n return pulumi.get(self, \\\"source_instant_snapshot_id\\\")\",\n \"def get_from_snap_id(self):\\n return self.from_snapshot_id\",\n \"def get_snapshot_uuid(self) -> str:\\n return self._snapshot_uuid\",\n \"def get_image(self):\\n logging.debug(\\\"%s get_image entered\\\" % str(self.machine_name))\\n snapshots = cs.list_snapshots()\\n # find the one for this server\\n if self.cloudserver:\\n server_id = self.cloudserver.id\\n else:\\n return self.image_id\\n\\n for snapshot in snapshots:\\n img = snapshot.metadata.get(\\\"instance_uuid\\\", None)\\n # print \\\"XXX:\\\", img\\n\\n if img == server_id:\\n print \\\"Server %s has snapshot %s\\\" % (server_id, img)\\n return img\\n\\n print \\\"Server %s has no snapshots\\\" % (server_id)\\n return None\",\n \"def get_snapshots_of(image):\\n snapshot_ids = []\\n device_mapping = image.block_device_mapping # dict of devices\\n devices = device_mapping.keys()\\n for device in devices:\\n if device_mapping[device].snapshot_id is not None:\\n snapshot_ids.append(device_mapping[device].snapshot_id.encode()) # do I need to have 'encode' here?\\n return snapshot_ids\",\n \"def identity(self, *args, **kwargs):\\n return {\\n 'id': self.drone_id,\\n }\",\n \"def get_primary_id(self):\",\n \"def get_from_snap_id(self):\\n raise NotImplementedError()\",\n \"def getIdent (self) :\\n return self.id\",\n \"def getID():\",\n \"def identifier(self):\\r\\n return self.id\",\n \"def get_snapshot(self, name=None, snapshot_id=None):\\n if snapshot_id:\\n return self._search_snapshot(key=\\\"snapshot_id\\\", value=snapshot_id)\\n elif name:\\n return self._search_snapshot(key=\\\"name\\\", value=name)\\n else:\\n raise ValueError(\\\"name or snapshot_id must be provided\\\")\",\n \"def snapshot(self, snapshot_id):\\r\\n return self.connection.create_dbsnapshot(snapshot_id, self.id)\",\n \"def image_reference(self, image_id):\\n info = self.image_info[image_id]\\n if info['source'] == self.dataset_name:\\n return info['id']\\n else:\\n super.image_reference(image_id)\",\n \"def getSnapshotsOf(image):\\n snapshotIds = []\\n deviceMapping = image.block_device_mapping # dict of devices\\n devices = deviceMapping.keys()\\n for d in devices:\\n snapshotId = deviceMapping[d].snapshot_id\\n if snapshotId is not None:\\n snapshotIds.append(snapshotId.encode())\\n return snapshotIds\",\n \"def snapshot_by_id(self, snapshot_id: int) -> Optional[Snapshot]:\\n try:\\n return next(snapshot for snapshot in self.metadata.snapshots if snapshot.snapshot_id == snapshot_id)\\n except StopIteration:\\n return None\",\n \"def getId(self):\",\n \"def test_reservation_id_one_instance(self):\\n (refs, resv_id) = self.compute_api.create(self.context,\\n self.default_flavor,\\n image_href=uuids.image_href_id)\\n self.assertEqual(len(refs), 1)\\n self.assertEqual(refs[0]['reservation_id'], resv_id)\",\n \"def identify(self):\\r\\n if \\\"signature\\\" in self or \\\"signatures\\\" in self:\\r\\n if len(self._multisignature):\\r\\n missings = \\\\\\r\\n self._multisignature[\\\"min\\\"] - \\\\\\r\\n len(self.get(\\\"signatures\\\", []))\\r\\n if missings:\\r\\n raise Exception(\\\"owner signature missing (%d)\\\" % missings)\\r\\n elif self._secondPublicKey:\\r\\n if \\\"signSignature\\\" not in self:\\r\\n raise Exception(\\\"second signature is missing\\\")\\r\\n dict.pop(self, \\\"id\\\", False)\\r\\n self[\\\"id\\\"] = dposlib.core.crypto.getIdFromBytes(\\r\\n serialize(self, exclude_multi_sig=False)\\r\\n )\\r\\n else:\\r\\n raise Exception(\\\"transaction not signed\\\")\",\n \"def image_reference(self, image_id):\\n info = self.image_info[image_id]\\n if info[\\\"source\\\"] == \\\"tampers\\\":\\n return info[\\\"id\\\"]\\n else:\\n super(self.__class__, self).image_reference(image_id)\",\n \"def image_reference(self, image_id):\\n\\n info = self.image_info[image_id]\\n if info[\\\"source\\\"] == \\\"openimage\\\":\\n return info[\\\"id\\\"]\\n else:\\n super(self.__class__, self).image_reference(image_id)\",\n \"def identifier(self):\\n ident = self._json['coredata']['dc:identifier'].split(\\\":\\\")[-1]\\n if ident != self._id:\\n text = \\\"Profile with ID {} has been merged and the new ID is \\\"\\\\\\n \\\"{}. Please update your records manually. Files have \\\"\\\\\\n \\\"been cached with the old ID.\\\".format(self._id, ident)\\n warn(text, UserWarning)\\n return ident\",\n \"def current_snapshot(self) -> Optional[Snapshot]:\\n if snapshot_id := self.metadata.current_snapshot_id:\\n return self.snapshot_by_id(snapshot_id)\\n return None\",\n \"def test_rename_snapshot_by_snap_id(self):\\n snapshot_info, sg_name = self.create_sg_snapshot()\\n old_name = snapshot_info.get('name')\\n snap_id = snapshot_info.get('snapid')\\n new_name = self.generate_name(object_type='ss')\\n self.replication.rename_snapshot_by_snap_id(\\n sg_name, old_name, new_name, snap_id)\\n snap_list = self.replication.get_storage_group_snapshot_list(\\n sg_name)\\n self.assertEqual(new_name, snap_list[0])\\n # change name back so clean up will work automatically\\n self.replication.rename_snapshot_by_snap_id(\\n sg_name, new_name, old_name, snap_id)\",\n \"def id(self):\\n raise NotImplementedError()\",\n \"def id(self): # type: () -> str\\n return self.inspection['Id']\",\n \"def find_identity(frame, x1, y1, x2, y2):\\n height, width, channels = frame.shape\\n # The padding is necessary since the OpenCV face detector creates the bounding box around the face and not the head\\n part_image = frame[max(0, y1):min(height, y2), max(0, x1):min(width, x2)]\\n \\n return who_is_it(part_image, database, FRmodel)\",\n \"def snapshot_name_to_id(name, snap_name, strict=False, runas=None):\\n # Validate VM and snapshot names\\n name = salt.utils.data.decode(name)\\n snap_name = salt.utils.data.decode(snap_name)\\n\\n # Get a multiline string containing all the snapshot GUIDs\\n info = prlctl(\\\"snapshot-list\\\", name, runas=runas)\\n\\n # Get a set of all snapshot GUIDs in the string\\n snap_ids = _find_guids(info)\\n\\n # Try to match the snapshot name to an ID\\n named_ids = []\\n for snap_id in snap_ids:\\n if snapshot_id_to_name(name, snap_id, runas=runas) == snap_name:\\n named_ids.append(snap_id)\\n\\n # Return one or more IDs having snap_name or raise an error upon\\n # non-singular names\\n if not named_ids:\\n raise SaltInvocationError(\\n 'No snapshots for VM \\\"{}\\\" have name \\\"{}\\\"'.format(name, snap_name)\\n )\\n elif len(named_ids) == 1:\\n return named_ids[0]\\n else:\\n multi_msg = 'Multiple snapshots for VM \\\"{}\\\" have name \\\"{}\\\"'.format(\\n name, snap_name\\n )\\n if strict:\\n raise SaltInvocationError(multi_msg)\\n else:\\n log.warning(multi_msg)\\n return named_ids\",\n \"def __get_image_id(self):\\n return self.__get_multi_images_ids(1)\",\n \"def identifier(self):\\n return self.__id\",\n \"def _id(self):\\n pass\",\n \"def identifier(self):\\n return self._id\",\n \"def next_identity(self) -> PublicationId:\\n ...\",\n \"def get_uuid(self, obj):\\n if \\\"opensim\\\" in obj.properties:\\n if \\\"uuid\\\" in obj.properties[\\\"opensim\\\"]:\\n return obj.properties['opensim']['uuid']\",\n \"def created_from_snapshot_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"created_from_snapshot_id\\\")\",\n \"def id(self):\\n return self.gene_id\",\n \"def detect_person(snap):\\n pass\",\n \"def unique_id(self):\\n return f\\\"{DOMAIN}_{self._name}_camera\\\"\",\n \"def do_id (self, line) :\\n\\t\\tprint \\\"\\tuid=%s(%s)\\tgid=%s\\\"\\t% (self.__image['meta']['UID'], self.__image['meta']['user'], self.__image['meta']['GID'] )\",\n \"def identity(self):\\n from sqlalchemy.orm import object_session\\n from identity import PartitionIdentity\\n\\n if self.dataset is None:\\n # The relationship will be null until the object is committed\\n s = object_session(self)\\n\\n ds = s.query(Dataset).filter(Dataset.id_ == self.d_id).one()\\n else:\\n ds = self.dataset\\n\\n d = {\\n 'id': self.id_,\\n 'vid': self.vid,\\n 'name': self.name,\\n 'vname': self.vname,\\n 'ref': self.ref,\\n 'space': self.space,\\n 'time': self.time,\\n 'table': self.table.name if self.t_vid is not None else None,\\n 'grain': self.grain,\\n 'segment': self.segment,\\n 'format': self.format if self.format else 'db'\\n }\\n\\n return PartitionIdentity.from_dict(dict(ds.dict.items() + d.items()))\",\n \"def snapshot(self):\\n pass\",\n \"def name(cls):\\n return 'Snapshot'\",\n \"def id(self):\\n\\t\\treturn self.__id\",\n \"def get_identifier(self, object):\\n try:\\n identifier = object[\\\"uri\\\"]\\n except KeyError:\\n identifier = object[\\\"ref\\\"]\\n return identifier\",\n \"def get_id(self):\\n pass\",\n \"def get_id(self):\\n pass\",\n \"def get_id(self):\\n pass\",\n \"def get_id(self):\\n pass\",\n \"def snapshot_name(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"snapshot_name\\\")\",\n \"def identifier(self):\\n raise NotImplementedError\",\n \"def get_uniqueId(rentalList, id):\\n for i in rentalList:\\n if id==i.get_id():\\n raise RepositoryExceptionRent(\\\"\\\\n The given id exists.\\\\n\\\".upper())\",\n \"def snapshot(self):\\n snapshot = super(VirtualMachineDAO, self).snapshot()\\n for entry in snapshot:\\n vm = entry.get(VirtualMachineDAO.INNER_OBJ)\\n vm['network'] = VMNetworkDAO(self.session, vm.get(VirtualMachineDAO.FOREIGN_KEY)).snapshot()\\n return snapshot\",\n \"def identifier(self):\",\n \"def __hash__(self):\\n return self['id'].__hash__()\",\n \"def getIdentity(cls):\\n l = []\\n for i in range(0,len(cls.id2items)):\\n item = (cls.id2items[i],cls.id2items[i])\\n l.append(item)\\n return Relation(*l)\",\n \"def __hash__(self):\\n return self._id\",\n \"def get_identifier(self):\",\n \"def search_id(self,obj):\\r\\n ##### create the new id ###########\\r\\n #for x in self.objectValues('Image'):\\r\\n for x in obj:\\r\\n liste_id.append(str(x.id())[0:6])\\r\\n for digit0 in liste_digit:\\r\\n for digit1 in liste_digit:\\r\\n for digit2 in liste_digit:\\r\\n for digit3 in liste_digit:\\r\\n for digit4 in liste_digit:\\r\\n for digit5 in liste_digit:\\r\\n searched_dict=0\\r\\n searched=str(digit0)+str(digit1)+str(digit2)+str(digit3)+str(digit4)+str(digit5)\\r\\n if(self.toolbox.hasProperty('eigene_formate')):\\r\\n self_val=self.toolbox.getProperty('eigene_formate').split(',')\\r\\n for x in self_val:\\r\\n liste_val.append('_'+x+'.jpeg')\\r\\n for extension in liste_val:\\r\\n searched_extension=str(searched)\\r\\n if searched_extension in liste_id:\\r\\n searched_dict=searched_dict+1\\r\\n if searched_dict==0:\\r\\n return searched\\r\\n return ''\",\n \"def test_link_snapshot_by_snap_id(self):\\n snapshot_info, sg_name = self.create_sg_snapshot()\\n target_sg = \\\"{sg}_lnk\\\".format(sg=sg_name)\\n snap_name = snapshot_info.get('name')\\n snap_id = snapshot_info.get('snapid')\\n self.assertIsNotNone(snap_id)\\n self.replication.link_snapshot_by_snap_id(\\n sg_name, target_sg, snap_name, snap_id)\\n snap_details = self._test_get_ss_snapid_detail(\\n sg_name, snap_name, snap_id, check_linked=True)\\n self.assertTrue(snap_details.get('linked'))\\n self.replication.modify_storage_group_snapshot_by_snap_id(\\n sg_name, target_sg, snap_name, snap_id, unlink=True)\\n snap_details = self._test_get_ss_snapid_detail(\\n sg_name, snap_name, snap_id, check_unlinked=True)\\n self.assertFalse(snap_details.get('linked'))\\n self.provisioning.delete_storage_group(target_sg)\",\n \"def ID(self):\\n if hasattr(self, 'currentID'):\\n return self.currentID\\n if hasattr(self, 'callDict'):\\n thisID = hashIt(self.callDict)\\n if hasattr(self, 'pastInfo'):\\n self.pastInfo[thisID] = {'callDict': self.callDict}\\n else:\\n thisID = None\\n self.currentID = thisID\\n return thisID\",\n \"def created_from_snapshot_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"created_from_snapshot_id\\\")\",\n \"def ivoid(self):\\n return self.get(\\\"identifier\\\")\",\n \"def image_id(cls):\\n return str(uuid.uuid4())\",\n \"def getIdentifiedObject(self):\\n return self._IdentifiedObject\",\n \"def _id(self, document):\\n pass\",\n \"def identity(self) -> Optional[pulumi.Input['IdentityInfoArgs']]:\\n return pulumi.get(self, \\\"identity\\\")\",\n \"def fingerprint(self):\\n return self.identifier[:4]\",\n \"def snapshot_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"snapshot_name\\\")\",\n \"def snapshot_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"snapshot_name\\\")\",\n \"def snapshot_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"snapshot_name\\\")\",\n \"def id(self):\\n return super().id()\",\n \"def test_create_storage_group_snapshot_by_snap_id(self):\\n snapshot_info, sg_name = self.create_sg_snapshot()\\n ss_name = self.generate_name(object_type='ss')\\n self.replication.create_storage_group_snapshot(\\n sg_name, ss_name, ttl=1, hours=True)\\n snapshot_info = self.replication.get_storage_group_snapshot_list(\\n sg_name)\\n snapshot_details = (\\n self.replication.get_storage_group_snapshot_snap_id_list(\\n sg_name, ss_name))\\n self.replication.delete_storage_group_snapshot_by_snap_id(\\n sg_name, ss_name, snapshot_details[0])\\n self.assertIn(ss_name, snapshot_info)\",\n \"def id(self):\\n return self.__id\",\n \"def unique_id(self):\\n return '{}-{}-{}'.format(self.airly.latitude, self.airly.longitude,\\n self.type)\",\n \"def __index__(self):\\n return self.id\",\n \"def _get_clone_snapshot_name(self, volume):\\n return 'cinder-clone-snapshot-%(id)s' % volume\",\n \"def id(self):\\n return self.__pairs[-1][1]\",\n \"def identify(self):\\n if self.cur_uid is None:\\n return\\n self.ola_thread.rdm_set(self.universe.get(), self.cur_uid, 0, \\n \\\"IDENTIFY_DEVICE\\\", \\n lambda b, s, uid = self.cur_uid:self._rdm_set_complete(uid, b, s), \\n [self.id_state.get()])\",\n \"def identify_primary_reference_datasets(conn, log):\\n\\n primary_ref = {}\\n\\n primary_ref['refimg_id_ip'] = phot_db.find_primary_reference_image_for_field(conn)\\n\\n query = 'SELECT facility, filter, software FROM reference_images WHERE refimg_id=\\\"'+str(primary_ref['refimg_id_ip'])+'\\\"'\\n t = phot_db.query_to_astropy_table(conn, query, args=())\\n\\n primary_ref['facility_id'] = t['facility'][0]\\n primary_ref['software_id'] = t['software'][0]\\n\\n query = 'SELECT filter_id, filter_name FROM filters WHERE filter_name=\\\"ip\\\"'\\n t = phot_db.query_to_astropy_table(conn, query, args=())\\n primary_ref['ip'] = t['filter_id'][0]\\n\\n for f in ['rp', 'gp']:\\n query = 'SELECT filter_id, filter_name FROM filters WHERE filter_name=\\\"'+f+'\\\"'\\n t = phot_db.query_to_astropy_table(conn, query, args=())\\n primary_ref[f] = t['filter_id'][0]\\n\\n query = 'SELECT refimg_id FROM reference_images WHERE facility=\\\"'+str(primary_ref['facility_id'])+\\\\\\n '\\\" AND software=\\\"'+str(primary_ref['software_id'])+\\\\\\n '\\\" AND filter=\\\"'+str(t['filter_id'][0])+'\\\"'\\n qs = phot_db.query_to_astropy_table(conn, query, args=())\\n\\n if len(qs) > 0:\\n primary_ref['refimg_id_'+f] = qs['refimg_id'][0]\\n else:\\n log.info('WARNING: Database contains no primary reference image data in filter '+f)\\n\\n log.info('Identified the primary reference datasets for this field as:')\\n for key, value in primary_ref.items():\\n log.info(str(key)+' = '+str(value))\\n\\n return primary_ref\",\n \"def match_id(self):\\n return self._id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\",\n \"def _get_id(self):\\n return self.__id\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6157024","0.6145881","0.6145881","0.58339775","0.58339775","0.58339775","0.5751372","0.5697604","0.5678704","0.55947214","0.5580041","0.5498619","0.5444909","0.54207444","0.53875417","0.5353588","0.5305235","0.52906895","0.5282701","0.5255412","0.5254084","0.5218394","0.5204684","0.51923317","0.51632935","0.5161018","0.5130703","0.51238745","0.51203436","0.5115463","0.51117176","0.5099776","0.5099292","0.50945324","0.5089469","0.50749916","0.50748384","0.5066023","0.5042032","0.50413626","0.50405043","0.5035843","0.5035353","0.5029963","0.49969777","0.49959773","0.49954036","0.49709487","0.4954098","0.49411428","0.49399576","0.49356645","0.49356645","0.49356645","0.49356645","0.4933257","0.4927136","0.4922148","0.49076575","0.4905834","0.48991603","0.4897471","0.4887162","0.48800242","0.48714793","0.48678458","0.48668203","0.48641223","0.48624244","0.485462","0.48311755","0.48260945","0.48195133","0.48136175","0.48051566","0.48051566","0.48051566","0.48032758","0.48032534","0.48011392","0.47983348","0.4796985","0.47914055","0.4789684","0.47865114","0.4768516","0.47652245","0.47587162","0.47587162","0.47587162","0.47587162","0.47587162","0.47587162","0.47587162","0.47587162","0.47587162","0.47587162","0.47587162","0.47587162","0.47587162"],"string":"[\n \"0.6157024\",\n \"0.6145881\",\n \"0.6145881\",\n \"0.58339775\",\n \"0.58339775\",\n \"0.58339775\",\n \"0.5751372\",\n \"0.5697604\",\n \"0.5678704\",\n \"0.55947214\",\n \"0.5580041\",\n \"0.5498619\",\n \"0.5444909\",\n \"0.54207444\",\n \"0.53875417\",\n \"0.5353588\",\n \"0.5305235\",\n \"0.52906895\",\n \"0.5282701\",\n \"0.5255412\",\n \"0.5254084\",\n \"0.5218394\",\n \"0.5204684\",\n \"0.51923317\",\n \"0.51632935\",\n \"0.5161018\",\n \"0.5130703\",\n \"0.51238745\",\n \"0.51203436\",\n \"0.5115463\",\n \"0.51117176\",\n \"0.5099776\",\n \"0.5099292\",\n \"0.50945324\",\n \"0.5089469\",\n \"0.50749916\",\n \"0.50748384\",\n \"0.5066023\",\n \"0.5042032\",\n \"0.50413626\",\n \"0.50405043\",\n \"0.5035843\",\n \"0.5035353\",\n \"0.5029963\",\n \"0.49969777\",\n \"0.49959773\",\n \"0.49954036\",\n \"0.49709487\",\n \"0.4954098\",\n \"0.49411428\",\n \"0.49399576\",\n \"0.49356645\",\n \"0.49356645\",\n \"0.49356645\",\n \"0.49356645\",\n \"0.4933257\",\n \"0.4927136\",\n \"0.4922148\",\n \"0.49076575\",\n \"0.4905834\",\n \"0.48991603\",\n \"0.4897471\",\n \"0.4887162\",\n \"0.48800242\",\n \"0.48714793\",\n \"0.48678458\",\n \"0.48668203\",\n \"0.48641223\",\n \"0.48624244\",\n \"0.485462\",\n \"0.48311755\",\n \"0.48260945\",\n \"0.48195133\",\n \"0.48136175\",\n \"0.48051566\",\n \"0.48051566\",\n \"0.48051566\",\n \"0.48032758\",\n \"0.48032534\",\n \"0.48011392\",\n \"0.47983348\",\n \"0.4796985\",\n \"0.47914055\",\n \"0.4789684\",\n \"0.47865114\",\n \"0.4768516\",\n \"0.47652245\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\",\n \"0.47587162\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6568016"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6397,"cells":{"query":{"kind":"string","value":"The AccountBroker initialze() function before we added the policy stat table. Used by test_policy_table_creation() to make sure that the AccountBroker will correctly add the table for cases where the DB existed before the policy support was added."},"document":{"kind":"string","value":"def prespi_AccountBroker_initialize(self, conn, put_timestamp, **kwargs):\n if not self.account:\n raise ValueError(\n 'Attempting to create a new database with no account set')\n self.create_container_table(conn)\n self.create_account_stat_table(conn, put_timestamp)"},"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 pre_init(self) -> None:\n self._check_and_set_network()\n self._check_and_apply_migrations()","def initialize():\n DATABASE.connect()\n DATABASE.create_tables([User, Entry], safe=True)\n DATABASE.close()","def init():\n database.create_tables([Tracker])\n database.commit()","def initialize():\n db.connect()\n db.create_tables([Entry], safe=True)","def initialize():\n db.connect()\n db.create_tables([Entry], safe=True)","def _init_db(self):\n cursor = self._main_connection.cursor()\n cursor.execute(self.sql[\"create_table\"])\n self._main_connection.commit()","def initialise(self):\n\n if self.db_type == 'sqlite':\n try:\n # Attempt to create schema if not present, to cope with fresh DB file\n BaseSQLite.metadata.create_all(self.engine)\n except OperationalError:\n print(\"Error creating database schema, possible invalid path? ('\" + self.db_name + \"'). Quitting\")\n exit()\n elif self.db_type == 'postgres':\n try:\n # ensure that create schema scripts created before create table scripts\n event.listen(BasePostgres.metadata, 'before_create', CreateSchema('datastore_schema'))\n BasePostgres.metadata.create_all(self.engine)\n except OperationalError:\n print(f\"Error creating database({self.db_name})! Quitting\")\n exit()","def initialize():\n DATABASE.connect()\n DATABASE.create_tables([User], safe=True)\n DATABASE.close()","def init_post_connection(self):\n\n if self.authorized and not self.post_initiated:\n self.create_tables_and_apply_patches()\n self.post_initiated = True\n\n PyFunceble.INTERN[\"mysql\"] = self.__dict__.copy()","def initialize():\n \n db.connect()\n db.create_tables([Product], safe=True)","def initialize():\n DATABASE.connect()\n DATABASE.drop_tables([Journal], safe=True)\n DATABASE.create_tables([Journal], safe=True)\n DATABASE.close()","def initialize():\n\n db.connect() # Se conecta\n db.create_tables([Entry], safe=True) # Crea las tablas\n # safe=true evita crear modelos ya creados","def setup_tables(self):\n try:\n self.cursor.execute('CREATE SCHEMA sandbox')\n self.cursor.execute(\"DROP TABLE sandbox.dvds_rdbhdb_super;\")\n except (db.ProgrammingError, db.OperationalError), e:\n # sandbox may not exist\n pass #raise\n\n try:\n self.cursor.execute(\n \"\"\"CREATE TABLE sandbox.dvds_rdbhdb_super(\n id SERIAL PRIMARY KEY,\n name varchar(40) NOT NULL,\n rating float,\n UNIQUE(name)\n );\n \"\"\" )\n except db.ProgrammingError, e:\n if e[0] != '42P07':\n raise","def setup_table(self):\n\n self.setup.create_basic_table_in_dev()\n self.setup.insert_random_records_into_dev()","def _initial_setup(self):\n logger.info(\"Performing initial database setup...\")\n\n # Set up the migration_version table\n self._execute(\n \"\"\"\n CREATE TABLE migration_version (\n version INTEGER PRIMARY KEY\n )\n \"\"\"\n )\n\n # Initially set the migration version to 0\n self._execute(\n \"\"\"\n INSERT INTO migration_version (\n version\n ) VALUES (?)\n \"\"\",\n (0,),\n )\n\n # Set up any other necessary database tables here\n\n logger.info(\"Database setup complete\")","def init_tables(self) -> None:\n # TODO(#93) maybe raise flag when the schema of existing tables isn't what we expect\n # it to be?\n # \"How to know that schema changes?\"\n # logger.warning(\"some message\")\n with self.table_access_condition:\n conn = self._get_connection()\n conn.execute(\"PRAGMA foreign_keys = 1\")\n with conn:\n c = conn.cursor()\n c.execute(CREATE_PROJECTS_TABLE)\n c.execute(CREATE_TASKS_TABLE)\n c.execute(CREATE_REQUESTERS_TABLE)\n c.execute(CREATE_TASK_RUNS_TABLE)\n c.execute(CREATE_ASSIGNMENTS_TABLE)\n c.execute(CREATE_UNITS_TABLE)\n c.execute(CREATE_WORKERS_TABLE)\n c.execute(CREATE_AGENTS_TABLE)\n c.execute(CREATE_QUALIFICATIONS_TABLE)\n c.execute(CREATE_GRANTED_QUALIFICATIONS_TABLE)\n c.execute(CREATE_ONBOARDING_AGENTS_TABLE)","def init_tables(self):\n\n settings.Base.metadata.tables[\n 'session_master'].drop(bind=settings.engine)\n settings.Base.metadata.tables['uurl'].drop(bind=settings.engine)\n\n settings.Base.metadata.tables[\n 'session_master'].create(bind=settings.engine)\n settings.Base.metadata.tables['uurl'].create(bind=settings.engine)\n\n logging.info(\"Sessionization Tables created\")","def initialize():\n db.connect()\n db.create_tables([Expense], safe=True)","def initialise(self):\n self.set_up()","def init_db():\n # We are setting the module variables here for the first time, so disable the warning\n global DB_USER_TABLE # pylint: disable=global-variable-undefined\n global DB_CUSTOMER_TABLE # pylint: disable=global-variable-undefined\n global DB_USER_CUSTOMER_RELS_TABLE # pylint: disable=global-variable-undefined\n global DB_TICKET_TABLE # pylint: disable=global-variable-undefined\n global DB_COMMENT_TABLE # pylint: disable=global-variable-undefined\n\n db = TinyDB(app.config['DB_NAME'])\n\n DB_USER_TABLE = db.table('users')\n DB_CUSTOMER_TABLE = db.table('customers')\n DB_USER_CUSTOMER_RELS_TABLE = db.table('user_customer_rels')\n DB_TICKET_TABLE = db.table('tickets')\n DB_COMMENT_TABLE = db.table('comments')","def create_tables_and_apply_patches(self):\n\n if self.authorized and not self.db_tables_initiated:\n with self.connection.cursor() as cursor:\n for statement in self.parse_mysql_sql_file():\n cursor.execute(statement)\n\n PyFunceble.LOGGER.info(\n \"Created the missing tables. Applied all patched\"\n )\n\n self.db_tables_initiated = True","def init_db():\n db = get_db()\n Page.create_table(db)\n PageVersion.create_table(db)\n User.create_table(db)","def setUp(self):\n self.app = create_app(config_name=\"testing\")\n self.client = self.app.test_client\n self.bucketlist = {'name':'Go to vacation'}\n\n # bind the app to current context\n with self.app.app_context():\n # create all tables\n db.create_all()","def initialize_db(self) -> None:\n if not self.check_schema_initialized():\n self._create_genes_table()\n self._create_meta_data_table()","def _pre_setup(self):\n apps.clear_cache()\n call_command('migrate', interactive=False, verbosity=0)\n call_command('loaddata', 'initial_data', verbosity=0)\n super(DatatableViewTestCase, self)._pre_setup()","def setup_table(self):\n self.interface.start_transaction()\n self.interface.drop_table(_history_table)\n self.interface.drop_table(_history_stats_table)\n self.interface.create_table(_history_table)\n self.interface.create_index('index1', _history_table, [_history_table['timestamp']])\n self.interface.create_table(_history_stats_table)\n self.interface.create_index('index2', _history_stats_table, [_history_stats_table['benchmark']])\n self.interface.commit_transaction()","def init_tables(self) -> None:\n with self.table_access_condition:\n conn = self._get_connection()\n conn.execute(\"PRAGMA foreign_keys = 1\")\n c = conn.cursor()\n c.execute(tables.CREATE_STUDIES_TABLE)\n c.execute(tables.CREATE_SUBMISSIONS_TABLE)\n c.execute(tables.CREATE_REQUESTERS_TABLE)\n c.execute(tables.CREATE_UNITS_TABLE)\n c.execute(tables.CREATE_WORKERS_TABLE)\n c.execute(tables.CREATE_RUNS_TABLE)\n c.execute(tables.CREATE_RUN_MAP_TABLE)\n c.execute(tables.CREATE_PARTICIPANT_GROUPS_TABLE)\n c.execute(tables.CREATE_PARTICIPANT_GROUP_QUALIFICATIONS_MAPPING_TABLE)\n conn.commit()","def init_tables(database_url, _metadata, checkfirst=True):\n import dpds.storages.db.tables.operations\n import dpds.storages.db.tables.block\n import dpds.storages.db.tables.meta\n with isolated_nullpool_engine(database_url) as engine:\n _metadata.create_all(bind=engine, checkfirst=checkfirst)","def _init_db():\n import alembic.config\n import alembic.command\n alembic_cfg = alembic.config.Config('alembic.ini')\n alembic_cfg.attributes['configure_logger'] = False\n alembic.command.upgrade(alembic_cfg, 'head')\n _reset_db(get_test_db_session())","def __post_init__(self):\n self.dbase = databases.Database(\n self.dsn,\n min_size=self.min_size,\n max_size=self.max_size\n )\n self.engine, self.meta = self.get_engine_metadata()","def init_pre_connection(self):\n\n if \"mysql\" in PyFunceble.INTERN:\n self.__dict__.update(PyFunceble.INTERN[\"mysql\"].copy())\n\n if self.authorized and not self.pre_initiated:\n for (description, data) in self.variables.items():\n environment_var = PyFunceble.helpers.EnvironmentVariable(data[\"env\"])\n if environment_var.exists():\n setattr(\n self, \"_{0}\".format(description), environment_var.get_value(),\n )\n else:\n message = \"[MySQL/MariaDB] Please give us your DB {0} ({1}): \".format(\n description.capitalize(), repr(data[\"default\"])\n )\n\n if description != \"password\":\n user_input = input(message)\n else:\n user_input = getpass(message)\n\n if user_input:\n setattr(self, \"_{0}\".format(description), user_input)\n self.env_content[data[\"env\"]] = user_input\n else:\n setattr(self, \"_{0}\".format(description), data[\"default\"])\n self.env_content[data[\"env\"]] = data[\"default\"]\n\n # pylint: disable = attribute-defined-outside-init\n self._port = int(self._port)\n self.save_to_env_file(self.env_content, self.pyfunceble_env_location)\n self.pre_initiated = True","def _initialize(self, chain, length):\n # If the table already exists, exit now.\n if chain != 0:\n return\n\n # Determine size\n try:\n size = len(self._getfunc())\n except TypeError:\n size = 1\n\n query = \"create table %s (recid INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, trace int(5), %s FLOAT)\" % (self.name, ' FLOAT, '.join(['v%s' % (x+1) for x in range(size)]))\n self.db.cur.execute(query)","def setUp(self):\n self.db_handler = DynamoDBHandler(ModelTests.TABLE_NAME)\n self.init_table()\n self.items = {}\n self.init_items()\n self.populate_table()","def initDB():\n global DATABASE\n\n uid0 = generate_resource_uid('Admin1', 0)\n\n DATABASE[\"users\"] = {\n \"Admin1\": {\n \"Type\": \"admin\",\n \"Password\": \"AdminPass\",\n \"Quota\": int(sys.maxsize),\n \"Resources\": {uid0},\n \"Created\": 1,\n },\n \"User1\": {\n \"Type\": \"user\",\n \"Password\": \"UserPass\",\n \"Quota\": int(sys.maxsize),\n \"Resources\": set([]),\n \"Created\": 0,\n }\n }\n\n DATABASE[\"resources\"] = {\n uid0: \"Admin1\",\n }","def setUp(self):\n init_db()\n self.client = Client(schema)","def setUp(self):\n self.app = create_app(config_name=\"testing\")\n self.client = self.app.test_client\n self.bucketlist = {'name': 'Go to Grand canyon for camping'}\n\n # binds the app to the current context\n with self.app.app_context():\n # create all tables\n db.session.close()\n db.drop_all()\n db.create_all()","def setUp(self):\n try:\n # Get default data from medical_forum_data_dump.sql, populate tables and connect to DB\n ENGINE.populate_tables()\n self.connection = ENGINE.connect()\n\n # In case of error/exception in populating tables, clear all tables data\n except Exception as exception:\n print(exception)\n ENGINE.clear()","def pre_database_node_create(self, resource_dict):\n pass","def initialize(self):\n\n cursor = self.conn.cursor()\n\n # This table can be used as a parent for a collection of runs\n cursor.execute(\n \"\"\"CREATE TABLE IF NOT EXISTS RunCollections (\n id INT AUTO_INCREMENT PRIMARY KEY,\n name VARCHAR(14) UNIQUE\n );\"\"\"\n )\n\n # This table holds in which run each appears.\n cursor.execute(\n \"\"\"CREATE TABLE IF NOT EXISTS Runs (\n id INT AUTO_INCREMENT PRIMARY KEY,\n name VARCHAR(14) UNIQUE,\n collection_id INT,\n FOREIGN KEY (collection_id) REFERENCES RunCollections (id) ON DELETE CASCADE);\"\"\"\n )\n\n # This table holds resources, which can be in multiple runs and have multiple varieties\n cursor.execute(\n \"\"\"CREATE TABLE IF NOT EXISTS Resources (\n id INT AUTO_INCREMENT PRIMARY KEY, \n extension VARCHAR(20), \n webpage VARCHAR(30),\n run_id INT NOT NULL,\n FOREIGN KEY (run_id) REFERENCES Runs (id) ON DELETE CASCADE);\"\"\"\n )\n\n cursor.execute(\n 'SELECT Table_name FROM information_schema.tables WHERE table_schema = \"vpntfg0\" AND Table_name LIKE \"%Varieties_%\" ORDER BY Table_name'\n )\n for row in cursor.fetchall():\n self.variety_tables.append(row[0])\n\n cursor.close()\n _logger.info(\"Variety tables are: %s\" % self.variety_tables)\n\n _logger.info(\"Database initialized\")","def setUp(self):\n create_table(self.DATABASE_PATH)\n self.model = model.CodeReviewDatabase(self.DATABASE_PATH)","def setUp(self):\n self.a = backend.dbconnection.DBConnect()","def __init_database(self):\n from admin.database import init_db\n init_db()","def setUpClass(cls):\n cls.database_connection = DatabaseHandler(database_path)\n cls.database_connection.connect()\n processing.create_table_if_not_exist(cls.database_connection, table_name)\n cls.database_connection.close()","def init_beeswax_db(cls):\n global _INITIALIZED\n if _INITIALIZED:\n return\n\n make_query(cls.client, 'CREATE DATABASE IF NOT EXISTS %(db)s' % {'db': cls.db_name}, wait=True)\n make_query(cls.client, 'CREATE DATABASE IF NOT EXISTS %(db)s_other' % {'db': cls.db_name}, wait=True)\n\n if cls.load_data:\n\n data_file = cls.cluster.fs_prefix + u'/beeswax/sample_data_échantillon_%d.tsv'\n\n # Create a \"test_partitions\" table.\n CREATE_PARTITIONED_TABLE = \"\"\"\n CREATE TABLE `%(db)s`.`test_partitions` (foo INT, bar STRING)\n PARTITIONED BY (baz STRING, boom INT)\n ROW FORMAT DELIMITED\n FIELDS TERMINATED BY '\\t'\n LINES TERMINATED BY '\\n'\n \"\"\" % {'db': cls.db_name}\n make_query(cls.client, CREATE_PARTITIONED_TABLE, wait=True)\n cls._make_data_file(data_file % 1)\n\n LOAD_DATA = \"\"\"\n LOAD DATA INPATH '%(data_file)s'\n OVERWRITE INTO TABLE `%(db)s`.`test_partitions`\n PARTITION (baz='baz_one', boom=12345)\n \"\"\" % {'db': cls.db_name, 'data_file': data_file % 1}\n make_query(cls.client, LOAD_DATA, wait=True, local=False)\n\n # Insert additional partition data into \"test_partitions\" table\n ADD_PARTITION = \"\"\"\n ALTER TABLE `%(db)s`.`test_partitions` ADD PARTITION(baz='baz_foo', boom=67890) LOCATION '%(fs_prefix)s/baz_foo/boom_bar'\n \"\"\" % {'db': cls.db_name, 'fs_prefix': cls.cluster.fs_prefix}\n make_query(cls.client, ADD_PARTITION, wait=True, local=False)\n\n # Create a bunch of other tables\n CREATE_TABLE = \"\"\"\n CREATE TABLE `%(db)s`.`%(name)s` (foo INT, bar STRING)\n COMMENT \"%(comment)s\"\n ROW FORMAT DELIMITED\n FIELDS TERMINATED BY '\\t'\n LINES TERMINATED BY '\\n'\n \"\"\"\n\n # Create a \"test\" table.\n table_info = {'db': cls.db_name, 'name': 'test', 'comment': 'Test table'}\n cls._make_data_file(data_file % 2)\n cls._make_table(table_info['name'], CREATE_TABLE % table_info, data_file % 2)\n\n if is_live_cluster():\n LOG.warning('HUE-2884: We cannot create Hive UTF8 tables when live cluster testing at the moment')\n else:\n # Create a \"test_utf8\" table.\n table_info = {'db': cls.db_name, 'name': 'test_utf8', 'comment': cls.get_i18n_table_comment()}\n cls._make_i18n_data_file(data_file % 3, 'utf-8')\n cls._make_table(table_info['name'], CREATE_TABLE % table_info, data_file % 3)\n\n # Create a \"test_latin1\" table.\n table_info = {'db': cls.db_name, 'name': 'test_latin1', 'comment': cls.get_i18n_table_comment()}\n cls._make_i18n_data_file(data_file % 4, 'latin1')\n cls._make_table(table_info['name'], CREATE_TABLE % table_info, data_file % 4)\n\n # Create a \"myview\" view.\n make_query(cls.client, \"CREATE VIEW `%(db)s`.`myview` (foo, bar) as SELECT * FROM `%(db)s`.`test`\" % {'db': cls.db_name}, wait=True)\n\n _INITIALIZED = True","def on_init(self):\n self.write_log(\"策略初始化\")\n self.exchange_load_bar(self.exchange)","def init(self):\n self.db.connect()\n try:\n self.db.create_tables([JambiModel], safe=True)\n JambiModel.create(ref='0')\n self.logger.info('Database initialized')\n except IntegrityError:\n self.logger.info('Database was already initialized')\n self.db.close()","def _post_init(self):\n pass","def pre_route_table_create(self, resource_dict):\n pass","def initialize_policies(self, policy_collection, options):","async def initialize(self, *, only_init_tables: bool=False):\n self.pool = await aiomysql.create_pool(\n host=self.host, user=self.user, password=self.passwd,\n loop=self.loop)\n db_exists = await self._check_db_exists()\n if not db_exists:\n await self._create_db()\n db_initialized = False\n else:\n db_initialized = await self._check_db_initialized()\n # We close the pool and create a new one because aiomysql doesn't\n # provide an easy way to change the active database for an entire\n # pool, just individual connections.\n self.pool.terminate()\n self.pool = await aiomysql.create_pool(\n host=self.host, user=self.user, password=self.passwd,\n db=self.dbname, loop=self.loop)\n if not db_initialized:\n await self._init_db(only_init_tables)\n await self._upgrade_db()\n log.msg('Database initialized')","def __init__(self):\n # create a connection through our super role via db.connect\n try:\n self.connection = db.connect(SUPER_ROLE, authcode=SUPER_AUTHCODE, host=HOST)\n except db.OperationalError: # thrown if password or role don't match\n print 'Caught an exception while trying to log in, maybe your account does not exist yet?'\n exit()\n \n # get a DictCursor as our cursor (which returns queries as column-name dicts)\n self.cursor = self.connection.cursor(DictCursor)\n \n self.setup_tables()","def configure(self, config):\n # create the follower table if it doesn't already exist\n model.follower_table.create(checkfirst=True)","def __init__(self):\n\n self.tableConnString = os.environ['ENTITYTABLE_CONNECTIONSTRING'];\n self.__table = None","def strict_startup(self):\n self.load_up_initial_db(TIMESTAMP_PARSE_DICT)\n self.clean()\n self.add_numeric_cols()","def prep(self):\n sq1 = 'create table TCVR ( ID, T, C, V, R , primary key ( ID ) ) ;'\n sq2 = 'create table IDX ( ID , A , primary key(A) ) ; '\n self.sq.SQX(sq1)\n self.sq.SQX(sq2)\n sq3 = \"insert into IDX VALUES ( 1 , 'A' ) ; \"\n self.sq.SQX(sq3)","def startup(self):\n self.load_up_initial_db(TIMESTAMP_PARSE_DICT)\n self.add_numeric_cols()","def initialize_db(self, table_name: str):\n create_table_sql = f\"\"\"\n create table if not exists {table_name} (\n id integer primary key autoincrement not null,\n sample_date text not null unique,\n location text not null,\n min_temp real not null,\n max_temp real not null,\n avg_temp real not null);\n \"\"\"\n with DBOperations(self.name) as dbcm:\n dbcm.execute(create_table_sql)","def setUp(self):\n if os.getenv(\"HBNB_TYPE_STORAGE\") == 'db':\n self.db = MySQLdb.connect(os.getenv(\"HBNB_MYSQL_HOST\"),\n os.getenv(\"HBNB_MYSQL_USER\"),\n os.getenv(\"HBNB_MYSQL_PWD\"),\n os.getenv(\"HBNB_MYSQL_DB\"))\n self.cursor = self.db.cursor()","def _initialize(self):\n query_table = self._cursor.execute(f\"\"\"\n SELECT name\n FROM sqlite_master\n WHERE type='table' AND name='{self._table_name}';\"\"\")\n\n if not query_table.fetchone():\n self._cursor.execute(f\"\"\"\n CREATE TABLE {self._table_name} (\n id char(36),\n term TEXT,\n timestamp BIGINT\n );\"\"\")\n\n self._cursor.execute(f\"\"\"\n CREATE INDEX index_timestamp\n ON {self._table_name} (timestamp);\"\"\")\n\n self._conn.commit()","def process_table_init(self):\n logging.debug(\"Processing table initialization, %d entries\",\n len(self.table_initialization))\n\n for init_entry in self.table_initialization:\n for table_name, entry_desc in init_entry.items():\n self.air_table[table_name].add_entry(\n table_entry.description_to_entry(entry_desc))","def db_initialise():\n generate_migration_file()\n if not MySQLScheme.fetch_one(IS_MIGRATION_TABLE,\n **{\"args\": {'schema': SCHEMA}}):\n with open(MIGRATION_FILE, 'r') as init_sql:\n data = init_sql.read()\n\n if f\"CREATE TABLE IF NOT EXISTS {MIGRATION_TABLE}\" not in data:\n when = str(int(time.time()))\n sql_file = os.path.join(MIGRATION_FOLDER, f\"{when}.sql\")\n\n with open(sql_file, 'w') as save_sql:\n up = MYSQL_MIGRATION_UP.format(f\"upgrade-{when}\", when,\n MIGRATION_TABLE)\n down = MYSQL_MIGRATION_DOWN.format(f\"downgrade-{when}\",\n MIGRATION_TABLE)\n\n save_sql.write(\"\\n\\n\".join([up, down]))\n LOGGER.info(f\"migration file: \"\n f\"{os.path.join('migrations', sql_file)}\")\n else:\n when = re.findall('[0-9]+', data)[0]\n\n generate_migration_file()\n dbi_query = anosql.from_path(MIGRATION_FILE, 'psycopg2')\n MySQLScheme.commit(getattr(dbi_query, f\"upgrade_{when}\").sql)\n LOGGER.info(f\"initial successful migration: {when}\")","def create_table(self):\n pass","def init_db():\n db.drop_all()\n db.create_all()\n\n print(\"Initialized Connect 4 Database.\")","def pre_track_containers_create_policy_stat(self, conn):\n conn.executescript(\"\"\"\n CREATE TABLE policy_stat (\n storage_policy_index INTEGER PRIMARY KEY,\n object_count INTEGER DEFAULT 0,\n bytes_used INTEGER DEFAULT 0\n );\n INSERT OR IGNORE INTO policy_stat (\n storage_policy_index, object_count, bytes_used\n )\n SELECT 0, object_count, bytes_used\n FROM account_stat\n WHERE container_count > 0;\n \"\"\")","def init_table_obj(self):\n # Check the existence of original table\n if not self.table_exists(self.table_name):\n raise OSCError(\n \"TABLE_NOT_EXIST\", {\"db\": self._current_db, \"table\": self.table_name}\n )\n self._old_table = self.fetch_table_schema(self.table_name)\n self.partitions[self.table_name] = self.fetch_partitions(self.table_name)\n # The table after swap will have the same partition layout as current\n # table\n self.partitions[self.renamed_table_name] = self.partitions[self.table_name]\n # Preserve the auto_inc value from old table, so that we don't revert\n # back to a smaller value after OSC\n if self._old_table.auto_increment:\n self._new_table.auto_increment = self._old_table.auto_increment\n # We don't change the storage engine in OSC, so just use\n # the fetched instance storage engine\n self._new_table.engine = self._old_table.engine\n # Populate both old and new tables with explicit charset/collate\n self.populate_charset_collation(self._old_table)\n self.populate_charset_collation(self._new_table)","def setup_before_migration(self, apps):","def _real_initialize(self):\n pass","def post_init(self):\n\t\tpass","def init():\n print(\"Executing initialization\")\n print(db.dsn)\n cursor = yield momoko.Op(\n db.execute,\n \"\"\"\n DROP SCHEMA public CASCADE;\n CREATE SCHEMA public;\n CREATE TABLE game\n (\n game_id text PRIMARY KEY,\n players integer,\n state bytea,\n timestamp timestamp\n );\n CREATE UNIQUE INDEX ix_game_id\n ON game\n (game_id);\n CREATE INDEX ix_timestamp\n ON game\n (timestamp);\n \"\"\")\n try:\n print(cursor.fetchall())\n except psycopg2.ProgrammingError:\n pass\n io = ioloop.IOLoop.instance()\n io.stop()","def _afterInit(self):\n pass","def _post_init(self) -> None:\n return","def init_db():\n global app\n Promotions.init_db(app)","def on_init(self):\n self.write_log(\"策略初始化\")","def on_init(self):\n self.write_log(\"策略初始化\")","def initialise(self):\r\n return","def initialise(self):\r\n return","def __init__(self, database_config):\n self.conn = self._get_database_connection(\n database_config[\"type\"], database_config[\"connection_string\"]\n )\n self.cursor = self.conn.cursor()\n self.db_type = database_config[\"type\"]\n\n # Try to check the current migration version\n migration_level = 0\n # noinspection PyBroadException\n try:\n self._execute(\"SELECT version FROM migration_version\")\n row = self.cursor.fetchone()\n migration_level = row[0]\n except Exception:\n self._initial_setup()\n finally:\n if migration_level < latest_migration_version:\n self._run_migrations(migration_level)\n\n logger.info(f\"Database initialization of type '{self.db_type}' complete\")","def __init__(self):\n # Wipe the db\n self.wipe_db()\n\n # Set some global things\n try:\n dashboard_configuration = DashboardConfiguration(type=\"default\")\n dashboard_configuration.save()\n except IntegrityError:\n dashboard_configuration = DashboardConfiguration.objects.filter(type=\"default\").first()\n\n # Add all players from dataset\n group = self.add_players(dashboard_configuration)\n\n # Add all games from the dataset\n self.add_games()\n\n # Create the games played for this group\n self.add_game_played(group)","def initialize(self) -> None:\n # First, establish a connection to the specified database\n try:\n self._connect_to_db()\n except psycopg2.OperationalError: # specified database does not exist\n with psycopg2.connect(database=DATABASE_ENV[\"POSTGRES_DB\"],\n user=self.dbuser, password=self.dbpassword,\n host=self.dbhost, port=str(self.dbport)) as con:\n with con.cursor() as cur:\n con.autocommit = True # cannot create db inside a transaction\n cur.execute(f'CREATE DATABASE \"{self.dbname}\"')\n con.autocommit = False\n self._connect_to_db() # try again\n\n # Second, create the necessary database table, only if required\n with self._connection.cursor() as cur:\n cur.execute(f\"\"\"\n CREATE TABLE IF NOT EXISTS \"{self.MESSAGE_TABLE_NAME}\" (\n id SERIAL PRIMARY KEY,\n key CHAR(4) NOT NULL,\n value REAL NOT NULL,\n ts TIMESTAMP NOT NULL,\n tz TEXT NOT NULL\n );\n \"\"\")\n self._connection.commit()","def setUp(self):\n db.drop_all() # clean up the last tests\n db.create_all() # make our sqlalchemy tables\n self.app = app.test_client()\n initialize_logging(logging.CRITICAL)","def pre_service_appliance_set_create(self, resource_dict):\n pass","def init_database(self):\n # init_database(self.engine)","def create_all_tables(self):\n pass","def _manually_initialize(self) -> None:\n # XXX: maybe refactor, this is actually part of the public interface\n pass","def __init__(self):\n self.__engine = create_engine('mysql+mysqldb://{}:{}@{}/{}'.\n format(getenv('HBNB_MYSQL_USER'),\n getenv('HBNB_MYSQL_PWD'),\n getenv('HBNB_MYSQL_HOST'),\n getenv('HBNB_MYSQL_DB')),\n pool_pre_ping=True)\n\n if getenv('HBNB_ENV') == 'test':\n \"\"\" Drop all tables\"\"\"\n Base.metadata.drop_all(self.__engine)\n\n Base.metadata.create_all(self.__engine)\n Session = sessionmaker(self.__engine)\n self.__session = Session()","def startUp(self):\n pass","def test_init(self):\n self.assertIsNotNone(DatabaseIntermediary(), self.ec.db)","def _db_init_data_tables(self):\n\n #\n # TESTTYPE table\n #\n return self._db_execute(\n \"\"\"\n create table TESTTYPE (\n KEY text unique,\n VALUE text\n )\n \"\"\"\n )","def test_init(self):\n sample = PrepSample(self.sample_id, self.prep_template)\n # Check that the internal id have been correctly set\n self.assertEqual(sample._id, '1.SKB8.640193')\n # Check that the internal template have been correctly set\n self.assertEqual(sample._md_template, self.prep_template)\n # Check that the internal dynamic table name have been correctly set\n self.assertEqual(sample._dynamic_table, \"prep_1\")","def django_db_setup(django_db_setup, django_db_blocker):\n with django_db_blocker.unblock():\n # todo Now remove the --noinput just to be sure that the test database's data will be deleted\n management.call_command('flush', '--noinput')\n zakanda.db.create_initial_data()","async def _create_table(self, table: TableSchema) -> None:\n try:\n await self.conn.execute(get_create_table(table))\n except PostgresError: # Only DB related exceptions\n print(f\"Failed to execute CREATE TABLE for {table['name']}\")\n raise\n # Initialize migration level (so that it can be altered in future)\n await self.conn.execute('INSERT INTO tinymud_migrations (table_name, level) VALUES ($1, $2)', table['name'], 0)","def __init__(self):\n self.__engine = create_engine('mysql+mysqldb://{}:{}@{}/{}'\n .format(os.environ['HBNB_MYSQL_USER'],\n os.environ['HBNB_MYSQL_PWD'],\n os.environ['HBNB_MYSQL_HOST'],\n os.environ['HBNB_MYSQL_DB']),\n pool_pre_ping=True)\n try:\n if os.environ['HBNB_ENV'] == 'test':\n Base.metadata.drop_all(self.__engine)\n except KeyError:\n pass","def pre_init_hook(cr):\n try:\n cr.execute(\n \"\"\"\n ALTER TABLE product_product\n ADD pricelist_id INTEGER REFERENCES product_pricelist(id),\n ADD currency_id INTEGER REFERENCES res_currency(id);\n ALTER TABLE product_template\n ADD currency_id INTEGER REFERENCES res_currency(id);\n \"\"\"\n )\n except psycopg2.ProgrammingError:\n cr.rollback()\n\n try:\n cr.execute(\n \"\"\"\n UPDATE product_product\n SET pricelist_id = 1,\n currency_id = 20\n \"\"\"\n )\n except psycopg2.ProgrammingError:\n cr.rollback()\n\n return True","def setUpClass(cls):\n if AppTestCase.run_once:\n return # Only create tables once per test suite run\n AppTestCase.run_once = True\n cls.create_test_database()","async def prepare_databases(self):","def setUp(self):\r\n self.app = create_app(config_name=\"testing\")\r\n self.client = self.app.test_client\r\n self.candidate = {\"name\":\"Aslam\", \"degree_name\":\"BSCS\", \"address\":\"lahore\"}\r\n\r\n # binds the app to the current context\r\n with self.app.app_context():\r\n # create all tables\r\n db.session.close()\r\n db.drop_all()\r\n db.create_all()","def init_db():\n\tdb.drop_all()\n\tdb.create_all()\n\n\tprint(\"Initialized Database.\")\n\treturn","def _initialize(self):\n self.send_init_command()","def do_init(self):\n\n pass","def __init__(self):\n self.__db = sqlite3.connect(DB_PATH)\n self.__cur = self.__db.cursor()\n self.__create_tables()"],"string":"[\n \"def pre_init(self) -> None:\\n self._check_and_set_network()\\n self._check_and_apply_migrations()\",\n \"def initialize():\\n DATABASE.connect()\\n DATABASE.create_tables([User, Entry], safe=True)\\n DATABASE.close()\",\n \"def init():\\n database.create_tables([Tracker])\\n database.commit()\",\n \"def initialize():\\n db.connect()\\n db.create_tables([Entry], safe=True)\",\n \"def initialize():\\n db.connect()\\n db.create_tables([Entry], safe=True)\",\n \"def _init_db(self):\\n cursor = self._main_connection.cursor()\\n cursor.execute(self.sql[\\\"create_table\\\"])\\n self._main_connection.commit()\",\n \"def initialise(self):\\n\\n if self.db_type == 'sqlite':\\n try:\\n # Attempt to create schema if not present, to cope with fresh DB file\\n BaseSQLite.metadata.create_all(self.engine)\\n except OperationalError:\\n print(\\\"Error creating database schema, possible invalid path? ('\\\" + self.db_name + \\\"'). Quitting\\\")\\n exit()\\n elif self.db_type == 'postgres':\\n try:\\n # ensure that create schema scripts created before create table scripts\\n event.listen(BasePostgres.metadata, 'before_create', CreateSchema('datastore_schema'))\\n BasePostgres.metadata.create_all(self.engine)\\n except OperationalError:\\n print(f\\\"Error creating database({self.db_name})! Quitting\\\")\\n exit()\",\n \"def initialize():\\n DATABASE.connect()\\n DATABASE.create_tables([User], safe=True)\\n DATABASE.close()\",\n \"def init_post_connection(self):\\n\\n if self.authorized and not self.post_initiated:\\n self.create_tables_and_apply_patches()\\n self.post_initiated = True\\n\\n PyFunceble.INTERN[\\\"mysql\\\"] = self.__dict__.copy()\",\n \"def initialize():\\n \\n db.connect()\\n db.create_tables([Product], safe=True)\",\n \"def initialize():\\n DATABASE.connect()\\n DATABASE.drop_tables([Journal], safe=True)\\n DATABASE.create_tables([Journal], safe=True)\\n DATABASE.close()\",\n \"def initialize():\\n\\n db.connect() # Se conecta\\n db.create_tables([Entry], safe=True) # Crea las tablas\\n # safe=true evita crear modelos ya creados\",\n \"def setup_tables(self):\\n try:\\n self.cursor.execute('CREATE SCHEMA sandbox')\\n self.cursor.execute(\\\"DROP TABLE sandbox.dvds_rdbhdb_super;\\\")\\n except (db.ProgrammingError, db.OperationalError), e:\\n # sandbox may not exist\\n pass #raise\\n\\n try:\\n self.cursor.execute(\\n \\\"\\\"\\\"CREATE TABLE sandbox.dvds_rdbhdb_super(\\n id SERIAL PRIMARY KEY,\\n name varchar(40) NOT NULL,\\n rating float,\\n UNIQUE(name)\\n );\\n \\\"\\\"\\\" )\\n except db.ProgrammingError, e:\\n if e[0] != '42P07':\\n raise\",\n \"def setup_table(self):\\n\\n self.setup.create_basic_table_in_dev()\\n self.setup.insert_random_records_into_dev()\",\n \"def _initial_setup(self):\\n logger.info(\\\"Performing initial database setup...\\\")\\n\\n # Set up the migration_version table\\n self._execute(\\n \\\"\\\"\\\"\\n CREATE TABLE migration_version (\\n version INTEGER PRIMARY KEY\\n )\\n \\\"\\\"\\\"\\n )\\n\\n # Initially set the migration version to 0\\n self._execute(\\n \\\"\\\"\\\"\\n INSERT INTO migration_version (\\n version\\n ) VALUES (?)\\n \\\"\\\"\\\",\\n (0,),\\n )\\n\\n # Set up any other necessary database tables here\\n\\n logger.info(\\\"Database setup complete\\\")\",\n \"def init_tables(self) -> None:\\n # TODO(#93) maybe raise flag when the schema of existing tables isn't what we expect\\n # it to be?\\n # \\\"How to know that schema changes?\\\"\\n # logger.warning(\\\"some message\\\")\\n with self.table_access_condition:\\n conn = self._get_connection()\\n conn.execute(\\\"PRAGMA foreign_keys = 1\\\")\\n with conn:\\n c = conn.cursor()\\n c.execute(CREATE_PROJECTS_TABLE)\\n c.execute(CREATE_TASKS_TABLE)\\n c.execute(CREATE_REQUESTERS_TABLE)\\n c.execute(CREATE_TASK_RUNS_TABLE)\\n c.execute(CREATE_ASSIGNMENTS_TABLE)\\n c.execute(CREATE_UNITS_TABLE)\\n c.execute(CREATE_WORKERS_TABLE)\\n c.execute(CREATE_AGENTS_TABLE)\\n c.execute(CREATE_QUALIFICATIONS_TABLE)\\n c.execute(CREATE_GRANTED_QUALIFICATIONS_TABLE)\\n c.execute(CREATE_ONBOARDING_AGENTS_TABLE)\",\n \"def init_tables(self):\\n\\n settings.Base.metadata.tables[\\n 'session_master'].drop(bind=settings.engine)\\n settings.Base.metadata.tables['uurl'].drop(bind=settings.engine)\\n\\n settings.Base.metadata.tables[\\n 'session_master'].create(bind=settings.engine)\\n settings.Base.metadata.tables['uurl'].create(bind=settings.engine)\\n\\n logging.info(\\\"Sessionization Tables created\\\")\",\n \"def initialize():\\n db.connect()\\n db.create_tables([Expense], safe=True)\",\n \"def initialise(self):\\n self.set_up()\",\n \"def init_db():\\n # We are setting the module variables here for the first time, so disable the warning\\n global DB_USER_TABLE # pylint: disable=global-variable-undefined\\n global DB_CUSTOMER_TABLE # pylint: disable=global-variable-undefined\\n global DB_USER_CUSTOMER_RELS_TABLE # pylint: disable=global-variable-undefined\\n global DB_TICKET_TABLE # pylint: disable=global-variable-undefined\\n global DB_COMMENT_TABLE # pylint: disable=global-variable-undefined\\n\\n db = TinyDB(app.config['DB_NAME'])\\n\\n DB_USER_TABLE = db.table('users')\\n DB_CUSTOMER_TABLE = db.table('customers')\\n DB_USER_CUSTOMER_RELS_TABLE = db.table('user_customer_rels')\\n DB_TICKET_TABLE = db.table('tickets')\\n DB_COMMENT_TABLE = db.table('comments')\",\n \"def create_tables_and_apply_patches(self):\\n\\n if self.authorized and not self.db_tables_initiated:\\n with self.connection.cursor() as cursor:\\n for statement in self.parse_mysql_sql_file():\\n cursor.execute(statement)\\n\\n PyFunceble.LOGGER.info(\\n \\\"Created the missing tables. Applied all patched\\\"\\n )\\n\\n self.db_tables_initiated = True\",\n \"def init_db():\\n db = get_db()\\n Page.create_table(db)\\n PageVersion.create_table(db)\\n User.create_table(db)\",\n \"def setUp(self):\\n self.app = create_app(config_name=\\\"testing\\\")\\n self.client = self.app.test_client\\n self.bucketlist = {'name':'Go to vacation'}\\n\\n # bind the app to current context\\n with self.app.app_context():\\n # create all tables\\n db.create_all()\",\n \"def initialize_db(self) -> None:\\n if not self.check_schema_initialized():\\n self._create_genes_table()\\n self._create_meta_data_table()\",\n \"def _pre_setup(self):\\n apps.clear_cache()\\n call_command('migrate', interactive=False, verbosity=0)\\n call_command('loaddata', 'initial_data', verbosity=0)\\n super(DatatableViewTestCase, self)._pre_setup()\",\n \"def setup_table(self):\\n self.interface.start_transaction()\\n self.interface.drop_table(_history_table)\\n self.interface.drop_table(_history_stats_table)\\n self.interface.create_table(_history_table)\\n self.interface.create_index('index1', _history_table, [_history_table['timestamp']])\\n self.interface.create_table(_history_stats_table)\\n self.interface.create_index('index2', _history_stats_table, [_history_stats_table['benchmark']])\\n self.interface.commit_transaction()\",\n \"def init_tables(self) -> None:\\n with self.table_access_condition:\\n conn = self._get_connection()\\n conn.execute(\\\"PRAGMA foreign_keys = 1\\\")\\n c = conn.cursor()\\n c.execute(tables.CREATE_STUDIES_TABLE)\\n c.execute(tables.CREATE_SUBMISSIONS_TABLE)\\n c.execute(tables.CREATE_REQUESTERS_TABLE)\\n c.execute(tables.CREATE_UNITS_TABLE)\\n c.execute(tables.CREATE_WORKERS_TABLE)\\n c.execute(tables.CREATE_RUNS_TABLE)\\n c.execute(tables.CREATE_RUN_MAP_TABLE)\\n c.execute(tables.CREATE_PARTICIPANT_GROUPS_TABLE)\\n c.execute(tables.CREATE_PARTICIPANT_GROUP_QUALIFICATIONS_MAPPING_TABLE)\\n conn.commit()\",\n \"def init_tables(database_url, _metadata, checkfirst=True):\\n import dpds.storages.db.tables.operations\\n import dpds.storages.db.tables.block\\n import dpds.storages.db.tables.meta\\n with isolated_nullpool_engine(database_url) as engine:\\n _metadata.create_all(bind=engine, checkfirst=checkfirst)\",\n \"def _init_db():\\n import alembic.config\\n import alembic.command\\n alembic_cfg = alembic.config.Config('alembic.ini')\\n alembic_cfg.attributes['configure_logger'] = False\\n alembic.command.upgrade(alembic_cfg, 'head')\\n _reset_db(get_test_db_session())\",\n \"def __post_init__(self):\\n self.dbase = databases.Database(\\n self.dsn,\\n min_size=self.min_size,\\n max_size=self.max_size\\n )\\n self.engine, self.meta = self.get_engine_metadata()\",\n \"def init_pre_connection(self):\\n\\n if \\\"mysql\\\" in PyFunceble.INTERN:\\n self.__dict__.update(PyFunceble.INTERN[\\\"mysql\\\"].copy())\\n\\n if self.authorized and not self.pre_initiated:\\n for (description, data) in self.variables.items():\\n environment_var = PyFunceble.helpers.EnvironmentVariable(data[\\\"env\\\"])\\n if environment_var.exists():\\n setattr(\\n self, \\\"_{0}\\\".format(description), environment_var.get_value(),\\n )\\n else:\\n message = \\\"[MySQL/MariaDB] Please give us your DB {0} ({1}): \\\".format(\\n description.capitalize(), repr(data[\\\"default\\\"])\\n )\\n\\n if description != \\\"password\\\":\\n user_input = input(message)\\n else:\\n user_input = getpass(message)\\n\\n if user_input:\\n setattr(self, \\\"_{0}\\\".format(description), user_input)\\n self.env_content[data[\\\"env\\\"]] = user_input\\n else:\\n setattr(self, \\\"_{0}\\\".format(description), data[\\\"default\\\"])\\n self.env_content[data[\\\"env\\\"]] = data[\\\"default\\\"]\\n\\n # pylint: disable = attribute-defined-outside-init\\n self._port = int(self._port)\\n self.save_to_env_file(self.env_content, self.pyfunceble_env_location)\\n self.pre_initiated = True\",\n \"def _initialize(self, chain, length):\\n # If the table already exists, exit now.\\n if chain != 0:\\n return\\n\\n # Determine size\\n try:\\n size = len(self._getfunc())\\n except TypeError:\\n size = 1\\n\\n query = \\\"create table %s (recid INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, trace int(5), %s FLOAT)\\\" % (self.name, ' FLOAT, '.join(['v%s' % (x+1) for x in range(size)]))\\n self.db.cur.execute(query)\",\n \"def setUp(self):\\n self.db_handler = DynamoDBHandler(ModelTests.TABLE_NAME)\\n self.init_table()\\n self.items = {}\\n self.init_items()\\n self.populate_table()\",\n \"def initDB():\\n global DATABASE\\n\\n uid0 = generate_resource_uid('Admin1', 0)\\n\\n DATABASE[\\\"users\\\"] = {\\n \\\"Admin1\\\": {\\n \\\"Type\\\": \\\"admin\\\",\\n \\\"Password\\\": \\\"AdminPass\\\",\\n \\\"Quota\\\": int(sys.maxsize),\\n \\\"Resources\\\": {uid0},\\n \\\"Created\\\": 1,\\n },\\n \\\"User1\\\": {\\n \\\"Type\\\": \\\"user\\\",\\n \\\"Password\\\": \\\"UserPass\\\",\\n \\\"Quota\\\": int(sys.maxsize),\\n \\\"Resources\\\": set([]),\\n \\\"Created\\\": 0,\\n }\\n }\\n\\n DATABASE[\\\"resources\\\"] = {\\n uid0: \\\"Admin1\\\",\\n }\",\n \"def setUp(self):\\n init_db()\\n self.client = Client(schema)\",\n \"def setUp(self):\\n self.app = create_app(config_name=\\\"testing\\\")\\n self.client = self.app.test_client\\n self.bucketlist = {'name': 'Go to Grand canyon for camping'}\\n\\n # binds the app to the current context\\n with self.app.app_context():\\n # create all tables\\n db.session.close()\\n db.drop_all()\\n db.create_all()\",\n \"def setUp(self):\\n try:\\n # Get default data from medical_forum_data_dump.sql, populate tables and connect to DB\\n ENGINE.populate_tables()\\n self.connection = ENGINE.connect()\\n\\n # In case of error/exception in populating tables, clear all tables data\\n except Exception as exception:\\n print(exception)\\n ENGINE.clear()\",\n \"def pre_database_node_create(self, resource_dict):\\n pass\",\n \"def initialize(self):\\n\\n cursor = self.conn.cursor()\\n\\n # This table can be used as a parent for a collection of runs\\n cursor.execute(\\n \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS RunCollections (\\n id INT AUTO_INCREMENT PRIMARY KEY,\\n name VARCHAR(14) UNIQUE\\n );\\\"\\\"\\\"\\n )\\n\\n # This table holds in which run each appears.\\n cursor.execute(\\n \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS Runs (\\n id INT AUTO_INCREMENT PRIMARY KEY,\\n name VARCHAR(14) UNIQUE,\\n collection_id INT,\\n FOREIGN KEY (collection_id) REFERENCES RunCollections (id) ON DELETE CASCADE);\\\"\\\"\\\"\\n )\\n\\n # This table holds resources, which can be in multiple runs and have multiple varieties\\n cursor.execute(\\n \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS Resources (\\n id INT AUTO_INCREMENT PRIMARY KEY, \\n extension VARCHAR(20), \\n webpage VARCHAR(30),\\n run_id INT NOT NULL,\\n FOREIGN KEY (run_id) REFERENCES Runs (id) ON DELETE CASCADE);\\\"\\\"\\\"\\n )\\n\\n cursor.execute(\\n 'SELECT Table_name FROM information_schema.tables WHERE table_schema = \\\"vpntfg0\\\" AND Table_name LIKE \\\"%Varieties_%\\\" ORDER BY Table_name'\\n )\\n for row in cursor.fetchall():\\n self.variety_tables.append(row[0])\\n\\n cursor.close()\\n _logger.info(\\\"Variety tables are: %s\\\" % self.variety_tables)\\n\\n _logger.info(\\\"Database initialized\\\")\",\n \"def setUp(self):\\n create_table(self.DATABASE_PATH)\\n self.model = model.CodeReviewDatabase(self.DATABASE_PATH)\",\n \"def setUp(self):\\n self.a = backend.dbconnection.DBConnect()\",\n \"def __init_database(self):\\n from admin.database import init_db\\n init_db()\",\n \"def setUpClass(cls):\\n cls.database_connection = DatabaseHandler(database_path)\\n cls.database_connection.connect()\\n processing.create_table_if_not_exist(cls.database_connection, table_name)\\n cls.database_connection.close()\",\n \"def init_beeswax_db(cls):\\n global _INITIALIZED\\n if _INITIALIZED:\\n return\\n\\n make_query(cls.client, 'CREATE DATABASE IF NOT EXISTS %(db)s' % {'db': cls.db_name}, wait=True)\\n make_query(cls.client, 'CREATE DATABASE IF NOT EXISTS %(db)s_other' % {'db': cls.db_name}, wait=True)\\n\\n if cls.load_data:\\n\\n data_file = cls.cluster.fs_prefix + u'/beeswax/sample_data_échantillon_%d.tsv'\\n\\n # Create a \\\"test_partitions\\\" table.\\n CREATE_PARTITIONED_TABLE = \\\"\\\"\\\"\\n CREATE TABLE `%(db)s`.`test_partitions` (foo INT, bar STRING)\\n PARTITIONED BY (baz STRING, boom INT)\\n ROW FORMAT DELIMITED\\n FIELDS TERMINATED BY '\\\\t'\\n LINES TERMINATED BY '\\\\n'\\n \\\"\\\"\\\" % {'db': cls.db_name}\\n make_query(cls.client, CREATE_PARTITIONED_TABLE, wait=True)\\n cls._make_data_file(data_file % 1)\\n\\n LOAD_DATA = \\\"\\\"\\\"\\n LOAD DATA INPATH '%(data_file)s'\\n OVERWRITE INTO TABLE `%(db)s`.`test_partitions`\\n PARTITION (baz='baz_one', boom=12345)\\n \\\"\\\"\\\" % {'db': cls.db_name, 'data_file': data_file % 1}\\n make_query(cls.client, LOAD_DATA, wait=True, local=False)\\n\\n # Insert additional partition data into \\\"test_partitions\\\" table\\n ADD_PARTITION = \\\"\\\"\\\"\\n ALTER TABLE `%(db)s`.`test_partitions` ADD PARTITION(baz='baz_foo', boom=67890) LOCATION '%(fs_prefix)s/baz_foo/boom_bar'\\n \\\"\\\"\\\" % {'db': cls.db_name, 'fs_prefix': cls.cluster.fs_prefix}\\n make_query(cls.client, ADD_PARTITION, wait=True, local=False)\\n\\n # Create a bunch of other tables\\n CREATE_TABLE = \\\"\\\"\\\"\\n CREATE TABLE `%(db)s`.`%(name)s` (foo INT, bar STRING)\\n COMMENT \\\"%(comment)s\\\"\\n ROW FORMAT DELIMITED\\n FIELDS TERMINATED BY '\\\\t'\\n LINES TERMINATED BY '\\\\n'\\n \\\"\\\"\\\"\\n\\n # Create a \\\"test\\\" table.\\n table_info = {'db': cls.db_name, 'name': 'test', 'comment': 'Test table'}\\n cls._make_data_file(data_file % 2)\\n cls._make_table(table_info['name'], CREATE_TABLE % table_info, data_file % 2)\\n\\n if is_live_cluster():\\n LOG.warning('HUE-2884: We cannot create Hive UTF8 tables when live cluster testing at the moment')\\n else:\\n # Create a \\\"test_utf8\\\" table.\\n table_info = {'db': cls.db_name, 'name': 'test_utf8', 'comment': cls.get_i18n_table_comment()}\\n cls._make_i18n_data_file(data_file % 3, 'utf-8')\\n cls._make_table(table_info['name'], CREATE_TABLE % table_info, data_file % 3)\\n\\n # Create a \\\"test_latin1\\\" table.\\n table_info = {'db': cls.db_name, 'name': 'test_latin1', 'comment': cls.get_i18n_table_comment()}\\n cls._make_i18n_data_file(data_file % 4, 'latin1')\\n cls._make_table(table_info['name'], CREATE_TABLE % table_info, data_file % 4)\\n\\n # Create a \\\"myview\\\" view.\\n make_query(cls.client, \\\"CREATE VIEW `%(db)s`.`myview` (foo, bar) as SELECT * FROM `%(db)s`.`test`\\\" % {'db': cls.db_name}, wait=True)\\n\\n _INITIALIZED = True\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\\n self.exchange_load_bar(self.exchange)\",\n \"def init(self):\\n self.db.connect()\\n try:\\n self.db.create_tables([JambiModel], safe=True)\\n JambiModel.create(ref='0')\\n self.logger.info('Database initialized')\\n except IntegrityError:\\n self.logger.info('Database was already initialized')\\n self.db.close()\",\n \"def _post_init(self):\\n pass\",\n \"def pre_route_table_create(self, resource_dict):\\n pass\",\n \"def initialize_policies(self, policy_collection, options):\",\n \"async def initialize(self, *, only_init_tables: bool=False):\\n self.pool = await aiomysql.create_pool(\\n host=self.host, user=self.user, password=self.passwd,\\n loop=self.loop)\\n db_exists = await self._check_db_exists()\\n if not db_exists:\\n await self._create_db()\\n db_initialized = False\\n else:\\n db_initialized = await self._check_db_initialized()\\n # We close the pool and create a new one because aiomysql doesn't\\n # provide an easy way to change the active database for an entire\\n # pool, just individual connections.\\n self.pool.terminate()\\n self.pool = await aiomysql.create_pool(\\n host=self.host, user=self.user, password=self.passwd,\\n db=self.dbname, loop=self.loop)\\n if not db_initialized:\\n await self._init_db(only_init_tables)\\n await self._upgrade_db()\\n log.msg('Database initialized')\",\n \"def __init__(self):\\n # create a connection through our super role via db.connect\\n try:\\n self.connection = db.connect(SUPER_ROLE, authcode=SUPER_AUTHCODE, host=HOST)\\n except db.OperationalError: # thrown if password or role don't match\\n print 'Caught an exception while trying to log in, maybe your account does not exist yet?'\\n exit()\\n \\n # get a DictCursor as our cursor (which returns queries as column-name dicts)\\n self.cursor = self.connection.cursor(DictCursor)\\n \\n self.setup_tables()\",\n \"def configure(self, config):\\n # create the follower table if it doesn't already exist\\n model.follower_table.create(checkfirst=True)\",\n \"def __init__(self):\\n\\n self.tableConnString = os.environ['ENTITYTABLE_CONNECTIONSTRING'];\\n self.__table = None\",\n \"def strict_startup(self):\\n self.load_up_initial_db(TIMESTAMP_PARSE_DICT)\\n self.clean()\\n self.add_numeric_cols()\",\n \"def prep(self):\\n sq1 = 'create table TCVR ( ID, T, C, V, R , primary key ( ID ) ) ;'\\n sq2 = 'create table IDX ( ID , A , primary key(A) ) ; '\\n self.sq.SQX(sq1)\\n self.sq.SQX(sq2)\\n sq3 = \\\"insert into IDX VALUES ( 1 , 'A' ) ; \\\"\\n self.sq.SQX(sq3)\",\n \"def startup(self):\\n self.load_up_initial_db(TIMESTAMP_PARSE_DICT)\\n self.add_numeric_cols()\",\n \"def initialize_db(self, table_name: str):\\n create_table_sql = f\\\"\\\"\\\"\\n create table if not exists {table_name} (\\n id integer primary key autoincrement not null,\\n sample_date text not null unique,\\n location text not null,\\n min_temp real not null,\\n max_temp real not null,\\n avg_temp real not null);\\n \\\"\\\"\\\"\\n with DBOperations(self.name) as dbcm:\\n dbcm.execute(create_table_sql)\",\n \"def setUp(self):\\n if os.getenv(\\\"HBNB_TYPE_STORAGE\\\") == 'db':\\n self.db = MySQLdb.connect(os.getenv(\\\"HBNB_MYSQL_HOST\\\"),\\n os.getenv(\\\"HBNB_MYSQL_USER\\\"),\\n os.getenv(\\\"HBNB_MYSQL_PWD\\\"),\\n os.getenv(\\\"HBNB_MYSQL_DB\\\"))\\n self.cursor = self.db.cursor()\",\n \"def _initialize(self):\\n query_table = self._cursor.execute(f\\\"\\\"\\\"\\n SELECT name\\n FROM sqlite_master\\n WHERE type='table' AND name='{self._table_name}';\\\"\\\"\\\")\\n\\n if not query_table.fetchone():\\n self._cursor.execute(f\\\"\\\"\\\"\\n CREATE TABLE {self._table_name} (\\n id char(36),\\n term TEXT,\\n timestamp BIGINT\\n );\\\"\\\"\\\")\\n\\n self._cursor.execute(f\\\"\\\"\\\"\\n CREATE INDEX index_timestamp\\n ON {self._table_name} (timestamp);\\\"\\\"\\\")\\n\\n self._conn.commit()\",\n \"def process_table_init(self):\\n logging.debug(\\\"Processing table initialization, %d entries\\\",\\n len(self.table_initialization))\\n\\n for init_entry in self.table_initialization:\\n for table_name, entry_desc in init_entry.items():\\n self.air_table[table_name].add_entry(\\n table_entry.description_to_entry(entry_desc))\",\n \"def db_initialise():\\n generate_migration_file()\\n if not MySQLScheme.fetch_one(IS_MIGRATION_TABLE,\\n **{\\\"args\\\": {'schema': SCHEMA}}):\\n with open(MIGRATION_FILE, 'r') as init_sql:\\n data = init_sql.read()\\n\\n if f\\\"CREATE TABLE IF NOT EXISTS {MIGRATION_TABLE}\\\" not in data:\\n when = str(int(time.time()))\\n sql_file = os.path.join(MIGRATION_FOLDER, f\\\"{when}.sql\\\")\\n\\n with open(sql_file, 'w') as save_sql:\\n up = MYSQL_MIGRATION_UP.format(f\\\"upgrade-{when}\\\", when,\\n MIGRATION_TABLE)\\n down = MYSQL_MIGRATION_DOWN.format(f\\\"downgrade-{when}\\\",\\n MIGRATION_TABLE)\\n\\n save_sql.write(\\\"\\\\n\\\\n\\\".join([up, down]))\\n LOGGER.info(f\\\"migration file: \\\"\\n f\\\"{os.path.join('migrations', sql_file)}\\\")\\n else:\\n when = re.findall('[0-9]+', data)[0]\\n\\n generate_migration_file()\\n dbi_query = anosql.from_path(MIGRATION_FILE, 'psycopg2')\\n MySQLScheme.commit(getattr(dbi_query, f\\\"upgrade_{when}\\\").sql)\\n LOGGER.info(f\\\"initial successful migration: {when}\\\")\",\n \"def create_table(self):\\n pass\",\n \"def init_db():\\n db.drop_all()\\n db.create_all()\\n\\n print(\\\"Initialized Connect 4 Database.\\\")\",\n \"def pre_track_containers_create_policy_stat(self, conn):\\n conn.executescript(\\\"\\\"\\\"\\n CREATE TABLE policy_stat (\\n storage_policy_index INTEGER PRIMARY KEY,\\n object_count INTEGER DEFAULT 0,\\n bytes_used INTEGER DEFAULT 0\\n );\\n INSERT OR IGNORE INTO policy_stat (\\n storage_policy_index, object_count, bytes_used\\n )\\n SELECT 0, object_count, bytes_used\\n FROM account_stat\\n WHERE container_count > 0;\\n \\\"\\\"\\\")\",\n \"def init_table_obj(self):\\n # Check the existence of original table\\n if not self.table_exists(self.table_name):\\n raise OSCError(\\n \\\"TABLE_NOT_EXIST\\\", {\\\"db\\\": self._current_db, \\\"table\\\": self.table_name}\\n )\\n self._old_table = self.fetch_table_schema(self.table_name)\\n self.partitions[self.table_name] = self.fetch_partitions(self.table_name)\\n # The table after swap will have the same partition layout as current\\n # table\\n self.partitions[self.renamed_table_name] = self.partitions[self.table_name]\\n # Preserve the auto_inc value from old table, so that we don't revert\\n # back to a smaller value after OSC\\n if self._old_table.auto_increment:\\n self._new_table.auto_increment = self._old_table.auto_increment\\n # We don't change the storage engine in OSC, so just use\\n # the fetched instance storage engine\\n self._new_table.engine = self._old_table.engine\\n # Populate both old and new tables with explicit charset/collate\\n self.populate_charset_collation(self._old_table)\\n self.populate_charset_collation(self._new_table)\",\n \"def setup_before_migration(self, apps):\",\n \"def _real_initialize(self):\\n pass\",\n \"def post_init(self):\\n\\t\\tpass\",\n \"def init():\\n print(\\\"Executing initialization\\\")\\n print(db.dsn)\\n cursor = yield momoko.Op(\\n db.execute,\\n \\\"\\\"\\\"\\n DROP SCHEMA public CASCADE;\\n CREATE SCHEMA public;\\n CREATE TABLE game\\n (\\n game_id text PRIMARY KEY,\\n players integer,\\n state bytea,\\n timestamp timestamp\\n );\\n CREATE UNIQUE INDEX ix_game_id\\n ON game\\n (game_id);\\n CREATE INDEX ix_timestamp\\n ON game\\n (timestamp);\\n \\\"\\\"\\\")\\n try:\\n print(cursor.fetchall())\\n except psycopg2.ProgrammingError:\\n pass\\n io = ioloop.IOLoop.instance()\\n io.stop()\",\n \"def _afterInit(self):\\n pass\",\n \"def _post_init(self) -> None:\\n return\",\n \"def init_db():\\n global app\\n Promotions.init_db(app)\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\",\n \"def initialise(self):\\r\\n return\",\n \"def initialise(self):\\r\\n return\",\n \"def __init__(self, database_config):\\n self.conn = self._get_database_connection(\\n database_config[\\\"type\\\"], database_config[\\\"connection_string\\\"]\\n )\\n self.cursor = self.conn.cursor()\\n self.db_type = database_config[\\\"type\\\"]\\n\\n # Try to check the current migration version\\n migration_level = 0\\n # noinspection PyBroadException\\n try:\\n self._execute(\\\"SELECT version FROM migration_version\\\")\\n row = self.cursor.fetchone()\\n migration_level = row[0]\\n except Exception:\\n self._initial_setup()\\n finally:\\n if migration_level < latest_migration_version:\\n self._run_migrations(migration_level)\\n\\n logger.info(f\\\"Database initialization of type '{self.db_type}' complete\\\")\",\n \"def __init__(self):\\n # Wipe the db\\n self.wipe_db()\\n\\n # Set some global things\\n try:\\n dashboard_configuration = DashboardConfiguration(type=\\\"default\\\")\\n dashboard_configuration.save()\\n except IntegrityError:\\n dashboard_configuration = DashboardConfiguration.objects.filter(type=\\\"default\\\").first()\\n\\n # Add all players from dataset\\n group = self.add_players(dashboard_configuration)\\n\\n # Add all games from the dataset\\n self.add_games()\\n\\n # Create the games played for this group\\n self.add_game_played(group)\",\n \"def initialize(self) -> None:\\n # First, establish a connection to the specified database\\n try:\\n self._connect_to_db()\\n except psycopg2.OperationalError: # specified database does not exist\\n with psycopg2.connect(database=DATABASE_ENV[\\\"POSTGRES_DB\\\"],\\n user=self.dbuser, password=self.dbpassword,\\n host=self.dbhost, port=str(self.dbport)) as con:\\n with con.cursor() as cur:\\n con.autocommit = True # cannot create db inside a transaction\\n cur.execute(f'CREATE DATABASE \\\"{self.dbname}\\\"')\\n con.autocommit = False\\n self._connect_to_db() # try again\\n\\n # Second, create the necessary database table, only if required\\n with self._connection.cursor() as cur:\\n cur.execute(f\\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS \\\"{self.MESSAGE_TABLE_NAME}\\\" (\\n id SERIAL PRIMARY KEY,\\n key CHAR(4) NOT NULL,\\n value REAL NOT NULL,\\n ts TIMESTAMP NOT NULL,\\n tz TEXT NOT NULL\\n );\\n \\\"\\\"\\\")\\n self._connection.commit()\",\n \"def setUp(self):\\n db.drop_all() # clean up the last tests\\n db.create_all() # make our sqlalchemy tables\\n self.app = app.test_client()\\n initialize_logging(logging.CRITICAL)\",\n \"def pre_service_appliance_set_create(self, resource_dict):\\n pass\",\n \"def init_database(self):\\n # init_database(self.engine)\",\n \"def create_all_tables(self):\\n pass\",\n \"def _manually_initialize(self) -> None:\\n # XXX: maybe refactor, this is actually part of the public interface\\n pass\",\n \"def __init__(self):\\n self.__engine = create_engine('mysql+mysqldb://{}:{}@{}/{}'.\\n format(getenv('HBNB_MYSQL_USER'),\\n getenv('HBNB_MYSQL_PWD'),\\n getenv('HBNB_MYSQL_HOST'),\\n getenv('HBNB_MYSQL_DB')),\\n pool_pre_ping=True)\\n\\n if getenv('HBNB_ENV') == 'test':\\n \\\"\\\"\\\" Drop all tables\\\"\\\"\\\"\\n Base.metadata.drop_all(self.__engine)\\n\\n Base.metadata.create_all(self.__engine)\\n Session = sessionmaker(self.__engine)\\n self.__session = Session()\",\n \"def startUp(self):\\n pass\",\n \"def test_init(self):\\n self.assertIsNotNone(DatabaseIntermediary(), self.ec.db)\",\n \"def _db_init_data_tables(self):\\n\\n #\\n # TESTTYPE table\\n #\\n return self._db_execute(\\n \\\"\\\"\\\"\\n create table TESTTYPE (\\n KEY text unique,\\n VALUE text\\n )\\n \\\"\\\"\\\"\\n )\",\n \"def test_init(self):\\n sample = PrepSample(self.sample_id, self.prep_template)\\n # Check that the internal id have been correctly set\\n self.assertEqual(sample._id, '1.SKB8.640193')\\n # Check that the internal template have been correctly set\\n self.assertEqual(sample._md_template, self.prep_template)\\n # Check that the internal dynamic table name have been correctly set\\n self.assertEqual(sample._dynamic_table, \\\"prep_1\\\")\",\n \"def django_db_setup(django_db_setup, django_db_blocker):\\n with django_db_blocker.unblock():\\n # todo Now remove the --noinput just to be sure that the test database's data will be deleted\\n management.call_command('flush', '--noinput')\\n zakanda.db.create_initial_data()\",\n \"async def _create_table(self, table: TableSchema) -> None:\\n try:\\n await self.conn.execute(get_create_table(table))\\n except PostgresError: # Only DB related exceptions\\n print(f\\\"Failed to execute CREATE TABLE for {table['name']}\\\")\\n raise\\n # Initialize migration level (so that it can be altered in future)\\n await self.conn.execute('INSERT INTO tinymud_migrations (table_name, level) VALUES ($1, $2)', table['name'], 0)\",\n \"def __init__(self):\\n self.__engine = create_engine('mysql+mysqldb://{}:{}@{}/{}'\\n .format(os.environ['HBNB_MYSQL_USER'],\\n os.environ['HBNB_MYSQL_PWD'],\\n os.environ['HBNB_MYSQL_HOST'],\\n os.environ['HBNB_MYSQL_DB']),\\n pool_pre_ping=True)\\n try:\\n if os.environ['HBNB_ENV'] == 'test':\\n Base.metadata.drop_all(self.__engine)\\n except KeyError:\\n pass\",\n \"def pre_init_hook(cr):\\n try:\\n cr.execute(\\n \\\"\\\"\\\"\\n ALTER TABLE product_product\\n ADD pricelist_id INTEGER REFERENCES product_pricelist(id),\\n ADD currency_id INTEGER REFERENCES res_currency(id);\\n ALTER TABLE product_template\\n ADD currency_id INTEGER REFERENCES res_currency(id);\\n \\\"\\\"\\\"\\n )\\n except psycopg2.ProgrammingError:\\n cr.rollback()\\n\\n try:\\n cr.execute(\\n \\\"\\\"\\\"\\n UPDATE product_product\\n SET pricelist_id = 1,\\n currency_id = 20\\n \\\"\\\"\\\"\\n )\\n except psycopg2.ProgrammingError:\\n cr.rollback()\\n\\n return True\",\n \"def setUpClass(cls):\\n if AppTestCase.run_once:\\n return # Only create tables once per test suite run\\n AppTestCase.run_once = True\\n cls.create_test_database()\",\n \"async def prepare_databases(self):\",\n \"def setUp(self):\\r\\n self.app = create_app(config_name=\\\"testing\\\")\\r\\n self.client = self.app.test_client\\r\\n self.candidate = {\\\"name\\\":\\\"Aslam\\\", \\\"degree_name\\\":\\\"BSCS\\\", \\\"address\\\":\\\"lahore\\\"}\\r\\n\\r\\n # binds the app to the current context\\r\\n with self.app.app_context():\\r\\n # create all tables\\r\\n db.session.close()\\r\\n db.drop_all()\\r\\n db.create_all()\",\n \"def init_db():\\n\\tdb.drop_all()\\n\\tdb.create_all()\\n\\n\\tprint(\\\"Initialized Database.\\\")\\n\\treturn\",\n \"def _initialize(self):\\n self.send_init_command()\",\n \"def do_init(self):\\n\\n pass\",\n \"def __init__(self):\\n self.__db = sqlite3.connect(DB_PATH)\\n self.__cur = self.__db.cursor()\\n self.__create_tables()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66067785","0.6455682","0.6373156","0.63563114","0.63563114","0.62698793","0.6163393","0.6154188","0.60957396","0.60849506","0.60809666","0.5964424","0.5955808","0.5944223","0.5935643","0.5916183","0.591556","0.5893408","0.58916914","0.5885537","0.58717024","0.58418834","0.58233","0.58160424","0.5815057","0.5799095","0.57769054","0.5734957","0.5724158","0.5717349","0.5713739","0.5709721","0.5704054","0.57018375","0.56926066","0.5684585","0.56744415","0.5655622","0.5654633","0.5649244","0.5640207","0.5633132","0.5632341","0.5626851","0.5625027","0.5619768","0.56144357","0.56044084","0.56033564","0.5599736","0.5598124","0.55846125","0.5578301","0.55729073","0.55728716","0.55514437","0.5540544","0.55300725","0.55291253","0.55289686","0.5518183","0.55102086","0.55087006","0.5505862","0.5501549","0.5498526","0.5493618","0.54909307","0.5490669","0.54852664","0.54846567","0.5482914","0.54828626","0.54828626","0.54759794","0.54759794","0.54691267","0.54667085","0.5462546","0.5448306","0.54476976","0.5445401","0.5444712","0.54406863","0.5434655","0.5429676","0.54270774","0.54208565","0.54185194","0.54164934","0.54077035","0.5407264","0.53993124","0.53968734","0.53944916","0.5389854","0.53833354","0.53824025","0.5380373","0.5377358"],"string":"[\n \"0.66067785\",\n \"0.6455682\",\n \"0.6373156\",\n \"0.63563114\",\n \"0.63563114\",\n \"0.62698793\",\n \"0.6163393\",\n \"0.6154188\",\n \"0.60957396\",\n \"0.60849506\",\n \"0.60809666\",\n \"0.5964424\",\n \"0.5955808\",\n \"0.5944223\",\n \"0.5935643\",\n \"0.5916183\",\n \"0.591556\",\n \"0.5893408\",\n \"0.58916914\",\n \"0.5885537\",\n \"0.58717024\",\n \"0.58418834\",\n \"0.58233\",\n \"0.58160424\",\n \"0.5815057\",\n \"0.5799095\",\n \"0.57769054\",\n \"0.5734957\",\n \"0.5724158\",\n \"0.5717349\",\n \"0.5713739\",\n \"0.5709721\",\n \"0.5704054\",\n \"0.57018375\",\n \"0.56926066\",\n \"0.5684585\",\n \"0.56744415\",\n \"0.5655622\",\n \"0.5654633\",\n \"0.5649244\",\n \"0.5640207\",\n \"0.5633132\",\n \"0.5632341\",\n \"0.5626851\",\n \"0.5625027\",\n \"0.5619768\",\n \"0.56144357\",\n \"0.56044084\",\n \"0.56033564\",\n \"0.5599736\",\n \"0.5598124\",\n \"0.55846125\",\n \"0.5578301\",\n \"0.55729073\",\n \"0.55728716\",\n \"0.55514437\",\n \"0.5540544\",\n \"0.55300725\",\n \"0.55291253\",\n \"0.55289686\",\n \"0.5518183\",\n \"0.55102086\",\n \"0.55087006\",\n \"0.5505862\",\n \"0.5501549\",\n \"0.5498526\",\n \"0.5493618\",\n \"0.54909307\",\n \"0.5490669\",\n \"0.54852664\",\n \"0.54846567\",\n \"0.5482914\",\n \"0.54828626\",\n \"0.54828626\",\n \"0.54759794\",\n \"0.54759794\",\n \"0.54691267\",\n \"0.54667085\",\n \"0.5462546\",\n \"0.5448306\",\n \"0.54476976\",\n \"0.5445401\",\n \"0.5444712\",\n \"0.54406863\",\n \"0.5434655\",\n \"0.5429676\",\n \"0.54270774\",\n \"0.54208565\",\n \"0.54185194\",\n \"0.54164934\",\n \"0.54077035\",\n \"0.5407264\",\n \"0.53993124\",\n \"0.53968734\",\n \"0.53944916\",\n \"0.5389854\",\n \"0.53833354\",\n \"0.53824025\",\n \"0.5380373\",\n \"0.5377358\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73197085"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6398,"cells":{"query":{"kind":"string","value":"Copied from AccountBroker before the metadata column was added; used for testing with TestAccountBrokerBeforeMetadata. Create account_stat table which is specific to the account DB."},"document":{"kind":"string","value":"def premetadata_create_account_stat_table(self, conn, put_timestamp):\n conn.executescript('''\n CREATE TABLE account_stat (\n account TEXT,\n created_at TEXT,\n put_timestamp TEXT DEFAULT '0',\n delete_timestamp TEXT DEFAULT '0',\n container_count INTEGER,\n object_count INTEGER DEFAULT 0,\n bytes_used INTEGER DEFAULT 0,\n hash TEXT default '00000000000000000000000000000000',\n id TEXT,\n status TEXT DEFAULT '',\n status_changed_at TEXT DEFAULT '0'\n );\n\n INSERT INTO account_stat (container_count) VALUES (0);\n ''')\n\n conn.execute('''\n UPDATE account_stat SET account = ?, created_at = ?, id = ?,\n put_timestamp = ?\n ''', (self.account, Timestamp.now().internal, str(uuid4()),\n put_timestamp))"},"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 pre_track_containers_create_policy_stat(self, conn):\n conn.executescript(\"\"\"\n CREATE TABLE policy_stat (\n storage_policy_index INTEGER PRIMARY KEY,\n object_count INTEGER DEFAULT 0,\n bytes_used INTEGER DEFAULT 0\n );\n INSERT OR IGNORE INTO policy_stat (\n storage_policy_index, object_count, bytes_used\n )\n SELECT 0, object_count, bytes_used\n FROM account_stat\n WHERE container_count > 0;\n \"\"\")","def _create_schema(self): \n q = (\"CREATE TABLE IF NOT EXISTS \" + \\\n \"profiles (username text, body text, epoch numeric)\",)\n for x in q: self.cursor.execute(x)\n self.conn.commit()","def prespi_AccountBroker_initialize(self, conn, put_timestamp, **kwargs):\n if not self.account:\n raise ValueError(\n 'Attempting to create a new database with no account set')\n self.create_container_table(conn)\n self.create_account_stat_table(conn, put_timestamp)","def setup_table(self):\n self.interface.start_transaction()\n self.interface.drop_table(_history_table)\n self.interface.drop_table(_history_stats_table)\n self.interface.create_table(_history_table)\n self.interface.create_index('index1', _history_table, [_history_table['timestamp']])\n self.interface.create_table(_history_stats_table)\n self.interface.create_index('index2', _history_stats_table, [_history_stats_table['benchmark']])\n self.interface.commit_transaction()","async def statinit(client):\n conn = client.bot.dbs[client.server_tag]\n print(('Initializing stat columns in \\'users\\''\n f' in /persist/db/{client.server_tag}.db...'))\n for attr in usr_attributes:\n db.add_column(conn, 'users', attr)\n db.ccache()\n print('User stat initialization complete.')","def load_status_table():","def _populate_table_status():\n [db_insert_or_get(Status, name=name) for name in app.config['STATUS_DICT'][1:]]\n db.session.commit()","def create_table(self):\n pass","def build_metadata():\n metadata = sa.MetaData()\n\n sa.Table(\n 'hive_blocks', metadata,\n sa.Column('num', sa.Integer, primary_key=True, autoincrement=False),\n sa.Column('hash', CHAR(40), nullable=False),\n sa.Column('prev', CHAR(40)),\n sa.Column('txs', SMALLINT, server_default='0', nullable=False),\n sa.Column('ops', SMALLINT, server_default='0', nullable=False),\n sa.Column('created_at', sa.DateTime, nullable=False),\n\n sa.UniqueConstraint('hash', name='hive_blocks_ux1'),\n sa.ForeignKeyConstraint(['prev'], ['hive_blocks.hash'], name='hive_blocks_fk1'),\n )\n\n sa.Table(\n 'hive_accounts', metadata,\n sa.Column('id', sa.Integer, primary_key=True),\n sa.Column('name', VARCHAR(16), nullable=False),\n sa.Column('created_at', sa.DateTime, nullable=False),\n #sa.Column('block_num', sa.Integer, nullable=False),\n sa.Column('reputation', sa.Float(precision=6), nullable=False, server_default='25'),\n\n sa.Column('display_name', sa.String(20)),\n sa.Column('about', sa.String(160)),\n sa.Column('location', sa.String(30)),\n sa.Column('website', sa.String(100)),\n sa.Column('profile_image', sa.String(1024), nullable=False, server_default=''),\n sa.Column('cover_image', sa.String(1024), nullable=False, server_default=''),\n\n sa.Column('followers', sa.Integer, nullable=False, server_default='0'),\n sa.Column('following', sa.Integer, nullable=False, server_default='0'),\n\n sa.Column('proxy', VARCHAR(16), nullable=False, server_default=''),\n sa.Column('post_count', sa.Integer, nullable=False, server_default='0'),\n sa.Column('proxy_weight', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('vote_weight', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('kb_used', sa.Integer, nullable=False, server_default='0'), # deprecated\n sa.Column('rank', sa.Integer, nullable=False, server_default='0'),\n\n sa.Column('lastread_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\n sa.Column('active_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\n sa.Column('cached_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\n sa.Column('raw_json', sa.Text),\n\n\n sa.UniqueConstraint('name', name='hive_accounts_ux1'),\n sa.Index('hive_accounts_ix1', 'vote_weight', 'id'), # core: quick ranks\n sa.Index('hive_accounts_ix2', 'name', 'id'), # core: quick id map\n sa.Index('hive_accounts_ix3', 'vote_weight', 'name', postgresql_ops=dict(name='varchar_pattern_ops')), # API: lookup\n sa.Index('hive_accounts_ix4', 'id', 'name'), # API: quick filter/sort\n sa.Index('hive_accounts_ix5', 'cached_at', 'name'), # core/listen sweep\n )\n\n sa.Table(\n 'hive_posts', metadata,\n sa.Column('id', sa.Integer, primary_key=True),\n sa.Column('parent_id', sa.Integer),\n sa.Column('author', VARCHAR(16), nullable=False),\n sa.Column('permlink', VARCHAR(255), nullable=False),\n sa.Column('category', VARCHAR(255), nullable=False, server_default=''),\n sa.Column('community_id', sa.Integer, nullable=True),\n sa.Column('created_at', sa.DateTime, nullable=False),\n sa.Column('depth', SMALLINT, nullable=False),\n sa.Column('is_deleted', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_pinned', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_muted', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_valid', BOOLEAN, nullable=False, server_default='1'),\n sa.Column('promoted', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\n\n sa.ForeignKeyConstraint(['author'], ['hive_accounts.name'], name='hive_posts_fk1'),\n sa.ForeignKeyConstraint(['parent_id'], ['hive_posts.id'], name='hive_posts_fk3'),\n sa.UniqueConstraint('author', 'permlink', name='hive_posts_ux1'),\n sa.Index('hive_posts_ix3', 'author', 'depth', 'id', postgresql_where=sql_text(\"is_deleted = '0'\")), # API: author blog/comments\n sa.Index('hive_posts_ix4', 'parent_id', 'id', postgresql_where=sql_text(\"is_deleted = '0'\")), # API: fetching children\n sa.Index('hive_posts_ix5', 'id', postgresql_where=sql_text(\"is_pinned = '1' AND is_deleted = '0'\")), # API: pinned post status\n sa.Index('hive_posts_ix6', 'community_id', 'id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_pinned = '1' AND is_deleted = '0'\")), # API: community pinned\n )\n\n sa.Table(\n 'hive_post_tags', metadata,\n sa.Column('post_id', sa.Integer, nullable=False),\n sa.Column('tag', sa.String(32), nullable=False),\n sa.UniqueConstraint('tag', 'post_id', name='hive_post_tags_ux1'), # core\n sa.Index('hive_post_tags_ix1', 'post_id'), # core\n )\n\n sa.Table(\n 'hive_follows', metadata,\n sa.Column('follower', sa.Integer, nullable=False),\n sa.Column('following', sa.Integer, nullable=False),\n sa.Column('state', SMALLINT, nullable=False, server_default='1'),\n sa.Column('created_at', sa.DateTime, nullable=False),\n\n sa.UniqueConstraint('following', 'follower', name='hive_follows_ux3'), # core\n sa.Index('hive_follows_ix5a', 'following', 'state', 'created_at', 'follower'),\n sa.Index('hive_follows_ix5b', 'follower', 'state', 'created_at', 'following'),\n )\n\n sa.Table(\n 'hive_reblogs', metadata,\n sa.Column('account', VARCHAR(16), nullable=False),\n sa.Column('post_id', sa.Integer, nullable=False),\n sa.Column('created_at', sa.DateTime, nullable=False),\n\n sa.ForeignKeyConstraint(['account'], ['hive_accounts.name'], name='hive_reblogs_fk1'),\n sa.ForeignKeyConstraint(['post_id'], ['hive_posts.id'], name='hive_reblogs_fk2'),\n sa.UniqueConstraint('account', 'post_id', name='hive_reblogs_ux1'), # core\n sa.Index('hive_reblogs_ix1', 'post_id', 'account', 'created_at'), # API -- not yet used\n )\n\n sa.Table(\n 'hive_payments', metadata,\n sa.Column('id', sa.Integer, primary_key=True),\n sa.Column('block_num', sa.Integer, nullable=False),\n sa.Column('tx_idx', SMALLINT, nullable=False),\n sa.Column('post_id', sa.Integer, nullable=False),\n sa.Column('from_account', sa.Integer, nullable=False),\n sa.Column('to_account', sa.Integer, nullable=False),\n sa.Column('amount', sa.types.DECIMAL(10, 3), nullable=False),\n sa.Column('token', VARCHAR(5), nullable=False),\n\n sa.ForeignKeyConstraint(['from_account'], ['hive_accounts.id'], name='hive_payments_fk1'),\n sa.ForeignKeyConstraint(['to_account'], ['hive_accounts.id'], name='hive_payments_fk2'),\n sa.ForeignKeyConstraint(['post_id'], ['hive_posts.id'], name='hive_payments_fk3'),\n )\n\n sa.Table(\n 'hive_feed_cache', metadata,\n sa.Column('post_id', sa.Integer, nullable=False),\n sa.Column('account_id', sa.Integer, nullable=False),\n sa.Column('created_at', sa.DateTime, nullable=False),\n sa.UniqueConstraint('post_id', 'account_id', name='hive_feed_cache_ux1'), # core\n sa.Index('hive_feed_cache_ix1', 'account_id', 'post_id', 'created_at'), # API (and rebuild?)\n )\n\n sa.Table(\n 'hive_posts_cache', metadata,\n sa.Column('post_id', sa.Integer, primary_key=True, autoincrement=False),\n sa.Column('author', VARCHAR(16), nullable=False),\n sa.Column('permlink', VARCHAR(255), nullable=False),\n sa.Column('category', VARCHAR(255), nullable=False, server_default=''),\n\n # important/index\n sa.Column('community_id', sa.Integer, nullable=True),\n sa.Column('depth', SMALLINT, nullable=False, server_default='0'),\n sa.Column('children', SMALLINT, nullable=False, server_default='0'),\n\n # basic/extended-stats\n sa.Column('author_rep', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('flag_weight', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('total_votes', sa.Integer, nullable=False, server_default='0'),\n sa.Column('up_votes', sa.Integer, nullable=False, server_default='0'),\n\n # basic ui fields\n sa.Column('title', sa.String(255), nullable=False, server_default=''),\n sa.Column('preview', sa.String(1024), nullable=False, server_default=''),\n sa.Column('img_url', sa.String(1024), nullable=False, server_default=''),\n\n # core stats/indexes\n sa.Column('payout', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\n sa.Column('promoted', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\n sa.Column('created_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\n sa.Column('payout_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\n sa.Column('updated_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\n sa.Column('is_paidout', BOOLEAN, nullable=False, server_default='0'),\n\n # ui flags/filters\n sa.Column('is_nsfw', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_declined', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_full_power', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_hidden', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_grayed', BOOLEAN, nullable=False, server_default='0'),\n\n # important indexes\n sa.Column('rshares', sa.BigInteger, nullable=False, server_default='0'),\n sa.Column('sc_trend', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('sc_hot', sa.Float(precision=6), nullable=False, server_default='0'),\n\n # bulk data\n sa.Column('body', TEXT),\n sa.Column('votes', TEXT),\n sa.Column('json', sa.Text),\n sa.Column('raw_json', sa.Text),\n\n # index: misc\n sa.Index('hive_posts_cache_ix3', 'payout_at', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # core: payout sweep\n sa.Index('hive_posts_cache_ix8', 'category', 'payout', 'depth', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: tag stats\n\n # index: ranked posts\n sa.Index('hive_posts_cache_ix2', 'promoted', postgresql_where=sql_text(\"is_paidout = '0' AND promoted > 0\")), # API: promoted\n\n sa.Index('hive_posts_cache_ix6a', 'sc_trend', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: trending todo: depth=0\n sa.Index('hive_posts_cache_ix7a', 'sc_hot', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: hot todo: depth=0\n sa.Index('hive_posts_cache_ix6b', 'post_id', 'sc_trend', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: trending, filtered todo: depth=0\n sa.Index('hive_posts_cache_ix7b', 'post_id', 'sc_hot', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: hot, filtered todo: depth=0\n\n sa.Index('hive_posts_cache_ix9a', 'depth', 'payout', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: payout todo: rem depth\n sa.Index('hive_posts_cache_ix9b', 'category', 'depth', 'payout', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: payout, filtered todo: rem depth\n\n sa.Index('hive_posts_cache_ix10', 'post_id', 'payout', postgresql_where=sql_text(\"is_grayed = '1' AND payout > 0\")), # API: muted, by filter/date/payout\n\n # index: stats\n sa.Index('hive_posts_cache_ix20', 'community_id', 'author', 'payout', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: pending distribution; author payout\n\n # index: community ranked posts\n sa.Index('hive_posts_cache_ix30', 'community_id', 'sc_trend', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\")), # API: community trend\n sa.Index('hive_posts_cache_ix31', 'community_id', 'sc_hot', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\")), # API: community hot\n sa.Index('hive_posts_cache_ix32', 'community_id', 'created_at', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\")), # API: community created\n sa.Index('hive_posts_cache_ix33', 'community_id', 'payout', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '0' AND is_paidout = '0'\")), # API: community payout\n sa.Index('hive_posts_cache_ix34', 'community_id', 'payout', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '1' AND is_paidout = '0'\")), # API: community muted\n )\n\n sa.Table(\n 'hive_state', metadata,\n sa.Column('block_num', sa.Integer, primary_key=True, autoincrement=False),\n sa.Column('db_version', sa.Integer, nullable=False),\n sa.Column('steem_per_mvest', sa.types.DECIMAL(8, 3), nullable=False),\n sa.Column('usd_per_steem', sa.types.DECIMAL(8, 3), nullable=False),\n sa.Column('sbd_per_steem', sa.types.DECIMAL(8, 3), nullable=False),\n sa.Column('dgpo', sa.Text, nullable=False),\n )\n\n metadata = build_metadata_community(metadata)\n\n metadata = build_metadata_blacklist(metadata)\n\n metadata = build_trxid_block_num(metadata)\n\n return metadata","def create_table(self):\n from deployflag.models.metadata import (\n GridSearchParameter,\n ModelFramework,\n ModelPerformanceMetadata,\n )\n\n with self.connection:\n self.connection.create_tables(\n [ModelPerformanceMetadata, GridSearchParameter, ModelFramework],\n safe=True,\n )","def __create_wallets_table(self):\n cmd = \"\"\" CREATE TABLE IF NOT EXISTS %s (\n %s text PRIMARY KEY,\n %s blob,\n %s blob);\"\"\" %(TABLE_WALLETS,\n COL_WALLETS_NAME,\n COL_WALLETS_PUB_KEY,\n COL_WALLETS_PVT_KEY)\n self.__dbcursor.execute(cmd)","def create_statistics(self):\n now = datetime.now()\n min_timestamp = Statistic.objects.all().aggregate(Max('timestamp_end'))[\"timestamp_end__max\"]\n max_timestamp = (now + ((datetime.min - now) % timedelta(minutes=60)) - timedelta(minutes=60)).replace(tzinfo=pytz.UTC)\n\n if min_timestamp is None:\n min_timestamp = datetime(2000, 1, 1, tzinfo=timezone('UTC'))\n\n aggregated_measurements = MeasurementService.get_aggregate_measurements(min_timestamp,max_timestamp)\n StatisticService.create_statistics(aggregated_measurements)","def _setup_user_bookmark_count(self):\r\n test_date_1 = datetime(2013, 11, 25)\r\n stat1 = factory.make_user_bookmark_count(username=u'admin',\r\n data=20,\r\n tstamp=test_date_1)\r\n test_date_2 = datetime(2013, 11, 15)\r\n stat2 = factory.make_user_bookmark_count(username=u'admin',\r\n data=30,\r\n tstamp=test_date_2)\r\n test_date_3 = datetime(2013, 12, 28)\r\n stat3 = factory.make_user_bookmark_count(username=u'admin',\r\n data=15,\r\n tstamp=test_date_3)\r\n transaction.commit()\r\n return [stat1, stat2, stat3]","def generate_cap_table(logger: Logger,\n dbsession: Session,\n token_address: str,\n order_by: str,\n order_direction: str,\n identity_provider: IdentityProvider,\n include_empty: bool,\n TokenScanStatus: type,\n TokenHolderAccount: type,\n no_name=\"<Unknown>\") -> CapTableInfo:\n\n status = dbsession.query(TokenScanStatus).filter_by(address=token_address).one_or_none() # type: TokenScanStatus\n if not status or status.end_block is None:\n raise NeedsTokenScan(\n \"No token {} balances available in the local database. Please run tokfetch token-scan first.\".format(\n token_address))\n\n q = status.get_accounts(include_empty)\n\n results = []\n total_balance = Decimal(0)\n last_token_transfer_at = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)\n for holder in q:\n\n id_check = identity_provider.get_identity(holder.address)\n if id_check:\n name = id_check.name\n else:\n name = no_name\n\n decimal_balance = holder.get_decimal_balance()\n\n entry = CapTableEntry(name, holder.address, decimal_balance, holder.last_block_updated_at)\n\n if entry.updated_at > last_token_transfer_at:\n last_token_transfer_at = entry.updated_at\n results.append(entry)\n\n if decimal_balance > 0: # Ignore cases where we cannot detect mint transaction\n total_balance += decimal_balance\n\n sort_entries(results, order_by, order_direction)\n\n # Retrofit decimal balances after we know the total sum\n if total_balance > 0:\n for r in results:\n r.percent = r.balance / total_balance\n\n info = CapTableInfo(status, last_token_transfer_at, total_balance, results)\n\n return info","async def _create_tables_declarative(self, base, engine):\n if hasattr(base, 'metadata'):\n base.metadata.create_all(bind=engine, checkfirst=True)\n return","def _create_table(self):\n query = f\"\"\"CREATE TABLE IF NOT EXISTS {TABLE}(\n member_Id INT,\n memberName VARCHAR(50),\n amount INT,\n date datetime NOT NULL,\n time datetime NOT NULL,\n status VARCHAR(20) NOT NULL DEFAULT 'Completed'\n );\"\"\"\n\n self.cursor.execute(query)\n self.conn.commit()","def describe_account_attributes():\n pass","def create_meta_loan_table(self):\n table_exists = self.check_if_table_exists(\"meta_loan_tables\")\n\n if not table_exists:\n self.read_sql_from_file('create_meta_loan_tables.sql')\n return","def add_statistics(self, stat_col):\n self.module.add_statistics(stat_col)","def create_table(response_json):\n account_table = PrettyTable()\n account_table.field_names = ([\"Account ID\", \"Account Name\"])\n for account in response_json['result']['accounts']:\n account_id = account['accountID']\n account_name = account['username']\n account_table.add_row([account_id, account_name])\n return account_table","def init():\n database.create_tables([Tracker])\n database.commit()","def create_marker_table(self):\n if self.marker_table is None:\n self.marker_table = luigi.configuration.get_config().get('sqlalchemy', 'marker-table', 'table_updates')\n\n engine = self.engine\n\n with engine.begin() as con:\n metadata = sqlalchemy.MetaData()\n if not con.dialect.has_table(con, self.marker_table):\n self.marker_table_bound = sqlalchemy.Table(\n self.marker_table, metadata,\n sqlalchemy.Column(\"ParquetSource\", sqlalchemy.String(128), primary_key=True),\n sqlalchemy.Column(\"TargetTable\", sqlalchemy.String(128)),\n sqlalchemy.Column(\"Environment\", sqlalchemy.String(128)),\n sqlalchemy.Column(\"BackupDate\", sqlalchemy.DateTime),\n sqlalchemy.Column(\"InsertedDate\", sqlalchemy.DateTime, default=datetime.now()))\n metadata.create_all(engine)\n else:\n metadata.reflect(only=[self.marker_table], bind=engine)\n self.marker_table_bound = metadata.tables[self.marker_table]","def __init__(self, config_path: str = \"config.yml\", config_dict: dict = None,\n create_all: bool = True):\n\n # Prepare user_details configured in config.yml for user_details table creation\n self.config = Config(config_path, config_dict)\n user_details_list = []\n if \"twitter_user_details\" in self.config.config:\n for detail, sqldatatype in self.config.config[\"twitter_user_details\"].items():\n if sqldatatype is not None:\n user_details_list.append(detail + \" \" + sqldatatype)\n else:\n print(\"\"\"Key \"twitter_user_details\" could not be found in config.yml. Will not create\n a user_details table.\"\"\")\n\n # Table creation for SQLITE database type.\n # Note and TODO: the collector does not support sqlite (yet)\n if self.config.dbtype.lower() == \"sqlite\":\n try:\n self.engine = lite.connect(self.config.dbname + \".db\")\n print(\"Connected to \" + self.config.dbname + \"!\")\n except Error as e:\n raise e\n if create_all:\n try:\n create_friends_table_sql = \"\"\"CREATE TABLE IF NOT EXISTS friends (\n source BIGINT NOT NULL,\n target BIGINT NOT NULL,\n burned TINYINT NOT NULL,\n timestamp DATETIME DEFAULT CURRENT_TIMESTAMP\n );\"\"\"\n create_friends_index_sql_1 = \"CREATE INDEX iFSource ON friends(source);\"\n create_friends_index_sql_2 = \"CREATE INDEX iFTimestamp ON friends(timestamp);\"\n create_results_table_sql = \"\"\"CREATE TABLE IF NOT EXISTS result (\n source BIGINT NOT NULL,\n target BIGINT NOT NULL,\n timestamp DATETIME DEFAULT CURRENT_TIMESTAMP\n );\"\"\"\n create_results_index_sql_1 = \"CREATE INDEX iRSource ON result(source);\"\n create_results_index_sql_2 = \"CREATE INDEX iRTimestamp ON result(timestamp);\"\n c = self.engine.cursor()\n c.execute(create_friends_table_sql)\n c.execute(create_friends_index_sql_1)\n c.execute(create_friends_index_sql_2)\n c.execute(create_results_table_sql)\n c.execute(create_results_index_sql_1)\n c.execute(create_results_index_sql_2)\n if user_details_list != []:\n create_user_details_sql = \"\"\"\n CREATE TABLE IF NOT EXISTS user_details\n (\"\"\" + \", \".join(user_details_list) + \"\"\",\n timestamp DATETIME DEFAULT CURRENT_TIMESTAMP);\"\"\"\n create_ud_index = \"CREATE INDEX iUTimestamp ON user_details(timestamp)\"\n c.execute(create_user_details_sql)\n c.execute(create_ud_index)\n else:\n # TODO: Make this a minimal user_details table?\n print(\"\"\"No user_details configured in config.yml. Will not create a\n user_details table.\"\"\")\n except Error as e:\n print(e)\n\n # Table creation for mysql database type\n elif self.config.dbtype.lower() == \"mysql\":\n try:\n self.engine = create_engine(\n f'mysql+pymysql://{self.config.dbuser}:'\n f'{self.config.dbpwd}@{self.config.dbhost}/{self.config.dbname}'\n )\n print('Connected to database \"' + self.config.dbname + '\" via mySQL!')\n except OperationalError as e:\n raise e\n if create_all:\n try:\n create_friends_table_sql = \"\"\"CREATE TABLE IF NOT EXISTS friends (\n source BIGINT NOT NULL,\n target BIGINT NOT NULL,\n burned TINYINT NOT NULL,\n timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n ON UPDATE CURRENT_TIMESTAMP,\n UNIQUE INDEX fedge (source, target),\n INDEX(timestamp)\n );\"\"\"\n create_results_table_sql = \"\"\"CREATE TABLE IF NOT EXISTS result (\n source BIGINT NOT NULL,\n target BIGINT NOT NULL,\n timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n UNIQUE INDEX redge (source, target),\n INDEX(timestamp)\n );\"\"\"\n self.engine.execute(create_friends_table_sql)\n self.engine.execute(create_results_table_sql)\n if user_details_list != []:\n create_user_details_sql = \"\"\"\n CREATE TABLE IF NOT EXISTS user_details\n (\"\"\" + \", \".join(user_details_list) + \"\"\", timestamp TIMESTAMP\n DEFAULT CURRENT_TIMESTAMP,\n INDEX(timestamp));\"\"\"\n self.engine.execute(create_user_details_sql)\n else:\n print(\"\"\"No user_details configured in config.yml. Will not create a\n user_details table.\"\"\")\n except OperationalError as e:\n raise e","def _populate_new_notifications_imei_table(self, conn):\n with CodeProfiler() as cp:\n tblname = self._notifications_imei_new_tblname\n num_records = self._populate_new_blacklist_or_notifications_imei_table(conn, tblname, is_blacklist=False)\n\n return num_records, cp.duration","def createTable(self):\n results = self.db.table_create(self.entity).run(self.r)\n time.sleep(5)\n return results","def get_table(base, engine):\n class w1_temp_table(base):\n __tablename__ = 'w1_temp'\n __table_args__ = {\"useexisting\": True}\n\n id = sa.Column(sa.types.Integer, primary_key=True)\n logger_id = sa.Column(sa.types.Integer)\n value = sa.Column(sa.types.String)\n datetime = sa.Column(sa.types.DateTime)\n return w1_temp_table","def populate_stat(self, table):\n myrow = table.row\n # HDF5 doesn't handle unicode strings, so we need to convert to \n # *byte* strings, which we can put in the HDF5 file \n addy = numpy.zeros(len(self.address), \n dtype=(numpy.str, glob.nchar_address))\n for i in range(len(addy)):\n addy[i] = (self.address[i]).encode('utf8')\n\n myrow[\"address\"] = addy\n myrow[\"bike_stands\"] = self.bike_stands\n myrow[\"number\"] = self.number\n myrow[\"position\"] = self.position\n myrow.append()\n table.flush()","def accounts():","def __create(self):\n cursor = self.conn.cursor()\n sql = 'CREATE TABLE IF NOT EXISTS speedlogs ' + \\\n '(id INTEGER primary key, measure_dt TIMESTAMP, ping REAL, download REAL, upload REAL)'\n cursor.execute(sql)\n self.conn.commit()","async def create_sys_tables(self) -> None:\n await self.conn.execute(\"\"\"CREATE TABLE IF NOT EXISTS tinymud_migrations (\n table_name TEXT,\n level INTEGER\n )\"\"\")","def account_summary(self):\n pass","def baseline_statistics(self, **_):\n raise NotImplementedError(\"{} doesn't support statistics.\".format(__class__.__name__))","def _create_intermediate_new_tables_structure(self, conn):\n table_names = []\n with conn.cursor() as cursor, CodeProfiler() as cp:\n tblname = self._blacklist_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n is_valid BOOLEAN,\n imei_norm_with_check_digit TEXT\n ) PARTITION BY RANGE (virt_imei_shard)\n \"\"\").format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._notifications_lists_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n operator_id TEXT NOT NULL,\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n msisdn TEXT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n is_valid BOOLEAN,\n amnesty_granted BOOLEAN,\n imei_norm_with_check_digit TEXT\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._notifications_lists_new_part_tblname,\n is_unlogged=True)\n\n tblname = self._exceptions_lists_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n operator_id TEXT NOT NULL,\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n is_valid BOOLEAN,\n imei_norm_with_check_digit TEXT,\n is_blacklisted BOOLEAN\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._exceptions_lists_new_part_tblname,\n is_unlogged=True)\n\n tblname = self._blocking_conditions_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n cond_name TEXT NOT NULL,\n reason TEXT NOT NULL\n )\"\"\")\n .format(sql.Identifier(tblname)))\n table_names.append(tblname)\n\n tblname = self._mnc_mcc_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n mcc_mnc_pattern TEXT NOT NULL,\n operator_id TEXT NOT NULL\n )\"\"\")\n .format(sql.Identifier(tblname)))\n table_names.append(tblname)\n\n tblname = self._notifications_imei_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n is_valid BOOLEAN,\n amnesty_granted BOOLEAN,\n imei_norm_with_check_digit TEXT\n ) PARTITION BY RANGE (virt_imei_shard)\"\"\")\n .format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._notifications_triplets_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n msisdn TEXT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n is_valid BOOLEAN,\n amnesty_granted BOOLEAN,\n imei_norm_with_check_digit TEXT,\n home_operator TEXT,\n fallback_operators TEXT[]\n ) PARTITION BY RANGE (virt_imei_shard)\"\"\")\n .format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._pairings_imei_imsi_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n is_valid BOOLEAN,\n imei_norm_with_check_digit TEXT,\n home_operator TEXT,\n is_blacklisted BOOLEAN\n ) PARTITION BY RANGE (virt_imei_shard) \"\"\")\n .format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True, fillfactor=45)\n table_names.append(tblname)\n\n self._intermediate_table_names.extend(table_names)\n return -1, cp.duration","def __create_table(self):\n\n self.connection = self.db.connect()\n self.metadata = MetaData(self.connection)\n\n self.system = Table(self.table_name, self.metadata,\n Column('timestamp', DateTime(), primary_key=True, nullable=False),\n Column('vibration_sensor', Float()),\n Column('flow', Float()),\n Column('pressure', Float()),\n Column('power_consumption', Float()),\n Column('failure_times', Float()),\n Column('operational', Boolean())\n )\n\n self.metadata.create_all()","def create_tables_and_apply_patches(self):\n\n if self.authorized and not self.db_tables_initiated:\n with self.connection.cursor() as cursor:\n for statement in self.parse_mysql_sql_file():\n cursor.execute(statement)\n\n PyFunceble.LOGGER.info(\n \"Created the missing tables. Applied all patched\"\n )\n\n self.db_tables_initiated = True","def _create_meta_data_table(self) -> None:\n self.dynamodb.create_table(\n TableName=self.gene_metadata_table,\n KeySchema=[\n {\"AttributeName\": \"src_name\", \"KeyType\": \"HASH\"} # Partition key\n ],\n AttributeDefinitions=[\n {\"AttributeName\": \"src_name\", \"AttributeType\": \"S\"},\n ],\n ProvisionedThroughput={\"ReadCapacityUnits\": 10, \"WriteCapacityUnits\": 10},\n )","def __update_accounts(self):\n\t\tfor acct in self.wallet:\n\t\t\tif len(get_unspent(acct[\"address\"], self.testnet))!=0:\n\t\t\t\tacct[\"status\"] = \"in use\"\n\t\t\telse:\n\t\t\t\tspent = get_spent(acct[\"address\"], self.testnet)\n\t\t\t\tconfirm = (s[\"confirmations\"] >= 6 for s in spent)\n\t\t\t\tif len(spent) > 0 and all(confirm):\n\t\t\t\t\tacct[\"status\"] = \"used\"\n\t\t\t\telif len(spent) > 0:\n\t\t\t\t\tacct[\"status\"] = \"in use\"\n\t\tself.header[\"LAST_UPDATE_TIME\"] = str(round(time.time()))\n\t\toutput = [self.header, *self.wallet]\n\t\twith open(self.filepath, 'w+') as f:\n\t\t\tjson.dump(output, f)","def cutadapt_general_stats_table(self):\n\n headers = {}\n headers['percent_trimmed'] = {\n 'title': 'Trimmed',\n 'description': '% Total Base Pairs trimmed',\n 'max': 30,\n 'min': 0,\n 'scale': 'RdYlBu-rev',\n 'format': '{:.1f}%'\n }\n self.general_stats_addcols(self.cutadapt_data, headers)","def __init__(self, database='/tmp/blingalytics_cache'):\n self.database = database\n self._create_metadata_table()","def collect_stat(self):\n\n cnstat_dict, ratestat_dict = self.get_cnstat()\n self.cnstat_dict.update(cnstat_dict)\n self.ratestat_dict.update(ratestat_dict)","def _populate_new_blacklist(self, conn):\n with CodeProfiler() as cp:\n tblname = self._blacklist_new_tblname\n num_records = self._populate_new_blacklist_or_notifications_imei_table(conn,\n tblname, is_blacklist=True)\n\n return num_records, cp.duration","def add_statistics(self, stat_col):\n # Those will be displayed.\n stat_col.add_statistics(self.key_precision, '{:05.4f}')\n stat_col.add_statistics(self.key_recall, '{:05.4f}')\n stat_col.add_statistics(self.key_f1score, '{:05.4f}')\n # That one will be collected and used by aggregator.\n stat_col.add_statistics(self.key_f1score+'_support', None)","def _create_tables_classic(self, engine, metadata):\n if engine and metadata:\n with (yield from engine) as conn:\n for x in self._models.values():\n try:\n yield from conn.execute(CreateTable(x))\n except ProgrammingError as error:\n if hasattr(self.app, 'log') and self.app.log:\n if self.app.debug:\n self.app.log.info(\"[PostgressPlugin] [ `{}` already exists]\".format(x))\n else:\n if self.app.debug:\n print(\"[PostgressPlugin] [ `{}` already exists]\".format(x))\n return","def create_table():\n sql = sqlite3.connect('data.db')\n cursor = sql.cursor()\n logging.debug(\"Successfully Connected to SQLite\")\n\n cursor.execute(\n '''CREATE TABLE Status\n ([ip] text, [port] integer, [count_requests] integer, [t_start] integer, [protocol] text)'''\n )\n\n cursor.close()","def pre_track_containers_create_container_table(self, conn):\n # revert to old trigger script to support one of the tests\n OLD_POLICY_STAT_TRIGGER_SCRIPT = \"\"\"\n CREATE TRIGGER container_insert_ps AFTER INSERT ON container\n BEGIN\n INSERT OR IGNORE INTO policy_stat\n (storage_policy_index, object_count, bytes_used)\n VALUES (new.storage_policy_index, 0, 0);\n UPDATE policy_stat\n SET object_count = object_count + new.object_count,\n bytes_used = bytes_used + new.bytes_used\n WHERE storage_policy_index = new.storage_policy_index;\n END;\n CREATE TRIGGER container_delete_ps AFTER DELETE ON container\n BEGIN\n UPDATE policy_stat\n SET object_count = object_count - old.object_count,\n bytes_used = bytes_used - old.bytes_used\n WHERE storage_policy_index = old.storage_policy_index;\n END;\n\n \"\"\"\n conn.executescript(\"\"\"\n CREATE TABLE container (\n ROWID INTEGER PRIMARY KEY AUTOINCREMENT,\n name TEXT,\n put_timestamp TEXT,\n delete_timestamp TEXT,\n object_count INTEGER,\n bytes_used INTEGER,\n deleted INTEGER DEFAULT 0,\n storage_policy_index INTEGER DEFAULT 0\n );\n\n CREATE INDEX ix_container_deleted_name ON\n container (deleted, name);\n\n CREATE TRIGGER container_insert AFTER INSERT ON container\n BEGIN\n UPDATE account_stat\n SET container_count = container_count + (1 - new.deleted),\n object_count = object_count + new.object_count,\n bytes_used = bytes_used + new.bytes_used,\n hash = chexor(hash, new.name,\n new.put_timestamp || '-' ||\n new.delete_timestamp || '-' ||\n new.object_count || '-' || new.bytes_used);\n END;\n\n CREATE TRIGGER container_update BEFORE UPDATE ON container\n BEGIN\n SELECT RAISE(FAIL, 'UPDATE not allowed; DELETE and INSERT');\n END;\n\n\n CREATE TRIGGER container_delete AFTER DELETE ON container\n BEGIN\n UPDATE account_stat\n SET container_count = container_count - (1 - old.deleted),\n object_count = object_count - old.object_count,\n bytes_used = bytes_used - old.bytes_used,\n hash = chexor(hash, old.name,\n old.put_timestamp || '-' ||\n old.delete_timestamp || '-' ||\n old.object_count || '-' || old.bytes_used);\n END;\n \"\"\" + OLD_POLICY_STAT_TRIGGER_SCRIPT)","async def _create_table(self, table: TableSchema) -> None:\n try:\n await self.conn.execute(get_create_table(table))\n except PostgresError: # Only DB related exceptions\n print(f\"Failed to execute CREATE TABLE for {table['name']}\")\n raise\n # Initialize migration level (so that it can be altered in future)\n await self.conn.execute('INSERT INTO tinymud_migrations (table_name, level) VALUES ($1, $2)', table['name'], 0)","def populate_twitter_account_to_db():\n api = twitter.Api(**settings.TWITTER_OAUTH, sleep_on_rate_limit=False)\n with open(NEWSFEED['TWITTER']['ACCOUNT_LIST'], 'r') as f:\n lines = f.readlines()\n for l in lines:\n screen_name = l.strip()\n\n if CredibleUSTwitterAccount.objects.filter(screen_name=screen_name).exists():\n continue\n\n try:\n twitteruser = api.GetUser(screen_name=screen_name)\n CredibleUSTwitterAccount.objects.create(screen_name=twitteruser.screen_name,\n uid=twitteruser.id,\n description=twitteruser.description)\n except TwitterError as e:\n print(e.message)","def analyze_table(self):\n\n # Analyze table has a query result, we have to use query here.\n # Otherwise we'll get a out of sync error\n self.query(sql.analyze_table(self.new_table_name))\n self.query(sql.analyze_table(self.delta_table_name))","def create_base_table(self, table_name):\n print('new')\n # Create table at first.\n select_stm = self.construct_base_table()\n exec_query('DROP TABLE IF EXISTS %s;' % table_name) \n sql = \"\"\"\n CREATE TABLE %s AS\n %s\n \"\"\" % (table_name, select_stm)\n exec_query(sql)","def __create_recentconn_table(self):\r\n QtSql.QSqlQuery('''CREATE TABLE IF NOT EXISTS recentconn\r\n (host varchar(255),\r\n port int,\r\n passphrase varchar(255),\r\n UNIQUE (host, port) ON CONFLICT REPLACE)''')","def _prepare_stats_table(self, pinfos):\n\n stats_tbl = OrderedDict()\n stats_tbl[\"Title\"] = OrderedDict()\n for res in self.rsts:\n stats_tbl[res.reportid] = OrderedDict()\n\n for pinfo in pinfos:\n for colname in (pinfo[\"colname\"], pinfo[\"xcolname\"]):\n if colname in stats_tbl[\"Title\"]:\n continue\n\n # Each column name is represented by a row in the statistics table. Fill the \"Title\"\n # column.\n title_dict = stats_tbl[\"Title\"][colname] = OrderedDict()\n defs = self._refdefs.info[colname]\n\n if defs.get(\"unit\") == \"nanosecond\":\n # Convert nanoseconds to microseconds.\n unit = \"us\"\n else:\n unit = defs.get(\"short_unit\", \"\")\n\n title_dict[\"colname\"] = colname\n if unit:\n title_dict[\"colname\"] += f\", {unit}\"\n title_dict[\"coldescr\"] = defs[\"descr\"]\n\n title_dict[\"funcs\"] = OrderedDict()\n for funcname in self._stats_funcs:\n if funcname in self.rsts[0].cstats[colname]:\n title_dict[\"funcs\"][funcname] = RORawResult.get_stat_func_descr(funcname)\n\n # Now fill the values for each result.\n for res in self.rsts:\n res_dict = stats_tbl[res.reportid][colname] = OrderedDict()\n res_dict[\"funcs\"] = OrderedDict()\n\n for funcname in title_dict[\"funcs\"]:\n val = res.cstats[colname][funcname]\n fmt = \"{}\"\n if defs.get(\"unit\") == \"nanosecond\" and \"index\" not in funcname:\n val /= 1000\n fmt = \"{:.2f}\"\n if defs[\"type\"] == \"float\":\n fmt = \"{:.2f}\"\n\n fdict = res_dict[\"funcs\"][funcname] = OrderedDict()\n fdict[\"val\"] = fmt.format(val)\n fdict[\"raw_val\"] = val\n\n if self._refres.reportid == res.reportid:\n fdict[\"hovertext\"] = \"This is the reference result, other results \" \\\n \"are compared to this one.\"\n continue\n\n ref_fdict = stats_tbl[self._refres.reportid][colname][\"funcs\"][funcname]\n change = val - ref_fdict[\"raw_val\"]\n if ref_fdict[\"raw_val\"]:\n percent = (change / ref_fdict[\"raw_val\"]) * 100\n else:\n percent = change\n change = fmt.format(change) + unit\n percent = \"{:.1f}%\".format(percent)\n fdict[\"hovertext\"] = f\"Change: {change} ({percent})\"\n\n return stats_tbl","def _upsert_account_structure(campaign_data, con: sqlite3.Connection):\n con.execute(\"\"\"\nCREATE TABLE IF NOT EXISTS account_structure (\n ad_id BIGINT NOT NULL,\n ad TEXT NOT NULL,\n ad_set_id BIGINT NOT NULL,\n ad_set TEXT NOT NULL,\n campaign_id BIGINT NOT NULL,\n campaign TEXT NOT NULL,\n account_id BIGINT NOT NULL,\n account TEXT NOT NULL,\n attributes JSON,\n PRIMARY KEY (ad_id)\n);\"\"\")\n con.execute(\"INSERT OR REPLACE INTO account_structure VALUES (?,?,?,?,?,?,?,?,?)\",\n campaign_data)","def test_custom_metadata_schema(self):\n # The use-case for this functionality is to allow using\n # Foreign Data Wrappers, each with a full set of Django\n # tables, to copy between databases using SQLAlchemy\n # and the automatically generation of aldjemy.\n metadata = MetaData(schema=\"arbitrary\")\n sa_models = construct_models(metadata)\n self.assertEqual(sa_models[Log].__table__.schema, \"arbitrary\")","def createFriendsTable(conn):\n \n c = conn.cursor()\n \n c.execute(\"CREATE TABLE friend (name TEXT, country TEXT, age INT)\") \n conn.commit()","async def update_trade_stats(self):\n\n summary_keys = [base for base in config['min_base_volumes']] + ['global']\n summaries = {\n key: {\n 'open_count': 0,\n 'buys': 0,\n 'rebuys': 0,\n 'sells': 0,\n 'collect_sells': 0,\n 'soft_stop_sells': 0,\n 'total_profit': 0.0,\n 'total_loss': 0.0,\n 'total_fees': 0.0,\n 'balancer_refills': 0,\n 'balancer_remits': 0,\n 'balancer_stop_losses': 0,\n 'balancer_profit': 0.0,\n 'balancer_loss': 0.0,\n 'balancer_fees': 0.0,\n } for key in summary_keys\n }\n\n for pair in self.trades:\n if pair not in self.trade_stats[self.time_prefix]:\n continue\n\n base = pair.split('-', 1)[0]\n open_count = len(self.trades[pair]['open'])\n\n summaries[base]['open_count'] += open_count\n summaries[base]['buys'] += self.trade_stats[self.time_prefix][pair]['buys']\n summaries[base]['rebuys'] += self.trade_stats[self.time_prefix][pair]['rebuys']\n summaries[base]['sells'] += self.trade_stats[self.time_prefix][pair]['sells']\n summaries[base]['collect_sells'] += self.trade_stats[self.time_prefix][pair]['collect_sells']\n summaries[base]['soft_stop_sells'] += self.trade_stats[self.time_prefix][pair]['soft_stop_sells']\n summaries[base]['total_profit'] += self.trade_stats[self.time_prefix][pair]['total_profit']\n summaries[base]['total_loss'] += self.trade_stats[self.time_prefix][pair]['total_loss']\n summaries[base]['total_fees'] += self.trade_stats[self.time_prefix][pair]['total_fees']\n summaries[base]['balancer_refills'] += self.trade_stats[self.time_prefix][pair]['balancer_refills']\n summaries[base]['balancer_remits'] += self.trade_stats[self.time_prefix][pair]['balancer_remits']\n summaries[base]['balancer_profit'] += self.trade_stats[self.time_prefix][pair]['balancer_profit']\n summaries[base]['balancer_loss'] += self.trade_stats[self.time_prefix][pair]['balancer_loss']\n summaries[base]['balancer_fees'] += self.trade_stats[self.time_prefix][pair]['balancer_fees']\n\n summaries['global']['open_count'] += open_count\n summaries['global']['buys'] += self.trade_stats[self.time_prefix][pair]['buys']\n summaries['global']['rebuys'] += self.trade_stats[self.time_prefix][pair]['rebuys']\n summaries['global']['sells'] += self.trade_stats[self.time_prefix][pair]['sells']\n summaries['global']['collect_sells'] += self.trade_stats[self.time_prefix][pair]['collect_sells']\n summaries['global']['soft_stop_sells'] += self.trade_stats[self.time_prefix][pair]['soft_stop_sells']\n summaries['global']['total_profit'] += self.trade_stats[self.time_prefix][pair]['total_profit']\n summaries['global']['total_loss'] += self.trade_stats[self.time_prefix][pair]['total_loss']\n summaries['global']['total_fees'] += self.trade_stats[self.time_prefix][pair]['total_fees']\n summaries['global']['balancer_refills'] += self.trade_stats[self.time_prefix][pair]['balancer_refills']\n summaries['global']['balancer_remits'] += self.trade_stats[self.time_prefix][pair]['balancer_remits']\n summaries['global']['balancer_profit'] += self.trade_stats[self.time_prefix][pair]['balancer_profit']\n summaries['global']['balancer_loss'] += self.trade_stats[self.time_prefix][pair]['balancer_loss']\n summaries['global']['balancer_fees'] += self.trade_stats[self.time_prefix][pair]['balancer_fees']\n\n for key in summaries:\n self.trade_stats[self.time_prefix][key]['buys'] = summaries[key]['buys']\n self.trade_stats[self.time_prefix][key]['rebuys'] = summaries[key]['rebuys']\n self.trade_stats[self.time_prefix][key]['sells'] = summaries[key]['sells']\n self.trade_stats[self.time_prefix][key]['collect_sells'] = summaries[key]['collect_sells']\n self.trade_stats[self.time_prefix][key]['soft_stop_sells'] = summaries[key]['soft_stop_sells']\n self.trade_stats[self.time_prefix][key]['total_profit'] = summaries[key]['total_profit']\n self.trade_stats[self.time_prefix][key]['total_loss'] = summaries[key]['total_loss']\n self.trade_stats[self.time_prefix][key]['total_fees'] = summaries[key]['total_fees']\n self.trade_stats[self.time_prefix][key]['balancer_refills'] = summaries[key]['balancer_refills']\n self.trade_stats[self.time_prefix][key]['balancer_remits'] = summaries[key]['balancer_remits']\n self.trade_stats[self.time_prefix][key]['balancer_profit'] = summaries[key]['balancer_profit']\n self.trade_stats[self.time_prefix][key]['balancer_loss'] = summaries[key]['balancer_loss']\n self.trade_stats[self.time_prefix][key]['balancer_fees'] = summaries[key]['balancer_fees']\n\n if summaries[key]['open_count'] > self.trade_stats[self.time_prefix][key]['most_open']:\n self.trade_stats[self.time_prefix][key]['most_open'] = summaries[key]['open_count']\n\n filter_items = [pair for pair in self.trades] + [base for base in config['min_base_volumes']] + ['global']\n self.save_attr('trade_stats', max_depth=2, filter_items=filter_items, filter_keys=[self.time_prefix])","def add_statistics_to_status(status):\n return [{\n 'host': h['host'],\n 'status': h['status'],\n 'stats': get_statistics_for_host(h['host']),\n } for h in status]","def test_extra_col_updates_account_balance(self):\n\t\tbanco = Bancos.objects.get(id=1)\n\t\tprevious_balance = banco.balance\n\t\tcondominio = Condominio.objects.get(rif='J6750435')\n\t\tfactura_condominio = Factura_Condominio.objects.get(id=1)\n\t\tdata ={\n\t\t\t'id':1,\n\t\t\t'factura': factura_condominio,\n\t\t\t'titulo': 'sample_extra_col',\n\t\t\t'banco':banco,\n\t\t\t'monto': decimal.Decimal(100.5)\n\t\t}\n\t\textra_col = Factura_Condominio_Extra_Colum.objects.create(**data)\n\t\tself.assertEqual(extra_col.banco.balance, previous_balance-extra_col.monto)","def initiate_db_account_balances(self, quote:str, started_with:str, real_balance:str, internal_balance:str):\n\n\t\tconn \t\t\t = sqlite3.connect(self.name, detect_types=sqlite3.PARSE_DECLTYPES)\n\t\tconn.row_factory = sqlite3.Row\n\t\tc \t\t\t\t = conn.cursor()\n\n\t\tvalues = (quote,\n\t\t\t\t started_with,\n\t\t\t\t real_balance,\n\t\t\t\t '0',\n\t\t\t\t internal_balance,\n\t\t\t\t '0',\n\t\t\t\t '0',\n\t\t\t\t '0',\n\t\t\t\t '0',\n\t\t\t\t '0',\n\t\t\t\t quote)\n\t\t# Insert a row for the quoreasset only if doesn't already exist\n\t\tc.execute('INSERT INTO account_balances SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ? WHERE NOT EXISTS (SELECT * FROM account_balances WHERE quote=?)', values)\n\n\t\tconn.commit()","async def metadata(self) -> AccountInformationMetaData:\n\n e = await self.request.request(url=f'https://accountinformation.roblox.com/v1/metadata', method='get')\n return AccountInformationMetaData(item=e)","def create_UAG_table_in_sql(sql_cursor):\n sql_cursor.execute('''DROP TABLE IF EXISTS uag_complete;''')\n sql_cursor.execute(\n '''CREATE TABLE uag_complete (\n _id integer PRIMARY KEY, \n user_id varchar(50),\n age_bucket varchar(20),\n age_avg varchar(20),\n gender_bucket varchar(20),\n source varchar(30));\n ''')","def make_temp_tbl(self, type: str = \"user_details\"):\n uid = uuid.uuid4()\n temp_tbl_name = \"temp_\" + str(uid).replace('-', '_')\n\n if self.config.dbtype.lower() == \"mysql\":\n create_temp_tbl_sql = f\"CREATE TABLE {temp_tbl_name} LIKE {type};\"\n elif self.config.dbtype.lower() == \"sqlite\":\n create_temp_tbl_sql = f\"CREATE TABLE {temp_tbl_name} AS SELECT * FROM {type} WHERE 0\"\n self.engine.execute(create_temp_tbl_sql)\n return temp_tbl_name","def create_base_users(): # TODO: Just call create_user for each\n with engine.connect() as connection:\n\n result = connection.execute(\"select user from pdp_users\")\n user_count = len(result.fetchall())\n if user_count == 0:\n\n print(\"Creating base users\")\n\n pu = sa.Table(\"pdp_users\", metadata, autoload=True, autoload_with=engine)\n\n # user\n pw_hash = user_api.hash_password(BASEUSER_PW)\n ins_stmt = pu.insert().values(\n username=\"base_user\", full_name=\"Base User\", password=pw_hash, active=\"Y\", role=1,\n )\n connection.execute(ins_stmt)\n\n # INactive user\n # Reuse pw hash\n ins_stmt = pu.insert().values(\n username=\"base_user_inact\", full_name=\"Inactive User\", password=pw_hash, active=\"N\", role=1,\n )\n connection.execute(ins_stmt)\n\n # editor\n pw_hash = user_api.hash_password(BASEEDITOR_PW)\n ins_stmt = pu.insert().values(\n username=\"base_editor\", full_name=\"Base Editor\", password=pw_hash, active=\"Y\", role=2,\n )\n connection.execute(ins_stmt)\n\n # admin\n pw_hash = user_api.hash_password(BASEADMIN_PW)\n ins_stmt = pu.insert().values(\n username=\"base_admin\", full_name=\"Base Admin\", password=pw_hash, active=\"Y\", role=9,\n )\n connection.execute(ins_stmt)\n\n else:\n print(user_count, \"users already present in DB, not creating\")","def configure(self, config):\n # create the follower table if it doesn't already exist\n model.follower_table.create(checkfirst=True)","def add_stat(self, c_vid, stats):\n\n from sqlalchemy.orm.session import Session\n\n # Names that come from the Pandas describe() method\n stat_map = {'25%': 'p25', '50%': 'p50', '75%': 'p75'}\n\n stats = {stat_map.get(k, k): v for k, v in stats.items()}\n\n cs = ColumnStat(p_vid=self.vid, c_vid=c_vid, **stats)\n\n self._stats.append(cs)\n\n return cs","def create_table(opts, stats):\n print(\"--------------------------------------\")\n print(\"Creating table %s\" % (opts.table_name,))\n print(\"--------------------------------------\")\n print(timestamp())\n create_table_ddl = \"CREATE TABLE %s (\" % (opts.table_name,)\n num_bigint_cols = opts.columns - opts.num_string_columns\n assert(num_bigint_cols > 0)\n for i in range(opts.columns):\n coltype = 'STRING'\n if i < num_bigint_cols: coltype = 'BIGINT'\n if i > 0: create_table_ddl += ', '\n create_table_ddl += \"f%d %s\" % (i, coltype)\n if i == 0: create_table_ddl += ' PRIMARY KEY'\n create_table_ddl += \") PARTITION BY HASH(f0) PARTITIONS %d STORED AS KUDU \" % \\\n (opts.partitions, )\n create_table_ddl += \"TBLPROPERTIES ('kudu.num_tablet_replicas' = '%d')\" % \\\n (opts.replication_factor, )\n\n cmd = 'echo \"%s\" | impala-shell -i %s -f -' % (create_table_ddl, opts.impalad_address)\n run_command(opts, cmd)","def create_new_user_table():\n # Connect to database\n conn = psycopg2.connect(DATABASE_URL, sslmode='require')\n # Open a cursor to perform db operations\n cur = conn.cursor()\n # Create the table\n cur.execute(\"\"\"\n CREATE TABLE test (\n user_id int NOT NULL PRIMARY KEY,\n username varchar(255),\n id_last_message_sent int,\n id_last_message_stickered int,\n count_since_last_stickered int\n );\n \"\"\"\n )\n # Commit and close connection\n conn.commit()\n cur.close()\n conn.close()","def create_dataBase(conn, create_cmd):\n if conn:\n cursor = conn.cursor()\n cursor.execute(create_cmd)\n conn.commit()\n #print '[sql management] Table Created...'","def sync_tables():\n sync_table(ShoppingList)\n sync_table(User)\n sync_table(Category)\n sync_table(Feed)\n sync_table(News)\n sync_table(Photo)\n sync_table(Profile)\n sync_table(Video)\n sync_type(FeedPhoto)\n sync_type(NewsPhoto)","def upgrade():\n op.add_column(\n 'share_instances',\n Column('access_rules_status', String(length=255))\n )\n\n connection = op.get_bind()\n share_instances_table = utils.load_table('share_instances', connection)\n instance_access_table = utils.load_table('share_instance_access_map',\n connection)\n\n # NOTE(u_glide): Data migrations shouldn't be performed on live clouds\n # because it will lead to unpredictable behaviour of running operations\n # like migration.\n instances_query = (\n share_instances_table.select()\n .where(share_instances_table.c.status == constants.STATUS_AVAILABLE)\n .where(share_instances_table.c.deleted == 'False')\n )\n\n for instance in connection.execute(instances_query):\n\n access_mappings_query = instance_access_table.select().where(\n instance_access_table.c.share_instance_id == instance['id']\n ).where(instance_access_table.c.deleted == 'False')\n\n status = constants.STATUS_ACTIVE\n\n for access_rule in connection.execute(access_mappings_query):\n\n if (access_rule['state'] == constants.STATUS_DELETING or\n access_rule['state'] not in priorities):\n continue\n\n if priorities[access_rule['state']] > priorities[status]:\n status = access_rule['state']\n\n # pylint: disable=no-value-for-parameter\n op.execute(\n share_instances_table.update().where(\n share_instances_table.c.id == instance['id']\n ).values({'access_rules_status': upgrade_data_mapping[status]})\n )\n\n op.drop_column('share_instance_access_map', 'state')","def test_cap_table_formats(logger, dbsession, network, scanned_distribution, web3):\n\n identity_provider = NullIdentityProvider()\n\n token_address = scanned_distribution\n for sort_direction in [\"asc\", \"desc\"]:\n for sort_order in [\"address\", \"name\", \"balance\", \"updated\"]:\n generate_cap_table(\n logger,\n dbsession,\n token_address,\n order_by=sort_order,\n identity_provider=identity_provider,\n order_direction=sort_direction,\n include_empty=False,\n TokenScanStatus=TokenScanStatus,\n TokenHolderAccount=TokenHolderAccount,\n )","def __create_failures_table(self, schema=REPORTS_SCHEMA_300):\r\n QtSql.QSqlQuery(schema)","def _create_db(self, overwrite=False):\n current = list(self._cur.execute(\"select * from sqlite_master where type='table' and name='metrics'\"))\n if overwrite and len(current) >= 1:\n self._cur.execute('''DROP TABLE IF EXISTS metrics''')\n self._conn.commit()\n elif len(current) >= 1:\n self._fields = [x[1] for x in sorted(self._cur.execute('''PRAGMA table_info(metrics)'''))]\n return None\n self._cur.execute('''CREATE TABLE metrics (model_name text, operation_name text, metric_name text, metric_type text, metric_value real)''')\n self._fields = [\"model_name\", \"operation_name\", \"metric_name\", \"metric_type\", \"metric_value\"]\n self._conn.commit()","def create_all_tables(self):\n pass","def apply_migration (self, migration) :\n scope = self.home_scope\n for k in (\"Account\", \"Group\", \"Person\", \"links\") :\n for epk, db_attrs in sorted (pyk.iteritems (migration [k])) :\n ET = scope [epk [-1]]\n obj = ET.instance (* epk, raw = True)\n if obj is None :\n obj = ET (* epk, raw = True, ** dict (db_attrs))\n elif k == \"Account\" :\n obj.set_raw (** dict (db_attrs))","def create_table(self):\n c = self.conn.cursor()\n c.execute(\"CREATE TABLE sensor_data (mac text, name text, temperature real, light integer, moisture real, conductivity real, battery real, ts_utc int, date_iso text, firmware text )\")","def _populate_old_blacklist(self, executor):\n with create_db_connection(self._config.db_config) as conn, conn.cursor() as cursor, CodeProfiler() as cp:\n tblname = self._blacklist_old_tblname\n cursor.execute(sql.SQL(\"\"\"INSERT INTO {0}(imei_norm, virt_imei_shard, block_date, reasons)\n SELECT imei_norm, virt_imei_shard, block_date, reasons\n FROM gen_blacklist()\n \"\"\").format(sql.Identifier(tblname)))\n num_records = cursor.rowcount\n self._add_pk(conn, tblname=tblname, pk_columns=['imei_norm'])\n self._analyze_helper(cursor, tblname)\n\n return num_records, cp.duration","def create_table(self, table_info, table_name):\r\n t1 = time.time()\r\n if self.database in ['redshift', 'postgres']:\r\n postgres_helper.create_table(\r\n conf=self.conf,\r\n table_info=table_info,\r\n table_name=table_name\r\n )\r\n else:\r\n raise Exception(\"database not supported yet: '{}'\"\r\n .format(self.database))\r\n t2 = time.time()\r\n t = t2 - t1\r\n print('Finished in {:.2f} seconds.'.format(t))\r\n return","def create_tmp_shadow_tables(session, config):\n session.execute(create_trigger_sql(config, for_tmp=True))\n\n conn = session.connection()\n # Create annotationshadowtranscript in a temp table amd insert all data\n tmp_annotationshadowtranscript = get_annotationshadowtranscript_table(\n \"tmp_annotationshadowtranscript\"\n )\n tmp_annotationshadowtranscript.create(conn)\n conn.execute(\n \"SELECT insert_tmp_annotationshadowtranscript(allele_id, annotations) from annotation WHERE date_superceeded IS NULL\"\n )\n\n # Remove temporary table from metadata\n Base.metadata.remove(tmp_annotationshadowtranscript)\n\n # Create annotationshadowfrequency in a temp table amd insert all data\n tmp_annotationshadowfrequency = get_annotationshadowfrequency_table(\n config, name=\"tmp_annotationshadowfrequency\"\n )\n tmp_annotationshadowfrequency.create(conn)\n conn.execute(\n \"SELECT insert_tmp_annotationshadowfrequency(allele_id, annotations) from annotation WHERE date_superceeded IS NULL;\"\n )\n\n # Remove temporary table from metadata\n Base.metadata.remove(tmp_annotationshadowfrequency)\n\n # Map AnnotationShadowFrequency using the same config used to refresh the table\n update_annotation_shadow_columns(config)\n\n # Check that all filterconfigs and usergroups' ACMG-configuration are still valid,\n # given the possible change in columns\n check_filterconfig_and_acmg_groups(session, config)","def create_schema(self):\n schema = '''CREATE TABLE jping (\n ip_address text not null,\n interface text not null,\n hostname text not null,\n ping_results integer not null,\n UNIQUE(ip_address, hostname)\n )\n '''\n self.query(schema)","def add_torch_stat(self, stat_type, stat_tensor):\n stat = stat_tensor.item.detach().cpu().item()\n self.add_stat(stat_type, stat)","def _create_intermediate_delta_tables_structure(self, conn):\n table_names = []\n with conn.cursor() as cursor, CodeProfiler() as cp:\n tblname = self._blacklist_delta_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n LIKE {blacklist_delta_tbl} INCLUDING DEFAULTS\n INCLUDING IDENTITY\n INCLUDING CONSTRAINTS\n INCLUDING STORAGE\n INCLUDING COMMENTS\n ) PARTITION BY RANGE (virt_imei_shard)\n \"\"\").format(sql.Identifier(tblname),\n blacklist_delta_tbl=sql.Identifier(self._blacklist_tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._notifications_lists_delta_tblname\n notifications_delta_tbl = sql.Identifier(self._notifications_lists_tblname)\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n LIKE {notifications_delta_tbl} INCLUDING DEFAULTS\n INCLUDING IDENTITY\n INCLUDING CONSTRAINTS\n INCLUDING STORAGE\n INCLUDING COMMENTS\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname),\n notifications_delta_tbl=notifications_delta_tbl))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._notifications_lists_delta_part_tblname,\n is_unlogged=True)\n\n tblname = self._exceptions_lists_delta_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n LIKE {exceptions_delta_tbl} INCLUDING DEFAULTS\n INCLUDING IDENTITY\n INCLUDING CONSTRAINTS\n INCLUDING STORAGE\n INCLUDING COMMENTS\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname),\n exceptions_delta_tbl=sql.Identifier(self._exceptions_lists_tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._exceptions_lists_delta_part_tblname,\n is_unlogged=True)\n\n self._intermediate_table_names.extend(table_names)\n return -1, cp.duration","def __create_transactions_table(self):\n cmd = \"\"\" CREATE TABLE IF NOT EXISTS %s (\n %s text,\n %s text,\n %s text,\n %s real,\n %s text,\n %s text);\"\"\" %(TABLE_TRANSACTIONS,\n COL_TRANSACTION_BLOCK,\n COL_TRANSACTION_SENDER,\n COL_TRANSACTION_RECEIVER,\n COL_TRANSACTION_AMOUNT,\n COL_TRANSACTION_SUB_TIME,\n COL_TRANSACTION_VER_TIME)\n self.__dbcursor.execute(cmd)","def _update_base_stats(self, base_stats):\n self.total_samples += base_stats[\"sample_size\"]\n self.sample = base_stats[\"sample\"]\n self._empty_line_count += base_stats[\"empty_line_count\"]\n self.memory_size += base_stats[\"memory_size\"]","def load_metadata(self):\n self.meta[\"user_tables\"] = pd.read_sql(self.SQL[\"User Tables\"], self.engine)\n self.meta[\"all_tables\"] = pd.read_sql(self.SQL[\"All Tables\"], self.engine)\n self.meta[\"all_databases\"] = pd.read_sql(self.SQL[\"All Databases\"], self.engine)","def _db_init_data_tables(self):\n\n #\n # TESTTYPE table\n #\n return self._db_execute(\n \"\"\"\n create table TESTTYPE (\n KEY text unique,\n VALUE text\n )\n \"\"\"\n )","def create_user_state_table():\n connection = connection_to_db()\n cursor = connection.cursor()\n\n cursor.execute(\n \"CREATE TABLE IF NOT EXISTS user_state \"\n \"(id serial PRIMARY KEY, \"\n \"user_id INTEGER NOT NULL, \"\n \"state INTEGER DEFAULT 0);\"\n )\n\n connection.commit()","def chart_of_accounts(qbo_session, attrs = \"strict\"):\n\n #query all the accounts\n accounts = qbo_session.get_objects(\"Account\")\n\n #by strict, I mean the order the docs say to use when udpating:\n #https://developer.intuit.com/docs/0025_quickbooksapi/\n #0050_data_services/030_entity_services_reference/account\n\n if attrs == \"strict\":\n attrs = [\n \"Id\", \"SyncToken\", \"MetaData\", \"Name\", \"SubAccount\",\n \"ParentRef\", \"Description\", \"FullyQualifiedName\", \"Active\",\n \"Classification\", \"AccountType\", \"AccountSubType\", \"AcctNum\",\n \"OpeningBalance\", \"OpeningBalanceDate\", \"CurrentBalance\",\n \"CurentBalanceWithSubAccounts\", \"CurrencyRef\"\n ]\n\n else:\n #TODO: validate the attrs against the 'strict' list above\n pass\n\n #As a first cut, we'll sort them by AccountType in trial balance order\n\n tb_type_order = [\n \"Bank\", \"Accounts Receivable\", \"Other Current Asset\",\n \"Fixed Asset\", \"Other Asset\",\n \"Accounts Payable\", \"Credit Card\",\n \"Other Current Liability\", \"Other Liability\",\n \"Equity\",\n \"Income\", \"Other Income\",\n \"Expense\", \"Other Expense\", \"Cost of Goods Sold\"\n ]\n\n accounts_by_type = {} #{Accounts_Payable:[row_list]\n\n for a_id in accounts:\n a = accounts[a_id]\n at = a[\"AccountType\"]\n if at not in tb_type_order:\n raise Exception(\"Unexpected AccountType: %s\" % at)\n\n if at not in accounts_by_type:\n accounts_by_type[at]=[]\n\n this_row = []\n for field in attrs:\n if field not in a:\n this_row.append(\"\")\n else:\n value = a[field]\n if isinstance(value,(list,tuple,dict)):\n this_row.append(\"<complex>\")\n else:\n this_row.append(a[field])\n\n accounts_by_type[at].append(this_row)\n\n rows = [attrs] #headers are the first row\n for at in tb_type_order:\n if at in accounts_by_type:\n for row in accounts_by_type[at]:\n rows.append(row)\n\n return rows","def migrate(cls)->None:\n database.cursor.execute(\"\"\"CREATE TABLE IF NOT EXISTS rsvps (\n creatd_date varchar,\n meetup integer,\n user_id integer,\n response varchar,\n PRIMARY KEY(meetup,user_id)\n )\"\"\")\n database.connection.commit()","def create_table(self, context, connection, *, engine):\n yield Table(self.table_name, MetaData(), autoload=True, autoload_with=engine)","def _create_intermediate_old_tables_structure(self, conn):\n table_names = []\n with conn.cursor() as cursor, CodeProfiler() as cp:\n tblname = self._blacklist_old_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL\n ) PARTITION BY RANGE (virt_imei_shard)\n \"\"\").format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._notifications_lists_old_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n operator_id TEXT NOT NULL,\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n msisdn TEXT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n amnesty_granted BOOLEAN\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._notifications_lists_old_part_tblname,\n is_unlogged=True)\n\n tblname = self._exceptions_lists_old_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n operator_id TEXT NOT NULL,\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._exceptions_lists_old_part_tblname,\n is_unlogged=True)\n\n self._intermediate_table_names.extend(table_names)\n return -1, cp.duration","def add_team_derived_stats(stats, opp_stats):\n stats['FGP'] = gen_derived_var(stats['FG'], stats['FGA'])\n stats['FTP'] = gen_derived_var(stats['FT'], stats['FTA'])\n stats['THRP'] = gen_derived_var(stats['THR'], stats['THRA'])\n stats['EFGP'] = gen_derived_var(stats['FG'] + 0.5 *\n stats['THR'], stats['FGA'])\n stats['TSA'] = stats['FGA'] + 0.44 * stats['FTA']\n stats['TSP'] = gen_derived_var(stats['PTS'], 2 * stats['TSA'])\n stats['THRAr'] = gen_derived_var(stats['THRA'], stats['FGA'])\n stats['FTAr'] = gen_derived_var(stats['FTA'], stats['FGA'])\n stats['TWOAr'] = gen_derived_var(stats['TWOA'], stats['FGA'])\n stats['TWOP'] = gen_derived_var(stats['TWO'], stats['TWOA'])\n stats['ORBr'] = gen_derived_var(stats['ORB'], stats['TRB'])\n stats['DRBr'] = gen_derived_var(stats['DRB'], stats['TRB'])\n stats['AST_to_TOV'] = gen_derived_var(stats['AST'], stats['TOV'])\n stats['STL_to_TOV'] = gen_derived_var(stats['STL'], stats['TOV'])\n stats['FIC'] = (stats['PTS'] + stats['ORB'] + 0.75 * stats['DRB'] +\n stats['AST'] + stats['STL'] + stats['BLK'] - 0.75 *\n stats['FGA'] - 0.375 * stats['FTA'] -\n stats['TOV'] - 0.5 * stats['PF'])\n stats['FT_to_FGA'] = gen_derived_var(stats['FT'], stats['FGA'])\n\n stats['OPOS'] = gen_possessions(stats, opp_stats)\n stats['DPOS'] = gen_possessions(opp_stats, stats)\n stats['PACE'] = 48 * ((stats['OPOS'] + stats['DPOS']) / (2 * (float(stats['MP']) / 5)))\n\n stats['ORBP'] = stats['ORB'] / (stats['ORB'] + opp_stats['DRB'])\n stats['DRBP'] = stats['DRB'] / (stats['DRB'] + opp_stats['ORB'])\n stats['TRBP'] = stats['TRB'] / (stats['TRB'] + opp_stats['TRB'])\n stats['ASTP'] = stats['AST'] / stats['FG']\n stats['STLP'] = stats['STL'] / stats['DPOS']\n stats['BLKP'] = stats['BLK'] / opp_stats['TWOA']\n stats['TOVP'] = stats['TOV'] / stats['OPOS']\n # stats['+/-'] = stats['+/-'] / stats['N']","def create_table(self, repo, table, params):\n return self.user_con.create_table(\n repo=repo, table=table, params=params)","def _setup_stats(self) -> None:\n\n # Save statistics\n self.mass = np.array([0])\n self.mass_balance = np.array([0])\n self.mass_balance_trend = np.array([0])","def prespi_create_container_table(self, conn):\n conn.executescript(\"\"\"\n CREATE TABLE container (\n ROWID INTEGER PRIMARY KEY AUTOINCREMENT,\n name TEXT,\n put_timestamp TEXT,\n delete_timestamp TEXT,\n object_count INTEGER,\n bytes_used INTEGER,\n deleted INTEGER DEFAULT 0\n );\n\n CREATE INDEX ix_container_deleted_name ON\n container (deleted, name);\n\n CREATE TRIGGER container_insert AFTER INSERT ON container\n BEGIN\n UPDATE account_stat\n SET container_count = container_count + (1 - new.deleted),\n object_count = object_count + new.object_count,\n bytes_used = bytes_used + new.bytes_used,\n hash = chexor(hash, new.name,\n new.put_timestamp || '-' ||\n new.delete_timestamp || '-' ||\n new.object_count || '-' || new.bytes_used);\n END;\n\n CREATE TRIGGER container_update BEFORE UPDATE ON container\n BEGIN\n SELECT RAISE(FAIL, 'UPDATE not allowed; DELETE and INSERT');\n END;\n\n\n CREATE TRIGGER container_delete AFTER DELETE ON container\n BEGIN\n UPDATE account_stat\n SET container_count = container_count - (1 - old.deleted),\n object_count = object_count - old.object_count,\n bytes_used = bytes_used - old.bytes_used,\n hash = chexor(hash, old.name,\n old.put_timestamp || '-' ||\n old.delete_timestamp || '-' ||\n old.object_count || '-' || old.bytes_used);\n END;\n \"\"\")","def createTables(self):\n metadata = Base.metadata\n metadata.create_all(self._engine)\n return","def mysql_status(self):\n stamp = int(time.time())\n\n # get data\n conn = self.object.connect()\n result = {}\n try:\n with conn.cursor() as cursor:\n for key in REQUIRED_STATUS_FIELDS:\n cursor.execute('SHOW GLOBAL STATUS LIKE \"%s\";' % key)\n row = cursor.fetchone()\n result[row[0]] = row[1]\n except Exception as e:\n exception_name = e.__class__.__name__\n context.log.debug('failed to collect MySQLd metrics due to %s' % exception_name)\n context.log.debug('additional info:', exc_info=True)\n finally:\n conn.close()\n\n # counters\n counted_vars = {}\n for metric, variable_name in METRICS['counters'].items():\n if variable_name in result:\n counted_vars[metric] = int(result[variable_name])\n\n # compound counter\n counted_vars['mysql.global.writes'] = \\\n counted_vars['mysql.global.insert'] + \\\n counted_vars['mysql.global.update'] + \\\n counted_vars['mysql.global.delete']\n\n self.aggregate_counters(counted_vars, stamp=stamp)\n\n # gauges\n tracked_gauges = {}\n for metric, variable_name in METRICS['gauges'].items():\n if variable_name in result:\n tracked_gauges[metric] = {\n self.object.definition_hash: int(result[variable_name])\n }\n\n # compound gauges\n pool_util = 0\n if ('mysql.global.innodb_buffer_pool_pages_total' in tracked_gauges and\n tracked_gauges['mysql.global.innodb_buffer_pool_pages_total'][self.object.definition_hash] > 0):\n pool_util = (\n (tracked_gauges['mysql.global.innodb_buffer_pool_pages_total'][self.object.definition_hash] -\n tracked_gauges['mysql.global.innodb_buffer_pool_pages_free'][self.object.definition_hash]) /\n tracked_gauges['mysql.global.innodb_buffer_pool_pages_total'][self.object.definition_hash] * 100\n )\n tracked_gauges['mysql.global.innodb_buffer_pool_util'] = {\n self.object.definition_hash: pool_util\n }\n\n hit_ratio = 0\n if ('mysql.global.innodb_buffer_pool_read_requests' in tracked_gauges and\n tracked_gauges['mysql.global.innodb_buffer_pool_read_requests'][self.object.definition_hash] > 0):\n hit_ratio = (\n (tracked_gauges['mysql.global.innodb_buffer_pool_read_requests'][self.object.definition_hash] /\n (tracked_gauges['mysql.global.innodb_buffer_pool_read_requests'][self.object.definition_hash] +\n tracked_gauges['mysql.global.innodb_buffer_pool_reads'][self.object.definition_hash])) * 100\n )\n\n tracked_gauges['mysql.global.innodb_buffer_pool.hit_ratio'] = {\n self.object.definition_hash: hit_ratio\n }\n\n self.aggregate_gauges(tracked_gauges, stamp=stamp)\n\n # finalize\n self.increment_counters()\n self.finalize_gauges()","def add_update_movie_metadata_table(self, table_name):\r\n if not self.csv_df.empty:\r\n self.csv_df.to_sql(table_name, self.conn, if_exists='replace')","def createStateTable(self):\r\n tableName = self._names['state']\r\n con = None\r\n try:\r\n con = sql.connect(self._filename, timeout=10, \r\n isolation_level=\"IMMEDIATE\")\r\n with con:\r\n c = con.cursor()\r\n c.execute(\"CREATE TABLE IF NOT EXISTS \"\r\n \"{}(id INTEGER PRIMARY KEY, manager TEXT, \"\r\n \"module TEXT, state TEXT)\".format(tableName))\r\n finally:\r\n _closeConnection(con)\r\n return tableName","def register(self):\n assert not self.is_registered\n with transaction.atomic():\n cursor = connection.cursor()\n cursor.execute(\"SELECT audit.audit_table(%s)\", [self.model_content_type.model_class()._meta.db_table])\n self.is_registered = True\n self.save()","def create_table1():\n connection = connect(\n host=\"localhost\",\n user=\"postgres\",\n password=\"coderslab\",\n database=f\"{name + '_db'}\"\n )\n connection.autocommit = True\n cursor = connection.cursor()\n sql_code2 = \"CREATE TABLE users(id serial PRIMARY KEY, username varchar(255) UNIQUE, hashed_password varchar(80)) \"\n cursor.execute(sql_code2)\n return \"Creating table users...\""],"string":"[\n \"def pre_track_containers_create_policy_stat(self, conn):\\n conn.executescript(\\\"\\\"\\\"\\n CREATE TABLE policy_stat (\\n storage_policy_index INTEGER PRIMARY KEY,\\n object_count INTEGER DEFAULT 0,\\n bytes_used INTEGER DEFAULT 0\\n );\\n INSERT OR IGNORE INTO policy_stat (\\n storage_policy_index, object_count, bytes_used\\n )\\n SELECT 0, object_count, bytes_used\\n FROM account_stat\\n WHERE container_count > 0;\\n \\\"\\\"\\\")\",\n \"def _create_schema(self): \\n q = (\\\"CREATE TABLE IF NOT EXISTS \\\" + \\\\\\n \\\"profiles (username text, body text, epoch numeric)\\\",)\\n for x in q: self.cursor.execute(x)\\n self.conn.commit()\",\n \"def prespi_AccountBroker_initialize(self, conn, put_timestamp, **kwargs):\\n if not self.account:\\n raise ValueError(\\n 'Attempting to create a new database with no account set')\\n self.create_container_table(conn)\\n self.create_account_stat_table(conn, put_timestamp)\",\n \"def setup_table(self):\\n self.interface.start_transaction()\\n self.interface.drop_table(_history_table)\\n self.interface.drop_table(_history_stats_table)\\n self.interface.create_table(_history_table)\\n self.interface.create_index('index1', _history_table, [_history_table['timestamp']])\\n self.interface.create_table(_history_stats_table)\\n self.interface.create_index('index2', _history_stats_table, [_history_stats_table['benchmark']])\\n self.interface.commit_transaction()\",\n \"async def statinit(client):\\n conn = client.bot.dbs[client.server_tag]\\n print(('Initializing stat columns in \\\\'users\\\\''\\n f' in /persist/db/{client.server_tag}.db...'))\\n for attr in usr_attributes:\\n db.add_column(conn, 'users', attr)\\n db.ccache()\\n print('User stat initialization complete.')\",\n \"def load_status_table():\",\n \"def _populate_table_status():\\n [db_insert_or_get(Status, name=name) for name in app.config['STATUS_DICT'][1:]]\\n db.session.commit()\",\n \"def create_table(self):\\n pass\",\n \"def build_metadata():\\n metadata = sa.MetaData()\\n\\n sa.Table(\\n 'hive_blocks', metadata,\\n sa.Column('num', sa.Integer, primary_key=True, autoincrement=False),\\n sa.Column('hash', CHAR(40), nullable=False),\\n sa.Column('prev', CHAR(40)),\\n sa.Column('txs', SMALLINT, server_default='0', nullable=False),\\n sa.Column('ops', SMALLINT, server_default='0', nullable=False),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n\\n sa.UniqueConstraint('hash', name='hive_blocks_ux1'),\\n sa.ForeignKeyConstraint(['prev'], ['hive_blocks.hash'], name='hive_blocks_fk1'),\\n )\\n\\n sa.Table(\\n 'hive_accounts', metadata,\\n sa.Column('id', sa.Integer, primary_key=True),\\n sa.Column('name', VARCHAR(16), nullable=False),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n #sa.Column('block_num', sa.Integer, nullable=False),\\n sa.Column('reputation', sa.Float(precision=6), nullable=False, server_default='25'),\\n\\n sa.Column('display_name', sa.String(20)),\\n sa.Column('about', sa.String(160)),\\n sa.Column('location', sa.String(30)),\\n sa.Column('website', sa.String(100)),\\n sa.Column('profile_image', sa.String(1024), nullable=False, server_default=''),\\n sa.Column('cover_image', sa.String(1024), nullable=False, server_default=''),\\n\\n sa.Column('followers', sa.Integer, nullable=False, server_default='0'),\\n sa.Column('following', sa.Integer, nullable=False, server_default='0'),\\n\\n sa.Column('proxy', VARCHAR(16), nullable=False, server_default=''),\\n sa.Column('post_count', sa.Integer, nullable=False, server_default='0'),\\n sa.Column('proxy_weight', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('vote_weight', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('kb_used', sa.Integer, nullable=False, server_default='0'), # deprecated\\n sa.Column('rank', sa.Integer, nullable=False, server_default='0'),\\n\\n sa.Column('lastread_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\\n sa.Column('active_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\\n sa.Column('cached_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\\n sa.Column('raw_json', sa.Text),\\n\\n\\n sa.UniqueConstraint('name', name='hive_accounts_ux1'),\\n sa.Index('hive_accounts_ix1', 'vote_weight', 'id'), # core: quick ranks\\n sa.Index('hive_accounts_ix2', 'name', 'id'), # core: quick id map\\n sa.Index('hive_accounts_ix3', 'vote_weight', 'name', postgresql_ops=dict(name='varchar_pattern_ops')), # API: lookup\\n sa.Index('hive_accounts_ix4', 'id', 'name'), # API: quick filter/sort\\n sa.Index('hive_accounts_ix5', 'cached_at', 'name'), # core/listen sweep\\n )\\n\\n sa.Table(\\n 'hive_posts', metadata,\\n sa.Column('id', sa.Integer, primary_key=True),\\n sa.Column('parent_id', sa.Integer),\\n sa.Column('author', VARCHAR(16), nullable=False),\\n sa.Column('permlink', VARCHAR(255), nullable=False),\\n sa.Column('category', VARCHAR(255), nullable=False, server_default=''),\\n sa.Column('community_id', sa.Integer, nullable=True),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n sa.Column('depth', SMALLINT, nullable=False),\\n sa.Column('is_deleted', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_pinned', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_muted', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_valid', BOOLEAN, nullable=False, server_default='1'),\\n sa.Column('promoted', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\\n\\n sa.ForeignKeyConstraint(['author'], ['hive_accounts.name'], name='hive_posts_fk1'),\\n sa.ForeignKeyConstraint(['parent_id'], ['hive_posts.id'], name='hive_posts_fk3'),\\n sa.UniqueConstraint('author', 'permlink', name='hive_posts_ux1'),\\n sa.Index('hive_posts_ix3', 'author', 'depth', 'id', postgresql_where=sql_text(\\\"is_deleted = '0'\\\")), # API: author blog/comments\\n sa.Index('hive_posts_ix4', 'parent_id', 'id', postgresql_where=sql_text(\\\"is_deleted = '0'\\\")), # API: fetching children\\n sa.Index('hive_posts_ix5', 'id', postgresql_where=sql_text(\\\"is_pinned = '1' AND is_deleted = '0'\\\")), # API: pinned post status\\n sa.Index('hive_posts_ix6', 'community_id', 'id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_pinned = '1' AND is_deleted = '0'\\\")), # API: community pinned\\n )\\n\\n sa.Table(\\n 'hive_post_tags', metadata,\\n sa.Column('post_id', sa.Integer, nullable=False),\\n sa.Column('tag', sa.String(32), nullable=False),\\n sa.UniqueConstraint('tag', 'post_id', name='hive_post_tags_ux1'), # core\\n sa.Index('hive_post_tags_ix1', 'post_id'), # core\\n )\\n\\n sa.Table(\\n 'hive_follows', metadata,\\n sa.Column('follower', sa.Integer, nullable=False),\\n sa.Column('following', sa.Integer, nullable=False),\\n sa.Column('state', SMALLINT, nullable=False, server_default='1'),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n\\n sa.UniqueConstraint('following', 'follower', name='hive_follows_ux3'), # core\\n sa.Index('hive_follows_ix5a', 'following', 'state', 'created_at', 'follower'),\\n sa.Index('hive_follows_ix5b', 'follower', 'state', 'created_at', 'following'),\\n )\\n\\n sa.Table(\\n 'hive_reblogs', metadata,\\n sa.Column('account', VARCHAR(16), nullable=False),\\n sa.Column('post_id', sa.Integer, nullable=False),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n\\n sa.ForeignKeyConstraint(['account'], ['hive_accounts.name'], name='hive_reblogs_fk1'),\\n sa.ForeignKeyConstraint(['post_id'], ['hive_posts.id'], name='hive_reblogs_fk2'),\\n sa.UniqueConstraint('account', 'post_id', name='hive_reblogs_ux1'), # core\\n sa.Index('hive_reblogs_ix1', 'post_id', 'account', 'created_at'), # API -- not yet used\\n )\\n\\n sa.Table(\\n 'hive_payments', metadata,\\n sa.Column('id', sa.Integer, primary_key=True),\\n sa.Column('block_num', sa.Integer, nullable=False),\\n sa.Column('tx_idx', SMALLINT, nullable=False),\\n sa.Column('post_id', sa.Integer, nullable=False),\\n sa.Column('from_account', sa.Integer, nullable=False),\\n sa.Column('to_account', sa.Integer, nullable=False),\\n sa.Column('amount', sa.types.DECIMAL(10, 3), nullable=False),\\n sa.Column('token', VARCHAR(5), nullable=False),\\n\\n sa.ForeignKeyConstraint(['from_account'], ['hive_accounts.id'], name='hive_payments_fk1'),\\n sa.ForeignKeyConstraint(['to_account'], ['hive_accounts.id'], name='hive_payments_fk2'),\\n sa.ForeignKeyConstraint(['post_id'], ['hive_posts.id'], name='hive_payments_fk3'),\\n )\\n\\n sa.Table(\\n 'hive_feed_cache', metadata,\\n sa.Column('post_id', sa.Integer, nullable=False),\\n sa.Column('account_id', sa.Integer, nullable=False),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n sa.UniqueConstraint('post_id', 'account_id', name='hive_feed_cache_ux1'), # core\\n sa.Index('hive_feed_cache_ix1', 'account_id', 'post_id', 'created_at'), # API (and rebuild?)\\n )\\n\\n sa.Table(\\n 'hive_posts_cache', metadata,\\n sa.Column('post_id', sa.Integer, primary_key=True, autoincrement=False),\\n sa.Column('author', VARCHAR(16), nullable=False),\\n sa.Column('permlink', VARCHAR(255), nullable=False),\\n sa.Column('category', VARCHAR(255), nullable=False, server_default=''),\\n\\n # important/index\\n sa.Column('community_id', sa.Integer, nullable=True),\\n sa.Column('depth', SMALLINT, nullable=False, server_default='0'),\\n sa.Column('children', SMALLINT, nullable=False, server_default='0'),\\n\\n # basic/extended-stats\\n sa.Column('author_rep', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('flag_weight', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('total_votes', sa.Integer, nullable=False, server_default='0'),\\n sa.Column('up_votes', sa.Integer, nullable=False, server_default='0'),\\n\\n # basic ui fields\\n sa.Column('title', sa.String(255), nullable=False, server_default=''),\\n sa.Column('preview', sa.String(1024), nullable=False, server_default=''),\\n sa.Column('img_url', sa.String(1024), nullable=False, server_default=''),\\n\\n # core stats/indexes\\n sa.Column('payout', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\\n sa.Column('promoted', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\\n sa.Column('created_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\\n sa.Column('payout_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\\n sa.Column('updated_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\\n sa.Column('is_paidout', BOOLEAN, nullable=False, server_default='0'),\\n\\n # ui flags/filters\\n sa.Column('is_nsfw', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_declined', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_full_power', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_hidden', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_grayed', BOOLEAN, nullable=False, server_default='0'),\\n\\n # important indexes\\n sa.Column('rshares', sa.BigInteger, nullable=False, server_default='0'),\\n sa.Column('sc_trend', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('sc_hot', sa.Float(precision=6), nullable=False, server_default='0'),\\n\\n # bulk data\\n sa.Column('body', TEXT),\\n sa.Column('votes', TEXT),\\n sa.Column('json', sa.Text),\\n sa.Column('raw_json', sa.Text),\\n\\n # index: misc\\n sa.Index('hive_posts_cache_ix3', 'payout_at', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # core: payout sweep\\n sa.Index('hive_posts_cache_ix8', 'category', 'payout', 'depth', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: tag stats\\n\\n # index: ranked posts\\n sa.Index('hive_posts_cache_ix2', 'promoted', postgresql_where=sql_text(\\\"is_paidout = '0' AND promoted > 0\\\")), # API: promoted\\n\\n sa.Index('hive_posts_cache_ix6a', 'sc_trend', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: trending todo: depth=0\\n sa.Index('hive_posts_cache_ix7a', 'sc_hot', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: hot todo: depth=0\\n sa.Index('hive_posts_cache_ix6b', 'post_id', 'sc_trend', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: trending, filtered todo: depth=0\\n sa.Index('hive_posts_cache_ix7b', 'post_id', 'sc_hot', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: hot, filtered todo: depth=0\\n\\n sa.Index('hive_posts_cache_ix9a', 'depth', 'payout', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: payout todo: rem depth\\n sa.Index('hive_posts_cache_ix9b', 'category', 'depth', 'payout', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: payout, filtered todo: rem depth\\n\\n sa.Index('hive_posts_cache_ix10', 'post_id', 'payout', postgresql_where=sql_text(\\\"is_grayed = '1' AND payout > 0\\\")), # API: muted, by filter/date/payout\\n\\n # index: stats\\n sa.Index('hive_posts_cache_ix20', 'community_id', 'author', 'payout', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: pending distribution; author payout\\n\\n # index: community ranked posts\\n sa.Index('hive_posts_cache_ix30', 'community_id', 'sc_trend', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\\\")), # API: community trend\\n sa.Index('hive_posts_cache_ix31', 'community_id', 'sc_hot', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\\\")), # API: community hot\\n sa.Index('hive_posts_cache_ix32', 'community_id', 'created_at', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\\\")), # API: community created\\n sa.Index('hive_posts_cache_ix33', 'community_id', 'payout', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '0' AND is_paidout = '0'\\\")), # API: community payout\\n sa.Index('hive_posts_cache_ix34', 'community_id', 'payout', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '1' AND is_paidout = '0'\\\")), # API: community muted\\n )\\n\\n sa.Table(\\n 'hive_state', metadata,\\n sa.Column('block_num', sa.Integer, primary_key=True, autoincrement=False),\\n sa.Column('db_version', sa.Integer, nullable=False),\\n sa.Column('steem_per_mvest', sa.types.DECIMAL(8, 3), nullable=False),\\n sa.Column('usd_per_steem', sa.types.DECIMAL(8, 3), nullable=False),\\n sa.Column('sbd_per_steem', sa.types.DECIMAL(8, 3), nullable=False),\\n sa.Column('dgpo', sa.Text, nullable=False),\\n )\\n\\n metadata = build_metadata_community(metadata)\\n\\n metadata = build_metadata_blacklist(metadata)\\n\\n metadata = build_trxid_block_num(metadata)\\n\\n return metadata\",\n \"def create_table(self):\\n from deployflag.models.metadata import (\\n GridSearchParameter,\\n ModelFramework,\\n ModelPerformanceMetadata,\\n )\\n\\n with self.connection:\\n self.connection.create_tables(\\n [ModelPerformanceMetadata, GridSearchParameter, ModelFramework],\\n safe=True,\\n )\",\n \"def __create_wallets_table(self):\\n cmd = \\\"\\\"\\\" CREATE TABLE IF NOT EXISTS %s (\\n %s text PRIMARY KEY,\\n %s blob,\\n %s blob);\\\"\\\"\\\" %(TABLE_WALLETS,\\n COL_WALLETS_NAME,\\n COL_WALLETS_PUB_KEY,\\n COL_WALLETS_PVT_KEY)\\n self.__dbcursor.execute(cmd)\",\n \"def create_statistics(self):\\n now = datetime.now()\\n min_timestamp = Statistic.objects.all().aggregate(Max('timestamp_end'))[\\\"timestamp_end__max\\\"]\\n max_timestamp = (now + ((datetime.min - now) % timedelta(minutes=60)) - timedelta(minutes=60)).replace(tzinfo=pytz.UTC)\\n\\n if min_timestamp is None:\\n min_timestamp = datetime(2000, 1, 1, tzinfo=timezone('UTC'))\\n\\n aggregated_measurements = MeasurementService.get_aggregate_measurements(min_timestamp,max_timestamp)\\n StatisticService.create_statistics(aggregated_measurements)\",\n \"def _setup_user_bookmark_count(self):\\r\\n test_date_1 = datetime(2013, 11, 25)\\r\\n stat1 = factory.make_user_bookmark_count(username=u'admin',\\r\\n data=20,\\r\\n tstamp=test_date_1)\\r\\n test_date_2 = datetime(2013, 11, 15)\\r\\n stat2 = factory.make_user_bookmark_count(username=u'admin',\\r\\n data=30,\\r\\n tstamp=test_date_2)\\r\\n test_date_3 = datetime(2013, 12, 28)\\r\\n stat3 = factory.make_user_bookmark_count(username=u'admin',\\r\\n data=15,\\r\\n tstamp=test_date_3)\\r\\n transaction.commit()\\r\\n return [stat1, stat2, stat3]\",\n \"def generate_cap_table(logger: Logger,\\n dbsession: Session,\\n token_address: str,\\n order_by: str,\\n order_direction: str,\\n identity_provider: IdentityProvider,\\n include_empty: bool,\\n TokenScanStatus: type,\\n TokenHolderAccount: type,\\n no_name=\\\"<Unknown>\\\") -> CapTableInfo:\\n\\n status = dbsession.query(TokenScanStatus).filter_by(address=token_address).one_or_none() # type: TokenScanStatus\\n if not status or status.end_block is None:\\n raise NeedsTokenScan(\\n \\\"No token {} balances available in the local database. Please run tokfetch token-scan first.\\\".format(\\n token_address))\\n\\n q = status.get_accounts(include_empty)\\n\\n results = []\\n total_balance = Decimal(0)\\n last_token_transfer_at = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)\\n for holder in q:\\n\\n id_check = identity_provider.get_identity(holder.address)\\n if id_check:\\n name = id_check.name\\n else:\\n name = no_name\\n\\n decimal_balance = holder.get_decimal_balance()\\n\\n entry = CapTableEntry(name, holder.address, decimal_balance, holder.last_block_updated_at)\\n\\n if entry.updated_at > last_token_transfer_at:\\n last_token_transfer_at = entry.updated_at\\n results.append(entry)\\n\\n if decimal_balance > 0: # Ignore cases where we cannot detect mint transaction\\n total_balance += decimal_balance\\n\\n sort_entries(results, order_by, order_direction)\\n\\n # Retrofit decimal balances after we know the total sum\\n if total_balance > 0:\\n for r in results:\\n r.percent = r.balance / total_balance\\n\\n info = CapTableInfo(status, last_token_transfer_at, total_balance, results)\\n\\n return info\",\n \"async def _create_tables_declarative(self, base, engine):\\n if hasattr(base, 'metadata'):\\n base.metadata.create_all(bind=engine, checkfirst=True)\\n return\",\n \"def _create_table(self):\\n query = f\\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {TABLE}(\\n member_Id INT,\\n memberName VARCHAR(50),\\n amount INT,\\n date datetime NOT NULL,\\n time datetime NOT NULL,\\n status VARCHAR(20) NOT NULL DEFAULT 'Completed'\\n );\\\"\\\"\\\"\\n\\n self.cursor.execute(query)\\n self.conn.commit()\",\n \"def describe_account_attributes():\\n pass\",\n \"def create_meta_loan_table(self):\\n table_exists = self.check_if_table_exists(\\\"meta_loan_tables\\\")\\n\\n if not table_exists:\\n self.read_sql_from_file('create_meta_loan_tables.sql')\\n return\",\n \"def add_statistics(self, stat_col):\\n self.module.add_statistics(stat_col)\",\n \"def create_table(response_json):\\n account_table = PrettyTable()\\n account_table.field_names = ([\\\"Account ID\\\", \\\"Account Name\\\"])\\n for account in response_json['result']['accounts']:\\n account_id = account['accountID']\\n account_name = account['username']\\n account_table.add_row([account_id, account_name])\\n return account_table\",\n \"def init():\\n database.create_tables([Tracker])\\n database.commit()\",\n \"def create_marker_table(self):\\n if self.marker_table is None:\\n self.marker_table = luigi.configuration.get_config().get('sqlalchemy', 'marker-table', 'table_updates')\\n\\n engine = self.engine\\n\\n with engine.begin() as con:\\n metadata = sqlalchemy.MetaData()\\n if not con.dialect.has_table(con, self.marker_table):\\n self.marker_table_bound = sqlalchemy.Table(\\n self.marker_table, metadata,\\n sqlalchemy.Column(\\\"ParquetSource\\\", sqlalchemy.String(128), primary_key=True),\\n sqlalchemy.Column(\\\"TargetTable\\\", sqlalchemy.String(128)),\\n sqlalchemy.Column(\\\"Environment\\\", sqlalchemy.String(128)),\\n sqlalchemy.Column(\\\"BackupDate\\\", sqlalchemy.DateTime),\\n sqlalchemy.Column(\\\"InsertedDate\\\", sqlalchemy.DateTime, default=datetime.now()))\\n metadata.create_all(engine)\\n else:\\n metadata.reflect(only=[self.marker_table], bind=engine)\\n self.marker_table_bound = metadata.tables[self.marker_table]\",\n \"def __init__(self, config_path: str = \\\"config.yml\\\", config_dict: dict = None,\\n create_all: bool = True):\\n\\n # Prepare user_details configured in config.yml for user_details table creation\\n self.config = Config(config_path, config_dict)\\n user_details_list = []\\n if \\\"twitter_user_details\\\" in self.config.config:\\n for detail, sqldatatype in self.config.config[\\\"twitter_user_details\\\"].items():\\n if sqldatatype is not None:\\n user_details_list.append(detail + \\\" \\\" + sqldatatype)\\n else:\\n print(\\\"\\\"\\\"Key \\\"twitter_user_details\\\" could not be found in config.yml. Will not create\\n a user_details table.\\\"\\\"\\\")\\n\\n # Table creation for SQLITE database type.\\n # Note and TODO: the collector does not support sqlite (yet)\\n if self.config.dbtype.lower() == \\\"sqlite\\\":\\n try:\\n self.engine = lite.connect(self.config.dbname + \\\".db\\\")\\n print(\\\"Connected to \\\" + self.config.dbname + \\\"!\\\")\\n except Error as e:\\n raise e\\n if create_all:\\n try:\\n create_friends_table_sql = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS friends (\\n source BIGINT NOT NULL,\\n target BIGINT NOT NULL,\\n burned TINYINT NOT NULL,\\n timestamp DATETIME DEFAULT CURRENT_TIMESTAMP\\n );\\\"\\\"\\\"\\n create_friends_index_sql_1 = \\\"CREATE INDEX iFSource ON friends(source);\\\"\\n create_friends_index_sql_2 = \\\"CREATE INDEX iFTimestamp ON friends(timestamp);\\\"\\n create_results_table_sql = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS result (\\n source BIGINT NOT NULL,\\n target BIGINT NOT NULL,\\n timestamp DATETIME DEFAULT CURRENT_TIMESTAMP\\n );\\\"\\\"\\\"\\n create_results_index_sql_1 = \\\"CREATE INDEX iRSource ON result(source);\\\"\\n create_results_index_sql_2 = \\\"CREATE INDEX iRTimestamp ON result(timestamp);\\\"\\n c = self.engine.cursor()\\n c.execute(create_friends_table_sql)\\n c.execute(create_friends_index_sql_1)\\n c.execute(create_friends_index_sql_2)\\n c.execute(create_results_table_sql)\\n c.execute(create_results_index_sql_1)\\n c.execute(create_results_index_sql_2)\\n if user_details_list != []:\\n create_user_details_sql = \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS user_details\\n (\\\"\\\"\\\" + \\\", \\\".join(user_details_list) + \\\"\\\"\\\",\\n timestamp DATETIME DEFAULT CURRENT_TIMESTAMP);\\\"\\\"\\\"\\n create_ud_index = \\\"CREATE INDEX iUTimestamp ON user_details(timestamp)\\\"\\n c.execute(create_user_details_sql)\\n c.execute(create_ud_index)\\n else:\\n # TODO: Make this a minimal user_details table?\\n print(\\\"\\\"\\\"No user_details configured in config.yml. Will not create a\\n user_details table.\\\"\\\"\\\")\\n except Error as e:\\n print(e)\\n\\n # Table creation for mysql database type\\n elif self.config.dbtype.lower() == \\\"mysql\\\":\\n try:\\n self.engine = create_engine(\\n f'mysql+pymysql://{self.config.dbuser}:'\\n f'{self.config.dbpwd}@{self.config.dbhost}/{self.config.dbname}'\\n )\\n print('Connected to database \\\"' + self.config.dbname + '\\\" via mySQL!')\\n except OperationalError as e:\\n raise e\\n if create_all:\\n try:\\n create_friends_table_sql = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS friends (\\n source BIGINT NOT NULL,\\n target BIGINT NOT NULL,\\n burned TINYINT NOT NULL,\\n timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP\\n ON UPDATE CURRENT_TIMESTAMP,\\n UNIQUE INDEX fedge (source, target),\\n INDEX(timestamp)\\n );\\\"\\\"\\\"\\n create_results_table_sql = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS result (\\n source BIGINT NOT NULL,\\n target BIGINT NOT NULL,\\n timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\\n UNIQUE INDEX redge (source, target),\\n INDEX(timestamp)\\n );\\\"\\\"\\\"\\n self.engine.execute(create_friends_table_sql)\\n self.engine.execute(create_results_table_sql)\\n if user_details_list != []:\\n create_user_details_sql = \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS user_details\\n (\\\"\\\"\\\" + \\\", \\\".join(user_details_list) + \\\"\\\"\\\", timestamp TIMESTAMP\\n DEFAULT CURRENT_TIMESTAMP,\\n INDEX(timestamp));\\\"\\\"\\\"\\n self.engine.execute(create_user_details_sql)\\n else:\\n print(\\\"\\\"\\\"No user_details configured in config.yml. Will not create a\\n user_details table.\\\"\\\"\\\")\\n except OperationalError as e:\\n raise e\",\n \"def _populate_new_notifications_imei_table(self, conn):\\n with CodeProfiler() as cp:\\n tblname = self._notifications_imei_new_tblname\\n num_records = self._populate_new_blacklist_or_notifications_imei_table(conn, tblname, is_blacklist=False)\\n\\n return num_records, cp.duration\",\n \"def createTable(self):\\n results = self.db.table_create(self.entity).run(self.r)\\n time.sleep(5)\\n return results\",\n \"def get_table(base, engine):\\n class w1_temp_table(base):\\n __tablename__ = 'w1_temp'\\n __table_args__ = {\\\"useexisting\\\": True}\\n\\n id = sa.Column(sa.types.Integer, primary_key=True)\\n logger_id = sa.Column(sa.types.Integer)\\n value = sa.Column(sa.types.String)\\n datetime = sa.Column(sa.types.DateTime)\\n return w1_temp_table\",\n \"def populate_stat(self, table):\\n myrow = table.row\\n # HDF5 doesn't handle unicode strings, so we need to convert to \\n # *byte* strings, which we can put in the HDF5 file \\n addy = numpy.zeros(len(self.address), \\n dtype=(numpy.str, glob.nchar_address))\\n for i in range(len(addy)):\\n addy[i] = (self.address[i]).encode('utf8')\\n\\n myrow[\\\"address\\\"] = addy\\n myrow[\\\"bike_stands\\\"] = self.bike_stands\\n myrow[\\\"number\\\"] = self.number\\n myrow[\\\"position\\\"] = self.position\\n myrow.append()\\n table.flush()\",\n \"def accounts():\",\n \"def __create(self):\\n cursor = self.conn.cursor()\\n sql = 'CREATE TABLE IF NOT EXISTS speedlogs ' + \\\\\\n '(id INTEGER primary key, measure_dt TIMESTAMP, ping REAL, download REAL, upload REAL)'\\n cursor.execute(sql)\\n self.conn.commit()\",\n \"async def create_sys_tables(self) -> None:\\n await self.conn.execute(\\\"\\\"\\\"CREATE TABLE IF NOT EXISTS tinymud_migrations (\\n table_name TEXT,\\n level INTEGER\\n )\\\"\\\"\\\")\",\n \"def account_summary(self):\\n pass\",\n \"def baseline_statistics(self, **_):\\n raise NotImplementedError(\\\"{} doesn't support statistics.\\\".format(__class__.__name__))\",\n \"def _create_intermediate_new_tables_structure(self, conn):\\n table_names = []\\n with conn.cursor() as cursor, CodeProfiler() as cp:\\n tblname = self._blacklist_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n is_valid BOOLEAN,\\n imei_norm_with_check_digit TEXT\\n ) PARTITION BY RANGE (virt_imei_shard)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._notifications_lists_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n operator_id TEXT NOT NULL,\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n msisdn TEXT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n is_valid BOOLEAN,\\n amnesty_granted BOOLEAN,\\n imei_norm_with_check_digit TEXT\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._notifications_lists_new_part_tblname,\\n is_unlogged=True)\\n\\n tblname = self._exceptions_lists_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n operator_id TEXT NOT NULL,\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n is_valid BOOLEAN,\\n imei_norm_with_check_digit TEXT,\\n is_blacklisted BOOLEAN\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._exceptions_lists_new_part_tblname,\\n is_unlogged=True)\\n\\n tblname = self._blocking_conditions_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n cond_name TEXT NOT NULL,\\n reason TEXT NOT NULL\\n )\\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n\\n tblname = self._mnc_mcc_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n mcc_mnc_pattern TEXT NOT NULL,\\n operator_id TEXT NOT NULL\\n )\\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n\\n tblname = self._notifications_imei_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n is_valid BOOLEAN,\\n amnesty_granted BOOLEAN,\\n imei_norm_with_check_digit TEXT\\n ) PARTITION BY RANGE (virt_imei_shard)\\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._notifications_triplets_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n msisdn TEXT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n is_valid BOOLEAN,\\n amnesty_granted BOOLEAN,\\n imei_norm_with_check_digit TEXT,\\n home_operator TEXT,\\n fallback_operators TEXT[]\\n ) PARTITION BY RANGE (virt_imei_shard)\\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._pairings_imei_imsi_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n is_valid BOOLEAN,\\n imei_norm_with_check_digit TEXT,\\n home_operator TEXT,\\n is_blacklisted BOOLEAN\\n ) PARTITION BY RANGE (virt_imei_shard) \\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True, fillfactor=45)\\n table_names.append(tblname)\\n\\n self._intermediate_table_names.extend(table_names)\\n return -1, cp.duration\",\n \"def __create_table(self):\\n\\n self.connection = self.db.connect()\\n self.metadata = MetaData(self.connection)\\n\\n self.system = Table(self.table_name, self.metadata,\\n Column('timestamp', DateTime(), primary_key=True, nullable=False),\\n Column('vibration_sensor', Float()),\\n Column('flow', Float()),\\n Column('pressure', Float()),\\n Column('power_consumption', Float()),\\n Column('failure_times', Float()),\\n Column('operational', Boolean())\\n )\\n\\n self.metadata.create_all()\",\n \"def create_tables_and_apply_patches(self):\\n\\n if self.authorized and not self.db_tables_initiated:\\n with self.connection.cursor() as cursor:\\n for statement in self.parse_mysql_sql_file():\\n cursor.execute(statement)\\n\\n PyFunceble.LOGGER.info(\\n \\\"Created the missing tables. Applied all patched\\\"\\n )\\n\\n self.db_tables_initiated = True\",\n \"def _create_meta_data_table(self) -> None:\\n self.dynamodb.create_table(\\n TableName=self.gene_metadata_table,\\n KeySchema=[\\n {\\\"AttributeName\\\": \\\"src_name\\\", \\\"KeyType\\\": \\\"HASH\\\"} # Partition key\\n ],\\n AttributeDefinitions=[\\n {\\\"AttributeName\\\": \\\"src_name\\\", \\\"AttributeType\\\": \\\"S\\\"},\\n ],\\n ProvisionedThroughput={\\\"ReadCapacityUnits\\\": 10, \\\"WriteCapacityUnits\\\": 10},\\n )\",\n \"def __update_accounts(self):\\n\\t\\tfor acct in self.wallet:\\n\\t\\t\\tif len(get_unspent(acct[\\\"address\\\"], self.testnet))!=0:\\n\\t\\t\\t\\tacct[\\\"status\\\"] = \\\"in use\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\tspent = get_spent(acct[\\\"address\\\"], self.testnet)\\n\\t\\t\\t\\tconfirm = (s[\\\"confirmations\\\"] >= 6 for s in spent)\\n\\t\\t\\t\\tif len(spent) > 0 and all(confirm):\\n\\t\\t\\t\\t\\tacct[\\\"status\\\"] = \\\"used\\\"\\n\\t\\t\\t\\telif len(spent) > 0:\\n\\t\\t\\t\\t\\tacct[\\\"status\\\"] = \\\"in use\\\"\\n\\t\\tself.header[\\\"LAST_UPDATE_TIME\\\"] = str(round(time.time()))\\n\\t\\toutput = [self.header, *self.wallet]\\n\\t\\twith open(self.filepath, 'w+') as f:\\n\\t\\t\\tjson.dump(output, f)\",\n \"def cutadapt_general_stats_table(self):\\n\\n headers = {}\\n headers['percent_trimmed'] = {\\n 'title': 'Trimmed',\\n 'description': '% Total Base Pairs trimmed',\\n 'max': 30,\\n 'min': 0,\\n 'scale': 'RdYlBu-rev',\\n 'format': '{:.1f}%'\\n }\\n self.general_stats_addcols(self.cutadapt_data, headers)\",\n \"def __init__(self, database='/tmp/blingalytics_cache'):\\n self.database = database\\n self._create_metadata_table()\",\n \"def collect_stat(self):\\n\\n cnstat_dict, ratestat_dict = self.get_cnstat()\\n self.cnstat_dict.update(cnstat_dict)\\n self.ratestat_dict.update(ratestat_dict)\",\n \"def _populate_new_blacklist(self, conn):\\n with CodeProfiler() as cp:\\n tblname = self._blacklist_new_tblname\\n num_records = self._populate_new_blacklist_or_notifications_imei_table(conn,\\n tblname, is_blacklist=True)\\n\\n return num_records, cp.duration\",\n \"def add_statistics(self, stat_col):\\n # Those will be displayed.\\n stat_col.add_statistics(self.key_precision, '{:05.4f}')\\n stat_col.add_statistics(self.key_recall, '{:05.4f}')\\n stat_col.add_statistics(self.key_f1score, '{:05.4f}')\\n # That one will be collected and used by aggregator.\\n stat_col.add_statistics(self.key_f1score+'_support', None)\",\n \"def _create_tables_classic(self, engine, metadata):\\n if engine and metadata:\\n with (yield from engine) as conn:\\n for x in self._models.values():\\n try:\\n yield from conn.execute(CreateTable(x))\\n except ProgrammingError as error:\\n if hasattr(self.app, 'log') and self.app.log:\\n if self.app.debug:\\n self.app.log.info(\\\"[PostgressPlugin] [ `{}` already exists]\\\".format(x))\\n else:\\n if self.app.debug:\\n print(\\\"[PostgressPlugin] [ `{}` already exists]\\\".format(x))\\n return\",\n \"def create_table():\\n sql = sqlite3.connect('data.db')\\n cursor = sql.cursor()\\n logging.debug(\\\"Successfully Connected to SQLite\\\")\\n\\n cursor.execute(\\n '''CREATE TABLE Status\\n ([ip] text, [port] integer, [count_requests] integer, [t_start] integer, [protocol] text)'''\\n )\\n\\n cursor.close()\",\n \"def pre_track_containers_create_container_table(self, conn):\\n # revert to old trigger script to support one of the tests\\n OLD_POLICY_STAT_TRIGGER_SCRIPT = \\\"\\\"\\\"\\n CREATE TRIGGER container_insert_ps AFTER INSERT ON container\\n BEGIN\\n INSERT OR IGNORE INTO policy_stat\\n (storage_policy_index, object_count, bytes_used)\\n VALUES (new.storage_policy_index, 0, 0);\\n UPDATE policy_stat\\n SET object_count = object_count + new.object_count,\\n bytes_used = bytes_used + new.bytes_used\\n WHERE storage_policy_index = new.storage_policy_index;\\n END;\\n CREATE TRIGGER container_delete_ps AFTER DELETE ON container\\n BEGIN\\n UPDATE policy_stat\\n SET object_count = object_count - old.object_count,\\n bytes_used = bytes_used - old.bytes_used\\n WHERE storage_policy_index = old.storage_policy_index;\\n END;\\n\\n \\\"\\\"\\\"\\n conn.executescript(\\\"\\\"\\\"\\n CREATE TABLE container (\\n ROWID INTEGER PRIMARY KEY AUTOINCREMENT,\\n name TEXT,\\n put_timestamp TEXT,\\n delete_timestamp TEXT,\\n object_count INTEGER,\\n bytes_used INTEGER,\\n deleted INTEGER DEFAULT 0,\\n storage_policy_index INTEGER DEFAULT 0\\n );\\n\\n CREATE INDEX ix_container_deleted_name ON\\n container (deleted, name);\\n\\n CREATE TRIGGER container_insert AFTER INSERT ON container\\n BEGIN\\n UPDATE account_stat\\n SET container_count = container_count + (1 - new.deleted),\\n object_count = object_count + new.object_count,\\n bytes_used = bytes_used + new.bytes_used,\\n hash = chexor(hash, new.name,\\n new.put_timestamp || '-' ||\\n new.delete_timestamp || '-' ||\\n new.object_count || '-' || new.bytes_used);\\n END;\\n\\n CREATE TRIGGER container_update BEFORE UPDATE ON container\\n BEGIN\\n SELECT RAISE(FAIL, 'UPDATE not allowed; DELETE and INSERT');\\n END;\\n\\n\\n CREATE TRIGGER container_delete AFTER DELETE ON container\\n BEGIN\\n UPDATE account_stat\\n SET container_count = container_count - (1 - old.deleted),\\n object_count = object_count - old.object_count,\\n bytes_used = bytes_used - old.bytes_used,\\n hash = chexor(hash, old.name,\\n old.put_timestamp || '-' ||\\n old.delete_timestamp || '-' ||\\n old.object_count || '-' || old.bytes_used);\\n END;\\n \\\"\\\"\\\" + OLD_POLICY_STAT_TRIGGER_SCRIPT)\",\n \"async def _create_table(self, table: TableSchema) -> None:\\n try:\\n await self.conn.execute(get_create_table(table))\\n except PostgresError: # Only DB related exceptions\\n print(f\\\"Failed to execute CREATE TABLE for {table['name']}\\\")\\n raise\\n # Initialize migration level (so that it can be altered in future)\\n await self.conn.execute('INSERT INTO tinymud_migrations (table_name, level) VALUES ($1, $2)', table['name'], 0)\",\n \"def populate_twitter_account_to_db():\\n api = twitter.Api(**settings.TWITTER_OAUTH, sleep_on_rate_limit=False)\\n with open(NEWSFEED['TWITTER']['ACCOUNT_LIST'], 'r') as f:\\n lines = f.readlines()\\n for l in lines:\\n screen_name = l.strip()\\n\\n if CredibleUSTwitterAccount.objects.filter(screen_name=screen_name).exists():\\n continue\\n\\n try:\\n twitteruser = api.GetUser(screen_name=screen_name)\\n CredibleUSTwitterAccount.objects.create(screen_name=twitteruser.screen_name,\\n uid=twitteruser.id,\\n description=twitteruser.description)\\n except TwitterError as e:\\n print(e.message)\",\n \"def analyze_table(self):\\n\\n # Analyze table has a query result, we have to use query here.\\n # Otherwise we'll get a out of sync error\\n self.query(sql.analyze_table(self.new_table_name))\\n self.query(sql.analyze_table(self.delta_table_name))\",\n \"def create_base_table(self, table_name):\\n print('new')\\n # Create table at first.\\n select_stm = self.construct_base_table()\\n exec_query('DROP TABLE IF EXISTS %s;' % table_name) \\n sql = \\\"\\\"\\\"\\n CREATE TABLE %s AS\\n %s\\n \\\"\\\"\\\" % (table_name, select_stm)\\n exec_query(sql)\",\n \"def __create_recentconn_table(self):\\r\\n QtSql.QSqlQuery('''CREATE TABLE IF NOT EXISTS recentconn\\r\\n (host varchar(255),\\r\\n port int,\\r\\n passphrase varchar(255),\\r\\n UNIQUE (host, port) ON CONFLICT REPLACE)''')\",\n \"def _prepare_stats_table(self, pinfos):\\n\\n stats_tbl = OrderedDict()\\n stats_tbl[\\\"Title\\\"] = OrderedDict()\\n for res in self.rsts:\\n stats_tbl[res.reportid] = OrderedDict()\\n\\n for pinfo in pinfos:\\n for colname in (pinfo[\\\"colname\\\"], pinfo[\\\"xcolname\\\"]):\\n if colname in stats_tbl[\\\"Title\\\"]:\\n continue\\n\\n # Each column name is represented by a row in the statistics table. Fill the \\\"Title\\\"\\n # column.\\n title_dict = stats_tbl[\\\"Title\\\"][colname] = OrderedDict()\\n defs = self._refdefs.info[colname]\\n\\n if defs.get(\\\"unit\\\") == \\\"nanosecond\\\":\\n # Convert nanoseconds to microseconds.\\n unit = \\\"us\\\"\\n else:\\n unit = defs.get(\\\"short_unit\\\", \\\"\\\")\\n\\n title_dict[\\\"colname\\\"] = colname\\n if unit:\\n title_dict[\\\"colname\\\"] += f\\\", {unit}\\\"\\n title_dict[\\\"coldescr\\\"] = defs[\\\"descr\\\"]\\n\\n title_dict[\\\"funcs\\\"] = OrderedDict()\\n for funcname in self._stats_funcs:\\n if funcname in self.rsts[0].cstats[colname]:\\n title_dict[\\\"funcs\\\"][funcname] = RORawResult.get_stat_func_descr(funcname)\\n\\n # Now fill the values for each result.\\n for res in self.rsts:\\n res_dict = stats_tbl[res.reportid][colname] = OrderedDict()\\n res_dict[\\\"funcs\\\"] = OrderedDict()\\n\\n for funcname in title_dict[\\\"funcs\\\"]:\\n val = res.cstats[colname][funcname]\\n fmt = \\\"{}\\\"\\n if defs.get(\\\"unit\\\") == \\\"nanosecond\\\" and \\\"index\\\" not in funcname:\\n val /= 1000\\n fmt = \\\"{:.2f}\\\"\\n if defs[\\\"type\\\"] == \\\"float\\\":\\n fmt = \\\"{:.2f}\\\"\\n\\n fdict = res_dict[\\\"funcs\\\"][funcname] = OrderedDict()\\n fdict[\\\"val\\\"] = fmt.format(val)\\n fdict[\\\"raw_val\\\"] = val\\n\\n if self._refres.reportid == res.reportid:\\n fdict[\\\"hovertext\\\"] = \\\"This is the reference result, other results \\\" \\\\\\n \\\"are compared to this one.\\\"\\n continue\\n\\n ref_fdict = stats_tbl[self._refres.reportid][colname][\\\"funcs\\\"][funcname]\\n change = val - ref_fdict[\\\"raw_val\\\"]\\n if ref_fdict[\\\"raw_val\\\"]:\\n percent = (change / ref_fdict[\\\"raw_val\\\"]) * 100\\n else:\\n percent = change\\n change = fmt.format(change) + unit\\n percent = \\\"{:.1f}%\\\".format(percent)\\n fdict[\\\"hovertext\\\"] = f\\\"Change: {change} ({percent})\\\"\\n\\n return stats_tbl\",\n \"def _upsert_account_structure(campaign_data, con: sqlite3.Connection):\\n con.execute(\\\"\\\"\\\"\\nCREATE TABLE IF NOT EXISTS account_structure (\\n ad_id BIGINT NOT NULL,\\n ad TEXT NOT NULL,\\n ad_set_id BIGINT NOT NULL,\\n ad_set TEXT NOT NULL,\\n campaign_id BIGINT NOT NULL,\\n campaign TEXT NOT NULL,\\n account_id BIGINT NOT NULL,\\n account TEXT NOT NULL,\\n attributes JSON,\\n PRIMARY KEY (ad_id)\\n);\\\"\\\"\\\")\\n con.execute(\\\"INSERT OR REPLACE INTO account_structure VALUES (?,?,?,?,?,?,?,?,?)\\\",\\n campaign_data)\",\n \"def test_custom_metadata_schema(self):\\n # The use-case for this functionality is to allow using\\n # Foreign Data Wrappers, each with a full set of Django\\n # tables, to copy between databases using SQLAlchemy\\n # and the automatically generation of aldjemy.\\n metadata = MetaData(schema=\\\"arbitrary\\\")\\n sa_models = construct_models(metadata)\\n self.assertEqual(sa_models[Log].__table__.schema, \\\"arbitrary\\\")\",\n \"def createFriendsTable(conn):\\n \\n c = conn.cursor()\\n \\n c.execute(\\\"CREATE TABLE friend (name TEXT, country TEXT, age INT)\\\") \\n conn.commit()\",\n \"async def update_trade_stats(self):\\n\\n summary_keys = [base for base in config['min_base_volumes']] + ['global']\\n summaries = {\\n key: {\\n 'open_count': 0,\\n 'buys': 0,\\n 'rebuys': 0,\\n 'sells': 0,\\n 'collect_sells': 0,\\n 'soft_stop_sells': 0,\\n 'total_profit': 0.0,\\n 'total_loss': 0.0,\\n 'total_fees': 0.0,\\n 'balancer_refills': 0,\\n 'balancer_remits': 0,\\n 'balancer_stop_losses': 0,\\n 'balancer_profit': 0.0,\\n 'balancer_loss': 0.0,\\n 'balancer_fees': 0.0,\\n } for key in summary_keys\\n }\\n\\n for pair in self.trades:\\n if pair not in self.trade_stats[self.time_prefix]:\\n continue\\n\\n base = pair.split('-', 1)[0]\\n open_count = len(self.trades[pair]['open'])\\n\\n summaries[base]['open_count'] += open_count\\n summaries[base]['buys'] += self.trade_stats[self.time_prefix][pair]['buys']\\n summaries[base]['rebuys'] += self.trade_stats[self.time_prefix][pair]['rebuys']\\n summaries[base]['sells'] += self.trade_stats[self.time_prefix][pair]['sells']\\n summaries[base]['collect_sells'] += self.trade_stats[self.time_prefix][pair]['collect_sells']\\n summaries[base]['soft_stop_sells'] += self.trade_stats[self.time_prefix][pair]['soft_stop_sells']\\n summaries[base]['total_profit'] += self.trade_stats[self.time_prefix][pair]['total_profit']\\n summaries[base]['total_loss'] += self.trade_stats[self.time_prefix][pair]['total_loss']\\n summaries[base]['total_fees'] += self.trade_stats[self.time_prefix][pair]['total_fees']\\n summaries[base]['balancer_refills'] += self.trade_stats[self.time_prefix][pair]['balancer_refills']\\n summaries[base]['balancer_remits'] += self.trade_stats[self.time_prefix][pair]['balancer_remits']\\n summaries[base]['balancer_profit'] += self.trade_stats[self.time_prefix][pair]['balancer_profit']\\n summaries[base]['balancer_loss'] += self.trade_stats[self.time_prefix][pair]['balancer_loss']\\n summaries[base]['balancer_fees'] += self.trade_stats[self.time_prefix][pair]['balancer_fees']\\n\\n summaries['global']['open_count'] += open_count\\n summaries['global']['buys'] += self.trade_stats[self.time_prefix][pair]['buys']\\n summaries['global']['rebuys'] += self.trade_stats[self.time_prefix][pair]['rebuys']\\n summaries['global']['sells'] += self.trade_stats[self.time_prefix][pair]['sells']\\n summaries['global']['collect_sells'] += self.trade_stats[self.time_prefix][pair]['collect_sells']\\n summaries['global']['soft_stop_sells'] += self.trade_stats[self.time_prefix][pair]['soft_stop_sells']\\n summaries['global']['total_profit'] += self.trade_stats[self.time_prefix][pair]['total_profit']\\n summaries['global']['total_loss'] += self.trade_stats[self.time_prefix][pair]['total_loss']\\n summaries['global']['total_fees'] += self.trade_stats[self.time_prefix][pair]['total_fees']\\n summaries['global']['balancer_refills'] += self.trade_stats[self.time_prefix][pair]['balancer_refills']\\n summaries['global']['balancer_remits'] += self.trade_stats[self.time_prefix][pair]['balancer_remits']\\n summaries['global']['balancer_profit'] += self.trade_stats[self.time_prefix][pair]['balancer_profit']\\n summaries['global']['balancer_loss'] += self.trade_stats[self.time_prefix][pair]['balancer_loss']\\n summaries['global']['balancer_fees'] += self.trade_stats[self.time_prefix][pair]['balancer_fees']\\n\\n for key in summaries:\\n self.trade_stats[self.time_prefix][key]['buys'] = summaries[key]['buys']\\n self.trade_stats[self.time_prefix][key]['rebuys'] = summaries[key]['rebuys']\\n self.trade_stats[self.time_prefix][key]['sells'] = summaries[key]['sells']\\n self.trade_stats[self.time_prefix][key]['collect_sells'] = summaries[key]['collect_sells']\\n self.trade_stats[self.time_prefix][key]['soft_stop_sells'] = summaries[key]['soft_stop_sells']\\n self.trade_stats[self.time_prefix][key]['total_profit'] = summaries[key]['total_profit']\\n self.trade_stats[self.time_prefix][key]['total_loss'] = summaries[key]['total_loss']\\n self.trade_stats[self.time_prefix][key]['total_fees'] = summaries[key]['total_fees']\\n self.trade_stats[self.time_prefix][key]['balancer_refills'] = summaries[key]['balancer_refills']\\n self.trade_stats[self.time_prefix][key]['balancer_remits'] = summaries[key]['balancer_remits']\\n self.trade_stats[self.time_prefix][key]['balancer_profit'] = summaries[key]['balancer_profit']\\n self.trade_stats[self.time_prefix][key]['balancer_loss'] = summaries[key]['balancer_loss']\\n self.trade_stats[self.time_prefix][key]['balancer_fees'] = summaries[key]['balancer_fees']\\n\\n if summaries[key]['open_count'] > self.trade_stats[self.time_prefix][key]['most_open']:\\n self.trade_stats[self.time_prefix][key]['most_open'] = summaries[key]['open_count']\\n\\n filter_items = [pair for pair in self.trades] + [base for base in config['min_base_volumes']] + ['global']\\n self.save_attr('trade_stats', max_depth=2, filter_items=filter_items, filter_keys=[self.time_prefix])\",\n \"def add_statistics_to_status(status):\\n return [{\\n 'host': h['host'],\\n 'status': h['status'],\\n 'stats': get_statistics_for_host(h['host']),\\n } for h in status]\",\n \"def test_extra_col_updates_account_balance(self):\\n\\t\\tbanco = Bancos.objects.get(id=1)\\n\\t\\tprevious_balance = banco.balance\\n\\t\\tcondominio = Condominio.objects.get(rif='J6750435')\\n\\t\\tfactura_condominio = Factura_Condominio.objects.get(id=1)\\n\\t\\tdata ={\\n\\t\\t\\t'id':1,\\n\\t\\t\\t'factura': factura_condominio,\\n\\t\\t\\t'titulo': 'sample_extra_col',\\n\\t\\t\\t'banco':banco,\\n\\t\\t\\t'monto': decimal.Decimal(100.5)\\n\\t\\t}\\n\\t\\textra_col = Factura_Condominio_Extra_Colum.objects.create(**data)\\n\\t\\tself.assertEqual(extra_col.banco.balance, previous_balance-extra_col.monto)\",\n \"def initiate_db_account_balances(self, quote:str, started_with:str, real_balance:str, internal_balance:str):\\n\\n\\t\\tconn \\t\\t\\t = sqlite3.connect(self.name, detect_types=sqlite3.PARSE_DECLTYPES)\\n\\t\\tconn.row_factory = sqlite3.Row\\n\\t\\tc \\t\\t\\t\\t = conn.cursor()\\n\\n\\t\\tvalues = (quote,\\n\\t\\t\\t\\t started_with,\\n\\t\\t\\t\\t real_balance,\\n\\t\\t\\t\\t '0',\\n\\t\\t\\t\\t internal_balance,\\n\\t\\t\\t\\t '0',\\n\\t\\t\\t\\t '0',\\n\\t\\t\\t\\t '0',\\n\\t\\t\\t\\t '0',\\n\\t\\t\\t\\t '0',\\n\\t\\t\\t\\t quote)\\n\\t\\t# Insert a row for the quoreasset only if doesn't already exist\\n\\t\\tc.execute('INSERT INTO account_balances SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ? WHERE NOT EXISTS (SELECT * FROM account_balances WHERE quote=?)', values)\\n\\n\\t\\tconn.commit()\",\n \"async def metadata(self) -> AccountInformationMetaData:\\n\\n e = await self.request.request(url=f'https://accountinformation.roblox.com/v1/metadata', method='get')\\n return AccountInformationMetaData(item=e)\",\n \"def create_UAG_table_in_sql(sql_cursor):\\n sql_cursor.execute('''DROP TABLE IF EXISTS uag_complete;''')\\n sql_cursor.execute(\\n '''CREATE TABLE uag_complete (\\n _id integer PRIMARY KEY, \\n user_id varchar(50),\\n age_bucket varchar(20),\\n age_avg varchar(20),\\n gender_bucket varchar(20),\\n source varchar(30));\\n ''')\",\n \"def make_temp_tbl(self, type: str = \\\"user_details\\\"):\\n uid = uuid.uuid4()\\n temp_tbl_name = \\\"temp_\\\" + str(uid).replace('-', '_')\\n\\n if self.config.dbtype.lower() == \\\"mysql\\\":\\n create_temp_tbl_sql = f\\\"CREATE TABLE {temp_tbl_name} LIKE {type};\\\"\\n elif self.config.dbtype.lower() == \\\"sqlite\\\":\\n create_temp_tbl_sql = f\\\"CREATE TABLE {temp_tbl_name} AS SELECT * FROM {type} WHERE 0\\\"\\n self.engine.execute(create_temp_tbl_sql)\\n return temp_tbl_name\",\n \"def create_base_users(): # TODO: Just call create_user for each\\n with engine.connect() as connection:\\n\\n result = connection.execute(\\\"select user from pdp_users\\\")\\n user_count = len(result.fetchall())\\n if user_count == 0:\\n\\n print(\\\"Creating base users\\\")\\n\\n pu = sa.Table(\\\"pdp_users\\\", metadata, autoload=True, autoload_with=engine)\\n\\n # user\\n pw_hash = user_api.hash_password(BASEUSER_PW)\\n ins_stmt = pu.insert().values(\\n username=\\\"base_user\\\", full_name=\\\"Base User\\\", password=pw_hash, active=\\\"Y\\\", role=1,\\n )\\n connection.execute(ins_stmt)\\n\\n # INactive user\\n # Reuse pw hash\\n ins_stmt = pu.insert().values(\\n username=\\\"base_user_inact\\\", full_name=\\\"Inactive User\\\", password=pw_hash, active=\\\"N\\\", role=1,\\n )\\n connection.execute(ins_stmt)\\n\\n # editor\\n pw_hash = user_api.hash_password(BASEEDITOR_PW)\\n ins_stmt = pu.insert().values(\\n username=\\\"base_editor\\\", full_name=\\\"Base Editor\\\", password=pw_hash, active=\\\"Y\\\", role=2,\\n )\\n connection.execute(ins_stmt)\\n\\n # admin\\n pw_hash = user_api.hash_password(BASEADMIN_PW)\\n ins_stmt = pu.insert().values(\\n username=\\\"base_admin\\\", full_name=\\\"Base Admin\\\", password=pw_hash, active=\\\"Y\\\", role=9,\\n )\\n connection.execute(ins_stmt)\\n\\n else:\\n print(user_count, \\\"users already present in DB, not creating\\\")\",\n \"def configure(self, config):\\n # create the follower table if it doesn't already exist\\n model.follower_table.create(checkfirst=True)\",\n \"def add_stat(self, c_vid, stats):\\n\\n from sqlalchemy.orm.session import Session\\n\\n # Names that come from the Pandas describe() method\\n stat_map = {'25%': 'p25', '50%': 'p50', '75%': 'p75'}\\n\\n stats = {stat_map.get(k, k): v for k, v in stats.items()}\\n\\n cs = ColumnStat(p_vid=self.vid, c_vid=c_vid, **stats)\\n\\n self._stats.append(cs)\\n\\n return cs\",\n \"def create_table(opts, stats):\\n print(\\\"--------------------------------------\\\")\\n print(\\\"Creating table %s\\\" % (opts.table_name,))\\n print(\\\"--------------------------------------\\\")\\n print(timestamp())\\n create_table_ddl = \\\"CREATE TABLE %s (\\\" % (opts.table_name,)\\n num_bigint_cols = opts.columns - opts.num_string_columns\\n assert(num_bigint_cols > 0)\\n for i in range(opts.columns):\\n coltype = 'STRING'\\n if i < num_bigint_cols: coltype = 'BIGINT'\\n if i > 0: create_table_ddl += ', '\\n create_table_ddl += \\\"f%d %s\\\" % (i, coltype)\\n if i == 0: create_table_ddl += ' PRIMARY KEY'\\n create_table_ddl += \\\") PARTITION BY HASH(f0) PARTITIONS %d STORED AS KUDU \\\" % \\\\\\n (opts.partitions, )\\n create_table_ddl += \\\"TBLPROPERTIES ('kudu.num_tablet_replicas' = '%d')\\\" % \\\\\\n (opts.replication_factor, )\\n\\n cmd = 'echo \\\"%s\\\" | impala-shell -i %s -f -' % (create_table_ddl, opts.impalad_address)\\n run_command(opts, cmd)\",\n \"def create_new_user_table():\\n # Connect to database\\n conn = psycopg2.connect(DATABASE_URL, sslmode='require')\\n # Open a cursor to perform db operations\\n cur = conn.cursor()\\n # Create the table\\n cur.execute(\\\"\\\"\\\"\\n CREATE TABLE test (\\n user_id int NOT NULL PRIMARY KEY,\\n username varchar(255),\\n id_last_message_sent int,\\n id_last_message_stickered int,\\n count_since_last_stickered int\\n );\\n \\\"\\\"\\\"\\n )\\n # Commit and close connection\\n conn.commit()\\n cur.close()\\n conn.close()\",\n \"def create_dataBase(conn, create_cmd):\\n if conn:\\n cursor = conn.cursor()\\n cursor.execute(create_cmd)\\n conn.commit()\\n #print '[sql management] Table Created...'\",\n \"def sync_tables():\\n sync_table(ShoppingList)\\n sync_table(User)\\n sync_table(Category)\\n sync_table(Feed)\\n sync_table(News)\\n sync_table(Photo)\\n sync_table(Profile)\\n sync_table(Video)\\n sync_type(FeedPhoto)\\n sync_type(NewsPhoto)\",\n \"def upgrade():\\n op.add_column(\\n 'share_instances',\\n Column('access_rules_status', String(length=255))\\n )\\n\\n connection = op.get_bind()\\n share_instances_table = utils.load_table('share_instances', connection)\\n instance_access_table = utils.load_table('share_instance_access_map',\\n connection)\\n\\n # NOTE(u_glide): Data migrations shouldn't be performed on live clouds\\n # because it will lead to unpredictable behaviour of running operations\\n # like migration.\\n instances_query = (\\n share_instances_table.select()\\n .where(share_instances_table.c.status == constants.STATUS_AVAILABLE)\\n .where(share_instances_table.c.deleted == 'False')\\n )\\n\\n for instance in connection.execute(instances_query):\\n\\n access_mappings_query = instance_access_table.select().where(\\n instance_access_table.c.share_instance_id == instance['id']\\n ).where(instance_access_table.c.deleted == 'False')\\n\\n status = constants.STATUS_ACTIVE\\n\\n for access_rule in connection.execute(access_mappings_query):\\n\\n if (access_rule['state'] == constants.STATUS_DELETING or\\n access_rule['state'] not in priorities):\\n continue\\n\\n if priorities[access_rule['state']] > priorities[status]:\\n status = access_rule['state']\\n\\n # pylint: disable=no-value-for-parameter\\n op.execute(\\n share_instances_table.update().where(\\n share_instances_table.c.id == instance['id']\\n ).values({'access_rules_status': upgrade_data_mapping[status]})\\n )\\n\\n op.drop_column('share_instance_access_map', 'state')\",\n \"def test_cap_table_formats(logger, dbsession, network, scanned_distribution, web3):\\n\\n identity_provider = NullIdentityProvider()\\n\\n token_address = scanned_distribution\\n for sort_direction in [\\\"asc\\\", \\\"desc\\\"]:\\n for sort_order in [\\\"address\\\", \\\"name\\\", \\\"balance\\\", \\\"updated\\\"]:\\n generate_cap_table(\\n logger,\\n dbsession,\\n token_address,\\n order_by=sort_order,\\n identity_provider=identity_provider,\\n order_direction=sort_direction,\\n include_empty=False,\\n TokenScanStatus=TokenScanStatus,\\n TokenHolderAccount=TokenHolderAccount,\\n )\",\n \"def __create_failures_table(self, schema=REPORTS_SCHEMA_300):\\r\\n QtSql.QSqlQuery(schema)\",\n \"def _create_db(self, overwrite=False):\\n current = list(self._cur.execute(\\\"select * from sqlite_master where type='table' and name='metrics'\\\"))\\n if overwrite and len(current) >= 1:\\n self._cur.execute('''DROP TABLE IF EXISTS metrics''')\\n self._conn.commit()\\n elif len(current) >= 1:\\n self._fields = [x[1] for x in sorted(self._cur.execute('''PRAGMA table_info(metrics)'''))]\\n return None\\n self._cur.execute('''CREATE TABLE metrics (model_name text, operation_name text, metric_name text, metric_type text, metric_value real)''')\\n self._fields = [\\\"model_name\\\", \\\"operation_name\\\", \\\"metric_name\\\", \\\"metric_type\\\", \\\"metric_value\\\"]\\n self._conn.commit()\",\n \"def create_all_tables(self):\\n pass\",\n \"def apply_migration (self, migration) :\\n scope = self.home_scope\\n for k in (\\\"Account\\\", \\\"Group\\\", \\\"Person\\\", \\\"links\\\") :\\n for epk, db_attrs in sorted (pyk.iteritems (migration [k])) :\\n ET = scope [epk [-1]]\\n obj = ET.instance (* epk, raw = True)\\n if obj is None :\\n obj = ET (* epk, raw = True, ** dict (db_attrs))\\n elif k == \\\"Account\\\" :\\n obj.set_raw (** dict (db_attrs))\",\n \"def create_table(self):\\n c = self.conn.cursor()\\n c.execute(\\\"CREATE TABLE sensor_data (mac text, name text, temperature real, light integer, moisture real, conductivity real, battery real, ts_utc int, date_iso text, firmware text )\\\")\",\n \"def _populate_old_blacklist(self, executor):\\n with create_db_connection(self._config.db_config) as conn, conn.cursor() as cursor, CodeProfiler() as cp:\\n tblname = self._blacklist_old_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"INSERT INTO {0}(imei_norm, virt_imei_shard, block_date, reasons)\\n SELECT imei_norm, virt_imei_shard, block_date, reasons\\n FROM gen_blacklist()\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n num_records = cursor.rowcount\\n self._add_pk(conn, tblname=tblname, pk_columns=['imei_norm'])\\n self._analyze_helper(cursor, tblname)\\n\\n return num_records, cp.duration\",\n \"def create_table(self, table_info, table_name):\\r\\n t1 = time.time()\\r\\n if self.database in ['redshift', 'postgres']:\\r\\n postgres_helper.create_table(\\r\\n conf=self.conf,\\r\\n table_info=table_info,\\r\\n table_name=table_name\\r\\n )\\r\\n else:\\r\\n raise Exception(\\\"database not supported yet: '{}'\\\"\\r\\n .format(self.database))\\r\\n t2 = time.time()\\r\\n t = t2 - t1\\r\\n print('Finished in {:.2f} seconds.'.format(t))\\r\\n return\",\n \"def create_tmp_shadow_tables(session, config):\\n session.execute(create_trigger_sql(config, for_tmp=True))\\n\\n conn = session.connection()\\n # Create annotationshadowtranscript in a temp table amd insert all data\\n tmp_annotationshadowtranscript = get_annotationshadowtranscript_table(\\n \\\"tmp_annotationshadowtranscript\\\"\\n )\\n tmp_annotationshadowtranscript.create(conn)\\n conn.execute(\\n \\\"SELECT insert_tmp_annotationshadowtranscript(allele_id, annotations) from annotation WHERE date_superceeded IS NULL\\\"\\n )\\n\\n # Remove temporary table from metadata\\n Base.metadata.remove(tmp_annotationshadowtranscript)\\n\\n # Create annotationshadowfrequency in a temp table amd insert all data\\n tmp_annotationshadowfrequency = get_annotationshadowfrequency_table(\\n config, name=\\\"tmp_annotationshadowfrequency\\\"\\n )\\n tmp_annotationshadowfrequency.create(conn)\\n conn.execute(\\n \\\"SELECT insert_tmp_annotationshadowfrequency(allele_id, annotations) from annotation WHERE date_superceeded IS NULL;\\\"\\n )\\n\\n # Remove temporary table from metadata\\n Base.metadata.remove(tmp_annotationshadowfrequency)\\n\\n # Map AnnotationShadowFrequency using the same config used to refresh the table\\n update_annotation_shadow_columns(config)\\n\\n # Check that all filterconfigs and usergroups' ACMG-configuration are still valid,\\n # given the possible change in columns\\n check_filterconfig_and_acmg_groups(session, config)\",\n \"def create_schema(self):\\n schema = '''CREATE TABLE jping (\\n ip_address text not null,\\n interface text not null,\\n hostname text not null,\\n ping_results integer not null,\\n UNIQUE(ip_address, hostname)\\n )\\n '''\\n self.query(schema)\",\n \"def add_torch_stat(self, stat_type, stat_tensor):\\n stat = stat_tensor.item.detach().cpu().item()\\n self.add_stat(stat_type, stat)\",\n \"def _create_intermediate_delta_tables_structure(self, conn):\\n table_names = []\\n with conn.cursor() as cursor, CodeProfiler() as cp:\\n tblname = self._blacklist_delta_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n LIKE {blacklist_delta_tbl} INCLUDING DEFAULTS\\n INCLUDING IDENTITY\\n INCLUDING CONSTRAINTS\\n INCLUDING STORAGE\\n INCLUDING COMMENTS\\n ) PARTITION BY RANGE (virt_imei_shard)\\n \\\"\\\"\\\").format(sql.Identifier(tblname),\\n blacklist_delta_tbl=sql.Identifier(self._blacklist_tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._notifications_lists_delta_tblname\\n notifications_delta_tbl = sql.Identifier(self._notifications_lists_tblname)\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n LIKE {notifications_delta_tbl} INCLUDING DEFAULTS\\n INCLUDING IDENTITY\\n INCLUDING CONSTRAINTS\\n INCLUDING STORAGE\\n INCLUDING COMMENTS\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname),\\n notifications_delta_tbl=notifications_delta_tbl))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._notifications_lists_delta_part_tblname,\\n is_unlogged=True)\\n\\n tblname = self._exceptions_lists_delta_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n LIKE {exceptions_delta_tbl} INCLUDING DEFAULTS\\n INCLUDING IDENTITY\\n INCLUDING CONSTRAINTS\\n INCLUDING STORAGE\\n INCLUDING COMMENTS\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname),\\n exceptions_delta_tbl=sql.Identifier(self._exceptions_lists_tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._exceptions_lists_delta_part_tblname,\\n is_unlogged=True)\\n\\n self._intermediate_table_names.extend(table_names)\\n return -1, cp.duration\",\n \"def __create_transactions_table(self):\\n cmd = \\\"\\\"\\\" CREATE TABLE IF NOT EXISTS %s (\\n %s text,\\n %s text,\\n %s text,\\n %s real,\\n %s text,\\n %s text);\\\"\\\"\\\" %(TABLE_TRANSACTIONS,\\n COL_TRANSACTION_BLOCK,\\n COL_TRANSACTION_SENDER,\\n COL_TRANSACTION_RECEIVER,\\n COL_TRANSACTION_AMOUNT,\\n COL_TRANSACTION_SUB_TIME,\\n COL_TRANSACTION_VER_TIME)\\n self.__dbcursor.execute(cmd)\",\n \"def _update_base_stats(self, base_stats):\\n self.total_samples += base_stats[\\\"sample_size\\\"]\\n self.sample = base_stats[\\\"sample\\\"]\\n self._empty_line_count += base_stats[\\\"empty_line_count\\\"]\\n self.memory_size += base_stats[\\\"memory_size\\\"]\",\n \"def load_metadata(self):\\n self.meta[\\\"user_tables\\\"] = pd.read_sql(self.SQL[\\\"User Tables\\\"], self.engine)\\n self.meta[\\\"all_tables\\\"] = pd.read_sql(self.SQL[\\\"All Tables\\\"], self.engine)\\n self.meta[\\\"all_databases\\\"] = pd.read_sql(self.SQL[\\\"All Databases\\\"], self.engine)\",\n \"def _db_init_data_tables(self):\\n\\n #\\n # TESTTYPE table\\n #\\n return self._db_execute(\\n \\\"\\\"\\\"\\n create table TESTTYPE (\\n KEY text unique,\\n VALUE text\\n )\\n \\\"\\\"\\\"\\n )\",\n \"def create_user_state_table():\\n connection = connection_to_db()\\n cursor = connection.cursor()\\n\\n cursor.execute(\\n \\\"CREATE TABLE IF NOT EXISTS user_state \\\"\\n \\\"(id serial PRIMARY KEY, \\\"\\n \\\"user_id INTEGER NOT NULL, \\\"\\n \\\"state INTEGER DEFAULT 0);\\\"\\n )\\n\\n connection.commit()\",\n \"def chart_of_accounts(qbo_session, attrs = \\\"strict\\\"):\\n\\n #query all the accounts\\n accounts = qbo_session.get_objects(\\\"Account\\\")\\n\\n #by strict, I mean the order the docs say to use when udpating:\\n #https://developer.intuit.com/docs/0025_quickbooksapi/\\n #0050_data_services/030_entity_services_reference/account\\n\\n if attrs == \\\"strict\\\":\\n attrs = [\\n \\\"Id\\\", \\\"SyncToken\\\", \\\"MetaData\\\", \\\"Name\\\", \\\"SubAccount\\\",\\n \\\"ParentRef\\\", \\\"Description\\\", \\\"FullyQualifiedName\\\", \\\"Active\\\",\\n \\\"Classification\\\", \\\"AccountType\\\", \\\"AccountSubType\\\", \\\"AcctNum\\\",\\n \\\"OpeningBalance\\\", \\\"OpeningBalanceDate\\\", \\\"CurrentBalance\\\",\\n \\\"CurentBalanceWithSubAccounts\\\", \\\"CurrencyRef\\\"\\n ]\\n\\n else:\\n #TODO: validate the attrs against the 'strict' list above\\n pass\\n\\n #As a first cut, we'll sort them by AccountType in trial balance order\\n\\n tb_type_order = [\\n \\\"Bank\\\", \\\"Accounts Receivable\\\", \\\"Other Current Asset\\\",\\n \\\"Fixed Asset\\\", \\\"Other Asset\\\",\\n \\\"Accounts Payable\\\", \\\"Credit Card\\\",\\n \\\"Other Current Liability\\\", \\\"Other Liability\\\",\\n \\\"Equity\\\",\\n \\\"Income\\\", \\\"Other Income\\\",\\n \\\"Expense\\\", \\\"Other Expense\\\", \\\"Cost of Goods Sold\\\"\\n ]\\n\\n accounts_by_type = {} #{Accounts_Payable:[row_list]\\n\\n for a_id in accounts:\\n a = accounts[a_id]\\n at = a[\\\"AccountType\\\"]\\n if at not in tb_type_order:\\n raise Exception(\\\"Unexpected AccountType: %s\\\" % at)\\n\\n if at not in accounts_by_type:\\n accounts_by_type[at]=[]\\n\\n this_row = []\\n for field in attrs:\\n if field not in a:\\n this_row.append(\\\"\\\")\\n else:\\n value = a[field]\\n if isinstance(value,(list,tuple,dict)):\\n this_row.append(\\\"<complex>\\\")\\n else:\\n this_row.append(a[field])\\n\\n accounts_by_type[at].append(this_row)\\n\\n rows = [attrs] #headers are the first row\\n for at in tb_type_order:\\n if at in accounts_by_type:\\n for row in accounts_by_type[at]:\\n rows.append(row)\\n\\n return rows\",\n \"def migrate(cls)->None:\\n database.cursor.execute(\\\"\\\"\\\"CREATE TABLE IF NOT EXISTS rsvps (\\n creatd_date varchar,\\n meetup integer,\\n user_id integer,\\n response varchar,\\n PRIMARY KEY(meetup,user_id)\\n )\\\"\\\"\\\")\\n database.connection.commit()\",\n \"def create_table(self, context, connection, *, engine):\\n yield Table(self.table_name, MetaData(), autoload=True, autoload_with=engine)\",\n \"def _create_intermediate_old_tables_structure(self, conn):\\n table_names = []\\n with conn.cursor() as cursor, CodeProfiler() as cp:\\n tblname = self._blacklist_old_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL\\n ) PARTITION BY RANGE (virt_imei_shard)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._notifications_lists_old_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n operator_id TEXT NOT NULL,\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n msisdn TEXT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n amnesty_granted BOOLEAN\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._notifications_lists_old_part_tblname,\\n is_unlogged=True)\\n\\n tblname = self._exceptions_lists_old_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n operator_id TEXT NOT NULL,\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._exceptions_lists_old_part_tblname,\\n is_unlogged=True)\\n\\n self._intermediate_table_names.extend(table_names)\\n return -1, cp.duration\",\n \"def add_team_derived_stats(stats, opp_stats):\\n stats['FGP'] = gen_derived_var(stats['FG'], stats['FGA'])\\n stats['FTP'] = gen_derived_var(stats['FT'], stats['FTA'])\\n stats['THRP'] = gen_derived_var(stats['THR'], stats['THRA'])\\n stats['EFGP'] = gen_derived_var(stats['FG'] + 0.5 *\\n stats['THR'], stats['FGA'])\\n stats['TSA'] = stats['FGA'] + 0.44 * stats['FTA']\\n stats['TSP'] = gen_derived_var(stats['PTS'], 2 * stats['TSA'])\\n stats['THRAr'] = gen_derived_var(stats['THRA'], stats['FGA'])\\n stats['FTAr'] = gen_derived_var(stats['FTA'], stats['FGA'])\\n stats['TWOAr'] = gen_derived_var(stats['TWOA'], stats['FGA'])\\n stats['TWOP'] = gen_derived_var(stats['TWO'], stats['TWOA'])\\n stats['ORBr'] = gen_derived_var(stats['ORB'], stats['TRB'])\\n stats['DRBr'] = gen_derived_var(stats['DRB'], stats['TRB'])\\n stats['AST_to_TOV'] = gen_derived_var(stats['AST'], stats['TOV'])\\n stats['STL_to_TOV'] = gen_derived_var(stats['STL'], stats['TOV'])\\n stats['FIC'] = (stats['PTS'] + stats['ORB'] + 0.75 * stats['DRB'] +\\n stats['AST'] + stats['STL'] + stats['BLK'] - 0.75 *\\n stats['FGA'] - 0.375 * stats['FTA'] -\\n stats['TOV'] - 0.5 * stats['PF'])\\n stats['FT_to_FGA'] = gen_derived_var(stats['FT'], stats['FGA'])\\n\\n stats['OPOS'] = gen_possessions(stats, opp_stats)\\n stats['DPOS'] = gen_possessions(opp_stats, stats)\\n stats['PACE'] = 48 * ((stats['OPOS'] + stats['DPOS']) / (2 * (float(stats['MP']) / 5)))\\n\\n stats['ORBP'] = stats['ORB'] / (stats['ORB'] + opp_stats['DRB'])\\n stats['DRBP'] = stats['DRB'] / (stats['DRB'] + opp_stats['ORB'])\\n stats['TRBP'] = stats['TRB'] / (stats['TRB'] + opp_stats['TRB'])\\n stats['ASTP'] = stats['AST'] / stats['FG']\\n stats['STLP'] = stats['STL'] / stats['DPOS']\\n stats['BLKP'] = stats['BLK'] / opp_stats['TWOA']\\n stats['TOVP'] = stats['TOV'] / stats['OPOS']\\n # stats['+/-'] = stats['+/-'] / stats['N']\",\n \"def create_table(self, repo, table, params):\\n return self.user_con.create_table(\\n repo=repo, table=table, params=params)\",\n \"def _setup_stats(self) -> None:\\n\\n # Save statistics\\n self.mass = np.array([0])\\n self.mass_balance = np.array([0])\\n self.mass_balance_trend = np.array([0])\",\n \"def prespi_create_container_table(self, conn):\\n conn.executescript(\\\"\\\"\\\"\\n CREATE TABLE container (\\n ROWID INTEGER PRIMARY KEY AUTOINCREMENT,\\n name TEXT,\\n put_timestamp TEXT,\\n delete_timestamp TEXT,\\n object_count INTEGER,\\n bytes_used INTEGER,\\n deleted INTEGER DEFAULT 0\\n );\\n\\n CREATE INDEX ix_container_deleted_name ON\\n container (deleted, name);\\n\\n CREATE TRIGGER container_insert AFTER INSERT ON container\\n BEGIN\\n UPDATE account_stat\\n SET container_count = container_count + (1 - new.deleted),\\n object_count = object_count + new.object_count,\\n bytes_used = bytes_used + new.bytes_used,\\n hash = chexor(hash, new.name,\\n new.put_timestamp || '-' ||\\n new.delete_timestamp || '-' ||\\n new.object_count || '-' || new.bytes_used);\\n END;\\n\\n CREATE TRIGGER container_update BEFORE UPDATE ON container\\n BEGIN\\n SELECT RAISE(FAIL, 'UPDATE not allowed; DELETE and INSERT');\\n END;\\n\\n\\n CREATE TRIGGER container_delete AFTER DELETE ON container\\n BEGIN\\n UPDATE account_stat\\n SET container_count = container_count - (1 - old.deleted),\\n object_count = object_count - old.object_count,\\n bytes_used = bytes_used - old.bytes_used,\\n hash = chexor(hash, old.name,\\n old.put_timestamp || '-' ||\\n old.delete_timestamp || '-' ||\\n old.object_count || '-' || old.bytes_used);\\n END;\\n \\\"\\\"\\\")\",\n \"def createTables(self):\\n metadata = Base.metadata\\n metadata.create_all(self._engine)\\n return\",\n \"def mysql_status(self):\\n stamp = int(time.time())\\n\\n # get data\\n conn = self.object.connect()\\n result = {}\\n try:\\n with conn.cursor() as cursor:\\n for key in REQUIRED_STATUS_FIELDS:\\n cursor.execute('SHOW GLOBAL STATUS LIKE \\\"%s\\\";' % key)\\n row = cursor.fetchone()\\n result[row[0]] = row[1]\\n except Exception as e:\\n exception_name = e.__class__.__name__\\n context.log.debug('failed to collect MySQLd metrics due to %s' % exception_name)\\n context.log.debug('additional info:', exc_info=True)\\n finally:\\n conn.close()\\n\\n # counters\\n counted_vars = {}\\n for metric, variable_name in METRICS['counters'].items():\\n if variable_name in result:\\n counted_vars[metric] = int(result[variable_name])\\n\\n # compound counter\\n counted_vars['mysql.global.writes'] = \\\\\\n counted_vars['mysql.global.insert'] + \\\\\\n counted_vars['mysql.global.update'] + \\\\\\n counted_vars['mysql.global.delete']\\n\\n self.aggregate_counters(counted_vars, stamp=stamp)\\n\\n # gauges\\n tracked_gauges = {}\\n for metric, variable_name in METRICS['gauges'].items():\\n if variable_name in result:\\n tracked_gauges[metric] = {\\n self.object.definition_hash: int(result[variable_name])\\n }\\n\\n # compound gauges\\n pool_util = 0\\n if ('mysql.global.innodb_buffer_pool_pages_total' in tracked_gauges and\\n tracked_gauges['mysql.global.innodb_buffer_pool_pages_total'][self.object.definition_hash] > 0):\\n pool_util = (\\n (tracked_gauges['mysql.global.innodb_buffer_pool_pages_total'][self.object.definition_hash] -\\n tracked_gauges['mysql.global.innodb_buffer_pool_pages_free'][self.object.definition_hash]) /\\n tracked_gauges['mysql.global.innodb_buffer_pool_pages_total'][self.object.definition_hash] * 100\\n )\\n tracked_gauges['mysql.global.innodb_buffer_pool_util'] = {\\n self.object.definition_hash: pool_util\\n }\\n\\n hit_ratio = 0\\n if ('mysql.global.innodb_buffer_pool_read_requests' in tracked_gauges and\\n tracked_gauges['mysql.global.innodb_buffer_pool_read_requests'][self.object.definition_hash] > 0):\\n hit_ratio = (\\n (tracked_gauges['mysql.global.innodb_buffer_pool_read_requests'][self.object.definition_hash] /\\n (tracked_gauges['mysql.global.innodb_buffer_pool_read_requests'][self.object.definition_hash] +\\n tracked_gauges['mysql.global.innodb_buffer_pool_reads'][self.object.definition_hash])) * 100\\n )\\n\\n tracked_gauges['mysql.global.innodb_buffer_pool.hit_ratio'] = {\\n self.object.definition_hash: hit_ratio\\n }\\n\\n self.aggregate_gauges(tracked_gauges, stamp=stamp)\\n\\n # finalize\\n self.increment_counters()\\n self.finalize_gauges()\",\n \"def add_update_movie_metadata_table(self, table_name):\\r\\n if not self.csv_df.empty:\\r\\n self.csv_df.to_sql(table_name, self.conn, if_exists='replace')\",\n \"def createStateTable(self):\\r\\n tableName = self._names['state']\\r\\n con = None\\r\\n try:\\r\\n con = sql.connect(self._filename, timeout=10, \\r\\n isolation_level=\\\"IMMEDIATE\\\")\\r\\n with con:\\r\\n c = con.cursor()\\r\\n c.execute(\\\"CREATE TABLE IF NOT EXISTS \\\"\\r\\n \\\"{}(id INTEGER PRIMARY KEY, manager TEXT, \\\"\\r\\n \\\"module TEXT, state TEXT)\\\".format(tableName))\\r\\n finally:\\r\\n _closeConnection(con)\\r\\n return tableName\",\n \"def register(self):\\n assert not self.is_registered\\n with transaction.atomic():\\n cursor = connection.cursor()\\n cursor.execute(\\\"SELECT audit.audit_table(%s)\\\", [self.model_content_type.model_class()._meta.db_table])\\n self.is_registered = True\\n self.save()\",\n \"def create_table1():\\n connection = connect(\\n host=\\\"localhost\\\",\\n user=\\\"postgres\\\",\\n password=\\\"coderslab\\\",\\n database=f\\\"{name + '_db'}\\\"\\n )\\n connection.autocommit = True\\n cursor = connection.cursor()\\n sql_code2 = \\\"CREATE TABLE users(id serial PRIMARY KEY, username varchar(255) UNIQUE, hashed_password varchar(80)) \\\"\\n cursor.execute(sql_code2)\\n return \\\"Creating table users...\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6411355","0.5693446","0.5648235","0.5506348","0.5451028","0.53575075","0.53320557","0.52726936","0.5267531","0.5266184","0.5225775","0.5171474","0.5141938","0.51097775","0.5103295","0.5092772","0.50799894","0.5075006","0.5058689","0.5051445","0.5033744","0.49713793","0.49707794","0.4965065","0.49502057","0.49417546","0.49387902","0.49206743","0.49206284","0.49006578","0.4898193","0.4892574","0.48859856","0.48853123","0.48709032","0.48589033","0.4846522","0.48368508","0.48347118","0.48329157","0.48260325","0.48166442","0.48155624","0.48151582","0.480946","0.47984612","0.479382","0.4791269","0.47758052","0.47736192","0.4770466","0.4760558","0.475955","0.47433102","0.47369957","0.47362086","0.47359082","0.47265583","0.47243214","0.4722459","0.4712333","0.4710793","0.47075337","0.47066373","0.47013533","0.47001684","0.46955186","0.46907178","0.46848422","0.46843347","0.4678716","0.46695977","0.46653068","0.46563002","0.4656163","0.46553656","0.46524718","0.46506676","0.46452892","0.46430734","0.4641663","0.46403787","0.46403402","0.46388012","0.46263352","0.46199957","0.46134305","0.46111256","0.46013707","0.4597145","0.45845643","0.45800415","0.45656782","0.45639086","0.45636597","0.456131","0.45578006","0.45575836","0.45503214","0.45501888"],"string":"[\n \"0.6411355\",\n \"0.5693446\",\n \"0.5648235\",\n \"0.5506348\",\n \"0.5451028\",\n \"0.53575075\",\n \"0.53320557\",\n \"0.52726936\",\n \"0.5267531\",\n \"0.5266184\",\n \"0.5225775\",\n \"0.5171474\",\n \"0.5141938\",\n \"0.51097775\",\n \"0.5103295\",\n \"0.5092772\",\n \"0.50799894\",\n \"0.5075006\",\n \"0.5058689\",\n \"0.5051445\",\n \"0.5033744\",\n \"0.49713793\",\n \"0.49707794\",\n \"0.4965065\",\n \"0.49502057\",\n \"0.49417546\",\n \"0.49387902\",\n \"0.49206743\",\n \"0.49206284\",\n \"0.49006578\",\n \"0.4898193\",\n \"0.4892574\",\n \"0.48859856\",\n \"0.48853123\",\n \"0.48709032\",\n \"0.48589033\",\n \"0.4846522\",\n \"0.48368508\",\n \"0.48347118\",\n \"0.48329157\",\n \"0.48260325\",\n \"0.48166442\",\n \"0.48155624\",\n \"0.48151582\",\n \"0.480946\",\n \"0.47984612\",\n \"0.479382\",\n \"0.4791269\",\n \"0.47758052\",\n \"0.47736192\",\n \"0.4770466\",\n \"0.4760558\",\n \"0.475955\",\n \"0.47433102\",\n \"0.47369957\",\n \"0.47362086\",\n \"0.47359082\",\n \"0.47265583\",\n \"0.47243214\",\n \"0.4722459\",\n \"0.4712333\",\n \"0.4710793\",\n \"0.47075337\",\n \"0.47066373\",\n \"0.47013533\",\n \"0.47001684\",\n \"0.46955186\",\n \"0.46907178\",\n \"0.46848422\",\n \"0.46843347\",\n \"0.4678716\",\n \"0.46695977\",\n \"0.46653068\",\n \"0.46563002\",\n \"0.4656163\",\n \"0.46553656\",\n \"0.46524718\",\n \"0.46506676\",\n \"0.46452892\",\n \"0.46430734\",\n \"0.4641663\",\n \"0.46403787\",\n \"0.46403402\",\n \"0.46388012\",\n \"0.46263352\",\n \"0.46199957\",\n \"0.46134305\",\n \"0.46111256\",\n \"0.46013707\",\n \"0.4597145\",\n \"0.45845643\",\n \"0.45800415\",\n \"0.45656782\",\n \"0.45639086\",\n \"0.45636597\",\n \"0.456131\",\n \"0.45578006\",\n \"0.45575836\",\n \"0.45503214\",\n \"0.45501888\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76754844"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6399,"cells":{"query":{"kind":"string","value":"Copied from AccountBroker before the sstoage_policy_index column was added; used for testing with TestAccountBrokerBeforeSPI. Create container table which is specific to the account DB."},"document":{"kind":"string","value":"def prespi_create_container_table(self, conn):\n conn.executescript(\"\"\"\n CREATE TABLE container (\n ROWID INTEGER PRIMARY KEY AUTOINCREMENT,\n name TEXT,\n put_timestamp TEXT,\n delete_timestamp TEXT,\n object_count INTEGER,\n bytes_used INTEGER,\n deleted INTEGER DEFAULT 0\n );\n\n CREATE INDEX ix_container_deleted_name ON\n container (deleted, name);\n\n CREATE TRIGGER container_insert AFTER INSERT ON container\n BEGIN\n UPDATE account_stat\n SET container_count = container_count + (1 - new.deleted),\n object_count = object_count + new.object_count,\n bytes_used = bytes_used + new.bytes_used,\n hash = chexor(hash, new.name,\n new.put_timestamp || '-' ||\n new.delete_timestamp || '-' ||\n new.object_count || '-' || new.bytes_used);\n END;\n\n CREATE TRIGGER container_update BEFORE UPDATE ON container\n BEGIN\n SELECT RAISE(FAIL, 'UPDATE not allowed; DELETE and INSERT');\n END;\n\n\n CREATE TRIGGER container_delete AFTER DELETE ON container\n BEGIN\n UPDATE account_stat\n SET container_count = container_count - (1 - old.deleted),\n object_count = object_count - old.object_count,\n bytes_used = bytes_used - old.bytes_used,\n hash = chexor(hash, old.name,\n old.put_timestamp || '-' ||\n old.delete_timestamp || '-' ||\n old.object_count || '-' || old.bytes_used);\n END;\n \"\"\")"},"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 pre_track_containers_create_container_table(self, conn):\n # revert to old trigger script to support one of the tests\n OLD_POLICY_STAT_TRIGGER_SCRIPT = \"\"\"\n CREATE TRIGGER container_insert_ps AFTER INSERT ON container\n BEGIN\n INSERT OR IGNORE INTO policy_stat\n (storage_policy_index, object_count, bytes_used)\n VALUES (new.storage_policy_index, 0, 0);\n UPDATE policy_stat\n SET object_count = object_count + new.object_count,\n bytes_used = bytes_used + new.bytes_used\n WHERE storage_policy_index = new.storage_policy_index;\n END;\n CREATE TRIGGER container_delete_ps AFTER DELETE ON container\n BEGIN\n UPDATE policy_stat\n SET object_count = object_count - old.object_count,\n bytes_used = bytes_used - old.bytes_used\n WHERE storage_policy_index = old.storage_policy_index;\n END;\n\n \"\"\"\n conn.executescript(\"\"\"\n CREATE TABLE container (\n ROWID INTEGER PRIMARY KEY AUTOINCREMENT,\n name TEXT,\n put_timestamp TEXT,\n delete_timestamp TEXT,\n object_count INTEGER,\n bytes_used INTEGER,\n deleted INTEGER DEFAULT 0,\n storage_policy_index INTEGER DEFAULT 0\n );\n\n CREATE INDEX ix_container_deleted_name ON\n container (deleted, name);\n\n CREATE TRIGGER container_insert AFTER INSERT ON container\n BEGIN\n UPDATE account_stat\n SET container_count = container_count + (1 - new.deleted),\n object_count = object_count + new.object_count,\n bytes_used = bytes_used + new.bytes_used,\n hash = chexor(hash, new.name,\n new.put_timestamp || '-' ||\n new.delete_timestamp || '-' ||\n new.object_count || '-' || new.bytes_used);\n END;\n\n CREATE TRIGGER container_update BEFORE UPDATE ON container\n BEGIN\n SELECT RAISE(FAIL, 'UPDATE not allowed; DELETE and INSERT');\n END;\n\n\n CREATE TRIGGER container_delete AFTER DELETE ON container\n BEGIN\n UPDATE account_stat\n SET container_count = container_count - (1 - old.deleted),\n object_count = object_count - old.object_count,\n bytes_used = bytes_used - old.bytes_used,\n hash = chexor(hash, old.name,\n old.put_timestamp || '-' ||\n old.delete_timestamp || '-' ||\n old.object_count || '-' || old.bytes_used);\n END;\n \"\"\" + OLD_POLICY_STAT_TRIGGER_SCRIPT)","def pre_track_containers_create_policy_stat(self, conn):\n conn.executescript(\"\"\"\n CREATE TABLE policy_stat (\n storage_policy_index INTEGER PRIMARY KEY,\n object_count INTEGER DEFAULT 0,\n bytes_used INTEGER DEFAULT 0\n );\n INSERT OR IGNORE INTO policy_stat (\n storage_policy_index, object_count, bytes_used\n )\n SELECT 0, object_count, bytes_used\n FROM account_stat\n WHERE container_count > 0;\n \"\"\")","def create_table(self):\n pass","def setup_tables(self):\n try:\n self.cursor.execute('CREATE SCHEMA sandbox')\n self.cursor.execute(\"DROP TABLE sandbox.dvds_rdbhdb_super;\")\n except (db.ProgrammingError, db.OperationalError), e:\n # sandbox may not exist\n pass #raise\n\n try:\n self.cursor.execute(\n \"\"\"CREATE TABLE sandbox.dvds_rdbhdb_super(\n id SERIAL PRIMARY KEY,\n name varchar(40) NOT NULL,\n rating float,\n UNIQUE(name)\n );\n \"\"\" )\n except db.ProgrammingError, e:\n if e[0] != '42P07':\n raise","def _create_intermediate_new_tables_structure(self, conn):\n table_names = []\n with conn.cursor() as cursor, CodeProfiler() as cp:\n tblname = self._blacklist_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n is_valid BOOLEAN,\n imei_norm_with_check_digit TEXT\n ) PARTITION BY RANGE (virt_imei_shard)\n \"\"\").format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._notifications_lists_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n operator_id TEXT NOT NULL,\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n msisdn TEXT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n is_valid BOOLEAN,\n amnesty_granted BOOLEAN,\n imei_norm_with_check_digit TEXT\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._notifications_lists_new_part_tblname,\n is_unlogged=True)\n\n tblname = self._exceptions_lists_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n operator_id TEXT NOT NULL,\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n is_valid BOOLEAN,\n imei_norm_with_check_digit TEXT,\n is_blacklisted BOOLEAN\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._exceptions_lists_new_part_tblname,\n is_unlogged=True)\n\n tblname = self._blocking_conditions_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n cond_name TEXT NOT NULL,\n reason TEXT NOT NULL\n )\"\"\")\n .format(sql.Identifier(tblname)))\n table_names.append(tblname)\n\n tblname = self._mnc_mcc_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n mcc_mnc_pattern TEXT NOT NULL,\n operator_id TEXT NOT NULL\n )\"\"\")\n .format(sql.Identifier(tblname)))\n table_names.append(tblname)\n\n tblname = self._notifications_imei_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n is_valid BOOLEAN,\n amnesty_granted BOOLEAN,\n imei_norm_with_check_digit TEXT\n ) PARTITION BY RANGE (virt_imei_shard)\"\"\")\n .format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._notifications_triplets_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n msisdn TEXT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n is_valid BOOLEAN,\n amnesty_granted BOOLEAN,\n imei_norm_with_check_digit TEXT,\n home_operator TEXT,\n fallback_operators TEXT[]\n ) PARTITION BY RANGE (virt_imei_shard)\"\"\")\n .format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._pairings_imei_imsi_new_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n is_valid BOOLEAN,\n imei_norm_with_check_digit TEXT,\n home_operator TEXT,\n is_blacklisted BOOLEAN\n ) PARTITION BY RANGE (virt_imei_shard) \"\"\")\n .format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True, fillfactor=45)\n table_names.append(tblname)\n\n self._intermediate_table_names.extend(table_names)\n return -1, cp.duration","def imp_create_tables():\n config = configparser.ConfigParser()\n config.read('dwh.cfg')\n\n conn = psycopg2.connect(\"host={} dbname={} user={} password={} port={}\".format(*config['CLUSTER'].values()))\n cur = conn.cursor()\n \n # Drop the tables (uncomment if necessary)\n #drop_tables(cur, conn)\n\n # Create the tables\n create_tables(cur, conn)\n\n conn.close()","def create_tables (cls, env=os.environ):\n\n cur = cls.pri_table_read_cursor (env=env)\n cur.execute ('SPECIALCASE gettablelist')\n ret = cur.fetchall ()\n \n existingtables = set ([x[0].lower() for x in ret])\n\n for tabname in (set (cls.table_desc.keys ()) - existingtables):\n sql, lsd = cls.table_desc[tabname]\n epls, desls, sqlprefix = lsd.get_create_labeling (savels=True)\n\n conn = get_labeled_conn (epls, desls)\n cur = conn.cursor ()\n cur.execute (sql)\n conn.close ()\n lsd.pop_labelset ()\n\n \n import psycopg2\n for sql in cls.sql_createindex:\n conn = get_labeled_conn ()\n cur = conn.cursor ()\n # XXX It would be better to check which indices exist as we do for tables.\n try:\n cur.execute (sql)\n except psycopg2.ProgrammingError, e: \n pass\n conn.close ()","def init_tables(self):\n\n settings.Base.metadata.tables[\n 'session_master'].drop(bind=settings.engine)\n settings.Base.metadata.tables['uurl'].drop(bind=settings.engine)\n\n settings.Base.metadata.tables[\n 'session_master'].create(bind=settings.engine)\n settings.Base.metadata.tables['uurl'].create(bind=settings.engine)\n\n logging.info(\"Sessionization Tables created\")","def create_base_table(self, table_name):\n print('new')\n # Create table at first.\n select_stm = self.construct_base_table()\n exec_query('DROP TABLE IF EXISTS %s;' % table_name) \n sql = \"\"\"\n CREATE TABLE %s AS\n %s\n \"\"\" % (table_name, select_stm)\n exec_query(sql)","def create_table(self):\n from deployflag.models.metadata import (\n GridSearchParameter,\n ModelFramework,\n ModelPerformanceMetadata,\n )\n\n with self.connection:\n self.connection.create_tables(\n [ModelPerformanceMetadata, GridSearchParameter, ModelFramework],\n safe=True,\n )","def prespi_AccountBroker_initialize(self, conn, put_timestamp, **kwargs):\n if not self.account:\n raise ValueError(\n 'Attempting to create a new database with no account set')\n self.create_container_table(conn)\n self.create_account_stat_table(conn, put_timestamp)","def _create_tables():\n from Model.DataAccessor.DbAccessor.DbOrmAccessor import db\n db.create_tables([SubjectType, SubjectRegion, Subject])","def create_table(user_id: int, jap_event_id: int) -> Table:\n table = Table(emperor=user_id,\n jap_event_id=jap_event_id,\n status=0)\n\n member = User.query.filter(User.id.__eq__(user_id)).first()\n table.members.append(member)\n\n db.session.add(table)\n db.session.commit()\n\n table_id = table.id\n command = CommandService.create_command(1, table_id)\n table.current_command_id = command.id\n\n db.session.add(table, command)\n db.session.commit()\n return table","def setup_table(self):\n self.interface.start_transaction()\n self.interface.drop_table(_history_table)\n self.interface.drop_table(_history_stats_table)\n self.interface.create_table(_history_table)\n self.interface.create_index('index1', _history_table, [_history_table['timestamp']])\n self.interface.create_table(_history_stats_table)\n self.interface.create_index('index2', _history_stats_table, [_history_stats_table['benchmark']])\n self.interface.commit_transaction()","def __create_wallets_table(self):\n cmd = \"\"\" CREATE TABLE IF NOT EXISTS %s (\n %s text PRIMARY KEY,\n %s blob,\n %s blob);\"\"\" %(TABLE_WALLETS,\n COL_WALLETS_NAME,\n COL_WALLETS_PUB_KEY,\n COL_WALLETS_PVT_KEY)\n self.__dbcursor.execute(cmd)","def create_database():\n DB_NAME = 'cloud_storage.db'\n DB_DIRECTORY = 'server_side_storage/'\n db = sqlite3.connect('{}/{}'.format(DB_DIRECTORY, DB_NAME))\n cursor = db.cursor()\n cursor.execute('''CREATE TABLE user_ids\n (row_id INTEGER PRIMARY KEY AUTOINCREMENT, uid TEXT, user_table_name TEXT)''')\n db.commit()\n cursor.close()\n db.close()","def _create(self):\n with self.pdq:\n c=self.pdq.cursor() \n c.execute('CREATE TABLE pdq (item blob,priority int)')\n c.execute('CREATE INDEX priority_index ON pdq (priority)')","def _create_intermediate_delta_tables_structure(self, conn):\n table_names = []\n with conn.cursor() as cursor, CodeProfiler() as cp:\n tblname = self._blacklist_delta_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n LIKE {blacklist_delta_tbl} INCLUDING DEFAULTS\n INCLUDING IDENTITY\n INCLUDING CONSTRAINTS\n INCLUDING STORAGE\n INCLUDING COMMENTS\n ) PARTITION BY RANGE (virt_imei_shard)\n \"\"\").format(sql.Identifier(tblname),\n blacklist_delta_tbl=sql.Identifier(self._blacklist_tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._notifications_lists_delta_tblname\n notifications_delta_tbl = sql.Identifier(self._notifications_lists_tblname)\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n LIKE {notifications_delta_tbl} INCLUDING DEFAULTS\n INCLUDING IDENTITY\n INCLUDING CONSTRAINTS\n INCLUDING STORAGE\n INCLUDING COMMENTS\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname),\n notifications_delta_tbl=notifications_delta_tbl))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._notifications_lists_delta_part_tblname,\n is_unlogged=True)\n\n tblname = self._exceptions_lists_delta_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n LIKE {exceptions_delta_tbl} INCLUDING DEFAULTS\n INCLUDING IDENTITY\n INCLUDING CONSTRAINTS\n INCLUDING STORAGE\n INCLUDING COMMENTS\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname),\n exceptions_delta_tbl=sql.Identifier(self._exceptions_lists_tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._exceptions_lists_delta_part_tblname,\n is_unlogged=True)\n\n self._intermediate_table_names.extend(table_names)\n return -1, cp.duration","def create_database_tables():\n with APP.app_context():\n DB.create_all()","def _create_schema(self): \n q = (\"CREATE TABLE IF NOT EXISTS \" + \\\n \"profiles (username text, body text, epoch numeric)\",)\n for x in q: self.cursor.execute(x)\n self.conn.commit()","def parseToDb(self):\n self.cursor.execute('''DROP TABLE IF EXISTS policy''')\n self.cursor.execute('''CREATE TABLE policy\n (name text, src text, dst text, services text, action INTEGER)''')","def test_create_hyperflex_cluster_storage_policy(self):\n pass","def create_table(self, conn, create_table_sql):\n try:\n # create a Cursor object and call its .execute() method to perform SQL queries\n c = conn.cursor()\n # execute SQL queries: create a table named card\n c.execute(create_table_sql)\n except Error as e:\n print(e)","def create_table(self, schema, table):\n fields = \", \".join([\" \".join(t) for t in zip(self.schemas[schema][table][0], self.schemas[schema][table][1])])\n sql = f'set role {self.write_role}; ' \\\n + f'CREATE TABLE IF NOT EXISTS {schema}.{table} ( {fields} );'\n return sql","def create_dataBase(conn, create_cmd):\n if conn:\n cursor = conn.cursor()\n cursor.execute(create_cmd)\n conn.commit()\n #print '[sql management] Table Created...'","def ensure_schema(client, table_name):\n query = ''.join([\n 'CREATE TABLE {cf} ',\n '(\"lockId\" ascii, \"claimId\" timeuuid, PRIMARY KEY(\"lockId\", \"claimId\"));'])\n\n def errback(failure):\n failure.trap(InvalidRequestException)\n\n return client.execute(query.format(cf=table_name),\n {}, ConsistencyLevel.QUORUM).addErrback(errback)","def _init_db(self):\n cursor = self._main_connection.cursor()\n cursor.execute(self.sql[\"create_table\"])\n self._main_connection.commit()","async def create_sys_tables(self) -> None:\n await self.conn.execute(\"\"\"CREATE TABLE IF NOT EXISTS tinymud_migrations (\n table_name TEXT,\n level INTEGER\n )\"\"\")","def create_container(cls, values):\n dbdriver = get_instance()\n return dbdriver.create_container(values)","def init_tables(database_url, _metadata, checkfirst=True):\n import dpds.storages.db.tables.operations\n import dpds.storages.db.tables.block\n import dpds.storages.db.tables.meta\n with isolated_nullpool_engine(database_url) as engine:\n _metadata.create_all(bind=engine, checkfirst=checkfirst)","def _create_intermediate_old_tables_structure(self, conn):\n table_names = []\n with conn.cursor() as cursor, CodeProfiler() as cp:\n tblname = self._blacklist_old_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL\n ) PARTITION BY RANGE (virt_imei_shard)\n \"\"\").format(sql.Identifier(tblname)))\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\n table_names.append(tblname)\n\n tblname = self._notifications_lists_old_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n operator_id TEXT NOT NULL,\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL,\n msisdn TEXT NOT NULL,\n block_date DATE NOT NULL,\n reasons TEXT[] NOT NULL,\n amnesty_granted BOOLEAN\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._notifications_lists_old_part_tblname,\n is_unlogged=True)\n\n tblname = self._exceptions_lists_old_tblname\n cursor.execute(sql.SQL(\"\"\"CREATE UNLOGGED TABLE {0} (\n operator_id TEXT NOT NULL,\n imei_norm TEXT NOT NULL,\n virt_imei_shard SMALLINT NOT NULL,\n imsi TEXT NOT NULL\n ) PARTITION BY LIST (operator_id)\n \"\"\").format(sql.Identifier(tblname)))\n table_names.append(tblname)\n self._create_operator_partitions(conn,\n parent_tbl_name=tblname,\n child_name_fn=self._exceptions_lists_old_part_tblname,\n is_unlogged=True)\n\n self._intermediate_table_names.extend(table_names)\n return -1, cp.duration","def test_create_hyperflex_ext_fc_storage_policy(self):\n pass","def create_new_index(self, dict_pg_info):\n # ! Setting if fun can use default setting\n ruler = Rules()\n str_conn = ruler.pg_info_rules(dict_pg_info)\n conn = psycopg2.connect(str_conn)\n\n with conn:\n with conn.cursor() as cur:\n str_create_table = \"CREATE TABLE \" + dict_pg_info['table'] + \" (path varchar PRIMARY KEY);\"\n # ! Check if table already exit\n cur.execute(str_create_table)\n cur.close()\n\n conn.close()","def create_table(table_name:str, database_name:str='dars_nic_391419_j3w9t_collab', select_sql_script:str=None) -> None:\n \n spark.conf.set(\"spark.sql.legacy.allowCreatingManagedTableUsingNonemptyLocation\",\"true\")\n \n if select_sql_script is None:\n select_sql_script = f\"SELECT * FROM global_temp.{table_name}\"\n \n spark.sql(f\"\"\"CREATE TABLE {database_name}.{table_name} AS\n {select_sql_script}\n \"\"\")\n spark.sql(f\"ALTER TABLE {database_name}.{table_name} OWNER TO {database_name}\")","def create_table(opts, stats):\n print(\"--------------------------------------\")\n print(\"Creating table %s\" % (opts.table_name,))\n print(\"--------------------------------------\")\n print(timestamp())\n create_table_ddl = \"CREATE TABLE %s (\" % (opts.table_name,)\n num_bigint_cols = opts.columns - opts.num_string_columns\n assert(num_bigint_cols > 0)\n for i in range(opts.columns):\n coltype = 'STRING'\n if i < num_bigint_cols: coltype = 'BIGINT'\n if i > 0: create_table_ddl += ', '\n create_table_ddl += \"f%d %s\" % (i, coltype)\n if i == 0: create_table_ddl += ' PRIMARY KEY'\n create_table_ddl += \") PARTITION BY HASH(f0) PARTITIONS %d STORED AS KUDU \" % \\\n (opts.partitions, )\n create_table_ddl += \"TBLPROPERTIES ('kudu.num_tablet_replicas' = '%d')\" % \\\n (opts.replication_factor, )\n\n cmd = 'echo \"%s\" | impala-shell -i %s -f -' % (create_table_ddl, opts.impalad_address)\n run_command(opts, cmd)","def make_cache_table(metadata, table_name='beaker_cache', schema_name=None):\n return sa.Table(table_name, metadata,\n sa.Column('namespace', sa.String(255), primary_key=True),\n sa.Column('accessed', sa.DateTime, nullable=False),\n sa.Column('created', sa.DateTime, nullable=False),\n sa.Column('data', sa.PickleType, nullable=False),\n schema=schema_name if schema_name else metadata.schema)","def createTable(self):\n results = self.db.table_create(self.entity).run(self.r)\n time.sleep(5)\n return results","def _create_schema(self):\n self._conn.executescript(self._db_schema)","def create_table():\n conn = psycopg2.connect(host=\"localhost\", database=\"integration\", user=\"postgres\", password=\"postgres\")\n cursor = conn.cursor()\n cursor.execute(CREATE_TABLE)\n conn.commit()\n cursor.close()","def _setup_origin_table(self):\n if self._create_table_if_not_exists(self.dataset):\n return\n\n directory, pipeline_builder = self._directory_origin(MAX_CONCURRENCY)\n jdbc_producer = pipeline_builder.add_stage('JDBC Producer', type='destination')\n jdbc_producer.set_attributes(default_operation=\"INSERT\",\n field_to_column_mapping=[],\n enclose_object_names=True,\n use_multi_row_operation=True,\n statement_parameter_limit=32768,\n table_name=self.dataset)\n\n directory >> jdbc_producer\n\n pipeline = pipeline_builder.build().configure_for_environment(self.environments['database'])\n self.sdc_executor.add_pipeline(pipeline)\n self.sdc_executor.start_pipeline(pipeline).wait_for_pipeline_output_records_count(self.record_count, timeout_sec=LOAD_TIMEOUT)\n self.sdc_executor.stop_pipeline(pipeline)\n self.sdc_executor.remove_pipeline(pipeline)","def sql_create_big_table():\n return \"\"\"\n SELECT\n m.tube_assembly_id as 'tube_assembly_id'\n , m.quantity_1 as 'quantity_component'\n , c.component_id \n , c.component_type_id \n , c.type as component_type \n , c.connection_type_id\n , c.outside_shape\n , c.base_type\n , c.height_over_tube\n , c.bolt_pattern_long\n , c.bolt_pattern_wide\n , c.groove\n , c.base_diameter\n , c.shoulder_diameter\n , c.unique_feature\n , c.orientation\n , c.weight\n , p.supplier\n , p.quote_date\n , p.annual_usage\n , p.min_order_quantity\n , p.bracket_pricing\n , p.quantity\n , p.cost\n FROM\n stg_bill_of_materials m INNER JOIN stg_comp_boss c\n ON m.component_id_1 = c.component_id\n \n INNER JOIN stg_price_quote p\n ON m.tube_assembly_id = p.tube_assembly_id\n \"\"\"","def upgrade():\n # # commands auto generated by Alembic - please adjust! ###\n op.create_table('downstream_map',\n sa.Column('key', sa.String(length=255), nullable=False),\n sa.Column('value', sa.String(length=512), nullable=True),\n sa.PrimaryKeyConstraint('key'))\n # # end Alembic commands ###","def create_all_tables(self):\n pass","def _create_table(self) :\n\n cur = self.con.cursor()\n delete_sql = 'DROP TABLE IF EXISTS \"%s\"' % self.name\n cur.execute(delete_sql)\n\n col_sql = ','.join(['\"%s\" %s' % (self.cols[i], self.types[i])\n for i in range(len(self.cols))])\n create_sql = 'CREATE TABLE \"%s\" ( %s );' % (self.name, col_sql)\n cur.execute(create_sql)","def _get_db_create_table(self, frame):\r\n\r\n columns = (u',\\n'.\r\n\r\n join([u' `%s` DECIMAL(20,5) DEFAULT NULL COMMENT \"%s\"' %\r\n\r\n (self._get_db_name(name), name) for name in\r\n\r\n frame.index.values]))\r\n\r\n table_name = self._get_db_table_name(frame)\r\n\r\n return (\r\n\r\n u'CREATE TABLE `%s` (\\n' % table_name +\r\n\r\n u' `ticker` VARCHAR(50) NOT NULL COMMENT \"Exchange:Ticker\",\\n' +\r\n\r\n u' `period` DATE NOT NULL COMMENT \"Period\",\\n' +\r\n\r\n u'%s,\\n' % columns +\r\n\r\n u' PRIMARY KEY USING BTREE (`ticker`, `period`),\\n' +\r\n\r\n u' KEY `ix_ticker` USING BTREE (`ticker`))\\n' +\r\n\r\n u'ENGINE=MyISAM DEFAULT CHARSET=utf8\\n' +\r\n\r\n u'COMMENT = \"%s\"' % frame.index.name)","def create_new_table():\n dataset = create_dataset()\n table_id = \"{}.{}.corona_cases_table\".format(client.project, dataset.dataset_id)\n table = bigquery.Table(table_id)\n table = client.create_table(table, exists_ok=True)\n print(\n \"Created table {}.{}.{}\".format(table.project, table.dataset_id, table.table_id)\n )\n return table","def build_metadata():\n metadata = sa.MetaData()\n\n sa.Table(\n 'hive_blocks', metadata,\n sa.Column('num', sa.Integer, primary_key=True, autoincrement=False),\n sa.Column('hash', CHAR(40), nullable=False),\n sa.Column('prev', CHAR(40)),\n sa.Column('txs', SMALLINT, server_default='0', nullable=False),\n sa.Column('ops', SMALLINT, server_default='0', nullable=False),\n sa.Column('created_at', sa.DateTime, nullable=False),\n\n sa.UniqueConstraint('hash', name='hive_blocks_ux1'),\n sa.ForeignKeyConstraint(['prev'], ['hive_blocks.hash'], name='hive_blocks_fk1'),\n )\n\n sa.Table(\n 'hive_accounts', metadata,\n sa.Column('id', sa.Integer, primary_key=True),\n sa.Column('name', VARCHAR(16), nullable=False),\n sa.Column('created_at', sa.DateTime, nullable=False),\n #sa.Column('block_num', sa.Integer, nullable=False),\n sa.Column('reputation', sa.Float(precision=6), nullable=False, server_default='25'),\n\n sa.Column('display_name', sa.String(20)),\n sa.Column('about', sa.String(160)),\n sa.Column('location', sa.String(30)),\n sa.Column('website', sa.String(100)),\n sa.Column('profile_image', sa.String(1024), nullable=False, server_default=''),\n sa.Column('cover_image', sa.String(1024), nullable=False, server_default=''),\n\n sa.Column('followers', sa.Integer, nullable=False, server_default='0'),\n sa.Column('following', sa.Integer, nullable=False, server_default='0'),\n\n sa.Column('proxy', VARCHAR(16), nullable=False, server_default=''),\n sa.Column('post_count', sa.Integer, nullable=False, server_default='0'),\n sa.Column('proxy_weight', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('vote_weight', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('kb_used', sa.Integer, nullable=False, server_default='0'), # deprecated\n sa.Column('rank', sa.Integer, nullable=False, server_default='0'),\n\n sa.Column('lastread_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\n sa.Column('active_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\n sa.Column('cached_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\n sa.Column('raw_json', sa.Text),\n\n\n sa.UniqueConstraint('name', name='hive_accounts_ux1'),\n sa.Index('hive_accounts_ix1', 'vote_weight', 'id'), # core: quick ranks\n sa.Index('hive_accounts_ix2', 'name', 'id'), # core: quick id map\n sa.Index('hive_accounts_ix3', 'vote_weight', 'name', postgresql_ops=dict(name='varchar_pattern_ops')), # API: lookup\n sa.Index('hive_accounts_ix4', 'id', 'name'), # API: quick filter/sort\n sa.Index('hive_accounts_ix5', 'cached_at', 'name'), # core/listen sweep\n )\n\n sa.Table(\n 'hive_posts', metadata,\n sa.Column('id', sa.Integer, primary_key=True),\n sa.Column('parent_id', sa.Integer),\n sa.Column('author', VARCHAR(16), nullable=False),\n sa.Column('permlink', VARCHAR(255), nullable=False),\n sa.Column('category', VARCHAR(255), nullable=False, server_default=''),\n sa.Column('community_id', sa.Integer, nullable=True),\n sa.Column('created_at', sa.DateTime, nullable=False),\n sa.Column('depth', SMALLINT, nullable=False),\n sa.Column('is_deleted', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_pinned', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_muted', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_valid', BOOLEAN, nullable=False, server_default='1'),\n sa.Column('promoted', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\n\n sa.ForeignKeyConstraint(['author'], ['hive_accounts.name'], name='hive_posts_fk1'),\n sa.ForeignKeyConstraint(['parent_id'], ['hive_posts.id'], name='hive_posts_fk3'),\n sa.UniqueConstraint('author', 'permlink', name='hive_posts_ux1'),\n sa.Index('hive_posts_ix3', 'author', 'depth', 'id', postgresql_where=sql_text(\"is_deleted = '0'\")), # API: author blog/comments\n sa.Index('hive_posts_ix4', 'parent_id', 'id', postgresql_where=sql_text(\"is_deleted = '0'\")), # API: fetching children\n sa.Index('hive_posts_ix5', 'id', postgresql_where=sql_text(\"is_pinned = '1' AND is_deleted = '0'\")), # API: pinned post status\n sa.Index('hive_posts_ix6', 'community_id', 'id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_pinned = '1' AND is_deleted = '0'\")), # API: community pinned\n )\n\n sa.Table(\n 'hive_post_tags', metadata,\n sa.Column('post_id', sa.Integer, nullable=False),\n sa.Column('tag', sa.String(32), nullable=False),\n sa.UniqueConstraint('tag', 'post_id', name='hive_post_tags_ux1'), # core\n sa.Index('hive_post_tags_ix1', 'post_id'), # core\n )\n\n sa.Table(\n 'hive_follows', metadata,\n sa.Column('follower', sa.Integer, nullable=False),\n sa.Column('following', sa.Integer, nullable=False),\n sa.Column('state', SMALLINT, nullable=False, server_default='1'),\n sa.Column('created_at', sa.DateTime, nullable=False),\n\n sa.UniqueConstraint('following', 'follower', name='hive_follows_ux3'), # core\n sa.Index('hive_follows_ix5a', 'following', 'state', 'created_at', 'follower'),\n sa.Index('hive_follows_ix5b', 'follower', 'state', 'created_at', 'following'),\n )\n\n sa.Table(\n 'hive_reblogs', metadata,\n sa.Column('account', VARCHAR(16), nullable=False),\n sa.Column('post_id', sa.Integer, nullable=False),\n sa.Column('created_at', sa.DateTime, nullable=False),\n\n sa.ForeignKeyConstraint(['account'], ['hive_accounts.name'], name='hive_reblogs_fk1'),\n sa.ForeignKeyConstraint(['post_id'], ['hive_posts.id'], name='hive_reblogs_fk2'),\n sa.UniqueConstraint('account', 'post_id', name='hive_reblogs_ux1'), # core\n sa.Index('hive_reblogs_ix1', 'post_id', 'account', 'created_at'), # API -- not yet used\n )\n\n sa.Table(\n 'hive_payments', metadata,\n sa.Column('id', sa.Integer, primary_key=True),\n sa.Column('block_num', sa.Integer, nullable=False),\n sa.Column('tx_idx', SMALLINT, nullable=False),\n sa.Column('post_id', sa.Integer, nullable=False),\n sa.Column('from_account', sa.Integer, nullable=False),\n sa.Column('to_account', sa.Integer, nullable=False),\n sa.Column('amount', sa.types.DECIMAL(10, 3), nullable=False),\n sa.Column('token', VARCHAR(5), nullable=False),\n\n sa.ForeignKeyConstraint(['from_account'], ['hive_accounts.id'], name='hive_payments_fk1'),\n sa.ForeignKeyConstraint(['to_account'], ['hive_accounts.id'], name='hive_payments_fk2'),\n sa.ForeignKeyConstraint(['post_id'], ['hive_posts.id'], name='hive_payments_fk3'),\n )\n\n sa.Table(\n 'hive_feed_cache', metadata,\n sa.Column('post_id', sa.Integer, nullable=False),\n sa.Column('account_id', sa.Integer, nullable=False),\n sa.Column('created_at', sa.DateTime, nullable=False),\n sa.UniqueConstraint('post_id', 'account_id', name='hive_feed_cache_ux1'), # core\n sa.Index('hive_feed_cache_ix1', 'account_id', 'post_id', 'created_at'), # API (and rebuild?)\n )\n\n sa.Table(\n 'hive_posts_cache', metadata,\n sa.Column('post_id', sa.Integer, primary_key=True, autoincrement=False),\n sa.Column('author', VARCHAR(16), nullable=False),\n sa.Column('permlink', VARCHAR(255), nullable=False),\n sa.Column('category', VARCHAR(255), nullable=False, server_default=''),\n\n # important/index\n sa.Column('community_id', sa.Integer, nullable=True),\n sa.Column('depth', SMALLINT, nullable=False, server_default='0'),\n sa.Column('children', SMALLINT, nullable=False, server_default='0'),\n\n # basic/extended-stats\n sa.Column('author_rep', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('flag_weight', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('total_votes', sa.Integer, nullable=False, server_default='0'),\n sa.Column('up_votes', sa.Integer, nullable=False, server_default='0'),\n\n # basic ui fields\n sa.Column('title', sa.String(255), nullable=False, server_default=''),\n sa.Column('preview', sa.String(1024), nullable=False, server_default=''),\n sa.Column('img_url', sa.String(1024), nullable=False, server_default=''),\n\n # core stats/indexes\n sa.Column('payout', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\n sa.Column('promoted', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\n sa.Column('created_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\n sa.Column('payout_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\n sa.Column('updated_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\n sa.Column('is_paidout', BOOLEAN, nullable=False, server_default='0'),\n\n # ui flags/filters\n sa.Column('is_nsfw', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_declined', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_full_power', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_hidden', BOOLEAN, nullable=False, server_default='0'),\n sa.Column('is_grayed', BOOLEAN, nullable=False, server_default='0'),\n\n # important indexes\n sa.Column('rshares', sa.BigInteger, nullable=False, server_default='0'),\n sa.Column('sc_trend', sa.Float(precision=6), nullable=False, server_default='0'),\n sa.Column('sc_hot', sa.Float(precision=6), nullable=False, server_default='0'),\n\n # bulk data\n sa.Column('body', TEXT),\n sa.Column('votes', TEXT),\n sa.Column('json', sa.Text),\n sa.Column('raw_json', sa.Text),\n\n # index: misc\n sa.Index('hive_posts_cache_ix3', 'payout_at', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # core: payout sweep\n sa.Index('hive_posts_cache_ix8', 'category', 'payout', 'depth', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: tag stats\n\n # index: ranked posts\n sa.Index('hive_posts_cache_ix2', 'promoted', postgresql_where=sql_text(\"is_paidout = '0' AND promoted > 0\")), # API: promoted\n\n sa.Index('hive_posts_cache_ix6a', 'sc_trend', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: trending todo: depth=0\n sa.Index('hive_posts_cache_ix7a', 'sc_hot', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: hot todo: depth=0\n sa.Index('hive_posts_cache_ix6b', 'post_id', 'sc_trend', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: trending, filtered todo: depth=0\n sa.Index('hive_posts_cache_ix7b', 'post_id', 'sc_hot', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: hot, filtered todo: depth=0\n\n sa.Index('hive_posts_cache_ix9a', 'depth', 'payout', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: payout todo: rem depth\n sa.Index('hive_posts_cache_ix9b', 'category', 'depth', 'payout', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: payout, filtered todo: rem depth\n\n sa.Index('hive_posts_cache_ix10', 'post_id', 'payout', postgresql_where=sql_text(\"is_grayed = '1' AND payout > 0\")), # API: muted, by filter/date/payout\n\n # index: stats\n sa.Index('hive_posts_cache_ix20', 'community_id', 'author', 'payout', 'post_id', postgresql_where=sql_text(\"is_paidout = '0'\")), # API: pending distribution; author payout\n\n # index: community ranked posts\n sa.Index('hive_posts_cache_ix30', 'community_id', 'sc_trend', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\")), # API: community trend\n sa.Index('hive_posts_cache_ix31', 'community_id', 'sc_hot', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\")), # API: community hot\n sa.Index('hive_posts_cache_ix32', 'community_id', 'created_at', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\")), # API: community created\n sa.Index('hive_posts_cache_ix33', 'community_id', 'payout', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '0' AND is_paidout = '0'\")), # API: community payout\n sa.Index('hive_posts_cache_ix34', 'community_id', 'payout', 'post_id', postgresql_where=sql_text(\"community_id IS NOT NULL AND is_grayed = '1' AND is_paidout = '0'\")), # API: community muted\n )\n\n sa.Table(\n 'hive_state', metadata,\n sa.Column('block_num', sa.Integer, primary_key=True, autoincrement=False),\n sa.Column('db_version', sa.Integer, nullable=False),\n sa.Column('steem_per_mvest', sa.types.DECIMAL(8, 3), nullable=False),\n sa.Column('usd_per_steem', sa.types.DECIMAL(8, 3), nullable=False),\n sa.Column('sbd_per_steem', sa.types.DECIMAL(8, 3), nullable=False),\n sa.Column('dgpo', sa.Text, nullable=False),\n )\n\n metadata = build_metadata_community(metadata)\n\n metadata = build_metadata_blacklist(metadata)\n\n metadata = build_trxid_block_num(metadata)\n\n return metadata","def create_tables(cursor):\n cursor.execute(\"\"\"\n CREATE TABLE users(\n userid INTEGER PRIMARY KEY,\n username TEXT NOT NULL,\n password TEXT NOT NULL,\n email TEXT NOT NULL\n );\n \"\"\")\n cursor.execute(\"\"\"\n CREATE TABLE groups(\n groupid INTEGER PRIMARY KEY,\n name TEXT NOT NULL\n );\n \"\"\")\n cursor.execute(\"\"\"\n CREATE TABLE usergroups(\n userid INTEGER,\n groupid INTEGER,\n PRIMARY KEY (userid, groupid)\n FOREIGN KEY (userid) REFERENCES users (userid)\n ON DELETE CASCADE ON UPDATE NO ACTION\n FOREIGN KEY (groupid) REFERENCES groups (groupid)\n ON DELETE CASCADE ON UPDATE NO ACTION\n );\n \"\"\")\n cursor.execute(\"\"\"\n CREATE TABLE settings(\n key TEXT PRIMARY KEY,\n value\n );\n \"\"\")\n cursor.execute(\"\"\"\n CREATE TABLE sessions(\n userid INTEGER PRIMARY KEY,\n key TEXT NOT NULL,\n started TEXT DEFAULT (datetime('now')),\n FOREIGN KEY (userid) REFERENCES users (userid)\n ON DELETE CASCADE ON UPDATE NO ACTION\n );\n \"\"\")\n cursor.execute(\"CREATE UNIQUE INDEX idx_groups_name ON groups (name)\")\n cursor.execute(\n \"CREATE UNIQUE INDEX idx_users_username ON users (username)\"\n )","async def _create_table(self, table: TableSchema) -> None:\n try:\n await self.conn.execute(get_create_table(table))\n except PostgresError: # Only DB related exceptions\n print(f\"Failed to execute CREATE TABLE for {table['name']}\")\n raise\n # Initialize migration level (so that it can be altered in future)\n await self.conn.execute('INSERT INTO tinymud_migrations (table_name, level) VALUES ($1, $2)', table['name'], 0)","def schema_upgrades():\n op.create_table('vpp_licenses',\n sa.Column('license_id', sa.Integer(), nullable=False),\n sa.Column('adam_id', sa.String(), nullable=True),\n sa.Column('product_type', sa.Enum('Software', 'Application', 'Publication', name='vppproducttype'), nullable=True),\n sa.Column('product_type_name', sa.String(), nullable=True),\n sa.Column('pricing_param', sa.Enum('StandardQuality', 'HighQuality', name='vpppricingparam'), nullable=True),\n sa.Column('is_irrevocable', sa.Boolean(), nullable=True),\n sa.Column('user_id', sa.Integer(), nullable=True),\n sa.Column('client_user_id', commandment.dbtypes.GUID(), nullable=True),\n sa.Column('its_id_hash', sa.String(), nullable=True),\n sa.ForeignKeyConstraint(['client_user_id'], ['vpp_users.client_user_id'], ),\n sa.ForeignKeyConstraint(['user_id'], ['vpp_users.user_id'], ),\n sa.PrimaryKeyConstraint('license_id')\n )","def create_staging_schema(cursor,table_schema):\n create_schema = \"CREATE SCHEMA IF NOT EXISTS \" + table_schema + \";\"\n cursor.execute(create_schema)","def db_create_table(db_in, tablename):\n connection = db_in.connection.cursor()\n connection.execute('CREATE TABLE IF NOT EXISTS %s(id INTEGER PRIMARY KEY);' % tablename)","def create_marker_table(self):\n if self.marker_table is None:\n self.marker_table = luigi.configuration.get_config().get('sqlalchemy', 'marker-table', 'table_updates')\n\n engine = self.engine\n\n with engine.begin() as con:\n metadata = sqlalchemy.MetaData()\n if not con.dialect.has_table(con, self.marker_table):\n self.marker_table_bound = sqlalchemy.Table(\n self.marker_table, metadata,\n sqlalchemy.Column(\"ParquetSource\", sqlalchemy.String(128), primary_key=True),\n sqlalchemy.Column(\"TargetTable\", sqlalchemy.String(128)),\n sqlalchemy.Column(\"Environment\", sqlalchemy.String(128)),\n sqlalchemy.Column(\"BackupDate\", sqlalchemy.DateTime),\n sqlalchemy.Column(\"InsertedDate\", sqlalchemy.DateTime, default=datetime.now()))\n metadata.create_all(engine)\n else:\n metadata.reflect(only=[self.marker_table], bind=engine)\n self.marker_table_bound = metadata.tables[self.marker_table]","def create_table(self, create_table_sql):\n print('connect')\n conn = psycopg2.connect(self.name, sslmode='require')\n c = conn.cursor()\n c.execute(create_table_sql)\n conn.close()","def create_tables(self):\n con = self.connect()\n cursor = con.cursor()\n queries = self.tables()\n for query in queries:\n cursor.execute(query)\n cursor.close()\n con.commit()\n con.close()","def __create_table(self):\n\n self.connection = self.db.connect()\n self.metadata = MetaData(self.connection)\n\n self.system = Table(self.table_name, self.metadata,\n Column('timestamp', DateTime(), primary_key=True, nullable=False),\n Column('vibration_sensor', Float()),\n Column('flow', Float()),\n Column('pressure', Float()),\n Column('power_consumption', Float()),\n Column('failure_times', Float()),\n Column('operational', Boolean())\n )\n\n self.metadata.create_all()","def create_tables():\n db.create_all()","def create_tables():\n db.create_all()","def create_applications_table(cls):\n cursor = Database.connect_to_db()\n sql_command = \"\"\"CREATE TABLE IF NOT EXISTS \"public\".\"applications\" (\n id SERIAL ,\n party_name VARCHAR(255) NOT NULL,\n office_name VARCHAR(255) NOT NULL,\n user_id INTEGER NOT NULL,\n date_created VARCHAR(80),\n status VARCHAR(255) NOT NULL,\n PRIMARY KEY (id),\n FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE\n )\n \"\"\"\n cursor.execute(sql_command)","def create_tables( self ) :\n return self._create_tables","def create_table(self, schema: str, table: str, col_types: dict, non_null_columns: List[str]):\n return","def create_tables(self):\n\n self.cur.execute('''CREATE TABLE IF NOT EXISTS my_business_entry\n (\n id SERIAL PRIMARY KEY,\n url_yes_no boolean,\n url TEXT,\n phone_yes_no boolean,\n phone TEXT,\n rating TEXT,\n nr_of_ratings TEXT,\n myBusiness boolean,\n company TEXT\n );''')\n\n self.connection.commit()","def createTables(self,table=\"all\"):\n auto=\"\"\n\tif self.dbType==\"mysql\":\n\t auto=\"AUTO_INCREMENT\"\n\t \n\ttableName=\"FileID\"\n if table==\"all\" or table==tableName:\n\t # Drop/create FileID table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"CREATE TABLE %s (\n\t fileid %s %s PRIMARY KEY, \n\t fileName TEXT,\n\t typeid %s\n\t )\n\t \"\"\"%(tableName,self.long,auto,self.UINT)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\n\ttableName=\"KeyFile\"\n\tif table==\"all\" or table==tableName: \n\t # Drop/create KeyFile table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"\n\t CREATE TABLE %s (\n\t graphid %s NOT NULL, \n\t view VARCHAR(255) NOT NULL, \n\t run %s NOT NULL, \n\t uid %s, \n\t keyFileId %s NOT NULL, PRIMARY KEY(graphid,view,run,uid) )\n\t \"\"\"%(tableName,self.UINT,self.UINT,self.uid,self.UINT)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\t\n\ttableName=\"RunUID\"\n if table==\"all\" or table==tableName:\n\t # Drop/create RunUID table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"\n\t CREATE TABLE %s (\n\t run %s NOT NULL,\n\t uid %s )\n\t \"\"\"%(tableName,self.UINT,self.uid)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\n\ttableName=\"MaxMasterID\"\n if table==tableName:\n\t # Drop/create RunUID table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"\n\t CREATE TABLE %s (\n\t masterMaxId %s NOT NULL,\n\t comment TEXT )\n\t \"\"\"%(tableName,self.UINT)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\n\ttableName=\"Location\"\n if table==\"all\" or table==tableName:\n\t # Drop/create Localtion table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"\n\t CREATE TABLE %s (\n\t id %s %s PRIMARY KEY,\n\t graphid %s NOT NULL, \n\t run %s NOT NULL, \n\t uid %s, \n\t locationFileId %s NOT NULL )\n\t \"\"\"%(tableName,self.long,auto,self.UINT,self.UINT,self.uid,self.UINT)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t query = \"CREATE INDEX LocationGroups ON Location(graphid,run,uid)\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\n\ttableName=\"Version\"\n if table==\"all\" or table==tableName:\n\t # Drop/create Version table in SQLDB.EventStoreDB\n\t self.dropTable(tableName)\n\t query = \"\"\"\n\t CREATE TABLE %s (\n\t id %s %s PRIMARY KEY,\n\t grade VARCHAR(255) NOT NULL, \n\t timeStamp %s NOT NULL, \n\t minRunNumber %s NOT NULL, \n\t maxRunNumber %s NOT NULL, \n\t graphid %s NOT NULL,\n\t state VARCHAR(10) ) \n\t \"\"\"%(tableName,self.long,auto,self.UINT,self.UINT,self.UINT,self.UINT)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\n\ttableName=\"SpecificVersion\"\n if table==\"all\" or table==tableName:\n\t # Drop/create SpecificVersion table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"\n\t CREATE TABLE %s (\n\t svName VARCHAR(255) NOT NULL PRIMARY KEY, \n\t svid %s NOT NULL )\n\t \"\"\"%(tableName,self.UINT)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\n\ttableName=\"SpecificVersionComment\"\n if table==\"all\" or table==tableName:\n\t # Drop/create SpecificVersionComment table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"\n\t CREATE TABLE %s (\n\t id %s %s NOT NULL PRIMARY KEY,\n\t svid %s NOT NULL,\n\t CommentDate %s,\n\t Comment TEXT )\n\t \"\"\"%(tableName,self.UINT,auto,self.UINT,self.UINT)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\n\ttableName=\"GraphPath\"\n if table==\"all\" or table==tableName:\n\t # Drop/create GraphPath table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"\n\t CREATE TABLE %s (\n\t graphid %s NOT NULL PRIMARY KEY, \n\t svid %s NOT NULL )\n\t \"\"\"%(tableName,self.UINT,self.UINT)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\n\ttableName=\"PathDepend\"\n if table==\"all\" or table==tableName:\n\t # Drop/create GraphPath table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"\n\t CREATE TABLE %s (\n\t parentId %s, \n\t childId %s NOT NULL )\n\t \"\"\"%(tableName,self.UINT,self.UINT)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\n\ttableName=\"FileType\"\n if table==\"all\" or table==tableName: \n\t # Drop/create FileType table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"CREATE TABLE %s (\n\t id %s %s PRIMARY KEY, \n\t type VARCHAR(8) NOT NULL,\n\t description TEXT )\n\t \"\"\"%(tableName,self.UINT,auto)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query\n\t\n\ttableName=\"OrphanFileID\"\n if table==\"all\" or table==tableName:\n\t # Drop/create FileType table in SQLDB.EventStore\n\t self.dropTable(tableName)\n\t query = \"\"\"CREATE TABLE %s (\n\t id %s PRIMARY KEY, \n\t dateTime DATETIME,\n\t user VARCHAR(8) NOT NULL )\n\t \"\"\"%(tableName,self.long)\n\t if self.dbType==\"mysql\": query+=\" type=innodb\"\n\t self.updateDBAndLog(query)\n\t if not self.schemaDict.has_key(tableName):\n\t self.schemaDict[tableName]=query","def creating_big_table():\n engine = connecting_database()\n if engine is None:\n return False\n\n sql = sql_create_big_table()\n engine = connecting_database()\n print(\">> Creating the table: bt_challenge_boa\")\n df = pd.read_sql(sql=sql, con=engine)\n df.to_sql(\"bt_challenge_boa\", con=engine, index=False, if_exists='replace')\n\n return True","def _create_tables(self):\n\n print(\"\\n ** Creating DynamoDB Tables\")\n\n # Create Tables\n for table_config in self.table_list:\n with open(os.path.join(self.config_dir, table_config), \"rt\") as handle:\n config_data = json.load(handle)\n story_table = DynamoDB(DynamoTable.STACK_NAME, config_data[self.stack_name])\n story_table.create()","def create_table():\n with create_connection() as conn:\n cur = conn.cursor()\n cur.execute(query=SQL_STATEMENT)\n return conn","def _db_init_data_tables(self):\n\n #\n # TESTTYPE table\n #\n return self._db_execute(\n \"\"\"\n create table TESTTYPE (\n KEY text unique,\n VALUE text\n )\n \"\"\"\n )","def createschema(self):\n def closure(cur):\n cur.execute(\"\"\"\n CREATE TABLE IF NOT EXISTS config (\n key varchar(1024) PRIMARY KEY,\n value text\n );\n CREATE TABLE IF NOT EXISTS rooms (\n id serial PRIMARY KEY,\n name text NOT NULL\n );\n CREATE TABLE IF NOT EXISTS slides (\n id serial PRIMARY KEY,\n -- The ordering index of the slide, set to NULL if slide should be hidden\n sequence_no integer NULL UNIQUE,\n -- The room that should be displayed on this slide, set to NULL for master slides aren't associated with a room\n room integer REFERENCES rooms NULL,\n -- The masters are numbered sequentially and defined in content.py\n master integer NOT NULL,\n -- Overrides the title (normally the room name will be used)\n title text NULL,\n -- If max_rows is NULL, use the config default\n max_rows integer NULL\n );\n CREATE TABLE IF NOT EXISTS events (\n id serial PRIMARY KEY,\n room integer REFERENCES rooms NOT NULL,\n begins timestamp NOT NULL,\n ends timestamp NOT NULL,\n name text NOT NULL\n );\n \"\"\")\n \n self.execute(closure)","def create_tables():\n db.create_all()","def create_table(self):\n table = self.table\n table.create()\n return table.bind.wait()","def create_db_tables():\n\n try:\n webapp.dbsql.create_all()\n webapp.dbsql.session.commit()\n except Exception as e:\n # TODO: melhorar o informe do erro\n raise e","def __create_presentations_table(self, schema=PRESENTATIONS_SCHEMA_310):\r\n log.info(\"table created\")\r\n QtSql.QSqlQuery(schema)","def create_table(self, name: str, fields: Iterable[Field]) -> DbTable:","def create_db(self):","def test_create_tables(self):\n conn_object = ParentConnection()\n conn_object.create_tables()\n conn = psycopg2.connect(**{\"host\": \"localhost\",\n \"database\": \"test\",\n \"user\": \"test\",\n \"password\": \"test\"})\n cur = conn.cursor()\n cur.execute(\"SELECT * from information_schema.tables \"\n \"WHERE table_schema = 'public' \"\n \"AND table_type = 'BASE TABLE';\")\n result = cur.fetchall()\n result = [x[2] for x in result]\n self.assertCountEqual(result,\n ['bioms', 'counts', 'networks',\n 'taxonomy', 'edges', 'samples', 'meta']\n )\n cur.close()\n conn.close()\n conn_object.delete_tables()","def new_table(self):\n self.c.execute(\n \"\"\"CREATE TABLE IF NOT EXISTS {table} (\n id integer primary key,\n {event} integer,\n {desc} text,\n {date} text,\n {link} text)\n \"\"\".format(\n table=TABLE,\n event=EVENT,\n desc=DESC,\n date=DATE,\n link=LINK,\n )\n )","def create_table(self, param, timeout):\n _abstract()","def create_table(self, param, timeout):\n _abstract()","def test_cap_table_formats(logger, dbsession, network, scanned_distribution, web3):\n\n identity_provider = NullIdentityProvider()\n\n token_address = scanned_distribution\n for sort_direction in [\"asc\", \"desc\"]:\n for sort_order in [\"address\", \"name\", \"balance\", \"updated\"]:\n generate_cap_table(\n logger,\n dbsession,\n token_address,\n order_by=sort_order,\n identity_provider=identity_provider,\n order_direction=sort_direction,\n include_empty=False,\n TokenScanStatus=TokenScanStatus,\n TokenHolderAccount=TokenHolderAccount,\n )","def table_creater(self, tablename, columnnames, entries):\n createrurl = self.casjobsurl + '/contexts/MyDB/query'","def __init__(self, database='/tmp/blingalytics_cache'):\n self.database = database\n self._create_metadata_table()","def create_table(cls):\n if not connection.connected:\n raise Exception('Not connected to the database.')\n cursor = connection.execute(cls.create_table_sql())\n cursor.close()","def create_tables(): \n \n pk_contraint = \"CONSTRAINT {}_pk PRIMARY KEY ({})\"\n uq_contraint = \"CONSTRAINT {}_uq UNIQUE ({})\"\n fk_query = \"\"\"CONSTRAINT {}_fk_{} \n FOREIGN KEY ({}) \n REFERENCES {}({}) \n ON UPDATE CASCADE \n ON DELETE RESTRICT\n \"\"\"\n \n create_dict = {}\n index = 1\n\n\n ############################## public SCHEMA ##############################\n \n schema = 'public'\n create_schema(schema)\n\n #################### site ####################\n table_name = 'site'\n pk_id = 'site_id'\n uq_list = ['site_code']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_code CHAR(3),\n purok VARCHAR,\n sitio VARCHAR,\n barangay VARCHAR,\n municipality VARCHAR,\n province VARCHAR,\n region VARCHAR,\n psgc INTEGER,\n active BOOLEAN NOT NULL DEFAULT TRUE,\n season SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n ############################## spatial SCHEMA ##############################\n \n schema = 'spatial'\n create_schema(schema)\n \n #################### exposure ####################\n table_name = 'exposure'\n pk_id = 'exp_id'\n uq_list = ['exp_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n exp_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n \n #################### site_exposure ####################\n table_name = 'site_exposure'\n pk_id = 'se_id'\n uq_list = ['site_id', 'exp_id', 'geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\n 'exp_id': {'ref_schema': 'spatial', 'ref_table': 'exposure'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n exp_id INTEGER,\n label_name VARCHAR,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n \n #################### feature ####################\n table_name = 'feature'\n pk_id = 'feat_id'\n uq_list = ['feat_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n feat_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### site_feature ####################\n table_name = 'site_feature'\n pk_id = 'sf_id'\n uq_list = ['site_id', 'feat_id', 'geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\n 'feat_id': {'ref_schema': 'spatial', 'ref_table': 'feature'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n feat_id INTEGER,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### hazard_zone ####################\n table_name = 'hazard_zone'\n pk_id = 'hz_id'\n uq_list = ['site_id, geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\"\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### monitoring ####################\n table_name = 'monitoring'\n pk_id = 'mon_id'\n uq_list = ['mon_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n mon_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### site_monitoring ####################\n table_name = 'site_monitoring'\n pk_id = 'sm_id'\n uq_list = ['site_id', 'mon_id', 'geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\n 'mon_id': {'ref_schema': 'spatial', 'ref_table': 'monitoring'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n mon_id INTEGER,\n label_name VARCHAR,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n ############################### comm SCHEMA ###############################\n \n schema = 'comm'\n create_schema(schema)\n\n #################### gsm_server ####################\n table_name = 'gsm_server'\n pk_id = 'server_id'\n uq_list = ['server_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n server_name VARCHAR,\n platform_type VARCHAR,\n version SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### server_port ####################\n table_name = 'server_port'\n pk_id = 'port_id'\n uq_list = ['server_id', 'port']\n fk_dict = {'server_id': {'ref_schema': 'comm', 'ref_table': 'gsm_server'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n server_id INTEGER,\n port BOOLEAN,\n ser_port VARCHAR,\n pwr_on_pin SMALLINT,\n ring_pin SMALLINT,\n module_type SMALLINT,\n {}, {} {}\n );\n \"\"\"\n query += \"\"\" COMMENT ON TABLE {}.{} IS \n '0- left\n 1- right'\n ;\"\"\".format(schema, table_name)\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### network_type ####################\n table_name = 'network_type'\n pk_id = 'prefix'\n uq_list = ['prefix']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} VARCHAR(3), \n carrier SMALLINT,\n {}, {} {}\n );\n \"\"\"\n query += \"\"\" COMMENT ON TABLE {}.{} IS \n '1- globe\n 2- smart\n 3- landline'\n ;\"\"\".format(schema, table_name)\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### gsm_module ####################\n table_name = 'gsm_module'\n pk_id = 'gsm_id'\n uq_list = ['prefix', 'num', 'activated']\n fk_dict = {'prefix': {'ref_schema': 'comm', 'ref_table': 'network_type'},\n 'port_id': {'ref_schema': 'comm', 'ref_table': 'server_port'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n prefix VARCHAR(3),\n num CHAR(7),\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n port_id INTEGER,\n {}, {} {}\n );\n \"\"\"\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n ############################# temporal SCHEMA #############################\n \n schema = 'temporal'\n create_schema(schema)\n\n #################### marker_observation ####################\n table_name = 'marker_observation'\n pk_id = 'mo_id'\n uq_list = ['site_id', 'ts']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n ts TIMESTAMP,\n meas_type VARCHAR(7),\n weather VARCHAR,\n observer_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### marker_history ####################\n table_name = 'marker_history'\n pk_id = 'hist_id'\n uq_list = ['sm_id', 'ts', 'event']\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n sm_id BIGINT,\n ts TIMESTAMP,\n event BOOLEAN,\n label_name VARCHAR,\n {}, {} {}\n );\n \"\"\"\n query += \"\"\" COMMENT ON TABLE {}.{} IS \n '0- rename\n 1- reposition'\n ;\"\"\".format(schema, table_name)\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### marker_data ####################\n table_name = 'marker_data'\n pk_id = 'data_id'\n uq_list = ['sm_id', 'mo_id']\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\n 'mo_id': {'ref_schema': 'temporal', 'ref_table': 'marker_observation'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n mo_id BIGINT,\n sm_id BIGINT,\n measurement NUMERIC(5,1),\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### marker_alert ####################\n table_name = 'marker_alert'\n pk_id = 'alert_id'\n uq_list = ['data_id']\n fk_dict = {'data_id': {'ref_schema': 'temporal', 'ref_table': 'marker_data'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n data_id BIGINT,\n displacement NUMERIC(4,1),\n time_delta FLOAT,\n alert_level SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### logger_model ####################\n table_name = 'logger_model'\n pk_id = 'model_id'\n uq_list = ['has_tilt', 'has_rain', 'has_piezo', 'has_soms', 'logger_type']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n has_tilt BOOLEAN,\n has_rain BOOLEAN,\n has_piezo BOOLEAN,\n has_soms BOOLEAN,\n logger_type SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### logger ####################\n table_name = 'logger'\n pk_id = 'logger_id'\n uq_list = ['sm_id']\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\n 'model_id': {'ref_schema': 'temporal', 'ref_table': 'logger_model'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n sm_id BIGINT,\n model_id INTEGER,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n \n #################### logger_mobile ####################\n table_name = 'logger_mobile'\n pk_id = 'mobile_id'\n uq_list = ['logger_id', 'activated']\n fk_dict = {'logger_id': {'ref_schema': 'temporal', 'ref_table': 'logger'},\n 'gsm_id': {'ref_schema': 'comm', 'ref_table': 'gsm_module'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n logger_id INTEGER,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n sim_num VARCHAR(12),\n gsm_id INTEGER,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n #################### EXECUTE QUERY TO CREATE TABLES ####################\n for index in create_dict.keys():\n dct = create_dict[index]\n schema = dct['schema']\n table_name = dct['table_name']\n query = dct['query']\n pk_id = dct['pk_id']\n uq_list = dct['uq_list']\n fk_dict = dct['fk_dict']\n if len(fk_dict.keys()) == 0:\n fk_constraint = ''\n else:\n fk_constraint_list = ['']\n for fk_id in fk_dict.keys():\n ref_schema = fk_dict.get(fk_id)['ref_schema']\n ref_table = fk_dict.get(fk_id)['ref_table']\n fk_part = fk_query.format(table_name, ref_table, fk_id,\n \"{}.{}\".format(ref_schema, ref_table),\n fk_id)\n fk_constraint_list.append(fk_part)\n fk_constraint = ', '.join(fk_constraint_list)\n \n query = query.format(schema, table_name, pk_id, \n pk_contraint.format(table_name, pk_id),\n uq_contraint.format(table_name, ', '.join(uq_list)),\n \"{}\".format(fk_constraint))\n qdb.execute(query)","def create_layers_table():\n\n table_name = f\"{BQ_LAYERS_TABLE}\"","def create_tables():\n with db.connect() as conn:\n conn.execute(\n \"CREATE TABLE IF NOT EXISTS url_list \"\n \"(url_id VARCHAR(20) NOT NULL UNIQUE, url_data VARCHAR(2083) NOT NULL);\"\n )","def create_table(self):\n Engine.create_table(self)\n self.connection.commit()","def create_tables(self):\n for query in table_create_sql:\n self.cursor.execute(query)\n\n self.commit()","def create_tables(self):\n if not self.is_enabled(Subsystem.database):\n raise RuntimeError(\"Database subsystem was not enabled\")\n\n Base.metadata.create_all(self.engine)","def make_new_tbl(self):\n debug = False\n default_dd = getdata.get_default_db_dets()\n con, cur = default_dd.con, default_dd.cur\n oth_name_types = getdata.get_oth_name_types(self.settings_data)\n tblname = self.tblname_lst[0]\n if debug: print(f'DBE in make_new_tbl is: {default_dd.dbe}')\n getdata.make_sofa_tbl(\n con, cur, tblname, oth_name_types, headless=False)\n wx.MessageBox(\n _('Your new table has been added to the default SOFA database'))","def _create_tables_classic(self, engine, metadata):\n if engine and metadata:\n with (yield from engine) as conn:\n for x in self._models.values():\n try:\n yield from conn.execute(CreateTable(x))\n except ProgrammingError as error:\n if hasattr(self.app, 'log') and self.app.log:\n if self.app.debug:\n self.app.log.info(\"[PostgressPlugin] [ `{}` already exists]\".format(x))\n else:\n if self.app.debug:\n print(\"[PostgressPlugin] [ `{}` already exists]\".format(x))\n return","def create_tables(self):\n if self.mock:\n mock_dynamodb2(self._create_tables())\n else:\n self._create_tables()","def _create_table(self):\n query = f\"\"\"CREATE TABLE IF NOT EXISTS {TABLE}(\n member_Id INT,\n memberName VARCHAR(50),\n amount INT,\n date datetime NOT NULL,\n time datetime NOT NULL,\n status VARCHAR(20) NOT NULL DEFAULT 'Completed'\n );\"\"\"\n\n self.cursor.execute(query)\n self.conn.commit()","def create_new_user_table():\n # Connect to database\n conn = psycopg2.connect(DATABASE_URL, sslmode='require')\n # Open a cursor to perform db operations\n cur = conn.cursor()\n # Create the table\n cur.execute(\"\"\"\n CREATE TABLE test (\n user_id int NOT NULL PRIMARY KEY,\n username varchar(255),\n id_last_message_sent int,\n id_last_message_stickered int,\n count_since_last_stickered int\n );\n \"\"\"\n )\n # Commit and close connection\n conn.commit()\n cur.close()\n conn.close()","def create_table(self):\n\n # Get columns\n columns = []\n for i, (name, type_) in enumerate(self.schema.items()):\n if 'sqlalchemy' in str(type(type_)):\n pass\n else:\n type_ = str(type_).lower()\n\n if 'int' in type_:\n type_ = sqlalchemy.Integer\n elif 'float' in type_:\n type_ = sqlalchemy.Float\n elif 'bool' in type_:\n type_ = sqlalchemy.Boolean\n elif 'timestamp' in type_:\n type_ = sqlalchemy.TIMESTAMP\n elif 'varchar' in type_ or 'str' in type_:\n type_ = sqlalchemy.VARCHAR\n elif 'json' in type_:\n type_ = sqlalchemy.JSON\n elif 'datetime' in type_:\n type_ = sqlalchemy.DateTime\n elif 'date' in type_:\n type_ = sqlalchemy.Date\n else:\n raise Exception(f\"Column type {type_} not supported when creating a new table\")\n\n columns.append(sqlalchemy.Column(name, type_))#, primary_key=True))\n\n columns = tuple(columns)\n table = sqlalchemy.Table(\n self.table, self.metadata,\n *columns\n )\n self.metadata.create_all(self.engine)","def create(self, table, columns, types, primary_key_index=[], is_ifnotexists=True):\n\n self.lock.acquire()\n try:\n dblist = self.client.get_list_database()\n for dbdict in dblist:\n if self.dbname in dbdict[\"name\"]:\n self.lock.release()\n return True\n\n self.client.create_database(self.dbname)\n except Exception as e:\n raise Exception(\"Error in create statement; InfluxDb, DB=%s\\n\" % self.dbname)\n\n self.lock.release()\n\n return True","def create_schema(self, schema):\n sql = f'set role {self.write_role}; ' \\\n + f'CREATE SCHEMA IF NOT EXISTS {schema};'\n return sql","def create_example_test_table(conn):\n execute_sql_script(conn, \"06_create_example_test_table.sql\")","def create_table(self):\n session=self.session()\n fields_list = []\n for col_name, col_obj in self.column_objects.iteritems():\n\n if col_name in self.columns:\n fields_list.append(\"`%s` %s,\" % (col_name, _local_type_to_db_column(col_obj)))\n field_str = \"\\n\".join(fields_list)\n index_type = \"UNIQUE KEY\" if self.unique else \"INDEX\"\n index_fileds = \",\".join(\"`\" + f + \"`\" for f in self.columns)\n\n sql = \"\"\"CREATE TABLE `%(table_name)s` (\n`id` int(10) unsigned NOT NULL AUTO_INCREMENT,\n`entity_id` VARCHAR(36) NOT NULL,\n%(fields)s\nPRIMARY KEY (`id`),\nUNIQUE KEY (`entity_id`),\n%(idx_type)s `idx_%(idx_name)s` (%(idx_fields)s) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8;\n \"\"\" % dict(table_name=self.table_name, fields=field_str, idx_type=index_type, idx_name=self.table_name, idx_fields=index_fileds)\n\n session.connection.execute(sql)","def setup(db):\n # initialize schema\n build_metadata().create_all(db.engine())\n\n # tune auto vacuum/analyze\n reset_autovac(db)\n\n # default rows\n sqls = [\n \"INSERT INTO hive_state (block_num, db_version, steem_per_mvest, usd_per_steem, sbd_per_steem, dgpo) VALUES (0, %d, 0, 0, 0, '')\" % DB_VERSION,\n \"INSERT INTO hive_blocks (num, hash, created_at) VALUES (0, '0000000000000000000000000000000000000000', '2016-03-24 16:04:57')\",\n \"INSERT INTO hive_accounts (name, created_at) VALUES ('miners', '2016-03-24 16:05:00')\",\n \"INSERT INTO hive_accounts (name, created_at) VALUES ('null', '2016-03-24 16:05:00')\",\n \"INSERT INTO hive_accounts (name, created_at) VALUES ('temp', '2016-03-24 16:05:00')\",\n \"INSERT INTO hive_accounts (name, created_at) VALUES ('initminer', '2016-03-24 16:05:00')\"]\n for sql in sqls:\n db.query(sql)\n\n sql = \"CREATE INDEX hive_communities_ft1 ON hive_communities USING GIN (to_tsvector('english', title || ' ' || about))\"\n db.query(sql)","def create_table(self):\n logging.debug('Creating new table')\n if not self._dbconnect or not self._cursor:\n raise Exception('Invalid call to Context Manager method!')\n\n self._cursor.execute(\"create table {} (date text, time text, location text, nodeID text)\".format(self._name))"],"string":"[\n \"def pre_track_containers_create_container_table(self, conn):\\n # revert to old trigger script to support one of the tests\\n OLD_POLICY_STAT_TRIGGER_SCRIPT = \\\"\\\"\\\"\\n CREATE TRIGGER container_insert_ps AFTER INSERT ON container\\n BEGIN\\n INSERT OR IGNORE INTO policy_stat\\n (storage_policy_index, object_count, bytes_used)\\n VALUES (new.storage_policy_index, 0, 0);\\n UPDATE policy_stat\\n SET object_count = object_count + new.object_count,\\n bytes_used = bytes_used + new.bytes_used\\n WHERE storage_policy_index = new.storage_policy_index;\\n END;\\n CREATE TRIGGER container_delete_ps AFTER DELETE ON container\\n BEGIN\\n UPDATE policy_stat\\n SET object_count = object_count - old.object_count,\\n bytes_used = bytes_used - old.bytes_used\\n WHERE storage_policy_index = old.storage_policy_index;\\n END;\\n\\n \\\"\\\"\\\"\\n conn.executescript(\\\"\\\"\\\"\\n CREATE TABLE container (\\n ROWID INTEGER PRIMARY KEY AUTOINCREMENT,\\n name TEXT,\\n put_timestamp TEXT,\\n delete_timestamp TEXT,\\n object_count INTEGER,\\n bytes_used INTEGER,\\n deleted INTEGER DEFAULT 0,\\n storage_policy_index INTEGER DEFAULT 0\\n );\\n\\n CREATE INDEX ix_container_deleted_name ON\\n container (deleted, name);\\n\\n CREATE TRIGGER container_insert AFTER INSERT ON container\\n BEGIN\\n UPDATE account_stat\\n SET container_count = container_count + (1 - new.deleted),\\n object_count = object_count + new.object_count,\\n bytes_used = bytes_used + new.bytes_used,\\n hash = chexor(hash, new.name,\\n new.put_timestamp || '-' ||\\n new.delete_timestamp || '-' ||\\n new.object_count || '-' || new.bytes_used);\\n END;\\n\\n CREATE TRIGGER container_update BEFORE UPDATE ON container\\n BEGIN\\n SELECT RAISE(FAIL, 'UPDATE not allowed; DELETE and INSERT');\\n END;\\n\\n\\n CREATE TRIGGER container_delete AFTER DELETE ON container\\n BEGIN\\n UPDATE account_stat\\n SET container_count = container_count - (1 - old.deleted),\\n object_count = object_count - old.object_count,\\n bytes_used = bytes_used - old.bytes_used,\\n hash = chexor(hash, old.name,\\n old.put_timestamp || '-' ||\\n old.delete_timestamp || '-' ||\\n old.object_count || '-' || old.bytes_used);\\n END;\\n \\\"\\\"\\\" + OLD_POLICY_STAT_TRIGGER_SCRIPT)\",\n \"def pre_track_containers_create_policy_stat(self, conn):\\n conn.executescript(\\\"\\\"\\\"\\n CREATE TABLE policy_stat (\\n storage_policy_index INTEGER PRIMARY KEY,\\n object_count INTEGER DEFAULT 0,\\n bytes_used INTEGER DEFAULT 0\\n );\\n INSERT OR IGNORE INTO policy_stat (\\n storage_policy_index, object_count, bytes_used\\n )\\n SELECT 0, object_count, bytes_used\\n FROM account_stat\\n WHERE container_count > 0;\\n \\\"\\\"\\\")\",\n \"def create_table(self):\\n pass\",\n \"def setup_tables(self):\\n try:\\n self.cursor.execute('CREATE SCHEMA sandbox')\\n self.cursor.execute(\\\"DROP TABLE sandbox.dvds_rdbhdb_super;\\\")\\n except (db.ProgrammingError, db.OperationalError), e:\\n # sandbox may not exist\\n pass #raise\\n\\n try:\\n self.cursor.execute(\\n \\\"\\\"\\\"CREATE TABLE sandbox.dvds_rdbhdb_super(\\n id SERIAL PRIMARY KEY,\\n name varchar(40) NOT NULL,\\n rating float,\\n UNIQUE(name)\\n );\\n \\\"\\\"\\\" )\\n except db.ProgrammingError, e:\\n if e[0] != '42P07':\\n raise\",\n \"def _create_intermediate_new_tables_structure(self, conn):\\n table_names = []\\n with conn.cursor() as cursor, CodeProfiler() as cp:\\n tblname = self._blacklist_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n is_valid BOOLEAN,\\n imei_norm_with_check_digit TEXT\\n ) PARTITION BY RANGE (virt_imei_shard)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._notifications_lists_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n operator_id TEXT NOT NULL,\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n msisdn TEXT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n is_valid BOOLEAN,\\n amnesty_granted BOOLEAN,\\n imei_norm_with_check_digit TEXT\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._notifications_lists_new_part_tblname,\\n is_unlogged=True)\\n\\n tblname = self._exceptions_lists_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n operator_id TEXT NOT NULL,\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n is_valid BOOLEAN,\\n imei_norm_with_check_digit TEXT,\\n is_blacklisted BOOLEAN\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._exceptions_lists_new_part_tblname,\\n is_unlogged=True)\\n\\n tblname = self._blocking_conditions_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n cond_name TEXT NOT NULL,\\n reason TEXT NOT NULL\\n )\\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n\\n tblname = self._mnc_mcc_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n mcc_mnc_pattern TEXT NOT NULL,\\n operator_id TEXT NOT NULL\\n )\\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n\\n tblname = self._notifications_imei_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n is_valid BOOLEAN,\\n amnesty_granted BOOLEAN,\\n imei_norm_with_check_digit TEXT\\n ) PARTITION BY RANGE (virt_imei_shard)\\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._notifications_triplets_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n msisdn TEXT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n is_valid BOOLEAN,\\n amnesty_granted BOOLEAN,\\n imei_norm_with_check_digit TEXT,\\n home_operator TEXT,\\n fallback_operators TEXT[]\\n ) PARTITION BY RANGE (virt_imei_shard)\\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._pairings_imei_imsi_new_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n is_valid BOOLEAN,\\n imei_norm_with_check_digit TEXT,\\n home_operator TEXT,\\n is_blacklisted BOOLEAN\\n ) PARTITION BY RANGE (virt_imei_shard) \\\"\\\"\\\")\\n .format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True, fillfactor=45)\\n table_names.append(tblname)\\n\\n self._intermediate_table_names.extend(table_names)\\n return -1, cp.duration\",\n \"def imp_create_tables():\\n config = configparser.ConfigParser()\\n config.read('dwh.cfg')\\n\\n conn = psycopg2.connect(\\\"host={} dbname={} user={} password={} port={}\\\".format(*config['CLUSTER'].values()))\\n cur = conn.cursor()\\n \\n # Drop the tables (uncomment if necessary)\\n #drop_tables(cur, conn)\\n\\n # Create the tables\\n create_tables(cur, conn)\\n\\n conn.close()\",\n \"def create_tables (cls, env=os.environ):\\n\\n cur = cls.pri_table_read_cursor (env=env)\\n cur.execute ('SPECIALCASE gettablelist')\\n ret = cur.fetchall ()\\n \\n existingtables = set ([x[0].lower() for x in ret])\\n\\n for tabname in (set (cls.table_desc.keys ()) - existingtables):\\n sql, lsd = cls.table_desc[tabname]\\n epls, desls, sqlprefix = lsd.get_create_labeling (savels=True)\\n\\n conn = get_labeled_conn (epls, desls)\\n cur = conn.cursor ()\\n cur.execute (sql)\\n conn.close ()\\n lsd.pop_labelset ()\\n\\n \\n import psycopg2\\n for sql in cls.sql_createindex:\\n conn = get_labeled_conn ()\\n cur = conn.cursor ()\\n # XXX It would be better to check which indices exist as we do for tables.\\n try:\\n cur.execute (sql)\\n except psycopg2.ProgrammingError, e: \\n pass\\n conn.close ()\",\n \"def init_tables(self):\\n\\n settings.Base.metadata.tables[\\n 'session_master'].drop(bind=settings.engine)\\n settings.Base.metadata.tables['uurl'].drop(bind=settings.engine)\\n\\n settings.Base.metadata.tables[\\n 'session_master'].create(bind=settings.engine)\\n settings.Base.metadata.tables['uurl'].create(bind=settings.engine)\\n\\n logging.info(\\\"Sessionization Tables created\\\")\",\n \"def create_base_table(self, table_name):\\n print('new')\\n # Create table at first.\\n select_stm = self.construct_base_table()\\n exec_query('DROP TABLE IF EXISTS %s;' % table_name) \\n sql = \\\"\\\"\\\"\\n CREATE TABLE %s AS\\n %s\\n \\\"\\\"\\\" % (table_name, select_stm)\\n exec_query(sql)\",\n \"def create_table(self):\\n from deployflag.models.metadata import (\\n GridSearchParameter,\\n ModelFramework,\\n ModelPerformanceMetadata,\\n )\\n\\n with self.connection:\\n self.connection.create_tables(\\n [ModelPerformanceMetadata, GridSearchParameter, ModelFramework],\\n safe=True,\\n )\",\n \"def prespi_AccountBroker_initialize(self, conn, put_timestamp, **kwargs):\\n if not self.account:\\n raise ValueError(\\n 'Attempting to create a new database with no account set')\\n self.create_container_table(conn)\\n self.create_account_stat_table(conn, put_timestamp)\",\n \"def _create_tables():\\n from Model.DataAccessor.DbAccessor.DbOrmAccessor import db\\n db.create_tables([SubjectType, SubjectRegion, Subject])\",\n \"def create_table(user_id: int, jap_event_id: int) -> Table:\\n table = Table(emperor=user_id,\\n jap_event_id=jap_event_id,\\n status=0)\\n\\n member = User.query.filter(User.id.__eq__(user_id)).first()\\n table.members.append(member)\\n\\n db.session.add(table)\\n db.session.commit()\\n\\n table_id = table.id\\n command = CommandService.create_command(1, table_id)\\n table.current_command_id = command.id\\n\\n db.session.add(table, command)\\n db.session.commit()\\n return table\",\n \"def setup_table(self):\\n self.interface.start_transaction()\\n self.interface.drop_table(_history_table)\\n self.interface.drop_table(_history_stats_table)\\n self.interface.create_table(_history_table)\\n self.interface.create_index('index1', _history_table, [_history_table['timestamp']])\\n self.interface.create_table(_history_stats_table)\\n self.interface.create_index('index2', _history_stats_table, [_history_stats_table['benchmark']])\\n self.interface.commit_transaction()\",\n \"def __create_wallets_table(self):\\n cmd = \\\"\\\"\\\" CREATE TABLE IF NOT EXISTS %s (\\n %s text PRIMARY KEY,\\n %s blob,\\n %s blob);\\\"\\\"\\\" %(TABLE_WALLETS,\\n COL_WALLETS_NAME,\\n COL_WALLETS_PUB_KEY,\\n COL_WALLETS_PVT_KEY)\\n self.__dbcursor.execute(cmd)\",\n \"def create_database():\\n DB_NAME = 'cloud_storage.db'\\n DB_DIRECTORY = 'server_side_storage/'\\n db = sqlite3.connect('{}/{}'.format(DB_DIRECTORY, DB_NAME))\\n cursor = db.cursor()\\n cursor.execute('''CREATE TABLE user_ids\\n (row_id INTEGER PRIMARY KEY AUTOINCREMENT, uid TEXT, user_table_name TEXT)''')\\n db.commit()\\n cursor.close()\\n db.close()\",\n \"def _create(self):\\n with self.pdq:\\n c=self.pdq.cursor() \\n c.execute('CREATE TABLE pdq (item blob,priority int)')\\n c.execute('CREATE INDEX priority_index ON pdq (priority)')\",\n \"def _create_intermediate_delta_tables_structure(self, conn):\\n table_names = []\\n with conn.cursor() as cursor, CodeProfiler() as cp:\\n tblname = self._blacklist_delta_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n LIKE {blacklist_delta_tbl} INCLUDING DEFAULTS\\n INCLUDING IDENTITY\\n INCLUDING CONSTRAINTS\\n INCLUDING STORAGE\\n INCLUDING COMMENTS\\n ) PARTITION BY RANGE (virt_imei_shard)\\n \\\"\\\"\\\").format(sql.Identifier(tblname),\\n blacklist_delta_tbl=sql.Identifier(self._blacklist_tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._notifications_lists_delta_tblname\\n notifications_delta_tbl = sql.Identifier(self._notifications_lists_tblname)\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n LIKE {notifications_delta_tbl} INCLUDING DEFAULTS\\n INCLUDING IDENTITY\\n INCLUDING CONSTRAINTS\\n INCLUDING STORAGE\\n INCLUDING COMMENTS\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname),\\n notifications_delta_tbl=notifications_delta_tbl))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._notifications_lists_delta_part_tblname,\\n is_unlogged=True)\\n\\n tblname = self._exceptions_lists_delta_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n LIKE {exceptions_delta_tbl} INCLUDING DEFAULTS\\n INCLUDING IDENTITY\\n INCLUDING CONSTRAINTS\\n INCLUDING STORAGE\\n INCLUDING COMMENTS\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname),\\n exceptions_delta_tbl=sql.Identifier(self._exceptions_lists_tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._exceptions_lists_delta_part_tblname,\\n is_unlogged=True)\\n\\n self._intermediate_table_names.extend(table_names)\\n return -1, cp.duration\",\n \"def create_database_tables():\\n with APP.app_context():\\n DB.create_all()\",\n \"def _create_schema(self): \\n q = (\\\"CREATE TABLE IF NOT EXISTS \\\" + \\\\\\n \\\"profiles (username text, body text, epoch numeric)\\\",)\\n for x in q: self.cursor.execute(x)\\n self.conn.commit()\",\n \"def parseToDb(self):\\n self.cursor.execute('''DROP TABLE IF EXISTS policy''')\\n self.cursor.execute('''CREATE TABLE policy\\n (name text, src text, dst text, services text, action INTEGER)''')\",\n \"def test_create_hyperflex_cluster_storage_policy(self):\\n pass\",\n \"def create_table(self, conn, create_table_sql):\\n try:\\n # create a Cursor object and call its .execute() method to perform SQL queries\\n c = conn.cursor()\\n # execute SQL queries: create a table named card\\n c.execute(create_table_sql)\\n except Error as e:\\n print(e)\",\n \"def create_table(self, schema, table):\\n fields = \\\", \\\".join([\\\" \\\".join(t) for t in zip(self.schemas[schema][table][0], self.schemas[schema][table][1])])\\n sql = f'set role {self.write_role}; ' \\\\\\n + f'CREATE TABLE IF NOT EXISTS {schema}.{table} ( {fields} );'\\n return sql\",\n \"def create_dataBase(conn, create_cmd):\\n if conn:\\n cursor = conn.cursor()\\n cursor.execute(create_cmd)\\n conn.commit()\\n #print '[sql management] Table Created...'\",\n \"def ensure_schema(client, table_name):\\n query = ''.join([\\n 'CREATE TABLE {cf} ',\\n '(\\\"lockId\\\" ascii, \\\"claimId\\\" timeuuid, PRIMARY KEY(\\\"lockId\\\", \\\"claimId\\\"));'])\\n\\n def errback(failure):\\n failure.trap(InvalidRequestException)\\n\\n return client.execute(query.format(cf=table_name),\\n {}, ConsistencyLevel.QUORUM).addErrback(errback)\",\n \"def _init_db(self):\\n cursor = self._main_connection.cursor()\\n cursor.execute(self.sql[\\\"create_table\\\"])\\n self._main_connection.commit()\",\n \"async def create_sys_tables(self) -> None:\\n await self.conn.execute(\\\"\\\"\\\"CREATE TABLE IF NOT EXISTS tinymud_migrations (\\n table_name TEXT,\\n level INTEGER\\n )\\\"\\\"\\\")\",\n \"def create_container(cls, values):\\n dbdriver = get_instance()\\n return dbdriver.create_container(values)\",\n \"def init_tables(database_url, _metadata, checkfirst=True):\\n import dpds.storages.db.tables.operations\\n import dpds.storages.db.tables.block\\n import dpds.storages.db.tables.meta\\n with isolated_nullpool_engine(database_url) as engine:\\n _metadata.create_all(bind=engine, checkfirst=checkfirst)\",\n \"def _create_intermediate_old_tables_structure(self, conn):\\n table_names = []\\n with conn.cursor() as cursor, CodeProfiler() as cp:\\n tblname = self._blacklist_old_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL\\n ) PARTITION BY RANGE (virt_imei_shard)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n partition_utils.create_imei_shard_partitions(conn, tbl_name=tblname, unlogged=True)\\n table_names.append(tblname)\\n\\n tblname = self._notifications_lists_old_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n operator_id TEXT NOT NULL,\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL,\\n msisdn TEXT NOT NULL,\\n block_date DATE NOT NULL,\\n reasons TEXT[] NOT NULL,\\n amnesty_granted BOOLEAN\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._notifications_lists_old_part_tblname,\\n is_unlogged=True)\\n\\n tblname = self._exceptions_lists_old_tblname\\n cursor.execute(sql.SQL(\\\"\\\"\\\"CREATE UNLOGGED TABLE {0} (\\n operator_id TEXT NOT NULL,\\n imei_norm TEXT NOT NULL,\\n virt_imei_shard SMALLINT NOT NULL,\\n imsi TEXT NOT NULL\\n ) PARTITION BY LIST (operator_id)\\n \\\"\\\"\\\").format(sql.Identifier(tblname)))\\n table_names.append(tblname)\\n self._create_operator_partitions(conn,\\n parent_tbl_name=tblname,\\n child_name_fn=self._exceptions_lists_old_part_tblname,\\n is_unlogged=True)\\n\\n self._intermediate_table_names.extend(table_names)\\n return -1, cp.duration\",\n \"def test_create_hyperflex_ext_fc_storage_policy(self):\\n pass\",\n \"def create_new_index(self, dict_pg_info):\\n # ! Setting if fun can use default setting\\n ruler = Rules()\\n str_conn = ruler.pg_info_rules(dict_pg_info)\\n conn = psycopg2.connect(str_conn)\\n\\n with conn:\\n with conn.cursor() as cur:\\n str_create_table = \\\"CREATE TABLE \\\" + dict_pg_info['table'] + \\\" (path varchar PRIMARY KEY);\\\"\\n # ! Check if table already exit\\n cur.execute(str_create_table)\\n cur.close()\\n\\n conn.close()\",\n \"def create_table(table_name:str, database_name:str='dars_nic_391419_j3w9t_collab', select_sql_script:str=None) -> None:\\n \\n spark.conf.set(\\\"spark.sql.legacy.allowCreatingManagedTableUsingNonemptyLocation\\\",\\\"true\\\")\\n \\n if select_sql_script is None:\\n select_sql_script = f\\\"SELECT * FROM global_temp.{table_name}\\\"\\n \\n spark.sql(f\\\"\\\"\\\"CREATE TABLE {database_name}.{table_name} AS\\n {select_sql_script}\\n \\\"\\\"\\\")\\n spark.sql(f\\\"ALTER TABLE {database_name}.{table_name} OWNER TO {database_name}\\\")\",\n \"def create_table(opts, stats):\\n print(\\\"--------------------------------------\\\")\\n print(\\\"Creating table %s\\\" % (opts.table_name,))\\n print(\\\"--------------------------------------\\\")\\n print(timestamp())\\n create_table_ddl = \\\"CREATE TABLE %s (\\\" % (opts.table_name,)\\n num_bigint_cols = opts.columns - opts.num_string_columns\\n assert(num_bigint_cols > 0)\\n for i in range(opts.columns):\\n coltype = 'STRING'\\n if i < num_bigint_cols: coltype = 'BIGINT'\\n if i > 0: create_table_ddl += ', '\\n create_table_ddl += \\\"f%d %s\\\" % (i, coltype)\\n if i == 0: create_table_ddl += ' PRIMARY KEY'\\n create_table_ddl += \\\") PARTITION BY HASH(f0) PARTITIONS %d STORED AS KUDU \\\" % \\\\\\n (opts.partitions, )\\n create_table_ddl += \\\"TBLPROPERTIES ('kudu.num_tablet_replicas' = '%d')\\\" % \\\\\\n (opts.replication_factor, )\\n\\n cmd = 'echo \\\"%s\\\" | impala-shell -i %s -f -' % (create_table_ddl, opts.impalad_address)\\n run_command(opts, cmd)\",\n \"def make_cache_table(metadata, table_name='beaker_cache', schema_name=None):\\n return sa.Table(table_name, metadata,\\n sa.Column('namespace', sa.String(255), primary_key=True),\\n sa.Column('accessed', sa.DateTime, nullable=False),\\n sa.Column('created', sa.DateTime, nullable=False),\\n sa.Column('data', sa.PickleType, nullable=False),\\n schema=schema_name if schema_name else metadata.schema)\",\n \"def createTable(self):\\n results = self.db.table_create(self.entity).run(self.r)\\n time.sleep(5)\\n return results\",\n \"def _create_schema(self):\\n self._conn.executescript(self._db_schema)\",\n \"def create_table():\\n conn = psycopg2.connect(host=\\\"localhost\\\", database=\\\"integration\\\", user=\\\"postgres\\\", password=\\\"postgres\\\")\\n cursor = conn.cursor()\\n cursor.execute(CREATE_TABLE)\\n conn.commit()\\n cursor.close()\",\n \"def _setup_origin_table(self):\\n if self._create_table_if_not_exists(self.dataset):\\n return\\n\\n directory, pipeline_builder = self._directory_origin(MAX_CONCURRENCY)\\n jdbc_producer = pipeline_builder.add_stage('JDBC Producer', type='destination')\\n jdbc_producer.set_attributes(default_operation=\\\"INSERT\\\",\\n field_to_column_mapping=[],\\n enclose_object_names=True,\\n use_multi_row_operation=True,\\n statement_parameter_limit=32768,\\n table_name=self.dataset)\\n\\n directory >> jdbc_producer\\n\\n pipeline = pipeline_builder.build().configure_for_environment(self.environments['database'])\\n self.sdc_executor.add_pipeline(pipeline)\\n self.sdc_executor.start_pipeline(pipeline).wait_for_pipeline_output_records_count(self.record_count, timeout_sec=LOAD_TIMEOUT)\\n self.sdc_executor.stop_pipeline(pipeline)\\n self.sdc_executor.remove_pipeline(pipeline)\",\n \"def sql_create_big_table():\\n return \\\"\\\"\\\"\\n SELECT\\n m.tube_assembly_id as 'tube_assembly_id'\\n , m.quantity_1 as 'quantity_component'\\n , c.component_id \\n , c.component_type_id \\n , c.type as component_type \\n , c.connection_type_id\\n , c.outside_shape\\n , c.base_type\\n , c.height_over_tube\\n , c.bolt_pattern_long\\n , c.bolt_pattern_wide\\n , c.groove\\n , c.base_diameter\\n , c.shoulder_diameter\\n , c.unique_feature\\n , c.orientation\\n , c.weight\\n , p.supplier\\n , p.quote_date\\n , p.annual_usage\\n , p.min_order_quantity\\n , p.bracket_pricing\\n , p.quantity\\n , p.cost\\n FROM\\n stg_bill_of_materials m INNER JOIN stg_comp_boss c\\n ON m.component_id_1 = c.component_id\\n \\n INNER JOIN stg_price_quote p\\n ON m.tube_assembly_id = p.tube_assembly_id\\n \\\"\\\"\\\"\",\n \"def upgrade():\\n # # commands auto generated by Alembic - please adjust! ###\\n op.create_table('downstream_map',\\n sa.Column('key', sa.String(length=255), nullable=False),\\n sa.Column('value', sa.String(length=512), nullable=True),\\n sa.PrimaryKeyConstraint('key'))\\n # # end Alembic commands ###\",\n \"def create_all_tables(self):\\n pass\",\n \"def _create_table(self) :\\n\\n cur = self.con.cursor()\\n delete_sql = 'DROP TABLE IF EXISTS \\\"%s\\\"' % self.name\\n cur.execute(delete_sql)\\n\\n col_sql = ','.join(['\\\"%s\\\" %s' % (self.cols[i], self.types[i])\\n for i in range(len(self.cols))])\\n create_sql = 'CREATE TABLE \\\"%s\\\" ( %s );' % (self.name, col_sql)\\n cur.execute(create_sql)\",\n \"def _get_db_create_table(self, frame):\\r\\n\\r\\n columns = (u',\\\\n'.\\r\\n\\r\\n join([u' `%s` DECIMAL(20,5) DEFAULT NULL COMMENT \\\"%s\\\"' %\\r\\n\\r\\n (self._get_db_name(name), name) for name in\\r\\n\\r\\n frame.index.values]))\\r\\n\\r\\n table_name = self._get_db_table_name(frame)\\r\\n\\r\\n return (\\r\\n\\r\\n u'CREATE TABLE `%s` (\\\\n' % table_name +\\r\\n\\r\\n u' `ticker` VARCHAR(50) NOT NULL COMMENT \\\"Exchange:Ticker\\\",\\\\n' +\\r\\n\\r\\n u' `period` DATE NOT NULL COMMENT \\\"Period\\\",\\\\n' +\\r\\n\\r\\n u'%s,\\\\n' % columns +\\r\\n\\r\\n u' PRIMARY KEY USING BTREE (`ticker`, `period`),\\\\n' +\\r\\n\\r\\n u' KEY `ix_ticker` USING BTREE (`ticker`))\\\\n' +\\r\\n\\r\\n u'ENGINE=MyISAM DEFAULT CHARSET=utf8\\\\n' +\\r\\n\\r\\n u'COMMENT = \\\"%s\\\"' % frame.index.name)\",\n \"def create_new_table():\\n dataset = create_dataset()\\n table_id = \\\"{}.{}.corona_cases_table\\\".format(client.project, dataset.dataset_id)\\n table = bigquery.Table(table_id)\\n table = client.create_table(table, exists_ok=True)\\n print(\\n \\\"Created table {}.{}.{}\\\".format(table.project, table.dataset_id, table.table_id)\\n )\\n return table\",\n \"def build_metadata():\\n metadata = sa.MetaData()\\n\\n sa.Table(\\n 'hive_blocks', metadata,\\n sa.Column('num', sa.Integer, primary_key=True, autoincrement=False),\\n sa.Column('hash', CHAR(40), nullable=False),\\n sa.Column('prev', CHAR(40)),\\n sa.Column('txs', SMALLINT, server_default='0', nullable=False),\\n sa.Column('ops', SMALLINT, server_default='0', nullable=False),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n\\n sa.UniqueConstraint('hash', name='hive_blocks_ux1'),\\n sa.ForeignKeyConstraint(['prev'], ['hive_blocks.hash'], name='hive_blocks_fk1'),\\n )\\n\\n sa.Table(\\n 'hive_accounts', metadata,\\n sa.Column('id', sa.Integer, primary_key=True),\\n sa.Column('name', VARCHAR(16), nullable=False),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n #sa.Column('block_num', sa.Integer, nullable=False),\\n sa.Column('reputation', sa.Float(precision=6), nullable=False, server_default='25'),\\n\\n sa.Column('display_name', sa.String(20)),\\n sa.Column('about', sa.String(160)),\\n sa.Column('location', sa.String(30)),\\n sa.Column('website', sa.String(100)),\\n sa.Column('profile_image', sa.String(1024), nullable=False, server_default=''),\\n sa.Column('cover_image', sa.String(1024), nullable=False, server_default=''),\\n\\n sa.Column('followers', sa.Integer, nullable=False, server_default='0'),\\n sa.Column('following', sa.Integer, nullable=False, server_default='0'),\\n\\n sa.Column('proxy', VARCHAR(16), nullable=False, server_default=''),\\n sa.Column('post_count', sa.Integer, nullable=False, server_default='0'),\\n sa.Column('proxy_weight', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('vote_weight', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('kb_used', sa.Integer, nullable=False, server_default='0'), # deprecated\\n sa.Column('rank', sa.Integer, nullable=False, server_default='0'),\\n\\n sa.Column('lastread_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\\n sa.Column('active_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\\n sa.Column('cached_at', sa.DateTime, nullable=False, server_default='1970-01-01 00:00:00'),\\n sa.Column('raw_json', sa.Text),\\n\\n\\n sa.UniqueConstraint('name', name='hive_accounts_ux1'),\\n sa.Index('hive_accounts_ix1', 'vote_weight', 'id'), # core: quick ranks\\n sa.Index('hive_accounts_ix2', 'name', 'id'), # core: quick id map\\n sa.Index('hive_accounts_ix3', 'vote_weight', 'name', postgresql_ops=dict(name='varchar_pattern_ops')), # API: lookup\\n sa.Index('hive_accounts_ix4', 'id', 'name'), # API: quick filter/sort\\n sa.Index('hive_accounts_ix5', 'cached_at', 'name'), # core/listen sweep\\n )\\n\\n sa.Table(\\n 'hive_posts', metadata,\\n sa.Column('id', sa.Integer, primary_key=True),\\n sa.Column('parent_id', sa.Integer),\\n sa.Column('author', VARCHAR(16), nullable=False),\\n sa.Column('permlink', VARCHAR(255), nullable=False),\\n sa.Column('category', VARCHAR(255), nullable=False, server_default=''),\\n sa.Column('community_id', sa.Integer, nullable=True),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n sa.Column('depth', SMALLINT, nullable=False),\\n sa.Column('is_deleted', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_pinned', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_muted', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_valid', BOOLEAN, nullable=False, server_default='1'),\\n sa.Column('promoted', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\\n\\n sa.ForeignKeyConstraint(['author'], ['hive_accounts.name'], name='hive_posts_fk1'),\\n sa.ForeignKeyConstraint(['parent_id'], ['hive_posts.id'], name='hive_posts_fk3'),\\n sa.UniqueConstraint('author', 'permlink', name='hive_posts_ux1'),\\n sa.Index('hive_posts_ix3', 'author', 'depth', 'id', postgresql_where=sql_text(\\\"is_deleted = '0'\\\")), # API: author blog/comments\\n sa.Index('hive_posts_ix4', 'parent_id', 'id', postgresql_where=sql_text(\\\"is_deleted = '0'\\\")), # API: fetching children\\n sa.Index('hive_posts_ix5', 'id', postgresql_where=sql_text(\\\"is_pinned = '1' AND is_deleted = '0'\\\")), # API: pinned post status\\n sa.Index('hive_posts_ix6', 'community_id', 'id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_pinned = '1' AND is_deleted = '0'\\\")), # API: community pinned\\n )\\n\\n sa.Table(\\n 'hive_post_tags', metadata,\\n sa.Column('post_id', sa.Integer, nullable=False),\\n sa.Column('tag', sa.String(32), nullable=False),\\n sa.UniqueConstraint('tag', 'post_id', name='hive_post_tags_ux1'), # core\\n sa.Index('hive_post_tags_ix1', 'post_id'), # core\\n )\\n\\n sa.Table(\\n 'hive_follows', metadata,\\n sa.Column('follower', sa.Integer, nullable=False),\\n sa.Column('following', sa.Integer, nullable=False),\\n sa.Column('state', SMALLINT, nullable=False, server_default='1'),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n\\n sa.UniqueConstraint('following', 'follower', name='hive_follows_ux3'), # core\\n sa.Index('hive_follows_ix5a', 'following', 'state', 'created_at', 'follower'),\\n sa.Index('hive_follows_ix5b', 'follower', 'state', 'created_at', 'following'),\\n )\\n\\n sa.Table(\\n 'hive_reblogs', metadata,\\n sa.Column('account', VARCHAR(16), nullable=False),\\n sa.Column('post_id', sa.Integer, nullable=False),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n\\n sa.ForeignKeyConstraint(['account'], ['hive_accounts.name'], name='hive_reblogs_fk1'),\\n sa.ForeignKeyConstraint(['post_id'], ['hive_posts.id'], name='hive_reblogs_fk2'),\\n sa.UniqueConstraint('account', 'post_id', name='hive_reblogs_ux1'), # core\\n sa.Index('hive_reblogs_ix1', 'post_id', 'account', 'created_at'), # API -- not yet used\\n )\\n\\n sa.Table(\\n 'hive_payments', metadata,\\n sa.Column('id', sa.Integer, primary_key=True),\\n sa.Column('block_num', sa.Integer, nullable=False),\\n sa.Column('tx_idx', SMALLINT, nullable=False),\\n sa.Column('post_id', sa.Integer, nullable=False),\\n sa.Column('from_account', sa.Integer, nullable=False),\\n sa.Column('to_account', sa.Integer, nullable=False),\\n sa.Column('amount', sa.types.DECIMAL(10, 3), nullable=False),\\n sa.Column('token', VARCHAR(5), nullable=False),\\n\\n sa.ForeignKeyConstraint(['from_account'], ['hive_accounts.id'], name='hive_payments_fk1'),\\n sa.ForeignKeyConstraint(['to_account'], ['hive_accounts.id'], name='hive_payments_fk2'),\\n sa.ForeignKeyConstraint(['post_id'], ['hive_posts.id'], name='hive_payments_fk3'),\\n )\\n\\n sa.Table(\\n 'hive_feed_cache', metadata,\\n sa.Column('post_id', sa.Integer, nullable=False),\\n sa.Column('account_id', sa.Integer, nullable=False),\\n sa.Column('created_at', sa.DateTime, nullable=False),\\n sa.UniqueConstraint('post_id', 'account_id', name='hive_feed_cache_ux1'), # core\\n sa.Index('hive_feed_cache_ix1', 'account_id', 'post_id', 'created_at'), # API (and rebuild?)\\n )\\n\\n sa.Table(\\n 'hive_posts_cache', metadata,\\n sa.Column('post_id', sa.Integer, primary_key=True, autoincrement=False),\\n sa.Column('author', VARCHAR(16), nullable=False),\\n sa.Column('permlink', VARCHAR(255), nullable=False),\\n sa.Column('category', VARCHAR(255), nullable=False, server_default=''),\\n\\n # important/index\\n sa.Column('community_id', sa.Integer, nullable=True),\\n sa.Column('depth', SMALLINT, nullable=False, server_default='0'),\\n sa.Column('children', SMALLINT, nullable=False, server_default='0'),\\n\\n # basic/extended-stats\\n sa.Column('author_rep', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('flag_weight', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('total_votes', sa.Integer, nullable=False, server_default='0'),\\n sa.Column('up_votes', sa.Integer, nullable=False, server_default='0'),\\n\\n # basic ui fields\\n sa.Column('title', sa.String(255), nullable=False, server_default=''),\\n sa.Column('preview', sa.String(1024), nullable=False, server_default=''),\\n sa.Column('img_url', sa.String(1024), nullable=False, server_default=''),\\n\\n # core stats/indexes\\n sa.Column('payout', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\\n sa.Column('promoted', sa.types.DECIMAL(10, 3), nullable=False, server_default='0'),\\n sa.Column('created_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\\n sa.Column('payout_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\\n sa.Column('updated_at', sa.DateTime, nullable=False, server_default='1990-01-01'),\\n sa.Column('is_paidout', BOOLEAN, nullable=False, server_default='0'),\\n\\n # ui flags/filters\\n sa.Column('is_nsfw', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_declined', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_full_power', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_hidden', BOOLEAN, nullable=False, server_default='0'),\\n sa.Column('is_grayed', BOOLEAN, nullable=False, server_default='0'),\\n\\n # important indexes\\n sa.Column('rshares', sa.BigInteger, nullable=False, server_default='0'),\\n sa.Column('sc_trend', sa.Float(precision=6), nullable=False, server_default='0'),\\n sa.Column('sc_hot', sa.Float(precision=6), nullable=False, server_default='0'),\\n\\n # bulk data\\n sa.Column('body', TEXT),\\n sa.Column('votes', TEXT),\\n sa.Column('json', sa.Text),\\n sa.Column('raw_json', sa.Text),\\n\\n # index: misc\\n sa.Index('hive_posts_cache_ix3', 'payout_at', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # core: payout sweep\\n sa.Index('hive_posts_cache_ix8', 'category', 'payout', 'depth', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: tag stats\\n\\n # index: ranked posts\\n sa.Index('hive_posts_cache_ix2', 'promoted', postgresql_where=sql_text(\\\"is_paidout = '0' AND promoted > 0\\\")), # API: promoted\\n\\n sa.Index('hive_posts_cache_ix6a', 'sc_trend', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: trending todo: depth=0\\n sa.Index('hive_posts_cache_ix7a', 'sc_hot', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: hot todo: depth=0\\n sa.Index('hive_posts_cache_ix6b', 'post_id', 'sc_trend', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: trending, filtered todo: depth=0\\n sa.Index('hive_posts_cache_ix7b', 'post_id', 'sc_hot', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: hot, filtered todo: depth=0\\n\\n sa.Index('hive_posts_cache_ix9a', 'depth', 'payout', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: payout todo: rem depth\\n sa.Index('hive_posts_cache_ix9b', 'category', 'depth', 'payout', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: payout, filtered todo: rem depth\\n\\n sa.Index('hive_posts_cache_ix10', 'post_id', 'payout', postgresql_where=sql_text(\\\"is_grayed = '1' AND payout > 0\\\")), # API: muted, by filter/date/payout\\n\\n # index: stats\\n sa.Index('hive_posts_cache_ix20', 'community_id', 'author', 'payout', 'post_id', postgresql_where=sql_text(\\\"is_paidout = '0'\\\")), # API: pending distribution; author payout\\n\\n # index: community ranked posts\\n sa.Index('hive_posts_cache_ix30', 'community_id', 'sc_trend', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\\\")), # API: community trend\\n sa.Index('hive_posts_cache_ix31', 'community_id', 'sc_hot', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\\\")), # API: community hot\\n sa.Index('hive_posts_cache_ix32', 'community_id', 'created_at', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '0' AND depth = 0\\\")), # API: community created\\n sa.Index('hive_posts_cache_ix33', 'community_id', 'payout', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '0' AND is_paidout = '0'\\\")), # API: community payout\\n sa.Index('hive_posts_cache_ix34', 'community_id', 'payout', 'post_id', postgresql_where=sql_text(\\\"community_id IS NOT NULL AND is_grayed = '1' AND is_paidout = '0'\\\")), # API: community muted\\n )\\n\\n sa.Table(\\n 'hive_state', metadata,\\n sa.Column('block_num', sa.Integer, primary_key=True, autoincrement=False),\\n sa.Column('db_version', sa.Integer, nullable=False),\\n sa.Column('steem_per_mvest', sa.types.DECIMAL(8, 3), nullable=False),\\n sa.Column('usd_per_steem', sa.types.DECIMAL(8, 3), nullable=False),\\n sa.Column('sbd_per_steem', sa.types.DECIMAL(8, 3), nullable=False),\\n sa.Column('dgpo', sa.Text, nullable=False),\\n )\\n\\n metadata = build_metadata_community(metadata)\\n\\n metadata = build_metadata_blacklist(metadata)\\n\\n metadata = build_trxid_block_num(metadata)\\n\\n return metadata\",\n \"def create_tables(cursor):\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE users(\\n userid INTEGER PRIMARY KEY,\\n username TEXT NOT NULL,\\n password TEXT NOT NULL,\\n email TEXT NOT NULL\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE groups(\\n groupid INTEGER PRIMARY KEY,\\n name TEXT NOT NULL\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE usergroups(\\n userid INTEGER,\\n groupid INTEGER,\\n PRIMARY KEY (userid, groupid)\\n FOREIGN KEY (userid) REFERENCES users (userid)\\n ON DELETE CASCADE ON UPDATE NO ACTION\\n FOREIGN KEY (groupid) REFERENCES groups (groupid)\\n ON DELETE CASCADE ON UPDATE NO ACTION\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE settings(\\n key TEXT PRIMARY KEY,\\n value\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE sessions(\\n userid INTEGER PRIMARY KEY,\\n key TEXT NOT NULL,\\n started TEXT DEFAULT (datetime('now')),\\n FOREIGN KEY (userid) REFERENCES users (userid)\\n ON DELETE CASCADE ON UPDATE NO ACTION\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"CREATE UNIQUE INDEX idx_groups_name ON groups (name)\\\")\\n cursor.execute(\\n \\\"CREATE UNIQUE INDEX idx_users_username ON users (username)\\\"\\n )\",\n \"async def _create_table(self, table: TableSchema) -> None:\\n try:\\n await self.conn.execute(get_create_table(table))\\n except PostgresError: # Only DB related exceptions\\n print(f\\\"Failed to execute CREATE TABLE for {table['name']}\\\")\\n raise\\n # Initialize migration level (so that it can be altered in future)\\n await self.conn.execute('INSERT INTO tinymud_migrations (table_name, level) VALUES ($1, $2)', table['name'], 0)\",\n \"def schema_upgrades():\\n op.create_table('vpp_licenses',\\n sa.Column('license_id', sa.Integer(), nullable=False),\\n sa.Column('adam_id', sa.String(), nullable=True),\\n sa.Column('product_type', sa.Enum('Software', 'Application', 'Publication', name='vppproducttype'), nullable=True),\\n sa.Column('product_type_name', sa.String(), nullable=True),\\n sa.Column('pricing_param', sa.Enum('StandardQuality', 'HighQuality', name='vpppricingparam'), nullable=True),\\n sa.Column('is_irrevocable', sa.Boolean(), nullable=True),\\n sa.Column('user_id', sa.Integer(), nullable=True),\\n sa.Column('client_user_id', commandment.dbtypes.GUID(), nullable=True),\\n sa.Column('its_id_hash', sa.String(), nullable=True),\\n sa.ForeignKeyConstraint(['client_user_id'], ['vpp_users.client_user_id'], ),\\n sa.ForeignKeyConstraint(['user_id'], ['vpp_users.user_id'], ),\\n sa.PrimaryKeyConstraint('license_id')\\n )\",\n \"def create_staging_schema(cursor,table_schema):\\n create_schema = \\\"CREATE SCHEMA IF NOT EXISTS \\\" + table_schema + \\\";\\\"\\n cursor.execute(create_schema)\",\n \"def db_create_table(db_in, tablename):\\n connection = db_in.connection.cursor()\\n connection.execute('CREATE TABLE IF NOT EXISTS %s(id INTEGER PRIMARY KEY);' % tablename)\",\n \"def create_marker_table(self):\\n if self.marker_table is None:\\n self.marker_table = luigi.configuration.get_config().get('sqlalchemy', 'marker-table', 'table_updates')\\n\\n engine = self.engine\\n\\n with engine.begin() as con:\\n metadata = sqlalchemy.MetaData()\\n if not con.dialect.has_table(con, self.marker_table):\\n self.marker_table_bound = sqlalchemy.Table(\\n self.marker_table, metadata,\\n sqlalchemy.Column(\\\"ParquetSource\\\", sqlalchemy.String(128), primary_key=True),\\n sqlalchemy.Column(\\\"TargetTable\\\", sqlalchemy.String(128)),\\n sqlalchemy.Column(\\\"Environment\\\", sqlalchemy.String(128)),\\n sqlalchemy.Column(\\\"BackupDate\\\", sqlalchemy.DateTime),\\n sqlalchemy.Column(\\\"InsertedDate\\\", sqlalchemy.DateTime, default=datetime.now()))\\n metadata.create_all(engine)\\n else:\\n metadata.reflect(only=[self.marker_table], bind=engine)\\n self.marker_table_bound = metadata.tables[self.marker_table]\",\n \"def create_table(self, create_table_sql):\\n print('connect')\\n conn = psycopg2.connect(self.name, sslmode='require')\\n c = conn.cursor()\\n c.execute(create_table_sql)\\n conn.close()\",\n \"def create_tables(self):\\n con = self.connect()\\n cursor = con.cursor()\\n queries = self.tables()\\n for query in queries:\\n cursor.execute(query)\\n cursor.close()\\n con.commit()\\n con.close()\",\n \"def __create_table(self):\\n\\n self.connection = self.db.connect()\\n self.metadata = MetaData(self.connection)\\n\\n self.system = Table(self.table_name, self.metadata,\\n Column('timestamp', DateTime(), primary_key=True, nullable=False),\\n Column('vibration_sensor', Float()),\\n Column('flow', Float()),\\n Column('pressure', Float()),\\n Column('power_consumption', Float()),\\n Column('failure_times', Float()),\\n Column('operational', Boolean())\\n )\\n\\n self.metadata.create_all()\",\n \"def create_tables():\\n db.create_all()\",\n \"def create_tables():\\n db.create_all()\",\n \"def create_applications_table(cls):\\n cursor = Database.connect_to_db()\\n sql_command = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS \\\"public\\\".\\\"applications\\\" (\\n id SERIAL ,\\n party_name VARCHAR(255) NOT NULL,\\n office_name VARCHAR(255) NOT NULL,\\n user_id INTEGER NOT NULL,\\n date_created VARCHAR(80),\\n status VARCHAR(255) NOT NULL,\\n PRIMARY KEY (id),\\n FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE\\n )\\n \\\"\\\"\\\"\\n cursor.execute(sql_command)\",\n \"def create_tables( self ) :\\n return self._create_tables\",\n \"def create_table(self, schema: str, table: str, col_types: dict, non_null_columns: List[str]):\\n return\",\n \"def create_tables(self):\\n\\n self.cur.execute('''CREATE TABLE IF NOT EXISTS my_business_entry\\n (\\n id SERIAL PRIMARY KEY,\\n url_yes_no boolean,\\n url TEXT,\\n phone_yes_no boolean,\\n phone TEXT,\\n rating TEXT,\\n nr_of_ratings TEXT,\\n myBusiness boolean,\\n company TEXT\\n );''')\\n\\n self.connection.commit()\",\n \"def createTables(self,table=\\\"all\\\"):\\n auto=\\\"\\\"\\n\\tif self.dbType==\\\"mysql\\\":\\n\\t auto=\\\"AUTO_INCREMENT\\\"\\n\\t \\n\\ttableName=\\\"FileID\\\"\\n if table==\\\"all\\\" or table==tableName:\\n\\t # Drop/create FileID table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"CREATE TABLE %s (\\n\\t fileid %s %s PRIMARY KEY, \\n\\t fileName TEXT,\\n\\t typeid %s\\n\\t )\\n\\t \\\"\\\"\\\"%(tableName,self.long,auto,self.UINT)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\n\\ttableName=\\\"KeyFile\\\"\\n\\tif table==\\\"all\\\" or table==tableName: \\n\\t # Drop/create KeyFile table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"\\n\\t CREATE TABLE %s (\\n\\t graphid %s NOT NULL, \\n\\t view VARCHAR(255) NOT NULL, \\n\\t run %s NOT NULL, \\n\\t uid %s, \\n\\t keyFileId %s NOT NULL, PRIMARY KEY(graphid,view,run,uid) )\\n\\t \\\"\\\"\\\"%(tableName,self.UINT,self.UINT,self.uid,self.UINT)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\t\\n\\ttableName=\\\"RunUID\\\"\\n if table==\\\"all\\\" or table==tableName:\\n\\t # Drop/create RunUID table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"\\n\\t CREATE TABLE %s (\\n\\t run %s NOT NULL,\\n\\t uid %s )\\n\\t \\\"\\\"\\\"%(tableName,self.UINT,self.uid)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\n\\ttableName=\\\"MaxMasterID\\\"\\n if table==tableName:\\n\\t # Drop/create RunUID table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"\\n\\t CREATE TABLE %s (\\n\\t masterMaxId %s NOT NULL,\\n\\t comment TEXT )\\n\\t \\\"\\\"\\\"%(tableName,self.UINT)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\n\\ttableName=\\\"Location\\\"\\n if table==\\\"all\\\" or table==tableName:\\n\\t # Drop/create Localtion table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"\\n\\t CREATE TABLE %s (\\n\\t id %s %s PRIMARY KEY,\\n\\t graphid %s NOT NULL, \\n\\t run %s NOT NULL, \\n\\t uid %s, \\n\\t locationFileId %s NOT NULL )\\n\\t \\\"\\\"\\\"%(tableName,self.long,auto,self.UINT,self.UINT,self.uid,self.UINT)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t query = \\\"CREATE INDEX LocationGroups ON Location(graphid,run,uid)\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\n\\ttableName=\\\"Version\\\"\\n if table==\\\"all\\\" or table==tableName:\\n\\t # Drop/create Version table in SQLDB.EventStoreDB\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"\\n\\t CREATE TABLE %s (\\n\\t id %s %s PRIMARY KEY,\\n\\t grade VARCHAR(255) NOT NULL, \\n\\t timeStamp %s NOT NULL, \\n\\t minRunNumber %s NOT NULL, \\n\\t maxRunNumber %s NOT NULL, \\n\\t graphid %s NOT NULL,\\n\\t state VARCHAR(10) ) \\n\\t \\\"\\\"\\\"%(tableName,self.long,auto,self.UINT,self.UINT,self.UINT,self.UINT)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\n\\ttableName=\\\"SpecificVersion\\\"\\n if table==\\\"all\\\" or table==tableName:\\n\\t # Drop/create SpecificVersion table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"\\n\\t CREATE TABLE %s (\\n\\t svName VARCHAR(255) NOT NULL PRIMARY KEY, \\n\\t svid %s NOT NULL )\\n\\t \\\"\\\"\\\"%(tableName,self.UINT)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\n\\ttableName=\\\"SpecificVersionComment\\\"\\n if table==\\\"all\\\" or table==tableName:\\n\\t # Drop/create SpecificVersionComment table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"\\n\\t CREATE TABLE %s (\\n\\t id %s %s NOT NULL PRIMARY KEY,\\n\\t svid %s NOT NULL,\\n\\t CommentDate %s,\\n\\t Comment TEXT )\\n\\t \\\"\\\"\\\"%(tableName,self.UINT,auto,self.UINT,self.UINT)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\n\\ttableName=\\\"GraphPath\\\"\\n if table==\\\"all\\\" or table==tableName:\\n\\t # Drop/create GraphPath table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"\\n\\t CREATE TABLE %s (\\n\\t graphid %s NOT NULL PRIMARY KEY, \\n\\t svid %s NOT NULL )\\n\\t \\\"\\\"\\\"%(tableName,self.UINT,self.UINT)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\n\\ttableName=\\\"PathDepend\\\"\\n if table==\\\"all\\\" or table==tableName:\\n\\t # Drop/create GraphPath table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"\\n\\t CREATE TABLE %s (\\n\\t parentId %s, \\n\\t childId %s NOT NULL )\\n\\t \\\"\\\"\\\"%(tableName,self.UINT,self.UINT)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\n\\ttableName=\\\"FileType\\\"\\n if table==\\\"all\\\" or table==tableName: \\n\\t # Drop/create FileType table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"CREATE TABLE %s (\\n\\t id %s %s PRIMARY KEY, \\n\\t type VARCHAR(8) NOT NULL,\\n\\t description TEXT )\\n\\t \\\"\\\"\\\"%(tableName,self.UINT,auto)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\\n\\t\\n\\ttableName=\\\"OrphanFileID\\\"\\n if table==\\\"all\\\" or table==tableName:\\n\\t # Drop/create FileType table in SQLDB.EventStore\\n\\t self.dropTable(tableName)\\n\\t query = \\\"\\\"\\\"CREATE TABLE %s (\\n\\t id %s PRIMARY KEY, \\n\\t dateTime DATETIME,\\n\\t user VARCHAR(8) NOT NULL )\\n\\t \\\"\\\"\\\"%(tableName,self.long)\\n\\t if self.dbType==\\\"mysql\\\": query+=\\\" type=innodb\\\"\\n\\t self.updateDBAndLog(query)\\n\\t if not self.schemaDict.has_key(tableName):\\n\\t self.schemaDict[tableName]=query\",\n \"def creating_big_table():\\n engine = connecting_database()\\n if engine is None:\\n return False\\n\\n sql = sql_create_big_table()\\n engine = connecting_database()\\n print(\\\">> Creating the table: bt_challenge_boa\\\")\\n df = pd.read_sql(sql=sql, con=engine)\\n df.to_sql(\\\"bt_challenge_boa\\\", con=engine, index=False, if_exists='replace')\\n\\n return True\",\n \"def _create_tables(self):\\n\\n print(\\\"\\\\n ** Creating DynamoDB Tables\\\")\\n\\n # Create Tables\\n for table_config in self.table_list:\\n with open(os.path.join(self.config_dir, table_config), \\\"rt\\\") as handle:\\n config_data = json.load(handle)\\n story_table = DynamoDB(DynamoTable.STACK_NAME, config_data[self.stack_name])\\n story_table.create()\",\n \"def create_table():\\n with create_connection() as conn:\\n cur = conn.cursor()\\n cur.execute(query=SQL_STATEMENT)\\n return conn\",\n \"def _db_init_data_tables(self):\\n\\n #\\n # TESTTYPE table\\n #\\n return self._db_execute(\\n \\\"\\\"\\\"\\n create table TESTTYPE (\\n KEY text unique,\\n VALUE text\\n )\\n \\\"\\\"\\\"\\n )\",\n \"def createschema(self):\\n def closure(cur):\\n cur.execute(\\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS config (\\n key varchar(1024) PRIMARY KEY,\\n value text\\n );\\n CREATE TABLE IF NOT EXISTS rooms (\\n id serial PRIMARY KEY,\\n name text NOT NULL\\n );\\n CREATE TABLE IF NOT EXISTS slides (\\n id serial PRIMARY KEY,\\n -- The ordering index of the slide, set to NULL if slide should be hidden\\n sequence_no integer NULL UNIQUE,\\n -- The room that should be displayed on this slide, set to NULL for master slides aren't associated with a room\\n room integer REFERENCES rooms NULL,\\n -- The masters are numbered sequentially and defined in content.py\\n master integer NOT NULL,\\n -- Overrides the title (normally the room name will be used)\\n title text NULL,\\n -- If max_rows is NULL, use the config default\\n max_rows integer NULL\\n );\\n CREATE TABLE IF NOT EXISTS events (\\n id serial PRIMARY KEY,\\n room integer REFERENCES rooms NOT NULL,\\n begins timestamp NOT NULL,\\n ends timestamp NOT NULL,\\n name text NOT NULL\\n );\\n \\\"\\\"\\\")\\n \\n self.execute(closure)\",\n \"def create_tables():\\n db.create_all()\",\n \"def create_table(self):\\n table = self.table\\n table.create()\\n return table.bind.wait()\",\n \"def create_db_tables():\\n\\n try:\\n webapp.dbsql.create_all()\\n webapp.dbsql.session.commit()\\n except Exception as e:\\n # TODO: melhorar o informe do erro\\n raise e\",\n \"def __create_presentations_table(self, schema=PRESENTATIONS_SCHEMA_310):\\r\\n log.info(\\\"table created\\\")\\r\\n QtSql.QSqlQuery(schema)\",\n \"def create_table(self, name: str, fields: Iterable[Field]) -> DbTable:\",\n \"def create_db(self):\",\n \"def test_create_tables(self):\\n conn_object = ParentConnection()\\n conn_object.create_tables()\\n conn = psycopg2.connect(**{\\\"host\\\": \\\"localhost\\\",\\n \\\"database\\\": \\\"test\\\",\\n \\\"user\\\": \\\"test\\\",\\n \\\"password\\\": \\\"test\\\"})\\n cur = conn.cursor()\\n cur.execute(\\\"SELECT * from information_schema.tables \\\"\\n \\\"WHERE table_schema = 'public' \\\"\\n \\\"AND table_type = 'BASE TABLE';\\\")\\n result = cur.fetchall()\\n result = [x[2] for x in result]\\n self.assertCountEqual(result,\\n ['bioms', 'counts', 'networks',\\n 'taxonomy', 'edges', 'samples', 'meta']\\n )\\n cur.close()\\n conn.close()\\n conn_object.delete_tables()\",\n \"def new_table(self):\\n self.c.execute(\\n \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {table} (\\n id integer primary key,\\n {event} integer,\\n {desc} text,\\n {date} text,\\n {link} text)\\n \\\"\\\"\\\".format(\\n table=TABLE,\\n event=EVENT,\\n desc=DESC,\\n date=DATE,\\n link=LINK,\\n )\\n )\",\n \"def create_table(self, param, timeout):\\n _abstract()\",\n \"def create_table(self, param, timeout):\\n _abstract()\",\n \"def test_cap_table_formats(logger, dbsession, network, scanned_distribution, web3):\\n\\n identity_provider = NullIdentityProvider()\\n\\n token_address = scanned_distribution\\n for sort_direction in [\\\"asc\\\", \\\"desc\\\"]:\\n for sort_order in [\\\"address\\\", \\\"name\\\", \\\"balance\\\", \\\"updated\\\"]:\\n generate_cap_table(\\n logger,\\n dbsession,\\n token_address,\\n order_by=sort_order,\\n identity_provider=identity_provider,\\n order_direction=sort_direction,\\n include_empty=False,\\n TokenScanStatus=TokenScanStatus,\\n TokenHolderAccount=TokenHolderAccount,\\n )\",\n \"def table_creater(self, tablename, columnnames, entries):\\n createrurl = self.casjobsurl + '/contexts/MyDB/query'\",\n \"def __init__(self, database='/tmp/blingalytics_cache'):\\n self.database = database\\n self._create_metadata_table()\",\n \"def create_table(cls):\\n if not connection.connected:\\n raise Exception('Not connected to the database.')\\n cursor = connection.execute(cls.create_table_sql())\\n cursor.close()\",\n \"def create_tables(): \\n \\n pk_contraint = \\\"CONSTRAINT {}_pk PRIMARY KEY ({})\\\"\\n uq_contraint = \\\"CONSTRAINT {}_uq UNIQUE ({})\\\"\\n fk_query = \\\"\\\"\\\"CONSTRAINT {}_fk_{} \\n FOREIGN KEY ({}) \\n REFERENCES {}({}) \\n ON UPDATE CASCADE \\n ON DELETE RESTRICT\\n \\\"\\\"\\\"\\n \\n create_dict = {}\\n index = 1\\n\\n\\n ############################## public SCHEMA ##############################\\n \\n schema = 'public'\\n create_schema(schema)\\n\\n #################### site ####################\\n table_name = 'site'\\n pk_id = 'site_id'\\n uq_list = ['site_code']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_code CHAR(3),\\n purok VARCHAR,\\n sitio VARCHAR,\\n barangay VARCHAR,\\n municipality VARCHAR,\\n province VARCHAR,\\n region VARCHAR,\\n psgc INTEGER,\\n active BOOLEAN NOT NULL DEFAULT TRUE,\\n season SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n ############################## spatial SCHEMA ##############################\\n \\n schema = 'spatial'\\n create_schema(schema)\\n \\n #################### exposure ####################\\n table_name = 'exposure'\\n pk_id = 'exp_id'\\n uq_list = ['exp_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n exp_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n \\n #################### site_exposure ####################\\n table_name = 'site_exposure'\\n pk_id = 'se_id'\\n uq_list = ['site_id', 'exp_id', 'geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\\n 'exp_id': {'ref_schema': 'spatial', 'ref_table': 'exposure'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n exp_id INTEGER,\\n label_name VARCHAR,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n \\n #################### feature ####################\\n table_name = 'feature'\\n pk_id = 'feat_id'\\n uq_list = ['feat_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n feat_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### site_feature ####################\\n table_name = 'site_feature'\\n pk_id = 'sf_id'\\n uq_list = ['site_id', 'feat_id', 'geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\\n 'feat_id': {'ref_schema': 'spatial', 'ref_table': 'feature'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n feat_id INTEGER,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### hazard_zone ####################\\n table_name = 'hazard_zone'\\n pk_id = 'hz_id'\\n uq_list = ['site_id, geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### monitoring ####################\\n table_name = 'monitoring'\\n pk_id = 'mon_id'\\n uq_list = ['mon_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n mon_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### site_monitoring ####################\\n table_name = 'site_monitoring'\\n pk_id = 'sm_id'\\n uq_list = ['site_id', 'mon_id', 'geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\\n 'mon_id': {'ref_schema': 'spatial', 'ref_table': 'monitoring'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n mon_id INTEGER,\\n label_name VARCHAR,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n ############################### comm SCHEMA ###############################\\n \\n schema = 'comm'\\n create_schema(schema)\\n\\n #################### gsm_server ####################\\n table_name = 'gsm_server'\\n pk_id = 'server_id'\\n uq_list = ['server_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n server_name VARCHAR,\\n platform_type VARCHAR,\\n version SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### server_port ####################\\n table_name = 'server_port'\\n pk_id = 'port_id'\\n uq_list = ['server_id', 'port']\\n fk_dict = {'server_id': {'ref_schema': 'comm', 'ref_table': 'gsm_server'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n server_id INTEGER,\\n port BOOLEAN,\\n ser_port VARCHAR,\\n pwr_on_pin SMALLINT,\\n ring_pin SMALLINT,\\n module_type SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n query += \\\"\\\"\\\" COMMENT ON TABLE {}.{} IS \\n '0- left\\n 1- right'\\n ;\\\"\\\"\\\".format(schema, table_name)\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### network_type ####################\\n table_name = 'network_type'\\n pk_id = 'prefix'\\n uq_list = ['prefix']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} VARCHAR(3), \\n carrier SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n query += \\\"\\\"\\\" COMMENT ON TABLE {}.{} IS \\n '1- globe\\n 2- smart\\n 3- landline'\\n ;\\\"\\\"\\\".format(schema, table_name)\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### gsm_module ####################\\n table_name = 'gsm_module'\\n pk_id = 'gsm_id'\\n uq_list = ['prefix', 'num', 'activated']\\n fk_dict = {'prefix': {'ref_schema': 'comm', 'ref_table': 'network_type'},\\n 'port_id': {'ref_schema': 'comm', 'ref_table': 'server_port'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n prefix VARCHAR(3),\\n num CHAR(7),\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n port_id INTEGER,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n ############################# temporal SCHEMA #############################\\n \\n schema = 'temporal'\\n create_schema(schema)\\n\\n #################### marker_observation ####################\\n table_name = 'marker_observation'\\n pk_id = 'mo_id'\\n uq_list = ['site_id', 'ts']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n ts TIMESTAMP,\\n meas_type VARCHAR(7),\\n weather VARCHAR,\\n observer_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### marker_history ####################\\n table_name = 'marker_history'\\n pk_id = 'hist_id'\\n uq_list = ['sm_id', 'ts', 'event']\\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n sm_id BIGINT,\\n ts TIMESTAMP,\\n event BOOLEAN,\\n label_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n query += \\\"\\\"\\\" COMMENT ON TABLE {}.{} IS \\n '0- rename\\n 1- reposition'\\n ;\\\"\\\"\\\".format(schema, table_name)\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### marker_data ####################\\n table_name = 'marker_data'\\n pk_id = 'data_id'\\n uq_list = ['sm_id', 'mo_id']\\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\\n 'mo_id': {'ref_schema': 'temporal', 'ref_table': 'marker_observation'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n mo_id BIGINT,\\n sm_id BIGINT,\\n measurement NUMERIC(5,1),\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### marker_alert ####################\\n table_name = 'marker_alert'\\n pk_id = 'alert_id'\\n uq_list = ['data_id']\\n fk_dict = {'data_id': {'ref_schema': 'temporal', 'ref_table': 'marker_data'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n data_id BIGINT,\\n displacement NUMERIC(4,1),\\n time_delta FLOAT,\\n alert_level SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### logger_model ####################\\n table_name = 'logger_model'\\n pk_id = 'model_id'\\n uq_list = ['has_tilt', 'has_rain', 'has_piezo', 'has_soms', 'logger_type']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n has_tilt BOOLEAN,\\n has_rain BOOLEAN,\\n has_piezo BOOLEAN,\\n has_soms BOOLEAN,\\n logger_type SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### logger ####################\\n table_name = 'logger'\\n pk_id = 'logger_id'\\n uq_list = ['sm_id']\\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\\n 'model_id': {'ref_schema': 'temporal', 'ref_table': 'logger_model'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n sm_id BIGINT,\\n model_id INTEGER,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n \\n #################### logger_mobile ####################\\n table_name = 'logger_mobile'\\n pk_id = 'mobile_id'\\n uq_list = ['logger_id', 'activated']\\n fk_dict = {'logger_id': {'ref_schema': 'temporal', 'ref_table': 'logger'},\\n 'gsm_id': {'ref_schema': 'comm', 'ref_table': 'gsm_module'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n logger_id INTEGER,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n sim_num VARCHAR(12),\\n gsm_id INTEGER,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n #################### EXECUTE QUERY TO CREATE TABLES ####################\\n for index in create_dict.keys():\\n dct = create_dict[index]\\n schema = dct['schema']\\n table_name = dct['table_name']\\n query = dct['query']\\n pk_id = dct['pk_id']\\n uq_list = dct['uq_list']\\n fk_dict = dct['fk_dict']\\n if len(fk_dict.keys()) == 0:\\n fk_constraint = ''\\n else:\\n fk_constraint_list = ['']\\n for fk_id in fk_dict.keys():\\n ref_schema = fk_dict.get(fk_id)['ref_schema']\\n ref_table = fk_dict.get(fk_id)['ref_table']\\n fk_part = fk_query.format(table_name, ref_table, fk_id,\\n \\\"{}.{}\\\".format(ref_schema, ref_table),\\n fk_id)\\n fk_constraint_list.append(fk_part)\\n fk_constraint = ', '.join(fk_constraint_list)\\n \\n query = query.format(schema, table_name, pk_id, \\n pk_contraint.format(table_name, pk_id),\\n uq_contraint.format(table_name, ', '.join(uq_list)),\\n \\\"{}\\\".format(fk_constraint))\\n qdb.execute(query)\",\n \"def create_layers_table():\\n\\n table_name = f\\\"{BQ_LAYERS_TABLE}\\\"\",\n \"def create_tables():\\n with db.connect() as conn:\\n conn.execute(\\n \\\"CREATE TABLE IF NOT EXISTS url_list \\\"\\n \\\"(url_id VARCHAR(20) NOT NULL UNIQUE, url_data VARCHAR(2083) NOT NULL);\\\"\\n )\",\n \"def create_table(self):\\n Engine.create_table(self)\\n self.connection.commit()\",\n \"def create_tables(self):\\n for query in table_create_sql:\\n self.cursor.execute(query)\\n\\n self.commit()\",\n \"def create_tables(self):\\n if not self.is_enabled(Subsystem.database):\\n raise RuntimeError(\\\"Database subsystem was not enabled\\\")\\n\\n Base.metadata.create_all(self.engine)\",\n \"def make_new_tbl(self):\\n debug = False\\n default_dd = getdata.get_default_db_dets()\\n con, cur = default_dd.con, default_dd.cur\\n oth_name_types = getdata.get_oth_name_types(self.settings_data)\\n tblname = self.tblname_lst[0]\\n if debug: print(f'DBE in make_new_tbl is: {default_dd.dbe}')\\n getdata.make_sofa_tbl(\\n con, cur, tblname, oth_name_types, headless=False)\\n wx.MessageBox(\\n _('Your new table has been added to the default SOFA database'))\",\n \"def _create_tables_classic(self, engine, metadata):\\n if engine and metadata:\\n with (yield from engine) as conn:\\n for x in self._models.values():\\n try:\\n yield from conn.execute(CreateTable(x))\\n except ProgrammingError as error:\\n if hasattr(self.app, 'log') and self.app.log:\\n if self.app.debug:\\n self.app.log.info(\\\"[PostgressPlugin] [ `{}` already exists]\\\".format(x))\\n else:\\n if self.app.debug:\\n print(\\\"[PostgressPlugin] [ `{}` already exists]\\\".format(x))\\n return\",\n \"def create_tables(self):\\n if self.mock:\\n mock_dynamodb2(self._create_tables())\\n else:\\n self._create_tables()\",\n \"def _create_table(self):\\n query = f\\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {TABLE}(\\n member_Id INT,\\n memberName VARCHAR(50),\\n amount INT,\\n date datetime NOT NULL,\\n time datetime NOT NULL,\\n status VARCHAR(20) NOT NULL DEFAULT 'Completed'\\n );\\\"\\\"\\\"\\n\\n self.cursor.execute(query)\\n self.conn.commit()\",\n \"def create_new_user_table():\\n # Connect to database\\n conn = psycopg2.connect(DATABASE_URL, sslmode='require')\\n # Open a cursor to perform db operations\\n cur = conn.cursor()\\n # Create the table\\n cur.execute(\\\"\\\"\\\"\\n CREATE TABLE test (\\n user_id int NOT NULL PRIMARY KEY,\\n username varchar(255),\\n id_last_message_sent int,\\n id_last_message_stickered int,\\n count_since_last_stickered int\\n );\\n \\\"\\\"\\\"\\n )\\n # Commit and close connection\\n conn.commit()\\n cur.close()\\n conn.close()\",\n \"def create_table(self):\\n\\n # Get columns\\n columns = []\\n for i, (name, type_) in enumerate(self.schema.items()):\\n if 'sqlalchemy' in str(type(type_)):\\n pass\\n else:\\n type_ = str(type_).lower()\\n\\n if 'int' in type_:\\n type_ = sqlalchemy.Integer\\n elif 'float' in type_:\\n type_ = sqlalchemy.Float\\n elif 'bool' in type_:\\n type_ = sqlalchemy.Boolean\\n elif 'timestamp' in type_:\\n type_ = sqlalchemy.TIMESTAMP\\n elif 'varchar' in type_ or 'str' in type_:\\n type_ = sqlalchemy.VARCHAR\\n elif 'json' in type_:\\n type_ = sqlalchemy.JSON\\n elif 'datetime' in type_:\\n type_ = sqlalchemy.DateTime\\n elif 'date' in type_:\\n type_ = sqlalchemy.Date\\n else:\\n raise Exception(f\\\"Column type {type_} not supported when creating a new table\\\")\\n\\n columns.append(sqlalchemy.Column(name, type_))#, primary_key=True))\\n\\n columns = tuple(columns)\\n table = sqlalchemy.Table(\\n self.table, self.metadata,\\n *columns\\n )\\n self.metadata.create_all(self.engine)\",\n \"def create(self, table, columns, types, primary_key_index=[], is_ifnotexists=True):\\n\\n self.lock.acquire()\\n try:\\n dblist = self.client.get_list_database()\\n for dbdict in dblist:\\n if self.dbname in dbdict[\\\"name\\\"]:\\n self.lock.release()\\n return True\\n\\n self.client.create_database(self.dbname)\\n except Exception as e:\\n raise Exception(\\\"Error in create statement; InfluxDb, DB=%s\\\\n\\\" % self.dbname)\\n\\n self.lock.release()\\n\\n return True\",\n \"def create_schema(self, schema):\\n sql = f'set role {self.write_role}; ' \\\\\\n + f'CREATE SCHEMA IF NOT EXISTS {schema};'\\n return sql\",\n \"def create_example_test_table(conn):\\n execute_sql_script(conn, \\\"06_create_example_test_table.sql\\\")\",\n \"def create_table(self):\\n session=self.session()\\n fields_list = []\\n for col_name, col_obj in self.column_objects.iteritems():\\n\\n if col_name in self.columns:\\n fields_list.append(\\\"`%s` %s,\\\" % (col_name, _local_type_to_db_column(col_obj)))\\n field_str = \\\"\\\\n\\\".join(fields_list)\\n index_type = \\\"UNIQUE KEY\\\" if self.unique else \\\"INDEX\\\"\\n index_fileds = \\\",\\\".join(\\\"`\\\" + f + \\\"`\\\" for f in self.columns)\\n\\n sql = \\\"\\\"\\\"CREATE TABLE `%(table_name)s` (\\n`id` int(10) unsigned NOT NULL AUTO_INCREMENT,\\n`entity_id` VARCHAR(36) NOT NULL,\\n%(fields)s\\nPRIMARY KEY (`id`),\\nUNIQUE KEY (`entity_id`),\\n%(idx_type)s `idx_%(idx_name)s` (%(idx_fields)s) USING BTREE\\n) ENGINE=InnoDB DEFAULT CHARSET=utf8;\\n \\\"\\\"\\\" % dict(table_name=self.table_name, fields=field_str, idx_type=index_type, idx_name=self.table_name, idx_fields=index_fileds)\\n\\n session.connection.execute(sql)\",\n \"def setup(db):\\n # initialize schema\\n build_metadata().create_all(db.engine())\\n\\n # tune auto vacuum/analyze\\n reset_autovac(db)\\n\\n # default rows\\n sqls = [\\n \\\"INSERT INTO hive_state (block_num, db_version, steem_per_mvest, usd_per_steem, sbd_per_steem, dgpo) VALUES (0, %d, 0, 0, 0, '')\\\" % DB_VERSION,\\n \\\"INSERT INTO hive_blocks (num, hash, created_at) VALUES (0, '0000000000000000000000000000000000000000', '2016-03-24 16:04:57')\\\",\\n \\\"INSERT INTO hive_accounts (name, created_at) VALUES ('miners', '2016-03-24 16:05:00')\\\",\\n \\\"INSERT INTO hive_accounts (name, created_at) VALUES ('null', '2016-03-24 16:05:00')\\\",\\n \\\"INSERT INTO hive_accounts (name, created_at) VALUES ('temp', '2016-03-24 16:05:00')\\\",\\n \\\"INSERT INTO hive_accounts (name, created_at) VALUES ('initminer', '2016-03-24 16:05:00')\\\"]\\n for sql in sqls:\\n db.query(sql)\\n\\n sql = \\\"CREATE INDEX hive_communities_ft1 ON hive_communities USING GIN (to_tsvector('english', title || ' ' || about))\\\"\\n db.query(sql)\",\n \"def create_table(self):\\n logging.debug('Creating new table')\\n if not self._dbconnect or not self._cursor:\\n raise Exception('Invalid call to Context Manager method!')\\n\\n self._cursor.execute(\\\"create table {} (date text, time text, location text, nodeID text)\\\".format(self._name))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7222646","0.66707873","0.5947068","0.5887795","0.58477587","0.5694725","0.56702393","0.56475055","0.56451815","0.56367904","0.5633519","0.55940306","0.55933654","0.55901736","0.5587355","0.55573237","0.555128","0.5534241","0.55316937","0.55145425","0.5506047","0.54992753","0.54602504","0.5443343","0.5436131","0.5422965","0.5420758","0.5395065","0.5394638","0.5386561","0.5385011","0.5380324","0.53605217","0.5354589","0.53533185","0.534858","0.53466475","0.53397226","0.53331506","0.5329182","0.5327533","0.5319081","0.53125453","0.5312191","0.53083587","0.53034395","0.5302045","0.53017634","0.5285375","0.5281095","0.52784","0.5277871","0.5277759","0.5277087","0.52680767","0.52507323","0.5243736","0.5243736","0.5218516","0.52181214","0.5212845","0.5206943","0.5200336","0.5195607","0.51921105","0.5189088","0.5185938","0.5181792","0.5181608","0.51802516","0.51760274","0.5164666","0.51638824","0.51559705","0.51518124","0.5147848","0.51439047","0.51439047","0.51400316","0.51380396","0.5116714","0.51119","0.51105976","0.51025826","0.5101303","0.50970906","0.5092257","0.5091807","0.5090101","0.5088194","0.50858206","0.5082962","0.5078033","0.50693494","0.50648355","0.5059087","0.5051547","0.5050175","0.50469464","0.5041988"],"string":"[\n \"0.7222646\",\n \"0.66707873\",\n \"0.5947068\",\n \"0.5887795\",\n \"0.58477587\",\n \"0.5694725\",\n \"0.56702393\",\n \"0.56475055\",\n \"0.56451815\",\n \"0.56367904\",\n \"0.5633519\",\n \"0.55940306\",\n \"0.55933654\",\n \"0.55901736\",\n \"0.5587355\",\n \"0.55573237\",\n \"0.555128\",\n \"0.5534241\",\n \"0.55316937\",\n \"0.55145425\",\n \"0.5506047\",\n \"0.54992753\",\n \"0.54602504\",\n \"0.5443343\",\n \"0.5436131\",\n \"0.5422965\",\n \"0.5420758\",\n \"0.5395065\",\n \"0.5394638\",\n \"0.5386561\",\n \"0.5385011\",\n \"0.5380324\",\n \"0.53605217\",\n \"0.5354589\",\n \"0.53533185\",\n \"0.534858\",\n \"0.53466475\",\n \"0.53397226\",\n \"0.53331506\",\n \"0.5329182\",\n \"0.5327533\",\n \"0.5319081\",\n \"0.53125453\",\n \"0.5312191\",\n \"0.53083587\",\n \"0.53034395\",\n \"0.5302045\",\n \"0.53017634\",\n \"0.5285375\",\n \"0.5281095\",\n \"0.52784\",\n \"0.5277871\",\n \"0.5277759\",\n \"0.5277087\",\n \"0.52680767\",\n \"0.52507323\",\n \"0.5243736\",\n \"0.5243736\",\n \"0.5218516\",\n \"0.52181214\",\n \"0.5212845\",\n \"0.5206943\",\n \"0.5200336\",\n \"0.5195607\",\n \"0.51921105\",\n \"0.5189088\",\n \"0.5185938\",\n \"0.5181792\",\n \"0.5181608\",\n \"0.51802516\",\n \"0.51760274\",\n \"0.5164666\",\n \"0.51638824\",\n \"0.51559705\",\n \"0.51518124\",\n \"0.5147848\",\n \"0.51439047\",\n \"0.51439047\",\n \"0.51400316\",\n \"0.51380396\",\n \"0.5116714\",\n \"0.51119\",\n \"0.51105976\",\n \"0.51025826\",\n \"0.5101303\",\n \"0.50970906\",\n \"0.5092257\",\n \"0.5091807\",\n \"0.5090101\",\n \"0.5088194\",\n \"0.50858206\",\n \"0.5082962\",\n \"0.5078033\",\n \"0.50693494\",\n \"0.50648355\",\n \"0.5059087\",\n \"0.5051547\",\n \"0.5050175\",\n \"0.50469464\",\n \"0.5041988\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6937344"},"document_rank":{"kind":"string","value":"1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":63,"numItemsPerPage":100,"numTotalItems":95772,"offset":6300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3ODczNjg4MCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3Nzg3NDA0ODAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.ZOe69dwHllSGI8Z5u7m_iwVgSgekiPq5FgdgdmVPaj5zpDrsL3UgsmilUbbnJoFv8XNb7VQFrAXoz91ByNGyCQ","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 |
|---|---|---|---|---|---|---|
Load an ARFF File from a file. | def load(filename):
o = open(filename)
s = o.read()
a = ArffFile.parse(s)
o.close()
return a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self, filename=None):\n importer = aspecd.io.AdfImporter()\n importer.source = filename\n importer.import_into(self)",
"def loadFile(self, filename):\n #TODO: do a contents based detection\n if filename[-4:].lower() == '.txt':\n self.loadTIText(open(filename... | [
"0.6952331",
"0.6750146",
"0.6709102",
"0.67043614",
"0.6499693",
"0.6472072",
"0.6260189",
"0.6143849",
"0.61354226",
"0.61135525",
"0.60728455",
"0.6060615",
"0.60431916",
"0.60410386",
"0.60397345",
"0.59697336",
"0.5964675",
"0.59411573",
"0.5907846",
"0.5897713",
"0.5881... | 0.8042971 | 0 |
Parse an ARFF File already loaded into a string. | def parse(s):
a = ArffFile()
a.state = 'comment'
a.lineno = 1
for l in s.splitlines():
a.__parseline(l)
a.lineno += 1
return a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(filename):\n o = open(filename)\n s = o.read()\n a = ArffFile.parse(s)\n o.close()\n return a",
"def parser(path):\n\t\n\tdata = Arff()\n\tdata.read_arff(path)\n\t\n\treturn data",
"def parse(self, fstring):\n pass",
"def readstring(self, fstring):\n ... | [
"0.7748348",
"0.6941203",
"0.65057826",
"0.6344125",
"0.6126974",
"0.60245204",
"0.5986282",
"0.5867104",
"0.58164245",
"0.5803675",
"0.5767087",
"0.5750282",
"0.5741847",
"0.57395566",
"0.5734487",
"0.57319623",
"0.5729989",
"0.57124734",
"0.57011807",
"0.56908566",
"0.56846... | 0.59209055 | 7 |
Save an arff structure to a file. | def save(self, filename):
o = open(filename, 'w')
o.write(self.write())
o.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_to(self, f: BinaryIO):\n raise NotImplementedError",
"def save(self, fp):\n fp.write(self.dump())",
"def arff_file(data,attributes,relation,description,output_dir=\"./\",filename=\"tmp\"):\n x = []\n for k in attributes:\n x.append(k[0])\n data_write = {}\n data_write[... | [
"0.69570386",
"0.68969166",
"0.6809577",
"0.67342925",
"0.66713744",
"0.6558785",
"0.65403384",
"0.6525226",
"0.65054166",
"0.65036285",
"0.6475159",
"0.63836706",
"0.6351954",
"0.63122535",
"0.62712467",
"0.6262766",
"0.62433875",
"0.6220814",
"0.6198543",
"0.61779356",
"0.6... | 0.6042053 | 39 |
Write an arff structure to a string. | def write(self):
o = []
print self.comment
o.append('% ' + re.sub("\n", "\n% ", self.comment))
o.append("@relation " + self.esc(self.relation))
for a in self.attributes:
at = self.attribute_types[a]
if at == 'numeric':
o.append("@attribute ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_string(fobj, strng):\n nchar = len(strng)\n fobj.write(struct.pack('i' + str(nchar) + 's',nchar, strng))",
"def writeArff(file_name, relation, classes, attrs, data):\n\tprint 'writeArff:', file_name, len(data), len(data[0])\n\tf = file(file_name, 'w')\n\tf.write('%\\n')\n\tf.write('%% %s \\n' % o... | [
"0.6324499",
"0.62119496",
"0.6018703",
"0.5856187",
"0.5729599",
"0.5729317",
"0.5680122",
"0.56663",
"0.5607432",
"0.55896235",
"0.55244505",
"0.55047196",
"0.5478621",
"0.54767764",
"0.5470894",
"0.5455972",
"0.54425216",
"0.54396397",
"0.542664",
"0.5419853",
"0.5416848",... | 0.53047353 | 36 |
Define a new attribute. atype has to be one of 'numeric', 'string', and 'nominal'. For nominal attributes, pass the possible values as data. | def define_attribute(self, name, atype, data=None):
self.attributes.append(name)
self.attribute_types[name] = atype
self.attribute_data[name] = data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_attribute(self,\n identifier,\n idl_type,\n is_readonly=False,\n extended_attributes=None,\n node=None):\n if isinstance(idl_type, str):\n idl_type = self._crea... | [
"0.6832389",
"0.6797418",
"0.67368126",
"0.6671336",
"0.65930986",
"0.6554519",
"0.65519553",
"0.650852",
"0.6398499",
"0.6318576",
"0.6294345",
"0.6168906",
"0.6158302",
"0.6157011",
"0.61001563",
"0.605466",
"0.6050371",
"0.6018214",
"0.6016995",
"0.60158825",
"0.60112774",... | 0.8044042 | 0 |
Print an overview of the ARFF file. | def dump(self):
print "Relation " + self.relation
print " With attributes"
for n in self.attributes:
if self.attribute_types[n] != 'nominal':
print " %s of type %s" % (n, self.attribute_types[n])
else:
print (" " + n + " of type nomi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display(self):\n art = \"\\n\".join([\"\".join(row) for row in self.text])\n if self.args.output:\n with open(self.args.output, \"w\") as f:\n f.write(art)\n\n if self.args.verbose:\n print(art)",
"def do_overview(self):\n summaries = []\n ... | [
"0.62585604",
"0.61102706",
"0.59338325",
"0.5928298",
"0.5916814",
"0.5912711",
"0.58843017",
"0.5880487",
"0.5864036",
"0.584445",
"0.5838104",
"0.5826809",
"0.5805153",
"0.5799806",
"0.57934296",
"0.57876754",
"0.57797",
"0.5754832",
"0.5734082",
"0.5728988",
"0.5718277",
... | 0.0 | -1 |
Update the overall ignorance | def update_overall_ignorance(overall_ignorance, object_ignorance, rate=0.05):
return (1-rate)*overall_ignorance + rate*object_ignorance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n # default implementation is to do nothing.",
"def dummy_update( self ):\r\n pass",
"def _update(self):\n pass",
"def update(self):\n\n pass",
"def update(self):\n pass",
"def update(self):\n pass",
"def update(self):\n pass",
"def u... | [
"0.60763353",
"0.60567635",
"0.60499495",
"0.59942096",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.59925723",
"0.5989389",... | 0.62073374 | 0 |
Return focus image at target positon | def check_target_position(environment, target_xy, fovea):
temp_fovea = Fovea(target_xy, fovea.size, [0, 0, 0], fovea.unit)
temp_image = temp_fovea.get_focus_image(environment)
return temp_image | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def click_img(self, target_img):\n pos = imagesearch_loop(target_img, timesample=0.5)\n if pos[0] == -1:\n print(\"No image found\")\n else:\n self.click(pos)",
"def extract_target_pixel_location(self):\n #Respective Image location\n pixel_array = self.ima... | [
"0.6471832",
"0.60620207",
"0.60257924",
"0.5962527",
"0.5960928",
"0.5843375",
"0.5577541",
"0.556946",
"0.5547605",
"0.55378973",
"0.55275726",
"0.54741293",
"0.5447037",
"0.543567",
"0.5431909",
"0.54052734",
"0.5387265",
"0.5387265",
"0.5387265",
"0.5387265",
"0.534272",
... | 0.64985406 | 0 |
Check if target area is free | def check_free_space(environment, target_xy, fovea):
temp_image = check_target_position(environment, target_xy, fovea)
if np.array_equal(temp_image, np.zeros(temp_image.shape)):
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_free(self) -> bool:\n return self.places < self.total",
"def is_free(self):\n return self._size > 0",
"def guard_occupy_transition(self):\n if not self.get_free_positions:\n return True",
"def _space_has_degrees_of_freedom(self) -> bool:\n return True",
"def fr... | [
"0.69473505",
"0.65693545",
"0.65516436",
"0.65503776",
"0.65440136",
"0.64887106",
"0.63822377",
"0.6373474",
"0.6314653",
"0.6287633",
"0.62136126",
"0.6197832",
"0.6167743",
"0.6130558",
"0.60996246",
"0.6068702",
"0.6056441",
"0.60131264",
"0.6010799",
"0.5976388",
"0.597... | 0.7472877 | 0 |
Generate random xy coordinates within limits | def get_random_position(limits):
x = (limits[0][1]-limits[0][0])*np.random.random_sample() + limits[0][0]
y = (limits[1][1]-limits[1][0])*np.random.random_sample() + limits[1][0]
return np.array([x, y]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RandomCoordinate(): \r\n return ReturnRounded(np.random.uniform(-10,10))",
"def random_coords(bounds):\n x_min, y_min, x_max, y_max = bounds\n x = np.random.randint(x_min, x_max)\n y = np.random.randint(y_min, y_max)\n return x, y",
"def random_coordinates():\n return Coor... | [
"0.7965414",
"0.784305",
"0.75514454",
"0.75506085",
"0.7408047",
"0.7375667",
"0.73101634",
"0.72578305",
"0.72399473",
"0.7202774",
"0.70819545",
"0.7014638",
"0.6981883",
"0.6853431",
"0.68348783",
"0.6809381",
"0.6802051",
"0.6801578",
"0.67783827",
"0.674277",
"0.6731451... | 0.7362432 | 6 |
Provisory function for plotting the graphics of the system. | def graphics(env, fovea, objects, unit):
plt.clf()
env = environment.redraw(env, unit, objects)
fovea_im = fovea.get_focus_image(env)
plt.subplot(121)
plt.title('Training environment')
plt.xlim(0, unit)
plt.ylim(0, unit)
plt.imshow(env)
# PLOT DESK EDGES
plt.plot([0.2*unit, 0.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot():\n pass",
"def plot_graph(self) -> None:",
"def plot(self):\n pass",
"def plot(self, *args, **kwargs):\n pass",
"def plot(self):\n\t\tself.plotOfHeatingCurrent().plot()",
"def make_plot(x,y):",
"def generate_plot(self):\r\n\t\tx, y = zip(*[p.p for p in self.universe])\r\n\t\... | [
"0.77779406",
"0.75133127",
"0.7475758",
"0.71247405",
"0.70805234",
"0.70423293",
"0.7034035",
"0.7024165",
"0.6948862",
"0.69376713",
"0.6886023",
"0.68375045",
"0.68164",
"0.68092847",
"0.6804923",
"0.67728657",
"0.676849",
"0.6763229",
"0.6728822",
"0.67281336",
"0.672028... | 0.0 | -1 |
Initialize a new network. | def __init__(self, input_dim=(3, 32, 32), hidden_dims_CNN = ((32, 5, 1, 1), (2, 2, 2)),
hidden_dims_FC = ((1024), (0.5)), num_classes=10, weight_scale=1e-3,
reg=0.0, dtype=np.float32):
self.params = {}
self.fix_params = {}
self.reg = reg
self.dtype = dtype
C_input... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialise_network(self):\n raise NotImplementedError",
"def initialize_network(self):\n self.sess = tf.InteractiveSession()\n sys.stderr.write(\"------\\n\")\n self.model.create_model()\n self._initialize_trainer()\n self.sess.run(tf.initialize_all_variables())\n ... | [
"0.82548803",
"0.73180324",
"0.7250326",
"0.7208859",
"0.7175182",
"0.71721554",
"0.7144906",
"0.71397537",
"0.7111056",
"0.70892704",
"0.7068604",
"0.70275855",
"0.7006372",
"0.70048183",
"0.6935608",
"0.6931045",
"0.68508935",
"0.6778785",
"0.6745369",
"0.6730585",
"0.67080... | 0.0 | -1 |
Evaluate loss and gradient for the threelayer convolutional network. | def loss(self, X, y=None):
X = X.astype(self.dtype)
mode = 'test' if y is None else 'train'
num_FC = self.num_FC
num_CNN = self.num_CNN
total_layer = self.num_FC + self.num_CNN
cache = {}
pre_layer_output = X
for i in range(0, num_CNN):
W_name = "W" + str(i)
b_name = "b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loss(self, X, y=None):\n W1, b1 = self.params['W1'], self.params['b1']\n W2, b2 = self.params['W2'], self.params['b2']\n W3, b3 = self.params['W3'], self.params['b3']\n \n # pass conv_param to the forward pass for the convolutional layer\n filter_size = W1.shape[2]\n conv_param = {'stride'... | [
"0.64657706",
"0.6235286",
"0.62264025",
"0.61885417",
"0.617772",
"0.61766106",
"0.6117092",
"0.609945",
"0.6043953",
"0.60374737",
"0.60298234",
"0.6029765",
"0.6028192",
"0.6012463",
"0.6012463",
"0.59997284",
"0.5982718",
"0.590393",
"0.58888876",
"0.5880226",
"0.5858676"... | 0.0 | -1 |
Initialize a new network. | def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,
hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,
dtype=np.float32):
self.params = {}
self.reg = reg
self.dtype = dtype
##################################################################... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialise_network(self):\n raise NotImplementedError",
"def initialize_network(self):\n self.sess = tf.InteractiveSession()\n sys.stderr.write(\"------\\n\")\n self.model.create_model()\n self._initialize_trainer()\n self.sess.run(tf.initialize_all_variables())\n ... | [
"0.82548803",
"0.73180324",
"0.7250326",
"0.7208859",
"0.7175182",
"0.71721554",
"0.7144906",
"0.71397537",
"0.7111056",
"0.70892704",
"0.7068604",
"0.70275855",
"0.7006372",
"0.70048183",
"0.6935608",
"0.6931045",
"0.68508935",
"0.6778785",
"0.6745369",
"0.6730585",
"0.67080... | 0.0 | -1 |
Evaluate loss and gradient for the threelayer convolutional network. | def loss(self, X, y=None):
W1, b1 = self.params['W1'], self.params['b1']
W2, b2 = self.params['W2'], self.params['b2']
W3, b3 = self.params['W3'], self.params['b3']
# pass conv_param to the forward pass for the convolutional layer
filter_size = W1.shape[2]
conv_param = {'stride': 1, 'pad': ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loss(self, X, y=None):\n W1, b1 = self.params['W1'], self.params['b1']\n W2, b2 = self.params['W2'], self.params['b2']\n W3, b3 = self.params['W3'], self.params['b3']\n \n # pass conv_param to the forward pass for the convolutional layer\n filter_size = W1.shape[2]\n conv_param = {'stride'... | [
"0.64657706",
"0.62264025",
"0.61885417",
"0.617772",
"0.61766106",
"0.6117092",
"0.609945",
"0.6043953",
"0.60374737",
"0.60298234",
"0.6029765",
"0.6028192",
"0.6012463",
"0.6012463",
"0.59997284",
"0.5982718",
"0.590393",
"0.58888876",
"0.5880226",
"0.5858676",
"0.5853266"... | 0.6235286 | 1 |
Set some default values. You may (and should) overwrite them for your Labourers in config of the Orchestrator. | def set_defaults(self):
for k, v in self.DEFAULTS.items():
if not getattr(self, k, None):
setattr(self, k, v) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_defaults(self):\n self.plastic = False\n self.unset_output()\n self.reward = False\n self.patmod = config.impact_modulation_default",
"def setdefaults(self):\n self.config = {\n 'dbuser': Infopage.DEFAULT_DBUSER,\n 'dbname': Infopage.DEFAULT_DBNAME... | [
"0.7093305",
"0.70469713",
"0.67849386",
"0.67849386",
"0.67849386",
"0.67587817",
"0.66523325",
"0.6466132",
"0.64581084",
"0.645666",
"0.64541894",
"0.64196736",
"0.6395543",
"0.6373748",
"0.63288397",
"0.63198304",
"0.63015604",
"0.62990135",
"0.62858754",
"0.62858754",
"0... | 0.6111626 | 36 |
Set timestamp attributes with some validation. Normally TaskManager is supposed to call me. | def set_custom_attribute(self, name: str, value: int):
if name not in self.CUSTOM_ATTRIBUTES:
raise ValueError(f"Failed to set custom attribute {name} with value {value} for Labourer {self.id}. "
f"Supported attributes are: {', '.join(self.CUSTOM_ATTRIBUTES)}.")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def timestamp(self, value):\n value = util.parse_valid_date(value)\n self._set_attr('timestamp', value)",
"def __init__(self, timestamp):\n self.timestamp = timestamp",
"def validate_timestamps(self, format, attr='timestamp'):\n for signal in self.last_notified[DEFAULT_TERMINAL]:\n ... | [
"0.6389384",
"0.6352489",
"0.625885",
"0.6236824",
"0.62339187",
"0.6217164",
"0.61725146",
"0.6168362",
"0.6143944",
"0.60877424",
"0.60449666",
"0.60201776",
"0.6011213",
"0.5992953",
"0.5985982",
"0.59728694",
"0.5938458",
"0.5936693",
"0.59341115",
"0.5922366",
"0.5922366... | 0.0 | -1 |
The Labourer must be first registered in TaskManager for this to work. | def get_attr(self, name: str):
if name not in self.CUSTOM_ATTRIBUTES:
raise ValueError(f"Supported values are: {', '.join(self.CUSTOM_ATTRIBUTES)}")
try:
return getattr(self, name)
except AttributeError:
raise AttributeError(f"The Labourer is not yet registe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task(self, name):\n pass",
"def task(self):",
"def task(self):",
"def task1(self):\n \n pass",
"def create_task():",
"def _service_task(self):\n pass",
"def setup_task(self, *args, **kwargs):\n pass",
"def task():",
"def task():\n pass",
"def task():\n ... | [
"0.6471944",
"0.6356887",
"0.6356887",
"0.6250948",
"0.62168896",
"0.6168737",
"0.6166343",
"0.61271644",
"0.6126083",
"0.6126083",
"0.611737",
"0.6075094",
"0.6068572",
"0.60475683",
"0.60475683",
"0.6020514",
"0.59368414",
"0.5921351",
"0.5903134",
"0.58914965",
"0.5884872"... | 0.0 | -1 |
Transform individual access rules states to 'access_rules_status'. | def upgrade():
op.add_column(
'share_instances',
Column('access_rules_status', String(length=255))
)
connection = op.get_bind()
share_instances_table = utils.load_table('share_instances', connection)
instance_access_table = utils.load_table('share_instance_access_map',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rights_status(self):\n return {uri: dict(name=name,\n open_access=(uri in RightsStatus.OPEN_ACCESS),\n allows_derivatives=(uri in RightsStatus.ALLOWS_DERIVATIVES))\n for uri, name in list(RightsStatus.NAMES.items())}",
"def get_left_pane... | [
"0.5165392",
"0.51448774",
"0.5017657",
"0.48824677",
"0.47823787",
"0.47806934",
"0.47753397",
"0.47299045",
"0.47297558",
"0.47259787",
"0.46960357",
"0.46546775",
"0.46254045",
"0.46073136",
"0.45791447",
"0.45639652",
"0.45602906",
"0.4543913",
"0.45438454",
"0.4541616",
... | 0.0 | -1 |
Inplace applies a one mode gate G into the process matrix T in mode i | def _apply_one_mode_gate(G, T, i):
T[i] *= G
return T | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _apply_two_mode_gate(G, T, i, j):\n (T[i], T[j]) = (G[0, 0] * T[i] + G[0, 1] * T[j], G[1, 0] * T[i] + G[1, 1] * T[j])\n return T",
"def compile(self, seq, registers):\n\n # Check which modes are actually being used\n used_modes = []\n for operations in seq:\n modes = [mo... | [
"0.70139986",
"0.5631263",
"0.5538027",
"0.5311544",
"0.5232887",
"0.5197726",
"0.5164995",
"0.5135691",
"0.50920993",
"0.50480705",
"0.5039565",
"0.50272524",
"0.49950483",
"0.49901596",
"0.4963029",
"0.49488658",
"0.4937678",
"0.49336824",
"0.49291444",
"0.49188215",
"0.487... | 0.79795337 | 0 |
Inplace applies a two mode gate G into the process matrix T in modes i and j | def _apply_two_mode_gate(G, T, i, j):
(T[i], T[j]) = (G[0, 0] * T[i] + G[0, 1] * T[j], G[1, 0] * T[i] + G[1, 1] * T[j])
return T | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _apply_one_mode_gate(G, T, i):\n\n T[i] *= G\n return T",
"def _assembler_baseV00(M2bass, Gi_, G_j, mode):\n Gi_ = Gi_.T\n G_j = G_j.T\n\n hmgeoiti_ = int(np.max(Gi_) + 1)\n hmgeoit_j = int(np.max(G_j) + 1)\n\n szGi_ = np.shape(Gi_)\n szG_j = np.shape(G_j)\n rowGi_ = szGi_[0]\n ... | [
"0.719273",
"0.57634723",
"0.5522466",
"0.509846",
"0.50796694",
"0.49862283",
"0.49686834",
"0.49493116",
"0.4947738",
"0.493212",
"0.48544836",
"0.48431808",
"0.48389664",
"0.48374176",
"0.4813507",
"0.4800392",
"0.47900787",
"0.47492748",
"0.47435454",
"0.47330758",
"0.472... | 0.80511445 | 0 |
Try to arrange a passive circuit into a single multimode passive operation This method checks whether the circuit can be implemented as a sequence of passive gates. If the answer is yes it arranges them into a single operation. | def compile(self, seq, registers):
# Check which modes are actually being used
used_modes = []
for operations in seq:
modes = [modes_label.ind for modes_label in operations.reg]
used_modes.append(modes)
used_modes = list(set(item for sublist in used_modes for it... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subsumes(self, cl):\n #-------------------------------------------------------\n # DISCRETE PHENOTYPE\n #-------------------------------------------------------\n if cons.env.format_data.discrete_action:\n if cl.action == self.action:\n if self.isPossibleSu... | [
"0.5135323",
"0.51068234",
"0.50888085",
"0.5013659",
"0.50006473",
"0.49939522",
"0.49842253",
"0.4959614",
"0.4951084",
"0.49505147",
"0.49332213",
"0.4926676",
"0.49138048",
"0.49060512",
"0.48939487",
"0.48903114",
"0.48635298",
"0.48454458",
"0.48432",
"0.48349684",
"0.4... | 0.0 | -1 |
Returns a list of the columns that are in our features dataframe that should not be used in prediction. These are essentially either metadata columns (team name, for example), or potential target variables that include the outcome. We want to make sure not to use the latter, since we don't want to use information about... | def get_non_feature_columns():
return ['teamid', 'op_teamid', 'matchid', 'competitionid', 'seasonid',
'goals', 'op_goals', 'points', 'timestamp', 'team_name',
'op_team_name'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_columns(self):\n df = self.get_prep_data()\n col = [c for c in df.columns if c not in ['target', 'idd', 'ft_data_dt']]\n return col",
"def missing_columns(self):\r\n _missing_columns = set(self.reqd_columns).difference(set(self.all_columns))\r\n return list(_missing... | [
"0.71959037",
"0.68640786",
"0.683394",
"0.6806973",
"0.67299575",
"0.6661575",
"0.6637758",
"0.65448886",
"0.65201235",
"0.64434034",
"0.6430318",
"0.6406203",
"0.63625467",
"0.6347281",
"0.6317178",
"0.6239724",
"0.621829",
"0.6213187",
"0.6197959",
"0.6065288",
"0.60188276... | 0.80354255 | 0 |
Returns a list of all columns that should be used in prediction (i.e. all features that are in the dataframe but are not in the features.get_non_feature_column() list). | def get_feature_columns(all_cols):
return [col for col in all_cols if col not in get_non_feature_columns()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_columns(self):\n df = self.get_prep_data()\n col = [c for c in df.columns if c not in ['target', 'idd', 'ft_data_dt']]\n return col",
"def get_cols(df):\n meta = get_metafeatures(df)\n categorical_columns = meta.loc[meta['type'] == 'object', 'column'].tolist()\n cols_to_... | [
"0.7311638",
"0.71005136",
"0.7081749",
"0.6978075",
"0.6938612",
"0.6809944",
"0.67643905",
"0.6764281",
"0.67626035",
"0.6757341",
"0.67021",
"0.6644742",
"0.6602799",
"0.64940643",
"0.64777064",
"0.6425499",
"0.64037734",
"0.6395039",
"0.6363723",
"0.6360488",
"0.6316431",... | 0.7818545 | 0 |
Setup cache object for wallet | def setup_cache(self):
if self.walletname not in cache:
cache[self.walletname] = {
"raw_transactions": {},
"transactions": [],
"tx_count": None,
"tx_changed": True,
"last_block": None,
"raw_tx_block_upda... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_cache(self):\n if self.cacheable:\n self._instance._cache[self.name] = {}",
"def __init__(self, *args, **kwargs):\n self._cachedict = {}",
"def __init_cache__(self) -> None:\n try:\n self.cache = caches[CACHE_NAME]\n logging.info(\"GeoIP2 - success... | [
"0.70809096",
"0.67123383",
"0.66832745",
"0.6391737",
"0.6336041",
"0.619476",
"0.6180135",
"0.6171709",
"0.6163314",
"0.6139369",
"0.60808635",
"0.6058581",
"0.60361993",
"0.60249174",
"0.6023925",
"0.5965481",
"0.59415615",
"0.5929574",
"0.59244114",
"0.59184754",
"0.58754... | 0.86449647 | 0 |
Cache `raw_transactions` (with full data on all the inputs and outputs of each tx) | def cache_raw_txs(self, cli_txs):
# Get list of all tx ids
txids = list(dict.fromkeys(cli_txs.keys()))
tx_count = len(txids)
# If there are new transactions (if the transations count changed)
if tx_count != self.cache["tx_count"]:
for txid in txids:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_txs(self, raw_txs):\n # Get the cached `raw_transactions` dict (txid -> tx) as a list of txs\n transactions = list(sorted(raw_txs.values(), key = lambda tx: tx['time'], reverse=True))\n result = []\n\n # If unconfirmed transactions were mined, assign them their block height\n ... | [
"0.7925975",
"0.6223888",
"0.61566186",
"0.60971904",
"0.5936462",
"0.58497435",
"0.58128",
"0.57948434",
"0.57376546",
"0.5634292",
"0.5595399",
"0.5577145",
"0.55244076",
"0.54729325",
"0.5469587",
"0.54539764",
"0.5448407",
"0.5412813",
"0.5397462",
"0.53824824",
"0.535970... | 0.79335445 | 0 |
Caches the transactions list. Cache the inputs and outputs which belong to the user's wallet for each `raw_transaction` | def cache_txs(self, raw_txs):
# Get the cached `raw_transactions` dict (txid -> tx) as a list of txs
transactions = list(sorted(raw_txs.values(), key = lambda tx: tx['time'], reverse=True))
result = []
# If unconfirmed transactions were mined, assign them their block height
if l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_raw_txs(self, cli_txs): \n # Get list of all tx ids\n txids = list(dict.fromkeys(cli_txs.keys()))\n tx_count = len(txids)\n\n # If there are new transactions (if the transations count changed)\n if tx_count != self.cache[\"tx_count\"]:\n for txid in tx... | [
"0.76756275",
"0.6882982",
"0.6274878",
"0.61497986",
"0.58140624",
"0.57319975",
"0.5679993",
"0.5659589",
"0.5585741",
"0.55252254",
"0.55109656",
"0.5479615",
"0.5473953",
"0.546898",
"0.5449675",
"0.54464066",
"0.542897",
"0.54221237",
"0.5411895",
"0.5377797",
"0.5366215... | 0.7736577 | 0 |
Cache Bitcoin Core `listtransactions` result | def update_txs(self, txs):
# For now avoid caching orphan transactions. We might want to show them somehow in the future.
cli_txs = {tx["txid"]: tx for tx in txs if tx["category"] != "orphan"}
raw_txs = self.cache_raw_txs(cli_txs)
cached_txs = self.cache_txs(raw_txs)
return cach... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_wallets_get_transaction_list(self):\n pass",
"def load_transactions(self, address, update=True, verbose=False, **kwargs):\n if self.apikey is None:\n update = False\n if verbose:\n print('load_transactions', address)\n fn = os.path.join(self.cache_dir, a... | [
"0.7081673",
"0.69549066",
"0.6773823",
"0.66765434",
"0.66569877",
"0.660985",
"0.64810187",
"0.6435633",
"0.6424816",
"0.64240026",
"0.63761234",
"0.63547444",
"0.6330722",
"0.6327416",
"0.6321605",
"0.6307761",
"0.6297964",
"0.6269112",
"0.62622905",
"0.62056416",
"0.61879... | 0.531083 | 95 |
This method hides fields that were added in newer API versions. Certain node fields were introduced at certain API versions. These fields are only made available when the request's API version matches or exceeds the versions when these fields were introduced. | def hide_fields_in_newer_versions(obj):
if not api_utils.allow_start_end_audit_time():
obj.start_time = wtypes.Unset
obj.end_time = wtypes.Unset
if not api_utils.allow_force():
obj.force = wtypes.Unset | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_api_fields(cls):\n return ['fqdn', 'ttl', 'description', 'views']",
"def remove_read_only_fields(self):\n self.fields = XML_List(Elements.FIELDS, [field for field in self.fields if\n not field.read_only or not str_to_bool(field.read_only)])",
... | [
"0.63221574",
"0.6136071",
"0.60758066",
"0.5660327",
"0.560701",
"0.5569673",
"0.55660045",
"0.55565786",
"0.55165595",
"0.54647285",
"0.54489416",
"0.54486406",
"0.54375917",
"0.5407587",
"0.54063267",
"0.5390326",
"0.53891975",
"0.53873795",
"0.5364011",
"0.5361968",
"0.53... | 0.6415202 | 0 |
Retrieve a list of audits. | def get_all(self, marker=None, limit=None, sort_key='id', sort_dir='asc',
goal=None, strategy=None):
context = pecan.request.context
policy.enforce(context, 'audit:get_all',
action='audit:get_all')
return self._get_audits_collection(marker, limit, sort_ke... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def audits(self, page=None, per_page=None):\r\n url = '{0}/{1}'.format(self.get_url(), 'audits')\r\n params = base.get_params(('page', 'per_page'), locals())\r\n\r\n return http.Request('GET', url, params), parsers.parse_json",
"async def getAudits(self, userid) -> GetAuditsResponse:\n ... | [
"0.7242189",
"0.6925415",
"0.6629473",
"0.6066214",
"0.58930445",
"0.57951593",
"0.5622102",
"0.55762124",
"0.5560621",
"0.5521924",
"0.54882264",
"0.54614747",
"0.54085684",
"0.5381083",
"0.5341541",
"0.53253835",
"0.5291983",
"0.52089226",
"0.5208324",
"0.519872",
"0.519041... | 0.5851862 | 5 |
Retrieve a list of audits with detail. | def detail(self, goal=None, marker=None, limit=None,
sort_key='id', sort_dir='asc'):
context = pecan.request.context
policy.enforce(context, 'audit:detail',
action='audit:detail')
# NOTE(lucasagomes): /detail should only work agaist collections
paren... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def audits(self, page=None, per_page=None):\r\n url = '{0}/{1}'.format(self.get_url(), 'audits')\r\n params = base.get_params(('page', 'per_page'), locals())\r\n\r\n return http.Request('GET', url, params), parsers.parse_json",
"async def getAudits(self, userid) -> GetAuditsResponse:\n ... | [
"0.69771624",
"0.6871864",
"0.60481256",
"0.5685963",
"0.5606537",
"0.5578751",
"0.53918356",
"0.5386999",
"0.53338796",
"0.53298634",
"0.52325433",
"0.5227748",
"0.52210885",
"0.5202364",
"0.52006584",
"0.5193474",
"0.51637083",
"0.51625",
"0.51477003",
"0.51229453",
"0.5108... | 0.6283404 | 2 |
Retrieve information about the given audit. | def get_one(self, audit):
if self.from_audits:
raise exception.OperationNotPermitted
context = pecan.request.context
rpc_audit = api_utils.get_resource('Audit', audit)
policy.enforce(context, 'audit:get', rpc_audit, action='audit:get')
return Audit.convert_with_link... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, audit_uuid):\n audit = AuditResource.get_by_id(audit_uuid=audit_uuid, withContacts=True, withScans=True)\n return audit",
"async def getAudit(self, auditid) -> GetAuditResponse:\n\n print(\"get audit 1\" + auditid)\n res = await self.stub.GetAudit(\n GetAuditR... | [
"0.7213119",
"0.7043593",
"0.66991794",
"0.63289493",
"0.6216085",
"0.62059367",
"0.6160432",
"0.58675766",
"0.5810578",
"0.56947064",
"0.5672697",
"0.5560825",
"0.55349076",
"0.5424039",
"0.541629",
"0.53783417",
"0.5374017",
"0.53407764",
"0.533264",
"0.53322256",
"0.526490... | 0.7407178 | 0 |
Create a new audit. | def post(self, audit_p):
context = pecan.request.context
policy.enforce(context, 'audit:create',
action='audit:create')
audit = audit_p.as_audit(context)
if self.from_audits:
raise exception.OperationNotPermitted
if not audit._goal_uuid:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_test_audit(context, **kw):\n audit = get_test_audit(context, **kw)\n audit.create()\n return audit",
"async def addAudit(self, name, description, status, type, data, userid) -> CreateAuditResponse:\n return await self.stub.CreateAudit(\n CreateAuditRequest(name=name,\n ... | [
"0.7987387",
"0.7321819",
"0.6951538",
"0.69068974",
"0.67013234",
"0.66529375",
"0.6481425",
"0.6336199",
"0.62626696",
"0.5870206",
"0.5868347",
"0.58341616",
"0.5810241",
"0.5751161",
"0.57454205",
"0.57079893",
"0.56360126",
"0.56107324",
"0.5599522",
"0.5566824",
"0.5530... | 0.67184925 | 4 |
Update an existing audit. | def patch(self, audit, patch):
if self.from_audits:
raise exception.OperationNotPermitted
context = pecan.request.context
audit_to_update = api_utils.get_resource(
'Audit', audit, eager=True)
policy.enforce(context, 'audit:update', audit_to_update,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def updateAudit(self, auditid, name, description, status, type, data, userid) -> UpdateAuditResponse:\n return await self.stub.UpdateAudit(\n UpdateAuditRequest(_id=auditid, name=name,\n description=description, status=status, type=type, created_by=userid\n ... | [
"0.7857467",
"0.6971718",
"0.6661846",
"0.5961999",
"0.59222054",
"0.58329576",
"0.56239164",
"0.55837953",
"0.55521935",
"0.5485416",
"0.54786855",
"0.5477399",
"0.5475961",
"0.5438302",
"0.5419978",
"0.5406263",
"0.54028344",
"0.5396701",
"0.5393715",
"0.5342789",
"0.534213... | 0.6875566 | 2 |
Format a Response object for an error_code. | def make_error_response(error_code: HTTP_STATUS_CODE, extra_details: Optional[ERROR_EXTRA_DETAILS] = None) -> Response:
error_message = ERROR_MESSAGES[error_code]
error_message['code'] = error_code.name
error_message['status'] = error_code.value
if extra_details is not None:
error_message['extra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def response_from_error(error_code, error_message=None):\n\terror = Error(error_code, error_message).__dict__\n\terror_response_code = error['response_code']\n\treturn Response(json.dumps(error), status=error_response_code, mimetype='application/json')",
"def error_response(http_response_code: Union[HTTPStatus, ... | [
"0.7530003",
"0.74910027",
"0.7406961",
"0.73116034",
"0.7230357",
"0.7164394",
"0.7131289",
"0.712245",
"0.7103296",
"0.7102053",
"0.7092803",
"0.7023021",
"0.692041",
"0.6913709",
"0.6907967",
"0.68782103",
"0.6853521",
"0.6830134",
"0.6802265",
"0.67787784",
"0.67218006",
... | 0.70570326 | 11 |
Check request is authenticated. If API_AUTH_SECRET_HEADER_NAME is not in request headers then return 401. If API_AUTH_SECRET_HEADER_NAME is in request headers but incorrect then return 403. Else return none. | def is_authenticated_request(req: Request) -> Optional[Response]:
if API_AUTH_SECRET_HEADER_NAME not in req.headers:
return make_error_response(HTTP_STATUS_CODE.UNAUTHORIZED)
if req.headers[API_AUTH_SECRET_HEADER_NAME] != API_AUTH_SECRET:
return make_error_response(HTTP_STATUS_CODE.FORBIDDEN)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_authorization_header_not_present(self, get_key_secret):\r\n request = Request(self.environ)\r\n request.body = self.get_request_body()\r\n response = self.xmodule.grade_handler(request, '')\r\n real_response = self.get_response_values(response)\r\n expected_response = {\... | [
"0.69187254",
"0.68816525",
"0.66055983",
"0.654799",
"0.6515225",
"0.64065534",
"0.63303685",
"0.63240373",
"0.63201493",
"0.6309157",
"0.6307791",
"0.62788045",
"0.6236683",
"0.6223184",
"0.6208542",
"0.6197912",
"0.6197359",
"0.6196875",
"0.61898404",
"0.6124128",
"0.61186... | 0.81665546 | 0 |
Add the the number of minutes represented by min to the currentDate input and returns that new date timestamp | def addMinutes(self, currentDate:str, dateFormat:str, mins:int) -> str:
inputDateTime = datetime.strptime(currentDate, dateFormat)
nextTime = inputDateTime + timedelta(minutes=mins)
return nextTime.strftime(dateFormat) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_datetime_before_given_minutes(minutes):\n from datetime import datetime\n import datetime as dt\n date_obj_before_3min = datetime.now()- dt.timedelta(minutes=minutes)\n return date_obj_before_3min",
"def get_today_start():\n return datetime.combine(datetime.today(), time.min)",
"def next... | [
"0.58505815",
"0.5687333",
"0.56670386",
"0.56670386",
"0.5537341",
"0.5529319",
"0.54898757",
"0.54418087",
"0.5429182",
"0.5377847",
"0.53345233",
"0.53310037",
"0.5325793",
"0.5316861",
"0.53041273",
"0.52726483",
"0.5251411",
"0.5228076",
"0.5211206",
"0.5204495",
"0.5169... | 0.6531147 | 0 |
Performs comparisons between two dates. | def compareDates(self, date1:str, date1Format:str, date2:str, date2Format:str) -> int:
try:
date1DateTime = datetime.strptime(date1, date1Format)
date2DateTime = datetime.strptime(date2, date2Format)
#Is the station built?
if date1DateTime... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare_dates(dt1, dt2):\n return dt1.year == dt2.year and dt1.month == dt2.month and dt1.day == dt2.day",
"def compareDates(date1, date2):\n if (date1 == date2):\n return 0\n elif (date1 > date2):\n return 1\n else:\n return -1",
"def compareDates(date1, date2):\n i... | [
"0.7317144",
"0.7154204",
"0.7154204",
"0.6905572",
"0.67966783",
"0.67367643",
"0.67232627",
"0.66853386",
"0.64393324",
"0.6373338",
"0.6361559",
"0.635992",
"0.63262355",
"0.62969035",
"0.62136775",
"0.6212751",
"0.6211607",
"0.620783",
"0.61857396",
"0.61663604",
"0.61202... | 0.6618818 | 8 |
Get a person, or a list of people. | def fetch(self, person=None):
if not person:
# get the list.
self.endpoint = 'people.json'
else:
self.endpoint = 'people/{0}.json'.format(person)
request = self.get(self.construct_url())
if request.status_code == 200:
return json.loads(re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self,id):\r\n person = get_one_by_persons_id(id=id)\r\n if not person:\r\n api.abort(404)\r\n else:\r\n return person",
"def get(self,id):\r\n person = get_one(id=id)\r\n if not person:\r\n api.abort(404)\r\n else:\r\n ... | [
"0.7088802",
"0.68807226",
"0.6546128",
"0.64830804",
"0.64762676",
"0.64040786",
"0.6379464",
"0.63460207",
"0.6253262",
"0.6118746",
"0.6103367",
"0.5969387",
"0.59533554",
"0.59300435",
"0.59290266",
"0.5909684",
"0.58746195",
"0.58618706",
"0.5822146",
"0.579045",
"0.5773... | 0.6276311 | 8 |
Send the given message to the given recipient. Serialization breaks the command message into two parts. The first part is a header specifying only the version number of the protocol used to confirm compatability, as well as the size of the rest of the message. The body of the request follows of size specified in the he... | def send_to_server(client_socket, command):
header, request = serialize_request(command)
if header and request:
try:
client_socket.send(header)
client_socket.send(request)
except socket.error:
print 'Server disconnected' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_message(self, message, serializer):\n bin_data = StringIO()\n message_header = MessageHeader(self.coin)\n message_header_serial = MessageHeaderSerializer()\n\n bin_message = serializer.serialize(message)\n payload_checksum = \\\n MessageHeaderSerializer.calc_c... | [
"0.6849743",
"0.64180076",
"0.6201422",
"0.6136934",
"0.6136291",
"0.6106256",
"0.6055221",
"0.6030019",
"0.5930607",
"0.59039015",
"0.5883832",
"0.58533734",
"0.5786345",
"0.57829654",
"0.5740297",
"0.5740297",
"0.57401174",
"0.57356936",
"0.5687052",
"0.56870025",
"0.566408... | 0.5532814 | 39 |
Prints out ">>" to make the prompt look nice. | def prompt():
sys.stdout.write('>> ')
sys.stdout.flush() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showPrompt(self):\r\n self.terminal.nextLine()\r\n self.terminal.write(self.ps[self.pn])",
"def do_prompt(self, line):\n self.prompt = line + ': '",
"def prompt(self, question):\n self.output(' ')\n self.output(question)\n self.output(self.parse_response(str(self.u... | [
"0.7335863",
"0.6978222",
"0.6823395",
"0.67102325",
"0.6643498",
"0.6569211",
"0.649697",
"0.64917946",
"0.6482021",
"0.6433004",
"0.63896614",
"0.63162845",
"0.62998056",
"0.6265454",
"0.6237534",
"0.6233695",
"0.6232359",
"0.618937",
"0.6169687",
"0.61388206",
"0.6136785",... | 0.7840775 | 0 |
Permet de lire les valeurs des constantes de couplage g_1, g_2 ET g_3 a partir du fichier g_file. | def set_interaction(self):
dirInd = "/Users/asedeki/Drive/environement/Quasi1D/quasi1d/data/inddata" # My laptop
N = self.N
array = np.load(f"{dirInd}/array_index_n{N}.npy")
Temps = np.loadtxt(self.g_file, usecols=[
1], unpack=True, dtype=np.double)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_g(file_name):\n \n r,g = np.loadtxt(file_name, dtype = 'float', unpack = 'true')\n \n return r,g",
"def read_gauss_coeff(file=None):\r\n\r\n if file is None:\r\n file = \"IGRF13.COF\"\r\n\r\n if file == \"IGRF13.COF\":\r\n (\r\n dic_dic_h,\r\n dic_dic... | [
"0.58956796",
"0.57218397",
"0.5694254",
"0.5611321",
"0.5530163",
"0.5499675",
"0.5396838",
"0.5381348",
"0.5357845",
"0.530564",
"0.5295147",
"0.52859634",
"0.528532",
"0.5280277",
"0.52575284",
"0.52474356",
"0.52196497",
"0.5175378",
"0.51711017",
"0.5149379",
"0.51163054... | 0.0 | -1 |
Takes video file path and a transcode profile, transcode the file, and returns the transcoded file in bytes, along with ffmpeg's stderr output. | def transcode_segment(self,
in_path: str,
profile: TranscodeProfile
) -> Tuple[bytes, str, str]:
out_filepath = f"/tmp/{uuid4()}.ts"
transcode_command = [
"ffmpeg",
"-i", in_path,
"-vf", f"s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transcode(path, outpath):\n\n needs_transcode = determine_transcode(path)\n logger.info(f\"Transcoding {path} to {outpath}...\")\n\n cmd = [\n \"ffmpeg\", \"-y\",\n \"-i\", path,\n \"-an\",\n \"-metadata:s\", \"handler_name=tator\",\n \"-vcodec\", \"libx264\",\n ... | [
"0.6997698",
"0.6566929",
"0.64950305",
"0.6379619",
"0.6161119",
"0.61035687",
"0.5958369",
"0.58059055",
"0.576237",
"0.57498455",
"0.57029223",
"0.5672103",
"0.5670517",
"0.5635099",
"0.5540602",
"0.5490141",
"0.541302",
"0.5378603",
"0.53590256",
"0.5312127",
"0.52753246"... | 0.75541896 | 0 |
Takes a video file path and generates a png image of the first frame along with the stderr output. | def generate_still_from_video(self,
in_path: str
) -> Tuple[bytes, float, str]:
out_filepath = f"/tmp/{uuid4()}.jpg"
command = [
"ffmpeg",
"-i", in_path,
"-vframes", "1",
out_filepath
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def take_one_shot(path_to_images, name_image, video_source=\"/dev/video0\"):\n subprocess_cmd(\"ffmpeg -f video4linux2 -s 1280x720 -i {} -frames 1 ./{}/{} -loglevel error -nostats\".format(video_source, path_to_images, name_image))",
"def make_video(data,\n xdim, ydim, sample_read_rows, sample_read_cols, i... | [
"0.72368175",
"0.6741803",
"0.6729747",
"0.66759086",
"0.6672142",
"0.6609485",
"0.65107006",
"0.64243746",
"0.63670754",
"0.6340442",
"0.6312494",
"0.62720597",
"0.6271513",
"0.626696",
"0.6263821",
"0.6262629",
"0.6260199",
"0.6227164",
"0.62193406",
"0.620616",
"0.61849064... | 0.63672096 | 8 |
Get start from an stderr dump. | def parse_start_timecode_from_stderr(self, stderr: str) -> float:
pattern = "start: ([0-9]+\.[0-9]+)"
pattern = re.compile(pattern)
result = pattern.search(stderr)
if result is None:
return None
# Parse result
timecode = float(result.group(1))
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stderr(self: \"ShellOutput\") -> Artefact[bytes]:\n self.__check_len()\n return self.stderrs[0]",
"def find_traceback_start(self):\n ### FILL IN ###",
"def _readline(stderr: IO) -> str:\n return stderr.readline().decode('utf-8').rstrip()",
"def get_stderr(self):\n return self._... | [
"0.6187324",
"0.615454",
"0.6144744",
"0.6122382",
"0.6052839",
"0.5921778",
"0.5872651",
"0.57856077",
"0.5730318",
"0.57201964",
"0.5620374",
"0.5603881",
"0.5599026",
"0.559445",
"0.5582995",
"0.55650765",
"0.5544137",
"0.552032",
"0.545329",
"0.54468346",
"0.5399817",
"... | 0.61422455 | 3 |
Get duration from an ffmpeg stderr dump. | def parse_duration_from_stderr(self, stderr: str) -> float:
pattern = "Duration: (\\d\\d):(\\d\\d):(\\d\\d\\.\\d\\d)"
pattern = re.compile(pattern)
result = pattern.search(stderr)
if result is None:
return None
# Parse result
hours = float(result.grou... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_duration(filename):\n cmd = ('ffprobe -v 0 -of flat=s=_ -select_streams v:0 -show_entries '\n 'stream=duration -of default=nokey=1:noprint_wrappers=1 ' +\n filename).split()\n pid = subprocess.run(cmd, universal_newlines=True,\n stdout=subprocess.PIPE)\n ... | [
"0.7139366",
"0.6637791",
"0.6516288",
"0.6415554",
"0.6111052",
"0.5992013",
"0.59010184",
"0.5797666",
"0.5752247",
"0.57105243",
"0.5628981",
"0.55969137",
"0.555516",
"0.5550522",
"0.551304",
"0.54656565",
"0.5385895",
"0.5377022",
"0.5360331",
"0.53306353",
"0.5317654",
... | 0.77763784 | 0 |
return new ones only | def save_parsed_results(results,save='current_bikes.pkl'):
if os.path.exists(save):
with open(save, 'rb') as f:
past_results = pickle.load(f)
past_results_ids = [bike['id'] for bike in past_results]
# get new ones
new_ones = []
for bike in results:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all(self):",
"def all(self):",
"def NewItems(self) -> _n_1_t_7:",
"def all(self):\n return self[:]",
"def OldItems(self) -> _n_1_t_7:",
"def getChanges():",
"def _remove_initial_objects_from_list(self, all):\n\n new_list = []\n for obj in all:\n if obj not in self.in... | [
"0.5644095",
"0.5644095",
"0.55209374",
"0.54977685",
"0.54559356",
"0.5339211",
"0.530434",
"0.5261145",
"0.52509654",
"0.5248147",
"0.52323604",
"0.52179813",
"0.5206026",
"0.520254",
"0.51867276",
"0.51860404",
"0.51658946",
"0.51597655",
"0.51427966",
"0.50969976",
"0.508... | 0.0 | -1 |
Represents a new or an existing entry. | def __init__(self, module):
# Keep a reference to the parent module.
self._module = module
# Keep a mapping 'field_name' => value for every valid field retrieved.
self._fields = {}
self._dirty_fields = []
# Make sure that the 'id' field is always define... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_entry(self):\n # Filter out any fields that are invalid for the type of a new entry.\n properties = {\n field: value\n for field, value in self.properties.items()\n if field in self.type_cls.entry_fields\n }\n\n return self.type_cls.from_proxy(se... | [
"0.67095965",
"0.6477196",
"0.6332539",
"0.62504274",
"0.61646706",
"0.61252797",
"0.600303",
"0.59274566",
"0.5883338",
"0.5849355",
"0.58424836",
"0.583158",
"0.5752123",
"0.57427174",
"0.5730141",
"0.5707103",
"0.5706845",
"0.57047164",
"0.56399536",
"0.56265277",
"0.56032... | 0.0 | -1 |
Return the value of the field 'field_name' of this SugarEntry. | def __getitem__(self, field_name):
if field_name in self._module._fields.keys():
try:
return self._fields[field_name]
except KeyError:
if self['id'] == '':
# If this is a new entry, the 'id' field is yet undefined.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_field_value(self, field_name):\n if field_name in self.fields.keys():\n return self.fields[field_name]\n else:\n return \"No such field\"",
"def get_field_value(self, name, raw=False):\n field = self.get_field(name)\n if field is None:\n return... | [
"0.78668076",
"0.75023025",
"0.7114381",
"0.7114381",
"0.7114381",
"0.7114381",
"0.7064504",
"0.7064504",
"0.70414263",
"0.7009208",
"0.69945055",
"0.6993646",
"0.69624376",
"0.6957426",
"0.6872905",
"0.68179625",
"0.6812655",
"0.67997205",
"0.67977375",
"0.67850506",
"0.6739... | 0.7292334 | 2 |
Set the value of a field of this SugarEntry. | def __setitem__(self, field_name, value):
if field_name in self._module._fields.keys():
self._fields[field_name] = value
if field_name not in self._dirty_fields:
self._dirty_fields.append(field_name)
else:
raise AttributeError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_value(self, field, value):\n field = self.find_first(field)\n if field is not None:\n field.value = value",
"def _setValue(self, field, value):\n self._contents[field] = value",
"def setfield(self, field, value):\n self.__setitem__(field, value)",
"def set_entry... | [
"0.80276215",
"0.7663564",
"0.7361043",
"0.698671",
"0.67777884",
"0.6728715",
"0.6728715",
"0.6699535",
"0.6690918",
"0.66474557",
"0.65780324",
"0.65772873",
"0.65541035",
"0.65541035",
"0.65541035",
"0.6483881",
"0.64639485",
"0.64538443",
"0.6433936",
"0.64043486",
"0.637... | 0.5998666 | 55 |
Save this entry in the SugarCRM server. If the 'id' field is blank, it creates a new entry and sets the 'id' value. | def save(self):
# If 'id' wasn't blank, it's added to the list of dirty fields; this
# way the entry will be updated in the SugarCRM connection.
if self['id'] != '':
self._dirty_fields.append('id')
# nvl is the name_value_list, which has the list of attributes.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self):\n if self.id is None:\n self._insert()\n else:\n self._update()",
"def save(self):\n if self.id:\n self.update()\n else:\n self.create()",
"def save(self)->None:\n item = database.cursor.fetchone()\n if item:\... | [
"0.7648956",
"0.7361002",
"0.6938848",
"0.6878406",
"0.66949844",
"0.6614205",
"0.6569775",
"0.6563675",
"0.6438659",
"0.6280113",
"0.62362057",
"0.62102276",
"0.61960924",
"0.6164901",
"0.6155119",
"0.6127607",
"0.61145216",
"0.61145216",
"0.61145216",
"0.61145216",
"0.61145... | 0.7521411 | 1 |
Relate this SugarEntry with the one passed as a parameter. | def relate(self, related):
self._module._connection.relate(self, related) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, entry):\n return self",
"def add_item_entry(self, the_spec):\n debug(\"Adding entry {}\".format(the_spec))\n entry = tk.Entry(self.current_parent)\n self.entries[the_spec.value] = entry\n if not self.parent_is_grid:\n entry.pack()\n return e... | [
"0.5524577",
"0.55080557",
"0.53549623",
"0.53450733",
"0.53450733",
"0.53450733",
"0.53140515",
"0.52883685",
"0.5236298",
"0.5210294",
"0.51796716",
"0.5022049",
"0.4999028",
"0.4980691",
"0.49763468",
"0.49634597",
"0.49548715",
"0.49441412",
"0.49441412",
"0.49118453",
"0... | 0.0 | -1 |
Return the related entries in another module. | def get_related(self, module):
connection = self._module._connection
result = connection.get_relationships(self._module._name, self['id'],
module._name.lower(), '', ['id'])
entries = []
for elem in result['entry_list']:
entry = Su... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relationships(self):",
"def get_related_objects(self):\n result = []\n if self['name'] != None:\n tmp = ObjectDefinition.objects.filter(use__has_field=self['name'], object_type=self['object_type'])\n for i in tmp: result.append(i)\n return result",
"def associated... | [
"0.5929166",
"0.5709051",
"0.54539883",
"0.54411966",
"0.54079044",
"0.54058117",
"0.5341041",
"0.53391445",
"0.5284375",
"0.5259152",
"0.5229081",
"0.52277374",
"0.5226618",
"0.52161896",
"0.5207432",
"0.5207311",
"0.5198739",
"0.5186677",
"0.5138827",
"0.5136619",
"0.512700... | 0.7334194 | 0 |
Wrap for pooling and launching processes Here try to monitor time taken since real tasks may take quite a long time to complete. Then they the longest test should be lauch first so as to avoid having to wait for them to complete a good thing would be to pickle results (in the future) for now i'll juste try to have them... | def do_thing(scr_obj = None):
res = {}
t1 = time()
if not scr_obj:
return "No task provided"
ags = scr_obj.system_instr()
son = subprocess.Popen(ags)
print "spid %r pid %r "%(son.pid,os.getpid())
if os.waitpid(son.pid,0):
res['duration'] = time()-t1
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def measure_mp_speedup():\n modes = [\n # name, function\n ('dSMC', ana.d_smc),\n ('dAMC', ana.d_amc),\n ('EDF-VD', ana.d_edf_vd),\n ('pSMC', ana.p_smc),\n ('pAMC-BB', ana.p_amc_bb),\n ('pAMC-BB+', ft.partial(ana.p_amc_bb, ignore_hi_mode=True))\n ]\n times_... | [
"0.65764606",
"0.6285376",
"0.62616736",
"0.62181664",
"0.61683935",
"0.6149992",
"0.6098208",
"0.60810643",
"0.6076687",
"0.599215",
"0.59797597",
"0.5963703",
"0.59309655",
"0.59253407",
"0.5921455",
"0.59198266",
"0.5880402",
"0.58707196",
"0.58152556",
"0.5761431",
"0.575... | 0.5890367 | 16 |
Make the table 'symmetric'. The lower left part of the matrix is the reverse probability. | def prepare_table(table):
n = len(table)
for i, row in enumerate(table):
assert len(row) == n, f"len(row) = {len(row)} != {n} = n"
for j, _ in enumerate(row):
if i == j:
table[i][i] = 0.0
elif i > j:
table[i][j] = 1 - table[j][i]
return... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def symmetrize(self):\n if self.is_symmetric:\n return self\n else:\n return self.append(self.reverse()).squash().scale(0.5)",
"def make_symmetric(prior):\n print \"making symmetric\"\n\n new_map = {}\n for key1 in prior.keys():\n for key2 in prior[key1].keys()... | [
"0.62731516",
"0.61840785",
"0.6064608",
"0.58849204",
"0.587738",
"0.5790452",
"0.5790171",
"0.5788909",
"0.5750154",
"0.5694349",
"0.56869864",
"0.55907136",
"0.5530144",
"0.5499711",
"0.5498957",
"0.5494343",
"0.5491656",
"0.5470528",
"0.54271704",
"0.54172325",
"0.5415249... | 0.56995 | 9 |
Partition list ``l`` in ``K`` partitions. Examples >>> l = [0, 1, 2] >>> list(clusters(l, K=3)) [[[0], [1], [2]], [[], [0, 1], [2]], [[], [1], [0, 2]], [[0], [], [1, 2]], [[], [0], [1, 2]], [[], [], [0, 1, 2]]] >>> list(clusters(l, K=2)) [[[0, 1], [2]], [[1], [0, 2]], [[0], [1, 2]], [[], [0, 1, 2]]] >>> list(clusters(l... | def clusters(l, K): # noqa
if l:
prev = None
for t in clusters(l[1:], K):
tup = sorted(t)
if tup != prev:
prev = tup
for i in range(K):
yield tup[:i] + [
[l[0]] + tup[i],
] + tup[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_list(l, k):\n\n\tn = len(l)\n\tsublists = []\n\tnsubs = n / k\n\tnrems = n % k\n\n\t# little algo to split lists.\n\n\ti = int(0)\n\twhile i < n:\n\t\tsublists.append(l[i:i+k])\n\t\ti += k\n\n\treturn sublists",
"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial... | [
"0.6442916",
"0.6442183",
"0.6315446",
"0.6304946",
"0.6237085",
"0.617769",
"0.6146027",
"0.6125856",
"0.60932726",
"0.60206467",
"0.5957113",
"0.5909527",
"0.59080315",
"0.585992",
"0.58364034",
"0.58048147",
"0.58022964",
"0.57939726",
"0.5760786",
"0.5759672",
"0.57513547... | 0.7760409 | 0 |
Partition list ``l`` in ``K`` partitions, without empty parts. >>> l = [0, 1, 2] >>> list(neclusters(l, 2)) [[[0, 1], [2]], [[1], [0, 2]], [[0], [1, 2]]] >>> list(neclusters(l, 1)) [[[0, 1, 2]]] | def neclusters(l, K): # noqa
for c in clusters(l, K):
if all(x for x in c):
yield c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clusters(l, K): # noqa\n if l:\n prev = None\n for t in clusters(l[1:], K):\n tup = sorted(t)\n if tup != prev:\n prev = tup\n for i in range(K):\n yield tup[:i] + [\n [l[0]] + tup[i],\n ... | [
"0.7217303",
"0.63322186",
"0.625333",
"0.6235396",
"0.6019988",
"0.5918844",
"0.5856138",
"0.57952917",
"0.57450014",
"0.5674573",
"0.5655689",
"0.5525202",
"0.5506933",
"0.5506646",
"0.5503834",
"0.5496627",
"0.5489272",
"0.5465552",
"0.5463998",
"0.54601",
"0.54010504",
... | 0.74512917 | 0 |
Get all segmentations of a list ``l``. | def all_segmentations(l):
for K in range(1, len(l) + 1):
gen = neclusters(l, K)
yield from gen | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getIntersectorList(self, l):\n return [self.getIntersector(v) for v in l]",
"def getSegments(self):\n l = len(self.points)\n return [Segment(self.points[i % l], self.points[(i + 1) % l], \\\n color=self.side_color, width=self.side_width) for i in range(l)]",
"def... | [
"0.7343008",
"0.5786379",
"0.5737136",
"0.57333577",
"0.56923693",
"0.56832623",
"0.5526333",
"0.55071455",
"0.54750925",
"0.54672647",
"0.5410251",
"0.53292185",
"0.5260688",
"0.52098393",
"0.5078696",
"0.5060627",
"0.50543034",
"0.50465745",
"0.50461197",
"0.50444895",
"0.5... | 0.7035634 | 1 |
>>> find_index([[0, 1, 2], [3, 4], [5, 6, 7]], 0) 0 >>> find_index([[0, 1, 2], [3, 4], [5, 6, 7]], 1) 0 >>> find_index([[0, 1, 2], [3, 4], [5, 6, 7]], 5) 2 >>> find_index([[0, 1, 2], [3, 4], [5, 6, 7]], 6) 2 | def find_index(segmentation, stroke_id):
for i, symbol in enumerate(segmentation):
for sid in symbol:
if sid == stroke_id:
return i
return -1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def my_index(list_, element):\n pos = []\n for i in range(len(list_)):\n if list_[i] == element:\n pos.append(i)\n return pos",
"def find_index(row):\n value = row[index]\n if value in seen:\n return seen[value]\n for row_ in merged.iter_... | [
"0.67435414",
"0.6689435",
"0.667055",
"0.6616099",
"0.65715",
"0.65432054",
"0.6515102",
"0.65023714",
"0.6496401",
"0.6446747",
"0.64422274",
"0.6422349",
"0.6420835",
"0.64158803",
"0.6405739",
"0.6361784",
"0.6354577",
"0.6326094",
"0.6324002",
"0.63065636",
"0.62885135",... | 0.0 | -1 |
Test if ``s1`` and ``s2`` are in the same symbol, given the ``segmentation``. | def q(segmentation, s1, s2):
index1 = find_index(segmentation, s1)
index2 = find_index(segmentation, s2)
return index1 == index2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other: Segment) -> bool:\n return any(\n (\n self.start == other.start and self.end == other.end,\n self.start == other.end and self.end == other.start,\n )\n )",
"def segment_segment(s1, s2):\n l1=s1.line()\n l2=s2.line()\n... | [
"0.641324",
"0.6303756",
"0.62990654",
"0.6223713",
"0.60034645",
"0.59813756",
"0.59780806",
"0.5975479",
"0.58711016",
"0.5836675",
"0.5813403",
"0.5789767",
"0.5778101",
"0.57675564",
"0.5753647",
"0.5730708",
"0.56924576",
"0.5673696",
"0.5646707",
"0.5588982",
"0.5555126... | 0.7217469 | 0 |
Push an ``element`` into the datastrucutre together with its value and only save it if it currently is one of the top n elements. Drop elements if necessary. | def push(self, element, value):
insert_pos = 0
for index, el in enumerate(self.tops):
if not self.find_min and el[1] >= value:
insert_pos = index + 1
elif self.find_min and el[1] <= value:
insert_pos = index + 1
self.tops.insert(insert_pos,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push(self, element):\n self._data.append(element)",
"def push(self, element):\n self._data.append(element)",
"def push(self,element):\n self.stack.append(element)\n \n if self.maxx == []:\n self.maxx.append(element)\n else:\n #LessThan or equa... | [
"0.6947502",
"0.6947502",
"0.68805766",
"0.6826163",
"0.66402876",
"0.65689075",
"0.6567906",
"0.65321624",
"0.64744484",
"0.6363533",
"0.6332254",
"0.62661207",
"0.6240742",
"0.6183616",
"0.61692774",
"0.6107169",
"0.6103542",
"0.6082257",
"0.6069212",
"0.60639167",
"0.60554... | 0.6930433 | 2 |
Get the score of a segmentation. | def score_segmentation(segmentation, table):
stroke_nr = sum(1 for symbol in segmentation for stroke in symbol)
score = 1
for i in range(stroke_nr):
for j in range(i + 1, stroke_nr):
qval = q(segmentation, i, j)
if qval:
score *= table[i][j]
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self, segmentation, resolution):\n raise NotImplementedError",
"def get_score(self):\n return self.score",
"def get_score(self):\n return self.score",
"def get_score(self):\n return self.score",
"def score(self):\n return self.client.call('GET', self.name + 'sco... | [
"0.7821457",
"0.68884724",
"0.68884724",
"0.68884724",
"0.6864855",
"0.68069875",
"0.68069875",
"0.68069875",
"0.67806643",
"0.67513376",
"0.6750792",
"0.6743802",
"0.6731569",
"0.67256904",
"0.67151165",
"0.6540891",
"0.65062493",
"0.6485259",
"0.6454835",
"0.64071995",
"0.6... | 0.6577604 | 15 |
This builds your guide. Use Keyword to update any options at build time. | def build_guide(self, **kwargs):
# This builds your guide master and updates your options
self.create_guide_master(**kwargs)
prefix = self.prefix # Naming prefix. Use this for every new node you create and there should be no name clashes.
options = self.options ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_guide(self, **kwargs):\n\n # This builds your guide master and updates your options\n self.create_guide_master(**kwargs)\n\n prefix = self.prefix\n options = self.options\n mirror_value = self.mirror_value\n\n num_joints = options.get('numberJoints')\n... | [
"0.6530746",
"0.6263703",
"0.61089903",
"0.60497785",
"0.5882108",
"0.5788378",
"0.5788378",
"0.5754908",
"0.56987226",
"0.56863075",
"0.56494266",
"0.5625547",
"0.561691",
"0.5596764",
"0.5596764",
"0.55608445",
"0.5489056",
"0.5478003",
"0.5478003",
"0.5478003",
"0.546438",... | 0.63234144 | 1 |
This builds your anim rig. | def build_rig(self):
# create rig part top nodes
self.create_part_master()
prefix = self.prefix # Naming prefix. Use this for every new node you create and there should be no name clashes.
options = self.options # Build options
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_anim(self):\n pass",
"def build_rig(self):\n\n # create rig part top nodes\n self.create_part_master()\n\n # Get all the relevant part info\n prefix = self.prefix\n options = self.options\n anim_ctrls = self.anim_ctrls\n ... | [
"0.68172234",
"0.6249442",
"0.6228986",
"0.6166067",
"0.6068071",
"0.6007271",
"0.59737676",
"0.5947862",
"0.5921581",
"0.59017247",
"0.5882105",
"0.5882105",
"0.5882105",
"0.5882105",
"0.5882105",
"0.5882105",
"0.5882105",
"0.5882105",
"0.5882105",
"0.5882105",
"0.5882105",
... | 0.5954252 | 7 |
For use with midrotation treatments (affects product attribute generation) | def set_future(self, future):
self._future = future | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def product(self):\n return None",
"def product(self):\n return None",
"def product(self):\n raise NotImplementedError",
"def arm(self):\n pass",
"def metallicity(method, emsystem):\n if method == 'PG16':\n # Requires Hbeta, [OII], [OIII], [NII], [SII]\n R2 = (e... | [
"0.5675478",
"0.5675478",
"0.55882686",
"0.50788105",
"0.50288135",
"0.49819022",
"0.49562803",
"0.49551016",
"0.49269596",
"0.49080822",
"0.49069706",
"0.48976865",
"0.4886793",
"0.48700985",
"0.4859686",
"0.48417854",
"0.48343614",
"0.48108852",
"0.47970998",
"0.47970998",
... | 0.0 | -1 |
Add fu code to list. | def add_fu(self, state):
self._fu_set.add(state) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_code(self, code):\n self.code += code",
"def add_code(self, id, code):\n self.codes[id] = code",
"def set_function_list(self, L):\n\t\tself.function_list = L",
"def add_hook(f, h):\n if f in hooks:\n hooks[f] += [h]\n else:\n hooks[f] = [h]",
"def add_code(self, co... | [
"0.63861465",
"0.5658855",
"0.56266004",
"0.55539155",
"0.5490869",
"0.5488156",
"0.5473881",
"0.54088527",
"0.53393835",
"0.5329551",
"0.5329551",
"0.53095835",
"0.52636266",
"0.5237091",
"0.5221719",
"0.5194192",
"0.51796734",
"0.5135299",
"0.5118256",
"0.5104795",
"0.50775... | 0.5944328 | 1 |
Asks user to specify a city, month, and day to analyze. | def get_filters():
print('Welcome! Let\'s explore some US bikeshare data!')
# TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs
while True:
try:
city = input("Enter the name of the city you want to explore the data of (c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Raw_Data(city,month,day):\n print(\"The city you have entered is: \",city)\n print(\"The month you have entered is: \",month)\n print(\"The day you have entered is: \",day)",
"def get_filters():\n city = None\n month = None\n day = None\n while day == None:\n # TO DO: get user input f... | [
"0.66714007",
"0.65354675",
"0.64593667",
"0.6374057",
"0.6348314",
"0.63097656",
"0.62868035",
"0.6259136",
"0.62316",
"0.62130964",
"0.62050414",
"0.6181105",
"0.6171822",
"0.61686903",
"0.6158568",
"0.61582303",
"0.61532456",
"0.61444426",
"0.6131269",
"0.610484",
"0.61025... | 0.58922184 | 44 |
Loads data for the specified city and filters by month and day if applicable. | def load_data(city, month, day):
df = pd.read_csv(CITY_DATA[city])
df['Start Time'] = pd.to_datetime(df['Start Time'])
df['hour'] = df['Start Time'].dt.hour
df['month'] = df['Start Time'].dt.month
df['day_of_week'] = df['Start Time'].dt.weekday_name
#filter by month if needed and create a new fr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(city, month, day):\n df = pd.read_csv(CITY_DATA [city])\n \n # convert the Start Time column to datetime\n df['Start Time'] = pd.to_datetime(df['Start Time'])\n \n # extract month and day of week from Start Time to create new columns\n df['month'] = df['Start Time'].dt.month\n ... | [
"0.81320685",
"0.8108889",
"0.8045821",
"0.8042514",
"0.80090284",
"0.80071104",
"0.79991937",
"0.7998333",
"0.7988789",
"0.797905",
"0.79737365",
"0.79610896",
"0.7956163",
"0.7947432",
"0.79463065",
"0.7908287",
"0.7908229",
"0.7904569",
"0.7900715",
"0.78930074",
"0.788921... | 0.7787979 | 37 |
Displays statistics on the most frequent times of travel. | def time_stats(df, month, day):
print('\nCalculating The Most Frequent Times of Travel...\n')
start_time = time.time()
# TO DO: display the most common month
if month == 'all':
most_common_month = df['month'].mode()[0]
print ("The most frequent month of travel is: ", calendar.month_nam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time_stats(df):\n\n print('\\nDisplaying the statistics on the most frequent times of '\n 'travel...\\n')\n start_time = time.time()\n\n # display the most common month\n most_common_month = df['Month'].mode()[0]\n print('For the selected filter, the month with the most travels is: ' +\... | [
"0.80247396",
"0.80233026",
"0.7915788",
"0.78266186",
"0.7822246",
"0.78143597",
"0.77659196",
"0.7740343",
"0.773628",
"0.77344066",
"0.76867086",
"0.7668633",
"0.7651731",
"0.7644636",
"0.76399267",
"0.76367253",
"0.7625196",
"0.7623158",
"0.7612803",
"0.76002145",
"0.7583... | 0.74564284 | 39 |
Displays statistics on the most popular stations and trip. | def station_stats(df):
print('\nCalculating The Most Popular Stations and Trip...\n')
start_time = time.time()
# TO DO: display most commonly used start station
most_common_start_station = df['Start Station'].mode()[0]
print ("The most frequent start station is:\n ->", most_common_start_station)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def station_stats(df):\n\n print('\\nCalculating The Most Popular Stations and Trip...\\n')\n start_time = time.time()\n\n # display most commonly used start station\n print(popular_start_station(df))\n\n # display most commonly used end station\n print(popular_end_station(df))\n\n # display m... | [
"0.7815675",
"0.7662213",
"0.7553417",
"0.74914914",
"0.74748665",
"0.7446617",
"0.7428588",
"0.74237514",
"0.74177027",
"0.7400495",
"0.7387161",
"0.7385634",
"0.73647535",
"0.735934",
"0.73566747",
"0.73548365",
"0.7351854",
"0.7351274",
"0.735057",
"0.73421645",
"0.7340198... | 0.7134921 | 58 |
Displays statistics on the total and average trip duration. | def trip_duration_stats(df):
print('\nCalculating Trip Duration...\n')
start_time = time.time()
# TO DO: display total travel time
total_travel_time = round(np.sum(df['Trip Duration'])/60/60,2)
print ('Total travel time over the selected period (in hours) is: ', total_travel_time)
# TO DO: di... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trip_duration_stats(data):\n print('\\nCalculating Trip Duration...\\n')\n start_time = time.time()\n # display total travel time\n total_trip_time= data['Trip Duration'].sum()\n print('The Total Travel Time is {} Hours'. format(total_trip_time/3600))\n # display mean travel time\n avg_tri... | [
"0.814274",
"0.8025143",
"0.80041367",
"0.79496753",
"0.7937415",
"0.79312176",
"0.7926815",
"0.7915187",
"0.79142886",
"0.7908032",
"0.79055744",
"0.7900715",
"0.7891682",
"0.78894734",
"0.7886722",
"0.78851086",
"0.7884266",
"0.7882474",
"0.78738385",
"0.78686154",
"0.78664... | 0.784452 | 32 |
Displays statistics on bikeshare users. | def user_stats(df, city):
print('\nCalculating User Stats...\n')
start_time = time.time()
# TO DO: Display counts of user types
df['User Type'] = df['User Type'].fillna('Type Unknown')
user_types = df['User Type'].unique()
for user_type in user_types:
count_user_type = (df['User Type']... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_stats(request):\r\n user_count = UserMgr.count()\r\n pending_activations = ActivationMgr.count()\r\n users_with_bookmarks = BmarkMgr.count(distinct_users=True)\r\n return _api_response(request, {\r\n 'count': user_count,\r\n 'activations': pending_activations,\r\n 'with_bo... | [
"0.73559105",
"0.73306274",
"0.7287611",
"0.72494894",
"0.72382116",
"0.71733415",
"0.7168679",
"0.7129041",
"0.7076894",
"0.7071431",
"0.70602304",
"0.7056935",
"0.70490867",
"0.7045232",
"0.703642",
"0.70238316",
"0.7022488",
"0.7022265",
"0.7012312",
"0.70086145",
"0.69945... | 0.0 | -1 |
Allow to scroll through the raw data of the csv file selected | def see_raw_data(city):
while True:
try:
see_raw_data_input = input('\nIn addition of the stats above, would you like to scroll through the raw data? (y/n)\n')
if see_raw_data_input not in ('y', 'n'):
raise Exception ('Invalid answer')
if see_raw_data_inp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_loading_file(self):\n column_headers = []\n column_headers_all = []\n\n # Open the file once to get idea of the total rowcount to display progress\n with open(self.csv_file_path[0], newline='') as csv_file:\n self.progress_max.emit(len(csv_file.readlines()) - 2)\n... | [
"0.6083973",
"0.6001787",
"0.59245104",
"0.58940566",
"0.5861581",
"0.581427",
"0.5679473",
"0.56790644",
"0.5672839",
"0.565956",
"0.5653351",
"0.5615062",
"0.560097",
"0.5599851",
"0.5589927",
"0.55863386",
"0.5574873",
"0.5549084",
"0.55258",
"0.55049545",
"0.54869586",
... | 0.62122077 | 0 |
Initialization function. Sets the model name and function, path to input data, and the output filename. | def __init__(self, sfs, model, popnames, output):
self.sfs = self.load_sfs(sfs)
self.modelname = model
# Make an extrapolating version of the function
self.modelfunc = dadi.Numerics.make_extrap_log_func(
self.set_model_func(model))
self.params = self.set_parameters()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self,\n model_fn=cake_fn,\n model_dir: Optional[str] = \"model\",\n saved_path : Optional[str] = None,\n ):\n self.model_fn = model_fn \n self.model_dir = model_dir\n if saved_path == None:\n self.update_p... | [
"0.71706414",
"0.69452214",
"0.6822937",
"0.66740066",
"0.6421178",
"0.63648045",
"0.6306152",
"0.62590146",
"0.6255789",
"0.62344706",
"0.62207854",
"0.62166464",
"0.6183033",
"0.61792994",
"0.61410034",
"0.61369526",
"0.61364913",
"0.61285555",
"0.61272836",
"0.6064312",
"0... | 0.69727397 | 1 |
Parse the dadi SFS file and return it as a Spectrum object. Dadi will do basic checking of the spectrum, but we will be more thorough. | def load_sfs(self, sfs):
try:
fs = dadi.Spectrum.from_file(sfs)
except:
print 'The spectrum file you provided is not valid!'
exit(1)
return fs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_file(self):\n file_time = ''\n num_dir = 0\n num_freq = 0\n freq_w_band = 0.0\n freq_0 = 0.0\n start_dir = 0.0\n\n dspec_matrix = []\n\n # Extract the file time from the file name\n input_file_name = self._stream_handle.name\n\n match ... | [
"0.69581074",
"0.647524",
"0.63855165",
"0.63855165",
"0.6374014",
"0.63154924",
"0.6295988",
"0.61925375",
"0.6125525",
"0.6066723",
"0.60588676",
"0.6026092",
"0.5996392",
"0.5974746",
"0.5853758",
"0.5807754",
"0.5777854",
"0.57754326",
"0.5728101",
"0.57191104",
"0.571364... | 0.7699114 | 0 |
Given a model name, set the function that has to be called to run that model. This should be safe because we restrict the user input for the models at the argument parsing stage. | def set_model_func(self, model):
if model == 'SI':
import cavefish_dadi.Models.si
return cavefish_dadi.Models.si.si
elif model == 'SC':
import cavefish_dadi.Models.sc
return cavefish_dadi.Models.sc.sc
elif model == 'IM':
import cavefish... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_model(model: str) -> Any:\n try:\n model_function = eval(model)\n except (NameError, AttributeError) as err:\n sys.exit(f'{err}. Accepted models from {tf}, {sm}, {tfa}, {tfc}')\n return model_function",
"def get_function(model_or_function, preprocess_function=None):\n from diann... | [
"0.6543695",
"0.6317053",
"0.6138432",
"0.6007846",
"0.5799357",
"0.5794181",
"0.57566136",
"0.56700885",
"0.55889934",
"0.5577638",
"0.5568402",
"0.5544729",
"0.55088854",
"0.55060846",
"0.5459015",
"0.5454922",
"0.54414725",
"0.53864926",
"0.5364902",
"0.5340603",
"0.533630... | 0.6588683 | 0 |
Set the parameters for the function, depending on the model being run. Also set the bounds for the optimization. | def set_parameters(self):
params = {}
if self.modelname == 'SI':
# N1: Pop 1 size after split
# N2: Pop 2 size after splot
# Ts: Time from split to present, in 2*Na generation units
names = ['N1', 'N2', 'Ts']
values = [1, 1, 1]
uppe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_bounds(self, **kwargs):\n for name, bounds in kwargs.items():\n if name not in self._parameters:\n raise AttributeError('Unknown parameter %s for %s' % (name, self.__class__.__name__))\n param = self._parameters[name]\n # Set bounds\n lower_... | [
"0.6652114",
"0.64041644",
"0.6387559",
"0.63850904",
"0.6212778",
"0.61772054",
"0.6171171",
"0.6166634",
"0.6135607",
"0.6128549",
"0.6125473",
"0.6125473",
"0.6125473",
"0.61149114",
"0.60589886",
"0.6044676",
"0.604221",
"0.6038992",
"0.60294724",
"0.60294724",
"0.6024169... | 0.6072073 | 14 |
Inference function. This borrows heavily from the callmodel() function in 'script_inference_anneal2_newton.py' from SEA lab. | def infer(self, niter, reps):
# Start containers to hold the optimized parameters
self.p_init = []
self.hot_params = []
self.cold_params = []
self.opt_params = []
self.theta = []
self.mod_like = []
self.opt_like = []
self.aic = []
# Get the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inference(model, data, diagnostics, seed, extra_fitting_args):\n pass",
"def inference(self):\n raise NotImplementedError",
"def infer(self, example, model):\n asp_input = model + '\\n\\n' + example + '\\n\\n' + inference_program_ec\n ctl = clingo.Control()\n ctl.add(\"base\"... | [
"0.7005118",
"0.68879014",
"0.6468674",
"0.63714975",
"0.63685554",
"0.63409275",
"0.62861687",
"0.62818676",
"0.6193505",
"0.61855865",
"0.6120753",
"0.6109425",
"0.6101459",
"0.60623956",
"0.6023192",
"0.6022813",
"0.6013857",
"0.60059744",
"0.59605026",
"0.5955767",
"0.595... | 0.5622197 | 47 |
Summarize the replicate runs and convert the parameters estimates into meaningful numbers. | def summarize(self, locuslen):
# First, calculate the mean of the parameter estimates from each
# of the replicates
hot_means = []
for r_t in zip(*self.hot_params):
v = [x for x in r_t if not math.isnan(x)]
hot_means.append(sum(v)/len(v))
cold_means = []
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_mcts(self, runs_per_round):\n for i in range(runs_per_round):\n self.select(self.env, 'r')\n self.env_reset()\n counts = [self.Nsa[('r', a)] for a in range(self.actions)]\n # print(\"counts \", counts)\n # print(\"Q-values\", [self.Qsa[('r', a)] for a in ra... | [
"0.596659",
"0.5817768",
"0.57848805",
"0.5778032",
"0.5736855",
"0.5722777",
"0.5721804",
"0.56309265",
"0.5599941",
"0.5561327",
"0.5554734",
"0.5542044",
"0.55361605",
"0.55108637",
"0.5486883",
"0.5457525",
"0.544647",
"0.542683",
"0.5396689",
"0.53914917",
"0.5365846",
... | 0.58705 | 1 |
Write some output summaries for the dadi runs. | def write_out(self, niter, locuslen):
try:
handle = open(self.output, 'w')
except OSError:
print 'Error, you do not have permission to write files here.'
extit(1)
# First, write the pop names
handle.write('#Pop 1: ' + self.popnames[0] + '\n')
h... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _output_summary(self, run_id):\n time = self._summary.get_time_taken()\n time_delta = None\n num_tests_run_delta = None\n num_failures_delta = None\n values = [(\"id\", run_id, None)]\n failures = self._summary.get_num_failures()\n previous_summary = self._get_p... | [
"0.706741",
"0.6504042",
"0.64469904",
"0.6359",
"0.6317233",
"0.62217075",
"0.62181455",
"0.62145364",
"0.6196254",
"0.61518073",
"0.61190933",
"0.61190766",
"0.61024827",
"0.60801",
"0.6074785",
"0.6020409",
"0.6015638",
"0.6012356",
"0.59702814",
"0.59702814",
"0.5955046",... | 0.0 | -1 |
Plot the comparison between the data and the chosen model. This is a copypaste with some modification from the dadi.Plotting.plot_2d_comp_Poisson function. | def plot(self, vmin, vmax, resid_range=None,
pop_ids=None, residual='Anscombe'):
# Scale the model SFS to the data SFS
sc_mod = dadi.Inference.optimally_scaled_sfs(self.model_sfs, self.sfs)
# Start a new figure, and clear it
f = pylab.gcf()
pylab.clf()
ax = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_comparison(self, X_val, y_val):\n import matplotlib.pyplot as plt\n x = []\n y = []\n for model_tuple in self.model_list:\n x.append(model_tuple[1])\n y.append(model_tuple[0].score(X_val, y_val))\n plt.scatter(x, y)\n plt.show()",
"def p... | [
"0.6889876",
"0.6815983",
"0.6491328",
"0.6326441",
"0.630209",
"0.6259812",
"0.62159556",
"0.6189489",
"0.60769445",
"0.60425025",
"0.6001705",
"0.59992814",
"0.59848875",
"0.5948288",
"0.592511",
"0.589603",
"0.5892012",
"0.5887439",
"0.58789676",
"0.5858394",
"0.5851891",
... | 0.0 | -1 |
Drive the combination process. This entails generating code for use in the casa interpreter and then running it. If the 'generate' commandline option is invoked, the code will be printed to a file instead of run in the interpreter. | def drive(param_dict, clargs):
output_basename = _gen_basename(param_dict, clargs)
if not clargs.overwrite:
i = 1
while glob.glob('*{}*'.format(output_basename)):
output_basename = '{}.{}'.format(
_gen_basename(param_dict, clargs), i)
i += 1
casa_ins... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\n BASIC.run(PROGRAM)",
"def generate(options):\n interactive = options['i']\n if interactive:\n generate_interactive(options)\n else:\n generate_rcfile(vars(options['c']), options['rcfile'])",
"def run():\n names=[i.__name__ for i in modList]\n res,action=kcs_ui.st... | [
"0.6534681",
"0.6394365",
"0.6163484",
"0.61047703",
"0.60676014",
"0.60312563",
"0.60181093",
"0.5815423",
"0.57839054",
"0.57279795",
"0.57003903",
"0.5678264",
"0.5646332",
"0.5634394",
"0.56316435",
"0.562979",
"0.5626772",
"0.5618201",
"0.5612563",
"0.5597489",
"0.558429... | 0.0 | -1 |
Drive the UV plane combination. Functionally, this means Performing concatenation Cleaning the concatenated MS in the UV plane Imaging the concatenated MS | def _drive_uv(param_dict, clargs, output_basename, casa_instance):
script = []
if glob.glob('{}.concat.ms'.format(output_basename)) and clargs.overwrite:
os.system('rm -rf {}.concat.ms'.format(output_basename))
# casa_instance.run_script(script)
# todo
# write an extension of the drivecas... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_uvs(mesh, bsp_verts):\n\n mesh.uv_textures.new(\"UVs\")\n bm = bmesh.new()\n bm.from_mesh(mesh)\n\n if hasattr(bm.faces, \"ensure_lookup_table\"): \n bm.faces.ensure_lookup_table()\n\n uv_layer = bm.loops.layers.uv[0]\n\n for face_idx, current_face in enumerate(bm.faces):\n ... | [
"0.5860706",
"0.5756254",
"0.558495",
"0.55116755",
"0.5500914",
"0.54856575",
"0.5411383",
"0.53948486",
"0.53849983",
"0.5343461",
"0.5337835",
"0.5308709",
"0.53073806",
"0.53056586",
"0.5296829",
"0.5273831",
"0.52715695",
"0.5257271",
"0.52373564",
"0.5233863",
"0.522525... | 0.61613876 | 0 |
Drive the feather combination. Functionally, this means Cleaning the individual ms separately. Imaging the individual ms. Feathering the two together. | def _drive_feather(param_dict, clargs, output_basename, casa_instance):
# todo later -> the imstat stuff
script = []
thresh, seven_meter_clean_args = utils.param_dict_to_clean_input(
param_dict, seven_meter=True)
_, twelve_meter_clean_args = utils.param_dict_to_clean_input(
param_dic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _removeFX(self):\r\n\t\tnodesToClean = [CONST.FOAM_FLUID_SHAPENODE, CONST.WAKE_FLUID_SHAPENODE, 'fluids_hrc']\r\n\t\tfor eachNode in nodesToClean:\r\n\t\t\ttry:\r\n\t\t\t\tcmds.delete(each)\r\n\t\t\texcept:\r\n\t\t\t\tpass\r\n\r\n\t\tfor eachCache in cmds.ls(type = 'cacheFile'):\r\n\t\t\tcmds.delete(eachCache)... | [
"0.53458524",
"0.5341943",
"0.5341767",
"0.51823235",
"0.51823235",
"0.51713705",
"0.51584935",
"0.50687635",
"0.50499785",
"0.5038589",
"0.50249314",
"0.5024092",
"0.5023892",
"0.50143516",
"0.49986392",
"0.49689344",
"0.49604985",
"0.49398032",
"0.49370384",
"0.49188516",
"... | 0.72748023 | 0 |
Calculate weightings to use for the feather task | def _calc_feather_weighting(param_dict):
weightings = param_dict['weightings']
if not isinstance(weightings, (list, tuple)):
return 1.0
return float(weightings[1]) / float(weightings[0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_weighted_results():\n pass",
"def weight(self):",
"def getWeight(self) -> float:\n ...",
"def calculateWeights(self):\n return self.distances #En lo que encontramos una funcion que represente",
"def get_weights(self):",
"def calculate_weights():\n weights = {}\n... | [
"0.7639016",
"0.75578135",
"0.7499282",
"0.73658234",
"0.72466195",
"0.7217344",
"0.7214428",
"0.7214428",
"0.7117307",
"0.7097232",
"0.70433426",
"0.6888601",
"0.6846439",
"0.68106675",
"0.6809401",
"0.6799938",
"0.67643374",
"0.6751411",
"0.6691422",
"0.6686457",
"0.6686457... | 0.7724041 | 0 |
Automatically generate a basename or else use the one provided. | def _gen_basename(param_dict, clargs):
if param_dict['output_basename'] in ['', 'auto']:
return clargs.input_fname.lower().split('.json')[0]
else:
return param_dict['output_basename'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_fullname(basename, _type=None):\n return '{}.{}'.format(basename, extensions.get(_type, None))",
"def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True, ext=None):\n if not basename:\n msg = \"Unable to generate filename for command %s. \" % self.cmd\n msg... | [
"0.7162985",
"0.71130204",
"0.71064943",
"0.70725805",
"0.70725805",
"0.6988176",
"0.6869497",
"0.6849551",
"0.672568",
"0.6704061",
"0.66934615",
"0.65571934",
"0.6534404",
"0.64742374",
"0.6473847",
"0.646789",
"0.6352444",
"0.6296653",
"0.6274127",
"0.62643063",
"0.6244662... | 0.77820414 | 0 |
fit gaussian to line | def womgau(hop):
import numpy as np
import logging
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
from tmath.wombat.womwaverange import womwaverange
from tmath.wombat.womget_element import womget_element
from tmath.wombat.inputter import inputter
from tmath.wombat.i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def line_fit(x,y):\n\t# clean\n\tx = np.squeeze(x)\n\ty = np.squeeze(y)\n\t# concatenate\n\txy = np.concatenate((x[:,np.newaxis],y[:,np.newaxis]),1)\n\t# sort by x values\n\txy = xy[xy[:,0].argsort()]\n\t#print(xy)\n\tf = lambda x,m,b : m*x+b\n\tpars,_ = opt.curve_fit(f,xy[:,0],xy[:,1])\n\tm = pars[0]\n\tb = pars[... | [
"0.7053034",
"0.6899664",
"0.66803604",
"0.6613913",
"0.66093487",
"0.655105",
"0.655105",
"0.6387049",
"0.63094246",
"0.62380975",
"0.622621",
"0.62161845",
"0.6191844",
"0.61702806",
"0.6145452",
"0.61285686",
"0.61094004",
"0.61094004",
"0.6043475",
"0.6034672",
"0.6022126... | 0.0 | -1 |
! Create ssh client. Create ssh client to run commands in host machine from inside container. | def create_client():
hostname = "localhost"
username = "she393"
password = os.getenv("PASSWORD")
client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(hostname=hostname, username=username, password=password)
return client | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_sshclient(host, user, port, secret):\n ssh_client = paramiko.SSHClient()\n ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n ssh_client.load_system_host_keys()\n if secret and port:\n ssh_client.connect(hostname=host, username=user, password=secret, port=port)\n elif... | [
"0.69851446",
"0.6791386",
"0.6668736",
"0.6655599",
"0.6630987",
"0.65980434",
"0.6580812",
"0.65597147",
"0.655599",
"0.6490338",
"0.641064",
"0.6405131",
"0.6365197",
"0.63595355",
"0.6352704",
"0.6299737",
"0.62719107",
"0.62428546",
"0.6240554",
"0.6232706",
"0.6225897",... | 0.7121306 | 0 |
! Wrapper for HTTP responses. message The content of the successful (200) HTTP response. Flask HTTP response object with content of message from the argument and status code 200. | def response(message):
res = Response(json.dumps(message))
res.status_code = 200
res.content_type = "application/json"
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def response(status, message, code):\n return make_response(jsonify({\n 'status': status,\n 'message': message\n })), code",
"def HandleResponse(data,message,success = True,err = 'no err',resp_status = status.HTTP_200_OK):\n return Response({\n 'success':success,\n \"error\":... | [
"0.8077968",
"0.7261069",
"0.7197937",
"0.71356225",
"0.7122571",
"0.7062746",
"0.70605296",
"0.70228976",
"0.7000634",
"0.69415414",
"0.6871562",
"0.67692024",
"0.6674502",
"0.6664123",
"0.65871406",
"0.65599144",
"0.6558028",
"0.65498847",
"0.6513427",
"0.6454303",
"0.64455... | 0.7737896 | 1 |
! HTTP route '/' Returns 'OK' successful response to the user. | def home():
return response("OK") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def root():\n return Response(\"It's alive!\", status=200)",
"def root():\n if request.headers['Accept'] == 'application/json':\n return \"Welcome\\n\\n\", 200\n else:\n return redirect(url_for('index'))",
"def index():\n return Response(\n \"Welcome to basic-http-server, you're ready to a... | [
"0.8000715",
"0.76302844",
"0.7217383",
"0.7034739",
"0.6969286",
"0.69551736",
"0.6937947",
"0.69072324",
"0.684836",
"0.6830389",
"0.68042636",
"0.67833495",
"0.6741848",
"0.6703643",
"0.66771775",
"0.6644887",
"0.6582273",
"0.6569342",
"0.65503997",
"0.6548875",
"0.6541204... | 0.7412834 | 2 |
! HTTP route '/api/tasks/' API endpoint for manipulating tasks. Allows GET, POST and DELETE requests. | def kamel_get():
client = create_client()
task_name = request.args.get('name')
if request.method == "GET":
if task_name is not None:
# describe behavior
stdin, stdout, stderr = client.exec_command(f"/usr/local/bin/kamel describe integration {task_name}") # noqa
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_tasks(self, request):\n \"\"\"\n @api {get} /tasks List tasks\n @apiName GetTasks\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiDescription Return a list of all configured tasks, along with their configuration.\n\n @apiSuccessExample {json} Example respon... | [
"0.7414974",
"0.73624206",
"0.72924006",
"0.7080843",
"0.6978864",
"0.68153924",
"0.67486525",
"0.667285",
"0.65907764",
"0.64850056",
"0.645972",
"0.6416525",
"0.6354801",
"0.6345557",
"0.62794614",
"0.6248126",
"0.62155837",
"0.61991686",
"0.61804813",
"0.61286545",
"0.6125... | 0.0 | -1 |
! HTTP route '/api/logs/tasks/' API endpoint for manipulating logs. Allows only GET requests. | def kamel_logs():
task_name = request.args.get('name')
if task_name is None:
return response("Need to specify task name!")
client = create_client()
stdin, stdout, stderr = client.exec_command(f"/usr/local/bin/kamel logs {task_name}") # noqa
time.sleep(1)
stdout.channel.close()
body ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_get(self, req, resp):\n try:\n task_model_list = self.state_manager.get_tasks()\n task_list = [x.to_dict() for x in task_model_list]\n resp.text = json.dumps(task_list)\n resp.status = falcon.HTTP_200\n except Exception as ex:\n self.error... | [
"0.6197851",
"0.607282",
"0.5970462",
"0.59704053",
"0.5964452",
"0.59584445",
"0.58986974",
"0.581812",
"0.5806979",
"0.57502735",
"0.5739828",
"0.5729748",
"0.56855357",
"0.5676162",
"0.56016225",
"0.5558941",
"0.55346864",
"0.5530376",
"0.5528069",
"0.5521597",
"0.55141115... | 0.60648406 | 2 |
Access token auth logic. | def authenticate(self, request=None, **kwargs):
if request is None:
return None
access_token = jwt_utils.get_access_token_by_request(request)
if access_token is None:
return None
try:
payload = jwt_utils.jwt_decode(access_token)
except Deco... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def auth_token(self):",
"def do_auth(self, access_token, *args, **kwargs):\n data = self.user_data(access_token)\n data['access_token'] = access_token\n kwargs.update(data)\n kwargs.update({'response': data, 'backend': self})\n return self.strategy.authenticate(*args, **kwargs)... | [
"0.7375866",
"0.7111791",
"0.7054406",
"0.70490533",
"0.70432705",
"0.7001905",
"0.6994722",
"0.6989808",
"0.6969049",
"0.6969049",
"0.69665104",
"0.69614655",
"0.6938845",
"0.68905526",
"0.6871101",
"0.67952436",
"0.6786014",
"0.6768033",
"0.6756323",
"0.67161775",
"0.671617... | 0.0 | -1 |
Used by django auth system. We don`t need this method implementation. | def get_user(self, user_id):
return None # noqa: WPS324 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authentication_hook(self):\n pass",
"def auth(self, user):",
"def _get_auth_string(self):",
"def authenticate_user(self):\n raise NotImplementedError(\n \"\"\"\n authenticate_user must be implemented by a child class\n \"\"\"\n )",
"def auth():\... | [
"0.7454468",
"0.7185157",
"0.7009156",
"0.688985",
"0.6836429",
"0.6836429",
"0.6824741",
"0.68042165",
"0.66339934",
"0.66053426",
"0.65637714",
"0.6532335",
"0.64916205",
"0.643852",
"0.63844854",
"0.6349493",
"0.6346315",
"0.6337269",
"0.6337102",
"0.63232756",
"0.63232756... | 0.0 | -1 |
Wraps the function, so that the id's it gets will always be strings | def string_ids(f):
@functools.wraps(f)
def wrapper(self, *args):
return f(self, *[str(arg) for arg in args])
return wrapper | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def getId(*args):",
"def id_(x: Any) -> Any:\n return x",... | [
"0.72658205",
"0.72658205",
"0.72658205",
"0.72658205",
"0.72658205",
"0.72658205",
"0.72658205",
"0.72658205",
"0.72658205",
"0.72658205",
"0.72658205",
"0.72658205",
"0.7023903",
"0.6685517",
"0.6608628",
"0.6440895",
"0.64001304",
"0.63244265",
"0.6252984",
"0.6210254",
"0... | 0.66786057 | 14 |
Saves user to database | def save_user(self, user: dict):
logger.debug('Inserting new user....')
users = self.db.users
users.update(self.user_identification(user), user, upsert=True)
logger.debug('New user inserted') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_user(user):\n User.save_user(user)",
"def save_users(user):\n user.save_user()",
"def save_user(self):\n db.session.add(self)\n db.session.commit()",
"def save(self, context=None):\n updates = self.obj_get_changes()\n self.dbapi.update_user(context, self.id, updates... | [
"0.8537059",
"0.8319131",
"0.8278781",
"0.7453417",
"0.73806924",
"0.7328633",
"0.7308185",
"0.72789395",
"0.7239284",
"0.723523",
"0.7180633",
"0.71803653",
"0.7159296",
"0.71304476",
"0.71304476",
"0.7122661",
"0.711703",
"0.71088237",
"0.71088237",
"0.7087179",
"0.7080573"... | 0.7518099 | 3 |
One to one identification of the snapshots. | def snapshot_identification(snapshot):
return {
'user_id': snapshot['user_id'],
'timestamp': snapshot['timestamp'],
'snapshot_id': snapshot['snapshot_id']} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unique_id(self):\n return f\"{DOMAIN}_{self._cam_name}_{self._obj_name}_snapshot\"",
"def snapshot_id(self) -> Optional[str]:\n return pulumi.get(self, \"snapshot_id\")",
"def snapshot_id(self) -> Optional[str]:\n return pulumi.get(self, \"snapshot_id\")",
"def snapshot_id(self) -> O... | [
"0.6157024",
"0.6145881",
"0.6145881",
"0.58339775",
"0.58339775",
"0.58339775",
"0.5751372",
"0.5697604",
"0.5678704",
"0.55947214",
"0.5580041",
"0.5498619",
"0.5444909",
"0.54207444",
"0.53875417",
"0.5353588",
"0.5305235",
"0.52906895",
"0.5282701",
"0.5255412",
"0.525408... | 0.6568016 | 0 |
The AccountBroker initialze() function before we added the policy stat table. Used by test_policy_table_creation() to make sure that the AccountBroker will correctly add the table for cases where the DB existed before the policy support was added. | def prespi_AccountBroker_initialize(self, conn, put_timestamp, **kwargs):
if not self.account:
raise ValueError(
'Attempting to create a new database with no account set')
self.create_container_table(conn)
self.create_account_stat_table(conn, put_timestamp) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_init(self) -> None:\n self._check_and_set_network()\n self._check_and_apply_migrations()",
"def initialize():\n DATABASE.connect()\n DATABASE.create_tables([User, Entry], safe=True)\n DATABASE.close()",
"def init():\n database.create_tables([Tracker])\n database.com... | [
"0.66067785",
"0.6455682",
"0.6373156",
"0.63563114",
"0.63563114",
"0.62698793",
"0.6163393",
"0.6154188",
"0.60957396",
"0.60849506",
"0.60809666",
"0.5964424",
"0.5955808",
"0.5944223",
"0.5935643",
"0.5916183",
"0.591556",
"0.5893408",
"0.58916914",
"0.5885537",
"0.587170... | 0.73197085 | 0 |
Copied from AccountBroker before the metadata column was added; used for testing with TestAccountBrokerBeforeMetadata. Create account_stat table which is specific to the account DB. | def premetadata_create_account_stat_table(self, conn, put_timestamp):
conn.executescript('''
CREATE TABLE account_stat (
account TEXT,
created_at TEXT,
put_timestamp TEXT DEFAULT '0',
delete_timestamp TEXT DEFAULT '0',
container_count INTEGER,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_track_containers_create_policy_stat(self, conn):\n conn.executescript(\"\"\"\n CREATE TABLE policy_stat (\n storage_policy_index INTEGER PRIMARY KEY,\n object_count INTEGER DEFAULT 0,\n bytes_used INTEGER DEFAULT 0\n );\n INSERT OR IGNORE INTO policy... | [
"0.6411355",
"0.5693446",
"0.5648235",
"0.5506348",
"0.5451028",
"0.53575075",
"0.53320557",
"0.52726936",
"0.5267531",
"0.5266184",
"0.5225775",
"0.5171474",
"0.5141938",
"0.51097775",
"0.5103295",
"0.5092772",
"0.50799894",
"0.5075006",
"0.5058689",
"0.5051445",
"0.5033744"... | 0.76754844 | 0 |
Copied from AccountBroker before the sstoage_policy_index column was added; used for testing with TestAccountBrokerBeforeSPI. Create container table which is specific to the account DB. | def prespi_create_container_table(self, conn):
conn.executescript("""
CREATE TABLE container (
ROWID INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT,
put_timestamp TEXT,
delete_timestamp TEXT,
object_count INTEGER,
bytes_used INTEGER,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_track_containers_create_container_table(self, conn):\n # revert to old trigger script to support one of the tests\n OLD_POLICY_STAT_TRIGGER_SCRIPT = \"\"\"\n CREATE TRIGGER container_insert_ps AFTER INSERT ON container\n BEGIN\n INSERT OR IGNORE INTO policy_stat\n ... | [
"0.7222646",
"0.66707873",
"0.5947068",
"0.5887795",
"0.58477587",
"0.5694725",
"0.56702393",
"0.56475055",
"0.56451815",
"0.56367904",
"0.5633519",
"0.55940306",
"0.55933654",
"0.55901736",
"0.5587355",
"0.55573237",
"0.555128",
"0.5534241",
"0.55316937",
"0.55145425",
"0.55... | 0.6937344 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.